Bug #88017: Adding the equalization factors to AOD/VEvent.

diff --git a/STEER/AOD/AliAODEvent.cxx b/STEER/AOD/AliAODEvent.cxx
index 6f9b7c071fb318ce4bb4cd73f94fe744287773ed..40e553f679ea988cc4b4a619470ab9f1b1022fbf 100644 (file)
--- a/STEER/AOD/AliAODEvent.cxx
+++ b/STEER/AOD/AliAODEvent.cxx
@@ -819,3 +819,20 @@ Bool_t AliAODEvent::IsPileupFromSPDInMultBins() const {
     else return IsPileupFromSPD(5,0.8);
 }
 
+Float_t AliAODEvent::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 (!fAODVZERO || !fHeader) return -1;
+
+  Int_t ring = i/8;
+  Float_t factorSum = 0;
+  for(Int_t j = 8*ring; j < (8*ring+8); ++j) {
+    factorSum += fHeader->GetVZEROEqFactors(j);
+  }
+  Float_t factor = fHeader->GetVZEROEqFactors(i)*8./factorSum;
+
+  return (fAODVZERO->GetMultiplicity(i)/factor);
+}

diff --git a/STEER/AOD/AliAODEvent.h b/STEER/AOD/AliAODEvent.h
index a0a269378b81825e2facc0531bc38898b67b85d1..caba5a304ef968a8578dab1bc907bbc33332db57 100644 (file)
--- a/STEER/AOD/AliAODEvent.h
+++ b/STEER/AOD/AliAODEvent.h
@@ -251,6 +251,11 @@ class AliAODEvent : public AliVEvent {
 
   // VZERO 
   AliAODVZERO *GetVZEROData() const { return fAODVZERO; }
+  virtual const Float_t* GetVZEROEqFactors() const {return fHeader?fHeader->GetVZEROEqFactors():0x0;}
+  virtual Float_t        GetVZEROEqMultiplicity(Int_t i) const;
+  void           SetVZEROEqFactors(const Float_t *factors) const {
+    if(fHeader && factors)
+      fHeader->SetVZEROEqFactors(factors);}
 
   //ZDC
   AliAODZDC   *GetZDCData() const { return fAODZDC; }
@@ -287,7 +292,7 @@ class AliAODEvent : public AliVEvent {
   
   static const char* fAODListName[kAODListN]; //!
 
-  ClassDef(AliAODEvent,87);
+  ClassDef(AliAODEvent,88);
 };
 
 #endif

diff --git a/STEER/AOD/AliAODHeader.cxx b/STEER/AOD/AliAODHeader.cxx
index ebdc361fbdf7b63b8536343f5d1b81fe06a2e0e6..81bcbb6eadf6db1cacc4fb4accc196e9d5b048db 100644 (file)
--- a/STEER/AOD/AliAODHeader.cxx
+++ b/STEER/AOD/AliAODHeader.cxx
@@ -76,6 +76,7 @@ AliAODHeader::AliAODHeader() :
   for (Int_t m=0; m<kNPHOSMatrix; m++) fPHOSMatrix[m]=NULL;
   for (Int_t sm=0; sm<kNEMCALMatrix; sm++) fEMCALMatrix[sm]=NULL;
   for (Int_t i = 0; i < 6; i++)  fITSClusters[i] = 0;
+  for (Int_t j=0; j<64; ++j) fVZEROEqFactors[j]=-1;
 }
 
 //______________________________________________________________________________
@@ -130,6 +131,7 @@ AliAODHeader::AliAODHeader(Int_t nRun,
   fDiamondCovXY[1]=0.;
   for (Int_t m=0; m<kNPHOSMatrix; m++) fPHOSMatrix[m]=NULL;
   for (Int_t sm=0; sm<kNEMCALMatrix; sm++) fEMCALMatrix[sm]=NULL;
+  for (Int_t j=0; j<64; ++j) fVZEROEqFactors[j]=-1;
 }
 
 //______________________________________________________________________________
@@ -152,6 +154,7 @@ AliAODHeader::AliAODHeader(Int_t nRun,
                           ULong64_t trigMask,
                           UChar_t trigClus,
                           UInt_t evttype,
+                          const Float_t *vzeroEqFactors,
                           const Char_t *title,
                           Int_t nMuons,
                           Int_t nDimuons) :
@@ -202,6 +205,7 @@ AliAODHeader::AliAODHeader(Int_t nRun,
   for (Int_t m=0; m<kNPHOSMatrix; m++) fPHOSMatrix[m]=NULL;
   for (Int_t sm=0; sm<kNEMCALMatrix; sm++) fEMCALMatrix[sm]=NULL;
   for (Int_t i = 0; i < 6; i++)  fITSClusters[i] = 0;
+  if (vzeroEqFactors) for (Int_t j=0; j<64; ++j) fVZEROEqFactors[j] = vzeroEqFactors[j];
 }
 
 //______________________________________________________________________________
@@ -275,6 +279,7 @@ AliAODHeader::AliAODHeader(const AliAODHeader& hdr) :
          fEMCALMatrix[sm]=0;
   }
   for (Int_t i = 0; i < 6; i++)  fITSClusters[i] = hdr.fITSClusters[i];
