Add a draw class for the CORRFW (produces a warning, will be fixed
authorandronic <andronic@f7af4fe6-9843-0410-8265-dc069ae4e863>
Tue, 9 Mar 2010 21:38:06 +0000 (21:38 +0000)
committerandronic <andronic@f7af4fe6-9843-0410-8265-dc069ae4e863>
Tue, 9 Mar 2010 21:38:06 +0000 (21:38 +0000)
later). Also, some bugfixes.

-This line, and those below, will be ignored--

M    PWG3/dielectron/AliDielectron.cxx
M    PWG3/dielectron/AliDielectronPair.h
M    PWG3/dielectron/AliAnalysisTaskMultiDielectron.cxx
M    PWG3/dielectron/AliDielectronVarManager.cxx
M    PWG3/dielectron/AliDielectronMC.h
M    PWG3/dielectron/AliDielectronCF.cxx
A    PWG3/dielectron/AliDielectronCFdraw.h
M    PWG3/dielectron/AliAnalysisTaskDielectronSE.cxx
M    PWG3/dielectron/AliDielectronMC.cxx
M    PWG3/dielectron/AliDielectron.h
A    PWG3/dielectron/AliDielectronCFdraw.cxx
M    PWG3/dielectron/AliDielectronVarManager.h
M    PWG3/dielectron/AliAnalysisTaskDielectronFilter.cxx
M    PWG3/dielectron/AliDielectronCF.h
M    PWG3/libPWG3dielectron.pkg
M    PWG3/PWG3dielectronLinkDef.h

16 files changed:
PWG3/PWG3dielectronLinkDef.h
PWG3/dielectron/AliAnalysisTaskDielectronFilter.cxx
PWG3/dielectron/AliAnalysisTaskDielectronSE.cxx
PWG3/dielectron/AliAnalysisTaskMultiDielectron.cxx
PWG3/dielectron/AliDielectron.cxx
PWG3/dielectron/AliDielectron.h
PWG3/dielectron/AliDielectronCF.cxx
PWG3/dielectron/AliDielectronCF.h
PWG3/dielectron/AliDielectronCFdraw.cxx [new file with mode: 0644]
PWG3/dielectron/AliDielectronCFdraw.h [new file with mode: 0644]
PWG3/dielectron/AliDielectronMC.cxx
PWG3/dielectron/AliDielectronMC.h
PWG3/dielectron/AliDielectronPair.h
PWG3/dielectron/AliDielectronVarManager.cxx
PWG3/dielectron/AliDielectronVarManager.h
PWG3/libPWG3dielectron.pkg

index a514fd4d1305a97a8be2c7facd8d5bab837e6eec..27662d0064d071b3897d2e1cc541a1c8b3433624 100644 (file)
@@ -10,6 +10,7 @@
 #pragma link C++ class AliDielectronPair+;
 #pragma link C++ class AliDielectronHistos+;
 #pragma link C++ class AliDielectronCF+;
+#pragma link C++ class AliDielectronCFdraw+;
 #pragma link C++ class AliDielectronMC+;
 #pragma link C++ class AliDielectronVarManager+;
 #pragma link C++ class AliAnalysisTaskDielectronSE+;
index 6037feccd819cae556f909f75e9427804f0b2b60..89826cf79ece354901704dc2afde2bb4771259d1 100644 (file)
@@ -88,7 +88,6 @@ void AliAnalysisTaskDielectronFilter::UserExec(Option_t *)
   AliKFParticle::SetField( bz );
   
   fDielectron->Process(InputEvent());
-  fDielectron->FillHistograms();
 
   if(fDielectron->HasCandidates()){
     AliAODExtension *extDielectron = dynamic_cast<AliAODHandler*>
index 0fef4149978915714e050277ac23eaa97e06fb4a..deded5e636d0aa82c1ee7d9986e1c39bd915d692 100644 (file)
@@ -82,7 +82,6 @@ void AliAnalysisTaskDielectronSE::UserExec(Option_t *)
   AliKFParticle::SetField( bz );
   
   fDielectron->Process(InputEvent());
-  fDielectron->FillHistograms();
 
   if (fDielectron->GetHistogramList()){
     PostData(1, const_cast<THashList*>(fDielectron->GetHistogramList()));
index db99c113dc18c525ba2da9e63fab3a871ddc8523..d2fa05fb5ec95480946fd141188cff9e52a656a1 100644 (file)
@@ -96,9 +96,7 @@ void AliAnalysisTaskMultiDielectron::UserExec(Option_t *)
   TIter nextDie(&fListDielectron);
   AliDielectron *die=0;
   while ( (die=static_cast<AliDielectron*>(nextDie())) ){
-//     printf("Processing '%s'\n",die->GetName());
     die->Process(InputEvent());
-    die->FillHistograms();
   }
   
   PostData(1, &fListHistos);
index 902e3eda7f23cc9af9b1d1df9929d124588bb0ce..c4dd961d3a3f3b8f58a0e305b51b4ea740ca2400 100644 (file)
@@ -132,6 +132,7 @@ void AliDielectron::Init()
   // Initialise objects
   //
   if (fCfManagerPair) fCfManagerPair->InitialiseContainer(fPairFilter);
+  AliDielectronVarManager::InitESDpid(); //currently this will take the values for MC
 }
 
 //________________________________________________________________
@@ -141,6 +142,8 @@ void AliDielectron::Process(AliVEvent *ev1, AliVEvent *ev2)
   // Process the events
   //
 
+  AliDielectronVarManager::SetEvent(0x0);
+   
   //in case we have MC load the MC event and process the MC particles
   if (AliDielectronMC::Instance()->ConnectMCEvent()) ProcessMC();
   
@@ -157,7 +160,9 @@ void AliDielectron::Process(AliVEvent *ev1, AliVEvent *ev2)
   //apply event cuts
     if ((ev1&&fEventFilter.IsSelected(ev1)!=selectedMask) ||
         (ev2&&fEventFilter.IsSelected(ev2)!=selectedMask)) return;
-
+  
+  AliDielectronVarManager::SetEvent(ev1);
+  
   //fill track arrays for the first event
   if (ev1) FillTrackArrays(ev1);
 
@@ -170,6 +175,10 @@ void AliDielectron::Process(AliVEvent *ev1, AliVEvent *ev2)
       FillPairArrays(itrackArr1, itrackArr2);
     }
   }
+
+  //in case there is a histogram manager, fill the QA histograms
+  if (fHistos) FillHistograms(ev1);
+  
 }
 
 //________________________________________________________________
@@ -193,34 +202,35 @@ void AliDielectron::ProcessMC()
 }
 
 //________________________________________________________________
