PHOS run2 geometry with CPV updated
authorprsnko <Dmitri.Peressounko@cern.ch>
Mon, 16 Feb 2015 15:00:50 +0000 (16:00 +0100)
committerprsnko <Dmitri.Peressounko@cern.ch>
Mon, 16 Feb 2015 15:02:27 +0000 (16:02 +0100)
PHOS/PHOSUtils/AliPHOSGeoUtils.cxx
PHOS/PHOSUtils/AliPHOSGeoUtils.h
PHOS/PHOSbase/AliPHOSDigitizer.cxx
PHOS/PHOSbase/AliPHOSGeometry.cxx
PHOS/PHOSbase/AliPHOSReconstructor.cxx
PHOS/PHOSsim/AliPHOSv0.cxx
PHOS/PHOSsim/AliPHOSv0.h
PHOS/PHOSsim/AliPHOSv1.cxx

index a6b1e12..1dfab20 100644 (file)
@@ -171,11 +171,10 @@ AliPHOSGeoUtils::~AliPHOSGeoUtils(void)
   }
 
   for(Int_t mod=0; mod<5; mod++){
-    delete fEMCMatrix[mod] ;
-    for(Int_t istrip=0; istrip<224; istrip++)
-      delete fStripMatrix[mod][istrip];
-    delete fCPVMatrix[mod];
-    delete fPHOSMatrix[mod];
+     if(fPHOSMatrix[mod]){
+      delete fPHOSMatrix[mod];
+      fPHOSMatrix[mod]=0x0 ;
+    }
   }
 }
 //____________________________________________________________________________
