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