PWGDQ/dielectron/AliDielectron.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 AliDielectron                   #
   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 #include <THnBase.h>
  22 #include <TSpline.h>
  23
  24 #include <AliAnalysisFilter.h>
  25 #include <AliKFParticle.h>
  26
  27 #include "AliDielectronHistos.h"
  28 #include "AliDielectronHF.h"
  29 #include "AliDielectronCutQA.h"
  30
  31 class AliEventplane;
  32 class AliVEvent;
  33 class AliMCEvent;
  34 class THashList;
  35 class AliDielectronCF;
  36 class AliDielectronDebugTree;
  37 class AliDielectronTrackRotator;
  38 class AliDielectronPair;
  39 class AliDielectronSignalMC;
  40 class AliDielectronMixingHandler;
  41
  42 //________________________________________________________________
  43 class AliDielectron : public TNamed {
  44
  45   friend class AliDielectronMixingHandler; //mixing as friend class
  46
  47 public:
  48   enum EPairType { kEv1PP=0, kEv1PM, kEv1MM,
  49       kEv1PEv2P, kEv1MEv2P, kEv2PP,
  50       kEv1PEv2M, kEv1MEv2M, kEv2PM,
  51       kEv2MM, kEv1PMRot };
  52   enum ELegType  { kEv1P, kEv1M, kEv2P, kEv2M };
  53
  54   AliDielectron();
  55   AliDielectron(const char* name, const char* title);
  56   virtual ~AliDielectron();
  57
  58   void Init();
  59
  60   void Process(/*AliVEvent *ev1, */TObjArray *arr);
  61   Bool_t Process(AliVEvent *ev1, AliVEvent *ev2=0);
  62
  63   const AliAnalysisFilter& GetEventFilter() const { return fEventFilter; }
  64   const AliAnalysisFilter& GetTrackFilter() const { return fTrackFilter; }
  65   const AliAnalysisFilter& GetPairFilter()  const { return fPairFilter;  }
  66
  67   AliAnalysisFilter& GetEventFilter()       { return fEventFilter;       }
  68   AliAnalysisFilter& GetTrackFilter()       { return fTrackFilter;       }
  69   AliAnalysisFilter& GetPairFilter()        { return fPairFilter;        }
  70   AliAnalysisFilter& GetPairPreFilter()     { return fPairPreFilter;     }
  71   AliAnalysisFilter& GetPairPreFilterLegs() { return fPairPreFilterLegs; }
  72   AliAnalysisFilter& GetEventPlanePreFilter(){ return fEventPlanePreFilter; }
  73   AliAnalysisFilter& GetEventPlanePOIPreFilter(){ return fEventPlanePOIPreFilter; }
  74
  75   void  SetMotherPdg( Int_t pdgMother ) { fPdgMother=pdgMother; }
  76   void  SetLegPdg(Int_t pdgLeg1, Int_t pdgLeg2) { fPdgLeg1=pdgLeg1; fPdgLeg2=pdgLeg2; }
  77   Int_t GetMotherPdg() const { return fPdgMother; }
  78   Int_t GetLeg1Pdg()   const { return fPdgLeg1;   }
  79   Int_t GetLeg2Pdg()   const { return fPdgLeg2;   }
  80
  81   void SetCutQA(Bool_t qa=kTRUE) { fCutQA=qa; }
  82   void SetNoPairing(Bool_t noPairing=kTRUE) { fNoPairing=noPairing; }
  83   void SetProcessLS(Bool_t doLS=kTRUE) { fProcessLS=doLS; }
  84   void SetUseKF(Bool_t useKF=kTRUE) { fUseKF=useKF; }
  85   const TObjArray* GetTrackArray(Int_t i) const {return (i>=0&&i<4)?&fTracks[i]:0;}
  86   const TObjArray* GetPairArray(Int_t i)  const {return (i>=0&&i<11)?
  87       static_cast<TObjArray*>(fPairCandidates->UncheckedAt(i)):0;}
  88
  89   TObjArray** GetPairArraysPointer() { return &fPairCandidates; }
  90   void SetPairArraysPointer( TObjArray *arr) { fPairCandidates=arr; }
  91   void SetHistogramArray(AliDielectronHF * const histoarray) { fHistoArray=histoarray; }
  92   const TObjArray * GetHistogramArray() const { return fHistoArray?fHistoArray->GetHistArray():0x0; }
  93   const TObjArray * GetQAHistArray() const { return fQAmonitor?fQAmonitor->GetQAHistArray():0x0; }
  94
  95   void SetHistogramManager(AliDielectronHistos * const histos) { fHistos=histos; }
  96   AliDielectronHistos* GetHistoManager() const { return fHistos; }
  97   const THashList * GetHistogramList() const { return fHistos?fHistos->GetHistogramList():0x0; }
  98
  99   Bool_t HasCandidates() const { return GetPairArray(1)?GetPairArray(1)->GetEntriesFast()>0:0; }
 100   Bool_t HasCandidatesLikeSign() const {
 101     return (GetPairArray(0)&&GetPairArray(2)) ? (GetPairArray(0)->GetEntriesFast()>0 || GetPairArray(2)->GetEntriesFast()>0) : 0;
 102   }
 103
 104   Bool_t HasCandidatesTR() const {return GetPairArray(10)?GetPairArray(10)->GetEntriesFast()>0:0;}
 105   void SetCFManagerPair(AliDielectronCF * const cf) { fCfManagerPair=cf; }
 106   AliDielectronCF* GetCFManagerPair() const { return fCfManagerPair; }
 107
 108   void SetPreFilterEventPlane(Bool_t setValue=kTRUE){fPreFilterEventPlane=setValue;};
 109   void SetLikeSignSubEvents(Bool_t setValue=kTRUE){fLikeSignSubEvents=setValue;};
 110   void SetPreFilterUnlikeOnly(Bool_t setValue=kTRUE){fPreFilterUnlikeOnly=setValue;};
 111   void SetPreFilterAllSigns(Bool_t setValue=kTRUE){fPreFilterAllSigns=setValue;};
 112
 113   void SetTrackRotator(AliDielectronTrackRotator * const rot) { fTrackRotator=rot; }
 114   AliDielectronTrackRotator* GetTrackRotator() const { return fTrackRotator; }
 115
 116   void SetMixingHandler(AliDielectronMixingHandler *mix) { fMixing=mix; }
 117   AliDielectronMixingHandler* GetMixingHandler() const { return fMixing; }
 118
 119   void SetHasMC(Bool_t hasMC) { fHasMC = hasMC; }
 120   Bool_t GetHasMC() const     { return fHasMC;  }
 121
 122   void SetStoreRotatedPairs(Bool_t storeTR) {fStoreRotatedPairs = storeTR;}
 123   void SetDontClearArrays(Bool_t dontClearArrays=kTRUE) { fDontClearArrays=dontClearArrays; }
 124   Bool_t DontClearArrays() const { return fDontClearArrays; }
 125
 126   void AddSignalMC(AliDielectronSignalMC* signal);
 127
 128   void SetDebugTree(AliDielectronDebugTree * const tree) { fDebugTree=tree; }
 129
 130   const TObjArray* GetMCSignals() const { return fSignalsMC; }
 131   static const char* TrackClassName(Int_t i) { return (i>=0&&i<4)?fgkTrackClassNames[i]:""; }
 132   static const char* PairClassName(Int_t i)  { return (i>=0&&i<11)?fgkPairClassNames[i]:""; }
 133
 134   void SetEstimatorFilename(const Char_t* filename) {fEstimatorFilename = filename;}
 135   void SetTRDcorrectionFilename(const Char_t* filename) {fTRDpidCorrectionFilename = filename;}
 136   void SetVZEROCalibrationFilename(const Char_t* filename) {fVZEROCalibrationFilename = filename;}
 137   void SetVZERORecenteringFilename(const Char_t* filename) {fVZERORecenteringFilename = filename;}
 138   void SetZDCRecenteringFilename(const Char_t* filename) {fZDCRecenteringFilename = filename;}
 139   void InitLegEffMap(TString filename)  { fLegEffMap=InitEffMap(filename)  ;}
 140   void InitPairEffMap(TString filename) { fPairEffMap=InitEffMap(filename) ;}
 141
 142   void SetCentroidCorrFunction(TF1 *fun, UInt_t varx, UInt_t vary=0, UInt_t varz=0);
 143   void SetWidthCorrFunction(TF1 *fun, UInt_t varx, UInt_t vary=0, UInt_t varz=0);
 144   void SetCentroidCorrFunction(TH1 *fun, UInt_t varx, UInt_t vary=0, UInt_t varz=0);
 145   void SetWidthCorrFunction(TH1 *fun, UInt_t varx, UInt_t vary=0, UInt_t varz=0);
 146
 147   void SaveDebugTree();
 148   Bool_t DoEventProcess() const { return fEventProcess; }
 149   void SetEventProcess(Bool_t setValue=kTRUE) { fEventProcess=setValue; }
 150   void  FillHistogramsFromPairArray(Bool_t pairInfoOnly=kFALSE);
 151
 152 private:
 153
 154   Bool_t fCutQA;                    // monitor cuts
 155   AliDielectronCutQA *fQAmonitor;   // monitoring of cuts
 156   TH1 *fPostPIDCntrdCorr;   // post pid correction object for centroids
 157   TH1 *fPostPIDWdthCorr;    // post pid correction object for widths
 158   TObject *fLegEffMap;      // single electron efficiency map
 159   TObject *fPairEffMap;      // pair efficiency map
 160   AliAnalysisFilter fEventFilter;    // Event cuts
 161   AliAnalysisFilter fTrackFilter;    // leg cuts
 162   AliAnalysisFilter fPairPreFilter;  // pair prefilter cuts
 163   AliAnalysisFilter fPairPreFilterLegs; // Leg filter after the pair prefilter cuts
 164   AliAnalysisFilter fPairFilter;     // pair cuts
 165   AliAnalysisFilter fEventPlanePreFilter;  // event plane prefilter cuts
 166   AliAnalysisFilter fEventPlanePOIPreFilter;  // PoI cuts in the event plane prefilter
 167
 168   Int_t fPdgMother;     // pdg code of mother tracks
 169   Int_t fPdgLeg1;       // pdg code leg1
 170   Int_t fPdgLeg2;       // pdg code leg2
 171
 172   TObjArray* fSignalsMC;      // array of AliDielectronSignalMC
 173
 174   Bool_t fNoPairing;    // if to skip pairing, can be used for track QA only
 175   Bool_t fProcessLS; // do the like-sign pairing (default kTRUE)
 176   Bool_t fUseKF;    // if to skip pairing, can be used for track QA only
 177
 178   AliDielectronHF *fHistoArray;   // Histogram framework
 179   AliDielectronHistos *fHistos;   // Histogram manager
 180                                   //  Streaming and merging should be handled
 181                                   //  by the analysis framework
 182   TBits *fUsedVars;               // used variables
 183
 184   TObjArray fTracks[4];           //! Selected track candidates
 185                                   //  0: Event1, positive particles
 186                                   //  1: Event1, negative particles
 187                                   //  2: Event2, positive particles
 188                                   //  3: Event2, negative particles
 189
 190   TObjArray *fPairCandidates;     //! Pair candidate arrays
 191                                   //TODO: better way to store it? TClonesArray?
 192
 193   AliDielectronCF *fCfManagerPair;//Correction Framework Manager for the Pair
 194   AliDielectronTrackRotator *fTrackRotator; //Track rotator
 195   AliDielectronDebugTree *fDebugTree;  // Debug tree output
 196   AliDielectronMixingHandler *fMixing; // handler for event mixing
 197
 198   Bool_t fPreFilterEventPlane;  //Filter for the Eventplane determination in TPC
 199   Bool_t fLikeSignSubEvents;    //Option for dividing into subevents, sub1 ++ sub2 --
 200   Bool_t fPreFilterUnlikeOnly;  //Apply PreFilter either in +- or to ++/--/+- individually
 201   Bool_t fPreFilterAllSigns;    //Apply PreFilter find in  ++/--/+- and remove from all
 202   Bool_t fHasMC;                //If we run with MC, at the moment only needed in AOD
 203   Bool_t fStoreRotatedPairs;    //It the rotated pairs should be stored in the pair array
 204   Bool_t fDontClearArrays;      //Don't clear the arrays at the end of the Process function, needed for external use of pair and tracks
 205   Bool_t fEventProcess;         //Process event (or pair array)
 206
 207   void FillTrackArrays(AliVEvent * const ev, Int_t eventNr=0);
 208   void EventPlanePreFilter(Int_t arr1, Int_t arr2, TObjArray arrTracks1, TObjArray arrTracks2, const AliVEvent *ev);
 209   void PairPreFilter(Int_t arr1, Int_t arr2, TObjArray &arrTracks1, TObjArray &arrTracks2);
 210   void FillPairArrays(Int_t arr1, Int_t arr2);
 211   void FillPairArrayTR();
 212
 213   Int_t GetPairIndex(Int_t arr1, Int_t arr2) const {return arr1>=arr2?arr1*(arr1+1)/2+arr2:arr2*(arr2+1)/2+arr1;}
 214
 215   void InitPairCandidateArrays();
 216   void ClearArrays();
 217
 218   TObjArray* PairArray(Int_t i);
 219   TObject* InitEffMap(TString filename);
 220
 221   static const char* fgkTrackClassNames[4];   //Names for track arrays
 222   static const char* fgkPairClassNames[11];   //Names for pair arrays
 223
 224   TString fEstimatorFilename;                // name for the pp multiplicity estimators filename
 225   TString fTRDpidCorrectionFilename;         // name for the file containing the single particle TRD pid corrections
 226   TString fVZEROCalibrationFilename;         // file containing VZERO channel-by-channel calibration
 227   TString fVZERORecenteringFilename;         // file containing VZERO Q-vector recentering averages
 228   TString fZDCRecenteringFilename;         // file containing ZDCQ-vector recentering averages
 229
 230   void ProcessMC(AliVEvent *ev1);
 231
 232   void  FillHistograms(const AliVEvent *ev, Bool_t pairInfoOnly=kFALSE);
 233   void  FillMCHistograms(const AliVEvent *ev);
 234   void  FillMCHistograms(Int_t label1, Int_t label2, Int_t nSignal);
 235   void  FillHistogramsMC(const AliMCEvent *ev,  AliVEvent *ev1);
 236   void  FillHistogramsPair(AliDielectronPair *pair,Bool_t fromPreFilter=kFALSE);
 237   void  FillHistogramsTracks(TObjArray **tracks);
 238
 239   void  FillDebugTree();
 240
 241   AliDielectron(const AliDielectron &c);
 242   AliDielectron &operator=(const AliDielectron &c);
 243
 244   ClassDef(AliDielectron,12);
 245 };
 246
 247 inline void AliDielectron::InitPairCandidateArrays()
 248 {
 249   //
 250   // initialise all pair candidate arrays
 251   //
 252   fPairCandidates->SetOwner();
 253   for (Int_t i=0;i<11;++i){
 254     TObjArray *arr=new TObjArray;
 255     fPairCandidates->AddAt(arr,i);
 256     arr->SetOwner();
 257   }
 258 }
 259
 260 inline TObjArray* AliDielectron::PairArray(Int_t i)
 261 {
 262   //
 263   // for internal use only: unchecked return of track array for fast access
 264   //
 265   return static_cast<TObjArray*>(fPairCandidates->UncheckedAt(i));
 266 }
 267
 268 inline void AliDielectron::ClearArrays()
 269 {
 270   //
 271   // Reset the Arrays
 272   //
 273   for (Int_t i=0;i<4;++i){
 274     fTracks[i].Clear();
 275   }
 276   for (Int_t i=0;i<11;++i){
 277     if (PairArray(i)) PairArray(i)->Delete();
 278   }
 279 }
 280
 281 #endif