Compatibility with ROOT trunk
[u/mrichter/AliRoot.git] / ANALYSIS / AliEventPoolManager.h
1 #ifndef AliEventPoolManager_h
2 #define AliEventPoolManager_h
3
4 #include <vector>
5 #include <deque>
6 #include <Rtypes.h>
7 #include <Riostream.h>
8 #include <TObjArray.h>
9 #include <TFile.h>
10 #include <TMath.h>
11 #include <TRandom.h>
12 #include <TSystem.h>
13
14 // Generic event mixing classes
15 //
16 // Stores a buffer of tracks that updates continuously. The track type
17 // contained by the pools can be anything inheriting from
18 // TObject. Pools are updated based on maintaining a minimum fixed
19 // number of tracks. Multiplicity/centrality and z-vertex bins must be
20 // passed in at initialization. For example of implementation, see
21 // $ALICE_ROOT/PWGCF/Correlations/DPhi/AliAnalysisTaskPhiCorrelations.cxx
22 //
23 // Authors: A. Adare and C. Loizides
24
25 using std::deque;
26
27 class AliEventPool : public TObject
28 {
29  public:
30  AliEventPool(Int_t d) 
31    : fEvents(0),
32     fNTracksInEvent(0),
33     fEventIndex(0),
34     fMixDepth(d), 
35     fMultMin(-999), 
36     fMultMax(+999), 
37     fZvtxMin(-999), 
38     fZvtxMax(+999), 
39     fWasUpdated(0), 
40     fMultBinIndex(0), 
41     fZvtxBinIndex(0), 
42     fDebug(0), 
43     fTargetTrackDepth(0),
44     fFirstFilled(0),
45     fNTimes(0) {;}
46   
47  AliEventPool(Int_t d, Double_t multMin, Double_t multMax, 
48                   Double_t zvtxMin, Double_t zvtxMax) 
49    : fEvents(0),
50     fNTracksInEvent(0),
51     fEventIndex(0),
52     fMixDepth(d), 
53     fMultMin(multMin), 
54     fMultMax(multMax), 
55     fZvtxMin(zvtxMin),
56     fZvtxMax(zvtxMax),
57     fWasUpdated(0),
58     fMultBinIndex(0), 
59     fZvtxBinIndex(0),
60     fDebug(0),
61     fTargetTrackDepth(0),
62     fFirstFilled(0),
63     fNTimes(0) {;}
64   ~AliEventPool() {;}
65   
66   Bool_t      EventMatchesBin(Int_t mult,    Double_t zvtx) const;
67   Bool_t      EventMatchesBin(Double_t mult, Double_t zvtx) const;
68   Bool_t      IsReady()                    const { return NTracksInPool() >= fTargetTrackDepth; }
69   Bool_t      IsFirstReady()               const { return fFirstFilled;   }
70   Int_t       GetNTimes()                  const { return fNTimes;        }
71   Int_t       GetCurrentNEvents()          const { return fEvents.size(); }
72   Int_t       GlobalEventIndex(Int_t j)    const;
73   TObject    *GetRandomTrack()             const;
74   TObjArray  *GetRandomEvent()             const;
75   TObjArray  *GetEvent(Int_t i)            const;
76   Int_t       MultBinIndex()               const { return fMultBinIndex; }
77   Int_t       NTracksInEvent(Int_t iEvent) const;
78   Int_t       NTracksInCurrentEvent()      const { return fNTracksInEvent.back(); }
79   void        PrintInfo()                  const;
80   Int_t       NTracksInPool()              const;
81   Bool_t      WasUpdated()                 const { return fWasUpdated; }
82   Int_t       ZvtxBinIndex()               const { return fZvtxBinIndex; }
83   void        SetDebug(Bool_t b)                 { fDebug = b; }
84   void        SetTargetTrackDepth(Int_t d)       { fTargetTrackDepth = d; }
85   Int_t       SetEventMultRange(Int_t    multMin, Int_t multMax);
86   Int_t       SetEventMultRange(Double_t multMin, Double_t multMax);
87   Int_t       SetEventZvtxRange(Double_t zvtxMin, Double_t zvtxMax);
88   void        SetMultBinIndex(Int_t iM) { fMultBinIndex = iM; }
89   void        SetZvtxBinIndex(Int_t iZ) { fZvtxBinIndex = iZ; }
90   Int_t       UpdatePool(TObjArray *trk);
91   
92 protected:
93   deque<TObjArray*>     fEvents;              //Holds TObjArrays of MyTracklets
94   deque<int>            fNTracksInEvent;      //Tracks in event
95   deque<int>            fEventIndex;          //Original event index
96   Int_t                 fMixDepth;            //Number of evts. to mix with
97   Double_t              fMultMin, fMultMax;   //Track multiplicity bin range
98   Double_t              fZvtxMin, fZvtxMax;   //Event z-vertex bin range
99   Bool_t                fWasUpdated;          //Evt. succesfully passed selection?
100   Int_t                 fMultBinIndex;        //Multiplicity bin
101   Int_t                 fZvtxBinIndex;        //Zvertex bin
102   Int_t                 fDebug;               //If 1 then debug on
103   Int_t                 fTargetTrackDepth;    //Number of tracks, once full
104   Bool_t                fFirstFilled;         //Init to false
105   Int_t                 fNTimes;              //Number of times init. condition reached
106
107   ClassDef(AliEventPool,1) // Event pool class
108 };
109
110 class AliEventPoolManager : public TObject
111 {
112 public:
113   AliEventPoolManager() 
114     : fDebug(0),
115     fNMultBins(0), 
116     fNZvtxBins(0),
117     fEvPool(0),
118     fTargetTrackDepth(0) {;}
119   AliEventPoolManager(Int_t maxEvts, Int_t minNTracks,
120                    Int_t nMultBins, Double_t *multbins,
121                    Int_t nZvtxBins, Double_t *zvtxbins);
122
123   ~AliEventPoolManager() {;}
124   
125   // First uses bin indices, second uses the variables themselves.
126   AliEventPool *GetEventPool(Int_t iMult, Int_t iZvtx) const;
127   AliEventPool *GetEventPool(Int_t    centVal, Double_t zvtxVal) const;
128   AliEventPool *GetEventPool(Double_t centVal, Double_t zvtxVal) const;
129
130   Int_t       InitEventPools(Int_t depth, 
131                              Int_t nmultbins, Double_t *multbins, 
132                              Int_t nzvtxbins, Double_t *zvtxbins);
133   void        SetTargetTrackDepth(Int_t d) { fTargetTrackDepth = d;} // Same as for G.E.P. class
134   Int_t       UpdatePools(TObjArray *trk);
135   void        SetDebug(Bool_t b) { fDebug = b; }
136
137 protected:
138   Int_t      fDebug;                                    // If 1 then debug on
139   Int_t      fNMultBins;                                // number mult bins
140   Int_t      fNZvtxBins;                                // number vertex bins
141   std::vector<std::vector<AliEventPool*> > fEvPool; // pool in bins of [fMultBin][fZvtxBin]
142   Int_t      fTargetTrackDepth;                         // Required track size, same for all pools.
143
144   ClassDef(AliEventPoolManager,1)
145 };
146 #endif