Added debug flags
[u/mrichter/AliRoot.git] / PWG2 / FORWARD / analysis2 / AliFMDSharingFilter.h
1 #ifndef ALIROOT_PWG2_FORWARD_ALIFMDSHARINGFILTER_H
2 #define ALIROOT_PWG2_FORWARD_ALIFMDSHARINGFILTER_H
3 #include <TNamed.h>
4 #include <TH2.h>
5 #include <TList.h>
6 #include "AliForwardUtil.h"
7 class AliESDFMD;
8 class TAxis;
9 class TList;
10 class TH2;
11
12 /**
13  * Class to do the sharing correction.  That is, a filter that merges 
14  * adjacent strip signals presumably originating from a single particle 
15  * that impinges on the detector in such a way that it deposite energy 
16  * into two or more strips. 
17  *
18  * @par Input: 
19  *    - AliESDFMD object  - from reconstruction
20  *
21  * @par Output: 
22  *    - AliESDFMD object  - copy of input, but with signals merged 
23  *
24  * @par Corrections used: 
25  *    - AliFMDAnaCalibEnergyDistribution objects 
26  *
27  * @par Histograms: 
28  *    - For each ring (FMD1i, FMD2i, FMD2o, FMD3i, FMD3o) the distribution of 
29  *      signals before and after the filter.  
30  *    - For each ring (see above), an array of distributions of number of 
31  *      hit strips for each vertex bin (if enabled - see Init method)
32  * 
33  *
34  * @ingroup pwg2_forward_analysis 
35  */
36 class AliFMDSharingFilter : public TNamed
37 {
38 public: 
39   /** 
40    * Destructor
41    */
42   virtual ~AliFMDSharingFilter();
43   /** 
44    * Default Constructor - do not use 
45    */
46   AliFMDSharingFilter();
47   /** 
48    * Constructor 
49    * 
50    * @param title Title of object  - not significant 
51    */
52   AliFMDSharingFilter(const char* title);
53   /** 
54    * Copy constructor 
55    * 
56    * @param o Object to copy from 
57    */
58   AliFMDSharingFilter(const AliFMDSharingFilter& o);
59   /** 
60    * Assignment operator 
61    * 
62    * @param o Object to assign from 
63    * 
64    * @return Reference to this 
65    */
66   AliFMDSharingFilter& operator=(const AliFMDSharingFilter& o);
67
68   /** 
69    * Set the low cut used for sharing 
70    * 
71    * @param lowCut Low cut
72    */
73   void SetLowCut(Double_t lowCut=0.3) { fLowCut = lowCut; }
74   /** 
75    * Set the debug level.  The higher the value the more output 
76    * 
77    * @param dbg Debug level 
78    */
79   void SetDebug(Int_t dbg=1) { fDebug = dbg; }
80
81   /** 
82    * Enable use of angle corrected signals in the algorithm 
83    * 
84    * @param use If true, use angle corrected signals, 
85    * otherwise use de-corrected signals.  In the final output, the 
86    * signals are always angle corrected. 
87    */
88   void UseAngleCorrectedSignals(Bool_t use) { fCorrectAngles = use; }
89   /** 
90    * Filter the input AliESDFMD object
91    * 
92    * @param input     Input 
93    * @param lowFlux   If this is a low-flux event 
94    * @param output    Output AliESDFMD object 
95    * @param vz        Current vertex position 
96    * 
97    * @return True on success, false otherwise 
98    */
99   Bool_t Filter(const AliESDFMD& input, 
100                 Bool_t           lowFlux, 
101                 AliESDFMD&       output);
102   /** 
103    * Scale the histograms to the total number of events 
104    * 
105    * @param nEvents Number of events 
106    */
107   void ScaleHistograms(TList* dir, Int_t nEvents);
108   
109   /** 
110    * Define the output histograms.  These are put in a sub list of the
111    * passed list.   The histograms are merged before the parent task calls 
112    * AliAnalysisTaskSE::Terminate 
113    * 
114    * @param dir Directory to add to 
115    */
116   void DefineOutput(TList* dir);
117 protected:
118   /** 
119    * Internal data structure to keep track of the histograms
120    */
121   struct RingHistos : public AliForwardUtil::RingHistos
122   { 
123     /** 
124      * Default CTOR
125      */
126     RingHistos();
127     /** 
128      * Constructor
129      * 
130      * @param d detector
131      * @param r ring 
132      */
133     RingHistos(UShort_t d, Char_t r);
134     /** 
135      * Copy constructor 
136      * 
137      * @param o Object to copy from 
138      */
139     RingHistos(const RingHistos& o);
140     /** 
141      * Assignment operator 
142      * 
143      * @param o Object to assign from 
144      * 
145      * @return Reference to this 
146      */
147     RingHistos& operator=(const RingHistos& o);
148     /** 
149      * Destructor 
150      */
151     ~RingHistos();
152     /** 
153      * Initialise this object 
154      */
155     void Clear(const Option_t* ="") { fNHits = 0; } 
156     void Incr() { fNHits++; } 
157     void Finish(); 
158     void Output(TList* dir);
159     /** 
160      * Scale the histograms to the total number of events 
161      * 
162      * @param nEvents Number of events 
163      */
164     void ScaleHistograms(TList* dir, Int_t nEvents);
165     TH1D*     fBefore;       // Distribution of signals before filter
166     TH1D*     fAfter;        // Distribution of signals after filter
167     TH1D*     fHits;         // Distribution of hit strips. 
168     Int_t     fNHits;        // Number of hit strips per event
169     ClassDef(RingHistos,1);
170   };
171   /** 
172    * Get the ring histogram container 
173    * 
174    * @param d Detector
175    * @param r Ring 
176    * 
177    * @return Ring histogram container 
178    */
179   RingHistos* GetRingHistos(UShort_t d, Char_t r) const;
180   /** 
181    * Get the signal in a strip 
182    * 
183    * @param fmd   ESD object
184    * @param d     Detector
185    * @param r     Ring 
186    * @param s     Sector 
187    * @param t     Strip
188    * 
189    * @return The energy signal 
190    */
191   Double_t SignalInStrip(const AliESDFMD& fmd, 
192                          UShort_t d,
193                          Char_t   r,
194                          UShort_t s,
195                          UShort_t t) const;
196   /** 
197    * The actual algorithm 
198    * 
199    * @param mult      The unfiltered signal in the strip
200    * @param eta       Psuedo rapidity 
201    * @param prevE     Previous strip signal (or 0)
202    * @param nextE     Next strip signal (or 0) 
203    * @param lowFlux   Whether this is a low flux event 
204    * @param d         Detector
205    * @param r         Ring 
206    * @param s         Sector 
207    * @param t         Strip
208    * @param usedPrev  Whether the previous strip was used in sharing or not
209    * @param usedThis  Wether this strip was used in sharing or not. 
210    * 
211    * @return The filtered signal in the strip
212    */
213   Double_t MultiplicityOfStrip(Double_t mult,
214                                Double_t eta,
215                                Double_t prevE,
216                                Double_t nextE,
217                                Bool_t   lowFlux,
218                                UShort_t d,
219                                Char_t   r,
220                                UShort_t s,
221                                UShort_t t,
222                                Bool_t&  usedPrev, 
223                                Bool_t&  usedThis);
224   /** 
225    * Angle correct the signal 
226    * 
227    * @param mult Angle Un-corrected Signal 
228    * @param eta  Pseudo-rapidity 
229    * 
230    * @return Angle corrected signal 
231    */
232   Double_t AngleCorrect(Double_t mult, Double_t eta) const;
233   /** 
234    * Angle de-correct the signal 
235    * 
236    * @param mult Angle corrected Signal 
237    * @param eta  Pseudo-rapidity 
238    * 
239    * @return Angle un-corrected signal 
240    */
241   Double_t DeAngleCorrect(Double_t mult, Double_t eta) const;
242   /**
243    * Get the high cut.  The high cut is defined as the 
244    * most-probably-value peak found from the energy distributions, minus 
245    * 2 times the width of the corresponding Landau.
246    */
247   virtual Double_t GetHighCut(UShort_t d, Char_t r, Double_t eta) const;
248
249   TList    fRingHistos;    // List of histogram containers
250   Double_t fLowCut;        // Low cut on sharing
251   Bool_t   fCorrectAngles; // Whether to work on angle corrected signals
252   Int_t    fDebug;         // Debug level 
253
254   ClassDef(AliFMDSharingFilter,1); //
255 };
256
257 #endif
258 // Local Variables:
259 //  mode: C++ 
260 // End: