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

CaloDet* Geometry::Find_CaloDet (unsigned int DetId){

        int Det    = (DetId>>28)&0xF; 
        int SubDet = (DetId>>25)&0x7;
        
        std::vector<CaloDet*>::iterator it;
        std::vector<CaloDet*>::iterator it_begin;
        std::vector<CaloDet*>::iterator it_end;

        if(Det==3){                                                             //ECAL        
                if(SubDet==1){                                          // Ecal Barrel
                        it_begin = Det_ECAL_EB.begin();
                        it_end   = Det_ECAL_EB.end();
                }else if(SubDet==2){                            // Ecal Endcap
                        it_begin = Det_ECAL_EE.begin();
                        it_end   = Det_ECAL_EE.end();
                }else if(SubDet==3){                            // Ecal Preshower
                        it_begin = Det_ECAL_PS.begin();
                        it_end   = Det_ECAL_PS.end();
                }else{
                        return NULL;
                }
        }else if(Det==4){                                               //HCAL                 
                if(SubDet==1){                                          // Hcal Barrel
                        it_begin = Det_HCAL_HB.begin();
                        it_end   = Det_HCAL_HB.end();
                }else if(SubDet==2){                            // Hcal Endcap
                        it_begin = Det_HCAL_HE.begin();
                        it_end   = Det_HCAL_HE.end();
                }else if(SubDet==3){                            // Hcal Outer
                        it_begin = Det_HCAL_HO.begin();
                        it_end   = Det_HCAL_HO.end();
                }else if(SubDet==4){                            // Hcal Forward
                        it_begin = Det_HCAL_HF.begin();
                        it_end   = Det_HCAL_HF.end();
                }else{
                        return NULL;
                }
        }


        for(it=it_begin;it!=it_end;it++){
                CaloDet* tmp = *it;
                if(tmp->DetId==DetId)return (tmp);
        }

        return NULL;
}
Revision:	1.7
Committed:	Mon Mar 24 09:55:23 2008 UTC (17 years, 1 month ago) by querten
Branch:	MAIN
CVS Tags:	Version_0_2
Changes since 1.6:	+47 -0 lines
Log Message:	add ECAL&HCAL Hits
#	Content
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	if(pFile==NULL){
19	printf("The file %s can not be open !\n",path);
20	return;
21	}
22
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	// 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
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	////////////////////////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	case C_ECAL_EE:{ // EE
116	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	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
161
162	////////////////////////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	/*
185	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	*/
203
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
229	CurrentChunk = new stChunkToSave;
230	CurrentChunk->type = C_ECAL;
231	CurrentChunk->size = 6;
232	ParentChunk->daughters.push_back(CurrentChunk);
233
234	CurrentChunk = new stChunkToSave;
235	CurrentChunk->type = C_HCAL;
236	CurrentChunk->size = 6;
237	ParentChunk->daughters.push_back(CurrentChunk);
238	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	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	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	break;
308
309
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
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	void Geometry::Add_TrackerDet(unsigned int DetId, float TrapezoidalParam,
357	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	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	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	temp->TrapezoidalParam = TrapezoidalParam;
385
386	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	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
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
468
469	}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	}
483
484	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	printf("No Collection has been found\n");
505	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	}
514
515	CaloDet* Geometry::Find_CaloDet (unsigned int DetId){
516
517	int Det = (DetId>>28)&0xF;
518	int SubDet = (DetId>>25)&0x7;
519
520	std::vector<CaloDet*>::iterator it;
521	std::vector<CaloDet*>::iterator it_begin;
522	std::vector<CaloDet*>::iterator it_end;
523
524	if(Det==3){ //ECAL
525	if(SubDet==1){ // Ecal Barrel
526	it_begin = Det_ECAL_EB.begin();
527	it_end = Det_ECAL_EB.end();
528	}else if(SubDet==2){ // Ecal Endcap
529	it_begin = Det_ECAL_EE.begin();
530	it_end = Det_ECAL_EE.end();
531	}else if(SubDet==3){ // Ecal Preshower
532	it_begin = Det_ECAL_PS.begin();
533	it_end = Det_ECAL_PS.end();
534	}else{
535	return NULL;
536	}
537	}else if(Det==4){ //HCAL
538	if(SubDet==1){ // Hcal Barrel
539	it_begin = Det_HCAL_HB.begin();
540	it_end = Det_HCAL_HB.end();
541	}else if(SubDet==2){ // Hcal Endcap
542	it_begin = Det_HCAL_HE.begin();
543	it_end = Det_HCAL_HE.end();
544	}else if(SubDet==3){ // Hcal Outer
545	it_begin = Det_HCAL_HO.begin();
546	it_end = Det_HCAL_HO.end();
547	}else if(SubDet==4){ // Hcal Forward
548	it_begin = Det_HCAL_HF.begin();
549	it_end = Det_HCAL_HF.end();
550	}else{
551	return NULL;
552	}
553	}
554
555
556	for(it=it_begin;it!=it_end;it++){
557	CaloDet* tmp = *it;
558	if(tmp->DetId==DetId)return (tmp);
559	}
560
561	return NULL;
562	}