@@ -548,12 +547,15 @@ const TGeoHMatrix * AliPHOSGeoUtils::GetMatrixForModule(Int_t mod)const {
     char path[255] ;
     snprintf(path,255,"/ALIC_1/PHOS_%d/PEMC_1/PCOL_1/PTIO_1/PCOR_1/PAGA_1/PTII_1",mod) ;
     //    sprintf(path,"/ALIC_1/PHOS_%d",relid[0]) ;
-    if (!gGeoManager->CheckPath(path)){
-//Try half-mod name      
-      snprintf(path,255,"/ALIC_1/PHOH_%d/PEMH_1/PCLH_1/PIOH_1/PCOH_1/PAGH_1/PTIH_1",mod) ;
+    if (!gGeoManager->CheckPath(path)){ //Module with CPV
+      snprintf(path,255,"/ALIC_1/PHOC_%d/PEMC_1/PCOL_1/PTIO_1/PCOR_1/PAGA_1/PTII_1",mod) ;
       if (!gGeoManager->CheckPath(path)){
-        AliWarning(Form("Geo manager can not find path %s \n",path));
-        return 0;
+        //Try half-mod name      
+        snprintf(path,255,"/ALIC_1/PHOH_%d/PEMH_1/PCLH_1/PIOH_1/PCOH_1/PAGH_1/PTIH_1",mod) ;
+        if (!gGeoManager->CheckPath(path)){
+          AliWarning(Form("Geo manager can not find path %s \n",path));
+          return 0;
+       }
       }
     }
     gGeoManager->cd(path) ;
@@ -579,12 +581,15 @@ const TGeoHMatrix * AliPHOSGeoUtils::GetMatrixForStrip(Int_t mod, Int_t strip)co
   if(gGeoManager){
     char path[255] ;
     snprintf(path,255,"/ALIC_1/PHOS_%d/PEMC_1/PCOL_1/PTIO_1/PCOR_1/PAGA_1/PTII_1/PSTR_%d",mod,strip) ;
-    if (!gGeoManager->CheckPath(path)){
-      //Look for half-module path
-      snprintf(path,255,"/ALIC_1/PHOH_%d/PEMH_1/PCLH_1/PIOH_1/PCOH_1/PAGH_1/PTIH_1/PSTR_%d",mod,strip) ;
-      if (!gGeoManager->CheckPath(path)){    
-        AliWarning(Form("Geo manager can not find path %s \n",path));
-        return 0 ;
+    if (!gGeoManager->CheckPath(path)){ //Test module with CPV
+      snprintf(path,255,"/ALIC_1/PHOC_%d/PEMC_1/PCOL_1/PTIO_1/PCOR_1/PAGA_1/PTII_1/PSTR_%d",mod,strip) ;
+      if (!gGeoManager->CheckPath(path)){
+        //Look for half-module path
+        snprintf(path,255,"/ALIC_1/PHOH_%d/PEMH_1/PCLH_1/PIOH_1/PCOH_1/PAGH_1/PTIH_1/PSTR_%d",mod,strip) ;
+        if (!gGeoManager->CheckPath(path)){    
+          AliWarning(Form("Geo manager can not find path %s \n",path));
+          return 0 ;
+       }
       }
     }
     gGeoManager->cd(path) ;
@@ -610,7 +615,7 @@ const TGeoHMatrix * AliPHOSGeoUtils::GetMatrixForCPV(Int_t mod)const {
   if(gGeoManager){ 
     char path[255] ;
     //now apply possible shifts and rotations
-    snprintf(path,255,"/ALIC_1/PHOS_%d/PCPV_1",mod) ;
+    snprintf(path,255,"/ALIC_1/PHOC_%d/PCPV_1",mod) ;
     if (!gGeoManager->CheckPath(path)){
       snprintf(path,255,"/ALIC_1/PHOH_%d/PCPV_1",mod) ;
       if (!gGeoManager->CheckPath(path)){
@@ -642,12 +647,14 @@ const TGeoHMatrix * AliPHOSGeoUtils::GetMatrixForPHOS(Int_t mod)const {
 
     char path[255] ;
     snprintf(path,255,"/ALIC_1/PHOS_%d",mod) ;
-  
-    if (!gGeoManager->CheckPath(path)){
-      snprintf(path,255,"/ALIC_1/PHOH_%d",mod) ;
-      if (!gGeoManager->CheckPath(path)){
-        AliWarning(Form("Geo manager can not find path %s \n",path));
-        return 0 ;
+    if (!gGeoManager->CheckPath(path)){ //Module with CPV
+      snprintf(path,255,"/ALIC_1/PHOC_%d",mod) ;
+      if (!gGeoManager->CheckPath(path)){ //1/2 module
+        snprintf(path,255,"/ALIC_1/PHOH_%d",mod) ;
+        if (!gGeoManager->CheckPath(path)){
+          AliWarning(Form("Geo manager can not find path %s \n",path));
+          return 0 ;
+       }
       }
     }
     gGeoManager->cd(path) ;
@@ -733,4 +740,18 @@ void AliPHOSGeoUtils::SetMisalMatrix(const TGeoHMatrix * m, Int_t mod){
   fCPVMatrix[mod]->SetTranslation(globCPV) ;
 
 }
+//____________________________________________________________________________ 
+void AliPHOSGeoUtils::TestSurvey(Int_t module, const Float_t *point, TVector3 &globaPos) const { 
+  //method used in PHOS alignment check
+  //Input is module number and point is Photogrammetry reference point wrt top right crystal
+  //output- point coordinates in ALICE global system
+  
+  Double_t x0=31.5*fCellStep;      //Number of crystals 
+  Double_t z0=26.5*fCellStep;  //from module center
+  Double_t posL[3]={-x0+point[0],-fCrystalShift-point[1],z0-point[2]} ; 
+  Double_t posG[3] ;
+  const TGeoHMatrix *mPHOS = GetMatrixForModule(module) ;
+  mPHOS->LocalToMaster(posL,posG);
+  globaPos.SetXYZ(posG[0],posG[1],posG[2]) ;
  
+}
\ No newline at end of file
index 7f6e74e..fdefac8 100644 (file)
@@ -51,7 +51,9 @@ public:
                                          // gets the position of element (pad or Xtal) relative to Alice
 
   void Local2Global(Int_t module, Float_t x, Float_t z, TVector3 &globaPos) const ;
-              
+
+  void TestSurvey(Int_t module, const Float_t *point, TVector3 &globaPos) const ; //method used in PHOS alignment check
+             
   void Global2Local(TVector3& localPosition,const TVector3& globalPosition,Int_t module) const ;
 
   Bool_t GlobalPos2RelId(TVector3 & global, Int_t * relId) ;
index da72758..b4c8270 100644 (file)
@@ -280,15 +280,24 @@ void AliPHOSDigitizer::Digitize(Int_t event)
   //Making digits with noise, first EMC
   //Check which PHOS modules are present
   Bool_t isPresent[5] ;
+  Bool_t isCPVpresent[5] ;
   TString volpath ;
   Int_t nmod=0 ;
+  Int_t nCPVmod=0 ;
   for(Int_t i=0; i<5; i++){
     isPresent[i]=0 ;
-    if (gGeoManager->CheckPath(Form("/ALIC_1/PHOS_%d",i+1))) {
+    isCPVpresent[i]=0 ;
+    if (gGeoManager->CheckPath(Form("/ALIC_1/PHOS_%d",i+1))) { //PHOS module without CPV
       isPresent[i]=1 ;
       nmod++ ;
     }
-    if (gGeoManager->CheckPath(Form("/ALIC_1/PHOH_%d",i+1))) {
+    if (gGeoManager->CheckPath(Form("/ALIC_1/PHOC_%d",i+1))) { //PHOS module with CPV
+      isPresent[i]=1 ;
+      isCPVpresent[i]=1 ;
+      nCPVmod++ ;
+      nmod++ ;
+    }
+    if (gGeoManager->CheckPath(Form("/ALIC_1/PHOH_%d",i+1))) { //1/2 PHOS module
       isPresent[i]=1 ;
       nmod++ ;
     }
@@ -298,24 +307,14 @@ void AliPHOSDigitizer::Digitize(Int_t event)
   
   Int_t nCPV ;
   Int_t absID ;
-  
-  //check if CPV exists
-  Bool_t isCPVpresent=0 ;
-  for(Int_t i=1; i<=5 && !isCPVpresent; i++){
-    volpath = "/ALIC_1/PHOS_";
-    volpath += i;
-    volpath += "/PCPV_1";
-    if (gGeoManager->CheckPath(volpath.Data())) 
-      isCPVpresent=1 ;
-  } 
-  
-  if(isCPVpresent){
-    nCPV = nEMC + geom->GetNumberOfCPVPadsZ() * geom->GetNumberOfCPVPadsPhi() * nmod ;
+    
+  if(nCPVmod){
+    nCPV = nEMC + geom->GetNumberOfCPVPadsZ() * geom->GetNumberOfCPVPadsPhi() * nCPVmod ;
   }
   else{
      nCPV = nEMC ;
-  }  
-
+  }    
+  
   digits->Expand(nCPV) ;
 
   //take all the inputs to add together and load the SDigits
@@ -385,6 +384,7 @@ void AliPHOSDigitizer::Digitize(Int_t event)
   if(toMakeNoise)
      apdNoise = AliPHOSSimParam::GetInstance()->GetAPDNoise() ; 
 
+  Int_t relId[4] ;
   Int_t emcpermod=geom->GetNPhi()*geom->GetNZ();
   Int_t idigit= 0;
   for(Int_t imod=0; imod<5; imod++){
@@ -393,6 +393,10 @@ void AliPHOSDigitizer::Digitize(Int_t event)
     Int_t firstAbsId=imod*emcpermod+1 ;
     Int_t lastAbsId =(imod+1)*emcpermod ; 
     for(absID = firstAbsId ; absID <= lastAbsId ; absID++){
+      //do not add digits to non-existing part of mod4
+      geom->AbsToRelNumbering(absID,relId) ;
+      if(relId[0]==4 && relId[2]<33) //This part of module does not exist
+       continue ;
       Float_t noise = gRandom->Gaus(0.,apdNoise) ; 
       new((*digits)[idigit]) AliPHOSDigit( -1, absID, noise, TimeOfNoise() ) ;
       //look if we have to add signal?
@@ -475,17 +479,20 @@ void AliPHOSDigitizer::Digitize(Int_t event)
     }
   }
 
+  Int_t nEMCcreated=idigit ;
 
   //Apply non-linearity
   if(AliPHOSSimParam::GetInstance()->IsCellNonlinearityOn()){ //Apply non-lineairyt on cell level
     const Double_t aNL = AliPHOSSimParam::GetInstance()->GetCellNonLineairyA() ;
     const Double_t bNL = AliPHOSSimParam::GetInstance()->GetCellNonLineairyB() ;
     const Double_t cNL = AliPHOSSimParam::GetInstance()->GetCellNonLineairyC() ;
-    for(Int_t i = 0 ; i < nEMC ; i++){
+    for(Int_t i = 0 ; i < nEMCcreated ; i++){
       digit = static_cast<AliPHOSDigit*>( digits->At(i) ) ;
-      Double_t e= digit->GetEnergy() ;
-      // version(1)      digit->SetEnergy(e*(1+a*TMath::Exp(-e/b))) ;
-      digit->SetEnergy(e*cNL*(1.+aNL*TMath::Exp(-e*e/2./bNL/bNL))) ; //Better agreement with data...
+      if(digit){ //if there is mod 4, there is a hole
+         Double_t e= digit->GetEnergy() ;
+         // version(1)      digit->SetEnergy(e*(1+a*TMath::Exp(-e/b))) ;
+         digit->SetEnergy(e*cNL*(1.+aNL*TMath::Exp(-e*e/2./bNL/bNL))) ; //Better agreement with data...
+      }
     }  
   }
 
@@ -493,16 +500,18 @@ void AliPHOSDigitizer::Digitize(Int_t event)
   //distretize energy if necessary
   if(AliPHOSSimParam::GetInstance()->IsEDigitizationOn()){
     Float_t adcW=AliPHOSSimParam::GetInstance()->GetADCchannelW() ;
-    for(Int_t i = 0 ; i < nEMC ; i++){                                                                                                       
+    for(Int_t i = 0 ; i < nEMCcreated ; i++){                                                                                                       
       digit = static_cast<AliPHOSDigit*>( digits->At(i) ) ;
-      digit->SetEnergy(adcW*ceil(digit->GetEnergy()/adcW)) ;
+      if(digit)
+        digit->SetEnergy(adcW*ceil(digit->GetEnergy()/adcW)) ;
     } 
   }
  
   //Apply decalibration if necessary
-  for(Int_t i = 0 ; i < nEMC ; i++){
+  for(Int_t i = 0 ; i < nEMCcreated ; i++){
     digit = static_cast<AliPHOSDigit*>( digits->At(i) ) ;
-    Decalibrate(digit) ;
+    if(digit)
+      Decalibrate(digit) ;
   }
   
 //  ticks->Delete() ;
@@ -512,10 +521,8 @@ void AliPHOSDigitizer::Digitize(Int_t event)
   Int_t cpvpermod = geom->GetNumberOfCPVPadsZ() * geom->GetNumberOfCPVPadsPhi() ;
   Int_t nEMCtotal=emcpermod*5 ;
   Float_t cpvNoise = AliPHOSSimParam::GetInstance()->GetCPVNoise() ;
-  if(isCPVpresent){  //CPV is present in current geometry
-    for(Int_t imod=0; imod<5; imod++){ //module is present in current geometry
-      if(!isPresent[imod])
-        continue ;
+  for(Int_t imod=0; imod<5; imod++){ //module is present in current geometry
+    if(isCPVpresent[imod]){  //CPV is present in current geometry
       Int_t firstAbsId=nEMCtotal+imod*cpvpermod+1 ;
       Int_t lastAbsId =nEMCtotal+(imod+1)*cpvpermod ;
       for(absID = firstAbsId; absID <= lastAbsId; absID++){
@@ -569,23 +576,27 @@ void AliPHOSDigitizer::Digitize(Int_t event)
 
   delete sdigArray ; //We should not delete its contents 
   
-  Int_t relId[4];
-
   //set amplitudes in bad channels to zero
+  
+  
 
-  for(Int_t i = 0 ; i <digits->GetEntriesFast(); i++){
+//  for(Int_t i = 0 ; i <digits->GetEntriesFast(); i++){
+  for(Int_t i = 0 ; i <nEMCcreated; i++){
     digit = static_cast<AliPHOSDigit*>( digits->At(i) ) ;
-    geom->AbsToRelNumbering(digit->GetId(),relId);
-    if(relId[1] == 0){ // Emc
-      if(fcdb->IsBadChannelEmc(relId[0],relId[3],relId[2])) digit->SetEnergy(0.); 
+    if(digit){
+      geom->AbsToRelNumbering(digit->GetId(),relId);
+      if(relId[1] == 0){ // Emc
+        if(fcdb->IsBadChannelEmc(relId[0],relId[3],relId[2])) digit->SetEnergy(0.); 
+      }
     }
   }
 
   //remove digits below thresholds
   Float_t emcThreshold = AliPHOSSimParam::GetInstance()->GetEmcDigitsThreshold() ;
-  for(Int_t i = 0 ; i < nEMC ; i++){
+  for(Int_t i = 0 ; i < nEMCcreated ; i++){
     digit = static_cast<AliPHOSDigit*>( digits->At(i) ) ;
-
+    if(!digit)
+      continue ;
     if(digit->GetEnergy() < emcThreshold){
       digits->RemoveAt(i) ;
       continue ;
@@ -609,8 +620,9 @@ void AliPHOSDigitizer::Digitize(Int_t event)
     digit->SetALTROSamplesLG(nSamples,fADCValuesLG);
   }
 
+  Int_t nCPVcreated=digits->GetEntriesFast() ;
   Float_t cpvDigitThreshold = AliPHOSSimParam::GetInstance()->GetCpvDigitsThreshold() ;
-  for(Int_t i = nEMC; i < nCPV ; i++){
+  for(Int_t i = nEMCcreated; i < nCPVcreated ; i++){
     if( static_cast<AliPHOSDigit*>(digits->At(i))->GetEnergy() < cpvDigitThreshold )
       digits->RemoveAt(i) ;
   } 
index 979139a..139c4bf 100644 (file)
@@ -252,9 +252,12 @@ void AliPHOSGeometry::GetGlobalPHOS(const AliPHOSRecPoint* recPoint, TVector3 &
   if(tmpPHOS->IsEmc()){
     snprintf(path,100,"/ALIC_1/PHOS_%d/PEMC_1/PCOL_1/PTIO_1/PCOR_1/PAGA_1/PTII_1",tmpPHOS->GetPHOSMod()) ;
     if (!gGeoManager->CheckPath(path)){
-      snprintf(path,100,"/ALIC_1/PHOH_%d/PEMH_1/PCLH_1/PIOH_1/PCOH_1/PAGH_1/PTIH_1",tmpPHOS->GetPHOSMod()) ;
-      if(!gGeoManager->CheckPath(path)){     
-        AliFatal("Geo manager can not find path \n");
+      snprintf(path,100,"/ALIC_1/PHOC_%d/PEMC_1/PCOL_1/PTIO_1/PCOR_1/PAGA_1/PTII_1",tmpPHOS->GetPHOSMod()) ;
+      if (!gGeoManager->CheckPath(path)){
+        snprintf(path,100,"/ALIC_1/PHOH_%d/PEMH_1/PCLH_1/PIOH_1/PCOH_1/PAGH_1/PTIH_1",tmpPHOS->GetPHOSMod()) ;
+        if(!gGeoManager->CheckPath(path)){     
+          AliFatal("Geo manager can not find path \n");
+       }
       }
     }
     gGeoManager->cd(path) ;
@@ -262,11 +265,11 @@ void AliPHOSGeometry::GetGlobalPHOS(const AliPHOSRecPoint* recPoint, TVector3 &
     dy=fCrystalShift ;
   }
   else{
-    snprintf(path,100,"/ALIC_1/PHOS_%d/PCPV_1",tmpPHOS->GetPHOSMod());
+    snprintf(path,100,"/ALIC_1/PHOC_%d/PCPV_1",tmpPHOS->GetPHOSMod());
     if (!gGeoManager->CheckPath(path)){
       snprintf(path,100,"/ALIC_1/PHOH_%d/PCPV_1",tmpPHOS->GetPHOSMod());
       if (!gGeoManager->CheckPath(path))
-        AliFatal(Form("Geo manager can not find path /ALIC_1/PHOS(H)_%d/PCPV_1 \n",tmpPHOS->GetPHOSMod()));
+        AliFatal(Form("Geo manager can not find path /ALIC_1/PHOC(H)_%d/PCPV_1 \n",tmpPHOS->GetPHOSMod()));
     }
     gGeoManager->cd(path) ;
     m = gGeoManager->GetCurrentMatrix();
index 11405c8..7624e86 100644 (file)
@@ -577,21 +577,29 @@ void AliPHOSReconstructor::FillMisalMatrixes(AliESDEvent* esd)const{
   char path[255] ;
   TGeoHMatrix * m ;
   for(Int_t mod=0; mod<5; mod++){
-    snprintf(path,255,"/ALIC_1/PHOS_%d",mod+1) ; //In Geometry modules numbered 1,2,.,5
+    snprintf(path,255,"/ALIC_1/PHOS_%d",mod+1) ; //In Geometry modules numbered 1,2,.,5 without CPV
     if (gGeoManager->CheckPath(path)){
       gGeoManager->cd(path) ;
       m = gGeoManager->GetCurrentMatrix() ;
       esd->SetPHOSMatrix(new TGeoHMatrix(*m),mod) ;
     }
     else{
-      snprintf(path,255,"/ALIC_1/PHOH_%d",mod+1) ; //In Geometry modules numbered 1,2,.,5
+      snprintf(path,255,"/ALIC_1/PHOC_%d",mod+1) ; //In Geometry modules numbered 1,2,3 with CPV
       if (gGeoManager->CheckPath(path)){
         gGeoManager->cd(path) ;
         m = gGeoManager->GetCurrentMatrix() ;
         esd->SetPHOSMatrix(new TGeoHMatrix(*m),mod) ;
       }
       else{
-        esd->SetPHOSMatrix(NULL,mod) ;
+        snprintf(path,255,"/ALIC_1/PHOH_%d",mod+1) ; //In Geometry modules numbered 1,2,.,5
+        if (gGeoManager->CheckPath(path)){
+          gGeoManager->cd(path) ;
+          m = gGeoManager->GetCurrentMatrix() ;
+          esd->SetPHOSMatrix(new TGeoHMatrix(*m),mod) ;
+        }
+        else{
+          esd->SetPHOSMatrix(NULL,mod) ;
+        }
       }
     }
   }
index f408b00..3109514 100644 (file)
 ClassImp(AliPHOSv0)
 
 //____________________________________________________________________________
-AliPHOSv0::AliPHOSv0(const char *name, const char *title):
-  AliPHOS(name,title)
+AliPHOSv0::AliPHOSv0(const char *name, const char *title): 
+  AliPHOS(name,title),
+ fCreateCPV(kFALSE), 
+ fCreateHalfMod(kFALSE) 
 {
   // ctor : title is used to identify the layout
+  //Check possible configurations  
+  
+  for(Int_t mod=0; mod<6; mod++){
+    fActiveModule[mod]=kFALSE ;
+    fActiveCPV[mod]=kFALSE ;
+  }
+  //Default geometries
+  //for period 2009-2013
+  if(strstr(title,"Run1")!=0){
+    fCreateCPV=kFALSE ;
+    fCreateHalfMod=kFALSE;
+    fActiveModule[1]=kTRUE ;
+    fActiveModule[2]=kTRUE ;
+    fActiveModule[3]=kTRUE ;
+    //NO CPV in Run1   
+  }
+  else{
+    //for period 2015-2018
+    if(strstr(title,"Run2")!=0){
+      fCreateCPV=kTRUE ;
+      fCreateHalfMod=kTRUE;
+      fActiveModule[1]=kTRUE ;
+      fActiveModule[2]=kTRUE ;
+      fActiveModule[3]=kTRUE ;
+      fActiveModule[4]=kTRUE ;
+      fActiveCPV[3]=kTRUE ;
+    }
+    else{
+     //custom geometry can be set in form
+     //Modxxx_CPVyyy, where xxx- list of PHOS modules in geometry, yyy -list of modules with CPVallFront
+     Bool_t isOK=kFALSE ;
+     TString a(title); 
+     Int_t modPos=a.Index("Mod",0,TString::kIgnoreCase) ;
+     Int_t cpvPos=a.Index("CPV",0,TString::kIgnoreCase) ;
+     Int_t size = a.Sizeof() ;
+     Int_t modEnd=(cpvPos>modPos)?cpvPos:size ;
+     Int_t cpvEnd=(cpvPos>modPos)?size:modPos ;
+     for(Int_t mod=1; mod<6; mod++){
+       Int_t imod=a.Index(Form("%d",mod),modPos);
+       if(imod>modPos && imod<modEnd){
+         fActiveModule[mod]=kTRUE ;
+        isOK=kTRUE ;
+        if(mod==4)
+           fCreateHalfMod=kTRUE;
+       }
+       Int_t icpv=a.Index(Form("%d",mod),cpvPos);
+       if(icpv>cpvPos && icpv<cpvEnd){
+         fActiveCPV[mod]=kTRUE ;
+         fCreateCPV=kTRUE ;
+       }
+     }
+     if(!isOK){
+       AliFatal(Form("Unknown PHOS configuration: %s. Possible: 'Run1' for 2009-2013, 'Run2' for 2015-2018', 'Modxxx_CPVyyy' for castom",title)) ; 
+     }
+    }
+  }
+   
   GetGeometry() ; 
+
+  
 }
 
 //____________________________________________________________________________
@@ -136,14 +197,17 @@ void AliPHOSv0::CreateGeometry()
   // Create a PHOS module.
   
   TVirtualMC::GetMC()->Gsvolu("PHOS", "TRD1", idtmed[798], geom->GetPHOSParams(), 4) ;        
-  if(strstr(GetTitle(),"4")!=0 ){
+  if(fCreateHalfMod){
     TVirtualMC::GetMC()->Gsvolu("PHOH", "TRD1", idtmed[798], geom->GetPHOSParams(), 4) ;        
   }
+  if(fCreateCPV){
+    TVirtualMC::GetMC()->Gsvolu("PHOC", "TRD1", idtmed[798], geom->GetPHOSParams(), 4) ;             
+  }
   
   this->CreateGeometryforEMC() ; 
   //Should we create 4-th module
 
-  if (strstr(fTitle.Data(),"noCPV") == 0) 
+  if (fCreateCPV) 
     this->CreateGeometryforCPV() ;
   
   this->CreateGeometryforSupport() ; 
@@ -152,12 +216,10 @@ void AliPHOSv0::CreateGeometry()
   Int_t idrotm[99] ;
   Int_t iXYZ,iAngle;
   char im[5] ;
-  Bool_t anyModuleCreated=0 ;
   for (Int_t iModule = 0; iModule < 5 ; iModule++ ) {
     snprintf(im,5,"%d",iModule+1) ;
-    if(strstr(GetTitle(),im)==0 && strcmp(GetTitle(),"IHEP")!=0 && strcmp(GetTitle(),"noCPV")!=0)
+    if(!fActiveModule[iModule+1])
       continue ;
-    anyModuleCreated=1 ;
     Float_t angle[3][2];
     for (iXYZ=0; iXYZ<3; iXYZ++)
       for (iAngle=0; iAngle<2; iAngle++)
@@ -170,17 +232,21 @@ void AliPHOSv0::CreateGeometry()
     Float_t pos[3];
     for (iXYZ=0; iXYZ<3; iXYZ++)
       pos[iXYZ] = geom->GetModuleCenter(iModule,iXYZ);
-    if(iModule!=3)
-       TVirtualMC::GetMC()->Gspos("PHOS", iModule+1, "ALIC", pos[0], pos[1], pos[2],
-              idrotm[iModule], "ONLY") ;
-    else{
+    if(iModule==3){ //special 1/2 module
        TVirtualMC::GetMC()->Gspos("PHOH", iModule+1, "ALIC", pos[0], pos[1], pos[2],
               idrotm[iModule], "ONLY") ;
-printf("Added PHOS module 4.... \n") ;        
     }
+    else{
+      if(fActiveCPV[iModule+1]){ //use module with CPV
+        TVirtualMC::GetMC()->Gspos("PHOC", iModule+1, "ALIC", pos[0], pos[1], pos[2],
+              idrotm[iModule], "ONLY") ;
+      }
+      else{ //module wihtout CPV
+        TVirtualMC::GetMC()->Gspos("PHOS", iModule+1, "ALIC", pos[0], pos[1], pos[2],
+              idrotm[iModule], "ONLY") ;
+      }
+   }
   }
-  if(!anyModuleCreated)
-    AliError("No one PHOS module was created") ;
 }
 
 //____________________________________________________________________________
@@ -211,11 +277,6 @@ void AliPHOSv0::CreateGeometryforEMC()
   AliPHOSEMCAGeometry * emcg = geom->GetEMCAGeometry() ;
   Float_t par[4];
   Int_t  ipar;
-
-  Bool_t makeHalfMod=kFALSE ;
-  if(strstr(GetTitle(),"4")!=0 ){
-    makeHalfMod=kTRUE; 
-  }  
   
   // ======= Define the strip ===============
 
@@ -285,7 +346,7 @@ void AliPHOSv0::CreateGeometryforEMC()
   for (ipar=0; ipar<3; ipar++) par[ipar] = *(emcg->GetInnerThermoHalfSize() + ipar);
   TVirtualMC::GetMC()->Gsvolu("PTII", "BOX ", idtmed[706], par, 3) ;     
   
-  if(makeHalfMod)
+  if(fCreateHalfMod)
     TVirtualMC::GetMC()->Gsvolu("PTIH", "BOX ", idtmed[706], par, 3) ;     
     
   
@@ -304,13 +365,13 @@ void AliPHOSv0::CreateGeometryforEMC()
       nr++ ;
     }
   }
-  if(makeHalfMod){
+  if(fCreateHalfMod){
     nr = 1 ;
     for(irow = 0; irow < emcg->GetNStripX(); irow ++){
       Float_t x = (2*irow + 1 - emcg->GetNStripX())* strip[0] ;
       for(icol = 0; icol < emcg->GetNStripZ(); icol ++){
         z = (2*icol + 1 - emcg->GetNStripZ()) * strip[2] ;
-       if(irow>emcg->GetNStripX()/2)
+       if(irow>=emcg->GetNStripX()/2)
           TVirtualMC::GetMC()->Gspos("PSTR", nr, "PTIH", x, y, z, 0, "ONLY") ;
         nr++ ;
       }
@@ -320,33 +381,33 @@ void AliPHOSv0::CreateGeometryforEMC()
   // ------- define the air gap between thermoinsulation and cooler
   for (ipar=0; ipar<3; ipar++) par[ipar] = *(emcg->GetAirGapHalfSize() + ipar);
   TVirtualMC::GetMC()->Gsvolu("PAGA", "BOX ", idtmed[798], par, 3) ;   
-  if(makeHalfMod)
+  if(fCreateHalfMod)
     TVirtualMC::GetMC()->Gsvolu("PAGH", "BOX ", idtmed[798], par, 3) ;   
   const Float_t * agap = emcg->GetAirGapHalfSize() ;
   y = agap[1] - inthermo[1]  ;
   
   TVirtualMC::GetMC()->Gspos("PTII", 1, "PAGA", 0.0, y, 0.0, 0, "ONLY") ;
-  if(makeHalfMod)
+  if(fCreateHalfMod)
     TVirtualMC::GetMC()->Gspos("PTIH", 1, "PAGH", 0.0, y, 0.0, 0, "ONLY") ;
 
 
   // ------- define the Al passive cooler 
   for (ipar=0; ipar<3; ipar++) par[ipar] = *(emcg->GetCoolerHalfSize() + ipar);
   TVirtualMC::GetMC()->Gsvolu("PCOR", "BOX ", idtmed[701], par, 3) ;   
-  if(makeHalfMod)
+  if(fCreateHalfMod)
     TVirtualMC::GetMC()->Gsvolu("PCOH", "BOX ", idtmed[701], par, 3) ;   
 
   const Float_t * cooler = emcg->GetCoolerHalfSize() ;
   y = cooler[1] - agap[1]  ;
   
   TVirtualMC::GetMC()->Gspos("PAGA", 1, "PCOR", 0.0, y, 0.0, 0, "ONLY") ;
-  if(makeHalfMod)
+  if(fCreateHalfMod)
     TVirtualMC::GetMC()->Gspos("PAGH", 1, "PCOH", 0.0, y, 0.0, 0, "ONLY") ;
   
   // ------- define the outer thermoinsulating cover
   for (ipar=0; ipar<4; ipar++) par[ipar] = *(emcg->GetOuterThermoParams() + ipar);
   TVirtualMC::GetMC()->Gsvolu("PTIO", "TRD1", idtmed[706], par, 4) ;        
-  if(makeHalfMod)
+  if(fCreateHalfMod)
     TVirtualMC::GetMC()->Gsvolu("PIOH", "TRD1", idtmed[706], par, 4) ;        
   const Float_t * outparams = emcg->GetOuterThermoParams() ; 
   
@@ -356,19 +417,19 @@ void AliPHOSv0::CreateGeometryforEMC()
   
   z = outparams[3] - cooler[1] ;
   TVirtualMC::GetMC()->Gspos("PCOR", 1, "PTIO", 0., 0.0, z, idrotm[1], "ONLY") ;
-  if(makeHalfMod)
+  if(fCreateHalfMod)
     TVirtualMC::GetMC()->Gspos("PCOH", 1, "PIOH", 0., 0.0, z, idrotm[1], "ONLY") ;
   
   // -------- Define the outer Aluminium cover -----
   for (ipar=0; ipar<4; ipar++) par[ipar] = *(emcg->GetAlCoverParams() + ipar);
   TVirtualMC::GetMC()->Gsvolu("PCOL", "TRD1", idtmed[701], par, 4) ;        
-  if(makeHalfMod)
+  if(fCreateHalfMod)
     TVirtualMC::GetMC()->Gsvolu("PCLH", "TRD1", idtmed[701], par, 4) ;        
 
   const Float_t * covparams = emcg->GetAlCoverParams() ; 
   z = covparams[3] - outparams[3] ;  
   TVirtualMC::GetMC()->Gspos("PTIO", 1, "PCOL", 0., 0.0, z, 0, "ONLY") ;
-  if(makeHalfMod)
+  if(fCreateHalfMod)
     TVirtualMC::GetMC()->Gspos("PIOH", 1, "PCLH", 0., 0.0, z, 0, "ONLY") ;
 
   // --------- Define front fiberglass cover -----------
@@ -376,7 +437,7 @@ void AliPHOSv0::CreateGeometryforEMC()
   TVirtualMC::GetMC()->Gsvolu("PFGC", "BOX ", idtmed[717], par, 3) ;  
   z = - outparams[3] ;
   TVirtualMC::GetMC()->Gspos("PFGC", 1, "PCOL", 0., 0.0, z, 0, "ONLY") ;
-  if(makeHalfMod)
+  if(fCreateHalfMod)
     TVirtualMC::GetMC()->Gspos("PFGC", 1, "PCLH", 0., 0.0, z, 0, "ONLY") ;
 
   //=============This is all with cold section==============
@@ -472,23 +533,26 @@ void AliPHOSv0::CreateGeometryforEMC()
   // Define the EMC module volume and combine Cool and Warm sections  
   for (ipar=0; ipar<4; ipar++) par[ipar] = *(emcg->GetEMCParams() + ipar);
   TVirtualMC::GetMC()->Gsvolu("PEMC", "TRD1", idtmed[798], par, 4) ;        
-  if(makeHalfMod)
+  if(fCreateHalfMod)
     TVirtualMC::GetMC()->Gsvolu("PEMH", "TRD1", idtmed[798], par, 4) ;        
   z =  - warmcov[2] ;
   TVirtualMC::GetMC()->Gspos("PCOL", 1, "PEMC",  0., 0., z, 0, "ONLY") ;
-  if(makeHalfMod)
+  if(fCreateHalfMod)
     TVirtualMC::GetMC()->Gspos("PCLH", 1, "PEMH",  0., 0., z, 0, "ONLY") ;
   z = covparams[3] ;
   TVirtualMC::GetMC()->Gspos("PWAR", 1, "PEMC",  0., 0., z, 0, "ONLY") ;
-  if(makeHalfMod)
+  if(fCreateHalfMod)
     TVirtualMC::GetMC()->Gspos("PWAR", 1, "PEMH",  0., 0., z, 0, "ONLY") ;
   
   
   // Put created EMC geometry into PHOS volume
   
   z = geom->GetCPVBoxSize(1) / 2. ;
+  //normal PHOS module
   TVirtualMC::GetMC()->Gspos("PEMC", 1, "PHOS", 0., 0., z, 0, "ONLY") ; 
-  if(makeHalfMod)
+  if(fCreateCPV) //Module with CPV 
+    TVirtualMC::GetMC()->Gspos("PEMC", 1, "PHOC", 0., 0., z, 0, "ONLY") ;   
+  if(fCreateHalfMod) //half of PHOS module
     TVirtualMC::GetMC()->Gspos("PEMH", 1, "PHOH", 0., 0., z, 0, "ONLY") ; 
   
 }
@@ -496,6 +560,9 @@ void AliPHOSv0::CreateGeometryforEMC()
 //____________________________________________________________________________
 void AliPHOSv0::CreateGeometryforCPV()
 {
+  
+printf("Create CPV geometry \n") ;  
+  
   // Create the PHOS-CPV geometry for GEANT
   // Author: Yuri Kharlov 11 September 2000
   //BEGIN_HTML
@@ -554,7 +621,7 @@ void AliPHOSv0::CreateGeometryforCPV()
   Int_t rotm ;
   AliMatrix(rotm, 90.,0., 0., 0., 90., 90.) ;
 
-  TVirtualMC::GetMC()->Gspos("PCPV", 1, "PHOS", 0.0, 0.0, z, rotm, "ONLY") ; 
+  TVirtualMC::GetMC()->Gspos("PCPV", 1, "PHOC", 0.0, 0.0, z, rotm, "ONLY") ; 
   
   // Gassiplex board
   
@@ -786,19 +853,21 @@ void AliPHOSv0::AddAlignableVolumes() const
   Int_t modUID, modnum = 0;
   TString physModulePath="/ALIC_1/PHOS_";
   TString physModulePath2="/ALIC_1/PHOH_";
+  TString physModulePath3="/ALIC_1/PHOC_";
   TString symbModuleName="PHOS/Module";
   Int_t nModules = GetGeometry()->GetNModules();
   
-  char im[5] ;
   for(Int_t iModule=1; iModule<=nModules; iModule++){
-    snprintf(im,5,"%d",iModule) ;
-    modUID = AliGeomManager::LayerToVolUID(idPHOS1,modnum++);
-    if(strstr(GetTitle(),im)==0 && strcmp(GetTitle(),"IHEP")!=0 && strcmp(GetTitle(),"noCPV")!=0)
+    if(!fActiveModule[iModule])
       continue ;
-    if(iModule!=4)
-      volpath = physModulePath;
-    else
+    modUID = AliGeomManager::LayerToVolUID(idPHOS1,iModule-1);
+     if(iModule==4)
       volpath = physModulePath2;
+    else
+      if(fActiveCPV[iModule])
+        volpath = physModulePath3;
+      else
+        volpath = physModulePath;      
     volpath += iModule;
     //    volpath += "/PEMC_1/PCOL_1/PTIO_1/PCOR_1/PAGA_1/PTII_1";
  
@@ -830,13 +899,10 @@ void AliPHOSv0::AddAlignableVolumes() const
   symbModuleName="PHOS/Module";
   modnum=0;
   for(Int_t iModule=1; iModule<=nModules; iModule++){
-    if(strstr(GetTitle(),"noCPV"))
-      continue ;
-    snprintf(im,5,"%d",iModule) ;
-    modUID = AliGeomManager::LayerToVolUID(idPHOS2,modnum++);
-    if(strstr(GetTitle(),im)==0 && strcmp(GetTitle(),"IHEP")!=0)
+    if(!fActiveCPV[iModule])
       continue ;
-    volpath = physModulePath;
+    modUID = AliGeomManager::LayerToVolUID(idPHOS2,iModule-1);
+    volpath = physModulePath3;
     volpath += iModule;
     volpath += "/PCPV_1";
     // Check the volume path
index d3fe3ef..5f1611a 100644 (file)
@@ -73,7 +73,15 @@ class AliPHOSv0 : public AliPHOS {
   AliPHOSv0(AliPHOSv0 & phos);
   AliPHOSv0 & operator = (const AliPHOSv0 & /*rvalue*/);
 
-  ClassDef(AliPHOSv0,1)  // Implementation of PHOS manager class for layout EMC+PPSD
+ protected:  
+  Bool_t fCreateCPV ;         //Should we create module with CPV
+  Bool_t fCreateHalfMod ;     //Should we create  1/2 filled module 
+  Bool_t fActiveModule[6] ;   //list of modules to create
+  Bool_t fActiveCPV[6] ;      //list of modules with CPV
+
+ private:
+  
+  ClassDef(AliPHOSv0,2)  // Implementation of PHOS manager class for layout EMC+PPSD
     
     };
     
index 655ed8d..fe7de24 100644 (file)
@@ -187,7 +187,7 @@ void AliPHOSv1::StepManager(void)
   Int_t moduleNumber ;
   
   static Int_t idPCPQ = -1;
-  if (strstr(fTitle.Data(),"noCPV") == 0) 
+  if (fCreateCPV) 
     idPCPQ = TVirtualMC::GetMC()->VolId("PCPQ");
 
   if( TVirtualMC::GetMC()->CurrentVolID(copy) == idPCPQ &&