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;

                ////////////////////////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);
                        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;

        
                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;
        }
}

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.4
Committed:	Fri Mar 21 07:25:16 2008 UTC (17 years, 1 month ago) by querten
Branch:	MAIN
Changes since 1.3:	+2 -1 lines
Log Message:	Fix TrackerGeometry in Endcap
#	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			////////////////////////UNKOWN CHUNK ////////////////////////
99			default:
100			printf("Unknown ChunkID (%i)\n",CurrentChunk->type);
101			printf("Chunk will be skipped\n");
102			printf("The program can not run properly\n");
103			fseek (pFile,CurrentChunk->size-CurrentChunk->read,SEEK_CUR);
104			CurrentChunk->read += CurrentChunk->size-CurrentChunk->read;
105			break;
106			}
107
108			ParentChunk->read += CurrentChunk->read;
109
110			}
111
112			void Geometry::Save (char* path)
113			{
114			stChunkToSave* Primary_chunk = new stChunkToSave;
115
116			Primary_chunk->type = C_PRIMARY;
117			Primary_chunk->size = 6;
118
119			Write(Primary_chunk);
120
121			printf("%i (%i)\n",Primary_chunk->type,Primary_chunk->size);
122			for(unsigned int i=0;i<Primary_chunk->daughters.size();i++){
123			stChunkToSave* tmp = Primary_chunk->daughters[i];
124			printf(" %i (%i)\n",tmp->type,tmp->size);
125			for(unsigned int j=0;j<tmp->daughters.size();j++){
126			stChunkToSave* Tmp = tmp->daughters[j];
127			printf(" %i (%i)\n",Tmp->type,Tmp->size);
128			for(unsigned int k=0;k<Tmp->daughters.size();k++){
129			stChunkToSave* TMp = Tmp->daughters[k];
130			printf(" %i (%i)\n",TMp->type,TMp->size);
131			for(unsigned int l=0;l<TMp->daughters.size();l++){
132			stChunkToSave* TMP = TMp->daughters[l];
133			printf(" %i (%i)\n",TMP->type,TMP->size);
134			}
135			}
136			}
137			}
138
139			FILE* pFile = fopen(path,"wb" );
140			WriteChunk(pFile, Primary_chunk);
141			fclose(pFile);
142			}
143
144			void Geometry::Write(stChunkToSave* ParentChunk)
145			{
146			unsigned int i;
147			stChunkToSave* CurrentChunk;
148
149			switch(ParentChunk->type)
150			{
151			case C_PRIMARY: // PrimaryChunk
152			CurrentChunk = new stChunkToSave;
153			CurrentChunk->type = C_GEOMETRY;
154			CurrentChunk->size = 6;
155			ParentChunk->daughters.push_back(CurrentChunk);
156			break;
157
158			case C_GEOMETRY: // Geometry
159			CurrentChunk = new stChunkToSave;
160			CurrentChunk->type = C_TRACKER;
161			CurrentChunk->size = 6;
162			ParentChunk->daughters.push_back(CurrentChunk);
163			break;
164
165			case C_TRACKER: // Tracker
166			for(i=0;i<Det_Tracker_PIB.size();i++){
167			CurrentChunk = new stChunkToSave;
168			CurrentChunk->type = C_TRACKER_PIB;
169			CurrentChunk->size = 6 + sizeof(TrackerDet);
170			CurrentChunk->data = Det_Tracker_PIB[i];
171			ParentChunk->daughters.push_back(CurrentChunk);
172			}
173			for(i=0;i<Det_Tracker_PIE.size();i++){
174			CurrentChunk = new stChunkToSave;
175			CurrentChunk->type = C_TRACKER_PIE;
176			CurrentChunk->size = 6 + sizeof(TrackerDet);
177			CurrentChunk->data = Det_Tracker_PIE[i];
178			ParentChunk->daughters.push_back(CurrentChunk);
179			}
180			for(i=0;i<Det_Tracker_TIB.size();i++){
181			CurrentChunk = new stChunkToSave;
182			CurrentChunk->type = C_TRACKER_TIB;
183			CurrentChunk->size = 6 + sizeof(TrackerDet);
184			CurrentChunk->data = Det_Tracker_TIB[i];
185			ParentChunk->daughters.push_back(CurrentChunk);
186			}
187			for(i=0;i<Det_Tracker_TID.size();i++){
188			CurrentChunk = new stChunkToSave;
189			CurrentChunk->type = C_TRACKER_TID;
190			CurrentChunk->size = 6 + sizeof(TrackerDet);
191			CurrentChunk->data = Det_Tracker_TID[i];
192			ParentChunk->daughters.push_back(CurrentChunk);
193			}
194			for(i=0;i<Det_Tracker_TOB.size();i++){
195			CurrentChunk = new stChunkToSave;
196			CurrentChunk->type = C_TRACKER_TOB;
197			CurrentChunk->size = 6 + sizeof(TrackerDet);
198			CurrentChunk->data = Det_Tracker_TOB[i];
199			ParentChunk->daughters.push_back(CurrentChunk);
200			}
201			for(i=0;i<Det_Tracker_TEC.size();i++){
202			CurrentChunk = new stChunkToSave;
203			CurrentChunk->type = C_TRACKER_TEC;
204			CurrentChunk->size = 6 + sizeof(TrackerDet);
205			CurrentChunk->data = Det_Tracker_TEC[i];
206			ParentChunk->daughters.push_back(CurrentChunk);
207			}
208			break;
209
210
211			default:
212			break;
213			}
214
215
216			for(i=0; i<ParentChunk->daughters.size();i++)
217			{
218			// if( !(ParentChunk->type == C_PRIMARY && i!=ParentChunk->daughters.size()-1))
219			Write(ParentChunk->daughters[i]);
220			ParentChunk->size += ParentChunk->daughters[i]->size;
221			}
222			}
223
224
225
226	querten	1.4	void Geometry::Add_TrackerDet(unsigned int DetId, float TrapezoidalParam,
227	querten	1.2	float PosX, float PosY, float PosZ,
228			float WidthX, float WidthY, float WidthZ,
229			float LengthX, float LengthY, float LengthZ,
230			float ThickX, float ThickY, float ThickZ){
231
232			int SubDet = (DetId>>25)&0x7;
233
234	querten	1.1	if(SubDet<0 \|\| SubDet>6)
235			{
236			printf("Unknown Subdet %i\n",SubDet);
237			return;
238			}
239
240			TrackerDet* temp = new TrackerDet();
241			temp->DetId = DetId;
242	querten	1.2	temp->PosX = PosX;
243			temp->PosY = PosY;
244			temp->PosZ = PosZ;
245			temp->WidthX = WidthX;
246			temp->WidthY = WidthY;
247			temp->WidthZ = WidthZ;
248			temp->LengthX = LengthX;
249			temp->LengthY = LengthY;
250			temp->LengthZ = LengthZ;
251			temp->ThickX = ThickX;
252			temp->ThickY = ThickY;
253			temp->ThickZ = ThickZ;
254	querten	1.4	temp->TrapezoidalParam = TrapezoidalParam;
255	querten	1.2
256	querten	1.1	Det_Tracker_ALL.push_back(temp);
257			switch(SubDet)
258			{
259			case 1 : Det_Tracker_PIB.push_back(temp); break;
260			case 2 : Det_Tracker_PIE.push_back(temp); break;
261			case 3 : Det_Tracker_TIB.push_back(temp); break;
262			case 4 : Det_Tracker_TID.push_back(temp); break;
263			case 5 : Det_Tracker_TOB.push_back(temp); break;
264			case 6 : Det_Tracker_TEC.push_back(temp); break;
265			}
266			}
267
268			TrackerDet* Geometry::Find_TrackerDet (unsigned int DetId){
269			int SubDet = (DetId>>25)&0x7;
270
271			if(SubDet<0 \|\| SubDet>6){
272			printf("Unknown Subdet %i\n",SubDet);
273			return NULL;
274			}
275
276			std::vector<TrackerDet> DetColl = NULL;
277
278			switch(SubDet){
279			case 1 : DetColl = &Det_Tracker_PIB; break;
280			case 2 : DetColl = &Det_Tracker_PIE; break;
281			case 3 : DetColl = &Det_Tracker_TIB; break;
282			case 4 : DetColl = &Det_Tracker_TID; break;
283			case 5 : DetColl = &Det_Tracker_TOB; break;
284			case 6 : DetColl = &Det_Tracker_TEC; break;
285			}
286
287			if(DetColl==NULL){
288			printf("No COllection has been found\n");
289			return NULL;
290			}
291
292			for(std::vector<TrackerDet*>::iterator it = DetColl->begin();it!=DetColl->end();it++){
293			TrackerDet* Det = *it;
294			if(Det->DetId == DetId)return Det;
295			}
296			return NULL;
297	querten	1.2	}
298
299