7d8ba9922d066d1e8f66c5be792494875a30d855
[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) { fLowCut = lowCut; }
74   /** 
75    * Reset the low cut for sharing to use the fit range lower cut 
76    * 
77    */
78   void UnsetLowCut() { fLowCut = 0; }
79   /** 
80    * Set the debug level.  The higher the value the more output 
81    * 
82    * @param dbg Debug level 
83    */
84   void SetDebug(Int_t dbg=1) { fDebug = dbg; }
85
86   /** 
87    * Enable use of angle corrected signals in the algorithm 
88    * 
89    * @param use If true, use angle corrected signals, 
90    * otherwise use de-corrected signals.  In the final output, the 
91    * signals are always angle corrected. 
92    */
93   void UseAngleCorrectedSignals(Bool_t use) { fCorrectAngles = use; }
94   /** 
95    * Set the number of landau width to subtract from the most probably
96    * value to get the high cut for the merging algorithm.
97    * 
98    * @param n Number of @f$ \xi@f$ 
99    */
100   void SetNXi(Short_t n) { fNXi = n; }
101   /** 
102    * Filter the input AliESDFMD object
103    * 
104    * @param input     Input 
105    * @param lowFlux   If this is a low-flux event 
106    * @param output    Output AliESDFMD object 
107    * 
108    * @return True on success, false otherwise 
109    */
110   Bool_t Filter(const AliESDFMD& input, 
111                 Bool_t           lowFlux, 
112                 AliESDFMD&       output);
113   /** 
114    * Scale the histograms to the total number of events 
115    * 
116    * @param dir     Where the output is 
117    * @param nEvents Number of events 
118    */
119   void ScaleHistograms(TList* dir, Int_t nEvents);
120   
121   /** 
122    * Define the output histograms.  These are put in a sub list of the
123    * passed list.   The histograms are merged before the parent task calls 
124    * AliAnalysisTaskSE::Terminate 
125    * 
126    * @param dir Directory to add to 
127    */
128   void DefineOutput(TList* dir);
129   /** 
130    * Print information
131    * 
132    * @param option Not used 
133    */
134   void Print(Option_t* option="") const;
135 protected:
136   /** 
137    * Internal data structure to keep track of the histograms
138    */
139   struct RingHistos : public AliForwardUtil::RingHistos
140   { 
141     /** 
142      * Default CTOR
143      */
144     RingHistos();
145     /** 
146      * Constructor
147      * 
148      * @param d detector
149      * @param r ring 
150      */
151     RingHistos(UShort_t d, Char_t r);
152     /** 
153      * Copy constructor 
154      * 
155      * @param o Object to copy from 
156      */
157     RingHistos(const RingHistos& o);
158     /** 
159      * Assignment operator 
160      * 
161      * @param o Object to assign from 
162      * 
163      * @return Reference to this 
164      */
165     RingHistos& operator=(const RingHistos& o);
166     /** 
167      * Destructor 
168      */
169     ~RingHistos();
170     /** 
171      * Clear this object
172      */
173     void Clear(const Option_t* ="") { fNHits = 0; } 
174     /** 
175      * Increase number of hits 
176      * 
177      */
178     void Incr() { fNHits++; } 
179     /** 
180      * Finish off 
181      * 
182      */
183     void Finish(); 
184     /** 
185      * Make output 
186      * 
187      * @param dir where to store 
188      */
189     void Output(TList* dir);
190     /** 
191      * Scale the histograms to the total number of events 
192      * 
193      * @param nEvents Number of events 
194      * @param dir     Where the output is 
195      */
196     void ScaleHistograms(TList* dir, Int_t nEvents);
197     TH1D*     fBefore;       // Distribution of signals before filter
198     TH1D*     fAfter;        // Distribution of signals after filter
199     TH1D*     fHits;         // Distribution of hit strips. 
200     Int_t     fNHits;        // Number of hit strips per event
201     ClassDef(RingHistos,1);
202   };
203   /** 
204    * Get the ring histogram container 
205    * 
206    * @param d Detector
207    * @param r Ring 
208    * 
209    * @return Ring histogram container 
210    */
211   RingHistos* GetRingHistos(UShort_t d, Char_t r) const;
212   /** 
213    * Get the signal in a strip 
214    * 
215    * @param fmd   ESD object
216    * @param d     Detector
217    * @param r     Ring 
218    * @param s     Sector 
219    * @param t     Strip
220    * 
221    * @return The energy signal 
222    */
223   Double_t SignalInStrip(const AliESDFMD& fmd, 
224                          UShort_t d,
225                          Char_t   r,
226                          UShort_t s,
227                          UShort_t t) const;
228   /** 
229    * The actual algorithm 
230    * 
231    * @param mult      The unfiltered signal in the strip
232    * @param eta       Psuedo rapidity 
233    * @param prevE     Previous strip signal (or 0)
234    * @param nextE     Next strip signal (or 0) 
235    * @param lowFlux   Whether this is a low flux event 
236    * @param d         Detector
237    * @param r         Ring 
238    * @param s         Sector 
239    * @param t         Strip
240    * @param usedPrev  Whether the previous strip was used in sharing or not
241    * @param usedThis  Wether this strip was used in sharing or not. 
242    * 
243    * @return The filtered signal in the strip
244    */
245   Double_t MultiplicityOfStrip(Double_t mult,
246                                Double_t eta,
247                                Double_t prevE,
248                                Double_t nextE,
249                                Bool_t   lowFlux,
250                                UShort_t d,
251                                Char_t   r,
252                                UShort_t s,
253                                UShort_t t,
254                                Bool_t&  usedPrev, 
255                                Bool_t&  usedThis);
256   /** 
257    * Angle correct the signal 
258    * 
259    * @param mult Angle Un-corrected Signal 
260    * @param eta  Pseudo-rapidity 
261    * 
262    * @return Angle corrected signal 
263    */
264   Double_t AngleCorrect(Double_t mult, Double_t eta) const;
265   /** 
266    * Angle de-correct the signal 
267    * 
268    * @param mult Angle corrected Signal 
269    * @param eta  Pseudo-rapidity 
270    * 
271    * @return Angle un-corrected signal 
272    */
273   Double_t DeAngleCorrect(Double_t mult, Double_t eta) const;
274   /**
275    * Get the high cut.  The high cut is defined as the 
276    * most-probably-value peak found from the energy distributions, minus 
277    * 2 times the width of the corresponding Landau.
278    */
279   virtual Double_t GetHighCut(UShort_t d, Char_t r, Double_t eta) const;
280   /**
281    * Get the low cut.  Normally, the low cut is taken to be the lower
282    * value of the fit range used when generating the energy loss fits.
283    * However, if fLowCut is set (using SetLowCit) to a value greater
284    * than 0, then that value is used.
285    */
286   virtual Double_t GetLowCut() const;
287
288   TList    fRingHistos;    // List of histogram containers
289   Double_t fLowCut;        // Low cut on sharing
290   Bool_t   fCorrectAngles; // Whether to work on angle corrected signals
291   Short_t  fNXi;           // Number of xi's from Delta to stop merging
292   Int_t    fDebug;         // Debug level 
293
294   ClassDef(AliFMDSharingFilter,1); //
295 };
296
297 #endif
298 // Local Variables:
299 //  mode: C++ 
300 // End: