FastOpenGlDisplayer/src/Geometry.cpp

// Geometry.cpp: implementation of the Geometry class.
//
//////////////////////////////////////////////////////////////////////

#include "../interface/Geometry.h"

Geometry::Geometry(void)
{
}

Geometry::~Geometry(void)
{
}

void Geometry::Load (char* path)
{
        FILE* pFile = fopen(path,"rb" );

        stChunk* PrimaryChunk = new stChunk;

        PrimaryChunk->read  =fread(&PrimaryChunk->type,1,2,pFile);
        PrimaryChunk->read +=fread(&PrimaryChunk->size,1,4,pFile);

        if(PrimaryChunk->type!=C_PRIMARY){
                printf("PrimaryChunk has not a good Id (%i!=%i)\n",PrimaryChunk->type,C_PRIMARY);
                printf("Exiting...\n");
                exit(0);
        }

        Read(pFile,PrimaryChunk);

        fclose(pFile);
}

void Geometry::Read (FILE* pFile, stChunk* ParentChunk)
{
//      unsigned short temp;
//      fread(&temp,1,2,pFile);
//      fseek(pFile,-2,SEEK_CUR);
//      printf("Parent = %i --> Current ChunkId = %i to read = %i\n",ParentChunk->type,temp,0);

        stChunk* CurrentChunk  = new stChunk;
        ReadChunk(pFile, CurrentChunk);

        switch(CurrentChunk->type)
        {
                case C_GEOMETRY:                // Geometry                     
                        while(CurrentChunk->read<CurrentChunk->size){
                                Read(pFile,CurrentChunk);
                        }
                        break;


        ////////////////////////TRACKER DATA//////////////////////////
                case C_TRACKER:                 // TRACKER
                        while(CurrentChunk->read<CurrentChunk->size){
                                Read(pFile,CurrentChunk);
                        }
                        break;

                case C_TRACKER_PIB:{    // PIB                  
                        TrackerDet* Temp = new TrackerDet;
                        CurrentChunk->read += fread(Temp,sizeof(TrackerDet),1,pFile) * sizeof(TrackerDet);
                        Det_Tracker_PIB.push_back(Temp);
                        Det_Tracker_ALL.push_back(Temp);                        
                        }break;
                case C_TRACKER_PIE:{    // PIE                  
                        TrackerDet* Temp = new TrackerDet;
                        CurrentChunk->read += fread(Temp,sizeof(TrackerDet),1,pFile) * sizeof(TrackerDet);
                        Det_Tracker_PIE.push_back(Temp);
                        Det_Tracker_ALL.push_back(Temp);                        
                        }break;
                case C_TRACKER_TIB:{    // TIB                  
                        TrackerDet* Temp = new TrackerDet;
                        CurrentChunk->read += fread(Temp,sizeof(TrackerDet),1,pFile) * sizeof(TrackerDet);
                        Det_Tracker_TIB.push_back(Temp);
                        Det_Tracker_ALL.push_back(Temp);                        
                        }break;
                case C_TRACKER_TID:{    // TID                  
                        TrackerDet* Temp = new TrackerDet;
                        CurrentChunk->read += fread(Temp,sizeof(TrackerDet),1,pFile) * sizeof(TrackerDet);
                        Det_Tracker_TID.push_back(Temp);
                        Det_Tracker_ALL.push_back(Temp);                        
                        }break;
                case C_TRACKER_TOB:{    // TOB                  
                        TrackerDet* Temp = new TrackerDet;
                        CurrentChunk->read += fread(Temp,sizeof(TrackerDet),1,pFile) * sizeof(TrackerDet);
                        Det_Tracker_TOB.push_back(Temp);
                        Det_Tracker_ALL.push_back(Temp);                        
                        }break;
                case C_TRACKER_TEC:{    // TEC                  
                        TrackerDet* Temp = new TrackerDet;
                        CurrentChunk->read += fread(Temp,sizeof(TrackerDet),1,pFile) * sizeof(TrackerDet);
                        Det_Tracker_TEC.push_back(Temp);
                        Det_Tracker_ALL.push_back(Temp);                        
                        }break;

        ////////////////////////ECAL DATA//////////////////////////
                case C_ECAL:                    // ECAL
                        while(CurrentChunk->read<CurrentChunk->size){
                                Read(pFile,CurrentChunk);
                        }
                        break;

                case C_ECAL_EB:{                // EB                   
                        CaloDet* Temp = new CaloDet;
                        CurrentChunk->read += fread(Temp,sizeof(CaloDet),1,pFile) * sizeof(CaloDet);
                        Det_ECAL_EB.push_back(Temp);
                        Det_ECAL_ALL.push_back(Temp);                   
                        }break;
                case C_ECAL_EE:{                // PIE                  
                        CaloDet* Temp = new CaloDet;
                        CurrentChunk->read += fread(Temp,sizeof(CaloDet),1,pFile) * sizeof(CaloDet);
                        Det_ECAL_EE.push_back(Temp);
                        Det_ECAL_ALL.push_back(Temp);                   
                        }break;


                ////////////////////////UNKOWN CHUNK ////////////////////////
                default:
                        printf("Unknown ChunkID (%i)\n",CurrentChunk->type);
                        printf("Chunk will be skipped\n");
                        printf("The program can not run properly\n");
                        fseek (pFile,CurrentChunk->size-CurrentChunk->read,SEEK_CUR);
                        CurrentChunk->read += CurrentChunk->size-CurrentChunk->read;
                        break;
        }               

        ParentChunk->read += CurrentChunk->read;

}
 
