Second ZDC module. More ZDC information included in the ESD and AOD classes (Chiara)

diff --git a/STEER/AliAODEvent.h b/STEER/AliAODEvent.h
index 257c10b1ef2c5ff4e2d96e384ecffce316da97d6..0abd716ffb220e6143dca6614f51abab72599693 100644 (file)
--- a/STEER/AliAODEvent.h
+++ b/STEER/AliAODEvent.h
@@ -91,7 +91,7 @@ class AliAODEvent : public AliVEvent {
   Double_t  GetZDCP1Energy()        const { return fHeader ? fHeader->GetZDCP1Energy() : -999.; }
   Double_t  GetZDCN2Energy()        const { return fHeader ? fHeader->GetZDCN2Energy() : -999.; }
   Double_t  GetZDCP2Energy()        const { return fHeader ? fHeader->GetZDCP2Energy() : -999.; }
-  Double_t  GetZDCEMEnergy()        const { return fHeader ? fHeader->GetZDCEMEnergy() : -999.; }
+  Double_t  GetZDCEMEnergy(Int_t i) const { return fHeader ? fHeader->GetZDCEMEnergy(i) : -999.; }
 
   // -- Tracks
   TClonesArray *GetTracks()              const { return fTracks; }

diff --git a/STEER/AliAODHeader.cxx b/STEER/AliAODHeader.cxx
index 5057696e96fd892c8e0c47335f8e8ee647927e1b..d952203594ec269c1cb5debed6f5cc30644a59e4 100644 (file)
--- a/STEER/AliAODHeader.cxx
+++ b/STEER/AliAODHeader.cxx
@@ -34,7 +34,6 @@ AliAODHeader::AliAODHeader() :
   fZDCP1Energy(-999.),
   fZDCN2Energy(-999.),
   fZDCP2Energy(-999.),
-  fZDCEMEnergy(-999.),
   fNQTheta(0),
   fQTheta(0x0),
   fTriggerMask(0),
@@ -51,6 +50,7 @@ AliAODHeader::AliAODHeader() :
   // default constructor
 
   SetName("header");
+  for(int j=0; j<2; j++) fZDCEMEnergy[j] = -999.;
 }
 
 //______________________________________________________________________________
