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
#	Content
1	// Geometry.cpp: implementation of the Geometry class.
2	//
3	//////////////////////////////////////////////////////////////////////
4
5	#include "../interface/Geometry.h"
6	#include <algorithm>
7
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	if(pFile==NULL){
20	printf("The file %s can not be open !\n",path);
21	return;
22	}
23
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	fclose(pFile);
37
38	sortDet();
39	}
40
41	void Geometry::Read (FILE* pFile, stChunk* ParentChunk)
42	{
43	// 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
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	////////////////////////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	case C_ECAL_EE:{ // EE
118	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	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
163
164	////////////////////////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	sortDet();
181	stChunkToSave* Primary_chunk = new stChunkToSave;
182
183	Primary_chunk->type = C_PRIMARY;
184	Primary_chunk->size = 6;
185
186	Write(Primary_chunk);
187	/*
188	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	*/
206
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
232	CurrentChunk = new stChunkToSave;
233	CurrentChunk->type = C_ECAL;
234	CurrentChunk->size = 6;
235	ParentChunk->daughters.push_back(CurrentChunk);
236
237	CurrentChunk = new stChunkToSave;
238	CurrentChunk->type = C_HCAL;
239	CurrentChunk->size = 6;
240	ParentChunk->daughters.push_back(CurrentChunk);
241	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	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	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	break;
311
312
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
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	void Geometry::sortDet() {
358	// Tracker
359	std::sort( Det_Tracker_ALL.begin(), Det_Tracker_ALL.end(), isLowerId() );
360	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	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	// HCAL
372	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	}
378
379
380
381	void Geometry::Add_TrackerDet(unsigned int DetId, float TrapezoidalParam,
382	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	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	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	temp->TrapezoidalParam = TrapezoidalParam;
410
411	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	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
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	}
499
500	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	printf("No Collection has been found\n");
521	return NULL;
522	}
523
524	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
530	return NULL;
531	}
532
533	CaloDet* Geometry::Find_CaloDet (unsigned int DetId){
534
535	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	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
579	return NULL;
580	}