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; }
fZDCP1Energy(-999.),
fZDCN2Energy(-999.),
fZDCP2Energy(-999.),
- fZDCEMEnergy(-999.),
fNQTheta(0),
fQTheta(0x0),
fTriggerMask(0),
// default constructor
SetName("header");
+ for(int j=0; j<2; j++) fZDCEMEnergy[j] = -999.;
}
//______________________________________________________________________________
fZDCP1Energy(-999.),
fZDCN2Energy(-999.),
fZDCP2Energy(-999.),
- fZDCEMEnergy(-999.),
fNQTheta(0),
fQTheta(0x0),
fTriggerMask(0),
SetName("header");
SetTitle(title);
+ for(int j=0; j<2; j++) fZDCEMEnergy[j] = -999.;
}
//______________________________________________________________________________
Double_t p1Energy,
Double_t n2Energy,
Double_t p2Energy,
- Double_t emEnergy,
+ Double_t *emEnergy,
ULong64_t trigMask,
UChar_t trigClus,
UInt_t evttype,
fZDCP1Energy(p1Energy),
fZDCN2Energy(n2Energy),
fZDCP2Energy(p2Energy),
- fZDCEMEnergy(emEnergy),
fNQTheta(0),
fQTheta(0x0),
fTriggerMask(trigMask),
SetName("header");
SetTitle(title);
+ for(int j=0; j<2; j++) fZDCEMEnergy[j] = emEnergy[j];
}
//______________________________________________________________________________
fZDCP1Energy(hdr.fZDCP1Energy),
fZDCN2Energy(hdr.fZDCN2Energy),
fZDCP2Energy(hdr.fZDCP2Energy),
- fZDCEMEnergy(hdr.fZDCEMEnergy),
fNQTheta(0),
fQTheta(0x0),
fTriggerMask(hdr.fTriggerMask),
SetName(hdr.fName);
SetTitle(hdr.fTitle);
SetQTheta(hdr.fQTheta, hdr.fNQTheta);
+ SetZDCEMEnergy(hdr.fZDCEMEnergy[0], hdr.fZDCEMEnergy[1]);
}
//______________________________________________________________________________
fZDCP1Energy = hdr.fZDCP1Energy;
fZDCN2Energy = hdr.fZDCN2Energy;
fZDCP2Energy = hdr.fZDCP2Energy;
- fZDCEMEnergy = hdr.fZDCEMEnergy;
fTriggerMask = hdr.fTriggerMask;
fRunNumber = hdr.fRunNumber;
fRefMult = hdr.fRefMult;
SetName(hdr.fName);
SetTitle(hdr.fTitle);
SetQTheta(hdr.fQTheta, hdr.fNQTheta);
+ SetZDCEMEnergy(hdr.fZDCEMEnergy[0], hdr.fZDCEMEnergy[1]);
}
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);
Double_t p1Energy,
Double_t n2Energy,
Double_t p2Energy,
- Double_t emEnergy,
+ Double_t *emEnergy,
ULong64_t fTriggerMask,
UChar_t fTriggerCluster,
UInt_t fEventType,
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; }
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; }
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)
UShort_t fBunchCrossNumber; // BunchCrossingNumber
UChar_t fTriggerCluster; // Trigger cluster (mask)
- ClassDef(AliAODHeader,5);
+ ClassDef(AliAODHeader,6);
};
#endif
// 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
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
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());
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());
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());
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());
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) :
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)
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;
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);
}
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();
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
fZDCProton1Energy(-10.0),
fZDCNeutron2Energy(-10.0),
fZDCProton2Energy(-10.0),
- fZDCEMEnergy(-10.0),
fT0VertexZ(-10.0),
fNumberOfTracks(-10),
fNumberOfPositiveTracks(-10),
fHBTRadii(-10.0)
{
// AliEventTag default constructor
+ for(Int_t i=0; i<2; i++) fZDCEMEnergy[i] = -10.0;
+
}
fZDCProton1Energy(evTag.fZDCProton1Energy),
fZDCNeutron2Energy(evTag.fZDCNeutron2Energy),
fZDCProton2Energy(evTag.fZDCProton2Energy),
- fZDCEMEnergy(evTag.fZDCEMEnergy),
fT0VertexZ(evTag.fT0VertexZ),
fNumberOfTracks(evTag.fNumberOfTracks),
fNumberOfPositiveTracks(evTag.fNumberOfPositiveTracks),
fHBTRadii(evTag.fHBTRadii)
{
// EventTag copy constructor
+ for(Int_t i=0; i<2; i++) fZDCEMEnergy[i] = evTag.fZDCEMEnergy[i];
}
//___________________________________________________________________________
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());
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;}
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;}
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
Float_t fEventPlaneAngle; //event plane info
Float_t fHBTRadii; //HBT info
- ClassDef(AliEventTag,8) //(ClassName, ClassVersion)
+ ClassDef(AliEventTag,9) //(ClassName, ClassVersion)
};
//___________________________________________________________________________
}
//___________________________________________________________________________
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;
return kFALSE;
if(fZDCEMEnergyFlag)
- if((EvTag->GetZDCEMEnergy() < fZDCEMEnergyMin) || (EvTag->GetZDCEMEnergy() > fZDCEMEnergyMax))
+ if((EvTag->GetZDCEMEnergy(1) < fZDCEMEnergyMin) || (EvTag->GetZDCEMEnergy(1) > fZDCEMEnergyMax))
return kFALSE;
if(fT0VertexZFlag)
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;}
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);
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;
fZN2Energy(0),
fZP2Energy(0),
//
- fZEMsignal(0),
+ fZEM1signal(0),
+ fZEM2signal(0),
//
fNDetSpecNLeft(0),
fNDetSpecPLeft(0),
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,
fZN2Energy(ezn2),
fZP2Energy(ezp2),
//
- fZEMsignal(ezem),
+ fZEM1signal(ezem1),
+ fZEM2signal(ezem2),
//
fNDetSpecNLeft(detspnLeft),
fNDetSpecPLeft(detsppLeft),
fZP2SigLowRes[i] = oldreco.GetZP2SigLowRes(i);
}
//
- fZEMsignal = oldreco.GetZEMsignal();
+ fZEM1signal = oldreco.GetZEM1signal();
+ fZEM2signal = oldreco.GetZEM2signal();
//
fNDetSpecNLeft = oldreco.GetNDetSpecNLeft();
fNDetSpecPLeft = oldreco.GetNDetSpecPLeft();
//
// 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);
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,
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;}
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
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
#include "AliRunLoader.h"
#include "AliRawReader.h"
#include "AliESDEvent.h"
+#include "AliESDZDC.h"
#include "AliZDCDigit.h"
#include "AliZDCRawStream.h"
#include "AliZDCReco.h"
// 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;
// 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);
}
// 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);
}
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
//
// *** RECONSTRUCTION FROM REAL DATA
//
+ Float_t corrADCZEMHG = corrADCZEM1HG + corrADCZEM2HG;
+ //
if(corrADCZEMHG > supValueZEM){
nGenSpecNLeft = (Int_t) (fZNCen->Eval(calibSumZN1HG));
nGenSpecPLeft = (Int_t) (fZPCen->Eval(calibSumZP1HG));
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,
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());
- */
+ //
}
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