Further bugfixes, coding violations and warning removal.

diff --git a/PWG3/dielectron/AliAnalysisTaskDielectronEfficiency.cxx b/PWG3/dielectron/AliAnalysisTaskDielectronEfficiency.cxx
index 97ed8d016794a0584fc9907aceb8a11f8996c3a5..1cc09e55a6dedd9dfaae5aac3977ce0bfb0b57d5 100644 (file)
--- a/PWG3/dielectron/AliAnalysisTaskDielectronEfficiency.cxx
+++ b/PWG3/dielectron/AliAnalysisTaskDielectronEfficiency.cxx
@@ -403,7 +403,7 @@ void AliAnalysisTaskDielectronEfficiency::FillPlots(AliVEvent *event)
 // }
 
 
-void AliAnalysisTaskDielectronEfficiency::FillMCInfo(AliStack *pStack)
+void AliAnalysisTaskDielectronEfficiency::FillMCInfo(AliStack * const pStack)
 {
   //
   // fill pure MC histograms

diff --git a/PWG3/dielectron/AliAnalysisTaskDielectronEfficiency.h b/PWG3/dielectron/AliAnalysisTaskDielectronEfficiency.h
index 902104bd86ecee4a69bf3d53abe2ae21d79210c1..0574d3b545e46504c792fb3bd998c11d72d88fff 100644 (file)
--- a/PWG3/dielectron/AliAnalysisTaskDielectronEfficiency.h
+++ b/PWG3/dielectron/AliAnalysisTaskDielectronEfficiency.h
@@ -60,7 +60,7 @@ private:
   TDatabasePDG        *fPDG;           //! PDG database
 
   void FillPlots(AliVEvent *event);
-  void FillMCInfo(AliStack *pStack);
+  void FillMCInfo(AliStack * const pStack);
 
   AliAnalysisTaskDielectronEfficiency(const AliAnalysisTaskDielectronEfficiency &c);
   AliAnalysisTaskDielectronEfficiency& operator= (const AliAnalysisTaskDielectronEfficiency &c);

diff --git a/PWG3/dielectron/AliDielectronCF.cxx b/PWG3/dielectron/AliDielectronCF.cxx
index 258739fd9c86a6c25d5cce2f7b51b9b31fcbb7ec..8c80541a2d03559536fec2acb6b90b1e74333ae5 100644 (file)
--- a/PWG3/dielectron/AliDielectronCF.cxx
+++ b/PWG3/dielectron/AliDielectronCF.cxx
@@ -47,7 +47,10 @@ AliDielectronCF::AliDielectronCF() :
   fNSteps(0),
   fNVars(0),
   fNCuts(0),
-  fStepsForEachCut(kTRUE),
+  fStepForMCtruth(kFALSE),
+  fStepForNoCutsMCmotherPid(kFALSE),
+  fStepForAfterAllCuts(kTRUE),
+  fStepsForEachCut(kFALSE),
   fStepsForCutsIncreasing(kFALSE),
   fNStepMasks(0),
   fPdgMother(-1),
@@ -61,9 +64,10 @@ AliDielectronCF::AliDielectronCF() :
   }
 
   for (Int_t i=0; i<kNmaxAddSteps; ++i){
-    fNBins[kNmaxAddSteps]=0;
-    fVarLoLimit[kNmaxAddSteps]=0.;
-    fVarUpLimit[kNmaxAddSteps]=0.;
+    fNBins[i]=0;
+    fVarLoLimit[i]=0.;
+    fVarUpLimit[i]=0.;
+    fStepMasks[i]=0xFFFFFF;
   }
 }
 
@@ -73,7 +77,10 @@ AliDielectronCF::AliDielectronCF(const char* name, const char* title) :
   fNSteps(0),
   fNVars(0),
   fNCuts(0),
-  fStepsForEachCut(kTRUE),
+  fStepForMCtruth(kFALSE),
+  fStepForNoCutsMCmotherPid(kFALSE),
+  fStepForAfterAllCuts(kTRUE),
+  fStepsForEachCut(kFALSE),
   fStepsForCutsIncreasing(kFALSE),
   fNStepMasks(0),
   fPdgMother(-1),
@@ -87,9 +94,10 @@ AliDielectronCF::AliDielectronCF(const char* name, const char* title) :
   }
   
   for (Int_t i=0; i<kNmaxAddSteps; ++i){
-    fNBins[kNmaxAddSteps]=0;
-    fVarLoLimit[kNmaxAddSteps]=0.;
-    fVarUpLimit[kNmaxAddSteps]=0.;
+    fNBins[i]=0;
+    fVarLoLimit[i]=0.;
+    fVarUpLimit[i]=0.;
+    fStepMasks[i]=0xFFFFFF;
   }
 }
 
