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 (short SubDet, float PosX, float PosY, float PosZ, unsigned int DetId)
{
        if(SubDet<0 || SubDet>6)
        {
                printf("Unknown Subdet %i\n",SubDet);
                return;
        }

        TrackerDet* temp = new TrackerDet();
        temp->PosX  = PosX;
        temp->PosY  = PosY;
        temp->PosZ  = PosZ;
        temp->DetId = DetId;

        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.1
Committed:	Mon Mar 17 06:26:31 2008 UTC (17 years, 1 month ago) by querten
Branch:	MAIN
Log Message:	Add Basic Tracker Geometry Informations
#	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			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
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			void Geometry::Add_TrackerDet (short SubDet, float PosX, float PosY, float PosZ, unsigned int DetId)
227			{
228			if(SubDet<0 \|\| SubDet>6)
229			{
230			printf("Unknown Subdet %i\n",SubDet);
231			return;
232			}
233
234			TrackerDet* temp = new TrackerDet();
235			temp->PosX = PosX;
236			temp->PosY = PosY;
237			temp->PosZ = PosZ;
238			temp->DetId = DetId;
239
240			Det_Tracker_ALL.push_back(temp);
241
242			switch(SubDet)
243			{
244			case 1 : Det_Tracker_PIB.push_back(temp); break;
245			case 2 : Det_Tracker_PIE.push_back(temp); break;
246			case 3 : Det_Tracker_TIB.push_back(temp); break;
247			case 4 : Det_Tracker_TID.push_back(temp); break;
248			case 5 : Det_Tracker_TOB.push_back(temp); break;
249			case 6 : Det_Tracker_TEC.push_back(temp); break;
250			}
251			}
252
253			TrackerDet* Geometry::Find_TrackerDet (unsigned int DetId){
254			int SubDet = (DetId>>25)&0x7;
255
256			if(SubDet<0 \|\| SubDet>6){
257			printf("Unknown Subdet %i\n",SubDet);
258			return NULL;
259			}
260
261			std::vector<TrackerDet> DetColl = NULL;
262
263			switch(SubDet){
264			case 1 : DetColl = &Det_Tracker_PIB; break;
265			case 2 : DetColl = &Det_Tracker_PIE; break;
266			case 3 : DetColl = &Det_Tracker_TIB; break;
267			case 4 : DetColl = &Det_Tracker_TID; break;
268			case 5 : DetColl = &Det_Tracker_TOB; break;
269			case 6 : DetColl = &Det_Tracker_TEC; break;
270			}
271
272			if(DetColl==NULL){
273			printf("No COllection has been found\n");
274			return NULL;
275			}
276
277			for(std::vector<TrackerDet*>::iterator it = DetColl->begin();it!=DetColl->end();it++){
278			TrackerDet* Det = *it;
279			if(Det->DetId == DetId)return Det;
280			}
281			return NULL;
282			}