PWGDQ/dielectron/TakuAlberica/single/AliDielectronTaku.h

   1 #ifndef ALIDIELECTRON_H
   2 #define ALIDIELECTRON_H
   3 /* Copyright(c) 1998-2009, ALICE Experiment at CERN, All rights reserved. *
   4  * See cxx source for full Copyright notice                               */
   5
   6 //#####################################################
   7 //#                                                   #
   8 //#             Class AliDielectronTaku                   #
   9 //#         Main Class for e+e- analysis              #
  10 //#                                                   #
  11 //#  by WooJin J. Park, GSI / W.J.Park@gsi.de         #
  12 //#     Ionut C. Arsene, GSI / I.C.Arsene@gsi.de      #
  13 //#     Magnus Mager, CERN / Magnus.Mager@cern.ch     #
  14 //#     Jens Wiechula, Uni HD / Jens.Wiechula@cern.ch #
  15 //#                                                   #
  16 //#####################################################
  17
  18
  19 #include <TNamed.h>
  20 #include <TObjArray.h>
  21
  22 #include <AliAnalysisFilter.h>
  23 #include <AliKFParticle.h>
  24
  25 #include "AliDielectronHistosTaku.h"
  26
  27 class AliVEvent;
  28 class AliMCEvent;
  29 class THashList;
  30 class AliDielectronCF;
  31 class AliDielectronDebugTreeTaku;
  32 class AliDielectronTrackRotator;
  33 class AliDielectronPair;
  34 class AliDielectronSignalMC;
  35
  36 //________________________________________________________________
  37 class AliDielectronTaku : public TNamed {
  38
  39 public:
  40   enum EPairType { kEv1PP=0, kEv1PM, kEv1MM,
  41       kEv1PEv2P, kEv1MEv2P, kEv2PP,
  42       kEv1PEv2M, kEv1MEv2M, kEv2PM,
  43       kEv2MM, kEv1PMRot };
  44   enum ELegType  { kEv1P, kEv1M, kEv2P, kEv2M };
  45
  46   AliDielectronTaku();
  47   AliDielectronTaku(const char* name, const char* title);
  48   virtual ~AliDielectronTaku();
  49
  50   void Init();
  51
  52   void Process(AliVEvent *ev1, AliVEvent *ev2=0);
  53
  54   const AliAnalysisFilter& GetEventFilter() const { return fEventFilter; }
  55   const AliAnalysisFilter& GetTrackFilter() const { return fTrackFilter; }
  56   const AliAnalysisFilter& GetPairFilter()  const { return fPairFilter;  }
  57
  58   AliAnalysisFilter& GetEventFilter()       { return fEventFilter;       }
  59   AliAnalysisFilter& GetTrackFilter()       { return fTrackFilter;       }
  60   AliAnalysisFilter& GetPairFilter()        { return fPairFilter;        }
  61   AliAnalysisFilter& GetPairPreFilter()     { return fPairPreFilter;     }
  62   AliAnalysisFilter& GetPairPreFilterLegs() { return fPairPreFilterLegs; }
  63
  64   void  SetMotherPdg( Int_t pdgMother ) { fPdgMother=pdgMother; }
  65   void  SetLegPdg(Int_t pdgLeg1, Int_t pdgLeg2) { fPdgLeg1=pdgLeg1; fPdgLeg2=pdgLeg2; }
  66   Int_t GetMotherPdg() const { return fPdgMother; }
  67   Int_t GetLeg1Pdg()   const { return fPdgLeg1;   }
  68   Int_t GetLeg2Pdg()   const { return fPdgLeg2;   }
  69
  70   void SetNoPairing(Bool_t noPairing=kTRUE) { fNoPairing=noPairing; }
  71   const TObjArray* GetTrackArray(Int_t i) const {return (i>=0&&i<4)?&fTracks[i]:0;}
  72   const TObjArray* GetPairArray(Int_t i)  const {return (i>=0&&i<10)?
  73       static_cast<TObjArray*>(fPairCandidates->UncheckedAt(i)):0;}
  74
  75   TObjArray** GetPairArraysPointer() { return &fPairCandidates; }
  76
  77   void SetHistogramManager(AliDielectronHistosTaku * const histos) { fHistos=histos; }
  78   void SetTreeManager(AliDielectronHistosTaku * const histos) { fTree=histos; }
  79   AliDielectronHistosTaku* GetHistoManager() const { return fHistos; }
  80   const THashList * GetHistogramList() const { return fHistos?fHistos->GetHistogramList():0x0; }
  81   AliDielectronHistosTaku* GetTreeManager() const { return fTree; }
  82   const THashList * GetTreeList() const { return fTree?fTree->GetTreeList():0x0; }
  83   TTree *GetSingleTree(AliDielectronHistosTaku *fTreeHisto) const {return fTreeHisto->GetSingleTree();}
  84
  85   Bool_t HasCandidates() const { return GetPairArray(1)?GetPairArray(1)->GetEntriesFast()>0:0; }
  86   Bool_t HasCandidatesLikeSign() const {
  87     return (GetPairArray(0)&&GetPairArray(2)) ? (GetPairArray(0)->GetEntriesFast()>0 || GetPairArray(2)->GetEntriesFast()>0) : 0;
  88   }
  89
  90   void SetCFManagerPair(AliDielectronCF * const cf) { fCfManagerPair=cf; }
  91   AliDielectronCF* GetCFManagerPair() const { return fCfManagerPair; }
  92
  93   void SetPreFilterUnlikeOnly(Bool_t setValue=kTRUE){fPreFilterUnlikeOnly=setValue;};
  94   void SetPreFilterAllSigns(Bool_t setValue=kTRUE){fPreFilterAllSigns=setValue;};
  95
  96   void SetTrackRotator(AliDielectronTrackRotator * const rot) { fTrackRotator=rot; }
  97   AliDielectronTrackRotator* GetTrackRotator() const { return fTrackRotator; }
  98
  99   void SetHasMC(Bool_t hasMC) { fHasMC = hasMC; }
 100   Bool_t GetHasMC() const     { return fHasMC;  }
 101
 102   void AddSignalMC(AliDielectronSignalMC* signal);
 103
 104   void SetDebugTree(AliDielectronDebugTreeTaku * const tree) { fDebugTree=tree; }
 105
 106   const TObjArray* GetMCSignals() const { return fSignalsMC; }
 107   static const char* TrackClassName(Int_t i) { return (i>=0&&i<4)?fgkTrackClassNames[i]:""; }
 108   static const char* PairClassName(Int_t i)  { return (i>=0&&i<11)?fgkPairClassNames[i]:""; }
 109
 110   void SaveDebugTree();
 111
 112
 113   Double_t GetVarManagerVariable(Int_t n) const {return fgData[n];}
 114
 115 private:
 116
 117   AliAnalysisFilter fEventFilter;    // Event cuts
 118   AliAnalysisFilter fTrackFilter;    // leg cuts
 119   AliAnalysisFilter fPairPreFilter;  // pair prefilter cuts
 120   AliAnalysisFilter fPairPreFilterLegs; // Leg filter after the pair prefilter cuts
 121   AliAnalysisFilter fPairFilter;     // pair cuts
 122
 123   Int_t fPdgMother;     // pdg code of mother tracks
 124   Int_t fPdgLeg1;       // pdg code leg1
 125   Int_t fPdgLeg2;       // pdg code leg2
 126
 127   TObjArray* fSignalsMC;      // array of AliDielectronSignalMC
 128
 129   Bool_t fNoPairing;    // if to skip pairing, can be used for track QA only
 130
 131   AliDielectronHistosTaku *fHistos;   // Histogram manager
 132                                   //  Streaming and merging should be handled
 133                                   //  by the analysis framework
 134
 135   AliDielectronHistosTaku *fTree;   // This is for tree
 136                                   //  Streaming and merging should be handled
 137                                   //  by the analysis framework
 138
 139
 140   TObjArray fTracks[4];           //! Selected track candidates
 141                                   //  0: Event1, positive particles
 142                                   //  1: Event1, negative particles
 143                                   //  2: Event2, positive particles
 144                                   //  3: Event2, negative particles
 145
 146   TObjArray *fPairCandidates;     //! Pair candidate arrays
 147                                   //TODO: better way to store it? TClonesArray?
 148
 149   AliDielectronCF *fCfManagerPair;//Correction Framework Manager for the Pair
 150   AliDielectronTrackRotator *fTrackRotator; //Track rotator
 151   AliDielectronDebugTreeTaku *fDebugTree;  // Debug tree output
 152
 153   Bool_t fPreFilterUnlikeOnly;  //Apply PreFilter either in +- or to ++/--/+- individually
 154   Bool_t fPreFilterAllSigns;  //Apply PreFilter find in  ++/--/+- and remove from all
 155   Bool_t fHasMC;                //If we run with MC, at the moment only needed in AOD
 156
 157   void FillTrackArrays(AliVEvent * const ev, Int_t eventNr=0);
 158   void PairPreFilter(Int_t arr1, Int_t arr2, TObjArray &arrTracks1, TObjArray &arrTracks2);
 159   void FillPairArrays(Int_t arr1, Int_t arr2);
 160   void FillPairArrayTR();
 161
 162   Int_t GetPairIndex(Int_t arr1, Int_t arr2) const {return arr1>=arr2?arr1*(arr1+1)/2+arr2:arr2*(arr2+1)/2+arr1;}
 163
 164   void InitPairCandidateArrays();
 165   void ClearArrays();
 166
 167   TObjArray* PairArray(Int_t i);
 168
 169   static const char* fgkTrackClassNames[4];   //Names for track arrays
 170   static const char* fgkPairClassNames[11];   //Names for pair arrays
 171
 172   void ProcessMC();
 173
 174   void  FillHistograms(const AliVEvent *ev);
 175   void  FillTree(const AliVEvent *ev);
 176   void  FillHistogramsMC(const AliMCEvent *ev);
 177   void  FillHistogramsPair(AliDielectronPair *pair,Bool_t fromPreFilter=kFALSE);
 178   void  FillHistogramsTracks(TObjArray **tracks);
 179
 180   void  FillDebugTree();
 181
 182   AliDielectronTaku(const AliDielectronTaku &c);
 183   AliDielectronTaku &operator=(const AliDielectronTaku &c);
 184
 185   Double_t fgData[AliDielectronVarManager::kNMaxValues];
 186
 187
 188   ClassDef(AliDielectronTaku,4);
 189 };
 190
 191 inline void AliDielectronTaku::InitPairCandidateArrays()
 192 {
 193   //
 194   // initialise all pair candidate arrays
 195   //
 196   fPairCandidates->SetOwner();
 197   for (Int_t i=0;i<10;++i){
 198     TObjArray *arr=new TObjArray;
 199     fPairCandidates->AddAt(arr,i);
 200     arr->SetOwner();
 201   }
 202 }
 203
 204 inline TObjArray* AliDielectronTaku::PairArray(Int_t i)
 205 {
 206   //
 207   // for internal use only: unchecked return of track array for fast access
 208   //
 209   return static_cast<TObjArray*>(fPairCandidates->UncheckedAt(i));
 210 }
 211
 212 inline void AliDielectronTaku::ClearArrays()
 213 {
 214   //
 215   // Reset the Arrays
 216   //
 217   for (Int_t i=0;i<4;++i){
 218     fTracks[i].Clear();
 219   }
 220   for (Int_t i=0;i<10;++i){
 221     PairArray(i)->Delete();
 222   }
 223
 224
 225
 226
 227 }
 228
 229 #endif