void Geometry::Save (char* path)
{
        stChunkToSave* Primary_chunk = new stChunkToSave;
        
        Primary_chunk->type  = C_PRIMARY;       
        Primary_chunk->size =  6;

        Write(Primary_chunk);
/*
        printf("%i (%i)\n",Primary_chunk->type,Primary_chunk->size);
        for(unsigned int i=0;i<Primary_chunk->daughters.size();i++){
                stChunkToSave* tmp = Primary_chunk->daughters[i];
                printf("    %i (%i)\n",tmp->type,tmp->size);
                for(unsigned int j=0;j<tmp->daughters.size();j++){
                        stChunkToSave* Tmp = tmp->daughters[j];
                        printf("        %i (%i)\n",Tmp->type,Tmp->size);
                        for(unsigned int k=0;k<Tmp->daughters.size();k++){
                                stChunkToSave* TMp = Tmp->daughters[k];
                                printf("            %i (%i)\n",TMp->type,TMp->size);
                                for(unsigned int l=0;l<TMp->daughters.size();l++){
                                        stChunkToSave* TMP = TMp->daughters[l];
                                        printf("                %i (%i)\n",TMP->type,TMP->size);
                                }                               
                        }                       
                }               
        }
*/

        FILE* pFile = fopen(path,"wb" );
                WriteChunk(pFile, Primary_chunk);
        fclose(pFile);
}