@@ -67,7 +67,6 @@ AliAODHeader::AliAODHeader(Int_t nRun,
   fZDCP1Energy(-999.),
   fZDCN2Energy(-999.),
   fZDCP2Energy(-999.),
-  fZDCEMEnergy(-999.),
   fNQTheta(0),
   fQTheta(0x0),
   fTriggerMask(0),
@@ -85,6 +84,7 @@ AliAODHeader::AliAODHeader(Int_t nRun,
 
   SetName("header");
   SetTitle(title);
+  for(int j=0; j<2; j++) fZDCEMEnergy[j] = -999.;
 }
 
 //______________________________________________________________________________
@@ -102,7 +102,7 @@ AliAODHeader::AliAODHeader(Int_t nRun,
                           Double_t p1Energy,
                           Double_t n2Energy,
                           Double_t p2Energy,
-                          Double_t emEnergy,
+                          Double_t *emEnergy,
                           ULong64_t trigMask,
                           UChar_t trigClus,
                           UInt_t evttype,
@@ -115,7 +115,6 @@ AliAODHeader::AliAODHeader(Int_t nRun,
   fZDCP1Energy(p1Energy),
   fZDCN2Energy(n2Energy),
   fZDCP2Energy(p2Energy),
-  fZDCEMEnergy(emEnergy),
   fNQTheta(0),
   fQTheta(0x0),
   fTriggerMask(trigMask),
@@ -133,6 +132,7 @@ AliAODHeader::AliAODHeader(Int_t nRun,
 
   SetName("header");
   SetTitle(title);
+  for(int j=0; j<2; j++) fZDCEMEnergy[j] = emEnergy[j];
 }
 
 //______________________________________________________________________________
@@ -153,7 +153,6 @@ AliAODHeader::AliAODHeader(const AliAODHeader& hdr) :
   fZDCP1Energy(hdr.fZDCP1Energy),
   fZDCN2Energy(hdr.fZDCN2Energy),
   fZDCP2Energy(hdr.fZDCP2Energy),
-  fZDCEMEnergy(hdr.fZDCEMEnergy),
   fNQTheta(0),
   fQTheta(0x0),
   fTriggerMask(hdr.fTriggerMask),
@@ -172,6 +171,7 @@ AliAODHeader::AliAODHeader(const AliAODHeader& hdr) :
   SetName(hdr.fName);
   SetTitle(hdr.fTitle);
   SetQTheta(hdr.fQTheta, hdr.fNQTheta);
+  SetZDCEMEnergy(hdr.fZDCEMEnergy[0], hdr.fZDCEMEnergy[1]);
 }
 
 //______________________________________________________________________________
@@ -189,7 +189,6 @@ AliAODHeader& AliAODHeader::operator=(const AliAODHeader& hdr)
     fZDCP1Energy      = hdr.fZDCP1Energy;
     fZDCN2Energy      = hdr.fZDCN2Energy;
     fZDCP2Energy      = hdr.fZDCP2Energy;
-    fZDCEMEnergy      = hdr.fZDCEMEnergy;
     fTriggerMask      = hdr.fTriggerMask;
     fRunNumber        = hdr.fRunNumber;
     fRefMult          = hdr.fRefMult;
@@ -204,6 +203,7 @@ AliAODHeader& AliAODHeader::operator=(const AliAODHeader& hdr)
     SetName(hdr.fName);
     SetTitle(hdr.fTitle);
     SetQTheta(hdr.fQTheta, hdr.fNQTheta);
+    SetZDCEMEnergy(hdr.fZDCEMEnergy[0], hdr.fZDCEMEnergy[1]);
   }
 
 
@@ -270,7 +270,8 @@ void AliAODHeader::Print(Option_t* /*option*/) const
   printf("ZDC P1 Energy           : %f\n", fZDCP1Energy);
   printf("ZDC N2 Energy           : %f\n", fZDCN2Energy);
   printf("ZDC P2 Energy           : %f\n", fZDCP2Energy);
-  printf("ZDC EM Energy           : %f\n", fZDCEMEnergy);
+  printf("ZDC EM1 Energy          : %f\n", fZDCEMEnergy[0]);
+  printf("ZDC EM2 Energy          : %f\n", fZDCEMEnergy[1]);
   printf("ref. Multiplicity       : %d\n", fRefMult);
   printf("ref. Multiplicity (pos) : %d\n", fRefMultPos);
   printf("ref. Multiplicity (neg) : %d\n", fRefMultNeg);

diff --git a/STEER/AliAODHeader.h b/STEER/AliAODHeader.h
index a06bd7c0fd456a099a408823e6cbf369cd928f6b..3383d71df6932215c6ec203eab78ad59a595bf1c 100644 (file)
--- a/STEER/AliAODHeader.h
+++ b/STEER/AliAODHeader.h
@@ -33,7 +33,7 @@ class AliAODHeader : public AliVHeader {
               Double_t p1Energy,
               Double_t n2Energy,
               Double_t p2Energy,
-              Double_t emEnergy,
+              Double_t *emEnergy,
               ULong64_t fTriggerMask,
               UChar_t   fTriggerCluster,
               UInt_t    fEventType,
@@ -58,7 +58,7 @@ class AliAODHeader : public AliVHeader {
   Double_t  GetZDCP1Energy()        const { return fZDCP1Energy; }
   Double_t  GetZDCN2Energy()        const { return fZDCN2Energy; }
   Double_t  GetZDCP2Energy()        const { return fZDCP2Energy; }
-  Double_t  GetZDCEMEnergy()        const { return fZDCEMEnergy; }
+  Double_t  GetZDCEMEnergy(Int_t i) const { return fZDCEMEnergy[i]; }
   Int_t     GetRefMultiplicity()    const { return fRefMult; }
   Int_t     GetRefMultiplicityPos() const { return fRefMultPos; }
   Int_t     GetRefMultiplicityNeg() const { return fRefMultNeg; }
@@ -81,7 +81,8 @@ class AliAODHeader : public AliVHeader {
   void SetZDCP1Energy(Double_t p1Energy)       { fZDCP1Energy = p1Energy; }
   void SetZDCN2Energy(Double_t n2Energy)       { fZDCN2Energy = n2Energy; }
   void SetZDCP2Energy(Double_t p2Energy)       { fZDCP2Energy = p2Energy; }
-  void SetZDCEMEnergy(Double_t emEnergy)       { fZDCEMEnergy = emEnergy; }
+  void SetZDCEMEnergy(Double_t emEnergy1, Double_t emEnergy2)      
+       { fZDCEMEnergy[0] = emEnergy1; fZDCEMEnergy[1] = emEnergy2;}
   void SetRefMultiplicity(Int_t refMult)       { fRefMult = refMult; }
   void SetRefMultiplicityPos(Int_t refMultPos) { fRefMultPos = refMultPos; }
   void SetRefMultiplicityNeg(Int_t refMultNeg) { fRefMultNeg = refMultNeg; }
@@ -101,7 +102,7 @@ class AliAODHeader : public AliVHeader {
   Double32_t  fZDCP1Energy;         // reconstructed energy in the proton1 ZDC
   Double32_t  fZDCN2Energy;         // reconstructed energy in the neutron2 ZDC
   Double32_t  fZDCP2Energy;         // reconstructed energy in the proton2 ZDC
-  Double32_t  fZDCEMEnergy;         // reconstructed energy in the electromagnetic ZDC
+  Double32_t  fZDCEMEnergy[2];      // reconstructed energy in the electromagnetic ZDCs
   Int_t       fNQTheta;             // number of QTheta elements
   Double32_t *fQTheta;              // [fNQTheta] values to store Lee-Yang-Zeros
   ULong64_t   fTriggerMask;         // Trigger Type (mask)
@@ -115,7 +116,7 @@ class AliAODHeader : public AliVHeader {
   UShort_t    fBunchCrossNumber;    // BunchCrossingNumber
   UChar_t     fTriggerCluster;      // Trigger cluster (mask)
   
-  ClassDef(AliAODHeader,5);
+  ClassDef(AliAODHeader,6);
 };
 
 #endif

diff --git a/STEER/AliESDEvent.cxx b/STEER/AliESDEvent.cxx
index 9e472b2ed71fed9251f06a814810cdb8d5f96c34..0dc7a6b1720e2ea76bdc1748d71a1d492ebb543e 100644 (file)
--- a/STEER/AliESDEvent.cxx
+++ b/STEER/AliESDEvent.cxx
@@ -1073,11 +1073,12 @@ void AliESDEvent::CopyFromOldESD()
     // ZDC
 
     SetZDC(fESDOld->GetZDCN1Energy(),
-          fESDOld->GetZDCP1Energy(),
-          fESDOld->GetZDCEMEnergy(),
-          fESDOld->GetZDCN2Energy(),
-          fESDOld->GetZDCP2Energy(),
-          fESDOld->GetZDCParticipants());
+           fESDOld->GetZDCP1Energy(),
+           fESDOld->GetZDCEMEnergy(),
+           0,
+           fESDOld->GetZDCN2Energy(),
+           fESDOld->GetZDCP2Energy(),
+           fESDOld->GetZDCParticipants());
 
     // FMD
     

diff --git a/STEER/AliESDEvent.h b/STEER/AliESDEvent.h
index 188779da872c0e0c5402df0c796fa9fb419f0563..6f8463c8771fde155761c1ebb7d2e1bf24afe60f 100644 (file)
--- a/STEER/AliESDEvent.h
+++ b/STEER/AliESDEvent.h
@@ -124,18 +124,18 @@ public:
   UChar_t   GetTriggerCluster() const {return fHeader->GetTriggerCluster();}
 
   // ZDC CKB: put this in the header?
-  const AliESDZDC*    GetESDZDC() const {return fESDZDC;}
+  AliESDZDC*    GetESDZDC() const {return fESDZDC;}
 
   // Delegated methods for fESDZDC
   Double_t GetZDCN1Energy() const {return fESDZDC->GetZDCN1Energy();}
   Double_t GetZDCP1Energy() const {return fESDZDC->GetZDCP1Energy();}
   Double_t GetZDCN2Energy() const {return fESDZDC->GetZDCN2Energy();}
   Double_t GetZDCP2Energy() const {return fESDZDC->GetZDCP2Energy();}
-  Double_t GetZDCEMEnergy() const {return fESDZDC->GetZDCEMEnergy();}
+  Double_t GetZDCEMEnergy(Int_t i=0) const {return fESDZDC->GetZDCEMEnergy(i);}
   Int_t   GetZDCParticipants() const {return fESDZDC->GetZDCParticipants();}
-  void    SetZDC(Float_t n1Energy, Float_t p1Energy, Float_t emEnergy,
+  void    SetZDC(Float_t n1Energy, Float_t p1Energy, Float_t em1Energy, Float_t em2Energy,
                  Float_t n2Energy, Float_t p2Energy, Int_t participants)
-  {fESDZDC->SetZDC(n1Energy, p1Energy, emEnergy, n2Energy, p2Energy, participants);}
+  {fESDZDC->SetZDC(n1Energy, p1Energy, em1Energy, em2Energy, n2Energy, p2Energy, participants);}
 
 
   // FMD

diff --git a/STEER/AliESDTagCreator.cxx b/STEER/AliESDTagCreator.cxx
index d612706100d0287d30443df75e9fc90b2a7b4900..b20a2cfbcffacc56f8fd78628db2f930a97a3916 100644 (file)
--- a/STEER/AliESDTagCreator.cxx
+++ b/STEER/AliESDTagCreator.cxx
@@ -445,7 +445,7 @@ void AliESDTagCreator::CreateTag(TChain* fChain, const char *type) {
     
     evTag->SetZDCNeutron1Energy(esd->GetZDCN1Energy());
     evTag->SetZDCProton1Energy(esd->GetZDCP1Energy());
-    evTag->SetZDCEMEnergy(esd->GetZDCEMEnergy());
+    evTag->SetZDCEMEnergy(esd->GetZDCEMEnergy(0),esd->GetZDCEMEnergy(1));
     evTag->SetZDCNeutron1Energy(esd->GetZDCN2Energy());
     evTag->SetZDCProton1Energy(esd->GetZDCP2Energy());
     evTag->SetNumOfParticipants(esd->GetZDCParticipants());
@@ -758,7 +758,7 @@ void AliESDTagCreator::CreateTag(TFile* file, const char *guid, const char *md5,
     
     evTag->SetZDCNeutron1Energy(esd->GetZDCN1Energy());
     evTag->SetZDCProton1Energy(esd->GetZDCP1Energy());
-    evTag->SetZDCEMEnergy(esd->GetZDCEMEnergy());
+    evTag->SetZDCEMEnergy(esd->GetZDCEMEnergy(0),esd->GetZDCEMEnergy(1));
     evTag->SetZDCNeutron1Energy(esd->GetZDCN2Energy());
     evTag->SetZDCProton1Energy(esd->GetZDCP2Energy());
     evTag->SetNumOfParticipants(esd->GetZDCParticipants());
@@ -1073,7 +1073,7 @@ void AliESDTagCreator::CreateTag(TFile* file, const char *filepath, Int_t Counte
     
     evTag->SetZDCNeutron1Energy(esd->GetZDCN1Energy());
     evTag->SetZDCProton1Energy(esd->GetZDCP1Energy());
-    evTag->SetZDCEMEnergy(esd->GetZDCEMEnergy());
+    evTag->SetZDCEMEnergy(esd->GetZDCEMEnergy(0),esd->GetZDCEMEnergy(1));
     evTag->SetZDCNeutron1Energy(esd->GetZDCN2Energy());
     evTag->SetZDCProton1Energy(esd->GetZDCP2Energy());
     evTag->SetNumOfParticipants(esd->GetZDCParticipants());
@@ -1396,7 +1396,7 @@ void AliESDTagCreator::CreateESDTags(Int_t fFirstEvent, Int_t fLastEvent, TList
     evTag->SetZDCProton1Energy(esd->GetZDCP1Energy());
     evTag->SetZDCNeutron2Energy(esd->GetZDCN2Energy());
     evTag->SetZDCProton2Energy(esd->GetZDCP2Energy());
-    evTag->SetZDCEMEnergy(esd->GetZDCEMEnergy());
+    evTag->SetZDCEMEnergy(esd->GetZDCEMEnergy(0),esd->GetZDCEMEnergy(1));
     evTag->SetNumOfParticipants(esd->GetZDCParticipants());
     
     

diff --git a/STEER/AliESDZDC.cxx b/STEER/AliESDZDC.cxx
index 581d13254ec5707fb36fe8d0c8b41f86b0932c2f..96e83e3c77b3fd8c4b24c486f0a7e8ef0dd03e50 100644 (file)
--- a/STEER/AliESDZDC.cxx
+++ b/STEER/AliESDZDC.cxx
@@ -34,10 +34,15 @@ AliESDZDC::AliESDZDC() :
   fZDCP1Energy(0),
   fZDCN2Energy(0),
   fZDCP2Energy(0),
-  fZDCEMEnergy(0),
   fZDCParticipants(0)
 {
-  for(int i = 0;i<4;i++) fZN1TowerEnergy[i] = fZN2TowerEnergy[i] = 0.;
+  for(int i=0; i<2; i++) fZDCEMEnergy[i] = 0.;
+  for(int i=0; i<5; i++){
+    fZN1TowerEnergy[i] = fZN2TowerEnergy[i] = 0.;
+    fZP1TowerEnergy[i] = fZP2TowerEnergy[i] = 0.;
+    fZN1TowerEnergyLR[i] = fZN2TowerEnergyLR[i] = 0.;
+    fZP1TowerEnergyLR[i] = fZP2TowerEnergyLR[i] = 0.;
+  }
 }
 
 AliESDZDC::AliESDZDC(const AliESDZDC& zdc) :
@@ -46,10 +51,20 @@ AliESDZDC::AliESDZDC(const AliESDZDC& zdc) :
   fZDCP1Energy(zdc.fZDCP1Energy),
   fZDCN2Energy(zdc.fZDCN2Energy),
   fZDCP2Energy(zdc.fZDCP2Energy),
-  fZDCEMEnergy(zdc.fZDCEMEnergy),
   fZDCParticipants(zdc.fZDCParticipants)
 {
   // copy constructor
+  for(int i=0; i<2; i++) fZDCEMEnergy[i] = zdc.fZDCEMEnergy[i];
+  for(int i=0; i<5; i++){
+     fZN1TowerEnergy[i] = zdc.fZN1TowerEnergy[i];
+     fZN2TowerEnergy[i] = zdc.fZN2TowerEnergy[i];
+     fZP1TowerEnergy[i] = zdc.fZP1TowerEnergy[i];
+     fZP2TowerEnergy[i] = zdc.fZP2TowerEnergy[i];
+     fZN1TowerEnergyLR[i] = zdc.fZN1TowerEnergyLR[i];
+     fZN2TowerEnergyLR[i] = zdc.fZN2TowerEnergyLR[i];
+     fZP1TowerEnergyLR[i] = zdc.fZP1TowerEnergyLR[i];
+     fZP2TowerEnergyLR[i] = zdc.fZP2TowerEnergyLR[i];
+  }
 }
 
 AliESDZDC& AliESDZDC::operator=(const AliESDZDC&zdc)
@@ -61,11 +76,17 @@ AliESDZDC& AliESDZDC::operator=(const AliESDZDC&zdc)
     fZDCP1Energy = zdc.fZDCP1Energy;
     fZDCN2Energy = zdc.fZDCN2Energy;
     fZDCP2Energy = zdc.fZDCP2Energy;
-    fZDCEMEnergy = zdc.fZDCEMEnergy;
     fZDCParticipants = zdc.fZDCParticipants;
-    for(Int_t i=0; i<4; i++){
+    for(Int_t i=0; i<2; i++) fZDCEMEnergy[i] = zdc.fZDCEMEnergy[i];
+    for(Int_t i=0; i<5; i++){
        fZN1TowerEnergy[i] = zdc.fZN1TowerEnergy[i];
        fZN2TowerEnergy[i] = zdc.fZN2TowerEnergy[i];
+       fZP1TowerEnergy[i] = zdc.fZP1TowerEnergy[i];
+       fZP2TowerEnergy[i] = zdc.fZP2TowerEnergy[i];
+       fZN1TowerEnergyLR[i] = zdc.fZN1TowerEnergyLR[i];
+       fZN2TowerEnergyLR[i] = zdc.fZN2TowerEnergyLR[i];
+       fZP1TowerEnergyLR[i] = zdc.fZP1TowerEnergyLR[i];
+       fZP2TowerEnergyLR[i] = zdc.fZP2TowerEnergyLR[i];
     }
   } 
   return *this;
@@ -80,15 +101,23 @@ void AliESDZDC::Reset()
   fZDCP1Energy=0;
   fZDCN2Energy=0;
   fZDCP2Energy=0;
-  fZDCEMEnergy=0;
   fZDCParticipants=0;  
-  for(int i=0; i<4; i++) fZN1TowerEnergy[i] = fZN2TowerEnergy[i] = 0.;
-
+  for(int i=0; i<2; i++) fZDCEMEnergy[i]=0;
+  for(int i=0; i<5; i++){
+    fZN1TowerEnergy[i] = fZN2TowerEnergy[i] = 0.;
+    fZP1TowerEnergy[i] = fZP2TowerEnergy[i] = 0.;
+    fZN1TowerEnergyLR[i] = fZN2TowerEnergyLR[i] = 0.;
+    fZP1TowerEnergyLR[i] = fZP2TowerEnergyLR[i] = 0.;
+  }
 }
 
 //______________________________________________________________________________
 void AliESDZDC::Print(const Option_t *) const
 {
+  //  Print ESD for the ZDC
+  printf("\n \t ZN1Energy = %f TeV, ZP1Energy = %f TeV, ZN2Energy = %f TeV,"
+  " ZP2Energy = %f, Nparticipants = %d\n",
+  fZDCN1Energy,fZDCP1Energy,fZDCN2Energy,fZDCP2Energy,fZDCParticipants);
 }
 
 

diff --git a/STEER/AliESDZDC.h b/STEER/AliESDZDC.h
index 0d23c495f6dd4a91887a8b0f4294fc531ce62b81..85ede7bffbec371f2bed9435bfe9d730565f7375 100644 (file)
--- a/STEER/AliESDZDC.h
+++ b/STEER/AliESDZDC.h
@@ -25,19 +25,43 @@ public:
   Double_t GetZDCP1Energy() const {return fZDCP1Energy;}
   Double_t GetZDCN2Energy() const {return fZDCN2Energy;}
   Double_t GetZDCP2Energy() const {return fZDCP2Energy;}
-  Double_t GetZDCEMEnergy() const {return fZDCEMEnergy;}
-  Short_t    GetZDCParticipants() const {return fZDCParticipants;}
+  Double_t GetZDCEMEnergy(Int_t i) const {return fZDCEMEnergy[i];}
+  Short_t  GetZDCParticipants() const {return fZDCParticipants;}
   const Double_t * GetZN1TowerEnergy() const {return fZN1TowerEnergy;}
   const Double_t * GetZN2TowerEnergy() const {return fZN2TowerEnergy;}
-  void  SetZDC(Double_t n1Energy, Double_t p1Energy, Double_t emEnergy,
+  const Double_t * GetZP1TowerEnergy() const {return fZP1TowerEnergy;}
+  const Double_t * GetZP2TowerEnergy() const {return fZP2TowerEnergy;}
+  const Double_t * GetZN1TowerEnergyLR() const {return fZN1TowerEnergyLR;}
+  const Double_t * GetZN2TowerEnergyLR() const {return fZN2TowerEnergyLR;}
+  const Double_t * GetZP1TowerEnergyLR() const {return fZP1TowerEnergyLR;}
+  const Double_t * GetZP2TowerEnergyLR() const {return fZP2TowerEnergyLR;}
+  void  SetZDC(Double_t n1Energy, Double_t p1Energy, Double_t emEnergy1, Double_t emEnergy2,
               Double_t n2Energy, Double_t p2Energy, Short_t participants) 
-   {fZDCN1Energy=n1Energy; fZDCP1Energy=p1Energy; fZDCEMEnergy=emEnergy;
+   {fZDCN1Energy=n1Energy; fZDCP1Energy=p1Energy; fZDCEMEnergy[0]=emEnergy1; fZDCEMEnergy[1]=emEnergy2;
     fZDCN2Energy=n2Energy; fZDCP2Energy=p2Energy; fZDCParticipants=participants;}
-  void  SetZN1TowerEnergy(Double_t tow1[4]){
-      for(Int_t i=0; i<4; i++) fZN1TowerEnergy[i] = tow1[i];
+  void  SetZN1TowerEnergy(Float_t tow1[5]){
+      for(Int_t i=0; i<5; i++) fZN1TowerEnergy[i] = tow1[i];
   }
-  void  SetZN2TowerEnergy(Double_t tow2[4]){
-      for(Int_t i=0; i<4; i++) fZN2TowerEnergy[i] = tow2[i];
+  void  SetZN2TowerEnergy(Float_t tow2[5]){
+      for(Int_t i=0; i<5; i++) fZN2TowerEnergy[i] = tow2[i];
+  }
+  void  SetZP1TowerEnergy(Float_t tow1[5]){
+      for(Int_t i=0; i<5; i++) fZP1TowerEnergy[i] = tow1[i];
+  }
+  void  SetZP2TowerEnergy(Float_t tow2[5]){
+      for(Int_t i=0; i<5; i++) fZP2TowerEnergy[i] = tow2[i];
+  }
+  void  SetZN1TowerEnergyLR(Float_t tow1[5]){
+      for(Int_t i=0; i<5; i++) fZN1TowerEnergyLR[i] = tow1[i];
+  }
+  void  SetZN2TowerEnergyLR(Float_t tow2[5]){
+      for(Int_t i=0; i<5; i++) fZN2TowerEnergyLR[i] = tow2[i];
+  }
+  void  SetZP1TowerEnergyLR(Float_t tow1[5]){
+      for(Int_t i=0; i<5; i++) fZP1TowerEnergyLR[i] = tow1[i];
+  }
+  void  SetZP2TowerEnergyLR(Float_t tow2[4]){
+      for(Int_t i=0; i<5; i++) fZP2TowerEnergyLR[i] = tow2[i];
   }
 
   void    Reset();
@@ -49,11 +73,17 @@ private:
   Double32_t   fZDCP1Energy;      // reconstructed energy in the proton ZDC
   Double32_t   fZDCN2Energy;      // reconstructed energy in the neutron ZDC
   Double32_t   fZDCP2Energy;      // reconstructed energy in the proton ZDC
-  Double32_t   fZDCEMEnergy;      // signal in the electromagnetic ZDC
-  Double32_t   fZN1TowerEnergy[4];// reconstructed energy in 4 neutron ZDC towers
-  Double32_t   fZN2TowerEnergy[4];// reconstructed energy in 4 neutron ZDC towers
+  Double32_t   fZDCEMEnergy[2];   // signal in the electromagnetic ZDCs
+  Double32_t   fZN1TowerEnergy[5];// reco E in 5 ZN1 sectors - high gain chain
+  Double32_t   fZN2TowerEnergy[5];// reco E in 5 ZN2 sectors - high gain chain
+  Double32_t   fZP1TowerEnergy[5];// reco E in 5 ZP1 sectors - high gain chain
+  Double32_t   fZP2TowerEnergy[5];// reco E in 5 ZP2 sectors - high gain chain
+  Double32_t   fZN1TowerEnergyLR[5];// reco E in 5 ZN1 sectors - low gain chain
+  Double32_t   fZN2TowerEnergyLR[5];// reco E in 5 ZN2 sectors - low gain chain
+  Double32_t   fZP1TowerEnergyLR[5];// reco E in 5 ZP1 sectors - low gain chain
+  Double32_t   fZP2TowerEnergyLR[5];// reco E in 5 ZP2 sectors - low gain chain
   Short_t      fZDCParticipants;  // number of participants estimated by the ZDC
-  ClassDef(AliESDZDC,4)
+  ClassDef(AliESDZDC,6)
 };
 
 #endif

diff --git a/STEER/AliEventTag.cxx b/STEER/AliEventTag.cxx
index 256145decef200bd379ec64ac88b1933409817d5..d696e67b035a6e8b53a7cd68051125bbcec948f4 100644 (file)
--- a/STEER/AliEventTag.cxx
+++ b/STEER/AliEventTag.cxx
@@ -47,7 +47,6 @@ ClassImp(AliEventTag)
     fZDCProton1Energy(-10.0),
     fZDCNeutron2Energy(-10.0),
     fZDCProton2Energy(-10.0),
-    fZDCEMEnergy(-10.0),
     fT0VertexZ(-10.0),
     fNumberOfTracks(-10),
     fNumberOfPositiveTracks(-10),
@@ -93,6 +92,8 @@ ClassImp(AliEventTag)
     fHBTRadii(-10.0)
 {
   // AliEventTag default constructor
+  for(Int_t i=0; i<2; i++)     fZDCEMEnergy[i] = -10.0;
+
 }
 
 
@@ -118,7 +119,6 @@ AliEventTag::AliEventTag(const AliEventTag & evTag) :
   fZDCProton1Energy(evTag.fZDCProton1Energy),
   fZDCNeutron2Energy(evTag.fZDCNeutron2Energy),
   fZDCProton2Energy(evTag.fZDCProton2Energy),
-  fZDCEMEnergy(evTag.fZDCEMEnergy),
   fT0VertexZ(evTag.fT0VertexZ),
   fNumberOfTracks(evTag.fNumberOfTracks),
   fNumberOfPositiveTracks(evTag.fNumberOfPositiveTracks),
@@ -164,6 +164,7 @@ AliEventTag::AliEventTag(const AliEventTag & evTag) :
   fHBTRadii(evTag.fHBTRadii)
  {
   // EventTag copy constructor
+  for(Int_t i=0; i<2; i++)     fZDCEMEnergy[i] = evTag.fZDCEMEnergy[i];
 }
 
 //___________________________________________________________________________
@@ -191,7 +192,7 @@ AliEventTag & AliEventTag::operator=(const AliEventTag &evTag) {
     SetZDCProton1Energy(evTag.GetZDCProton1Energy());
     SetZDCNeutron2Energy(evTag.GetZDCNeutron2Energy());
     SetZDCProton2Energy(evTag.GetZDCProton2Energy());
-    SetZDCEMEnergy(evTag.GetZDCEMEnergy());
+    SetZDCEMEnergy(evTag.GetZDCEMEnergy(0),evTag.GetZDCEMEnergy(1));
     SetT0VertexZ(evTag.GetT0VertexZ());
     SetNumOfTracks(evTag.GetNumOfTracks());
     SetNumOfPosTracks(evTag.GetNumOfPosTracks());

diff --git a/STEER/AliEventTag.h b/STEER/AliEventTag.h
index 95183d93d4dc2264f49ec76481f8d4b1d1b6ad68..60c7c0a7b191c44766c1ff750b50b4898b5285e5 100644 (file)
--- a/STEER/AliEventTag.h
+++ b/STEER/AliEventTag.h
@@ -45,7 +45,8 @@ class AliEventTag : public TObject {
   void SetZDCProton1Energy(Float_t Pen) {fZDCProton1Energy = Pen;}
   void SetZDCNeutron2Energy(Float_t Pen) {fZDCNeutron2Energy = Pen;}
   void SetZDCProton2Energy(Float_t Pen) {fZDCProton2Energy = Pen;}
-  void SetZDCEMEnergy(Float_t Pen) {fZDCEMEnergy = Pen;}
+  void SetZDCEMEnergy(Float_t Pen1, Float_t Pen2) 
+       {fZDCEMEnergy[0]=Pen1; fZDCEMEnergy[1]=Pen2;}
   void SetT0VertexZ(Float_t Pvz) {fT0VertexZ = Pvz;}
   void SetNumOfTracks(Int_t Ptr) {fNumberOfTracks = Ptr;}
   void SetNumOfPosTracks(Int_t Ptr) {fNumberOfPositiveTracks = Ptr;}
@@ -110,7 +111,7 @@ class AliEventTag : public TObject {
   Float_t     GetZDCProton1Energy() const {return fZDCProton1Energy;}
   Float_t     GetZDCNeutron2Energy() const {return fZDCNeutron2Energy;}
   Float_t     GetZDCProton2Energy() const {return fZDCProton2Energy;}
-  Float_t     GetZDCEMEnergy() const {return fZDCEMEnergy;}
+  Float_t     GetZDCEMEnergy(Int_t i) const {return fZDCEMEnergy[i];}
   Float_t     GetT0VertexZ() const {return fT0VertexZ;}
   Int_t       GetNumOfTracks() const {return fNumberOfTracks;}
   Int_t       GetNumOfPosTracks() const {return fNumberOfPositiveTracks;}
@@ -176,7 +177,7 @@ class AliEventTag : public TObject {
   Float_t   fZDCProton1Energy;             //ZDC info - proton
   Float_t   fZDCNeutron2Energy;                    //ZDC info - neutron
   Float_t   fZDCProton2Energy;             //ZDC info - proton
-  Float_t   fZDCEMEnergy;                  //ZDC info - em
+  Float_t   fZDCEMEnergy[2];               //ZDC info - em
   Float_t   fT0VertexZ;                            //T0 info
   Int_t     fNumberOfTracks;               //Multiplicity
   Int_t     fNumberOfPositiveTracks;       //Multiplicity of positive tracks
@@ -221,7 +222,7 @@ class AliEventTag : public TObject {
   Float_t   fEventPlaneAngle;              //event plane info
   Float_t   fHBTRadii;                      //HBT info
   
-  ClassDef(AliEventTag,8)  //(ClassName, ClassVersion)
+  ClassDef(AliEventTag,9)  //(ClassName, ClassVersion)
     };
 //___________________________________________________________________________
 

diff --git a/STEER/AliEventTagCuts.cxx b/STEER/AliEventTagCuts.cxx
index 26a01c6ef801e6bb93f8da4ab83fe64dbe513d59..c446a9a2ec2c7b291e74dc2631c6ca3e3b2cfbce 100644 (file)
--- a/STEER/AliEventTagCuts.cxx
+++ b/STEER/AliEventTagCuts.cxx
@@ -413,7 +413,7 @@ void AliEventTagCuts::SetZDCProton2Range(Float_t low, Float_t high) {
 }
 //___________________________________________________________________________
 void AliEventTagCuts::SetZDCEMRange(Float_t low, Float_t high) {
-  //Sets the ZDC's e/m energy range 
+  //Sets the ZDC's em energy range 
   //and the corresponding flag to kTRUE if the cut is used.
   fZDCEMEnergyMin = low;
   fZDCEMEnergyMax = high;
@@ -846,7 +846,7 @@ Bool_t AliEventTagCuts::IsAccepted(AliEventTag *EvTag) const {
       return kFALSE; 
   
   if(fZDCEMEnergyFlag)
-    if((EvTag->GetZDCEMEnergy() < fZDCEMEnergyMin) || (EvTag->GetZDCEMEnergy() > fZDCEMEnergyMax))
+    if((EvTag->GetZDCEMEnergy(1) < fZDCEMEnergyMin) || (EvTag->GetZDCEMEnergy(1) > fZDCEMEnergyMax))
       return kFALSE; 
   
   if(fT0VertexZFlag)

diff --git a/STEER/AliMCEvent.h b/STEER/AliMCEvent.h
index b076edff2376960e6fb93728fc080e2383d48d29..2c5f216ce6ce8c1d17c6b6899cc66b1d11f9dc2e 100644 (file)
--- a/STEER/AliMCEvent.h
+++ b/STEER/AliMCEvent.h
@@ -77,13 +77,13 @@ public:
     
     virtual UInt_t    GetEventType()         const         {return 0;}
 
-    virtual ULong64_t GetTriggerMask()       const {return 0;}
-    virtual UChar_t   GetTriggerCluster()    const {return 0;}
-    virtual Double_t  GetZDCN1Energy()       const {return 0.;}
-    virtual Double_t  GetZDCP1Energy()       const {return 0.;}
-    virtual Double_t  GetZDCN2Energy()       const {return 0.;}
-    virtual Double_t  GetZDCP2Energy()       const {return 0.;}
-    virtual Double_t  GetZDCEMEnergy()       const {return 0.;}
+    virtual ULong64_t GetTriggerMask()        const {return 0;}
+    virtual UChar_t   GetTriggerCluster()     const {return 0;}
+    virtual Double_t  GetZDCN1Energy()        const {return 0.;}
+    virtual Double_t  GetZDCP1Energy()        const {return 0.;}
+    virtual Double_t  GetZDCN2Energy()        const {return 0.;}
+    virtual Double_t  GetZDCP2Energy()        const {return 0.;}
+    virtual Double_t  GetZDCEMEnergy(Int_t i) const {return 0.;}
     // Tracks
     virtual AliMCParticle *GetTrack(Int_t i) const;
     virtual Int_t     GetNumberOfTracks()    const {return fNparticles;}

diff --git a/STEER/AliReconstruction.cxx b/STEER/AliReconstruction.cxx
index 210b93c0c15be8775a1d518444d59e8132e79106..2e8e81fbc702e46eb347e00c4251ccf3380ebae2 100644 (file)
--- a/STEER/AliReconstruction.cxx
+++ b/STEER/AliReconstruction.cxx
@@ -2029,7 +2029,7 @@ void AliReconstruction::ESDFile2AODFile(TFile* esdFile, TFile* aodFile)
     header->SetZDCP1Energy     (esd->GetZDCP1Energy()     );
     header->SetZDCN2Energy     (esd->GetZDCN2Energy()     );
     header->SetZDCP2Energy     (esd->GetZDCP2Energy()     );
-    header->SetZDCEMEnergy     (esd->GetZDCEMEnergy()     );
+    header->SetZDCEMEnergy     (esd->GetZDCEMEnergy(0),esd->GetZDCEMEnergy(1));
     header->SetRefMultiplicity   (nTracks);
     header->SetRefMultiplicityPos(nPosTracks);
     header->SetRefMultiplicityNeg(nTracks - nPosTracks);

diff --git a/STEER/AliVEvent.h b/STEER/AliVEvent.h
index 860b06c5c3feaf44cc52e5cfbe45b749f0e19869..92a38548d17ff9021ff76ff0dfbe17f74852f1a2 100644 (file)
--- a/STEER/AliVEvent.h
+++ b/STEER/AliVEvent.h
@@ -74,7 +74,7 @@ public:
   virtual Double_t  GetZDCP1Energy() const = 0;
   virtual Double_t  GetZDCN2Energy() const = 0;
   virtual Double_t  GetZDCP2Energy() const = 0;
-  virtual Double_t  GetZDCEMEnergy() const = 0;
+  virtual Double_t  GetZDCEMEnergy(Int_t i) const = 0;
  
   // Tracks
   virtual AliVParticle *GetTrack(Int_t i) const = 0;

diff --git a/ZDC/AliZDCReco.cxx b/ZDC/AliZDCReco.cxx
index 009ebf5ec57ed5046fb20f83e406cb6a46239ee2..62a86bf46b0706e74fa973d3574c6e9379450964 100644 (file)
--- a/ZDC/AliZDCReco.cxx
+++ b/ZDC/AliZDCReco.cxx
@@ -37,7 +37,8 @@ AliZDCReco::AliZDCReco() :
   fZN2Energy(0),
   fZP2Energy(0),
   //
-  fZEMsignal(0),
+  fZEM1signal(0),
+  fZEM2signal(0),
   //
   fNDetSpecNLeft(0),
   fNDetSpecPLeft(0),
@@ -78,7 +79,7 @@ AliZDCReco::AliZDCReco(Float_t ezn1, Float_t ezp1, Float_t ezn2, Float_t ezp2,
             Float_t* ezn2tow, Float_t* ezp2tow, 
             Float_t* ezn1siglr, Float_t* ezp1siglr,
             Float_t* ezn2siglr, Float_t* ezp2siglr,
-            Float_t ezem, 
+            Float_t ezem1, Float_t ezem2,
             //    
             Int_t detspnLeft,  Int_t detsppLeft, Int_t detspnRight,
             Int_t detsppRight,  Int_t trspnLeft, Int_t trsppLeft, 
@@ -92,7 +93,8 @@ AliZDCReco::AliZDCReco(Float_t ezn1, Float_t ezp1, Float_t ezn2, Float_t ezp2,
   fZN2Energy(ezn2),
   fZP2Energy(ezp2),
   //
-  fZEMsignal(ezem),
+  fZEM1signal(ezem1),
+  fZEM2signal(ezem2),
   //
   fNDetSpecNLeft(detspnLeft),
   fNDetSpecPLeft(detsppLeft),
@@ -148,7 +150,8 @@ AliZDCReco::AliZDCReco(const AliZDCReco &oldreco) :
      fZP2SigLowRes[i] = oldreco.GetZP2SigLowRes(i);
   }
   //
-  fZEMsignal = oldreco.GetZEMsignal(); 
+  fZEM1signal = oldreco.GetZEM1signal();       
+  fZEM2signal = oldreco.GetZEM2signal();       
   //   
   fNDetSpecNLeft = oldreco.GetNDetSpecNLeft(); 
   fNDetSpecPLeft = oldreco.GetNDetSpecPLeft(); 
@@ -170,13 +173,14 @@ void AliZDCReco::Print(Option_t *) const {
   //
   // Printing Reconstruction Parameters
   //
-  printf(" \t ---   Reconstruction -> EZN = %f TeV, EZP = %f TeV,  EZEM = %f GeV \n "          
+  printf(" \t ---   Reconstruction -> EZN1 = %f TeV, EZP1 = %f TeV,  EZEM1 = %f GeV ,  EZEM2 = %f GeV \n "             
+        "EZN2 = %f TeV, EZP2 = %f TeV \n"
         " \t NDetSpecNLeft = %d, NDetSpecPLeft = %d, NspecnLeft = %d,"
         " NspecpLeft = %d, NpartLeft = %d"
         " \t NDetSpecNRight = %d, NDetSpecPRight = %d, NspecnRight = %d,"
         " NspecpRight = %d, NpartRight = %d"
         " \t b = %f fm\n ", 
-        fZN1Energy,fZP1Energy,fZEMsignal,
+        fZN1Energy,fZP1Energy,fZEM1signal,fZEM2signal, fZN2Energy, fZP2Energy,
         fNDetSpecNLeft,fNDetSpecPLeft,fNTrueSpecNLeft,fNTrueSpecPLeft,fNPartLeft,
         fNDetSpecNRight,fNDetSpecPRight,fNTrueSpecNRight,fNTrueSpecPRight,fNPartRight,
         fImpPar);

diff --git a/ZDC/AliZDCReco.h b/ZDC/AliZDCReco.h
index 6ae5393557926856797d8383911c9e038e6025bc..b836cae8090fa651835995009702a0e25c0d070c 100644 (file)
--- a/ZDC/AliZDCReco.h
+++ b/ZDC/AliZDCReco.h
@@ -18,7 +18,7 @@ public:
             Float_t* ezn2tow, Float_t* ezp2tow, 
             Float_t* ezn1siglr, Float_t* ezp1siglr,
             Float_t* ezn2siglr, Float_t* ezp2siglr,
-            Float_t ezem, 
+            Float_t ezem1, Float_t ezem2, 
             //    
             Int_t detspnLeft,  Int_t detsppLeft, Int_t detspnRight, Int_t detsppRight,  
             Int_t trspnLeft, Int_t trsppLeft, Int_t trspLeft, 
@@ -45,7 +45,8 @@ public:
   virtual Float_t GetZN2SigLowRes(Int_t tow)  const {return fZN2SigLowRes[tow];}
   virtual Float_t GetZP2SigLowRes(Int_t tow)  const {return fZP2SigLowRes[tow];}
   //
-  virtual Float_t GetZEMsignal()   const  {return fZEMsignal;}
+  virtual Float_t GetZEM1signal()   const  {return fZEM1signal;}
+  virtual Float_t GetZEM2signal()   const  {return fZEM2signal;}
   //
   virtual Int_t   GetNDetSpecNLeft()   const {return fNDetSpecNLeft;}
   virtual Int_t   GetNDetSpecPLeft()   const {return fNDetSpecPLeft;}
@@ -81,7 +82,8 @@ private:
   Float_t fZN2SigLowRes[5]; // Energy in ZN2 towers - low res ch.
   Float_t fZP2SigLowRes[5]; // Energy in ZP2 towers - low res ch.
   //
-  Float_t fZEMsignal;  // Signal in EM ZDC
+  Float_t fZEM1signal; // Signal in EM1 ZDC
+  Float_t fZEM2signal; // Signal in EM2 ZDC
   //
   Int_t          fNDetSpecNLeft;  // Number of spectator neutrons detected
   Int_t          fNDetSpecPLeft;  // Number of spectator protons detected
@@ -98,7 +100,7 @@ private:
   Float_t fImpPar;     // Estimate of the impact parameter
 
 
-  ClassDef(AliZDCReco,3)  // RecPoints for the Zero Degree Calorimeters
+  ClassDef(AliZDCReco,4)  // RecPoints for the Zero Degree Calorimeters
 };
  
 #endif

diff --git a/ZDC/AliZDCReconstructor.cxx b/ZDC/AliZDCReconstructor.cxx
index 41a103b32744c7cf3f11de8b3eeaf9dd46cf63d3..a68a8406325484b56932ca768565a8789f0939d1 100644 (file)
--- a/ZDC/AliZDCReconstructor.cxx
+++ b/ZDC/AliZDCReconstructor.cxx
@@ -27,6 +27,7 @@
 #include "AliRunLoader.h"
 #include "AliRawReader.h"
 #include "AliESDEvent.h"
+#include "AliESDZDC.h"
 #include "AliZDCDigit.h"
 #include "AliZDCRawStream.h"
 #include "AliZDCReco.h"
@@ -100,8 +101,8 @@ void AliZDCReconstructor::Reconstruct(TTree* digitsTree, TTree* clustersTree) co
   // Works on the current event
     
   // Retrieving calibration data  
-  Float_t meanPed[47];
-  for(Int_t jj=0; jj<47; jj++) meanPed[jj] = fPedData->GetMeanPed(jj);
+  Float_t meanPed[48];
+  for(Int_t jj=0; jj<48; jj++) meanPed[jj] = fPedData->GetMeanPed(jj);
 
   // get digits
   AliZDCDigit digit;
@@ -110,91 +111,91 @@ void AliZDCReconstructor::Reconstruct(TTree* digitsTree, TTree* clustersTree) co
 
   // loop over digits
   Float_t tZN1CorrHG[]={0.,0.,0.,0.,0.}, tZP1CorrHG[]={0.,0.,0.,0.,0.}; 
-  Float_t dZEMCorrHG=0.; 
+  Float_t dZEM1CorrHG=0., dZEM2CorrHG=0.; 
   Float_t tZN2CorrHG[]={0.,0.,0.,0.,0.}, tZP2CorrHG[]={0.,0.,0.,0.,0.};
   Float_t tZN1CorrLG[]={0.,0.,0.,0.,0.}, tZP1CorrLG[]={0.,0.,0.,0.,0.};
-  Float_t dZEMCorrLG=0.; 
+  Float_t dZEM1CorrLG=0., dZEM2CorrLG=0.; 
   Float_t tZN2CorrLG[]={0.,0.,0.,0.,0.}, tZP2CorrLG[]={0.,0.,0.,0.,0.};
   
   //printf("\n\t # of digits in tree: %d\n",(Int_t) digitsTree->GetEntries());
   for (Int_t iDigit = 0; iDigit < (digitsTree->GetEntries()/2); iDigit++) {
-    digitsTree->GetEntry(iDigit);
-    if (!pdigit) continue;
-    //pdigit->Print("");
-    //  
-    Int_t det = digit.GetSector(0);
-    Int_t quad = digit.GetSector(1);
-    Int_t pedindex = -1;
-    //printf("\n\t #%d det %d quad %d", iDigit, det, quad);
-    //
+   digitsTree->GetEntry(iDigit);
+   if (!pdigit) continue;
+   //pdigit->Print("");
+   //  
+   Int_t det = digit.GetSector(0);
+   Int_t quad = digit.GetSector(1);
+   Int_t pedindex = -1;
+   //printf("\n\t Digit #%d det %d quad %d", iDigit, det, quad);
+   //
+   if(quad != 5){ // ZDC (not reference PTMs!)
     if(det == 1){ // *** ZN1
        pedindex = quad;
        tZN1CorrHG[quad] = (Float_t) (digit.GetADCValue(0)-meanPed[pedindex]);
        if(tZN1CorrHG[quad]<0.) tZN1CorrHG[quad] = 0.;
-       tZN1CorrLG[quad] = (Float_t) (digit.GetADCValue(1)-meanPed[pedindex+5]);
+       tZN1CorrLG[quad] = (Float_t) (digit.GetADCValue(1)-meanPed[pedindex+24]);
        if(tZN1CorrLG[quad]<0.) tZN1CorrLG[quad] = 0.;
        //printf("\t pedindex %d tZN1CorrHG[%d] = %1.0f tZN1CorrLG[%d] = %1.0f", 
        //      pedindex, quad, tZN1CorrHG[quad], quad, tZN1CorrLG[quad]);
     }
     else if(det == 2){ // *** ZP1
-       pedindex = quad+10;
+       pedindex = quad+5;
        tZP1CorrHG[quad] = (Float_t) (digit.GetADCValue(0)-meanPed[pedindex]);
        if(tZP1CorrLG[quad]<0.) tZP1CorrLG[quad] = 0.;
-       tZP1CorrLG[quad] = (Float_t) (digit.GetADCValue(1)-meanPed[pedindex+5]);
+       tZP1CorrLG[quad] = (Float_t) (digit.GetADCValue(1)-meanPed[pedindex+24]);
        if(tZP1CorrHG[quad]<0.) tZP1CorrHG[quad] = 0.;
        //printf("\t pedindex %d tZP1CorrHG[%d] = %1.0f tZP1CorrLG[%d] = %1.0f", 
        //      pedindex, quad, tZP1CorrHG[quad], quad, tZP1CorrLG[quad]);
     }
     else if(det == 3){
        if(quad == 1){      // *** ZEM1  
-        pedindex = quad+19;
-         dZEMCorrHG += (Float_t) (digit.GetADCValue(0)-meanPed[pedindex]); 
-         if(dZEMCorrHG<0.) dZEMCorrHG = 0.;
-         dZEMCorrLG += (Float_t) (digit.GetADCValue(1)-meanPed[pedindex+2]); 
-         if(dZEMCorrLG<0.) dZEMCorrLG = 0.;
+        pedindex = quad+9;
+         dZEM1CorrHG += (Float_t) (digit.GetADCValue(0)-meanPed[pedindex]); 
+         if(dZEM1CorrHG<0.) dZEM1CorrHG = 0.;
+         dZEM1CorrLG += (Float_t) (digit.GetADCValue(1)-meanPed[pedindex+24]); 
+         if(dZEM1CorrLG<0.) dZEM1CorrLG = 0.;
          //printf("\t pedindex %d ADC(0) = %d ped = %1.0f ADCCorr = %1.0f\n", 
-        //     pedindex, digit.GetADCValue(0), meanPed[pedindex], dZEMCorrHG);
+        //     pedindex, digit.GetADCValue(0), meanPed[pedindex], dZEM1CorrHG);
          //printf("\t pedindex %d ADC(1) = %d ped = %1.0f ADCCorr = %1.0f\n", 
-        //     pedindex+2, digit.GetADCValue(1), meanPed[pedindex+2], dZEMCorrLG);
-         ////printf("\t pedindex %d dZEMCorrHG = %1.0f dZEMCorrLG = %1.0f\n", pedindex, dZEMCorrHG, dZEMCorrLG);
+        //     pedindex+24, digit.GetADCValue(1), meanPed[pedindex+24], dZEM1CorrLG);
        }
-       else if(quad == 2){  // *** ZEM1
-        pedindex = quad+19;
-         dZEMCorrHG += (Float_t) (digit.GetADCValue(0)-meanPed[pedindex]); 
-         if(dZEMCorrHG<0.) dZEMCorrHG = 0.;
-         dZEMCorrLG += (Float_t) (digit.GetADCValue(1)-meanPed[pedindex+2]); 
-         if(dZEMCorrLG<0.) dZEMCorrLG = 0.;
+       else if(quad == 2){  // *** ZEM2
+        pedindex = quad+9;
+         dZEM2CorrHG += (Float_t) (digit.GetADCValue(0)-meanPed[pedindex]); 
+         if(dZEM2CorrHG<0.) dZEM2CorrHG = 0.;
+         dZEM2CorrLG += (Float_t) (digit.GetADCValue(1)-meanPed[pedindex+24]); 
+         if(dZEM2CorrLG<0.) dZEM2CorrLG = 0.;
          //printf("\t pedindex %d ADC(0) = %d ped = %1.0f ADCCorr = %1.0f\n", 
-        //     pedindex, digit.GetADCValue(0), meanPed[pedindex], dZEMCorrHG);
+        //     pedindex, digit.GetADCValue(0), meanPed[pedindex], dZEM2CorrHG);
          //printf("\t pedindex %d ADC(1) = %d ped = %1.0f ADCCorr = %1.0f\n", 
-        //     pedindex+2, digit.GetADCValue(1),meanPed[pedindex+2], dZEMCorrLG);
-         ////printf("\t pedindex %d dZEMCorrHG = %1.0f dZEMCorrLG = %1.0f\n", pedindex, dZEMCorrHG, dZEMCorrLG);
+        //     pedindex+2, digit.GetADCValue(1),meanPed[pedindex+2], dZEM2CorrLG);
        }
     }
     else if(det == 4){  // *** ZN2
-       pedindex = quad+24;
+       pedindex = quad+12;
        tZN2CorrHG[quad] = (Float_t) (digit.GetADCValue(0)-meanPed[pedindex]);
        if(tZN2CorrHG[quad]<0.) tZN2CorrHG[quad] = 0.;
-       tZN2CorrLG[quad] = (Float_t) (digit.GetADCValue(1)-meanPed[pedindex+5]);
+       tZN2CorrLG[quad] = (Float_t) (digit.GetADCValue(1)-meanPed[pedindex+24]);
        if(tZN2CorrLG[quad]<0.) tZN2CorrLG[quad] = 0.;
        //printf("\t pedindex %d tZN2CorrHG[%d] = %1.0f tZN2CorrLG[%d] = %1.0f\n", 
        //      pedindex, quad, tZN2CorrHG[quad], quad, tZN2CorrLG[quad]);
     }
     else if(det == 5){  // *** ZP2 
-       pedindex = quad+34;
+       pedindex = quad+17;
        tZP2CorrHG[quad] = (Float_t) (digit.GetADCValue(0)-meanPed[pedindex]);
        if(tZP2CorrHG[quad]<0.) tZP2CorrHG[quad] = 0.;
-       tZP2CorrLG[quad] = (Float_t) (digit.GetADCValue(1)-meanPed[pedindex+5]);
+       tZP2CorrLG[quad] = (Float_t) (digit.GetADCValue(1)-meanPed[pedindex+24]);
        if(tZP2CorrLG[quad]<0.) tZP2CorrLG[quad] = 0.;
        //printf("\t pedindex %d tZP2CorrHG[%d] = %1.0f tZP2CorrLG[%d] = %1.0f\n", 
        //      pedindex, quad, tZP2CorrHG[quad], quad, tZP2CorrLG[quad]);
     }
+   }
   }
 
   // reconstruct the event
     ReconstructEvent(clustersTree, tZN1CorrHG, tZP1CorrHG, tZN2CorrHG, 
        tZP2CorrHG, tZN1CorrLG, tZP1CorrLG, tZN2CorrLG, 
-       tZP2CorrLG, dZEMCorrHG);
+       tZP2CorrLG, dZEM1CorrHG, dZEM2CorrHG);
 
 }
 
@@ -205,66 +206,70 @@ void AliZDCReconstructor::Reconstruct(AliRawReader* rawReader, TTree* clustersTr
   // Works on the current event
   
   // Retrieving calibration data  
-  Float_t meanPed[47];
-  for(Int_t jj=0; jj<47; jj++) meanPed[jj] = fPedData->GetMeanPed(jj);
+  Float_t meanPed[48];
+  for(Int_t jj=0; jj<48; jj++) meanPed[jj] = fPedData->GetMeanPed(jj);
 
   rawReader->Reset();
 
   // loop over raw data rawDatas
   Float_t tZN1CorrHG[]={0.,0.,0.,0.,0.}, tZP1CorrHG[]={0.,0.,0.,0.,0.};
-  Float_t dZEMCorrHG=0.;
+  Float_t dZEM1CorrHG=0., dZEM2CorrHG=0.;
   Float_t tZN2CorrHG[]={0.,0.,0.,0.,0.}, tZP2CorrHG[]={0.,0.,0.,0.,0.};
   Float_t tZN1CorrLG[]={0.,0.,0.,0.,0.}, tZP1CorrLG[]={0.,0.,0.,0.,0.};
-  Float_t dZEMCorrLG=0.; 
+  Float_t dZEM1CorrLG=0., dZEM2CorrLG=0.; 
   Float_t tZN2CorrLG[]={0.,0.,0.,0.,0.}, tZP2CorrLG[]={0.,0.,0.,0.,0.};
   //
   AliZDCRawStream rawData(rawReader);
   while (rawData.Next()) {
     if(rawData.IsADCDataWord()){
-      Int_t det = rawData.GetSector(0);
-      Int_t quad = rawData.GetSector(1);
-      Int_t gain = rawData.GetADCGain();
-      Int_t pedindex;
-      //
+     Int_t det = rawData.GetSector(0);
+     Int_t quad = rawData.GetSector(1);
+     Int_t gain = rawData.GetADCGain();
+     Int_t pedindex=0;
+     //
+     if(quad !=5){ // ZDCs (not reference PTMs)
       if(det == 1){    
         pedindex = quad;
         if(gain == 0) tZN1CorrHG[quad]  += (Float_t) (rawData.GetADCValue()-meanPed[pedindex]); 
-        else tZN1CorrLG[quad]  += (Float_t) (rawData.GetADCValue()-meanPed[pedindex+5]); 
+        else tZN1CorrLG[quad]  += (Float_t) (rawData.GetADCValue()-meanPed[pedindex+24]); 
       }
       else if(det == 2){ 
-        pedindex = quad+10;
+        pedindex = quad+5;
         if(gain == 0) tZP1CorrHG[quad]  += (Float_t) (rawData.GetADCValue()-meanPed[pedindex]); 
-        else tZP1CorrLG[quad]  += (Float_t) (rawData.GetADCValue()-meanPed[pedindex+5]); 
+        else tZP1CorrLG[quad]  += (Float_t) (rawData.GetADCValue()-meanPed[pedindex+24]); 
       }
       else if(det == 3){ 
         if(quad==1){    
-          pedindex = quad+20;
-          if(gain == 0) dZEMCorrHG += (Float_t) (rawData.GetADCValue()-meanPed[pedindex]); 
-          else dZEMCorrLG += (Float_t) (rawData.GetADCValue()-meanPed[pedindex+2]); 
+          pedindex = quad+9;
+          if(gain == 0) dZEM1CorrHG += (Float_t) (rawData.GetADCValue()-meanPed[pedindex]); 
+          else dZEM1CorrLG += (Float_t) (rawData.GetADCValue()-meanPed[pedindex+24]); 
         }
         else if(quad==2){ 
-          pedindex = rawData.GetSector(1)+21;
-          if(gain == 0) dZEMCorrHG += (Float_t) (rawData.GetADCValue()-meanPed[pedindex]); 
-          else dZEMCorrLG += (Float_t) (rawData.GetADCValue()-meanPed[pedindex+2]); 
+          pedindex = quad+9;
+          if(gain == 0) dZEM2CorrHG += (Float_t) (rawData.GetADCValue()-meanPed[pedindex]); 
+          else dZEM2CorrLG += (Float_t) (rawData.GetADCValue()-meanPed[pedindex+24]); 
         }
       }
       else if(det == 4){       
-        pedindex = rawData.GetSector(1)+24;
+        pedindex = quad+12;
         if(gain == 0) tZN2CorrHG[quad]  += (Float_t) (rawData.GetADCValue()-meanPed[pedindex]); 
-        else tZN2CorrLG[quad]  += (Float_t) (rawData.GetADCValue()-meanPed[pedindex+2]); 
+        else tZN2CorrLG[quad]  += (Float_t) (rawData.GetADCValue()-meanPed[pedindex+24]); 
       }
       else if(det == 5){
-        pedindex = rawData.GetSector(1)+34;
+        pedindex = quad+17;
         if(gain == 0) tZP2CorrHG[quad]  += (Float_t) (rawData.GetADCValue()-meanPed[pedindex]); 
-        else tZP2CorrLG[quad]  += (Float_t) (rawData.GetADCValue()-meanPed[pedindex+5]); 
+        else tZP2CorrLG[quad]  += (Float_t) (rawData.GetADCValue()-meanPed[pedindex+24]); 
       }
-    }
+      printf("\t AliZDCReconstructor - det %d quad %d res %d -> Ped[%d] = %1.0f\n", 
+        det,quad,gain, pedindex, meanPed[pedindex]);
+     }
+    }//IsADCDataWord
   }
     
   // reconstruct the event
     ReconstructEvent(clustersTree, tZN1CorrHG, tZP1CorrHG, tZN2CorrHG, 
        tZP2CorrHG, tZN1CorrLG, tZP1CorrLG, tZN2CorrLG, 
-       tZP2CorrLG, dZEMCorrHG);
+       tZP2CorrLG, dZEM1CorrHG, dZEM2CorrHG);
 
 }
 
@@ -274,7 +279,7 @@ void AliZDCReconstructor::ReconstructEvent(TTree *clustersTree,
                Float_t* ZN2ADCCorrHG, Float_t* ZP2ADCCorrHG, 
                Float_t* ZN1ADCCorrLG, Float_t* ZP1ADCCorrLG, 
                Float_t* ZN2ADCCorrLG, Float_t* ZP2ADCCorrLG, 
-               Float_t corrADCZEMHG) const
+               Float_t corrADCZEM1HG, Float_t corrADCZEM2HG) const
 {
   // ***** Reconstruct one event
   
@@ -445,6 +450,8 @@ void AliZDCReconstructor::ReconstructEvent(TTree *clustersTree,
   //
   // *** RECONSTRUCTION FROM REAL DATA
   //
+  Float_t corrADCZEMHG = corrADCZEM1HG + corrADCZEM2HG;
+  //
   if(corrADCZEMHG > supValueZEM){
     nGenSpecNLeft  = (Int_t) (fZNCen->Eval(calibSumZN1HG));
     nGenSpecPLeft  = (Int_t) (fZPCen->Eval(calibSumZP1HG));
@@ -507,7 +514,7 @@ void AliZDCReconstructor::ReconstructEvent(TTree *clustersTree,
   AliZDCReco reco(calibSumZN1HG, calibSumZP1HG, calibSumZN2HG, calibSumZP2HG, 
                  calibTowZN1LG, calibTowZN2LG, calibTowZP1LG, calibTowZP2LG, 
                  calibTowZN1LG, calibTowZP1LG, calibTowZN2LG, calibTowZP2LG,
-                 corrADCZEMHG, 
+                 corrADCZEM1HG, corrADCZEM2HG,
                  nDetSpecNLeft, nDetSpecPLeft, nDetSpecNRight, nDetSpecPRight, 
                  nGenSpecNLeft, nGenSpecPLeft, nGenSpecLeft, nGenSpecNRight, 
                  nGenSpecPRight, nGenSpecRight,
@@ -532,22 +539,32 @@ void AliZDCReconstructor::FillZDCintoESD(TTree *clustersTree, AliESDEvent* esd)
 
   clustersTree->GetEntry(0);
   //
-  esd->SetZDC(reco.GetZN1Energy(), reco.GetZP1Energy(), reco.GetZEMsignal(),
-             reco.GetZN2Energy(), reco.GetZP2Energy(), 
-             reco.GetNPartLeft());
-  //
-  //
-  /*Double_t tZN1Ene[4], tZN2Ene[4];
-  for(Int_t i=0; i<4; i++){
+  AliESDZDC * esdzdc = esd->GetESDZDC();
+  Float_t tZN1Ene[5], tZN2Ene[5], tZP1Ene[5], tZP2Ene[5];
+  Float_t tZN1EneLR[5], tZN2EneLR[5], tZP1EneLR[5], tZP2EneLR[5];
+  for(Int_t i=0; i<5; i++){
      tZN1Ene[i] = reco.GetZN1EnTow(i);
      tZN2Ene[i] = reco.GetZN2EnTow(i);
+     tZP1Ene[i] = reco.GetZP1EnTow(i);
+     tZP2Ene[i] = reco.GetZP2EnTow(i);
+     tZN1EneLR[i] = reco.GetZN1SigLowRes(i);
+     tZN2EneLR[i] = reco.GetZP1SigLowRes(i);
+     tZP1EneLR[i] = reco.GetZN2SigLowRes(i);
+     tZP2EneLR[i] = reco.GetZP2SigLowRes(i);
   }
-  esd->SetZN1TowerEnergy(tZN1Ene);
-  esd->SetZN2TowerEnergy(tZN2Ene);
-  esd->SetZDC(tZN1Ene, tZN2Ene, reco.GetZN1Energy(), reco.GetZP1Energy(), reco.GetZEMsignal(),
-             reco.GetZN2Energy(), reco.GetZP2Energy(), 
+  esdzdc->SetZN1TowerEnergy(tZN1Ene);
+  esdzdc->SetZN2TowerEnergy(tZN2Ene);
+  esdzdc->SetZP1TowerEnergy(tZP1Ene);
+  esdzdc->SetZP2TowerEnergy(tZP2Ene);
+  esdzdc->SetZN1TowerEnergyLR(tZN1EneLR);
+  esdzdc->SetZN2TowerEnergyLR(tZN2EneLR);
+  esdzdc->SetZP1TowerEnergyLR(tZP1EneLR);
+  esdzdc->SetZP2TowerEnergyLR(tZP2EneLR);
+  // 
+  esd->SetZDC(reco.GetZN1Energy(), reco.GetZP1Energy(), reco.GetZEM1signal(), 
+             reco.GetZEM2signal(), reco.GetZN2Energy(), reco.GetZP2Energy(), 
              reco.GetNPartLeft());
-  */
+  //
   
 }
 

diff --git a/ZDC/AliZDCReconstructor.h b/ZDC/AliZDCReconstructor.h
index 3457567922026e972ac049c392f428635e295cd8..0d66b8cc67fd704b0af39080fb7fe7e386c2ba57 100644 (file)
--- a/ZDC/AliZDCReconstructor.h
+++ b/ZDC/AliZDCReconstructor.h
@@ -50,7 +50,8 @@ private:
                Float_t* ZP1ADCCorrHG, Float_t* ZN2ADCCorrHG, 
                Float_t* ZP2ADCCorrHG, Float_t* ZN1ADCCorrLG, 
                Float_t* ZP1ADCCorrLG, Float_t* ZN2ADCCorrLG, 
-               Float_t* ZP2ADCCorrLG, Float_t ZEMADCCorrHG) const;
+               Float_t* ZP2ADCCorrLG, 
+               Float_t ZEM1ADCCorrHG, Float_t ZEM2ADCCorrHG) const;
   void   FillZDCintoESD(TTree *clustersTree, AliESDEvent*esd) const;
 
   TF1*   fZNCen;     //! Nspectator n true vs. EZN