]> git.uio.no Git - u/mrichter/AliRoot.git/commitdiff
o update package
authorwiechula <wiechula@f7af4fe6-9843-0410-8265-dc069ae4e863>
Mon, 7 May 2012 23:55:54 +0000 (23:55 +0000)
committerwiechula <wiechula@f7af4fe6-9843-0410-8265-dc069ae4e863>
Mon, 7 May 2012 23:55:54 +0000 (23:55 +0000)
12 files changed:
PWGDQ/dielectron/AliAnalysisTaskMultiDielectron.cxx
PWGDQ/dielectron/AliDielectron.cxx
PWGDQ/dielectron/AliDielectron.h
PWGDQ/dielectron/AliDielectronCFdraw.cxx
PWGDQ/dielectron/AliDielectronCFdraw.h
PWGDQ/dielectron/AliDielectronEventCuts.cxx
PWGDQ/dielectron/AliDielectronEventCuts.h
PWGDQ/dielectron/AliDielectronHelper.cxx
PWGDQ/dielectron/AliDielectronMixingHandler.cxx
PWGDQ/dielectron/AliDielectronPID.h
PWGDQ/dielectron/AliDielectronVarManager.cxx
PWGDQ/dielectron/AliDielectronVarManager.h

index caec68f5a3c4dd76dadb20cd57497898bb3aeab7..71abef1d8ac861509d0da26dfea1d0f53fd95d3e 100644 (file)
@@ -222,6 +222,7 @@ void AliAnalysisTaskMultiDielectron::UserExec(Option_t *)
   AliDielectron *die=0;
   Double_t values[AliDielectronVarManager::kNMaxValues]={0};
   Double_t valuesMC[AliDielectronVarManager::kNMaxValues]={0};
+  AliDielectronVarManager::SetEvent(InputEvent());
   AliDielectronVarManager::Fill(InputEvent(),values);
   AliDielectronVarManager::Fill(InputEvent(),valuesMC);
   Bool_t hasMC=AliDielectronMC::Instance()->HasMC();
index 85d744b1f42c1ba97f3f21cb68ae1cc1ed95c92d..98eecae86a50b9517c6e8309184c8485b6241b8d 100644 (file)
@@ -118,7 +118,9 @@ AliDielectron::AliDielectron() :
   fHasMC(kFALSE),
   fStoreRotatedPairs(kFALSE),
   fEstimatorFilename(""),