@@ -123,13 +131,13 @@ void AliDielectronCF::InitialiseContainer(const AliAnalysisFilter& filter)
   //
 
   fNCuts=filter.GetCuts()->GetEntries();
+
+  fNSteps=0;
+  if (fStepForMCtruth) ++fNSteps;
+  if (fStepForNoCutsMCmotherPid) ++fNSteps;
+  if (fStepForAfterAllCuts) fNSteps+=2;
   
-  fNSteps=4; //defaults: 0: MC truth
-             //          1: no Cuts + MC
-             //          2: after all cuts
-             //          3: after all cuts + MC truth
-  
-  if (fStepsForEachCut)        fNSteps+=(2*fNCuts);     //one step for each cut + MC truth
+  if (fStepsForEachCut&&fNCuts>1)        fNSteps+=(2*fNCuts);     //one step for each cut + MC truth
   if (fStepsForCutsIncreasing&&fNCuts>2) fNSteps+=(2*(fNCuts-2)); //one step for the increasing cuts + MC truth
                                                       // e.g. cut2&cut3, cut2&cut3&cut4
   fNSteps+=(2*fNStepMasks);                            // cuts for the additional cut masks
@@ -158,24 +166,30 @@ void AliDielectronCF::InitialiseContainer(const AliAnalysisFilter& filter)
   Int_t step=0;
 
   //Pure MC truth
-  fCfContainer->SetStepTitle(step++,"MC truth");
+  if (fStepForMCtruth){
+      fCfContainer->SetStepTitle(step++,"MC truth");
+  }
 
   //before cuts (MC truth)
-  fCfContainer->SetStepTitle(step++,"No cuts (MC truth)");
+  if (fStepForNoCutsMCmotherPid){
+    fCfContainer->SetStepTitle(step++,"No cuts (MC mother)");
+  }
   
   //After All cuts
-  TString cutName="All Cuts"; //TODO: User GetTitle???
-  fCfContainer->SetStepTitle(step++, cutName.Data()); //Step for the cut
-  cutName+=" (MC truth)";
-  fCfContainer->SetStepTitle(step++, cutName.Data()); //Step for the cut with MC truth
-  
+  TString cutName;
+  if (fStepForAfterAllCuts){
+    cutName="All Cuts"; //TODO: User GetTitle???
+    fCfContainer->SetStepTitle(step++, cutName.Data()); //Step for the cut
+    cutName+=" (MC truth)";
+    fCfContainer->SetStepTitle(step++, cutName.Data()); //Step for the cut with MC truth
+  }
 
   //Steps for each of the cuts
-  if (fStepsForEachCut){
+  if (fStepsForEachCut&&fNCuts>1){
     for (Int_t iCut=0; iCut<fNCuts;++iCut) {
       cutName=filter.GetCuts()->At(iCut)->GetName(); //TODO: User GetTitle???
       fCfContainer->SetStepTitle(step++, cutName.Data()); //Step for the cut
-      cutName+=" (MC truth)";
+      cutName+=" (MC mother)";
       fCfContainer->SetStepTitle(step++, cutName.Data()); //Step for the cut with MC truth
     }
   }
@@ -187,7 +201,7 @@ void AliDielectronCF::InitialiseContainer(const AliAnalysisFilter& filter)
       cutName+="&";
       cutName+=filter.GetCuts()->At(iCut)->GetName();
       fCfContainer->SetStepTitle(step++, cutName.Data()); //Step for the cut
-      cutName+=" (MC truth)";
+      cutName+=" (MC mother)";
       fCfContainer->SetStepTitle(step++, cutName.Data()); //Step for the cut with MC truth
     }
   }
@@ -207,7 +221,7 @@ void AliDielectronCF::InitialiseContainer(const AliAnalysisFilter& filter)
       }
     }
     fCfContainer->SetStepTitle(step++, cutName.Data()); //Step for the cut
-    cutName+=" (MC truth)";
+    cutName+=" (MC mother)";
     fCfContainer->SetStepTitle(step++, cutName.Data()); //Step for the cut with MC truth
   }
 
@@ -241,24 +255,29 @@ void AliDielectronCF::Fill(UInt_t mask, const TObject *particle)
   // Fill steps //
   //============//
   // step 0 would be full MC truth and is handled in FillMC
