Add separate time calibration for PHOS low gain channel
authorprsnko <prsnko@f7af4fe6-9843-0410-8265-dc069ae4e863>
Thu, 29 Nov 2012 07:17:32 +0000 (07:17 +0000)
committerprsnko <prsnko@f7af4fe6-9843-0410-8265-dc069ae4e863>
Thu, 29 Nov 2012 07:17:32 +0000 (07:17 +0000)
PHOS/AliPHOSCalibData.cxx
PHOS/AliPHOSCalibData.h
PHOS/AliPHOSClusterizerv1.cxx
PHOS/AliPHOSClusterizerv1.h
PHOS/AliPHOSDigit.cxx
PHOS/AliPHOSDigit.h
PHOS/AliPHOSEmcCalibData.cxx
PHOS/AliPHOSRawDigiProducer.cxx
PHOS/AliPHOSReconstructor.cxx
PHOS/AliPHOSReconstructor.h

index 7a7226f..65acd6f 100644 (file)
@@ -317,9 +317,34 @@ Float_t AliPHOSCalibData::GetTimeShiftEmc(Int_t module, Int_t column, Int_t row)
   if(fCalibDataEmc)
     return fCalibDataEmc->GetTimeShiftEmc(module,column,row);
   else
-    return 1.0; // default width of one EMC ADC channel in GeV
+    return 0.0; // by default no offset
 }
+//________________________________________________________________
+Float_t AliPHOSCalibData::GetLGTimeShiftEmc(Int_t module, Int_t column, Int_t row) const
+{ 
+  // Return EMC calibration coefficient 
+  // for channel defined by (module,column,row)                                
+  // module, column,raw should follow the internal PHOS convention:            
+  // module 1:5, column 1:56, row 1:64 
+  // if CBD instance exists, the value is taken from CDB. 
+  // Otherwise it is an ideal one  
+  
+  if(fCalibDataEmc)
+    return fCalibDataEmc->GetLGTimeShiftEmc(module,column,row);
+  else
+    return 0.0; // no offset by default
+}
+//________________________________________________________________
+void AliPHOSCalibData::SetLGTimeShiftEmc(Int_t module, Int_t column, Int_t row, Float_t value)
+{
+  // Set EMC calibration coefficient for (module,column,row)
  
+  if(!fCalibDataEmc)
+    fCalibDataEmc = new AliPHOSEmcCalibData("PHOS-EMC");
+  fCalibDataEmc->SetLGTimeShiftEmc(module,column,row,value);
+}
 //________________________________________________________________
 void AliPHOSCalibData::SetTimeShiftEmc(Int_t module, Int_t column, Int_t row, Float_t value)
 {
index cd79689..b8e235c 100644 (file)
@@ -51,6 +51,9 @@ class AliPHOSCalibData: public TNamed {
   Float_t GetTimeShiftEmc(Int_t module, Int_t column, Int_t row) const;
   void    SetTimeShiftEmc(Int_t module, Int_t column, Int_t row, Float_t value) ;
 
+  Float_t GetLGTimeShiftEmc(Int_t module, Int_t column, Int_t row) const;
+  void    SetLGTimeShiftEmc(Int_t module, Int_t column, Int_t row, Float_t value) ;
+
   Int_t  GetAltroOffsetEmc(Int_t module, Int_t column, Int_t row) const;
   void   SetAltroOffsetEmc(Int_t module, Int_t column, Int_t row, Int_t value) ;
 
index ecda67c..840ffd0 100644 (file)
@@ -606,7 +606,7 @@ void AliPHOSClusterizerv1::MakeClusters()
         fEMCRecPoints->AddAt(new  AliPHOSEmcRecPoint(""), fNumberOfEmcClusters) ;
         clu = static_cast<AliPHOSEmcRecPoint *>( fEMCRecPoints->At(fNumberOfEmcClusters) ) ; 
        fNumberOfEmcClusters++ ; 
-       clu->AddDigit(*digit, Calibrate(digit->GetEnergy(),digit->GetId()),CalibrateT(digit->GetTime(),digit->GetId())) ;
+       clu->AddDigit(*digit, Calibrate(digit->GetEnergy(),digit->GetId()),CalibrateT(digit->GetTime(),digit->GetId(),digit->IsLG())) ;
         clusterdigitslist[iDigitInCluster] = digit->GetIndexInList() ;
         iDigitInCluster++ ;
         fDigitsUsed[i]=kTRUE ; 
@@ -648,7 +648,7 @@ void AliPHOSClusterizerv1::MakeClusters()
           case 0 :   // not a neighbour
             break ;
           case 1 :   // are neighbours 
-           clu->AddDigit(*digitN, Calibrate(digitN->GetEnergy(),digitN->GetId()),CalibrateT(digitN->GetTime(),digitN->GetId())) ;
+           clu->AddDigit(*digitN, Calibrate(digitN->GetEnergy(),digitN->GetId()),CalibrateT(digitN->GetTime(),digitN->GetId(),digit->IsLG())) ;
             clusterdigitslist[iDigitInCluster] = j ; 
             iDigitInCluster++ ; 
             fDigitsUsed[j]=kTRUE ;
@@ -862,7 +862,7 @@ void  AliPHOSClusterizerv1::UnfoldCluster(AliPHOSEmcRecPoint * iniEmc,
 //      ratio = epar * ShowerShape(xDigit - xpar,zDigit - zpar,vIncid) / efit[iDigit] ; 
       ratio = epar * ShowerShape(xDigit - xpar,zDigit - zpar) / efit[iDigit] ; 
       eDigit = emcEnergies[iDigit] * ratio ;
-      emcRP->AddDigit( *digit, eDigit,CalibrateT(digit->GetTime(),digit->GetId()) ) ;
+      emcRP->AddDigit( *digit, eDigit,CalibrateT(digit->GetTime(),digit->GetId(),digit->IsLG()) ) ;
     }        
   }
  
@@ -1139,7 +1139,7 @@ Float_t AliPHOSClusterizerv1::Calibrate(Float_t amp, Int_t absId) const{
   }
 }
 //==================================================================================
