Introduction of V0 equalization factors in the ESD and their filling inside the V0...
authorcvetan <cvetan@f7af4fe6-9843-0410-8265-dc069ae4e863>
Mon, 24 Oct 2011 09:57:41 +0000 (09:57 +0000)
committercvetan <cvetan@f7af4fe6-9843-0410-8265-dc069ae4e863>
Mon, 24 Oct 2011 09:57:41 +0000 (09:57 +0000)
STEER/ESD/AliESDEvent.cxx
STEER/ESD/AliESDEvent.h
STEER/ESD/AliESDRun.cxx
STEER/ESD/AliESDRun.h
VZERO/AliVZEROReconstructor.cxx
VZERO/AliVZEROReconstructor.h

index d4494a3..45a361d 100644 (file)
@@ -1856,3 +1856,21 @@ AliEventplane* AliESDEvent::GetEventplane()
     if (!fEventplane) fEventplane = new AliEventplane();
     return  fEventplane;
 }
+
+Float_t AliESDEvent::GetVZEROEqMultiplicity(Int_t i) const
+{
+  // Get VZERO Multiplicity for channel i
+  // Themethod uses the equalization factors
+  // stored in the ESD-run object in order to
+  // get equal multiplicities within a VZERO rins (1/8 of VZERO)
+  if (!fESDVZERO || !fESDRun) return -1;
+
+  Int_t ring = i/8;
+  Float_t factorSum = 0;
+  for(Int_t j = 8*ring; j < (8*ring+8); ++j) {
+    factorSum += fESDRun->GetVZEROEqFactors(j);
+  }
+  Float_t factor = fESDRun->GetVZEROEqFactors(i)*8./factorSum;
+
+  return (fESDVZERO->GetMultiplicity(i)/factor);
+}
index 50e7d1f..d3c756f 100644 (file)
@@ -144,7 +144,9 @@ public:
   void     SetEMCALMatrix(TGeoHMatrix*matrix, Int_t i) {if(fESDRun) fESDRun->SetEMCALMatrix(matrix,i);}
   const TGeoHMatrix* GetEMCALMatrix(Int_t i) const {return fESDRun?fESDRun->GetEMCALMatrix(i):0x0;}
   void     SetCaloTriggerType(const Int_t* type) {if (fESDRun) fESDRun->SetCaloTriggerType(type);}
-  Int_t*   GetCaloTriggerType() const {return fESDRun?fESDRun->GetCaloTriggerType():0x0;};
+  Int_t*   GetCaloTriggerType() const {return fESDRun?fESDRun->GetCaloTriggerType():0x0;}
+  const Float_t* GetVZEROEqFactors() const {return fESDRun?fESDRun->GetVZEROEqFactors():0x0;}
+  Float_t        GetVZEROEqMultiplicity(Int_t i) const;
        
   //
   void        SetCurrentL3(Float_t cur)           const  {if(fESDRun) fESDRun->SetCurrentL3(cur);}
@@ -162,6 +164,7 @@ public:
   //
   Bool_t      InitMagneticField()                 const  {return fESDRun?fESDRun->InitMagneticField():kFALSE;} 
   void      SetT0spread(Float_t *t)               const  {if(fESDRun) fESDRun->SetT0spread(t);} 
+  void      SetVZEROEqFactors(Float_t factors[64]) const {if(fESDRun) fESDRun->SetVZEROEqFactors(factors);}
   // HEADER
   AliESDHeader* GetHeader() const {return fHeader;}
 
index 12536e5..87af68f 100644 (file)
@@ -57,6 +57,7 @@ AliESDRun::AliESDRun() :
   for (Int_t sm=0; sm<kNEMCALMatrix; sm++) fEMCALMatrix[sm]=NULL;
   for (Int_t i=0; i<kT0spreadSize;i++) fT0spread[i]=0.;
   for (Int_t it=0; it<8; it++) fCaloTriggerType[it]=0;
+  for (Int_t j=0; j<64; ++j) fVZEROEqFactors[j]=-1;
 }
 
 //______________________________________________________________________________
@@ -102,6 +103,7 @@ AliESDRun::AliESDRun(const AliESDRun &esd) :
   }
   for (Int_t i=0; i<kT0spreadSize;i++) fT0spread[i]=esd.fT0spread[i];
   for (Int_t it=0; it<8; it++) fCaloTriggerType[it]=esd.fCaloTriggerType[it];
+  for (Int_t j=0; j<64; ++j) fVZEROEqFactors[j]=esd.fVZEROEqFactors[j];
 
 }
 
@@ -150,6 +152,7 @@ AliESDRun& AliESDRun::operator=(const AliESDRun &esd)
   } 
   for (Int_t i=0; i<kT0spreadSize;i++) fT0spread[i]=esd.fT0spread[i];
   for (Int_t it=0; it<8; it++) fCaloTriggerType[it]=esd.fCaloTriggerType[it];
