Various fixes to deal with centrality
[u/mrichter/AliRoot.git] / PWG2 / FORWARD / analysis2 / AliBasedNdetaTask.h
1 //
2 // Task to analyse the AOD for for dN/deta in the base regions 
3 //
4 #ifndef ALIBASEDNDETATASK_H
5 #define ALIBASEDNDETATASK_H
6 #include <AliAnalysisTaskSE.h>
7 class TAxis;
8 class TList;
9 class TH2D;
10 class TH1D;
11 class AliAODEvent;
12 class AliAODForwardMult;
13 class TObjArray;
14
15 /**
16  * Task to determine the 
17  */
18 class AliBasedNdetaTask : public AliAnalysisTaskSE
19 {
20 public:
21   /** 
22    * Constructor 
23    * 
24    */
25   AliBasedNdetaTask();
26   /** 
27    * Constructor
28    * 
29    * @param name    Name of task 
30    * @param maxVtx  Set @f$v_z@f$ range
31    */
32   AliBasedNdetaTask(const char* name);
33   /**
34    * Destructor
35    * 
36    */
37   virtual ~AliBasedNdetaTask();
38
39   /** 
40    * @{ 
41    * @name Task configuration 
42    */
43   /** 
44    * Set the vertex range to use 
45    * 
46    * @param min Minimum (in centermeter)
47    * @param max Maximum (in centermeter)
48    */  
49   void SetVertexRange(Double_t min, Double_t max) { fVtxMin=min; fVtxMax=max; }
50   /** 
51    * Set the rebinning factor 
52    * 
53    * @param rebin Rebinning factor 
54    */
55   void SetRebinning(Int_t rebin) { fRebin = rebin; }
56   /** 
57    * Set the trigger maskl 
58    * 
59    * @param mask Trigger mask
60    */
61   void SetTriggerMask(UShort_t mask) { fTriggerMask = mask; }
62   /** 
63    * Set the trigger mask 
64    * 
65    * @param mask trigger mask 
66    */
67   void SetTriggerMask(const char* mask);
68   /** 
69    * Set the centrality bins to use. 
70    * 
71    * @code 
72    *   UShort_t bins[] = { 0, 5, 10, 20, 30, 40, 50, 60, 70, 80, 90, 100 };
73    *   task->SetCentralityBins(11, bins);
74    * @endcode 
75    * 
76    * @param n     Number of bins (elements in @a bins minus 1)
77    * @param bins  Bin limits 
78    */
79   void SetCentralityAxis(UShort_t n, Short_t* bins);
80   /** 
81    * Trigger efficiency for selected trigger(s)
82    * 
83    * @param e Trigger efficiency 
84    */
85   void SetCutEdges(Bool_t cut) {fCutEdges = cut;}
86   /** 
87    * Trigger efficiency for selected trigger(s)
88    * 
89    * @param e Trigger efficiency 
90    */
91   void SetTriggerEff(Double_t e) { fTriggerEff = e; } 
92   /** 
93    * Set the shape correction (a.k.a., track correction) for selected
94    * trigger(s)
95    * 
96    * @param h Correction
97    */
98   void SetShapeCorrection(const TH1* h);
99   /** 
100    * Set whether to use the shape correction 
101    *
102    * @param use  whether to use the shape correction 
103    */
104   void SetUseShapeCorrection(Bool_t use) { fUseShapeCorr = use; }
105   /** 
106    * Load the normalization data - done automatically if not set from outside
107    * 
108    * @param sys system
109    * @param energy energy
110    */
111   void LoadNormalizationData(UShort_t sys, UShort_t energy);  
112   /** @} */
113
114   /** @{ 
115    *  @name Task interface 
116    */
117   /** 
118    * Initialise on master - does nothing
119    * 
120    */
121   virtual void   Init() {}
122   /** 
123    * Create output objects.  
124    *
125    * This is called once per slave process 
126    */
127   virtual void UserCreateOutputObjects();
128   /** 
129    * Process a single event 
130    * 
131    * @param option Not used
132    */
133   virtual void UserExec(Option_t* option);
134   /** 
135    * Called at end of event processing.. 
136    *
137    * This is called once in the master 
138    * 
139    * @param option Not used 
140    */
141   virtual void Terminate(Option_t* option);
142   /** @} */
143
144   /** 
145    * @{ 
146    * @name Services member functions 
147    */
148   /** 
149    * Make a copy of the input histogram and rebin that histogram
150    * 
151    * @param h  Histogram to rebin
152    * 
153    * @return New (rebinned) histogram
154    */
155   static TH1D* Rebin(const TH1D* h, Int_t rebin, Bool_t cutEdges=false);
156   /** 
157    * Make an extension of @a h to make it symmetric about 0 
158    * 
159    * @param h Histogram to symmertrice 
160    * 
161    * @return Symmetric extension of @a h 
162    */
163   static TH1* Symmetrice(const TH1* h);
164   /** 
165    * Project onto the X axis 
166    * 
167    * @param h         2D histogram 
168    * @param name      New name 
169    * @param firstbin  First bin to use 
170    * @param lastbin   Last bin to use
171    * @param error     Whether to calculate errors
172    * 
173    * @return Newly created histogram or null
174    */
175   static TH1D* ProjectX(const TH2D* h, 
176                         const char* name,
177                         Int_t firstbin, 
178                         Int_t lastbin, 
179                         bool  corr=true,
180                         bool  error=true);
181   /** 
182    * Set histogram graphical options, etc. 
183    * 
184    * @param h       Histogram to modify
185    * @param colour  Marker color 
186    * @param marker  Marker style
187    * @param title   Title of histogram
188    * @param ytitle  Title on y-axis. 
189    */
190   static void SetHistogramAttributes(TH1D* h, Int_t colour, Int_t marker, 
191                                      const char* title, 
192                                      const char* ytitle="#frac{1}{N} #frac{dN_{ch}}{d#eta}");
193   /** @} */
194 protected:
195   AliBasedNdetaTask(const AliBasedNdetaTask&);
196   AliBasedNdetaTask& operator=(const AliBasedNdetaTask&) { return *this; }
197   class CentralityBin;
198
199   /** 
200    * Retrieve the histogram 
201    * 
202    * @param aod AOD event 
203    * @param mc  Whether to get the MC histogram or not
204    * 
205    * @return Retrieved histogram or null
206    */
207   virtual TH2D* GetHistogram(const AliAODEvent* aod, Bool_t mc=false) = 0;
208   /** 
209    * Add a centrality bin 
210    * 
211    * @param low  Low cut
212    * @param high High cut
213    */
214   void AddCentralityBin(UShort_t at, Short_t low, Short_t high);
215   /** 
216    * Make a centrality bin 
217    * 
218    * @param name  Name used for histograms
219    * @param low   Low cut in percent
220    * @param high  High cut in percent
221    * 
222    * @return A newly created centrality bin 
223    */
224   virtual CentralityBin* MakeCentralityBin(const char* name, Short_t low, 
225                                            Short_t high) const;
226   /** 
227    * Trigger histogram bins 
228    */
229   enum { 
230     kAll        = 1, 
231     kB          = 2, 
232     kA          = 3, 
233     kC          = 4, 
234     kE          = 5,
235     kMB         = 6,
236     kPileUp     = 7,
237     kWithTrigger= 8,
238     kWithVertex = 9,
239     kAccepted   = 10,
240     kMCNSD      = 11
241   };
242   /**
243    * Calculations done per centrality 
244    * 
245    */
246   struct CentralityBin : public TNamed
247   {
248     /** 
249      * Constructor 
250      */
251     CentralityBin();
252     /** 
253      * Constructor 
254      * 
255      * @param name Name used for histograms (e.g., Forward)
256      * @param low  Lower centrality cut in percent 
257      * @param high Upper centrality cut in percent 
258      */
259     CentralityBin(const char* name, Short_t low, Short_t high);
260     /** 
261      * Copy constructor 
262      * 
263      * @param other Object to copy from 
264      */
265     CentralityBin(const CentralityBin& other);
266     /** 
267      * Destructor 
268      */
269     virtual ~CentralityBin();
270     /** 
271      * Assignment operator 
272      * 
273      * @param other Object to assign from 
274      * 
275      * @return Reference to this 
276      */
277     CentralityBin& operator=(const CentralityBin& other);
278     /** 
279      * Check if this is the 'all' bin 
280      * 
281      * @return true if low and high cuts are both zero
282      */    
283     Bool_t IsAllBin() const { return fLow == 0 && fHigh == 0; }
284     /** 
285      * Get the list name 
286      * 
287      * @return List Name 
288      */
289     const char* GetListName() const;
290     /** 
291      * Create output objects 
292      * 
293      * @param dir   Parent list
294      */
295     virtual void CreateOutputObjects(TList* dir);
296     /** 
297      * Process an event
298      * 
299      * @param forward     Forward data (for trigger, vertex, & centrality)
300      * @param triggerMask Trigger mask 
301      * @param vzMin       Minimum IP z coordinate
302      * @param vzMax       Maximum IP z coordinate
303      * @param data        Data histogram 
304      * @param mc          MC histogram
305      */
306     virtual void ProcessEvent(const AliAODForwardMult* forward, 
307                               Int_t triggerMask,
308                               Double_t vzMin, Double_t vzMax, 
309                               const TH2D* data, const TH2D* mc);
310     /** 
311      * End of processing 
312      * 
313      * @param sums        List of sums
314      * @param results     Output list of results
315      * @param shapeCorr   Shape correction or nil
316      * @param trigEff     Trigger efficiency 
317      * @param symmetrice  Whether to symmetrice the results
318      * @param rebin       Whether to rebin the results
319      * @param corrEmpty   Whether to correct for empty bins
320      * @param cutEdges    Whether to cut edges when rebinning
321      * @param vzMin       Minimum IP z coordinate
322      * @param vzMax       Maximum IP z coordinate
323      * @param triggerMask Trigger mask 
324      */
325     virtual void End(TList*      sums, 
326                      TList*      results,
327                      const TH1*  shapeCorr, 
328                      Double_t    trigEff,
329                      Bool_t      symmetrice,
330                      Int_t       rebin, 
331                      Bool_t      corrEmpty, 
332                      Bool_t      cutEdges, 
333                      Double_t    vzMin, 
334                      Double_t    vzMax, 
335                      Int_t       triggerMask);
336     /**
337      * @{
338      * @name Access histograms
339      */
340     /** 
341      * Get sum histogram 
342      * 
343      * @param mc If true, return MC histogram 
344      * 
345      * @return Sum histogram
346      */
347     const TH2D* GetSum(Bool_t mc=false) const { return mc ? fSumMC : fSum; }
348     /** 
349      * Get sum histogram 
350      * 
351      * @param mc If true, return MC histogram 
352      * 
353      * @return Sum histogram
354      */
355     TH2D* GetSum(Bool_t mc=false) { return mc ? fSumMC : fSum; }
356     /** 
357      * Get trigger histogram
358      * 
359      * @return Trigger histogram
360      */
361     const TH1D* GetTriggers() const { return fTriggers; } 
362     /** 
363      * Get trigger histogram
364      * 
365      * @return Trigger histogram 
366      */
367     TH1D* GetTrigggers() { return fTriggers; }
368     /** @} */
369   protected:
370     /** 
371      * Create sum histogram 
372      * 
373      * @param data  Data histogram to clone 
374      * @param mc    (optional) MC histogram to clone 
375      */
376     virtual void CreateSums(const TH2D* data, const TH2D* mc);
377     /** 
378      * Check the trigger, vertex, and centrality
379      * 
380      * @param aod Event input 
381      * 
382      * @return true if the event is to be used 
383      */
384     virtual Bool_t CheckEvent(const AliAODForwardMult* forward, 
385                               Int_t triggerMask,
386                               Double_t vzMin, Double_t vzMax);
387     TList*   fSums;      // Output list 
388     TList*   fOutput;    // Output list 
389     TH2D*    fSum;       // Sum histogram
390     TH2D*    fSumMC;     // MC sum histogram
391     TH1D*    fTriggers;  // Trigger histogram 
392     UShort_t fLow;       // Lower limit (inclusive)
393     UShort_t fHigh;      // Upper limit (exclusive)
394
395     ClassDef(CentralityBin,1); // A centrality bin 
396   };
397   TList*          fSums;         // Container of sums 
398   TList*          fOutput;       // Container of outputs 
399   Double_t        fVtxMin;       // Minimum v_z
400   Double_t        fVtxMax;       // Maximum v_z
401   Int_t           fTriggerMask;  // Trigger mask 
402   Int_t           fRebin;        // Rebinning factor 
403   Bool_t          fCutEdges;     // Whether to cut edges when rebinning
404   Bool_t          fSymmetrice;   // Whether to symmetrice data 
405   Bool_t          fCorrEmpty;    // Correct for empty bins 
406   Double_t        fTriggerEff;   // Trigger efficiency for selected trigger(s)
407   TH1*            fShapeCorr;    // Shape correction 
408   TObjArray*      fListOfCentralities; // Centrality bins 
409   Bool_t          fUseShapeCorr; // Whether to use shape correction
410   TNamed*         fSNNString;    // sqrt(s_NN) string 
411   TNamed*         fSysString;    // Collision system string 
412   TH1D*           fCent;         // Centrality distribution 
413   TAxis*          fCentAxis;     // Centrality axis
414
415   ClassDef(AliBasedNdetaTask,2); // Determine multiplicity in base area
416 };
417
418 #endif
419 //
420 // Local Variables:
421 //  mode: C++
422 // End:
423 //