-void AliDielectron::FillHistograms()
+void AliDielectron::FillHistograms(const AliVEvent *ev)
 {
   //
   // Fill Histogram information for tracks and pairs
   //
   
-  if (!fHistos) return;
   TString  className;
-
+  Double_t values[AliDielectronVarManager::kNMaxValues];
+  //Fill event information
+  AliDielectronVarManager::Fill(ev, values);
+  fHistos->FillClass("Event", AliDielectronVarManager::kNMaxValues, values);
+  
   //Fill track information, separately for the track array candidates
-  Double_t trackValues[AliDielectronVarManager::kNMaxValues];
   for (Int_t i=0; i<4; ++i){
     className.Form("Track_%s",fgkTrackClassNames[i]);
     Int_t ntracks=fTracks[i].GetEntriesFast();
     for (Int_t itrack=0; itrack<ntracks; ++itrack){
-      AliDielectronVarManager::Fill(fTracks[i].UncheckedAt(itrack), trackValues);
-      fHistos->FillClass(className, AliDielectronVarManager::kNMaxValues, trackValues);
+      AliDielectronVarManager::Fill(fTracks[i].UncheckedAt(itrack), values);
+      fHistos->FillClass(className, AliDielectronVarManager::kNMaxValues, values);
     }
   }
 
   //Fill Pair information, separately for all pair candidate arrays
-  Double_t pairValues[AliDielectronVarManager::kNMaxValues];
   for (Int_t i=0; i<10; ++i){
     className.Form("Pair_%s",fgkPairClassNames[i]);
     Int_t ntracks=PairArray(i)->GetEntriesFast();
     for (Int_t ipair=0; ipair<ntracks; ++ipair){
-      AliDielectronVarManager::Fill(PairArray(i)->UncheckedAt(ipair), pairValues);
-      fHistos->FillClass(className, AliDielectronVarManager::kNMaxValues, pairValues);
+      AliDielectronVarManager::Fill(PairArray(i)->UncheckedAt(ipair), values);
+      fHistos->FillClass(className, AliDielectronVarManager::kNMaxValues, values);
     }
   }
   
index 19e0c91cbeb6a9203c2f4b24b6eda949cbe64743..a20b016095e1be3168089de9f2384f9a9c9654d0 100644 (file)
@@ -45,7 +45,7 @@ public:
   
   void Process(AliVEvent *ev1, AliVEvent *ev2=0);
 
-  void  FillHistograms();
+  void  FillHistograms(const AliVEvent *ev);
   
   const AliAnalysisFilter& GetEventFilter() const { return fEventFilter; }
   const AliAnalysisFilter& GetTrackFilter() const { return fTrackFilter; }
index 8c80541a2d03559536fec2acb6b90b1e74333ae5..7a0dc7730c4a88e6dc56ff26570bdcb60d2ff73c 100644 (file)
 #include <AliCFContainer.h>
 #include <AliAnalysisFilter.h>
 #include <AliAnalysisCuts.h>
+#include <AliVParticle.h>
 #include <AliLog.h>
 
 #include "AliDielectronCF.h"
 #include "AliDielectronMC.h"
+#include "AliDielectronPair.h"
 
 ClassImp(AliDielectronCF)
 
@@ -46,7 +48,9 @@ AliDielectronCF::AliDielectronCF() :
   TNamed("DielectronCF","DielectronCF"),
   fNSteps(0),
   fNVars(0),
+  fNVarsLeg(0),
   fNCuts(0),
+  fValues(0x0),
   fStepForMCtruth(kFALSE),
   fStepForNoCutsMCmotherPid(kFALSE),
   fStepForAfterAllCuts(kTRUE),
@@ -67,6 +71,9 @@ AliDielectronCF::AliDielectronCF() :
     fNBins[i]=0;
     fVarLoLimit[i]=0.;
     fVarUpLimit[i]=0.;
+    fNBinsLeg[i]=0;
+    fVarLoLimitLeg[i]=0.;
+    fVarUpLimitLeg[i]=0.;
     fStepMasks[i]=0xFFFFFF;
   }
 }
@@ -76,7 +83,9 @@ AliDielectronCF::AliDielectronCF(const char* name, const char* title) :
   TNamed(name, title),
   fNSteps(0),
   fNVars(0),
+  fNVarsLeg(0),
   fNCuts(0),
+  fValues(0x0),
   fStepForMCtruth(kFALSE),
   fStepForNoCutsMCmotherPid(kFALSE),
   fStepForAfterAllCuts(kTRUE),
@@ -97,6 +106,9 @@ AliDielectronCF::AliDielectronCF(const char* name, const char* title) :
     fNBins[i]=0;
     fVarLoLimit[i]=0.;
     fVarUpLimit[i]=0.;
+    fNBinsLeg[i]=0;
+    fVarLoLimitLeg[i]=0.;
+    fVarUpLimitLeg[i]=0.;
     fStepMasks[i]=0xFFFFFF;
   }
 }
@@ -107,20 +119,29 @@ AliDielectronCF::~AliDielectronCF()
   //
   // Destructor
   //
-  
+  if (fValues) delete [] fValues;
 }
 
 //________________________________________________________________
-void AliDielectronCF::AddVariable(AliDielectronVarManager::ValueTypes type, Int_t nbins, Double_t min, Double_t max)
+void AliDielectronCF::AddVariable(AliDielectronVarManager::ValueTypes type, Int_t nbins, Double_t min, Double_t max, Bool_t leg)
 {
   //
   // Add a variable to the CF configuration
   //
-  fVariables[fNVars]  = (UInt_t)type;
-  fVarLoLimit[fNVars] = min;
-  fVarUpLimit[fNVars] = max;
-  fNBins[fNVars]      = nbins;
-  ++fNVars;
+
+  if (!leg){
+    fVariables[fNVars]  = (UInt_t)type;
+    fVarLoLimit[fNVars] = min;
+    fVarUpLimit[fNVars] = max;
+    fNBins[fNVars]      = nbins;
+    ++fNVars;
+  } else {
+    fVariablesLeg[fNVarsLeg]  = (UInt_t)type;
+    fVarLoLimitLeg[fNVarsLeg] = min;
+    fVarUpLimitLeg[fNVarsLeg] = max;
+    fNBinsLeg[fNVarsLeg]      = nbins;
+    ++fNVarsLeg;
+  }
 }
 
 //________________________________________________________________
@@ -142,7 +163,13 @@ void AliDielectronCF::InitialiseContainer(const AliAnalysisFilter& filter)
                                                       // e.g. cut2&cut3, cut2&cut3&cut4
   fNSteps+=(2*fNStepMasks);                            // cuts for the additional cut masks
   // create the container
-  fCfContainer = new AliCFContainer(GetName(), GetTitle(), fNSteps, fNVars, fNBins);
+  Int_t *nbins=new Int_t[fNVars+2*fNVarsLeg];
+  for (Int_t i=0;i<fNVars;++i)    nbins[i]=fNBins[i];
+  for (Int_t i=0;i<fNVarsLeg;++i) nbins[i+fNVars]=fNBinsLeg[i];
+  for (Int_t i=0;i<fNVarsLeg;++i) nbins[i+fNVars+fNVarsLeg]=fNBinsLeg[i];
+  
+  fCfContainer = new AliCFContainer(GetName(), GetTitle(), fNSteps, fNVars+2*fNVarsLeg, nbins);
+  delete [] nbins;
   
   // initialize the variables and their bin limits
   for (Int_t iVar=0; iVar<fNVars; iVar++) {
@@ -157,8 +184,33 @@ void AliDielectronCF::InitialiseContainer(const AliAnalysisFilter& filter)
     
     fCfContainer->SetBinLimits(iVar, binLim);
     fCfContainer->SetVarTitle(iVar, AliDielectronVarManager::GetValueName(type));
-    delete binLim;
+    delete [] binLim;
+  }
+  
+  // initialize the variables and their bin limits for the Legs
+  for (Int_t iVar=0; iVar<fNVarsLeg; iVar++) {
+    UInt_t type=fVariablesLeg[iVar];
+    Int_t    nBins = fNBinsLeg[iVar];
+    Double_t loLim = fVarLoLimitLeg[iVar];
+    Double_t upLim = fVarUpLimitLeg[iVar];
+    Double_t *binLim = new Double_t[nBins+1];
+    
+    // set the bin limits
+    for(Int_t iBin=0; iBin<=nBins; iBin++) binLim[iBin] = loLim + (upLim-loLim) / nBins*(Double_t)iBin;
+
+    //Leg1
+    fCfContainer->SetBinLimits(iVar+fNVars, binLim);
+    fCfContainer->SetVarTitle(iVar+fNVars, Form("Leg1_%s",AliDielectronVarManager::GetValueName(type)));
+    
+    //Leg2
+    fCfContainer->SetBinLimits(iVar+fNVars+fNVarsLeg, binLim);
+    fCfContainer->SetVarTitle(iVar+fNVars+fNVarsLeg, Form("Leg2_%s",AliDielectronVarManager::GetValueName(type)));
+    
+    delete [] binLim;
   }
