Updates Remi
authorJens Wiechula <Jens.Wiechula@cern.ch>
Thu, 19 Dec 2013 21:50:06 +0000 (22:50 +0100)
committerJens Wiechula <Jens.Wiechula@cern.ch>
Thu, 19 Dec 2013 21:50:06 +0000 (22:50 +0100)
PWGDQ/dielectron/AliDielectron.cxx
PWGDQ/dielectron/AliDielectron.h
PWGDQ/dielectron/AliDielectronPair.cxx
PWGDQ/dielectron/AliDielectronPair.h
PWGDQ/dielectron/AliDielectronVarManager.cxx
PWGDQ/dielectron/AliDielectronVarManager.h

index 3d78d94..bd8ccad 100644 (file)
@@ -132,7 +132,9 @@ AliDielectron::AliDielectron() :
   fTRDpidCorrectionFilename(""),
   fVZEROCalibrationFilename(""),
   fVZERORecenteringFilename(""),
-  fEffMapFilename("")
+  fEffMapFilename(""),
+  fZDCRecenteringFilename("")
+
 {
   //
   // Default constructor
@@ -178,7 +180,8 @@ AliDielectron::AliDielectron(const char* name, const char* title) :
   fTRDpidCorrectionFilename(""),
   fVZEROCalibrationFilename(""),
   fVZERORecenteringFilename(""),
-  fEffMapFilename("")
+  fEffMapFilename(""),
+  fZDCRecenteringFilename("")
 {
   //
   // Named constructor
@@ -230,6 +233,7 @@ void AliDielectron::Init()
   allfiles+=fVZEROCalibrationFilename;
   allfiles+=fVZERORecenteringFilename;
   allfiles+=fEffMapFilename;
+  allfiles+=fZDCRecenteringFilename;
   if(allfiles.Contains("alien://")) TGrid::Connect("alien://",0,0,"t");
 
   if(fEstimatorFilename.Contains(".root"))        AliDielectronVarManager::InitEstimatorAvg(fEstimatorFilename.Data());
@@ -237,7 +241,7 @@ void AliDielectron::Init()
   if(fVZEROCalibrationFilename.Contains(".root")) AliDielectronVarManager::SetVZEROCalibrationFile(fVZEROCalibrationFilename.Data());
   if(fVZERORecenteringFilename.Contains(".root")) AliDielectronVarManager::SetVZERORecenteringFile(fVZERORecenteringFilename.Data());
   if(fEffMapFilename.Contains(".root"))           AliDielectronVarManager::InitEffMap(fEffMapFilename.Data());
-
+  if(fZDCRecenteringFilename.Contains(".root")) AliDielectronVarManager::SetZDCRecenteringFile(fZDCRecenteringFilename.Data());
 
   if (fMixing) fMixing->Init(this);
   if (fHistoArray) {
index 184dde2..909fa86 100644 (file)
@@ -131,6 +131,8 @@ public:
   void SetVZERORecenteringFilename(const Char_t* filename) {fVZERORecenteringFilename = filename;}
   void SetEffMapFilename(const Char_t* filename) {fEffMapFilename = filename;}
 
+  void SetZDCRecenteringFilename(const Char_t* filename) {fZDCRecenteringFilename = filename;}
+
   void SetCentroidCorrFunction(TF1 *fun, UInt_t varx, UInt_t vary=0, UInt_t varz=0);
   void SetWidthCorrFunction(TF1 *fun, UInt_t varx, UInt_t vary=0, UInt_t varz=0);
 
@@ -207,6 +209,7 @@ private:
   TString fVZEROCalibrationFilename;         // file containing VZERO channel-by-channel calibration
   TString fVZERORecenteringFilename;         // file containing VZERO Q-vector recentering averages
   TString fEffMapFilename;                   // file containing single electron efficiencies
+  TString fZDCRecenteringFilename;         // file containing ZDCQ-vector recentering averages
 
   void ProcessMC(AliVEvent *ev1);
   
index aa2a305..d9b12bf 100644 (file)
@@ -738,6 +738,52 @@ Double_t AliDielectronPair::GetPairPlaneAngle(Double_t v0rpH2, Int_t VariNum)con
 }
 
 
+//_______________________________________________
+Double_t AliDielectronPair::PairPlaneMagInnerProduct(Double_t ZDCrpH1) const
+{
+
+  // Calculate inner product of the strong magnetic field and electron pair plane
+
+  if(ZDCrpH1 == 0.) return -9999.;
+
+  Double_t px1=-9999.,py1=-9999.,pz1=-9999.;
+  Double_t px2=-9999.,py2=-9999.,pz2=-9999.;
+
+  px1 = fD1.GetPx();
+  py1 = fD1.GetPy();
+  pz1 = fD1.GetPz();
+
+
+  px2 = fD2.GetPx();
+  py2 = fD2.GetPy();
+  pz2 = fD2.GetPz();
+
+  // normal vector of ee plane
+  Double_t pnorx = py2*pz1 - pz2*py1;
+  Double_t pnory = pz2*px1 - px2*pz1;
+  Double_t pnorz = px2*py1 - py2*px1;
+  Double_t pnor  = TMath::Sqrt( pnorx*pnorx + pnory*pnory + pnorz*pnorz );
+
+  //unit vector
+  Double_t upnx = -9999.;
+  Double_t upny = -9999.;
+  //Double_t upnz = -9999.;
+
+  if (pnor == 0) return -9999.;
+  upnx= pnorx/pnor;
+  upny= pnory/pnor;
+  //upnz= pnorz/pnor;
+
+  //direction of strong magnetic field
+  Double_t magx = TMath::Cos(ZDCrpH1+(TMath::Pi()/2));
+  Double_t magy = TMath::Sin(ZDCrpH1+(TMath::Pi()/2));
+
+  //inner product of strong magnetic field and  ee plane
+  Double_t upnmag = upnx*magx + upny*magy;
+
+  return upnmag;
+}
+
 
 //______________________________________________
 void AliDielectronPair::SetBeamEnergy(AliVEvent *ev, Double_t beamEbyHand)
index 5fe5014..6797755 100644 (file)
@@ -143,6 +143,10 @@ public:
   Double_t GetArmPt()    const;
   void GetDCA(const AliVVertex *primVtx, Double_t d0z0[2]) const;
 
+  // Calculate inner product of strong magnetic field and ee plane
+  Double_t PairPlaneMagInnerProduct(Double_t ZDCrpH1) const;
+
+
   // internal KF particle
   const AliKFParticle& GetKFParticle()       const { return fPair; }
   const AliKFParticle& GetKFFirstDaughter()  const { return fD1;   }
index ef86a30..cb04aa4 100644 (file)
@@ -174,6 +174,9 @@ const char* AliDielectronVarManager::fgkParticleNames[AliDielectronVarManager::k
   {"PairPlaneAngle4Ran",     "#Phi_{4Ran}",                                        "(rad.)"},
   {"RandomRP",               "#Phi_{RanRP}",                                       "(rad.)"},
   {"DeltaPhiRandomRP",       "#Delta #Phi_{RanRP}",                                ""},
+
+  {"PairPlaneMagInPro",      "cos(#Phi)"                                           ""},
+
   {"Cos2PhiCS",              "cos(2#phi_{CS})",                                    ""},
   {"CosTilPhiCS",            "cos(#phi_{CS})",                                     ""},
   {"CosPhiH2",               "cos(2#phi)",                                         ""},
@@ -366,6 +369,12 @@ const char* AliDielectronVarManager::fgkParticleNames[AliDielectronVarManager::k
   {"TPCsub2rpH2uc",          "#Psi^{TPCsub2} (uncorr.)",                           ""},
   {"TPCsub12DiffH2uc",       "cos(2(#Psi^{TPCsub1}-#Psi^{TPCsub2})) (uncorr.)",    ""},
 
+  {"ZDCArpH1",               "#Psi^{ZDCA}"                                         ""},
+  {"ZDCCrpH1",               "#Psi^{ZDCA}"                                         ""},
+  {"ZDCACrpH1",              "#Psi^{ZDCA}"                                         ""},
+  {"kZDCrpResH1",            ""                                                    ""},
+  {"kv0ZDCrpRes",            ""                                                    ""},
+
   {"NTrk",                   "N_{trk}",                                            ""},
   {"Tracks",                 "tracks/per event",                                             ""},
   {"NVtxContrib",            "N_{vtx. contrib.}",                                  ""},
@@ -419,8 +428,10 @@ THnBase*        AliDielectronVarManager::fgEffMap           = 0x0;
 Double_t        AliDielectronVarManager::fgTRDpidEffCentRanges[10][4] = {{0.0}};
 TString         AliDielectronVarManager::fgVZEROCalibrationFile = "";
 TString         AliDielectronVarManager::fgVZERORecenteringFile = "";
+TString         AliDielectronVarManager::fgZDCRecenteringFile = "";
 TProfile2D*     AliDielectronVarManager::fgVZEROCalib[64] = {0x0};
 TProfile2D*     AliDielectronVarManager::fgVZERORecentering[2][2] = {{0x0,0x0},{0x0,0x0}};
+TProfile3D*     AliDielectronVarManager::fgZDCRecentering[3][2] = {{0x0,0x0},{0x0,0x0},{0x0,0x0}};
 Int_t           AliDielectronVarManager::fgCurrentRun = -1;
 Double_t        AliDielectronVarManager::fgData[AliDielectronVarManager::kNMaxValues] = {0.};
 //________________________________________________________________
@@ -440,6 +451,9 @@ AliDielectronVarManager::AliDielectronVarManager() :
   for(Int_t i=0; i<2; ++i) {
     for(Int_t j=0; j<2; ++j) fgVZERORecentering[i][j] = 0x0;
   }
+  for(Int_t i=0; i<3; ++i)
+    for(Int_t j=0; j<2; ++j) fgZDCRecentering[i][j] = 0x0;
+
   gRandom->SetSeed();
 }
 
@@ -460,6 +474,10 @@ AliDielectronVarManager::AliDielectronVarManager(const char* name, const char* t
   for(Int_t i=0; i<2; ++i)
     for(Int_t j=0; j<2; ++j) 
       fgVZERORecentering[i][j] = 0x0;
+  for(Int_t i=0; i<3; ++i)
+    for(Int_t j=0; j<2; ++j) fgZDCRecentering[i][j] = 0x0;
+
+
   gRandom->SetSeed();
 }
 
@@ -480,6 +498,10 @@ AliDielectronVarManager::~AliDielectronVarManager()
   for(Int_t i=0; i<2; ++i)
     for(Int_t j=0; j<2; ++j) 
       if(fgVZERORecentering[i][j]) delete fgVZERORecentering[i][j]; 
+  for(Int_t i=0; i<3; ++i)
+    for(Int_t j=0; j<2; ++j)
+      if(fgZDCRecentering[i][j]) delete fgZDCRecentering[i][j];
+
 }
 
 //________________________________________________________________
index 4a99b14..25cc440 100644 (file)
@@ -23,6 +23,7 @@
 #include <TNamed.h>
 #include <TProfile.h>
 #include <TProfile2D.h>
+#include <TProfile3D.h>
 #include <TH3D.h>
 #include <THnBase.h>
 #include <TFile.h>
@@ -236,6 +237,7 @@ public:
     kRandomRP,                //Random reaction plane
     kDeltaPhiRandomRP,        //delta phi of the pair
 
+    kPairPlaneMagInPro,     // Inner Product of strong magnetic field and ee plane
        kCos2PhiCS,              // Cosine of 2*phi in mother's rest frame in the Collins-Soper picture
     kCosTilPhiCS,            // Shifted phi depending on kThetaCS
     kCosPhiH2,               // cosine of pair phi for 2nd harmonic
@@ -371,6 +373,15 @@ public:
     kTPCsub2rpH2uc,             // TPC reaction plane of the Q vector for 2nd harmonic (uncorrected, sub event 2)
     kTPCsub12DiffH2uc,          // TPC reaction plane difference of sub event 1,2 for 2nd harmonic (uncorrected)
 
+    //ZDC reaction plane(v1 plane) quantities
+
+    kZDCArpH1,                  // ZDC-A reaction plane of the Q vector for 1st harmonic
+    kZDCCrpH1,                  // ZDC-C reaction plane of the Q vector for 1st harmonic
+    kZDCACrpH1,                  // ZDC-AC reaction plane of the Q vector for 1st harmonic
+    kZDCrpResH1,                  // 1st harmonic reaction plane resolution for ZDC
+    kv0ZDCrpRes,                //ZDC reaction plane for 1st harmonic and VZERO reaction plane for 2nd harmonic correlation
+
+
     kNTrk,                   // number of tracks (or tracklets) TODO: ambiguous
     kTracks,                 // track after all cuts
     kNVtxContrib,             // number of primary vertex contibutors
@@ -434,6 +445,7 @@ public:
   static void SetVZEROCalibrationFile(const Char_t* filename) {fgVZEROCalibrationFile = filename;}
   
   static void SetVZERORecenteringFile(const Char_t* filename) {fgVZERORecenteringFile = filename;}
+  static void SetZDCRecenteringFile(const Char_t* filename) {fgZDCRecenteringFile = filename;}
   static void SetPIDResponse(AliPIDResponse *pidResponse) {fgPIDResponse=pidResponse;}
   static AliPIDResponse* GetPIDResponse() { return fgPIDResponse; }
   static void SetEvent(AliVEvent * const ev);
@@ -441,6 +453,7 @@ public:
   static Bool_t GetDCA(const AliAODTrack *track, Double_t d0z0[2]);
   static void SetTPCEventPlane(AliEventplane *const evplane);
   static void GetVzeroRP(const AliVEvent* event, Double_t* qvec, Int_t sideOption);      // 0- V0A; 1- V0C; 2- V0A+V0C
+  static void GetZDCRP(const AliVEvent* event, Double_t qvec[][2]);
   static AliAODVertex* GetVertex(const AliAODEvent *event, AliAODVertex::AODVtx_t vtype);
 
   static TProfile* GetEstimatorHistogram(Int_t period, Int_t type) {return fgMultEstimatorAvg[period][type];}
@@ -479,7 +492,8 @@ private:
 
   static void InitVZEROCalibrationHistograms(Int_t runNo);
   static void InitVZERORecenteringHistograms(Int_t runNo);
-  
+  static void InitZDCRecenteringHistograms(Int_t runNo);
+
   static AliPIDResponse  *fgPIDResponse;        // PID response object
   static AliVEvent       *fgEvent;              // current event pointer
   static AliEventplane   *fgTPCEventPlane;      // current event tpc plane pointer
@@ -494,6 +508,9 @@ private:
   static TProfile2D      *fgVZERORecentering[2][2];   // 2 VZERO sides x 2 Q-vector components
   static Int_t            fgCurrentRun;               // current run number
   
+  static TString          fgZDCRecenteringFile; // file with ZDC Q-vector averages needed for event plane recentering
+  static TProfile3D      *fgZDCRecentering[3][2];   // 2 VZERO sides x 2 Q-vector components
+
   static Double_t fgData[kNMaxValues];        //! data
   
   AliDielectronVarManager(const AliDielectronVarManager &c);
@@ -1439,6 +1456,9 @@ inline void AliDielectronVarManager::FillVarDielectronPair(const AliDielectronPa
   if ( values[AliDielectronVarManager::kDeltaPhiTPCrpH2] < -1.*TMath::Pi() )
     values[AliDielectronVarManager::kDeltaPhiTPCrpH2] += TMath::TwoPi(); 
 
+  //calculate inner product of strong Mag and ee plane 
+  values[AliDielectronVarManager::kPairPlaneMagInPro] = pair->PairPlaneMagInnerProduct(values[AliDielectronVarManager::kZDCACrpH1]);
+
   //Calculate the angle between electrons decay plane and variables 1-4
   values[AliDielectronVarManager::kPairPlaneAngle1A] = pair->GetPairPlaneAngle(values[AliDielectronVarManager::kv0ArpH2],1);
   values[AliDielectronVarManager::kPairPlaneAngle2A] = pair->GetPairPlaneAngle(values[AliDielectronVarManager::kv0ArpH2],2);
@@ -1620,6 +1640,7 @@ inline void AliDielectronVarManager::FillVarVEvent(const AliVEvent *event, Doubl
   if(fgCurrentRun!=event->GetRunNumber()) {
     if(fgVZEROCalibrationFile.Contains(".root")) InitVZEROCalibrationHistograms(event->GetRunNumber());
     if(fgVZERORecenteringFile.Contains(".root")) InitVZERORecenteringHistograms(event->GetRunNumber());
+    if(fgZDCRecenteringFile.Contains(".root")) InitZDCRecenteringHistograms(event->GetRunNumber());
     fgCurrentRun=event->GetRunNumber();
   }
   values[AliDielectronVarManager::kMixingBin]=0;
@@ -1822,6 +1843,18 @@ inline void AliDielectronVarManager::FillVarVEvent(const AliVEvent *event, Doubl
   values[AliDielectronVarManager::kv0C0v0C3DiffH2] = TMath::Cos( 2.*(values[AliDielectronVarManager::kv0C0rpH2] - 
                                                                     values[AliDielectronVarManager::kv0C3rpH2]) ); 
 
+  Double_t ZDCqvec[3][2];
+  memset(ZDCqvec, 0, sizeof(ZDCqvec));
+  GetZDCRP(event, ZDCqvec);
+
+  values[AliDielectronVarManager::kZDCArpH1] = TMath::ATan2(ZDCqvec[0][1], ZDCqvec[0][0]);
+  values[AliDielectronVarManager::kZDCCrpH1] = TMath::ATan2(ZDCqvec[1][1], ZDCqvec[1][0]);
+  values[AliDielectronVarManager::kZDCACrpH1] = TMath::ATan2(ZDCqvec[2][1], ZDCqvec[2][0]);
+
+
+  values[AliDielectronVarManager::kv0ZDCrpRes] = cos(2*(values[AliDielectronVarManager::kZDCArpH1] - values[AliDielectronVarManager::kv0ArpH2]));
+  values[AliDielectronVarManager::kZDCrpResH1] = cos(values[AliDielectronVarManager::kZDCArpH1] - values[AliDielectronVarManager::kZDCCrpH1]);
+
 
 }
 
@@ -2281,6 +2314,38 @@ inline void AliDielectronVarManager::InitVZERORecenteringHistograms(Int_t runNo)
   
 }
 
+inline void AliDielectronVarManager::InitZDCRecenteringHistograms(Int_t runNo) {
+
+  //initialize only once
+  if(fgZDCRecentering[0][0]) return;
+
+  for(Int_t i=0; i<2; ++i)
+    for(Int_t j=0; j<2; ++j)
+      if(fgZDCRecentering[i][j]) {
+        delete fgZDCRecentering[i][j];
+        fgZDCRecentering[i][j] = 0x0;
+      }
+
+  TFile file(fgZDCRecenteringFile.Data());
+  if (!file.IsOpen()) return;
+  cout << fgZDCRecenteringFile << endl;
+  fgZDCRecentering[0][0] = (TProfile3D*)file.Get(Form("RUN%06d_QxA_Recent", runNo));
+  fgZDCRecentering[0][1] = (TProfile3D*)file.Get(Form("RUN%06d_QyA_Recent", runNo));
+  fgZDCRecentering[1][0] = (TProfile3D*)file.Get(Form("RUN%06d_QxC_Recent", runNo));
+  fgZDCRecentering[1][1] = (TProfile3D*)file.Get(Form("RUN%06d_QyC_Recent", runNo));
+  fgZDCRecentering[2][0] = (TProfile3D*)file.Get(Form("RUN%06d_QxAC_Recent", runNo));
+  fgZDCRecentering[2][1] = (TProfile3D*)file.Get(Form("RUN%06d_QyAC_Recent", runNo));
+
+
+  if (fgZDCRecentering[0][0]) fgZDCRecentering[0][0]->SetDirectory(0x0);
+  if (fgZDCRecentering[0][1]) fgZDCRecentering[0][1]->SetDirectory(0x0);
+  if (fgZDCRecentering[1][0]) fgZDCRecentering[1][0]->SetDirectory(0x0);
+  if (fgZDCRecentering[1][1]) fgZDCRecentering[1][1]->SetDirectory(0x0);
+  if (fgZDCRecentering[2][0]) fgZDCRecentering[2][0]->SetDirectory(0x0);
+  if (fgZDCRecentering[2][1]) fgZDCRecentering[2][1]->SetDirectory(0x0);
+
+}
+
 
 inline Double_t AliDielectronVarManager::GetTRDpidEfficiency(Int_t runNo, Double_t centrality, 
                                                             Double_t eta, Double_t trdPhi, Double_t pout,
@@ -2488,6 +2553,97 @@ inline void AliDielectronVarManager::GetVzeroRP(const AliVEvent* event, Double_t
   if(TMath::Abs(qvec[0])>1.0e-10)
     qvec[2] = TMath::ATan2(qvec[1],qvec[0])/2.0;
 }
+inline void AliDielectronVarManager::GetZDCRP(const AliVEvent* event, Double_t qvec[][2]) {
+
+  //
+  // Get the reaction plane from the ZDC detector for first harmonic
+  //
+  //  Q{x,y} = SUM{ri(x,y)*Ei} / SUM{Ei}
+  //
+
+  const Int_t   nZDCSides  = 2;
+  const Int_t   nZDCplanes = 3;
+  const Int_t   Aside = 0, Cside = 1, ACside = 2;
+  const Int_t   nZDCTowers = 4;// number of ZDCtowers
+  const Double_t ZDCTowerCenters[nZDCTowers][2] = { {-1.75, -1.75}, { 1.75, -1.75},
+                                                    {-1.75,  1.75}, { 1.75,  1.75} };
+
+  Double_t   *ZDCTEnergy[nZDCSides]; //reco E in 5 ZDC sectors - high gain chain
+  Double_t    qvecNUM[nZDCplanes][2];
+  Double_t    qvecDEN[nZDCplanes];
+  memset(   qvecNUM,    0,     sizeof(qvecNUM));  //format
+  memset(qvecDEN,     0,     sizeof(qvecDEN));  //format
+
+  Double_t TPCRefMulti = 999, vtxX = 999, vtxY = 999;
+  Int_t multiBin = 0, vtxXBin = 0, vtxYBin = 0;
+  Double_t recentdim[3][3] = { { 50, 0, 2500},   //multiplicity nbin, min, max
+                               { 20, 0.04, 0.08},   //    vertex x nbin, min, max
+                               { 20, 0.25, 0.29} }; //    vertex y nbin, min, max
+
+  AliVZDC* aliZDC = event->GetZDCData();
+  ZDCTEnergy[Aside] = (Double_t *)aliZDC -> GetZNATowerEnergy();
+  ZDCTEnergy[Cside] = (Double_t *)aliZDC -> GetZNCTowerEnergy();
+
+  for(int j = 0;  j < nZDCSides   ; j++){
+    for(int k = 0;   k < nZDCTowers ; k++){
+      qvecNUM[j][0] += ZDCTowerCenters[k][0]*ZDCTEnergy[j][k+1]; //    zdcQ += xE
+      qvecNUM[j][1] += ZDCTowerCenters[k][1]*ZDCTEnergy[j][k+1]; //    zdcQ += yE
+      qvecDEN[j]    += ZDCTEnergy[j][k+1];                   // zdcQsum +=  E
+
+    }
+    if(j == Aside){
+      qvecNUM[j][0] = -qvecNUM[j][0];
+    }
+
+    if(j == Cside){
+      qvecNUM[j][0] = -qvecNUM[j][0];
+      qvecNUM[j][1] = -qvecNUM[j][1];
+    }
+
+
+    qvecNUM[ACside][0] += qvecNUM[j][0];
+    qvecNUM[ACside][1] += qvecNUM[j][1];
+    qvecDEN[ACside] += qvecDEN[j];
+
+  }
+
+  for(int j = 0; j < nZDCplanes; j++){
+    if(qvecDEN[j] != 0){
+      qvec[j][0] = (qvecNUM[j][0] / qvecDEN[j]);
+      qvec[j][1] = (qvecNUM[j][1] / qvecDEN[j]);
+    }
+    else if(qvecDEN[j] == 0) {
+      qvec[j][0] = 999;
+      qvec[j][1] = 999;
+    }
+
+  }
+
+  if(fgZDCRecentering[0][0]){
+    const AliAODEvent* aodEv = static_cast<const AliAODEvent*>(event);
+    AliAODHeader *header = aodEv->GetHeader();
+    if(!header) return;
+    TPCRefMulti = header -> GetTPConlyRefMultiplicity();
+
+    const AliVVertex *primVtx = event->GetPrimaryVertex();
+    if(!primVtx) return;
+    vtxX = primVtx->GetX();
+    vtxY = primVtx->GetY();
+
+    multiBin = (Int_t)((TPCRefMulti-recentdim[0][1])*recentdim[0][0] / (recentdim[0][2] - recentdim[0][1])) + 1;
+    vtxXBin  = (Int_t)((vtxX-recentdim[1][1])*recentdim[1][0] / (recentdim[1][2] - recentdim[1][1])) + 1;
+    vtxYBin  = (Int_t)((vtxY-recentdim[2][1])*recentdim[2][0] / (recentdim[2][2] - recentdim[2][1])) + 1;
+
+    for(int j = 0; j < nZDCplanes; j++)
+      if(qvecDEN[j] != 0){
+        qvec[j][0] -= fgZDCRecentering[j][0] -> GetBinContent(multiBin, vtxXBin, vtxYBin);
+        qvec[j][1] -= fgZDCRecentering[j][1] -> GetBinContent(multiBin, vtxXBin, vtxYBin);
+      }
+  }
+
+}
+
+
 
 //______________________________________________________________________________                                                                                                                                                                                     
 inline AliAODVertex* AliDielectronVarManager::GetVertex(const AliAODEvent* event, AliAODVertex::AODVtx_t vtype) {