FastOpenGlDisplayer/src/Geometry.cpp

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

#include "../interface/Geometry.h"
#include <algorithm>

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

        sortDet();
}

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)
{
    sortDet();
        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::sortDet() {
        // Tracker
                std::sort( Det_Tracker_ALL.begin(), Det_Tracker_ALL.end(), isLowerId() );
        std::sort( Det_Tracker_PIB.begin(), Det_Tracker_PIB.end(), isLowerId() );
        std::sort( Det_Tracker_PIE.begin(), Det_Tracker_PIE.end(), isLowerId() );
        std::sort( Det_Tracker_TIB.begin(), Det_Tracker_TIB.end(), isLowerId() );
        std::sort( Det_Tracker_TID.begin(), Det_Tracker_TID.end(), isLowerId() );
        std::sort( Det_Tracker_TOB.begin(), Det_Tracker_TOB.end(), isLowerId() );
        std::sort( Det_Tracker_TEC.begin(), Det_Tracker_TEC.end(), isLowerId() );
        // ECAL
                std::sort( Det_ECAL_ALL.begin(), Det_ECAL_ALL.end(), isLowerId() );
        std::sort( Det_ECAL_EB.begin() , Det_ECAL_EB.end() , isLowerId() );
        std::sort( Det_ECAL_EE.begin() , Det_ECAL_EE.end() , isLowerId() );
        std::sort( Det_ECAL_PS.begin() , Det_ECAL_PS.end() , isLowerId() );
        // HCAL
                std::sort( Det_HCAL_ALL.begin(), Det_HCAL_ALL.end(), isLowerId() );
        std::sort( Det_HCAL_HB.begin() , Det_HCAL_HB.end() , isLowerId() );
        std::sort( Det_HCAL_HE.begin() , Det_HCAL_HE.end() , isLowerId() );
        std::sort( Det_HCAL_HO.begin() , Det_HCAL_HO.end() , isLowerId() );
        std::sort( Det_HCAL_HF.begin() , Det_HCAL_HF.end() , isLowerId() );
}


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

    TrackerDet* det = new TrackerDet();
        det->DetId = DetId;
    std::vector<TrackerDet*>::iterator where = std::lower_bound(DetColl->begin(), DetColl->end(), det, isLowerId());
        delete det;
        if( where != DetColl->end()) return *(where);

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

    CaloDet* det = new CaloDet();
        det->DetId = DetId;
    std::vector<CaloDet*>::iterator where = std::lower_bound(it_begin, it_end, det, isLowerId());
        delete det;  
        if( where != it_end) return *(where);

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