+
+  // array for storing values
+  fValues = new Double_t[fNVars+2*fNVarsLeg];
   
   //=================//
   // Set step titles //
@@ -231,7 +283,7 @@ void AliDielectronCF::InitialiseContainer(const AliAnalysisFilter& filter)
 }
 
 //________________________________________________________________
-void AliDielectronCF::Fill(UInt_t mask, const TObject *particle)
+void AliDielectronCF::Fill(UInt_t mask, const AliDielectronPair *particle)
 {
   //
   // Fill the containers
@@ -240,15 +292,27 @@ void AliDielectronCF::Fill(UInt_t mask, const TObject *particle)
   Bool_t isMCTruth=kFALSE;
   if (fPdgMother>=0) isMCTruth=AliDielectronMC::Instance()->IsMotherPdg(particle,fPdgMother);
 
-  Double_t valuesAll[AliDielectronVarManager::kNMaxValues];
-  AliDielectronVarManager::Fill(particle,valuesAll);
+  Double_t valuesPair[AliDielectronVarManager::kNMaxValues];
+  AliDielectronVarManager::Fill(particle,valuesPair);
 
-  Double_t values[AliDielectronVarManager::kNMaxValues];
   for (Int_t iVar=0; iVar<fNVars; ++iVar){
     Int_t var=fVariables[iVar];
-    values[iVar]=valuesAll[var];
+    fValues[iVar]=valuesPair[var];
   }
 
+  if (fNVarsLeg>0){
+    Double_t valuesLeg1[AliDielectronVarManager::kNMaxValues];
+    AliDielectronVarManager::Fill(particle->GetFirstDaughter(),valuesLeg1);
+    Double_t valuesLeg2[AliDielectronVarManager::kNMaxValues];
+    AliDielectronVarManager::Fill(particle->GetSecondDaughter(),valuesLeg2);
+
+    for (Int_t iVar=0; iVar<fNVarsLeg; ++iVar){
+      Int_t var=fVariablesLeg[iVar];
+      fValues[iVar+fNVars]=valuesLeg1[var];
+      fValues[iVar+fNVars+fNVarsLeg]=valuesLeg2[var];
+    }
+  }
+  
   UInt_t selectedMask=(1<<fNCuts)-1;
 
   //============//
@@ -260,16 +324,16 @@ void AliDielectronCF::Fill(UInt_t mask, const TObject *particle)
 
   //No cuts (MC truth)
   if (fStepForNoCutsMCmotherPid){
-    if (isMCTruth) fCfContainer->Fill(values,step);
+    if (isMCTruth) fCfContainer->Fill(fValues,step);
     ++step;
   }
   
   //All cuts
   if (fStepForAfterAllCuts){
     if (mask == selectedMask){
-      fCfContainer->Fill(values,step);
+      fCfContainer->Fill(fValues,step);
       ++step;
-      if (isMCTruth) fCfContainer->Fill(values,step);
+      if (isMCTruth) fCfContainer->Fill(fValues,step);
       ++step;
     } else {
       step+=2;
@@ -280,9 +344,9 @@ void AliDielectronCF::Fill(UInt_t mask, const TObject *particle)
   if (fStepsForEachCut&&fNCuts>1){
     for (Int_t iCut=0; iCut<fNCuts;++iCut) {
       if (mask&(1<<iCut)) {
-        fCfContainer->Fill(values,step);
+        fCfContainer->Fill(fValues,step);
         ++step;
-        if (isMCTruth) fCfContainer->Fill(values,step);
+        if (isMCTruth) fCfContainer->Fill(fValues,step);
         ++step;
       } else {
         step+=2;
@@ -294,9 +358,9 @@ void AliDielectronCF::Fill(UInt_t mask, const TObject *particle)
   if (fStepsForCutsIncreasing&&fNCuts>2){
     for (Int_t iCut=1; iCut<fNCuts-1;++iCut) {
       if (mask&(1<<((iCut+1)-1))) {
-        fCfContainer->Fill(values,step);
+        fCfContainer->Fill(fValues,step);
         ++step;
-        if (isMCTruth) fCfContainer->Fill(values,step);
+        if (isMCTruth) fCfContainer->Fill(fValues,step);
         ++step;
       } else {
         step+=2;
@@ -308,9 +372,9 @@ void AliDielectronCF::Fill(UInt_t mask, const TObject *particle)
   for (UInt_t iComb=0; iComb<fNStepMasks; ++iComb){
     UInt_t userMask=fStepMasks[iComb];
     if (mask&userMask) {
-      fCfContainer->Fill(values,step);
+      fCfContainer->Fill(fValues,step);
       ++step;
-      if (isMCTruth) fCfContainer->Fill(values,step);
+      if (isMCTruth) fCfContainer->Fill(fValues,step);
       ++step;
     } else {
       step+=2;
@@ -327,16 +391,33 @@ void AliDielectronCF::FillMC(const TObject *particle)
   //
   if (!fStepForMCtruth) return;
   
-  Double_t valuesAll[AliDielectronVarManager::kNMaxValues];
-  AliDielectronVarManager::Fill(particle,valuesAll);
+  Double_t valuesPair[AliDielectronVarManager::kNMaxValues];
+  AliDielectronVarManager::Fill(particle,valuesPair);
+  
+  //TODO: temporary solution, set manually the pair type to 1: mixed e+-
+  valuesPair[AliDielectronVarManager::kPairType]=1;
   
-  Double_t values[AliDielectronVarManager::kNMaxValues];
   for (Int_t iVar=0; iVar<fNVars; ++iVar){
     Int_t var=fVariables[iVar];
-    values[iVar]=valuesAll[var];
+    fValues[iVar]=valuesPair[var];
   }
-  //TODO: temporary solution, set manually the pair type to 1: mixed e+-
-  values[AliDielectronVarManager::kPairType]=1;
-  fCfContainer->Fill(values,0);
+  
+  if (fNVarsLeg>0){
+    AliVParticle *d1=0x0;
+    AliVParticle *d2=0x0;
+    AliDielectronMC::Instance()->GetDaughters(particle,d1,d2);
+    Double_t valuesLeg1[AliDielectronVarManager::kNMaxValues];
+    AliDielectronVarManager::Fill(d1,valuesLeg1);
+    Double_t valuesLeg2[AliDielectronVarManager::kNMaxValues];
+    AliDielectronVarManager::Fill(d2,valuesLeg2);
+    
+    for (Int_t iVar=0; iVar<fNVarsLeg; ++iVar){
+      Int_t var=fVariablesLeg[iVar];
+      fValues[iVar+fNVars]=valuesLeg1[var];
+      fValues[iVar+fNVars+fNVarsLeg]=valuesLeg2[var];
+    }
+  }
+  
+  fCfContainer->Fill(fValues,0);
 }
 
index 272791c982b755e4745ae931ad328736857127f2..609cd42834d9cf694562764ffb205a5eff667cb7 100644 (file)
@@ -27,6 +27,7 @@
 class AliAnalysisCuts;
 class AliAnalysisFilter;
 class AliCFContainer;
+class AliDielectronPair;
 
 class AliDielectronCF : public TNamed {
 public:
@@ -46,26 +47,36 @@ public:
   
   void AddStepMask(UInt_t mask)                  { fStepMasks[fNStepMasks++]=mask; }
   
-  void AddVariable(AliDielectronVarManager::ValueTypes type, Int_t nbins, Double_t min, Double_t max);
+  void AddVariable(AliDielectronVarManager::ValueTypes type, Int_t nbins, Double_t min, Double_t max, Bool_t leg=kFALSE);
 
   void InitialiseContainer(const AliAnalysisFilter& filter);
   
-  void Fill(UInt_t mask, const TObject *particle);
+//   void Fill(UInt_t mask, const TObject *particle);
+  void Fill(UInt_t mask, const AliDielectronPair *particle);
   void FillMC(const TObject *particle);
   
   AliCFContainer* GetContainer() const { return fCfContainer; }
   
-// private:
+private:
   UInt_t          fVariables[AliDielectronVarManager::kNMaxValues]; //configured variables
+  UInt_t          fVariablesLeg[AliDielectronVarManager::kNMaxValues]; //configured variables for the legs
   
   Int_t           fNSteps;                     // number of selection steps
+  
   Int_t           fNVars;                      // number of variables
   Int_t           fNBins[kNmaxAddSteps];       // array of numbers ob bins of the vars
   Double_t        fVarLoLimit[kNmaxAddSteps];  // array of the lower limits of the vars
   Double_t        fVarUpLimit[kNmaxAddSteps];  // array of the upper limits of the vars
 
-  Int_t           fNCuts;                      // Number of cuts in the filter concerned
+  Int_t           fNVarsLeg;                      // number of variables for the legs
+  Int_t           fNBinsLeg[kNmaxAddSteps];       // array of numbers ob bins of the vars for the legs
+  Double_t        fVarLoLimitLeg[kNmaxAddSteps];  // array of the lower limits of the vars for the legs
+  Double_t        fVarUpLimitLeg[kNmaxAddSteps];  // array of the upper limits of the vars for the legs
+  
+  Int_t           fNCuts;                         // Number of cuts in the filter concerned
 
+  Double_t        *fValues;                       // Value array for filling the container
+  
   Bool_t fStepForMCtruth;               //create a step for the MC truth
   Bool_t fStepForNoCutsMCmotherPid;     //create a step for before cuts, but with MC truth of the mother
   Bool_t fStepForAfterAllCuts;          //create a step for before cuts, but with MC truth of the mother
@@ -82,7 +93,7 @@ public:
   AliDielectronCF(const AliDielectronCF &c);
   AliDielectronCF &operator=(const AliDielectronCF &c);
   
-  ClassDef(AliDielectronCF,2)  //Dielectron Correction Framework handler
+  ClassDef(AliDielectronCF,3)  //Dielectron Correction Framework handler
 };
 
 #endif
diff --git a/PWG3/dielectron/AliDielectronCFdraw.cxx b/PWG3/dielectron/AliDielectronCFdraw.cxx
new file mode 100644 (file)
index 0000000..4deb36d
--- /dev/null
@@ -0,0 +1,344 @@
+/*************************************************************************
+* Copyright(c) 1998-2009, ALICE Experiment at CERN, All rights reserved. *
+*                                                                        *
+* Author: The ALICE Off-line Project.                                    *
+* Contributors are mentioned in the code where appropriate.              *
+*                                                                        *
+* Permission to use, copy, modify and distribute this software and its   *
+* documentation strictly for non-commercial purposes is hereby granted   *
+* without fee, provided that the above copyright notice appears in all   *
+* copies and that both the copyright notice and this permission notice   *
+* appear in the supporting documentation. The authors make no claims     *
+* about the suitability of this software for any purpose. It is          *
+* provided "as is" without express or implied warranty.                  *
+**************************************************************************/
+
+///////////////////////////////////////////////////////////////////////////
+//       Dielectron Correction framework draw helper                     //
+//                                                                       //
+/*
+
+
+
+
+
+
+
+
+
+*/
+//                                                                       //
+///////////////////////////////////////////////////////////////////////////
+
+#include <TSeqCollection.h>
+#include <TObjArray.h>
+#include <TKey.h>
+#include <TList.h>
+#include <TObject.h>
+#include <TFile.h>
+#include <TString.h>
+#include <TObjString.h>
+#include <TMath.h>
+#include <TH1.h>
+#include <TH2.h>
+#include <TH3.h>
+#include <TPad.h>
+#include <TCanvas.h>
+
+#include <AliLog.h>
+
+#include "AliDielectronCFdraw.h"
+
+ClassImp(AliDielectronCFdraw)
+
+AliDielectronCFdraw::AliDielectronCFdraw() :
+  TNamed(),
+  fCfContainer(0x0)
+{
+  //
+  // Ctor
+  //
+}
+
+//________________________________________________________________
+AliDielectronCFdraw::AliDielectronCFdraw(const char*name, const char* title) :
+  TNamed(name,title),
+  fCfContainer(0x0)
+{
+  //
+  // Named Ctor
+  //
+  
+}
+
+//________________________________________________________________
+void AliDielectronCFdraw::SetCFContainers(const TSeqCollection *arr)
+{
+  //
+  // Merge CF Container out of several containers
+  //
+
+  TIter next(arr);
+  TObject *o=0x0;
+
+  Int_t nstep=0;
+  while ( (o=next()) ){
+    AliCFContainer *cf=dynamic_cast<AliCFContainer*>(o);
+    if (!o) continue;
+    nstep+=cf->GetNStep();
+  }
+  Int_t nbins[1]={1};
+  fCfContainer=new AliCFContainer(GetName(), GetTitle(), nstep, 1, nbins);
+
+  //delete unneeded steps
+  for (Int_t istep=0; istep<nstep; ++istep) delete fCfContainer->GetGrid(istep);
+
+  //add step to the new container
+  Int_t istep=0;
+  for (Int_t icf=0; icf<arr->GetEntries(); ++icf){
+    AliCFContainer *cf=dynamic_cast<AliCFContainer*>(arr->At(icf));
+    if (!cf) continue;
+    for (Int_t istepCurr=0; istepCurr<cf->GetNStep(); ++istepCurr){
+      fCfContainer->SetGrid(istep, cf->GetGrid(istepCurr));
+      fCfContainer->SetStepTitle(istep,Form("%s: %s",cf->GetName(),cf->GetStepTitle(istepCurr)));
+      ++istep;
+    }
+  }
+}
+
+//________________________________________________________________
+void AliDielectronCFdraw::SetCFContainers(const char* filename)
+{
+  //
+  // get CF containers from file
+  //
+
+  TFile f(filename);
+  TList *l=f.GetListOfKeys();
+  Int_t entries=l->GetEntries();
+  if (entries==0) return;
+  
+  TKey *k=(TKey*)l->At(0);
+  TSeqCollection *arr=dynamic_cast<TSeqCollection*>(k->ReadObj());
+  if (!arr) return;
+  
+  SetCFContainers(arr);
+}
+
+//________________________________________________________________
+void AliDielectronCFdraw::SetRangeUser(Int_t ivar, Double_t min, Double_t max, const char* slices)
+{
+  //
+  // Set range of cut steps defined in slices
+  // Steps may be separated by one the the characteres ,;:
+  //
+  TObjArray *arr=TString(slices).Tokenize(",:;");
+
+  if (arr->GetEntriesFast()==0){
+    // all slices in case of 0 entries
+    for (Int_t istep=0; istep<fCfContainer->GetNStep(); ++istep){
+      fCfContainer->SetRangeUser(ivar,min,max,istep);
+    }
+  } else {
+    TIter next(arr);
+    TObjString *ostr=0x0;
+    while ( (ostr=static_cast<TObjString*>(next())) ) {
+      Int_t istep=ostr->GetString().Atoi();
+      fCfContainer->SetRangeUser(ivar,min,max,istep);
+    }
+  }
+  delete arr;
+}
+
+//________________________________________________________________
+void AliDielectronCFdraw::UnsetRangeUser(Int_t ivar, const char* slices)
+{
+  //
+  // Unset range of cut steps defined in slices
+  // Steps may be separated by one the the characteres ,;:
+  //
+  TObjArray *arr=TString(slices).Tokenize(",:;");
+  
+  if (arr->GetEntriesFast()==0){
+    // all slices in case of 0 entries
+    for (Int_t istep=0; istep<fCfContainer->GetNStep(); ++istep){
+      fCfContainer->SetRangeUser(ivar,fCfContainer->GetAxis(ivar,istep)->GetXmin(),
+                                 fCfContainer->GetAxis(ivar,istep)->GetXmax(),istep);
+    }
+  } else {
+    TIter next(arr);
+    TObjString *ostr=0x0;
+    while ( (ostr=static_cast<TObjString*>(next())) ) {
+      Int_t istep=ostr->GetString().Atoi();
+      fCfContainer->SetRangeUser(ivar,fCfContainer->GetAxis(ivar,istep)->GetXmin(),
+                                 fCfContainer->GetAxis(ivar,istep)->GetXmax(),istep);
+    }
+  }
+  delete arr;
+}
+
+//________________________________________________________________
+void AliDielectronCFdraw::Draw(const Option_t* varnames, const char* slices, const char* opt)
+{
+  //
+  // Draw 'variables' of 'slices'
+  // for multidimensional draw variables may be separated by a ':'
+  // slice numbers may be separated by any of ,:;
+  //
+  // variables may be called by either their name or number
+  //
+
+  TObjArray *arrVars=TString(varnames).Tokenize(":");
+  Int_t entries=arrVars->GetEntriesFast();
+  if (entries<1||entries>3){
+    AliError("Wrong number of variables, supported are 1 - 3 dimensions");
+    delete arrVars;
+    return;
+  }
+  
+  TIter next(arrVars);
+  TObjString *ostr=0x0;
+  Int_t ivar[3]={-1,-1,-1};
+  for (Int_t i=0; i<entries; ++i){
+    ostr=static_cast<TObjString*>(next());
+    if (ostr->GetString().IsDigit()){
+      ivar[i]=ostr->GetString().Atoi();
+    } else {
+      ivar[i]=fCfContainer->GetVar(ostr->GetName());
+    }
+  }
+
+  switch (entries){
+  case 1:
+    Draw(ivar[0],slices,opt);
+    break;
+  case 2:
+    Draw(ivar[0],ivar[1],slices,opt);
+    break;
+  case 3:
+    Draw(ivar[0],ivar[1],ivar[2],slices,opt);
+    break;
+  }
+  delete arrVars;
+}
+
+//________________________________________________________________
+void AliDielectronCFdraw::Draw(Int_t var, const char* opt, const char* slices)
+{
+  //
+  // Draw variable var for all slices
+  // slices may be divided by and of ,;:
+  //
+  // if opt contains 'same' all histograms are drawn in the same pad
+  // otherwise the pad will be divided in sub pads and the histograms
+  // are drawn in each sub pad
+  //
+
+  const Int_t ndim=1;
+  Int_t vars[ndim]={var};
+  TObjArray *arr=CollectHistos(ndim,vars,slices);
+  Draw(arr,opt);
+  delete arr; 
+}
+
+//________________________________________________________________
+void AliDielectronCFdraw::Draw(Int_t var0, Int_t var1, const char* opt, const char* slices)
+{
+  //
+  // Draw 2D case
+  //
+  const Int_t ndim=2;
+  Int_t vars[ndim]={var0,var1};
+  TObjArray *arr=CollectHistos(ndim,vars,slices);
+  Draw(arr,opt);
+  delete arr;
+}
+
+//________________________________________________________________
+void AliDielectronCFdraw::Draw(Int_t var0, Int_t var1, Int_t var2, const char* opt, const char* slices)
+{
+  //
+  // Draw 3D case
+  //
+  const Int_t ndim=3;
+  Int_t vars[ndim]={var0,var1,var2};
+  TObjArray *arr=CollectHistos(ndim,vars,slices);
+  Draw(arr,opt);
+  delete arr;
+}
+
+//________________________________________________________________
+void AliDielectronCFdraw::Draw(const TObjArray *arr, const char* opt)
+{
+  //
+  // draw all objects in arr
+  //
+  TString optStr(opt);
+  optStr.ToLower();
+  Bool_t drawSame=optStr.Contains("same");
+  optStr.ReplaceAll("same","");
+  if (!gPad) new TCanvas;
+  TCanvas *c=gPad->GetCanvas();
+  c->Clear();
+  if (!drawSame){
+    //optimised division
+    Int_t nPads = arr->GetEntries();
+    Int_t nCols = (Int_t)TMath::Ceil( TMath::Sqrt(nPads) );
+    Int_t nRows = (Int_t)TMath::Ceil( (Double_t)nPads/(Double_t)nCols );
+    c->Divide(nCols,nRows);
+    for (Int_t i=0; i<nPads; ++i){
+      c->cd(i+1);
+      arr->UncheckedAt(i)->Draw(optStr.Data());
+    }
+  }
+}
+
+//________________________________________________________________
+TObjArray* AliDielectronCFdraw::CollectHistos(Int_t dim, Int_t *vars, const char* slices)
+{
+  //
+  // Collect histos with 'dim'ension of the 'slices' separated by one of "':;'"
+  // in a TObjArray and return it
+  //
+  TObjArray *arr=TString(slices).Tokenize(",:;");
+  TObjArray *arrHists=0x0;
+  if (arr->GetEntriesFast()==0){
+    // all slices in case of 0 entries
+    arrHists=new TObjArray(fCfContainer->GetNStep());
+    for (Int_t istep=0; istep<fCfContainer->GetNStep(); ++istep){
+      arrHists->Add(Project(dim,vars,istep));
+    }
+  } else {
+    arrHists=new TObjArray(arr->GetEntriesFast());
+    TIter next(arr);
+    TObjString *ostr=0x0;
+    while ( (ostr=static_cast<TObjString*>(next())) ) {
+      Int_t istep=ostr->GetString().Atoi();
+      arrHists->Add(Project(dim,vars,istep));
+    }
+  }
+  delete arr;
+
+  return arrHists;
+}
+
+//________________________________________________________________
+TH1* AliDielectronCFdraw::Project(Int_t ndim, Int_t *vars, Int_t slice)
+{
+  //
+  // Do an nim projection
+  //
+  switch (ndim){
+  case 1:
+    return fCfContainer->Project(vars[0],slice);
+    break;
+  case 2:
+    return fCfContainer->Project(vars[0],vars[1],slice);
+    break;
+  case 3:
+    return fCfContainer->Project(vars[0],vars[1],vars[2],slice);
+    break;
+  }
+  return 0x0;
+}
+
diff --git a/PWG3/dielectron/AliDielectronCFdraw.h b/PWG3/dielectron/AliDielectronCFdraw.h
new file mode 100644 (file)
index 0000000..e79c5b6
--- /dev/null
@@ -0,0 +1,84 @@
+#ifndef ALIDIELECTRONCFDRAW_H
+#define ALIDIELECTRONCFDRAW_H
+/* Copyright(c) 1998-2009, ALICE Experiment at CERN, All rights reserved. *
+ * See cxx source for full Copyright notice                               */
+
+//#############################################################
+//#                                                           #
+//#             Class AliDielectronCF                         #
+//#       Dielectron Correction Framework Draw helper         #
+//#                                                           #
+//#  Authors:                                                 #
+//#   Anton     Andronic, GSI / A.Andronic@gsi.de             #
+//#   Ionut C.  Arsene,   GSI / I.C.Arsene@gsi.de             #
+//#   Julian    Book,     Uni Ffm / Julian.Book@cern.ch       #
+//#   Frederick Kramer,   Uni Ffm, / Frederick.Kramer@cern.ch #
+//#   Magnus    Mager,    CERN / Magnus.Mager@cern.ch         #
+//#   WooJin J. Park,     GSI / W.J.Park@gsi.de               #
+//#   Jens      Wiechula, Uni HD / Jens.Wiechula@cern.ch      #
+//#                                                           #
+//#############################################################
+
+
+
+#include <TNamed.h>
+#include <AliCFContainer.h>
+
+class TObjArray;
+class TSeqCollection;
+class TH1;
+
+class AliCFContainer;
+
+class AliDielectronCFdraw : public TNamed {
+public:
+  AliDielectronCFdraw();
+  AliDielectronCFdraw(const char* name, const char* title);
+
+  void SetCFContainer(AliCFContainer * const container) {fCfContainer=container;}
+  void SetCFContainers(const TSeqCollection *arr);
+
+  void SetCFContainers(const char* filename);
+
+  AliCFContainer* GetCFContainer() const {return fCfContainer;}
+
+  void SetRangeUser(Int_t ivar, Double_t min, Double_t max, const char* slices="");
+  void SetRangeUser(const char* varname, Double_t min, Double_t max, const char* slices="");
+
+  void UnsetRangeUser(Int_t ivar, const char* slices="");
+  void UnsetRangeUser(const char* varname, const char* slices="");
+
+//   virtual void Draw(const Option_t* /*option*/ = "") {;}
+  void Draw(const Option_t* varnames, const char* opt="", const char* slices="");
+  void Draw(Int_t var, const char* opt="", const char* slices="");
+  void Draw(Int_t var0, Int_t var1, const char* opt="", const char* slices="");
+  void Draw(Int_t var0, Int_t var1, Int_t var2, const char* opt="", const char* slices="");
+  void Draw(const TObjArray *arr, const char* opt="");
+  
+  TObjArray* CollectHistos(Int_t dim, Int_t *vars, const char* slices);
+  TH1* Project(Int_t ndim, Int_t *vars, Int_t slice);
+  
+private:
+  AliCFContainer *fCfContainer;                     // CF container
+
+  AliDielectronCFdraw(const AliDielectronCFdraw &c);
+  AliDielectronCFdraw &operator=(const AliDielectronCFdraw &c);
+  
+  ClassDef(AliDielectronCFdraw,0)                   // CF draw helper class
+};
+
+//
+// Inline functions
+//
+inline void AliDielectronCFdraw::SetRangeUser(const char* varname, Double_t min, Double_t max, const char* slices)
+{
+  SetRangeUser(fCfContainer->GetVar(varname),min,max,slices);
+}
+
+//________________________________________________________________
+inline void AliDielectronCFdraw::UnsetRangeUser(const char* varname, const char* slices)
+{
+  UnsetRangeUser(fCfContainer->GetVar(varname),slices);
+}
+#endif
+
index b2fcaf573a33597e23b63dd2c2263acdeb343aaa..6ba008e179b8a2868a51a7ee500fc900ac325799 100644 (file)
@@ -424,3 +424,27 @@ Bool_t AliDielectronMC::IsMotherPdgAOD(const AliVParticle *particle1, const AliV
   return kTRUE;
 }
 
+//____________________________________________________________
+void AliDielectronMC::GetDaughters(const TObject *mother, AliVParticle* &d1, AliVParticle* &d2)
+{
+  //
+  // Get First two daughters of the mother
+  //
+
+  Int_t lblD1=-1;
+  Int_t lblD2=-1;
+  d1=0;
+  d2=0;
+  if (!fMCEvent) return;
+  if (fAnaType==kAOD){
+    const AliAODMCParticle *aodMother=static_cast<const AliAODMCParticle*>(mother);
+    lblD1=aodMother->GetDaughter(0);
+    lblD2=aodMother->GetDaughter(1);
+  } else if (fAnaType==kESD){
+    const AliMCParticle *aodMother=static_cast<const AliMCParticle*>(mother);
+    lblD1=aodMother->GetFirstDaughter();
+    lblD2=aodMother->GetLastDaughter();
+  }
+  d1=fMCEvent->GetTrack(lblD1);
+  d2=fMCEvent->GetTrack(lblD2);
+}
index 17231afafb42e62eeb398c6f0e7edf401d3bbb2c..cc0edef124e247ec65a1043f5ece8bfb7e33dd9a 100644 (file)
@@ -61,6 +61,8 @@ public:
   AliMCParticle* GetMCTrack(AliESDtrack* _track);             // return MC track associated with reco track
   TParticle* GetMCTrackMotherFromStack(AliESDtrack* _track);  // return MC mother track from stack
   AliMCParticle* GetMCTrackMother(AliESDtrack* _track);       // return MC mother track from stack
+
+  void GetDaughters(const TObject *mother, AliVParticle* &d1, AliVParticle* &d2);
   
 private:
   AliMCEvent    *fMCEvent;  // MC event object
index 4c93cc8c7499580e78a46a65294fde26427a3018..7957a565d7dfe4ca7f2254f7500996439196ccf8 100644 (file)
@@ -68,7 +68,7 @@ public:
   virtual Double_t M() const { return fPair.GetMass(); }
   
   virtual Double_t Eta() const { return fPair.GetEta();}
-  virtual Double_t Y()  const  { return TLorentzVector(Px(),Py(),Pz(),E()).Y();}
+  virtual Double_t Y()  const  { return TLorentzVector(Px(),Py(),Pz(),E()).Rapidity();}
   
   virtual Short_t Charge() const    { return fPair.GetQ();}
   virtual Int_t   GetLabel() const  { return -1; }  //TODO: check
index a6fcbb53edab3f4d434ca0027715de5685b9afca..b8247a5c0f6504ae5f7851626237e8ce7a11dc93 100644 (file)
@@ -56,6 +56,7 @@ const char* AliDielectronVarManager::fgkParticleNames[AliDielectronVarManager::k
   "PdgCode",
   "P from InnerParam",
   "TPC signal",
+  "TPC nSigma Electrons",
   //
   "Chi2NDF",
   "DecayLength",
@@ -72,10 +73,12 @@ const char* AliDielectronVarManager::fgkParticleNames[AliDielectronVarManager::k
   "YRes",
   "ZRes",
   "NTrk",
-  "Tracks"
+  "Tracks",
+  "Nevents"
 };
 
-
+AliESDpid* AliDielectronVarManager::fgESDpid = new AliESDpid;
+AliVEvent* AliDielectronVarManager::fgEvent  = 0x0;
 //________________________________________________________________
 AliDielectronVarManager::AliDielectronVarManager() :
   TNamed("AliDielectronVarManager","AliDielectronVarManager")
index c57f34db475da4c72a3ead95aa907f78b5a942b2..7e82f2c9b13486a528a6c07ef8f346e6fefe60b1 100644 (file)
@@ -12,7 +12,7 @@
 //#   Anton     Andronic, GSI / A.Andronic@gsi.de             #
 //#   Ionut C.  Arsene,   GSI / I.C.Arsene@gsi.de             #
 //#   Julian    Book,     Uni Ffm / Julian.Book@cern.ch       #
-//#   Frederick Kramer,   Uni Ffm, / Frederick.Kramer@cern.ch #
+//#   Frederick Kramer,   Uni Ffm / Frederick.Kramer@cern.ch  #
 //#   Magnus    Mager,    CERN / Magnus.Mager@cern.ch         #
 //#   WooJin J. Park,     GSI / W.J.Park@gsi.de               #
 //#   Jens      Wiechula, Uni HD / Jens.Wiechula@cern.ch      #
 
 #include <AliVEvent.h>
 #include <AliESDEvent.h>
+#include <AliAODEvent.h>
+#include <AliMCEvent.h>
+#include <AliVVertex.h>
+#include <AliESDVertex.h>
 
 #include <AliVParticle.h>
-#include <AliExternalTrackParam.h>
 #include <AliESDtrack.h>
 #include <AliAODTrack.h>
 #include <AliKFParticle.h>
@@ -34,6 +37,9 @@
 #include <AliAODMCParticle.h>
 #include <AliVTrack.h>  // ?
 
+#include <AliExternalTrackParam.h>
+#include <AliESDpid.h>
+
 #include "AliDielectronPair.h"
 
 class AliVEvent;
@@ -74,6 +80,7 @@ public:
     kPdgCode,                // PDG code
     kPIn,                    // momentum at inner wall of TPC (if available), used for PID
     kTPCsignal,              // TPC dE/dx signal
+    kTPCnSigmaEle,           // number of sigmas to the dE/dx electron line in the TPC
     kParticleMax,             //
     // TODO: kRNClusters ??
   // AliDielectronPair specific variables
@@ -86,14 +93,15 @@ public:
     kPairType,               // type of the pair, like like sign ++ unlikesign ...
     kPairMax,                 //
   // Event specific variables
-    kXvPrim=kPairMax,        // TODO: prim vertex
-    kYvPrim,                 // TODO: prim vertex
-    kZvPrim,                 // TODO: prim vertex
-    kXRes,                   // primary vertex x-resolution (AliESDVertex)
-    kYRes,                   // primary vertex y-resolution (AliESDVertex)
-    kZRes,                   // primary vertex z-resolution (AliESDVertex)
+    kXvPrim=kPairMax,        // prim vertex
+    kYvPrim,                 // prim vertex
+    kZvPrim,                 // prim vertex
+    kXRes,                   // primary vertex x-resolution
+    kYRes,                   // primary vertex y-resolution
+    kZRes,                   // primary vertex z-resolution
     kNTrk,                   // number of tracks (or tracklets)
-    kTracks,                 // ESD tracks (AliESDEvent)
+    kTracks,                 // ESD tracks
+    kNevents,                // event counter
     kNMaxValues              //
     // TODO: (for A+A) ZDCEnergy, impact parameter, Iflag??
   };
@@ -104,6 +112,9 @@ public:
   virtual ~AliDielectronVarManager();
   static void Fill(const TObject* particle, Double_t * const values);
 
+  static void InitESDpid(Int_t type=0);
+  static void SetEvent(AliVEvent * const ev) { fgEvent = ev; }
+
   static const char* GetValueName(Int_t i) { return (i>=0&&i<kNMaxValues)?fgkParticleNames[i]:""; }
 private:
 
@@ -112,9 +123,16 @@ private:
   static void FillVarVParticle(const AliVParticle *particle,         Double_t * const values);
   static void FillVarESDtrack(const AliESDtrack *particle,           Double_t * const values);
   static void FillVarAODTrack(const AliAODTrack *particle,           Double_t * const values);
-  static  void FillVarMCParticle(const AliMCParticle *particle,       Double_t * const values);
+  static  void FillVarMCParticle(const AliMCParticle *particle,      Double_t * const values);
   static void FillVarAODMCParticle(const AliAODMCParticle *particle, Double_t * const values);
   static void FillVarDielectronPair(const AliDielectronPair *pair,   Double_t * const values);
+  static void FillVarVEvent(const AliVEvent *event,                  Double_t * const values);
+  static void FillVarESDEvent(const AliESDEvent *event,              Double_t * const values);
+  static void FillVarAODEvent(const AliAODEvent *event,              Double_t * const values);
+  static void FillVarMCEvent(const AliMCEvent *event,                Double_t * const values);
+
+  static AliESDpid* fgESDpid;                 // ESD pid object
+  static AliVEvent* fgEvent;                  // current event pointer
 
   AliDielectronVarManager(const AliDielectronVarManager &c);
   AliDielectronVarManager &operator=(const AliDielectronVarManager &c);
@@ -124,18 +142,25 @@ private:
 
 
 //Inline functions
-inline void AliDielectronVarManager::Fill(const TObject* particle, Double_t * const values)
+inline void AliDielectronVarManager::Fill(const TObject* object, Double_t * const values)
 {
   //
   // Main function to fill all available variables according to the type of particle
   //
 
-  if      (particle->IsA() == AliESDtrack::Class())       FillVarESDtrack(static_cast<const AliESDtrack*>(particle), values);
-  else if (particle->IsA() == AliAODTrack::Class())       FillVarAODTrack(static_cast<const AliAODTrack*>(particle), values);
-  else if (particle->IsA() == AliMCParticle::Class())     FillVarMCParticle(static_cast<const AliMCParticle*>(particle), values);
-  else if (particle->IsA() == AliAODMCParticle::Class())  FillVarAODMCParticle(static_cast<const AliAODMCParticle*>(particle), values);
-  else if (particle->IsA() == AliDielectronPair::Class()) FillVarDielectronPair(static_cast<const AliDielectronPair*>(particle), values);
-//   else Error("Fill",Form("Type %s is not supported by AliDielectronVarManager!", particle->ClassName())); //TODO: implement without object needed
+  if      (object->IsA() == AliESDtrack::Class())       FillVarESDtrack(static_cast<const AliESDtrack*>(object), values);
+  else if (object->IsA() == AliAODTrack::Class())       FillVarAODTrack(static_cast<const AliAODTrack*>(object), values);
+  else if (object->IsA() == AliMCParticle::Class())     FillVarMCParticle(static_cast<const AliMCParticle*>(object), values);
+  else if (object->IsA() == AliAODMCParticle::Class())  FillVarAODMCParticle(static_cast<const AliAODMCParticle*>(object), values);
+  else if (object->IsA() == AliDielectronPair::Class()) FillVarDielectronPair(static_cast<const AliDielectronPair*>(object), values);
+
+  // Main function to fill all available variables according to the type of event
+  
+  else if (object->IsA() == AliVEvent::Class())         FillVarVEvent(static_cast<const AliVEvent*>(object), values);
+  else if (object->IsA() == AliESDEvent::Class())       FillVarESDEvent(static_cast<const AliESDEvent*>(object), values);
+  else if (object->IsA() == AliAODEvent::Class())       FillVarAODEvent(static_cast<const AliAODEvent*>(object), values);
+  else if (object->IsA() == AliMCEvent::Class())        FillVarMCEvent(static_cast<const AliMCEvent*>(object), values);
+//   else Error("Fill",Form("Type %s is not supported by AliDielectronVarManager!", object->ClassName())); //TODO: implement without object needed
 }
 
 inline void AliDielectronVarManager::FillVarVParticle(const AliVParticle *particle, Double_t * const values)
@@ -162,6 +187,8 @@ inline void AliDielectronVarManager::FillVarVParticle(const AliVParticle *partic
   values[AliDielectronVarManager::kE]         = particle->E();
   values[AliDielectronVarManager::kM]         = particle->M();
   values[AliDielectronVarManager::kCharge]    = particle->Charge();
+
+  if ( fgEvent ) AliDielectronVarManager::Fill(fgEvent, values);
 }
 
 inline void AliDielectronVarManager::FillVarESDtrack(const AliESDtrack *particle, Double_t * const values)
@@ -188,14 +215,16 @@ inline void AliDielectronVarManager::FillVarESDtrack(const AliESDtrack *particle
   values[AliDielectronVarManager::kImpactParZ]    = impactParZ;
 
   values[AliDielectronVarManager::kTrackLength]   = particle->GetIntegratedLength();
-
   //dEdx information
   Double_t mom = particle->GetP();
   const AliExternalTrackParam *in=particle->GetInnerParam();
   if (in) mom = in->GetP();
   values[AliDielectronVarManager::kPIn]=mom;
   values[AliDielectronVarManager::kTPCsignal]=particle->GetTPCsignal();
-  
+  // nsigma to Electron band
+  // TODO: for the moment we set the bethe bloch parameters manually
+  //       this should be changed in future!
+  values[AliDielectronVarManager::kTPCnSigmaEle]=fgESDpid->NumberOfSigmasTPC(particle,AliPID::kElectron);
 }
 
 inline void AliDielectronVarManager::FillVarAODTrack(const AliAODTrack *particle, Double_t * const values)
@@ -257,6 +286,92 @@ inline void AliDielectronVarManager::FillVarDielectronPair(const AliDielectronPa
   values[AliDielectronVarManager::kPairType]     = pair->GetType();
 }
 
+
+inline void AliDielectronVarManager::FillVarVEvent(const AliVEvent *event, Double_t * const values)
+{
+  //
+  // Fill event information available for histogramming into an array
+  //
+  const AliVVertex *primVtx = event->GetPrimaryVertex();
+  values[AliDielectronVarManager::kXvPrim]       = primVtx->GetX();
+  values[AliDielectronVarManager::kYvPrim]       = primVtx->GetY();
+  values[AliDielectronVarManager::kZvPrim]       = primVtx->GetZ();
+  values[AliDielectronVarManager::kChi2NDF]      = primVtx->GetChi2perNDF();
+
+  values[AliDielectronVarManager::kNTrk]         = event->GetNumberOfTracks();
+  values[AliDielectronVarManager::kNevents]      = 0; //always fill bin 0;
+}
+
+inline void AliDielectronVarManager::FillVarESDEvent(const AliESDEvent *event, Double_t * const values)
+{
+  //
+  // Fill event information available for histogramming into an array
+  // 
+  
+  // Fill common AliVEvent interface information
+  FillVarVEvent(event, values);
+  // Fill AliESDEvent interface specific information
+  const AliESDVertex *primVtx = event->GetPrimaryVertex();
+  values[AliDielectronVarManager::kXRes]       = primVtx->GetXRes();
+  values[AliDielectronVarManager::kYRes]       = primVtx->GetYRes();
+  values[AliDielectronVarManager::kZRes]       = primVtx->GetZRes();
+}
+  
+inline void AliDielectronVarManager::FillVarAODEvent(const AliAODEvent *event, Double_t * const values)
+{
+  //
+  // Fill event information available for histogramming into an array
+  //   
+
+  // Fill common AliVEvent interface information
+  FillVarVEvent(event, values);
+
+  // Fill AliAODEvent interface specific information
+}
+  
+inline void AliDielectronVarManager::FillVarMCEvent(const AliMCEvent *event, Double_t * const values)
+{ 
+  //
+  // Fill event information available for histogramming into an array
+  //   
+        
+  // Fill common AliVEvent interface information
+  FillVarVEvent(event, values);
+
+  // Fill AliMCEvent interface specific information
+} 
+  
+inline void AliDielectronVarManager::InitESDpid(Int_t type)
+{
+  //
+  // initialize PID parameters
+  // type=0 is simulation
+  // type=1 is data
+
+  Double_t alephParameters[5];
+  // simulation
+  alephParameters[0] = 2.15898e+00/50.;
+  alephParameters[1] = 1.75295e+01;
+  alephParameters[2] = 3.40030e-09;
+  alephParameters[3] = 1.96178e+00;
+  alephParameters[4] = 3.91720e+00;
+  
+  // data
+  if (type==1){
+    alephParameters[0] = 0.0283086;
+    alephParameters[1] = 2.63394e+01;
+    alephParameters[2] = 5.04114e-11;
+    alephParameters[3] = 2.12543e+00;
+    alephParameters[4] = 4.88663e+00;
+  }
+
+  fgESDpid->GetTPCResponse().SetBetheBlochParameters(
+    alephParameters[0],alephParameters[1],alephParameters[2],
+    alephParameters[3],alephParameters[4]);
+  
+}
+
 /*
 inline void AliDielectronVarManager::FillValues(const TParticle *particle, Double_t *values)
 {
index bceb5287db4ff1a0276d031f282b23b413988e56..4e4aeb58f911e95c8a8646d9e8bd91fbe285fec4 100644 (file)
@@ -4,6 +4,7 @@ SRCS= dielectron/AliDielectron.cxx \
       dielectron/AliDielectronPair.cxx \
       dielectron/AliDielectronHistos.cxx \
       dielectron/AliDielectronCF.cxx \
+      dielectron/AliDielectronCFdraw.cxx \
       dielectron/AliDielectronMC.cxx \
       dielectron/AliDielectronVarManager.cxx \
       dielectron/AliAnalysisTaskDielectronSE.cxx \