void Geometry::Write(stChunkToSave* ParentChunk)
{
        unsigned int i;
        stChunkToSave* CurrentChunk;
        
        switch(ParentChunk->type)
        {
                case C_PRIMARY:                 // PrimaryChunk         
                        CurrentChunk = new stChunkToSave;
                        CurrentChunk->type = C_GEOMETRY;
                        CurrentChunk->size = 6;
                        ParentChunk->daughters.push_back(CurrentChunk);
                        break;

                case C_GEOMETRY:                // Geometry
                        CurrentChunk = new stChunkToSave;
                        CurrentChunk->type = C_TRACKER;                                 
                        CurrentChunk->size = 6;
                        ParentChunk->daughters.push_back(CurrentChunk);

                        CurrentChunk = new stChunkToSave;
                        CurrentChunk->type = C_ECAL;                                    
                        CurrentChunk->size = 6;
                        ParentChunk->daughters.push_back(CurrentChunk);
                        break;

                case C_TRACKER:                 // Tracker
                        for(i=0;i<Det_Tracker_PIB.size();i++){
                                CurrentChunk = new stChunkToSave;
                                CurrentChunk->type = C_TRACKER_PIB;
                                CurrentChunk->size = 6 + sizeof(TrackerDet);
                                CurrentChunk->data = Det_Tracker_PIB[i];
                                ParentChunk->daughters.push_back(CurrentChunk);
                        }
                        for(i=0;i<Det_Tracker_PIE.size();i++){
                                CurrentChunk = new stChunkToSave;
                                CurrentChunk->type = C_TRACKER_PIE;
                                CurrentChunk->size = 6 + sizeof(TrackerDet);
                                CurrentChunk->data = Det_Tracker_PIE[i];
                                ParentChunk->daughters.push_back(CurrentChunk);
                        }
                        for(i=0;i<Det_Tracker_TIB.size();i++){
                                CurrentChunk = new stChunkToSave;
                                CurrentChunk->type = C_TRACKER_TIB;
                                CurrentChunk->size = 6 + sizeof(TrackerDet);
                                CurrentChunk->data = Det_Tracker_TIB[i];
                                ParentChunk->daughters.push_back(CurrentChunk);                         
                        }
                        for(i=0;i<Det_Tracker_TID.size();i++){
                                CurrentChunk = new stChunkToSave;
                                CurrentChunk->type = C_TRACKER_TID;
                                CurrentChunk->size = 6 + sizeof(TrackerDet);
                                CurrentChunk->data = Det_Tracker_TID[i];
                                ParentChunk->daughters.push_back(CurrentChunk);
                        }
                        for(i=0;i<Det_Tracker_TOB.size();i++){
                                CurrentChunk = new stChunkToSave;
                                CurrentChunk->type = C_TRACKER_TOB;
                                CurrentChunk->size = 6 + sizeof(TrackerDet);
                                CurrentChunk->data = Det_Tracker_TOB[i];
                                ParentChunk->daughters.push_back(CurrentChunk);
                        }
                        for(i=0;i<Det_Tracker_TEC.size();i++){
                                CurrentChunk = new stChunkToSave;
                                CurrentChunk->type = C_TRACKER_TEC;
                                CurrentChunk->size = 6 + sizeof(TrackerDet);
                                CurrentChunk->data = Det_Tracker_TEC[i];
                                ParentChunk->daughters.push_back(CurrentChunk);
                        }
                        break;

                case C_ECAL:                    // ECAL
                        for(i=0;i<Det_ECAL_EB.size();i++){
                                CurrentChunk = new stChunkToSave;
                                CurrentChunk->type = C_ECAL_EB;
                                CurrentChunk->size = 6 + sizeof(CaloDet);
                                CurrentChunk->data = Det_ECAL_EB[i];
                                ParentChunk->daughters.push_back(CurrentChunk);
                        }
                        break;

        
                default:
                        break;
        }       


        for(i=0; i<ParentChunk->daughters.size();i++)
        {
//              if( !(ParentChunk->type == C_PRIMARY && i!=ParentChunk->daughters.size()-1))
                        Write(ParentChunk->daughters[i]);                                               
                ParentChunk->size += ParentChunk->daughters[i]->size;           
        }
}


void Geometry::Add_TrackerDet(unsigned int DetId, float TrapezoidalParam,
                                                          float PosX,    float PosY,    float PosZ,
                                                          float WidthX,  float WidthY,  float WidthZ,
                                                          float LengthX, float LengthY, float LengthZ,
                                                          float ThickX,  float ThickY,  float ThickZ){

        int SubDet = (DetId>>25)&0x7;

        if(SubDet<0 || SubDet>6)
        {
                printf("Unknown Subdet %i\n",SubDet);
                return;
        }

        TrackerDet* temp = new TrackerDet();
        temp->DetId = DetId;
        temp->PosX    = PosX;
        temp->PosY    = PosY;
        temp->PosZ    = PosZ;
        temp->WidthX  = WidthX;
        temp->WidthY  = WidthY;
        temp->WidthZ  = WidthZ;
        temp->LengthX = LengthX;
        temp->LengthY = LengthY;
        temp->LengthZ = LengthZ;
        temp->ThickX  = ThickX;
        temp->ThickY  = ThickY;
        temp->ThickZ  = ThickZ;
        temp->TrapezoidalParam = TrapezoidalParam;
        
        Det_Tracker_ALL.push_back(temp);
        switch(SubDet)
        {
                case 1 : Det_Tracker_PIB.push_back(temp); break;
                case 2 : Det_Tracker_PIE.push_back(temp); break;
                case 3 : Det_Tracker_TIB.push_back(temp); break;
                case 4 : Det_Tracker_TID.push_back(temp); break;
                case 5 : Det_Tracker_TOB.push_back(temp); break;
                case 6 : Det_Tracker_TEC.push_back(temp); break;
        }
}