+  for (Int_t j=0; j<64; ++j) fVZEROEqFactors[j]=hdr.fVZEROEqFactors[j];
 }
 
 //______________________________________________________________________________
@@ -354,6 +359,7 @@ AliAODHeader& AliAODHeader::operator=(const AliAODHeader& hdr)
   }
 
   for (Int_t i = 0; i < 6; i++)  fITSClusters[i] = hdr.fITSClusters[i];
+  for (Int_t j=0; j<64; ++j) fVZEROEqFactors[j] = hdr.fVZEROEqFactors[j];
   return *this;
 }
 
@@ -449,6 +455,9 @@ void AliAODHeader::Print(Option_t* /*option*/) const
       printf("QTheta[%d]              : %13.3e\n", i, GetQTheta(i));
     }
   }
+  printf("V0 Eq factors: ");
+  for (Int_t j=0; j<64; ++j) printf(" %.3f",fVZEROEqFactors[j]);
+  printf("\n");
 
   return;
 }

diff --git a/STEER/AOD/AliAODHeader.h b/STEER/AOD/AliAODHeader.h
index a022ad716bb26a1779b78277ed299942cb61097d..b03ec3635b39e28096441cc11807fd6e47b34993 100644 (file)
--- a/STEER/AOD/AliAODHeader.h
+++ b/STEER/AOD/AliAODHeader.h
@@ -45,6 +45,7 @@ class AliAODHeader : public AliVHeader {
               ULong64_t fTriggerMask,
               UChar_t   fTriggerCluster,
               UInt_t    fEventType,
+              const Float_t *vzeroEqFactors,
               const Char_t *title="",
               Int_t nMuons=0,
               Int_t nDimuons=0);
@@ -163,6 +164,12 @@ class AliAODHeader : public AliVHeader {
   void Clear(Option_t* = "");
   enum {kNPHOSMatrix = 5};
   enum {kNEMCALMatrix = 12};
+
+  void           SetVZEROEqFactors(const Float_t* factors) {
+    if (factors)
+      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 :
   
@@ -206,7 +213,8 @@ class AliAODHeader : public AliVHeader {
   Int_t       fTPConlyRefMult;      // Reference multiplicty for standard TPC only tracks
   AliCentrality* fCentralityP;      // Pointer to full centrality information
   AliEventplane* fEventplaneP;     // Pointer to full event plane information
-  ClassDef(AliAODHeader, 16);
+  Float_t     fVZEROEqFactors[64];  // V0 channel equalization factors for event-plane reconstruction
+  ClassDef(AliAODHeader, 17);
 };
 inline
 void AliAODHeader::SetCentrality(AliCentrality* cent)      { 

diff --git a/STEER/ESD/AliESDEvent.h b/STEER/ESD/AliESDEvent.h
index d3c756f13868ca5aa742347737c894fcc43ce2e9..a3c457a09ab20859f521b344dfc4b86e1b2169e1 100644 (file)
--- a/STEER/ESD/AliESDEvent.h
+++ b/STEER/ESD/AliESDEvent.h
@@ -145,8 +145,8 @@ public:
   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;}
-  const Float_t* GetVZEROEqFactors() const {return fESDRun?fESDRun->GetVZEROEqFactors():0x0;}
-  Float_t        GetVZEROEqMultiplicity(Int_t i) const;
+  virtual const Float_t* GetVZEROEqFactors() const {return fESDRun?fESDRun->GetVZEROEqFactors():0x0;}
+  virtual Float_t        GetVZEROEqMultiplicity(Int_t i) const;
        
   //
   void        SetCurrentL3(Float_t cur)           const  {if(fESDRun) fESDRun->SetCurrentL3(cur);}
@@ -519,7 +519,7 @@ protected:
                              //  and T0spread as written in OCDB
   AliCentrality *fCentrality; //! Centrality for AA collision
   AliEventplane *fEventplane; //! Event plane for AA collision
-  ClassDef(AliESDEvent,15)  //ESDEvent class 
+  ClassDef(AliESDEvent,16)  //ESDEvent class 
 };
 #endif 
 

diff --git a/STEER/STEERBase/AliVEvent.h b/STEER/STEERBase/AliVEvent.h
index 8445513e182313c3d187e3a5ed6c0ca7f62c2967..7584b5f013c6e9537720a090f6121ea14efc18a5 100644 (file)
--- a/STEER/STEERBase/AliVEvent.h
+++ b/STEER/STEERBase/AliVEvent.h
@@ -153,9 +153,11 @@ public:
   virtual Int_t        EventIndexForEMCALCell(Int_t icell)  const = 0;  
 
   virtual AliVVZERO *GetVZEROData() const = 0;   
+  virtual const Float_t* GetVZEROEqFactors() const {return NULL;}
+  virtual Float_t        GetVZEROEqMultiplicity(Int_t /* i */) const {return -1;}
   virtual AliVZDC   *GetZDCData() const = 0;
 
-  ClassDef(AliVEvent,1)  // base class for AliEvent data
+  ClassDef(AliVEvent,2)  // base class for AliEvent data
 };
 #endif