-Float_t AliPHOSClusterizerv1::CalibrateT(Float_t time, Int_t absId)const{
+Float_t AliPHOSClusterizerv1::CalibrateT(Float_t time, Int_t absId,Bool_t isLG)const{
   // Calibrate time in EMC digit
 
   const AliPHOSGeometry *geom = AliPHOSGeometry::GetInstance() ;
@@ -1154,7 +1154,10 @@ Float_t AliPHOSClusterizerv1::CalibrateT(Float_t time, Int_t absId)const{
     return 0. ;
   }
   else{ //EMC
-    time += fgCalibData->GetTimeShiftEmc(module,column,row);
+    if(isLG)
+      time += fgCalibData->GetLGTimeShiftEmc(module,column,row);
+    else
+      time += fgCalibData->GetTimeShiftEmc(module,column,row);
     return time ;
   }
 }
index 2892832..1e5d831 100644 (file)
@@ -123,7 +123,7 @@ protected:
   void           CleanDigits(TClonesArray * digits) ;
   void           SetDistancesToBadChannels();
   virtual Float_t Calibrate(Float_t amp, Int_t absId) const ;  // Tranforms ADC counts to energy   
-  virtual Float_t CalibrateT(Float_t amp, Int_t absId) const ;  //Tranforms Sample counts to sec.
+  virtual Float_t CalibrateT(Float_t amp, Int_t absId, Bool_t isLG) const ;  //Tranforms Sample counts to sec.
   Bool_t CheckTimeGate(Float_t t1, Float_t amp1, Float_t t2, Float_t amp2)const ; //Checks if time difference is reasonable
    
 private:
index 2ec6c67..8defc4d 100644 (file)
@@ -56,6 +56,7 @@ ClassImp(AliPHOSDigit)
 //____________________________________________________________________________
 AliPHOSDigit::AliPHOSDigit() :
   AliDigitNew(),
+  fIsLG(0),
   fNprimary(0),  
   fPrimary(0x0),
   fEnergy(0.),
@@ -71,6 +72,7 @@ AliPHOSDigit::AliPHOSDigit() :
 
 //____________________________________________________________________________
 AliPHOSDigit::AliPHOSDigit(Int_t primary, Int_t id, Int_t digEnergy, Float_t time, Int_t index) :
+  fIsLG(0),
   fNprimary(0),
   fPrimary(0),
   fEnergy(0.f),
@@ -89,6 +91,7 @@ AliPHOSDigit::AliPHOSDigit(Int_t primary, Int_t id, Int_t digEnergy, Float_t tim
   fTimeR       = fTime ;
   fId          = id ;
   fIndexInList = index ; 
+
   if( primary != -1){
     fNprimary    = 1 ; 
     fPrimary = new Int_t[fNprimary] ;
@@ -102,6 +105,7 @@ AliPHOSDigit::AliPHOSDigit(Int_t primary, Int_t id, Int_t digEnergy, Float_t tim
 
 //____________________________________________________________________________
 AliPHOSDigit::AliPHOSDigit(Int_t primary, Int_t id, Float_t energy, Float_t time, Int_t index) :
+  fIsLG(0),
   fNprimary(0),
   fPrimary(0),
   fEnergy(0.f),
@@ -135,6 +139,7 @@ AliPHOSDigit::AliPHOSDigit(Int_t primary, Int_t id, Float_t energy, Float_t time
 AliPHOSDigit::AliPHOSDigit(const AliPHOSDigit & digit) : 
   AliDigitNew(digit),
   fNprimary(digit.fNprimary),
+  fIsLG(digit.fIsLG),
   fPrimary(0),
   fEnergy(digit.fEnergy),
   fTime(digit.fTime),
@@ -344,6 +349,9 @@ AliPHOSDigit& AliPHOSDigit::operator+=(AliPHOSDigit const & digit)
      for (i=0; i<fNSamplesLG; i++)
        fSamplesLG[i] = TMath::Max(1023,fSamplesLG[i] + (digit.fSamplesLG)[i]);
    }
+   
+   //If at least one digit in LG, then sum also
+   fIsLG=fIsLG||digit.fIsLG ;
 
    return *this ;
 }
index 08cc588..d6bdf4a 100644 (file)
@@ -67,6 +67,7 @@ public:
   UShort_t *GetSamplesHG()          const {return fSamplesHG;}
   UShort_t *GetSamplesLG()          const {return fSamplesLG;}
   Bool_t    IsSortable()            const { return kTRUE ; }
+  Bool_t    IsLG()                  const {return fIsLG ;}
   void      Print(const Option_t * = "") const;
   void      SetAmp(Int_t Amp)      {fAmp   = Amp  ;} 
   void      SetEnergy(Float_t E)   {fEnergy= E    ;} 
@@ -75,12 +76,12 @@ public:
   void      SetALTROSamplesHG(Int_t nSamplesHG, Int_t *samplesHG);
   void      SetALTROSamplesLG(Int_t nSamplesLG, Int_t *samplesLG);
   void      ShiftPrimary(Int_t shift); // shift to separate different TreeK in merging
-
+  void      SetLG(Bool_t inLG){fIsLG=inLG;} //mark digits produced from LG when HG in overflow
 private:
   AliPHOSDigit & operator = (const AliPHOSDigit & /*digit*/);
 
 private:
-
+  Bool_t      fIsLG;       //If this digit created from HG or LG channels
   Int_t       fNprimary ;  // Number of primaries
   Int_t *     fPrimary ;   //[fNprimary] Array of primaries      
   Float_t     fEnergy ;    // Deposited energy in ADC counts
@@ -91,7 +92,7 @@ private:
   UShort_t   *fSamplesHG;  //[fNSamplesHG] Array of high-gain ALTRO samples
   UShort_t   *fSamplesLG;  //[fNSamplesLG] Array of low-gain  ALTRO samples
 
-  ClassDef(AliPHOSDigit,6) // Digit in PHOS 
+  ClassDef(AliPHOSDigit,7) // Digit in PHOS 
 
 } ;
 
index a3cdc62..0fc34f2 100644 (file)
@@ -61,6 +61,7 @@ AliPHOSEmcCalibData::AliPHOSEmcCalibData(const AliPHOSEmcCalibData& calibda) :
        fADCpedestalEmc[module][column][row] = calibda.fADCpedestalEmc[module][column][row];
        fHighLowRatioEmc[module][column][row] = calibda.fHighLowRatioEmc[module][column][row];
        fTimeShiftEmc[module][column][row] = calibda.fTimeShiftEmc[module][column][row];
+       fLGTimeShiftEmc[module][column][row] = calibda.fLGTimeShiftEmc[module][column][row];
         fAltroOffsets[module][column][row] = calibda.fAltroOffsets[module][column][row];
        fDecal[module][column][row]        = calibda.fDecal[module][column][row];
       }
@@ -85,6 +86,7 @@ AliPHOSEmcCalibData &AliPHOSEmcCalibData::operator =(const AliPHOSEmcCalibData&
          fADCpedestalEmc[module][column][row] = calibda.fADCpedestalEmc[module][column][row];
          fHighLowRatioEmc[module][column][row] = calibda.fHighLowRatioEmc[module][column][row];
          fTimeShiftEmc[module][column][row] = calibda.fTimeShiftEmc[module][column][row];
+         fLGTimeShiftEmc[module][column][row] = calibda.fLGTimeShiftEmc[module][column][row];
           fAltroOffsets[module][column][row] = calibda.fAltroOffsets[module][column][row];
          fDecal[module][column][row]        = calibda.fDecal[module][column][row];
        }
@@ -113,6 +115,7 @@ void AliPHOSEmcCalibData::Reset()
        fADCchannelEmc[module][column][row]  = 0.005;
        fHighLowRatioEmc[module][column][row] = 16. ;
        fTimeShiftEmc[module][column][row] = 0. ;
+       fLGTimeShiftEmc[module][column][row] = 0. ;
         fAltroOffsets[module][column][row] = 0 ;
        fDecal[module][column][row] = 1.;
       }