-  fTRDpidCorrectionFilename("")
+  fTRDpidCorrectionFilename(""),
+  fVZEROCalibrationFilename(""),
+  fVZERORecenteringFilename("")
 {
   //
   // Default constructor
@@ -154,7 +156,9 @@ AliDielectron::AliDielectron(const char* name, const char* title) :
   fHasMC(kFALSE),
   fStoreRotatedPairs(kFALSE),
   fEstimatorFilename(""),
-  fTRDpidCorrectionFilename("")
+  fTRDpidCorrectionFilename(""),
+  fVZEROCalibrationFilename(""),
+  fVZERORecenteringFilename("")
 {
   //
   // Named constructor
@@ -198,7 +202,9 @@ void AliDielectron::Init()
   if (fDebugTree) fDebugTree->SetDielectron(this);
   if(fEstimatorFilename.Contains(".root")) AliDielectronVarManager::InitEstimatorAvg(fEstimatorFilename.Data());
   if(fTRDpidCorrectionFilename.Contains(".root")) AliDielectronVarManager::InitTRDpidEffHistograms(fTRDpidCorrectionFilename.Data());
-
+  if(fVZEROCalibrationFilename.Contains(".root")) AliDielectronVarManager::SetVZEROCalibrationFile(fVZEROCalibrationFilename.Data());
+  if(fVZERORecenteringFilename.Contains(".root")) AliDielectronVarManager::SetVZERORecenteringFile(fVZERORecenteringFilename.Data());
+  
   if (fMixing) fMixing->Init(this);
 } 
 
index b1443a5bb77e7778d90c971d0869ef76368cf989..d73181929e2d39c8a26368e16bc7d1cf7deaf602 100644 (file)
@@ -119,7 +119,8 @@ public:
 
   void SetEstimatorFilename(const Char_t* filename) {fEstimatorFilename = filename;}
   void SetTRDcorrectionFilename(const Char_t* filename) {fTRDpidCorrectionFilename = filename;}
-
+  void SetVZEROCalibrationFilename(const Char_t* filename) {fVZEROCalibrationFilename = filename;}
+  void SetVZERORecenteringFilename(const Char_t* filename) {fVZERORecenteringFilename = filename;}
 
   void SaveDebugTree();
 
@@ -184,6 +185,8 @@ private:
 
   TString fEstimatorFilename;                // name for the pp multiplicity estimators filename
   TString fTRDpidCorrectionFilename;         // name for the file containing the single particle TRD pid corrections
+  TString fVZEROCalibrationFilename;         // file containing VZERO channel-by-channel calibration
+  TString fVZERORecenteringFilename;         // file containing VZERO Q-vector recentering averages
 
   void ProcessMC(AliVEvent *ev1);
   
index b1a9bf8d67314dd7b3b546d33f105be9bd1175cc..0e399ee432887e2a0b972d676e4eb9cf4258ec21 100644 (file)
@@ -416,19 +416,44 @@ TObjArray* AliDielectronCFdraw::CollectHistosProj(const Int_t vars[3], const cha
 }
 
 //________________________________________________________________
-TObjArray* AliDielectronCFdraw::CollectMinvProj(Int_t slice)
+TObjArray* AliDielectronCFdraw::CollectMinvProj(Int_t slice, ECollectType collect, TString var)
 {
   //
-  // Collect invariant mass spectra of slice 'slice' for all pair types
+  // Collect invariant mass spectra of step 'slice' for pair types
   //
   
   TObjArray *arr = new TObjArray();
   arr->SetOwner();
   for (Int_t iType = 0; iType <= AliDielectron::kEv1PMRot; iType++) {
-    fCfContainer->SetRangeUser(fCfContainer->GetVar("PairType"),iType,iType,slice);
-    arr->AddAt(fCfContainer->Project(fCfContainer->GetVar("M"),slice),iType);
+
+    switch (iType) {
+      // same events
+      case AliDielectron::kEv1PP:
+      case AliDielectron::kEv1MM:
+        if(collect==kROT || collect==kME || collect==kMEOS) continue; break;
+        // mixed events
+      case AliDielectron::kEv1PEv2P:
+      case AliDielectron::kEv1MEv2M:
+        if(collect==kROT || collect==kSE || collect==kMEOS) continue; break;
+      case AliDielectron::kEv1MEv2P:
+      case AliDielectron::kEv1PEv2M:
+        if(collect==kROT || collect==kSE) continue; break;
+        // rotations
+      case AliDielectron::kEv1PMRot:
+        if(collect==kSE || collect==kME || collect==kMEOS) continue; break;
+        // unused
+      case AliDielectron::kEv2PP:
+      case AliDielectron::kEv2PM:
+      case AliDielectron::kEv2MM:
+        continue; break;
+    }
+    SetRangeUser("PairType",iType,iType,Form("%d",slice));
+    TH1 *hM=Project(var.Data(),slice);
+    hM->SetDirectory(0x0);
+    hM->SetNameTitle(Form("Minv_%d",iType),Form("M for type %d;M (GeV/c^{2})", iType));
+    arr->AddAt(hM,iType);
   }
-  
+  UnsetRangeUser("PairType",Form("%d",slice));
   return arr;
 }
 
index f7799a631b085ce2cdc9d950a1d7799ad067262f..7148b339c5e554c956eed9faecc85eb94623ad1b 100644 (file)
@@ -34,6 +34,8 @@ class AliCFContainer;
 
 class AliDielectronCFdraw : public TNamed {
 public:
+  enum ECollectType { kSE=0, kME, kMEOS, kROT, kAll };
+  
   AliDielectronCFdraw();
   AliDielectronCFdraw(const char* name, const char* title);
   AliDielectronCFdraw(AliCFContainer *cont);
@@ -64,7 +66,7 @@ public:
 
   TObjArray* CollectHistosProj(const Option_t* varnames, const char* slices);
   TObjArray* CollectHistosProj(const Int_t vars[3], const char* slices);
-  TObjArray* CollectMinvProj(Int_t slice);
+  TObjArray* CollectMinvProj(Int_t slice, ECollectType collect=kAll, TString var="M");
   TH1* Project(const Int_t vars[3], Int_t slice);
   TH1* Project(const Option_t* var, Int_t slice);
   
index 241841a56e181d8138d605b635f8fe1f8949f5c9..a1ee80b30e54654f360ba8ec3fc061f2c0f34b4d 100644 (file)
@@ -199,15 +199,14 @@ Bool_t AliDielectronEventCuts::IsSelectedAOD(TObject* event)
 
   switch(fVtxType){
   case kVtxTracks:
-    fkVertexAOD=ev->GetVertex(AliAODVertex::kPrimary);
-    break;
-  case kVtxTPC:   //  not stored 
     fkVertexAOD=0x0;
     break;
+  case kVtxTPC:            fkVertexAOD=GetPrimaryVertexTPC(ev); 
+    break;
   case kVtxSPD:
-  case kVtxTracksOrSPD:    fkVertexAOD=ev->GetPrimaryVertexSPD(); // == AliAODVertex::kMainSPD
+  case kVtxTracksOrSPD:    fkVertexAOD=ev->GetPrimaryVertexSPD();
     break;
-  case kVtxAny:    fkVertexAOD=ev->GetPrimaryVertex(); // == AliAODVertex::kUndef);
+  case kVtxAny:            fkVertexAOD=ev->GetPrimaryVertex();
     break;
   }
 
@@ -216,21 +215,22 @@ Bool_t AliDielectronEventCuts::IsSelectedAOD(TObject* event)
   if (fMinVtxContributors>0){
     Int_t nCtrb = fkVertexAOD->GetNContributors();
     if (nCtrb<fMinVtxContributors){
-      if (fVtxType==kVtxTracksOrSPD){
-        fkVertexAOD=ev->GetVertex(AliAODVertex::kPrimary);
-        nCtrb = fkVertexAOD->GetNContributors();
-        if (nCtrb<fMinVtxContributors) return kFALSE;
-      } else {
-        return kFALSE;
-      }
+      // if (fVtxType==kVtxTracksOrSPD){
+      //   fkVertexAOD=ev->GetVertex(AliAODVertex::kPrimary);
+      //   nCtrb = fkVertexAOD->GetNContributors();
+      //   if (nCtrb<fMinVtxContributors) return kFALSE;
+      //      } else {
+      return kFALSE;
+      //}
     }
   }
-
+  
 
   if (fVtxZmin<fVtxZmax){
     Double_t zvtx=fkVertexAOD->GetZ();
     if (zvtx<fVtxZmin||zvtx>fVtxZmax) return kFALSE;
   }
+
   /*
   if (fRequireV0and){
     //    if (!fTriggerAnalysis) fTriggerAnalysis=new AliTriggerAnalysis;
index 734fc3a42b875584fa9c47e3fd4ef89a4f763567..c3697d8e1b11260718b8ca46c31fecad5840353d 100644 (file)
@@ -68,6 +68,8 @@ private:
   const AliESDVertex *fkVertex;         //! current vertex
   const AliAODVertex *fkVertexAOD;      //! current vertex AOD
 
+  AliAODVertex* GetPrimaryVertexTPC(AliAODEvent *ev);
+
   AliDielectronEventCuts(const AliDielectronEventCuts &c);
   AliDielectronEventCuts &operator=(const AliDielectronEventCuts &c);
 
@@ -75,6 +77,15 @@ private:
   ClassDef(AliDielectronEventCuts,1)         // Dielectron EventCuts
 };
 
-
+//______________________________________________________________________________
+inline AliAODVertex* GetPrimaryVertexTPC(AliAODEvent *ev){
+  // Get TPC primary vertex
+  Int_t nVertices=ev->GetNumberOfVertices();
+  for(Int_t iVert=0; iVert<nVertices; iVert++){
+    AliAODVertex *v=ev->GetVertex(iVert);
+    if(v->GetType()==AliAODVertex::kMainSPD) return v;
+  }
+  return 0;
+}
 
 #endif
index b9616b9257ea7a8de3e690a5fec6e41db0d84ba9..2a3c494b6d2caa83d839957cec8f791805acb9a0 100644 (file)
@@ -45,6 +45,8 @@
 #include <AliMultiplicity.h>
 #include <AliStack.h>
 
+#include "AliDielectronVarCuts.h"
+#include "AliDielectronTrackCuts.h"
 #include "AliDielectronVarManager.h"
 #include "AliDielectronHelper.h"
 
@@ -230,38 +232,43 @@ Double_t AliDielectronHelper::GetNaccTrckltsCorrected(const AliVEvent *event, Do
 }
 
 //_____________________________________________________________________________
-Int_t AliDielectronHelper::GetNacc(const AliVEvent */*ev*/){
+Int_t AliDielectronHelper::GetNacc(const AliVEvent *ev){
   // put a robust Nacc definition here
 
-  return -1;
-/*  
-  if (!ev || ev->IsA()!=AliESDEvent::Class()) return -1;
-  
-  // basic track cuts for the N_acc definition
-  AliESDtrackCuts esdTC;
-  esdTC.SetMaxDCAToVertexZ(3.0);
-  esdTC.SetMaxDCAToVertexXY(1.0);
-  esdTC.SetEtaRange( -0.9 , 0.9 );
-  esdTC.SetAcceptKinkDaughters(kFALSE);
-  esdTC.SetRequireITSRefit(kTRUE);
-  esdTC.SetRequireTPCRefit(kTRUE);
-  esdTC.SetMinNClustersTPC(70);
-  esdTC.SetMaxChi2PerClusterTPC(4);
-  esdTC.SetClusterRequirementITS(AliESDtrackCuts::kSPD,AliESDtrackCuts::kAny);
+  if (!ev) return -1;
+
+  AliDielectronVarCuts *varCuts = new AliDielectronVarCuts("VarCuts","VarCuts");
+  varCuts->AddCut(AliDielectronVarManager::kImpactParXY, -1.0,   1.0);
+  varCuts->AddCut(AliDielectronVarManager::kImpactParZ,  -3.0,   3.0);
+  varCuts->AddCut(AliDielectronVarManager::kEta,         -0.9,   0.9);
+  varCuts->AddCut(AliDielectronVarManager::kTPCchi2Cl,    0.0,   4.0);   // not filled in AODs?
+  varCuts->AddCut(AliDielectronVarManager::kNclsTPC,     70.0, 160.0);
+  varCuts->AddCut(AliDielectronVarManager::kITSLayerFirstCls,-0.01,1.5); //ITS(0-1) = SPDany
+  varCuts->AddCut(AliDielectronVarManager::kKinkIndex0,  -0.5,   0.5);   //noKinks
+    
+  AliDielectronTrackCuts *trkCuts = new AliDielectronTrackCuts("TrkCuts","TrkCuts");
+  trkCuts->SetRequireITSRefit(kTRUE);
+  trkCuts->SetRequireTPCRefit(kTRUE);
 
   Int_t nRecoTracks = ev->GetNumberOfTracks();
   Int_t nAcc = 0;
-
+  
   for (Int_t iTrack = 0; iTrack < nRecoTracks; iTrack++) {
     AliVParticle* candidate = ev->GetTrack(iTrack);
-    if (esdTC.IsSelected(candidate)) nAcc++;
+    AliVTrack *track        = static_cast<AliVTrack*>(candidate);
+    if (!track) continue;
+    if (varCuts->IsSelected(track) && trkCuts->IsSelected(track)) 
+      nAcc++;
   }
+  
+  delete varCuts;
+  delete trkCuts;
+
+  //  if(nRecoTracks==nAcc) printf(" all (%d) reco tracks are accepted tracks? \n",nAcc);
 
   return nAcc;
-*/
 }
 
-
 //_____________________________________________________________________________
 void AliDielectronHelper::RotateKFParticle(AliKFParticle * kfParticle,Double_t angle, const AliVEvent * const ev){
   // Before rotate needs to be moved to position 0,0,0, ; move back after rotation
index adae74e204a6db22f92601c2bddeb61946c61bca..b43f873f4a40618d3a8a92b3123dc4db85227fda 100644 (file)
@@ -410,8 +410,8 @@ Int_t AliDielectronMixingHandler::FindBin(const Double_t values[], TString *dim)
 
     Int_t pos=TMath::BinarySearch(nRows,bins->GetMatrixArray(),val);
     bin+=sizeAdd*pos;
-    if (dim) (*dim)+=Form("%s: %f; ",AliDielectronVarManager::GetValueName(fEventCuts[i]),val);
-    sizeAdd*=nRows;
+    if (dim) (*dim)+=Form("%s: %f (%d); ",AliDielectronVarManager::GetValueName(fEventCuts[i]),val,pos);
+    sizeAdd*=(nRows-1);
   }
 
   return bin;
index 2280c383a6075d9ad29e5cfc3216ee3b9f206ff2..fa9a91876356e675622b3abfa580abb1452cf17a 100644 (file)
@@ -79,7 +79,7 @@ public:
   static Double_t GetEtaCorr(AliVTrack *track);
 
 private:
-  enum {kNmaxPID=10};
+  enum {kNmaxPID=30};
 
   DetType  fDetType[kNmaxPID];    //detector type of nsigma cut
   AliPID::EParticleType fPartType[kNmaxPID]; //particle type
index 54588a663939b21288f3c02ce8c69f2008251913..29f81625404c5c8844218d01bd53392237199fec 100644 (file)
@@ -114,6 +114,11 @@ const char* AliDielectronVarManager::fgkParticleNames[AliDielectronVarManager::k
   "TOF_nSigma_Protons",
 
   "EMCAL_nSigma_Electrons",
+  "EMCAL_EoverP",
+  "EMCAL_NCells",
+  "EMCAL_M02",
+  "EMCAL_M20",
+  "EMCAL_Dispersion",
 
   "KinkIndex0",
   //
@@ -124,9 +129,11 @@ const char* AliDielectronVarManager::fgkParticleNames[AliDielectronVarManager::k
   "ThetaHE",
   "PhiHE",
   "Cos2PhiHE",
+  "CosTilPhiHE",
   "ThetaCS",
   "PhiCS",
   "Cos2PhiCS",
+  "CosTilPhiCS",
   "DeltaPhiV0ArpH2",        
   "DeltaPhiV0CrpH2",        
   "DeltaPhiV0ACrpH2",       
@@ -218,6 +225,7 @@ const char* AliDielectronVarManager::fgkParticleNames[AliDielectronVarManager::k
 
   "NTrk",
   "Tracks",
+  "NVtxContrib",
   "Nacc",
   "NaccTrcklts",
   "NaccTrcklts0916",
@@ -241,10 +249,11 @@ const char* AliDielectronVarManager::fgkParticleNames[AliDielectronVarManager::k
   "NaccItsPureEsd10Corr",
   "NaccItsPureEsd16Corr",  
     
-  "Nch",                    // Number of charged MC tracks in |eta|<1.6
-  "Nch05",                  // Number of charged MC tracks in |eta|<0.5
-  "Nch10",                  // Number of charged MC tracks in |eta|<1.0
+  "Nch",
+  "Nch05",
+  "Nch10",
   "Centrality",
+  "CentralitySPD",
   "Nevents",
   "RunNumber",
   "MixingBin"
@@ -257,7 +266,12 @@ AliKFVertex*    AliDielectronVarManager::fgKFVertex         = 0x0;
 TProfile*       AliDielectronVarManager::fgMultEstimatorAvg[4][9] = {{0x0}};
 TH3D*           AliDielectronVarManager::fgTRDpidEff[10][4] = {{0x0}};
 Double_t        AliDielectronVarManager::fgTRDpidEffCentRanges[10][4] = {{0.0}};
-Double_t        AliDielectronVarManager::fgData[AliDielectronVarManager::kNMaxValues] = {};
+TString         AliDielectronVarManager::fgVZEROCalibrationFile = "";
+TString         AliDielectronVarManager::fgVZERORecenteringFile = "";
+TProfile2D*     AliDielectronVarManager::fgVZEROCalib[64] = {0x0};
+TProfile2D*     AliDielectronVarManager::fgVZERORecentering[2][2] = {{0x0,0x0},{0x0,0x0}};
+Int_t           AliDielectronVarManager::fgCurrentRun = -1;
+Double_t        AliDielectronVarManager::fgData[AliDielectronVarManager::kNMaxValues] = {0.};
 //________________________________________________________________
 AliDielectronVarManager::AliDielectronVarManager() :
   TNamed("AliDielectronVarManager","AliDielectronVarManager")
@@ -271,6 +285,10 @@ AliDielectronVarManager::AliDielectronVarManager() :
   for(Int_t i=0; i<10; ++i)
     for(Int_t j=0; j<4; ++j)
       fgTRDpidEff[i][j] = 0x0;
+  for(Int_t i=0; i<64; ++i) fgVZEROCalib[i] = 0x0;
+  for(Int_t i=0; i<2; ++i) {
+    for(Int_t j=0; j<2; ++j) fgVZERORecentering[i][j] = 0x0;
+  }
 }
 
 //________________________________________________________________
@@ -286,6 +304,10 @@ AliDielectronVarManager::AliDielectronVarManager(const char* name, const char* t
   for(Int_t i=0; i<10; ++i)
     for(Int_t j=0; j<4; ++j)
       fgTRDpidEff[i][j] = 0x0;  
+  for(Int_t i=0; i<64; ++i) fgVZEROCalib[i] = 0x0;
+  for(Int_t i=0; i<2; ++i)
+    for(Int_t j=0; j<2; ++j) 
+      fgVZERORecentering[i][j] = 0x0;
 }
 
 //________________________________________________________________
@@ -300,5 +322,10 @@ AliDielectronVarManager::~AliDielectronVarManager()
   for(Int_t i=0; i<10; ++i)
     for(Int_t j=0; j<4; ++j)
       if(fgTRDpidEff[i][j]) delete fgTRDpidEff[i][j];    
+  for(Int_t i=0; i<64; ++i) 
+    if(fgVZEROCalib[i]) delete fgVZEROCalib[i];
+  for(Int_t i=0; i<2; ++i)
+    for(Int_t j=0; j<2; ++j) 
+      if(fgVZERORecentering[i][j]) delete fgVZERORecentering[i][j]; 
 }
 
index 988cdc3c55fe9fa0d8e434f9b01fe7bc8e5b1a63..b010cb9e9f70bee7d9b6529bd2250a7222ad4989 100644 (file)
@@ -22,6 +22,7 @@
 
 #include <TNamed.h>
 #include <TProfile.h>
+#include <TProfile2D.h>
 #include <TH3D.h>
 #include <TFile.h>
 #include <TDatabasePDG.h>
@@ -157,6 +158,11 @@ public:
     kTOFnSigmaPro,           // number of sigmas to the proton line in the TOF
 
     kEMCALnSigmaEle,         // number of sigmas to the proton line in the TOF
+    kEMCALEoverP,            // E over P from EMCAL
+    kEMCALNCells,            // NCells from EMCAL
+    kEMCALM02,               // M02 showershape parameter
+    kEMCALM20,               // M20 showershape parameter
+    kEMCALDispersion,        // Dispersion paramter
     
     kKinkIndex0,             // kink index 0
       
@@ -171,11 +177,13 @@ public:
     kThetaHE,                // theta in mother's rest frame in the helicity picture 
     kPhiHE,                  // phi in mother's rest frame in the helicity picture
     kCos2PhiHE,              // Cosine of 2*phi in mother's rest frame in the helicity picture
+    kCosTilPhiHE,            // Sin(phi) +/- Cos(phi) in mother's rest frame in the helicity picture; Sign is sign(Cos(phi))
     // Collins-Soper picture: Z-axis is considered the direction of the vectorial difference between 
     // the 3-mom vectors of target and projectile beams
     kThetaCS,                // theta in mother's rest frame in Collins-Soper picture
     kPhiCS,                  // phi in mother's rest frame in Collins-Soper picture
     kCos2PhiCS,              // Cosine of 2*phi in mother's rest frame in the Collins-Soper picture
+    kCosTilPhiCS,            // Sin(phi) +/- Cos(phi) in mother's rest frame in Collins-Soper picture; Sign is sign(Cos(phi))
     kDeltaPhiV0ArpH2,        // Delta phi of the pair with respect to the 2nd order harmonic reaction plane from V0-A
     kDeltaPhiV0CrpH2,        // Delta phi of the pair with respect to the 2nd order harmonic reaction plane from V0-C
     kDeltaPhiV0ACrpH2,       // Delta phi of the pair with respect to the 2nd order harmonic reaction plane from V0-A + V0-C
@@ -265,6 +273,7 @@ public:
 
     kNTrk,                   // number of tracks (or tracklets) TODO: ambiguous
     kTracks,                 // ESD tracks TODO: ambiguous
+    kNVtxContrib,             // number of primary vertex contibutors
     kNacc,                   // Number of accepted tracks
     kNaccTrcklts,            // number of accepted SPD tracklets in |eta|<1.6        
     kNaccTrcklts0916,        // number of accepted SPD tracklets in 0.9<|eta|<1.6
@@ -294,6 +303,7 @@ public:
     kNch10,                  // MC true number of charged particles in |eta|<1.0
 
     kCentrality,             // event centrality fraction
+    kCentralitySPD,          // centrality using SPD
     kNevents,                // event counter
     kRunNumber,              // run number
     kMixingBin,
@@ -312,13 +322,16 @@ public:
   static void InitAODpidUtil(Int_t type=0);
   static void InitEstimatorAvg(const Char_t* filename);
   static void InitTRDpidEffHistograms(const Char_t* filename);
+  static void SetVZEROCalibrationFile(const Char_t* filename) {fgVZEROCalibrationFile = filename;}
+  
+  static void SetVZERORecenteringFile(const Char_t* filename) {fgVZERORecenteringFile = filename;}
   static void SetPIDResponse(AliPIDResponse *pidResponse) {fgPIDResponse=pidResponse;}
   static AliPIDResponse* GetPIDResponse() { return fgPIDResponse; }
   static void SetEvent(AliVEvent * const ev);
   static void SetEventData(const Double_t data[AliDielectronVarManager::kNMaxValues]);
   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 GetVzeroRP(const AliVEvent* event, Double_t* qvec, Int_t sideOption);      // 0- V0A; 1- V0C; 2- V0A+V0C
 
   static TProfile* GetEstimatorHistogram(Int_t period, Int_t type) {return fgMultEstimatorAvg[period][type];}
   static Double_t GetTRDpidEfficiency(Int_t runNo, Double_t centrality, Double_t eta, Double_t trdPhi, Double_t pout, Double_t& effErr);
@@ -350,6 +363,9 @@ private:
   static void FillVarMCEvent(const AliMCEvent *event,                Double_t * const values);
   static void FillVarTPCEventPlane(const AliEventplane *evplane,     Double_t * const values);
 
+  static void InitVZEROCalibrationHistograms(Int_t runNo);
+  static void InitVZERORecenteringHistograms(Int_t runNo);
+  
   static AliPIDResponse  *fgPIDResponse;        // PID response object
   static AliVEvent       *fgEvent;              // current event pointer
   static AliEventplane   *fgTPCEventPlane;      // current event plane pointer
@@ -357,7 +373,12 @@ private:
   static TProfile        *fgMultEstimatorAvg[4][9];  // multiplicity estimator averages (4 periods x 9 estimators)
   static Double_t         fgTRDpidEffCentRanges[10][4];   // centrality ranges for the TRD pid efficiency histograms
   static TH3D            *fgTRDpidEff[10][4];   // TRD pid efficiencies from conversion electrons
-
+  static TString          fgVZEROCalibrationFile;  // file with VZERO channel-by-channel calibrations
+  static TString          fgVZERORecenteringFile;  // file with VZERO Q-vector averages needed for event plane recentering
+  static TProfile2D      *fgVZEROCalib[64];           // 1 histogram per VZERO channel
+  static TProfile2D      *fgVZERORecentering[2][2];   // 2 VZERO sides x 2 Q-vector components
+  static Int_t            fgCurrentRun;
+  
   static Double_t fgData[kNMaxValues];        //! data
   
   AliDielectronVarManager(const AliDielectronVarManager &c);
@@ -597,8 +618,18 @@ inline void AliDielectronVarManager::FillVarESDtrack(const AliESDtrack *particle
   values[AliDielectronVarManager::kTOFnSigmaKao]=fgPIDResponse->NumberOfSigmasTOF(particle,AliPID::kKaon);
   values[AliDielectronVarManager::kTOFnSigmaPro]=fgPIDResponse->NumberOfSigmasTOF(particle,AliPID::kProton);
 
-  values[AliDielectronVarManager::kEMCALnSigmaEle]=fgPIDResponse->NumberOfSigmasEMCAL(particle,AliPID::kElectron);
-
+  //EMCAL PID information
+  Double_t eop=0;
+  Double_t showershape[4]={0.,0.,0.,0.};
+//   values[AliDielectronVarManager::kEMCALnSigmaEle]  = fgPIDResponse->NumberOfSigmasEMCAL(particle,AliPID::kElectron);
+  values[AliDielectronVarManager::kEMCALnSigmaEle]  = fgPIDResponse->NumberOfSigmasEMCAL(particle,AliPID::kElectron,eop,showershape);
+  values[AliDielectronVarManager::kEMCALEoverP]     = eop;
+  values[AliDielectronVarManager::kEMCALNCells]     = showershape[0];
+  values[AliDielectronVarManager::kEMCALM02]        = showershape[1];
+  values[AliDielectronVarManager::kEMCALM20]        = showershape[2];
+  values[AliDielectronVarManager::kEMCALDispersion] = showershape[3];
+  
+  
   //restore TPC signal if it was changed
   if (esdTrack) esdTrack->SetTPCsignal(origdEdx,esdTrack->GetTPCsignalSigma(),esdTrack->GetTPCsignalN());
 }
@@ -644,6 +675,9 @@ inline void AliDielectronVarManager::FillVarAODTrack(const AliAODTrack *particle
   
   // Fill AliAODTrack interface information
   //
+
+  values[AliDielectronVarManager::kKinkIndex0]    = particle->GetProdVertex()->GetType()==AliAODVertex::kKink ? 1 : 0;
+
   Double_t d0z0[2];
   GetDCA(particle, d0z0);
   values[AliDielectronVarManager::kImpactParXY]   = d0z0[0];
@@ -702,6 +736,17 @@ inline void AliDielectronVarManager::FillVarAODTrack(const AliAODTrack *particle
     
   }
 
+  //EMCAL PID information
+  Double_t eop=0;
+  Double_t showershape[4]={0.,0.,0.,0.};
+//   values[AliDielectronVarManager::kEMCALnSigmaEle]  = fgPIDResponse->NumberOfSigmasEMCAL(particle,AliPID::kElectron);
+  values[AliDielectronVarManager::kEMCALnSigmaEle]  = fgPIDResponse->NumberOfSigmasEMCAL(particle,AliPID::kElectron,eop,showershape);
+  values[AliDielectronVarManager::kEMCALEoverP]     = eop;
+  values[AliDielectronVarManager::kEMCALNCells]     = showershape[0];
+  values[AliDielectronVarManager::kEMCALM02]        = showershape[1];
+  values[AliDielectronVarManager::kEMCALM20]        = showershape[2];
+  values[AliDielectronVarManager::kEMCALDispersion] = showershape[3];
+
   values[AliDielectronVarManager::kPdgCode]=-1;
   values[AliDielectronVarManager::kPdgCodeMother]=-1;
   values[AliDielectronVarManager::kPdgCodeGrandMother]=-1;
@@ -875,12 +920,15 @@ inline void AliDielectronVarManager::FillVarMCParticle2(const AliVParticle *p1,
 
     if ( fgEvent ) AliDielectronVarManager::Fill(fgEvent, values);
   }
+
   values[AliDielectronVarManager::kThetaHE]   = AliDielectronPair::ThetaPhiCM(p1,p2,kTRUE,  kTRUE);
   values[AliDielectronVarManager::kPhiHE]     = AliDielectronPair::ThetaPhiCM(p1,p2,kTRUE,  kFALSE);
   values[AliDielectronVarManager::kCos2PhiHE] = TMath::Cos(2*values[AliDielectronVarManager::kPhiHE]);
   values[AliDielectronVarManager::kThetaCS]   = AliDielectronPair::ThetaPhiCM(p1,p2,kFALSE, kTRUE);
   values[AliDielectronVarManager::kPhiCS]     = AliDielectronPair::ThetaPhiCM(p1,p2,kFALSE, kFALSE);
   values[AliDielectronVarManager::kCos2PhiCS] = TMath::Cos(2*values[AliDielectronVarManager::kPhiCS]);
+  values[AliDielectronVarManager::kCosTilPhiHE]  = (TMath::Cos(values[AliDielectronVarManager::kPhiHE])>0)?(TMath::Cos(values[AliDielectronVarManager::kPhiHE]-TMath::Pi()/4.)):(TMath::Cos(values[AliDielectronVarManager::kPhiHE]-3*TMath::Pi()/4.));
+  values[AliDielectronVarManager::kCosTilPhiCS]  = (TMath::Cos(values[AliDielectronVarManager::kPhiCS])>0)?(TMath::Cos(values[AliDielectronVarManager::kPhiCS]-TMath::Pi()/4.)):(TMath::Cos(values[AliDielectronVarManager::kPhiCS]-3*TMath::Pi()/4.));
 }
 
 
@@ -975,9 +1023,11 @@ inline void AliDielectronVarManager::FillVarDielectronPair(const AliDielectronPa
   values[AliDielectronVarManager::kThetaHE]      = thetaHE;
   values[AliDielectronVarManager::kPhiHE]        = phiHE;
   values[AliDielectronVarManager::kCos2PhiHE]    = TMath::Cos(2.0*phiHE);
+  values[AliDielectronVarManager::kCosTilPhiHE]  = (TMath::Cos(phiHE)>0)?(TMath::Cos(phiHE-TMath::Pi()/4.)):(TMath::Cos(phiHE-3*TMath::Pi()/4.));
   values[AliDielectronVarManager::kThetaCS]      = thetaCS;
   values[AliDielectronVarManager::kPhiCS]        = phiCS;
   values[AliDielectronVarManager::kCos2PhiCS]    = TMath::Cos(2.0*phiCS);
+  values[AliDielectronVarManager::kCosTilPhiCS]  = (TMath::Cos(phiCS)>0)?(TMath::Cos(phiCS-TMath::Pi()/4.)):(TMath::Cos(phiCS-3*TMath::Pi()/4.));
   values[AliDielectronVarManager::kLegDist]      = pair->DistanceDaughters();
   values[AliDielectronVarManager::kLegDistXY]    = pair->DistanceDaughtersXY();
   values[AliDielectronVarManager::kDeltaEta]     = pair->DeltaEta();
@@ -1122,6 +1172,11 @@ inline void AliDielectronVarManager::FillVarVEvent(const AliVEvent *event, Doubl
   // Fill event information available for histogramming into an array
   //
   values[AliDielectronVarManager::kRunNumber]    = event->GetRunNumber();
+  if(fgCurrentRun!=event->GetRunNumber()) {
+    if(fgVZEROCalibrationFile.Contains(".root")) InitVZEROCalibrationHistograms(event->GetRunNumber());
+    if(fgVZERORecenteringFile.Contains(".root")) InitVZERORecenteringHistograms(event->GetRunNumber());
+    fgCurrentRun=event->GetRunNumber();
+  }
   const AliVVertex *primVtx = event->GetPrimaryVertex();
   
   values[AliDielectronVarManager::kXvPrim]       = 0;
@@ -1130,6 +1185,7 @@ inline void AliDielectronVarManager::FillVarVEvent(const AliVEvent *event, Doubl
 //   values[AliDielectronVarManager::kChi2NDF]      = 0; //This is the pair value!!!
 
   values[AliDielectronVarManager::kNTrk]         = 0;
+  values[AliDielectronVarManager::kNVtxContrib]   = 0;
   values[AliDielectronVarManager::kNacc]         = 0;
   values[AliDielectronVarManager::kNaccTrcklts]  = 0;
   values[AliDielectronVarManager::kNaccTrcklts0916] = 0;
@@ -1143,6 +1199,7 @@ inline void AliDielectronVarManager::FillVarVEvent(const AliVEvent *event, Doubl
 //   values[AliDielectronVarManager::kChi2NDF]      = primVtx->GetChi2perNDF(); //this is the pair value
 
   values[AliDielectronVarManager::kNTrk]            = event->GetNumberOfTracks();
+  values[AliDielectronVarManager::kNVtxContrib]     = primVtx->GetNContributors();
   values[AliDielectronVarManager::kNacc]            = AliDielectronHelper::GetNacc(event);
   values[AliDielectronVarManager::kNaccTrcklts]     = AliDielectronHelper::GetNaccTrcklts(event);      // etaRange = 1.6 (default)
   values[AliDielectronVarManager::kNaccTrcklts0916] = AliDielectronHelper::GetNaccTrcklts(event,1.6)-AliDielectronHelper::GetNaccTrcklts(event,.9);
@@ -1165,10 +1222,10 @@ inline void AliDielectronVarManager::FillVarVEvent(const AliVEvent *event, Doubl
   values[AliDielectronVarManager::kAdcV0A]  = 0.0;
   values[AliDielectronVarManager::kAdcV0C]  = 0.0;
   for(Int_t i=0; i<32; ++i) {
-    //values[AliDielectronVarManager::kVZEROchMult+i] = vzeroData->GetMultiplicity(i);
-    //values[AliDielectronVarManager::kVZEROchMult+32+i] = vzeroData->GetMultiplicity(i+32);
-    values[AliDielectronVarManager::kVZEROchMult+i] = event->GetVZEROEqMultiplicity(i);
-    values[AliDielectronVarManager::kVZEROchMult+32+i] = event->GetVZEROEqMultiplicity(i+32);
+    values[AliDielectronVarManager::kVZEROchMult+i] = vzeroData->GetMultiplicity(i);
+    values[AliDielectronVarManager::kVZEROchMult+32+i] = vzeroData->GetMultiplicity(i+32);
+    //values[AliDielectronVarManager::kVZEROchMult+i] = event->GetVZEROEqMultiplicity(i);
+    //values[AliDielectronVarManager::kVZEROchMult+32+i] = event->GetVZEROEqMultiplicity(i+32);
     values[AliDielectronVarManager::kMultV0A] += vzeroData->GetMultiplicityV0A(i);
     values[AliDielectronVarManager::kMultV0C] += vzeroData->GetMultiplicityV0C(i);
     //values[AliDielectronVarManager::kAdcV0A] += vzeroData->GetAdcV0A(i);
@@ -1254,9 +1311,10 @@ inline void AliDielectronVarManager::FillVarESDEvent(const AliESDEvent *event, D
   // Fill common AliVEvent interface information
   FillVarVEvent(event, values);
 
-  Double_t centralityF=-1;
+  Double_t centralityF=-1; Double_t centralitySPD=-1;
   AliCentrality *esdCentrality = const_cast<AliESDEvent*>(event)->GetCentrality();
   if (esdCentrality) centralityF = esdCentrality->GetCentralityPercentile("V0M");
+  if (esdCentrality) centralitySPD = esdCentrality->GetCentralityPercentile("CL1");
   
   // Fill AliESDEvent interface specific information
   const AliESDVertex *primVtx = event->GetPrimaryVertex();
@@ -1264,6 +1322,7 @@ inline void AliDielectronVarManager::FillVarESDEvent(const AliESDEvent *event, D
   values[AliDielectronVarManager::kYRes]       = primVtx->GetYRes();
   values[AliDielectronVarManager::kZRes]       = primVtx->GetZRes();
   values[AliDielectronVarManager::kCentrality] = centralityF;
+  values[AliDielectronVarManager::kCentralitySPD] = centralitySPD;
   
   // Event multiplicity estimators
   Int_t nTrSPD05=0; Int_t nTrITSTPC05=0; Int_t nTrITSSA05=0;
@@ -1316,10 +1375,12 @@ inline void AliDielectronVarManager::FillVarAODEvent(const AliAODEvent *event, D
   // Fill AliAODEvent interface specific information
   AliAODHeader *header = event->GetHeader();
   
-  Double_t centralityF=-1;
+  Double_t centralityF=-1; Double_t centralitySPD=-1;
   AliCentrality *aodCentrality = header->GetCentralityP();
   if (aodCentrality) centralityF = aodCentrality->GetCentralityPercentile("V0M");
+  if (aodCentrality) centralitySPD = aodCentrality->GetCentralityPercentile("CL1");
   values[AliDielectronVarManager::kCentrality] = centralityF;
+  values[AliDielectronVarManager::kCentralitySPD] = centralitySPD;
   
   //const AliAODVertex *primVtx = event->GetPrimaryVertex();
 }
@@ -1375,6 +1436,7 @@ inline void AliDielectronVarManager::FillVarTPCEventPlane(const AliEventplane *e
                                                                        values[AliDielectronVarManager::kTPCsub2rpH2]) );
 }
   
+
 inline void AliDielectronVarManager::InitESDpid(Int_t type)
 {
   //
@@ -1512,6 +1574,60 @@ inline void AliDielectronVarManager::InitTRDpidEffHistograms(const Char_t* filen
 }
 
 
+inline void AliDielectronVarManager::InitVZEROCalibrationHistograms(Int_t runNo) {
+  //
+  // Initialize the VZERO channel-by-channel calibration histograms
+  //
+
+  //initialize only once
+  if(fgVZEROCalib[0]) return;
+  
+  for(Int_t i=0; i<64; ++i) 
+    if(fgVZEROCalib[i]) {
+      delete fgVZEROCalib[i];
+      fgVZEROCalib[i] = 0x0;
+    }
+  
+  TFile file(fgVZEROCalibrationFile.Data());
+  
+  for(Int_t i=0; i<64; ++i){
+    fgVZEROCalib[i] = (TProfile2D*)(file.Get(Form("RUN%d_ch%d_VtxCent", runNo, i)));
+    if (fgVZEROCalib[i]) fgVZEROCalib[i]->SetDirectory(0x0);
+  }
+}
+
+
+inline void AliDielectronVarManager::InitVZERORecenteringHistograms(Int_t runNo) {
+  //
+  // Initialize the VZERO event plane recentering histograms
+  //
+
+  //initialize only once
+  if(fgVZERORecentering[0][0]) return;
+  
+  for(Int_t i=0; i<2; ++i)
+    for(Int_t j=0; j<2; ++j)
+      if(fgVZERORecentering[i][j]) {
+        delete fgVZERORecentering[i][j];
+        fgVZERORecentering[i][j] = 0x0;
+      }
+  
+  TFile file(fgVZERORecenteringFile.Data());
+  if (!file.IsOpen()) return;
+  
+  fgVZERORecentering[0][0] = (TProfile2D*)(file.Get(Form("RUN%d_QxA_CentVtx", runNo)));
+  fgVZERORecentering[0][1] = (TProfile2D*)(file.Get(Form("RUN%d_QyA_CentVtx", runNo)));
+  fgVZERORecentering[1][0] = (TProfile2D*)(file.Get(Form("RUN%d_QxC_CentVtx", runNo)));
+  fgVZERORecentering[1][1] = (TProfile2D*)(file.Get(Form("RUN%d_QyC_CentVtx", runNo)));
+
+  if (fgVZERORecentering[0][0]) fgVZERORecentering[0][0]->SetDirectory(0x0);
+  if (fgVZERORecentering[0][1]) fgVZERORecentering[0][1]->SetDirectory(0x0);
+  if (fgVZERORecentering[1][0]) fgVZERORecentering[1][0]->SetDirectory(0x0);
+  if (fgVZERORecentering[1][1]) fgVZERORecentering[1][1]->SetDirectory(0x0);
+  
+}
+
+
 inline Double_t AliDielectronVarManager::GetTRDpidEfficiency(Int_t runNo, Double_t centrality, 
                                                             Double_t eta, Double_t trdPhi, Double_t pout,
                                                             Double_t& effErr) {
@@ -1631,19 +1747,73 @@ inline void AliDielectronVarManager::GetVzeroRP(const AliVEvent* event, Double_t
   const Double_t kY[8] = {0.38268, 0.92388, 0.92388, 0.38268, -0.38268, -0.92388, -0.92388, -0.38268};    // sines     -- " --
   Int_t phi;
   Float_t mult;
-
-//  AliVVZERO* vzero = event->GetVZEROData();
   
+  // get centrality and vertex for this event
+  Double_t centralitySPD = -1; Double_t vtxZ = -999.;
+  if(event->IsA() == AliESDEvent::Class()) {
+    const AliESDEvent* esdEv = static_cast<const AliESDEvent*>(event);
+    AliCentrality *esdCentrality = const_cast<AliESDEvent*>(esdEv)->GetCentrality();
+    if(esdCentrality) centralitySPD = esdCentrality->GetCentralityPercentile("CL1");
+  }
+  if(event->IsA() == AliAODEvent::Class()) {
+    const AliAODEvent* aodEv = static_cast<const AliAODEvent*>(event);
+    AliAODHeader *header = aodEv->GetHeader();
+    AliCentrality *aodCentrality = header->GetCentralityP();
+    if(aodCentrality) centralitySPD = aodCentrality->GetCentralityPercentile("CL1");
+  }
+  const AliVVertex *primVtx = event->GetPrimaryVertex();
+  if(!primVtx) return;
+  vtxZ = primVtx->GetZ();
+  if(TMath::Abs(vtxZ)>10.) return;
+  if(centralitySPD<0. || centralitySPD>80.) return;
+  
+  Int_t binCent = -1; Int_t binVtx = -1;
+  if(fgVZEROCalib[0]) {
+    binVtx = fgVZEROCalib[0]->GetXaxis()->FindBin(vtxZ);
+    binCent = fgVZEROCalib[0]->GetYaxis()->FindBin(centralitySPD);
+  }
+  
+  AliVVZERO* vzero = event->GetVZEROData();
+  Double_t average = 0.0;
   for(Int_t iChannel=0; iChannel<64; ++iChannel) {
     if(iChannel<32 && sideOption==0) continue;
     if(iChannel>=32 && sideOption==1) continue;
     phi=iChannel%8;
-    //mult = vzero->GetMultiplicity(iChannel);
-    mult = event->GetVZEROEqMultiplicity(iChannel);
+    mult = vzero->GetMultiplicity(iChannel);
+    if(fgVZEROCalib[iChannel])
+      average = fgVZEROCalib[iChannel]->GetBinContent(binVtx, binCent);
+    if(average>1.0e-10 && mult>0.5) 
+      mult /= average;
+    else
+      mult = 0.0;
     //  2nd harmonic
     qvec[0] += mult*(2.0*TMath::Power(kX[phi],2.0)-1);
     qvec[1] += mult*(2.0*kX[phi]*kY[phi]);
   }    // end loop over channels 
+  
+  // do recentering
+  if(fgVZERORecentering[0][0]) {
+//     printf("vzero: %p\n",fgVZERORecentering[0][0]);
+    Int_t binCentRecenter = -1; Int_t binVtxRecenter = -1;
+    binCentRecenter = fgVZERORecentering[0][0]->GetXaxis()->FindBin(centralitySPD);
+    binVtxRecenter = fgVZERORecentering[0][0]->GetYaxis()->FindBin(vtxZ);
+    if(sideOption==0) {  // side A
+      qvec[0] -= fgVZERORecentering[0][0]->GetBinContent(binCentRecenter, binVtxRecenter);
+      qvec[1] -= fgVZERORecentering[0][1]->GetBinContent(binCentRecenter, binVtxRecenter);
+    }
+    if(sideOption==1) {  // side C
+      qvec[0] -= fgVZERORecentering[1][0]->GetBinContent(binCentRecenter, binVtxRecenter);
+      qvec[1] -= fgVZERORecentering[1][1]->GetBinContent(binCentRecenter, binVtxRecenter);
+    }
+    if(sideOption==2) {  // side A and C together
+      qvec[0] -= fgVZERORecentering[0][0]->GetBinContent(binCentRecenter, binVtxRecenter);
+      qvec[0] -= fgVZERORecentering[1][0]->GetBinContent(binCentRecenter, binVtxRecenter);
+      qvec[1] -= fgVZERORecentering[0][1]->GetBinContent(binCentRecenter, binVtxRecenter);
+      qvec[1] -= fgVZERORecentering[1][1]->GetBinContent(binCentRecenter, binVtxRecenter);
+    }
+  }
+  
+  // calculate the reaction plane
   if(TMath::Abs(qvec[0])>1.0e-10)
     qvec[2] = TMath::ATan2(qvec[1],qvec[0])/2.0;
 }