void Geometry::Add_CaloDet(unsigned int DetId,
                                                        float PosX,    float PosY,    float PosZ,
                                                        float C1X,         float C1Y,     float C1Z,
                                                        float C2X,         float C2Y,     float C2Z,
                                                        float C3X,         float C3Y,     float C3Z,
                                                        float C4X,         float C4Y,     float C4Z,
                                                        float C5X,         float C5Y,     float C5Z,
                                                        float C6X,         float C6Y,     float C6Z,
                                                        float C7X,         float C7Y,     float C7Z,
                                                        float C8X,         float C8Y,     float C8Z){
/*
        int SubDet = (DetId>>25)&0x7;

        if(SubDet<0 || SubDet>6)
        {
                printf("Unknown Subdet %i\n",SubDet);
                return;
        }
*/

        CaloDet* temp = new CaloDet();
        temp->DetId = DetId;
        temp->PosX    = PosX;
        temp->PosY    = PosY;
        temp->PosZ    = PosZ;
        temp->C1X = C1X; temp->C1Y = C1Y; temp->C1Z = C1Z;
        temp->C2X = C2X; temp->C2Y = C2Y; temp->C2Z = C2Z;
        temp->C3X = C3X; temp->C3Y = C3Y; temp->C3Z = C3Z;
        temp->C4X = C4X; temp->C4Y = C4Y; temp->C4Z = C4Z;
        temp->C5X = C5X; temp->C5Y = C5Y; temp->C5Z = C5Z;
        temp->C6X = C6X; temp->C6Y = C6Y; temp->C6Z = C6Z;
        temp->C7X = C7X; temp->C7Y = C7Y; temp->C7Z = C7Z;
        temp->C8X = C8X; temp->C8Y = C8Y; temp->C8Z = C8Z;
        
                
        Det_ECAL_ALL.push_back(temp);
        Det_ECAL_EB.push_back(temp);

//      switch(SubDet)
//      {
//              case 1 : Det_Tracker_PIB.push_back(temp); break;
//              case 2 : Det_Tracker_PIE.push_back(temp); break;
//      }
}

TrackerDet* Geometry::Find_TrackerDet (unsigned int DetId){
        int SubDet = (DetId>>25)&0x7;

        if(SubDet<0 || SubDet>6){
                printf("Unknown Subdet %i\n",SubDet);
                return NULL;
        }

        std::vector<TrackerDet*>* DetColl = NULL;

        switch(SubDet){
                case 1 : DetColl = &Det_Tracker_PIB; break;
                case 2 : DetColl = &Det_Tracker_PIE; break;
                case 3 : DetColl = &Det_Tracker_TIB; break;
                case 4 : DetColl = &Det_Tracker_TID; break;
                case 5 : DetColl = &Det_Tracker_TOB; break;
                case 6 : DetColl = &Det_Tracker_TEC; break;
        }

        if(DetColl==NULL){
                printf("No COllection has been found\n");
                return NULL;
        }

        for(std::vector<TrackerDet*>::iterator it = DetColl->begin();it!=DetColl->end();it++){
                TrackerDet* Det = *it;
                if(Det->DetId == DetId)return Det;
        }
        return NULL;
}