+  for (Int_t j=0; j<64; ++j) fVZEROEqFactors[j]=esd.fVZEROEqFactors[j];
   return *this;
 }
 
index 96aa044..6f7e76c 100644 (file)
@@ -104,6 +104,10 @@ public:
   void       SetCaloTriggerType(const Int_t* in) {for (int i = 0; i < 8; i++) fCaloTriggerType[i] = in[i];}
   Int_t*     GetCaloTriggerType() {return fCaloTriggerType;}
 
+  void           SetVZEROEqFactors(Float_t factors[64]) {for (Int_t i = 0; i < 64; ++i) fVZEROEqFactors[i] = factors[i];}
+  const Float_t* GetVZEROEqFactors() const {return fVZEROEqFactors;}
+  Float_t        GetVZEROEqFactors(Int_t i) const {return fVZEROEqFactors[i];}
+
 private:
   Float_t         fCurrentL3;       // signed current in the L3     (LHC convention: +current -> +Bz)
   Float_t         fCurrentDip;      // signed current in the Dipole (LHC convention: +current -> -Bx)
@@ -125,8 +129,9 @@ private:
   TGeoHMatrix*    fEMCALMatrix[kNEMCALMatrix]; //EMCAL supermodule position and orientation matrices
   Float_t         fT0spread[kT0spreadSize];     // spread of time distributions on T0A, T0C, (T0A+T0C)/2, (T0A-T0C)/2
   Int_t           fCaloTriggerType[8]; // Calorimeter trigger type
+  Float_t         fVZEROEqFactors[64]; // V0 channel equalization factors for event-plane reconstruction
        
-  ClassDef(AliESDRun,11)
+  ClassDef(AliESDRun,12)
 };
 
 #endif 
index a53edcb..440db6e 100644 (file)
@@ -55,6 +55,7 @@ AliVZEROReconstructor:: AliVZEROReconstructor(): AliReconstructor(),
                         fTriggerData(NULL),
                         fTimeSlewing(NULL),
                         fSaturationCorr(NULL),
+                        fEqFactors(NULL),
                         fCollisionMode(0),
                         fBeamEnergy(0.),
                         fDigitsArray(0)
@@ -104,6 +105,10 @@ AliVZEROReconstructor:: AliVZEROReconstructor(): AliReconstructor(),
   AliCDBEntry *entry6 = AliCDBManager::Instance()->Get("VZERO/Trigger/Data");
   if (!entry6) AliFatal("VZERO trigger config data is not found in OCDB !");
   fTriggerData = (AliVZEROTriggerData*)entry6->GetObject();
+
+  AliCDBEntry *entry7 = AliCDBManager::Instance()->Get("VZERO/Calib/EqualizationFactors");
+  if (!entry7) AliFatal("VZERO equalization factors are not found in OCDB !");
+  fEqFactors = (TH1F*)entry7->GetObject();
 }
 
 
@@ -444,6 +449,20 @@ void AliVZEROReconstructor::FillESD(TTree* digitsTree, TTree* /*clustersTree*/,
   if (esd) { 
      AliDebug(1, Form("Writing VZERO data to ESD tree"));
      esd->SetVZEROData(fESDVZERO);
+     const AliESDRun *esdRun = esd->GetESDRun();
+     if (esdRun) {
+       Float_t factors[64];
+       Float_t factorSum = 0;
+       for(Int_t i = 0; i < 64; ++i) {
+        factors[i] = fEqFactors->GetBinContent(i+1)*fCalibData->GetMIPperADC(i);
+        factorSum += factors[i];
+       }
+       for(Int_t i = 0; i < 64; ++i) factors[i] *= (64./factorSum);
+       
+       esd->SetVZEROEqFactors(factors);
+     }
+     else
+       AliError("AliESDRun object is not available! Cannot write the equalization factors!");
   }
 
   if (esd) {
index 7fc7a14..1ca5370 100644 (file)
@@ -20,6 +20,7 @@
 #include "AliVZERORecoParam.h"
 
 class TF1;
+class TH1F;
 class AliVZEROCalibData;
 class AliVZEROTriggerData;
 class AliESDEvent;
@@ -74,13 +75,14 @@ private:
   Float_t            fTimeOffset[64]; //! HPTDC time offsets channel by channel
   TF1*               fTimeSlewing;    //! Function for time slewing correction
   TObjArray*         fSaturationCorr; //! Array with functions for correcting the signal saturation
+  TH1F*              fEqFactors;      //! Histogram with the equalization factors used in event-plane reconstruction
 
   Int_t              fCollisionMode;  // =0->p-p, =1->A-A
   Float_t            fBeamEnergy;     // beam energy
 
   mutable TClonesArray *fDigitsArray; // clones-array for ConvertDigits() and FillESD()
 
-  ClassDef(AliVZEROReconstructor, 4)  // class for the VZERO reconstruction
+  ClassDef(AliVZEROReconstructor, 5)  // class for the VZERO reconstruction
 };
 
 #endif