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