Revision:	1.5
Committed:	Fri Mar 21 19:40:46 2008 UTC (17 years, 1 month ago) by querten
Branch:	MAIN
Changes since 1.4:	+84 -1 lines
Log Message:	Include Geometry of Calorimter
#	User	Rev	Content
1	querten	1.1	// Geometry.cpp: implementation of the Geometry class.
2			//
3			//////////////////////////////////////////////////////////////////////
4
5			#include "../interface/Geometry.h"
6
7			Geometry::Geometry(void)
8			{
9			}
10
11			Geometry::~Geometry(void)
12			{
13			}
14
15			void Geometry::Load (char* path)
16			{
17			FILE* pFile = fopen(path,"rb" );
18
19			stChunk* PrimaryChunk = new stChunk;
20
21			PrimaryChunk->read =fread(&PrimaryChunk->type,1,2,pFile);
22			PrimaryChunk->read +=fread(&PrimaryChunk->size,1,4,pFile);
23
24			if(PrimaryChunk->type!=C_PRIMARY){
25			printf("PrimaryChunk has not a good Id (%i!=%i)\n",PrimaryChunk->type,C_PRIMARY);
26			printf("Exiting...\n");
27			exit(0);
28			}
29
30			Read(pFile,PrimaryChunk);
31
32			fclose(pFile);
33			}
34
35			void Geometry::Read (FILE* pFile, stChunk* ParentChunk)
36			{
37	querten	1.3	// unsigned short temp;
38			// fread(&temp,1,2,pFile);
39			// fseek(pFile,-2,SEEK_CUR);
40			// printf("Parent = %i --> Current ChunkId = %i to read = %i\n",ParentChunk->type,temp,0);
41	querten	1.1
42			stChunk* CurrentChunk = new stChunk;
43			ReadChunk(pFile, CurrentChunk);
44
45			switch(CurrentChunk->type)
46			{
47			case C_GEOMETRY: // Geometry
48			while(CurrentChunk->read<CurrentChunk->size){
49			Read(pFile,CurrentChunk);
50			}
51			break;
52
53
54			////////////////////////TRACKER DATA//////////////////////////
55			case C_TRACKER: // TRACKER
56			while(CurrentChunk->read<CurrentChunk->size){
57			Read(pFile,CurrentChunk);
58			}
59			break;
60
61			case C_TRACKER_PIB:{ // PIB
62			TrackerDet* Temp = new TrackerDet;
63			CurrentChunk->read += fread(Temp,sizeof(TrackerDet),1,pFile) * sizeof(TrackerDet);
64			Det_Tracker_PIB.push_back(Temp);
65			Det_Tracker_ALL.push_back(Temp);
66			}break;
67			case C_TRACKER_PIE:{ // PIE
68			TrackerDet* Temp = new TrackerDet;
69			CurrentChunk->read += fread(Temp,sizeof(TrackerDet),1,pFile) * sizeof(TrackerDet);
70			Det_Tracker_PIE.push_back(Temp);
71			Det_Tracker_ALL.push_back(Temp);
72			}break;
73			case C_TRACKER_TIB:{ // TIB
74			TrackerDet* Temp = new TrackerDet;
75			CurrentChunk->read += fread(Temp,sizeof(TrackerDet),1,pFile) * sizeof(TrackerDet);
76			Det_Tracker_TIB.push_back(Temp);
77			Det_Tracker_ALL.push_back(Temp);
78			}break;
79			case C_TRACKER_TID:{ // TID
80			TrackerDet* Temp = new TrackerDet;
81			CurrentChunk->read += fread(Temp,sizeof(TrackerDet),1,pFile) * sizeof(TrackerDet);
82			Det_Tracker_TID.push_back(Temp);
83			Det_Tracker_ALL.push_back(Temp);
84			}break;
85			case C_TRACKER_TOB:{ // TOB
86			TrackerDet* Temp = new TrackerDet;
87			CurrentChunk->read += fread(Temp,sizeof(TrackerDet),1,pFile) * sizeof(TrackerDet);
88			Det_Tracker_TOB.push_back(Temp);
89			Det_Tracker_ALL.push_back(Temp);
90			}break;
91			case C_TRACKER_TEC:{ // TEC
92			TrackerDet* Temp = new TrackerDet;
93			CurrentChunk->read += fread(Temp,sizeof(TrackerDet),1,pFile) * sizeof(TrackerDet);
94			Det_Tracker_TEC.push_back(Temp);
95			Det_Tracker_ALL.push_back(Temp);
96			}break;
97
98	querten	1.5	////////////////////////ECAL DATA//////////////////////////
99			case C_ECAL: // ECAL
100			while(CurrentChunk->read<CurrentChunk->size){
101			Read(pFile,CurrentChunk);
102			}
103			break;
104
105			case C_ECAL_EB:{ // EB
106			CaloDet* Temp = new CaloDet;
107			CurrentChunk->read += fread(Temp,sizeof(CaloDet),1,pFile) * sizeof(CaloDet);
108			Det_ECAL_EB.push_back(Temp);
109			Det_ECAL_ALL.push_back(Temp);
110			}break;
111			case C_ECAL_EE:{ // PIE
112			CaloDet* Temp = new CaloDet;
113			CurrentChunk->read += fread(Temp,sizeof(CaloDet),1,pFile) * sizeof(CaloDet);
114			Det_ECAL_EE.push_back(Temp);
115			Det_ECAL_ALL.push_back(Temp);
116			}break;
117
118
119	querten	1.1	////////////////////////UNKOWN CHUNK ////////////////////////
120			default:
121			printf("Unknown ChunkID (%i)\n",CurrentChunk->type);
122			printf("Chunk will be skipped\n");
123			printf("The program can not run properly\n");
124			fseek (pFile,CurrentChunk->size-CurrentChunk->read,SEEK_CUR);
125			CurrentChunk->read += CurrentChunk->size-CurrentChunk->read;
126			break;
127			}
128
129			ParentChunk->read += CurrentChunk->read;
130
131			}
132
133			void Geometry::Save (char* path)
134			{
135			stChunkToSave* Primary_chunk = new stChunkToSave;
136
137			Primary_chunk->type = C_PRIMARY;
138			Primary_chunk->size = 6;
139
140			Write(Primary_chunk);
141	querten	1.5	/*
142	querten	1.1	printf("%i (%i)\n",Primary_chunk->type,Primary_chunk->size);
143			for(unsigned int i=0;i<Primary_chunk->daughters.size();i++){
144			stChunkToSave* tmp = Primary_chunk->daughters[i];
145			printf(" %i (%i)\n",tmp->type,tmp->size);
146			for(unsigned int j=0;j<tmp->daughters.size();j++){
147			stChunkToSave* Tmp = tmp->daughters[j];
148			printf(" %i (%i)\n",Tmp->type,Tmp->size);
149			for(unsigned int k=0;k<Tmp->daughters.size();k++){
150			stChunkToSave* TMp = Tmp->daughters[k];
151			printf(" %i (%i)\n",TMp->type,TMp->size);
152			for(unsigned int l=0;l<TMp->daughters.size();l++){
153			stChunkToSave* TMP = TMp->daughters[l];
154			printf(" %i (%i)\n",TMP->type,TMP->size);
155			}
156			}
157			}
158			}
159	querten	1.5	*/
160	querten	1.1
161			FILE* pFile = fopen(path,"wb" );
162			WriteChunk(pFile, Primary_chunk);
163			fclose(pFile);
164			}
165
166			void Geometry::Write(stChunkToSave* ParentChunk)
167			{
168			unsigned int i;
169			stChunkToSave* CurrentChunk;
170
171			switch(ParentChunk->type)
172			{
173			case C_PRIMARY: // PrimaryChunk
174			CurrentChunk = new stChunkToSave;
175			CurrentChunk->type = C_GEOMETRY;
176			CurrentChunk->size = 6;
177			ParentChunk->daughters.push_back(CurrentChunk);
178			break;
179
180			case C_GEOMETRY: // Geometry
181			CurrentChunk = new stChunkToSave;
182			CurrentChunk->type = C_TRACKER;
183			CurrentChunk->size = 6;
184			ParentChunk->daughters.push_back(CurrentChunk);
185	querten	1.5
186			CurrentChunk = new stChunkToSave;
187			CurrentChunk->type = C_ECAL;
188			CurrentChunk->size = 6;
189			ParentChunk->daughters.push_back(CurrentChunk);
190	querten	1.1	break;
191
192			case C_TRACKER: // Tracker
193			for(i=0;i<Det_Tracker_PIB.size();i++){
194			CurrentChunk = new stChunkToSave;
195			CurrentChunk->type = C_TRACKER_PIB;
196			CurrentChunk->size = 6 + sizeof(TrackerDet);
197			CurrentChunk->data = Det_Tracker_PIB[i];
198			ParentChunk->daughters.push_back(CurrentChunk);
199			}
200			for(i=0;i<Det_Tracker_PIE.size();i++){
201			CurrentChunk = new stChunkToSave;
202			CurrentChunk->type = C_TRACKER_PIE;
203			CurrentChunk->size = 6 + sizeof(TrackerDet);
204			CurrentChunk->data = Det_Tracker_PIE[i];
205			ParentChunk->daughters.push_back(CurrentChunk);
206			}
207			for(i=0;i<Det_Tracker_TIB.size();i++){
208			CurrentChunk = new stChunkToSave;
209			CurrentChunk->type = C_TRACKER_TIB;
210			CurrentChunk->size = 6 + sizeof(TrackerDet);
211			CurrentChunk->data = Det_Tracker_TIB[i];
212			ParentChunk->daughters.push_back(CurrentChunk);
213			}
214			for(i=0;i<Det_Tracker_TID.size();i++){
215			CurrentChunk = new stChunkToSave;
216			CurrentChunk->type = C_TRACKER_TID;
217			CurrentChunk->size = 6 + sizeof(TrackerDet);
218			CurrentChunk->data = Det_Tracker_TID[i];
219			ParentChunk->daughters.push_back(CurrentChunk);
220			}
221			for(i=0;i<Det_Tracker_TOB.size();i++){
222			CurrentChunk = new stChunkToSave;
223			CurrentChunk->type = C_TRACKER_TOB;
224			CurrentChunk->size = 6 + sizeof(TrackerDet);
225			CurrentChunk->data = Det_Tracker_TOB[i];
226			ParentChunk->daughters.push_back(CurrentChunk);
227			}
228			for(i=0;i<Det_Tracker_TEC.size();i++){
229			CurrentChunk = new stChunkToSave;
230			CurrentChunk->type = C_TRACKER_TEC;
231			CurrentChunk->size = 6 + sizeof(TrackerDet);
232			CurrentChunk->data = Det_Tracker_TEC[i];
233			ParentChunk->daughters.push_back(CurrentChunk);
234			}
235			break;
236
237	querten	1.5	case C_ECAL: // ECAL
238			for(i=0;i<Det_ECAL_EB.size();i++){
239			CurrentChunk = new stChunkToSave;
240			CurrentChunk->type = C_ECAL_EB;
241			CurrentChunk->size = 6 + sizeof(CaloDet);
242			CurrentChunk->data = Det_ECAL_EB[i];
243			ParentChunk->daughters.push_back(CurrentChunk);
244			}
245			break;
246
247	querten	1.1
248			default:
249			break;
250			}
251
252
253			for(i=0; i<ParentChunk->daughters.size();i++)
254			{
255			// if( !(ParentChunk->type == C_PRIMARY && i!=ParentChunk->daughters.size()-1))
256			Write(ParentChunk->daughters[i]);
257			ParentChunk->size += ParentChunk->daughters[i]->size;
258			}
259			}
260
261
262
263	querten	1.4	void Geometry::Add_TrackerDet(unsigned int DetId, float TrapezoidalParam,
264	querten	1.2	float PosX, float PosY, float PosZ,
265			float WidthX, float WidthY, float WidthZ,
266			float LengthX, float LengthY, float LengthZ,
267			float ThickX, float ThickY, float ThickZ){
268
269			int SubDet = (DetId>>25)&0x7;
270
271	querten	1.1	if(SubDet<0 \|\| SubDet>6)
272			{
273			printf("Unknown Subdet %i\n",SubDet);
274			return;
275			}
276
277			TrackerDet* temp = new TrackerDet();
278			temp->DetId = DetId;
279	querten	1.2	temp->PosX = PosX;
280			temp->PosY = PosY;
281			temp->PosZ = PosZ;
282			temp->WidthX = WidthX;
283			temp->WidthY = WidthY;
284			temp->WidthZ = WidthZ;
285			temp->LengthX = LengthX;
286			temp->LengthY = LengthY;
287			temp->LengthZ = LengthZ;
288			temp->ThickX = ThickX;
289			temp->ThickY = ThickY;
290			temp->ThickZ = ThickZ;
291	querten	1.4	temp->TrapezoidalParam = TrapezoidalParam;
292	querten	1.2
293	querten	1.1	Det_Tracker_ALL.push_back(temp);
294			switch(SubDet)
295			{
296			case 1 : Det_Tracker_PIB.push_back(temp); break;
297			case 2 : Det_Tracker_PIE.push_back(temp); break;
298			case 3 : Det_Tracker_TIB.push_back(temp); break;
299			case 4 : Det_Tracker_TID.push_back(temp); break;
300			case 5 : Det_Tracker_TOB.push_back(temp); break;
301			case 6 : Det_Tracker_TEC.push_back(temp); break;
302			}
303			}
304
305	querten	1.5	void Geometry::Add_CaloDet(unsigned int DetId,
306			float PosX, float PosY, float PosZ,
307			float C1X, float C1Y, float C1Z,
308			float C2X, float C2Y, float C2Z,
309			float C3X, float C3Y, float C3Z,
310			float C4X, float C4Y, float C4Z,
311			float C5X, float C5Y, float C5Z,
312			float C6X, float C6Y, float C6Z,
313			float C7X, float C7Y, float C7Z,
314			float C8X, float C8Y, float C8Z){
315			/*
316			int SubDet = (DetId>>25)&0x7;
317
318			if(SubDet<0 \|\| SubDet>6)
319			{
320			printf("Unknown Subdet %i\n",SubDet);
321			return;
322			}
323			*/
324
325			CaloDet* temp = new CaloDet();
326			temp->DetId = DetId;
327			temp->PosX = PosX;
328			temp->PosY = PosY;
329			temp->PosZ = PosZ;
330			temp->C1X = C1X; temp->C1Y = C1Y; temp->C1Z = C1Z;
331			temp->C2X = C2X; temp->C2Y = C2Y; temp->C2Z = C2Z;
332			temp->C3X = C3X; temp->C3Y = C3Y; temp->C3Z = C3Z;
333			temp->C4X = C4X; temp->C4Y = C4Y; temp->C4Z = C4Z;
334			temp->C5X = C5X; temp->C5Y = C5Y; temp->C5Z = C5Z;
335			temp->C6X = C6X; temp->C6Y = C6Y; temp->C6Z = C6Z;
336			temp->C7X = C7X; temp->C7Y = C7Y; temp->C7Z = C7Z;
337			temp->C8X = C8X; temp->C8Y = C8Y; temp->C8Z = C8Z;
338
339
340
341			Det_ECAL_ALL.push_back(temp);
342			Det_ECAL_EB.push_back(temp);
343
344			// switch(SubDet)
345			// {
346			// case 1 : Det_Tracker_PIB.push_back(temp); break;
347			// case 2 : Det_Tracker_PIE.push_back(temp); break;
348			// }
349			}
350
351	querten	1.1	TrackerDet* Geometry::Find_TrackerDet (unsigned int DetId){
352			int SubDet = (DetId>>25)&0x7;
353
354			if(SubDet<0 \|\| SubDet>6){
355			printf("Unknown Subdet %i\n",SubDet);
356			return NULL;
357			}
358
359			std::vector<TrackerDet> DetColl = NULL;
360
361			switch(SubDet){
362			case 1 : DetColl = &Det_Tracker_PIB; break;
363			case 2 : DetColl = &Det_Tracker_PIE; break;
364			case 3 : DetColl = &Det_Tracker_TIB; break;
365			case 4 : DetColl = &Det_Tracker_TID; break;
366			case 5 : DetColl = &Det_Tracker_TOB; break;
367			case 6 : DetColl = &Det_Tracker_TEC; break;
368			}
369
370			if(DetColl==NULL){
371			printf("No COllection has been found\n");
372			return NULL;
373			}
374
375			for(std::vector<TrackerDet*>::iterator it = DetColl->begin();it!=DetColl->end();it++){
376			TrackerDet* Det = *it;
377			if(Det->DetId == DetId)return Det;
378			}
379			return NULL;
380	querten	1.2	}
381
382