-  Int_t step=1;
+  Int_t step=0;
+  if (fStepForMCtruth) ++step;
 
   //No cuts (MC truth)
-  if (isMCTruth) fCfContainer->Fill(values,step);
-  ++step;
-  
-  //All cuts, 
-  if (mask == selectedMask){
-    fCfContainer->Fill(values,step);
-    ++step;
+  if (fStepForNoCutsMCmotherPid){
     if (isMCTruth) fCfContainer->Fill(values,step);
     ++step;
-  } else {
-    step+=2;
   }
-
+  
+  //All cuts
+  if (fStepForAfterAllCuts){
+    if (mask == selectedMask){
+      fCfContainer->Fill(values,step);
+      ++step;
+      if (isMCTruth) fCfContainer->Fill(values,step);
+      ++step;
+    } else {
+      step+=2;
+    }
+  }
+  
   //Steps for each of the cuts
-  if (fStepsForEachCut){
+  if (fStepsForEachCut&&fNCuts>1){
     for (Int_t iCut=0; iCut<fNCuts;++iCut) {
       if (mask&(1<<iCut)) {
         fCfContainer->Fill(values,step);
@@ -306,6 +325,8 @@ void AliDielectronCF::FillMC(const TObject *particle)
   //
   // fill MC part of the Container
   //
+  if (!fStepForMCtruth) return;
+  
   Double_t valuesAll[AliDielectronVarManager::kNMaxValues];
   AliDielectronVarManager::Fill(particle,valuesAll);
   

diff --git a/PWG3/dielectron/AliDielectronCF.h b/PWG3/dielectron/AliDielectronCF.h
index 0e252ad49714ab2ff27099a604d58700a722e240..272791c982b755e4745ae931ad328736857127f2 100644 (file)
--- a/PWG3/dielectron/AliDielectronCF.h
+++ b/PWG3/dielectron/AliDielectronCF.h
@@ -36,8 +36,11 @@ public:
   AliDielectronCF(const char* name, const char* title);
   virtual ~AliDielectronCF();
 
-  void SetStepsForEachCut(Bool_t steps=kTRUE)          { fStepsForEachCut=steps;        }
-  void SetStepsForCutsIncreasing(Bool_t steps=kTRUE)   { fStepsForCutsIncreasing=steps; }
+  void SetStepForMCtruth(Bool_t steps=kTRUE)           { fStepForMCtruth=steps;           }
+  void SetStepForNoCutsMCmotherPid(Bool_t steps=kTRUE) { fStepForNoCutsMCmotherPid=steps; }
+  void SetStepForAfterAllCuts(Bool_t steps=kTRUE)      { fStepForAfterAllCuts=steps;      }
+  void SetStepsForEachCut(Bool_t steps=kTRUE)          { fStepsForEachCut=steps;          }
+  void SetStepsForCutsIncreasing(Bool_t steps=kTRUE)   { fStepsForCutsIncreasing=steps;   }
   
   void SetPdgMother(Int_t pdg) { fPdgMother=pdg; }
   
@@ -52,7 +55,7 @@ public:
   
   AliCFContainer* GetContainer() const { return fCfContainer; }
   
-private:
+// private:
   UInt_t          fVariables[AliDielectronVarManager::kNMaxValues]; //configured variables
   
   Int_t           fNSteps;                     // number of selection steps
@@ -63,9 +66,12 @@ private:
 
   Int_t           fNCuts;                      // Number of cuts in the filter concerned
 
-  Bool_t fStepsForEachCut;               //create steps for each cut?
-  Bool_t fStepsForCutsIncreasing;        //create steps for increasing cut combinatons?
-                                         //e.g. cut1&cut2, cut1&cut2&cut3 ...
+  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
+  Bool_t fStepsForEachCut;              //create steps for each cut?
+  Bool_t fStepsForCutsIncreasing;       //create steps for increasing cut combinatons?
+                                        //e.g. cut1&cut2, cut1&cut2&cut3 ...
 
   UInt_t fStepMasks[kNmaxAddSteps];      //steps for additional cut combinatons
   UInt_t fNStepMasks;                    //number of configured step masks
@@ -76,7 +82,7 @@ private:
   AliDielectronCF(const AliDielectronCF &c);
   AliDielectronCF &operator=(const AliDielectronCF &c);
   
-  ClassDef(AliDielectronCF,1)  //Dielectron Correction Framework handler
+  ClassDef(AliDielectronCF,2)  //Dielectron Correction Framework handler
 };
 
 #endif

diff --git a/PWG3/dielectron/AliDielectronVarCuts.cxx b/PWG3/dielectron/AliDielectronVarCuts.cxx
index 68b6cff7c4fb1bb8d5e276c05ec27372dab8d960..4316184169821133076066950e3c925701fda78f 100644 (file)
--- a/PWG3/dielectron/AliDielectronVarCuts.cxx
+++ b/PWG3/dielectron/AliDielectronVarCuts.cxx
@@ -29,7 +29,7 @@
 
 
 #include "AliDielectronVarCuts.h"
-
+#include "AliDielectronMC.h"
 
 ClassImp(AliDielectronVarCuts)
 
@@ -38,7 +38,9 @@ AliDielectronVarCuts::AliDielectronVarCuts() :
   AliAnalysisCuts(),
   fNActiveCuts(0),
   fActiveCutsMask(0),
-  fSelectedCutsMask(0)
+  fSelectedCutsMask(0),
+  fCutOnMCtruth(kFALSE),
+  fCutType(kAll)
 {
   //
   // Default costructor
@@ -55,7 +57,9 @@ AliDielectronVarCuts::AliDielectronVarCuts(const char* name, const char* title)
   AliAnalysisCuts(name,title),
   fNActiveCuts(0),
   fActiveCutsMask(0),
-  fSelectedCutsMask(0)
+  fSelectedCutsMask(0),
+  fCutOnMCtruth(kFALSE),
+  fCutType(kAll)
 {
   //
   // Named contructor
@@ -82,23 +86,37 @@ Bool_t AliDielectronVarCuts::IsSelected(TObject* track)
   // Make cut decision
   //
 
-  Double_t values[AliDielectronVarManager::kNMaxValues];
-  AliDielectronVarManager::Fill(track,values);
+  //reset
   fSelectedCutsMask=0;
   SetSelected(kFALSE);
+
+  if (!track) return kFALSE;
+  
+  //If MC cut, get MC truth
+  if (fCutOnMCtruth){
+    AliVParticle *part=static_cast<AliVParticle*>(track);
+    track=AliDielectronMC::Instance()->GetMCTrackFromMCEvent(part->GetLabel());
+    if (!track) return kFALSE;
+  }
+
+  //Fill values
+  Double_t values[AliDielectronVarManager::kNMaxValues];
+  AliDielectronVarManager::Fill(track,values);
   
   for (Int_t iCut=0; iCut<fNActiveCuts; ++iCut){
     Int_t cut=fActiveCuts[iCut];
     SETBIT(fSelectedCutsMask,iCut);
-    if ( (values[cut]<fCutMin[cut]) || (values[cut]>fCutMax[cut]) ) CLRBIT(fSelectedCutsMask,iCut);
+    if ( (values[cut]<fCutMin[iCut]) || (values[cut]>fCutMax[iCut]) ) CLRBIT(fSelectedCutsMask,iCut);
   }
+  
   Bool_t isSelected=(fSelectedCutsMask==fActiveCutsMask);
+  if ( fCutType==kAny ) isSelected=(fSelectedCutsMask>0);
   SetSelected(isSelected);
   return isSelected;
 }
 
 //________________________________________________________________________
-void AliDielectronVarCuts::AddCut(Double_t min, Double_t max, AliDielectronVarManager::ValueTypes type)
+void AliDielectronVarCuts::AddCut(AliDielectronVarManager::ValueTypes type, Double_t min, Double_t max)
 {
   //
   // Set cut range and activate it
@@ -108,34 +126,11 @@ void AliDielectronVarCuts::AddCut(Double_t min, Double_t max, AliDielectronVarMa
     min=max;
     max=tmp;
   }
-  fCutMin[type]=min;
-  fCutMax[type]=max;
-  ActivateCut(type);
-}
-
-//________________________________________________________________________
-void AliDielectronVarCuts::ActivateCut(AliDielectronVarManager::ValueTypes cutName)
-{
-  //
-  // Add the cut to the list of active cuts
-  //
-
-  if (IsCutActive(cutName)) return;
+  fCutMin[fNActiveCuts]=min;
+  fCutMax[fNActiveCuts]=max;
   SETBIT(fActiveCutsMask,fNActiveCuts);
-  fActiveCuts[fNActiveCuts++]=(UChar_t)cutName;
-}
-
-//________________________________________________________________________
-Bool_t AliDielectronVarCuts::IsCutActive(AliDielectronVarManager::ValueTypes cut)
-{
-  //
-  // Check if this cut is already activated
-  //
-  for (Int_t iCut=0; iCut<fNActiveCuts; ++iCut){
-    if (fActiveCuts[iCut]==(UChar_t)cut) return kTRUE;
-  }
-  
-  return kFALSE;
+  fActiveCuts[fNActiveCuts]=(UShort_t)type;
+  ++fNActiveCuts;
 }
 
 //________________________________________________________________________
@@ -145,9 +140,14 @@ void AliDielectronVarCuts::Print(const Option_t* /*option*/) const
   // Print cuts and the range
   //
   printf("cut ranges for '%s'\n",GetTitle());
+  if (fCutType==kAll){
+    printf("All Cuts have to be fulfilled\n");
+  } else {
+    printf("Any Cut has to be fulfilled\n");
+  }
   for (Int_t iCut=0; iCut<fNActiveCuts; ++iCut){
-    UChar_t cut=fActiveCuts[iCut];
+    Int_t cut=(Int_t)fActiveCuts[iCut];
     printf("Cut %02d: %f < %s < %f\n", iCut,
-           fCutMin[cut], AliDielectronVarManager::GetValueName((Int_t)cut), fCutMax[cut]);
+           fCutMin[iCut], AliDielectronVarManager::GetValueName((Int_t)cut), fCutMax[iCut]);
   }
 }

diff --git a/PWG3/dielectron/AliDielectronVarCuts.h b/PWG3/dielectron/AliDielectronVarCuts.h
index 642dc496bd9d0c5ec2037bb50c087c4bd084d8c9..199083ad47c4d52392ad1542ab60c57765101044 100644 (file)
--- a/PWG3/dielectron/AliDielectronVarCuts.h
+++ b/PWG3/dielectron/AliDielectronVarCuts.h
@@ -27,12 +27,24 @@
 
 class AliDielectronVarCuts : public AliAnalysisCuts {
 public:
+  // Whether all cut criteria have to be fulfilled of just any
+  enum CutType { kAll=0, kAny };
+  
   AliDielectronVarCuts();
   AliDielectronVarCuts(const char* name, const char* title);
   virtual ~AliDielectronVarCuts();
   //TODO: make copy constructor and assignment operator public
-  void AddCut(Double_t min, Double_t max, AliDielectronVarManager::ValueTypes type);
+  void AddCut(AliDielectronVarManager::ValueTypes type, Double_t min, Double_t max);
+
+  // setters
+  void    SetCutOnMCtruth(Bool_t mc=kTRUE) { fCutOnMCtruth=mc; }
+  void    SetCutType(CutType type)         { fCutType=type;    }
+  
+  // getters
+  Bool_t  GetCutOnMCtruth() const { return fCutOnMCtruth; }
+  CutType GetCutType()      const { return fCutType;      }
 
+  
   //
   //Analysis cuts interface
   //
@@ -46,27 +58,28 @@ public:
   // Cut information
   //
   virtual UInt_t GetSelectedCutsMask() const { return fSelectedCutsMask; }
-  Bool_t IsCutActive(AliDielectronVarManager::ValueTypes cut);
 
   virtual void Print(const Option_t* option = "") const;
   
 private:
 
-  UChar_t  fActiveCuts[AliDielectronVarManager::kNMaxValues];       // list of activated cuts
-  UChar_t  fNActiveCuts;                      // number of acive cuts
-  UInt_t   fActiveCutsMask;                   // maks of active cuts
+  UShort_t  fActiveCuts[AliDielectronVarManager::kNMaxValues];       // list of activated cuts
+  UShort_t  fNActiveCuts;                      // number of acive cuts
+  UInt_t    fActiveCutsMask;                   // mask of active cuts
   
   UInt_t   fSelectedCutsMask;                 // Maks of selected cuts, is available after calling IsSelected
+
+  Bool_t   fCutOnMCtruth;                     // whether to cut on the MC truth of the particle
+
+  CutType  fCutType;                          // type of the cut: any, all
   
   Double_t fCutMin[AliDielectronVarManager::kNMaxValues];           // minimum values for the cuts
   Double_t fCutMax[AliDielectronVarManager::kNMaxValues];           // maximum values for the cuts
-
-  void ActivateCut(AliDielectronVarManager::ValueTypes cutName);
   
   AliDielectronVarCuts(const AliDielectronVarCuts &c);
   AliDielectronVarCuts &operator=(const AliDielectronVarCuts &c);
   
-  ClassDef(AliDielectronVarCuts,1)         //Cut class providing cuts to all infomation available for the AliVParticle interface
+  ClassDef(AliDielectronVarCuts,2)         //Cut class providing cuts to all infomation available for the AliVParticle interface
 };