Fix some documentation issues
[u/mrichter/AliRoot.git] / PWGLF / FORWARD / analysis2 / AliForwardMultDists.h
1 #ifndef ALIFORWARDMULTDIST_H
2 #define ALIFORWARDMULTDIST_H
3 /**
4  * @file   AliForwardMultDists.h
5  * @author Christian Holm Christensen <cholm@nbi.dk>
6  * @date   Tue Nov 12 09:57:28 2013
7  * 
8  * @brief  Class to make raw @f$P(N_{ch})@f$ distributions 
9  * 
10  * @ingroup pwglf_forward_multdist 
11  */
12
13 #include "AliBaseAODTask.h"
14 #include <TList.h>
15 #include <TString.h>
16 class TH1;
17 class TH2;
18 class AliAODForwardMult;
19
20 /**
21  * Class to make raw @f$P(N_{ch})@f$ distributions 
22  * 
23  * @ingroup pwglf_forward_multdist
24  */
25 class AliForwardMultDists : public AliBaseAODTask
26 {
27 public:
28   enum { 
29     kInvalidEta = 999
30   };
31   enum { 
32     kAnalysis = 1, 
33     kMC       = 2, 
34     kTrigger  = 3, 
35     kVertex   = 4, 
36     kTriggerVertex = 5
37   };
38   /**
39    * Structure to define @f$\eta@f$ bins with an @f$ N_{ch}@f$ axis 
40    * 
41    */
42   struct BinSpec 
43   {
44     /** 
45      * Constructor
46      * 
47      * @param etaMin Low cut on @f$\eta@f$
48      * @param etaMax High cut on @f$\eta@f$
49      * @param nchLow Lowest @f$ N_{ch}@f$ (e.g., -0.5);
50      */
51     BinSpec(Double_t etaMin, Double_t etaMax, Double_t nchLow);
52     /** 
53      * Push @a n bins of with @a d in @f$ N_{ch}@f$ onto the axis 
54      * 
55      * If only a single push is done, then we will get an axis of
56      * equally sized bins (@a d) from @f$ l@f$ edge to @f$ nd+low@f$ -
57      * e.g., if one only does 
58      *
59      * @code
60      * BinSpec b(e1, e2, -.5);
61      * b.Push(10, 1);
62      * @endcode 
63      *
64      * One ends up with 10 bins from -0.5 to 9.5. 
65      *
66      * @param n Number of bins to push
67      * @param d Bin width of each of the bins
68      */
69     void Push(UShort_t n, Double_t d);
70     /** 
71      * Get the axis computed from the setup using Push
72      * 
73      * @return Reference to the axis 
74      */
75     const TAxis& Axis() const;
76     Double_t fEtaMin;
77     Double_t fEtaMax;
78     Double_t fLow;
79     TArrayI  fN;
80     TArrayD  fD;
81     mutable TAxis    fAxis;
82   };
83
84   /** 
85    * Default constructor
86    */
87   AliForwardMultDists();
88   /** 
89    * User constructor 
90    * 
91    * @param name Name of the task 
92    */
93   AliForwardMultDists(const char* name);
94   /** 
95    * Destructor
96    */
97   virtual ~AliForwardMultDists() {}
98   /** 
99    * Create output objects - called at start of job in slave 
100    * 
101    * @return true on success
102    */
103   Bool_t Book();
104   /** 
105    * Set-up internal structures on first seen event 
106    * 
107    * @return true on success
108    */
109   Bool_t PreData();
110   /** 
111    * Executed before every event 
112    * 
113    * @return true on success
114    */
115   Bool_t PreEvent() { fIsSelected = false; return true; }
116   /** 
117    * Analyse a single event 
118    * 
119    * @param aod AOD Event
120    *
121    * @return true on success
122    */
123   Bool_t Event(AliAODEvent& aod);
124   /** 
125    * Called at the end of the final processing of the job on the
126    * full data set (merged data)
127    * 
128    * @return true on success
129    */
130   Bool_t Finalize();
131   /** 
132    * Add an @f$\eta@f$ bin
133    * 
134    * @param spec Bin specification 
135    */
136   void AddBin(const BinSpec& spec);
137   /** 
138    * Add an @f$\eta@f$ bin
139    * 
140    * @param etaLow Low cut on @f$\eta@f$  
141    * @param etaMax High cut on @f$\eta@f$ 
142    * @param nAxis  Axis to use for measured @f$ N_{ch}@f$ 
143    */
144   void AddBin(Double_t etaLow, Double_t etaMax, const TAxis& nAxis); 
145   /** 
146    * Add an @f$\eta@f$ bin
147    * 
148    * @param etaLow Low cut on @f$\eta@f$ 
149    * @param etaMax High cut on @f$\eta@f$ 
150    * @param nMax   Maximum @f$ N_{ch}@f$ 
151    * @param nDiv   Number of subdivisions per @f$ N_{ch}@f$
152    *
153    */
154   void AddBin(Double_t etaLow, Double_t etaMax, UShort_t nMax, UShort_t nDiv); 
155   /** 
156    * Whether to use the stored phi acceptance 
157    * 
158    * @param use If true, use stored phi acceptance 
159    */
160   void SetUsePhiAcc(Bool_t use) { fUsePhiAcc = use; }
161   /** 
162    * Print this task 
163    * 
164    * @param option Not used
165    */
166   void Print(Option_t* option="") const;
167 protected:
168   /** 
169    * Project a 2D histogram into a 1D histogram taking care to use
170    * either the @f$\phi@f$ acceptance stored in the overflow bins, or
171    * the @f$\eta@f$ coverage stored in the underflow bins.
172    * 
173    * @param input      2D histogram to project 
174    * @param cache      1D histogram to project into 
175    * @param usePhiAcc  If true, use the @f$\phi@f$ acceptance stored in
176    * the overflow bins, or if false the @f$\eta@f$ coverage stored in
177    * the underflow bins.
178    */
179   static void ProjectX(const TH2& input, TH1& cache, Bool_t usePhiAcc=true);
180   /** 
181    * Project on @f$\eta@f$ axis.  If any of the pointers passed is
182    * zero, do nothing.
183    * 
184    * @param input 
185    * @param cache 
186    */
187   static void ProjectX(const TH2* input, TH1* cache);
188   /** 
189    * An @f$\eta@f$ bin 
190    */
191   struct EtaBin : public TObject
192   {
193     /** 
194      * I/O constructor
195      */
196     EtaBin();
197     /** 
198      * User constructor 
199      * 
200      * @param minEta Least @f$\eta@f$ to consider 
201      * @param maxEta Largest @f$\eta@f$ to consider 
202      * @param mAxis  The @f$ N_{ch}@f$ axis to use for measured data 
203      */
204     EtaBin(Double_t minEta, Double_t maxEta, const TAxis& mAxis); 
205     /** 
206      * Copy constructor
207      *
208      * @param o object to copy fron
209      */
210     EtaBin(const EtaBin& o);
211     /** 
212      * Assignment operator
213      * 
214      * @param o object to assign from 
215      *
216      * @return Reference to this object
217      */
218     EtaBin& operator=(const EtaBin& o);
219     /** 
220      * Destructor
221      */
222     virtual ~EtaBin() {}
223     /** 
224      * Get the name of the bin
225      */
226     const char* GetName() const { return fName.Data(); }
227     /** 
228      * Is this bin symmetric around 0?
229      */
230     Bool_t IsSymmetric() const;
231     /** 
232      * Is this bin positive only?
233      */
234     Bool_t IsNegative() const;
235     /** 
236      * Is this bin positive only?
237      */
238     Bool_t IsPositive() const;
239     /** 
240      * Get parent container name 
241      * 
242      * 
243      * @return Parent container name
244      */
245     const char* ParentName() const;
246     /** 
247      * Find the parent container.  if not found, and @a create is
248      * true, then make the container.
249      * 
250      * @param l       Top container 
251      * @param create  If true, create container if not found
252      * 
253      * @return Container, or null
254      */
255     TList* FindParent(TList* l, Bool_t create=true) const;
256     /** 
257      * Create a 1D histogram with specified axis 
258      * 
259      * @param name  Name of histogram 
260      * @param title Title of histogram 
261      * @param xAxis X-axis to use 
262      * 
263      * @return Created histogram
264      */
265     static TH1* CreateH1(const char* name, const char* title, 
266                          const TAxis& xAxis);
267     /** 
268      * Create a 2D histogram with specified axis 
269      * 
270      * @param name  Name of histogram 
271      * @param title Title of histogram 
272      * @param xAxis X-axis to use 
273      * @param yAxis Y-axis to use 
274      * 
275      * @return Created histogram
276      */
277     static TH2* CreateH2(const char* name, const char* title, 
278                          const TAxis& xAxis, const TAxis& yAxis);
279     /** 
280      * Set-up internal structures on first event. 
281      * 
282      * @param list  List to add information to
283      * @param hist  Template histogram 
284      * @param useMC Whether to set-up for MC input 
285      */
286     void SetupForData(TList* list, const TH2& hist, Bool_t useMC);
287     /** 
288      * Process a single event 
289      * 
290      * @param sumForward  Projection of forward data
291      * @param sumCentral  Projection of the central data
292      * @param forward     The original forward data 
293      * @param central     The original central data
294      * @param accepted    True if event is accepted for analysis
295      * @param mc          Distribution of primary particles from MC
296      */
297     void Process(const TH1& sumForward, const TH1& sumCentral,
298                  const TH2& forward,    const TH2& central,
299                  Bool_t     accepted,   const TH1* mc);
300     /** 
301      * Called at the end of the final processing of the job on the
302      * full data set (merged data)
303      * 
304      * @param in    Input list
305      * @param out   Output list 
306      */
307     void Terminate(TList* in, TList* out);
308       
309     TString  fName;          // Name of this bin
310     TAxis    fMAxis;         // Axis used for measured Nch
311     TAxis    fTAxis;         // Axis used for true Nch
312     Double_t fMinEta;        // Least @f$\eta@f$ to consider
313     Double_t fMaxEta;        // Largest @f$\eta@f$ to consider
314     Int_t    fMinBin;        // Least @f$\eta@f$ bin to consider
315     Int_t    fMaxBin;        // Largest @f$\eta@f$ bin to consider
316     TH1*     fSum;           // Distribution 
317     TH2*     fCorr;          // Correlation between forward and central
318     TH2*     fResponse;      // Response matrix (for MC)
319     TH1*     fTruth;         // `true' distribution 
320     TH1*     fTruthAccepted; // `true' distribution for accepted events
321     TH1*     fCoverage;      // How much was covered
322
323     ClassDef(EtaBin,2);
324   };
325   /** 
326    * Copy constructor
327    *
328    * @param o object to copy fron
329    */
330   AliForwardMultDists(const AliForwardMultDists& o);
331   /** 
332    * Assignment operator
333    * 
334    * @param o object to assign from 
335    *
336    * @return Reference to this object
337    */
338   AliForwardMultDists& operator=(const AliForwardMultDists& o);
339   /** 
340    * Check the event 
341    * 
342    * @param fwd Forward data structure 
343    * 
344    * @return Always true 
345    */
346   Bool_t CheckEvent(const AliAODForwardMult& fwd);
347
348   TList    fBins;         // List of bins 
349   TList*   fSymmetric;    // Bins symmetric around 0
350   TList*   fNegative;     // Bins on negative side only 
351   TList*   fPositive;     // Bins on the positive side only
352   TH1*     fMCVertex;     // Histogram of MC IpZ
353   TH2*     fDiag;         // Diagnostics
354   TH1*     fForwardCache; // Projection cache 
355   TH1*     fCentralCache; // Projection cache 
356   TH1*     fMCCache;      // Projection cache 
357   Bool_t   fUsePhiAcc;    // If true, scale by phi acceptance 
358   Bool_t   fIsSelected;   // IF the even was selected
359
360   ClassDef(AliForwardMultDists,1);
361 };
362
363 #endif
364 // Local Variables:
365 //  mode: C++
366 // End:
367
368