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" );
        if(pFile==NULL){
                printf("The file %s can not be open !\n",path);
                return;
        }

        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:{                // EE                   
                        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;
                case C_ECAL_PS:{                // PS   
                        CaloDet* Temp = new CaloDet;
                        CurrentChunk->read += fread(Temp,sizeof(CaloDet),1,pFile) * sizeof(CaloDet);
                        Det_ECAL_PS.push_back(Temp);
                        Det_ECAL_ALL.push_back(Temp);                   
                        }break;


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

                case C_HCAL_HB:{                // HB                   
                        CaloDet* Temp = new CaloDet;
                        CurrentChunk->read += fread(Temp,sizeof(CaloDet),1,pFile) * sizeof(CaloDet);
                        Det_HCAL_HB.push_back(Temp);
                        Det_HCAL_ALL.push_back(Temp);                   
                        }break;
                case C_HCAL_HE:{                // HE
                        CaloDet* Temp = new CaloDet;
                        CurrentChunk->read += fread(Temp,sizeof(CaloDet),1,pFile) * sizeof(CaloDet);
                        Det_HCAL_HE.push_back(Temp);
                        Det_HCAL_ALL.push_back(Temp);                   
                        }break;
                case C_HCAL_HO:{                // HO                   
                        CaloDet* Temp = new CaloDet;
                        CurrentChunk->read += fread(Temp,sizeof(CaloDet),1,pFile) * sizeof(CaloDet);
                        Det_HCAL_HO.push_back(Temp);
                        Det_HCAL_ALL.push_back(Temp);                   
                        }break;
                case C_HCAL_HF:{                // HF                   
                        CaloDet* Temp = new CaloDet;
                        CurrentChunk->read += fread(Temp,sizeof(CaloDet),1,pFile) * sizeof(CaloDet);
                        Det_HCAL_HF.push_back(Temp);
                        Det_HCAL_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);

                        CurrentChunk = new stChunkToSave;
                        CurrentChunk->type = C_HCAL;                                    
                        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);
                        }
                        for(i=0;i<Det_ECAL_EE.size();i++){
                                CurrentChunk = new stChunkToSave;
                                CurrentChunk->type = C_ECAL_EE;
                                CurrentChunk->size = 6 + sizeof(CaloDet);
                                CurrentChunk->data = Det_ECAL_EE[i];
                                ParentChunk->daughters.push_back(CurrentChunk);
                        }
                        for(i=0;i<Det_ECAL_PS.size();i++){
                                CurrentChunk = new stChunkToSave;
                                CurrentChunk->type = C_ECAL_PS;
                                CurrentChunk->size = 6 + sizeof(CaloDet);
                                CurrentChunk->data = Det_ECAL_PS[i];
                                ParentChunk->daughters.push_back(CurrentChunk);
                        }
                        break;


                case C_HCAL:                    // HCAL
                        for(i=0;i<Det_HCAL_HB.size();i++){
                                CurrentChunk = new stChunkToSave;
                                CurrentChunk->type = C_HCAL_HB;
                                CurrentChunk->size = 6 + sizeof(CaloDet);
                                CurrentChunk->data = Det_HCAL_HB[i];
                                ParentChunk->daughters.push_back(CurrentChunk);
                        }
                        for(i=0;i<Det_HCAL_HE.size();i++){
                                CurrentChunk = new stChunkToSave;
                                CurrentChunk->type = C_HCAL_HE;
                                CurrentChunk->size = 6 + sizeof(CaloDet);
                                CurrentChunk->data = Det_HCAL_HE[i];
                                ParentChunk->daughters.push_back(CurrentChunk);
                        }
                        for(i=0;i<Det_HCAL_HO.size();i++){
                                CurrentChunk = new stChunkToSave;
                                CurrentChunk->type = C_HCAL_HO;
                                CurrentChunk->size = 6 + sizeof(CaloDet);
                                CurrentChunk->data = Det_HCAL_HO[i];
                                ParentChunk->daughters.push_back(CurrentChunk);
                        }
                        for(i=0;i<Det_HCAL_HF.size();i++){
                                CurrentChunk = new stChunkToSave;
                                CurrentChunk->type = C_HCAL_HF;
                                CurrentChunk->size = 6 + sizeof(CaloDet);
                                CurrentChunk->data = Det_HCAL_HF[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){

        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;


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


        if(Det==3){                                             //ECAL
                Det_ECAL_ALL.push_back(temp);
        
                if(SubDet==1){                          // Ecal Barrel
                        Det_ECAL_EB.push_back(temp);    
                }else if(SubDet==2){            // Ecal Endcap
                        Det_ECAL_EE.push_back(temp);    
                }else if(SubDet==3){            // Ecal Preshower
                        Det_ECAL_PS.push_back(temp);
                }else{
                        //SubDet==4 --> EcalTriggerTower
                        //SubDet==5 --> EcalLaserPnDiode

                        delete temp;
                        printf("Unknown Subdet %i\n",SubDet);
                        return;
                }
        }else if(Det==4){                               //HCAL
                Det_HCAL_ALL.push_back(temp);
        
                if(SubDet==1){                          // Hcal Barrel
                        Det_HCAL_HB.push_back(temp);    
                }else if(SubDet==2){            // Hcal Endcap
                        Det_HCAL_HE.push_back(temp);    
                }else if(SubDet==3){            // Hcal Outer
                        Det_HCAL_HO.push_back(temp);
                }else if(SubDet==4){            // Hcal Forward
                        Det_HCAL_HF.push_back(temp);
                }else{
                        //SubDet==0 --> HcalEmpty
                        //SubDet==5 --> HcalTriggerTower
                        //SubDet==7 --> HcalOther (HcalOtherEmpty or HcalCalibration)

                        delete temp;
                        printf("Unknown Subdet %i\n",SubDet);
                        return;
                }

        
        }else if(Det==5){                               //CALO?
                delete temp;

        }else{
                delete temp;
                printf("Unknown Det %i\n",Det);
                return;
        }


}

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.6
Committed:	Sun Mar 23 09:45:19 2008 UTC (17 years, 1 month ago) by querten
Branch:	MAIN
Changes since 1.5:	+153 -20 lines
Log Message:	Fix BMP under Linux and HCAL Geom
#	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	querten	1.6	if(pFile==NULL){
19			printf("The file %s can not be open !\n",path);
20			return;
21			}
22	querten	1.1
23			stChunk* PrimaryChunk = new stChunk;
24
25			PrimaryChunk->read =fread(&PrimaryChunk->type,1,2,pFile);
26			PrimaryChunk->read +=fread(&PrimaryChunk->size,1,4,pFile);
27
28			if(PrimaryChunk->type!=C_PRIMARY){
29			printf("PrimaryChunk has not a good Id (%i!=%i)\n",PrimaryChunk->type,C_PRIMARY);
30			printf("Exiting...\n");
31			exit(0);
32			}
33
34			Read(pFile,PrimaryChunk);
35
36			fclose(pFile);
37			}
38
39			void Geometry::Read (FILE* pFile, stChunk* ParentChunk)
40			{
41	querten	1.3	// unsigned short temp;
42			// fread(&temp,1,2,pFile);
43			// fseek(pFile,-2,SEEK_CUR);
44			// printf("Parent = %i --> Current ChunkId = %i to read = %i\n",ParentChunk->type,temp,0);
45	querten	1.1
46			stChunk* CurrentChunk = new stChunk;
47			ReadChunk(pFile, CurrentChunk);
48
49			switch(CurrentChunk->type)
50			{
51			case C_GEOMETRY: // Geometry
52			while(CurrentChunk->read<CurrentChunk->size){
53			Read(pFile,CurrentChunk);
54			}
55			break;
56
57
58			////////////////////////TRACKER DATA//////////////////////////
59			case C_TRACKER: // TRACKER
60			while(CurrentChunk->read<CurrentChunk->size){
61			Read(pFile,CurrentChunk);
62			}
63			break;
64
65			case C_TRACKER_PIB:{ // PIB
66			TrackerDet* Temp = new TrackerDet;
67			CurrentChunk->read += fread(Temp,sizeof(TrackerDet),1,pFile) * sizeof(TrackerDet);
68			Det_Tracker_PIB.push_back(Temp);
69			Det_Tracker_ALL.push_back(Temp);
70			}break;
71			case C_TRACKER_PIE:{ // PIE
72			TrackerDet* Temp = new TrackerDet;
73			CurrentChunk->read += fread(Temp,sizeof(TrackerDet),1,pFile) * sizeof(TrackerDet);
74			Det_Tracker_PIE.push_back(Temp);
75			Det_Tracker_ALL.push_back(Temp);
76			}break;
77			case C_TRACKER_TIB:{ // TIB
78			TrackerDet* Temp = new TrackerDet;
79			CurrentChunk->read += fread(Temp,sizeof(TrackerDet),1,pFile) * sizeof(TrackerDet);
80			Det_Tracker_TIB.push_back(Temp);
81			Det_Tracker_ALL.push_back(Temp);
82			}break;
83			case C_TRACKER_TID:{ // TID
84			TrackerDet* Temp = new TrackerDet;
85			CurrentChunk->read += fread(Temp,sizeof(TrackerDet),1,pFile) * sizeof(TrackerDet);
86			Det_Tracker_TID.push_back(Temp);
87			Det_Tracker_ALL.push_back(Temp);
88			}break;
89			case C_TRACKER_TOB:{ // TOB
90			TrackerDet* Temp = new TrackerDet;
91			CurrentChunk->read += fread(Temp,sizeof(TrackerDet),1,pFile) * sizeof(TrackerDet);
92			Det_Tracker_TOB.push_back(Temp);
93			Det_Tracker_ALL.push_back(Temp);
94			}break;
95			case C_TRACKER_TEC:{ // TEC
96			TrackerDet* Temp = new TrackerDet;
97			CurrentChunk->read += fread(Temp,sizeof(TrackerDet),1,pFile) * sizeof(TrackerDet);
98			Det_Tracker_TEC.push_back(Temp);
99			Det_Tracker_ALL.push_back(Temp);
100			}break;
101
102	querten	1.5	////////////////////////ECAL DATA//////////////////////////
103			case C_ECAL: // ECAL
104			while(CurrentChunk->read<CurrentChunk->size){
105			Read(pFile,CurrentChunk);
106			}
107			break;
108
109			case C_ECAL_EB:{ // EB
110			CaloDet* Temp = new CaloDet;
111			CurrentChunk->read += fread(Temp,sizeof(CaloDet),1,pFile) * sizeof(CaloDet);
112			Det_ECAL_EB.push_back(Temp);
113			Det_ECAL_ALL.push_back(Temp);
114			}break;
115	querten	1.6	case C_ECAL_EE:{ // EE
116	querten	1.5	CaloDet* Temp = new CaloDet;
117			CurrentChunk->read += fread(Temp,sizeof(CaloDet),1,pFile) * sizeof(CaloDet);
118			Det_ECAL_EE.push_back(Temp);
119			Det_ECAL_ALL.push_back(Temp);
120			}break;
121	querten	1.6	case C_ECAL_PS:{ // PS
122			CaloDet* Temp = new CaloDet;
123			CurrentChunk->read += fread(Temp,sizeof(CaloDet),1,pFile) * sizeof(CaloDet);
124			Det_ECAL_PS.push_back(Temp);
125			Det_ECAL_ALL.push_back(Temp);
126			}break;
127
128
129			////////////////////////HCAL DATA//////////////////////////
130			case C_HCAL: // HCAL
131			while(CurrentChunk->read<CurrentChunk->size){
132			Read(pFile,CurrentChunk);
133			}
134			break;
135
136			case C_HCAL_HB:{ // HB
137			CaloDet* Temp = new CaloDet;
138			CurrentChunk->read += fread(Temp,sizeof(CaloDet),1,pFile) * sizeof(CaloDet);
139			Det_HCAL_HB.push_back(Temp);
140			Det_HCAL_ALL.push_back(Temp);
141			}break;
142			case C_HCAL_HE:{ // HE
143			CaloDet* Temp = new CaloDet;
144			CurrentChunk->read += fread(Temp,sizeof(CaloDet),1,pFile) * sizeof(CaloDet);
145			Det_HCAL_HE.push_back(Temp);
146			Det_HCAL_ALL.push_back(Temp);
147			}break;
148			case C_HCAL_HO:{ // HO
149			CaloDet* Temp = new CaloDet;
150			CurrentChunk->read += fread(Temp,sizeof(CaloDet),1,pFile) * sizeof(CaloDet);
151			Det_HCAL_HO.push_back(Temp);
152			Det_HCAL_ALL.push_back(Temp);
153			}break;
154			case C_HCAL_HF:{ // HF
155			CaloDet* Temp = new CaloDet;
156			CurrentChunk->read += fread(Temp,sizeof(CaloDet),1,pFile) * sizeof(CaloDet);
157			Det_HCAL_HF.push_back(Temp);
158			Det_HCAL_ALL.push_back(Temp);
159			}break;
160	querten	1.5
161
162	querten	1.1	////////////////////////UNKOWN CHUNK ////////////////////////
163			default:
164			printf("Unknown ChunkID (%i)\n",CurrentChunk->type);
165			printf("Chunk will be skipped\n");
166			printf("The program can not run properly\n");
167			fseek (pFile,CurrentChunk->size-CurrentChunk->read,SEEK_CUR);
168			CurrentChunk->read += CurrentChunk->size-CurrentChunk->read;
169			break;
170			}
171
172			ParentChunk->read += CurrentChunk->read;
173
174			}
175
176			void Geometry::Save (char* path)
177			{
178			stChunkToSave* Primary_chunk = new stChunkToSave;
179
180			Primary_chunk->type = C_PRIMARY;
181			Primary_chunk->size = 6;
182
183			Write(Primary_chunk);
184	querten	1.5	/*
185	querten	1.1	printf("%i (%i)\n",Primary_chunk->type,Primary_chunk->size);
186			for(unsigned int i=0;i<Primary_chunk->daughters.size();i++){
187			stChunkToSave* tmp = Primary_chunk->daughters[i];
188			printf(" %i (%i)\n",tmp->type,tmp->size);
189			for(unsigned int j=0;j<tmp->daughters.size();j++){
190			stChunkToSave* Tmp = tmp->daughters[j];
191			printf(" %i (%i)\n",Tmp->type,Tmp->size);
192			for(unsigned int k=0;k<Tmp->daughters.size();k++){
193			stChunkToSave* TMp = Tmp->daughters[k];
194			printf(" %i (%i)\n",TMp->type,TMp->size);
195			for(unsigned int l=0;l<TMp->daughters.size();l++){
196			stChunkToSave* TMP = TMp->daughters[l];
197			printf(" %i (%i)\n",TMP->type,TMP->size);
198			}
199			}
200			}
201			}
202	querten	1.5	*/
203	querten	1.1
204			FILE* pFile = fopen(path,"wb" );
205			WriteChunk(pFile, Primary_chunk);
206			fclose(pFile);
207			}
208
209			void Geometry::Write(stChunkToSave* ParentChunk)
210			{
211			unsigned int i;
212			stChunkToSave* CurrentChunk;
213
214			switch(ParentChunk->type)
215			{
216			case C_PRIMARY: // PrimaryChunk
217			CurrentChunk = new stChunkToSave;
218			CurrentChunk->type = C_GEOMETRY;
219			CurrentChunk->size = 6;
220			ParentChunk->daughters.push_back(CurrentChunk);
221			break;
222
223			case C_GEOMETRY: // Geometry
224			CurrentChunk = new stChunkToSave;
225			CurrentChunk->type = C_TRACKER;
226			CurrentChunk->size = 6;
227			ParentChunk->daughters.push_back(CurrentChunk);
228	querten	1.5
229			CurrentChunk = new stChunkToSave;
230			CurrentChunk->type = C_ECAL;
231			CurrentChunk->size = 6;
232			ParentChunk->daughters.push_back(CurrentChunk);
233	querten	1.6
234			CurrentChunk = new stChunkToSave;
235			CurrentChunk->type = C_HCAL;
236			CurrentChunk->size = 6;
237			ParentChunk->daughters.push_back(CurrentChunk);
238	querten	1.1	break;
239
240			case C_TRACKER: // Tracker
241			for(i=0;i<Det_Tracker_PIB.size();i++){
242			CurrentChunk = new stChunkToSave;
243			CurrentChunk->type = C_TRACKER_PIB;
244			CurrentChunk->size = 6 + sizeof(TrackerDet);
245			CurrentChunk->data = Det_Tracker_PIB[i];
246			ParentChunk->daughters.push_back(CurrentChunk);
247			}
248			for(i=0;i<Det_Tracker_PIE.size();i++){
249			CurrentChunk = new stChunkToSave;
250			CurrentChunk->type = C_TRACKER_PIE;
251			CurrentChunk->size = 6 + sizeof(TrackerDet);
252			CurrentChunk->data = Det_Tracker_PIE[i];
253			ParentChunk->daughters.push_back(CurrentChunk);
254			}
255			for(i=0;i<Det_Tracker_TIB.size();i++){
256			CurrentChunk = new stChunkToSave;
257			CurrentChunk->type = C_TRACKER_TIB;
258			CurrentChunk->size = 6 + sizeof(TrackerDet);
259			CurrentChunk->data = Det_Tracker_TIB[i];
260			ParentChunk->daughters.push_back(CurrentChunk);
261			}
262			for(i=0;i<Det_Tracker_TID.size();i++){
263			CurrentChunk = new stChunkToSave;
264			CurrentChunk->type = C_TRACKER_TID;
265			CurrentChunk->size = 6 + sizeof(TrackerDet);
266			CurrentChunk->data = Det_Tracker_TID[i];
267			ParentChunk->daughters.push_back(CurrentChunk);
268			}
269			for(i=0;i<Det_Tracker_TOB.size();i++){
270			CurrentChunk = new stChunkToSave;
271			CurrentChunk->type = C_TRACKER_TOB;
272			CurrentChunk->size = 6 + sizeof(TrackerDet);
273			CurrentChunk->data = Det_Tracker_TOB[i];
274			ParentChunk->daughters.push_back(CurrentChunk);
275			}
276			for(i=0;i<Det_Tracker_TEC.size();i++){
277			CurrentChunk = new stChunkToSave;
278			CurrentChunk->type = C_TRACKER_TEC;
279			CurrentChunk->size = 6 + sizeof(TrackerDet);
280			CurrentChunk->data = Det_Tracker_TEC[i];
281			ParentChunk->daughters.push_back(CurrentChunk);
282			}
283			break;
284
285	querten	1.5	case C_ECAL: // ECAL
286			for(i=0;i<Det_ECAL_EB.size();i++){
287			CurrentChunk = new stChunkToSave;
288			CurrentChunk->type = C_ECAL_EB;
289			CurrentChunk->size = 6 + sizeof(CaloDet);
290			CurrentChunk->data = Det_ECAL_EB[i];
291			ParentChunk->daughters.push_back(CurrentChunk);
292			}
293	querten	1.6	for(i=0;i<Det_ECAL_EE.size();i++){
294			CurrentChunk = new stChunkToSave;
295			CurrentChunk->type = C_ECAL_EE;
296			CurrentChunk->size = 6 + sizeof(CaloDet);
297			CurrentChunk->data = Det_ECAL_EE[i];
298			ParentChunk->daughters.push_back(CurrentChunk);
299			}
300			for(i=0;i<Det_ECAL_PS.size();i++){
301			CurrentChunk = new stChunkToSave;
302			CurrentChunk->type = C_ECAL_PS;
303			CurrentChunk->size = 6 + sizeof(CaloDet);
304			CurrentChunk->data = Det_ECAL_PS[i];
305			ParentChunk->daughters.push_back(CurrentChunk);
306			}
307	querten	1.5	break;
308
309	querten	1.6
310			case C_HCAL: // HCAL
311			for(i=0;i<Det_HCAL_HB.size();i++){
312			CurrentChunk = new stChunkToSave;
313			CurrentChunk->type = C_HCAL_HB;
314			CurrentChunk->size = 6 + sizeof(CaloDet);
315			CurrentChunk->data = Det_HCAL_HB[i];
316			ParentChunk->daughters.push_back(CurrentChunk);
317			}
318			for(i=0;i<Det_HCAL_HE.size();i++){
319			CurrentChunk = new stChunkToSave;
320			CurrentChunk->type = C_HCAL_HE;
321			CurrentChunk->size = 6 + sizeof(CaloDet);
322			CurrentChunk->data = Det_HCAL_HE[i];
323			ParentChunk->daughters.push_back(CurrentChunk);
324			}
325			for(i=0;i<Det_HCAL_HO.size();i++){
326			CurrentChunk = new stChunkToSave;
327			CurrentChunk->type = C_HCAL_HO;
328			CurrentChunk->size = 6 + sizeof(CaloDet);
329			CurrentChunk->data = Det_HCAL_HO[i];
330			ParentChunk->daughters.push_back(CurrentChunk);
331			}
332			for(i=0;i<Det_HCAL_HF.size();i++){
333			CurrentChunk = new stChunkToSave;
334			CurrentChunk->type = C_HCAL_HF;
335			CurrentChunk->size = 6 + sizeof(CaloDet);
336			CurrentChunk->data = Det_HCAL_HF[i];
337			ParentChunk->daughters.push_back(CurrentChunk);
338			}
339			break;
340	querten	1.1
341			default:
342			break;
343			}
344
345
346			for(i=0; i<ParentChunk->daughters.size();i++)
347			{
348			// if( !(ParentChunk->type == C_PRIMARY && i!=ParentChunk->daughters.size()-1))
349			Write(ParentChunk->daughters[i]);
350			ParentChunk->size += ParentChunk->daughters[i]->size;
351			}
352			}
353
354
355
356	querten	1.4	void Geometry::Add_TrackerDet(unsigned int DetId, float TrapezoidalParam,
357	querten	1.2	float PosX, float PosY, float PosZ,
358			float WidthX, float WidthY, float WidthZ,
359			float LengthX, float LengthY, float LengthZ,
360			float ThickX, float ThickY, float ThickZ){
361
362			int SubDet = (DetId>>25)&0x7;
363
364	querten	1.1	if(SubDet<0 \|\| SubDet>6)
365			{
366			printf("Unknown Subdet %i\n",SubDet);
367			return;
368			}
369
370			TrackerDet* temp = new TrackerDet();
371			temp->DetId = DetId;
372	querten	1.2	temp->PosX = PosX;
373			temp->PosY = PosY;
374			temp->PosZ = PosZ;
375			temp->WidthX = WidthX;
376			temp->WidthY = WidthY;
377			temp->WidthZ = WidthZ;
378			temp->LengthX = LengthX;
379			temp->LengthY = LengthY;
380			temp->LengthZ = LengthZ;
381			temp->ThickX = ThickX;
382			temp->ThickY = ThickY;
383			temp->ThickZ = ThickZ;
384	querten	1.4	temp->TrapezoidalParam = TrapezoidalParam;
385	querten	1.2
386	querten	1.1	Det_Tracker_ALL.push_back(temp);
387			switch(SubDet)
388			{
389			case 1 : Det_Tracker_PIB.push_back(temp); break;
390			case 2 : Det_Tracker_PIE.push_back(temp); break;
391			case 3 : Det_Tracker_TIB.push_back(temp); break;
392			case 4 : Det_Tracker_TID.push_back(temp); break;
393			case 5 : Det_Tracker_TOB.push_back(temp); break;
394			case 6 : Det_Tracker_TEC.push_back(temp); break;
395			}
396			}
397
398	querten	1.5	void Geometry::Add_CaloDet(unsigned int DetId,
399			float PosX, float PosY, float PosZ,
400			float C1X, float C1Y, float C1Z,
401			float C2X, float C2Y, float C2Z,
402			float C3X, float C3Y, float C3Z,
403			float C4X, float C4Y, float C4Z,
404			float C5X, float C5Y, float C5Z,
405			float C6X, float C6Y, float C6Z,
406			float C7X, float C7Y, float C7Z,
407			float C8X, float C8Y, float C8Z){
408
409			CaloDet* temp = new CaloDet();
410			temp->DetId = DetId;
411			temp->PosX = PosX;
412			temp->PosY = PosY;
413			temp->PosZ = PosZ;
414			temp->C1X = C1X; temp->C1Y = C1Y; temp->C1Z = C1Z;
415			temp->C2X = C2X; temp->C2Y = C2Y; temp->C2Z = C2Z;
416			temp->C3X = C3X; temp->C3Y = C3Y; temp->C3Z = C3Z;
417			temp->C4X = C4X; temp->C4Y = C4Y; temp->C4Z = C4Z;
418			temp->C5X = C5X; temp->C5Y = C5Y; temp->C5Z = C5Z;
419			temp->C6X = C6X; temp->C6Y = C6Y; temp->C6Z = C6Z;
420			temp->C7X = C7X; temp->C7Y = C7Y; temp->C7Z = C7Z;
421			temp->C8X = C8X; temp->C8Y = C8Y; temp->C8Z = C8Z;
422	querten	1.6
423
424
425			int Det = (DetId>>28)&0xF;
426			int SubDet = (DetId>>25)&0x7;
427
428
429			if(Det==3){ //ECAL
430			Det_ECAL_ALL.push_back(temp);
431
432			if(SubDet==1){ // Ecal Barrel
433			Det_ECAL_EB.push_back(temp);
434			}else if(SubDet==2){ // Ecal Endcap
435			Det_ECAL_EE.push_back(temp);
436			}else if(SubDet==3){ // Ecal Preshower
437			Det_ECAL_PS.push_back(temp);
438			}else{
439			//SubDet==4 --> EcalTriggerTower
440			//SubDet==5 --> EcalLaserPnDiode
441
442			delete temp;
443			printf("Unknown Subdet %i\n",SubDet);
444			return;
445			}
446			}else if(Det==4){ //HCAL
447			Det_HCAL_ALL.push_back(temp);
448
449			if(SubDet==1){ // Hcal Barrel
450			Det_HCAL_HB.push_back(temp);
451			}else if(SubDet==2){ // Hcal Endcap
452			Det_HCAL_HE.push_back(temp);
453			}else if(SubDet==3){ // Hcal Outer
454			Det_HCAL_HO.push_back(temp);
455			}else if(SubDet==4){ // Hcal Forward
456			Det_HCAL_HF.push_back(temp);
457			}else{
458			//SubDet==0 --> HcalEmpty
459			//SubDet==5 --> HcalTriggerTower
460			//SubDet==7 --> HcalOther (HcalOtherEmpty or HcalCalibration)
461
462			delete temp;
463			printf("Unknown Subdet %i\n",SubDet);
464			return;
465			}
466
467	querten	1.5
468
469	querten	1.6	}else if(Det==5){ //CALO?
470			delete temp;
471
472			}else{
473			delete temp;
474			printf("Unknown Det %i\n",Det);
475			return;
476			}
477
478
479
480
481
482	querten	1.5	}
483
484	querten	1.1	TrackerDet* Geometry::Find_TrackerDet (unsigned int DetId){
485			int SubDet = (DetId>>25)&0x7;
486
487			if(SubDet<0 \|\| SubDet>6){
488			printf("Unknown Subdet %i\n",SubDet);
489			return NULL;
490			}
491
492			std::vector<TrackerDet> DetColl = NULL;
493
494			switch(SubDet){
495			case 1 : DetColl = &Det_Tracker_PIB; break;
496			case 2 : DetColl = &Det_Tracker_PIE; break;
497			case 3 : DetColl = &Det_Tracker_TIB; break;
498			case 4 : DetColl = &Det_Tracker_TID; break;
499			case 5 : DetColl = &Det_Tracker_TOB; break;
500			case 6 : DetColl = &Det_Tracker_TEC; break;
501			}
502
503			if(DetColl==NULL){
504	querten	1.6	printf("No Collection has been found\n");
505	querten	1.1	return NULL;
506			}
507
508			for(std::vector<TrackerDet*>::iterator it = DetColl->begin();it!=DetColl->end();it++){
509			TrackerDet* Det = *it;
510			if(Det->DetId == DetId)return Det;
511			}
512			return NULL;
513	querten	1.2	}
514
515