@@ -170,7 +173,7 @@ void  AliPHOSEmcCalibData::Print(Option_t *option) const
       printf("============== Module %d\n",module+1);
       for (Int_t column=0; column<56; column++){
        for (Int_t row=0; row<64; row++){
-         printf("%6.3e",fTimeShiftEmc[module][column][row]);
+         printf("%6.3e (%6.3e)",fTimeShiftEmc[module][column][row],fLGTimeShiftEmc[module][column][row]);
        }
        printf("\n");
       }
@@ -223,13 +226,22 @@ Float_t AliPHOSEmcCalibData::GetHighLowRatioEmc(Int_t module, Int_t column, Int_
 //________________________________________________________________
 Float_t AliPHOSEmcCalibData::GetTimeShiftEmc(Int_t module, Int_t column, Int_t row) const
 {
-  //Return EMC pedestal
+  //Return EMC time offset for high gain channel
   //module, column,raw should follow the internal PHOS convention:
   //module 1:5, column 1:56, row 1:64
 
   return fTimeShiftEmc[module-1][column-1][row-1];
 }
 //________________________________________________________________
+Float_t AliPHOSEmcCalibData::GetLGTimeShiftEmc(Int_t module, Int_t column, Int_t row) const
+{
+  //Return EMC time offset for LowGain channel
+  //module, column,raw should follow the internal PHOS convention:
+  //module 1:5, column 1:56, row 1:64
+
+  return fLGTimeShiftEmc[module-1][column-1][row-1];
+}
+//________________________________________________________________
 Float_t AliPHOSEmcCalibData::GetSampleTimeStep()const
 {
    //Returns conversion coefficient from ALTRO smaple time step and secods
@@ -276,12 +288,20 @@ void AliPHOSEmcCalibData::SetHighLowRatioEmc(Int_t module, Int_t column, Int_t r
 //________________________________________________________________
 void AliPHOSEmcCalibData::SetTimeShiftEmc(Int_t module, Int_t column, Int_t row, Float_t value)
 {
-  //Set EMC pedestal
+  //Set EMC time offset for high gain channel
   //module, column,raw should follow the internal PHOS convention:
   //module 1:5, column 1:56, row 1:64
   fTimeShiftEmc[module-1][column-1][row-1] = value;
 }
 //________________________________________________________________
+void AliPHOSEmcCalibData::SetLGTimeShiftEmc(Int_t module, Int_t column, Int_t row, Float_t value)
+{
+  //Set EMC time offset for low gain channel
+  //module, column,raw should follow the internal PHOS convention:
+  //module 1:5, column 1:56, row 1:64
+  fLGTimeShiftEmc[module-1][column-1][row-1] = value;
+}
+//________________________________________________________________
 void AliPHOSEmcCalibData::SetAltroOffsetEmc(Int_t module, Int_t column, Int_t row, Int_t value)
 {
   //Set EMC pedestal
index 5240912..6607464 100644 (file)
@@ -310,6 +310,7 @@ void AliPHOSRawDigiProducer::MakeDigits(TClonesArray *digits, TClonesArray *tmpD
        if(digHG->GetEnergy()<0.){ //This is overflow in HG
          digHG->SetTime(digLG->GetTime()) ;
          digHG->SetEnergy(digLG->GetEnergy()) ;
+         digHG->SetLG(kTRUE) ;
        }
       }
       else{ //no pair - remove
index 990c551..468e417 100644 (file)
@@ -272,9 +272,14 @@ void AliPHOSReconstructor::FillESD(TTree* digitsTree, TTree* clustersTree,
     const AliPHOSDigit * dig = (const AliPHOSDigit*)fgDigitsArray->At(idig);
     if(dig->GetId() <= knEMC && 
        Calibrate(dig->GetEnergy(),dig->GetId()) > GetRecoParam()->GetEMCMinE() ){
+      Int_t primary = dig->GetPrimary(1) ;
+      //For real data always primary==-1, we use this field to mark cells with overflow
+      //in HG channel. This is not needed in MC simulations,
+      if(primary==-1 && dig->IsLG())
+       primary=-2 ;
       phsCells.SetCell(idignew,dig->GetId(), Calibrate(dig->GetEnergy(),dig->GetId()),
-                                             CalibrateT(dig->GetTime(),dig->GetId()),
-                                             dig->GetPrimary(1)) ;
+                                             CalibrateT(dig->GetTime(),dig->GetId(),dig->IsLG()),
+                                             primary) ;
       idignew++;
     }
   }
@@ -510,7 +515,7 @@ Float_t AliPHOSReconstructor::Calibrate(Float_t amp, Int_t absId)const{
   }
 }
 //==================================================================================
-Float_t AliPHOSReconstructor::CalibrateT(Float_t time, Int_t absId)const{
+Float_t AliPHOSReconstructor::CalibrateT(Float_t time, Int_t absId,Bool_t isLG)const{
   // Calibrate EMC digit, i.e. multiply its Amp by a factor read from CDB
 
   const AliPHOSGeometry *geom = AliPHOSGeometry::GetInstance() ;
@@ -525,7 +530,10 @@ Float_t AliPHOSReconstructor::CalibrateT(Float_t time, Int_t absId)const{
     return 0. ;
   }
   else{ //EMC
-    time += fgCalibData->GetTimeShiftEmc(module,column,row);
+    if(isLG)
+      time += fgCalibData->GetLGTimeShiftEmc(module,column,row);
+    else
+      time += fgCalibData->GetTimeShiftEmc(module,column,row);
     return time ;
   }
 }
index cee0716..a2c881b 100644 (file)
@@ -85,7 +85,7 @@ public:
   virtual Bool_t             HasDigitConversion() const {return kTRUE;};
   virtual void               ConvertDigits(AliRawReader* rawReader, TTree* digitsTree) const;
   virtual Float_t            Calibrate(Float_t amp, Int_t absId) const ;
-  virtual Float_t            CalibrateT(Float_t time, Int_t absId) const ;
+  virtual Float_t            CalibrateT(Float_t time, Int_t absId, Bool_t isLG) const ;
 
   void FillMisalMatrixes(AliESDEvent* esd)const ;