Improved eloss fitting - see NIM B1, 16
[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    * 
96    * @return True on success, false otherwise 
97    */
98   Bool_t Filter(const AliESDFMD& input, 
99                 Bool_t           lowFlux, 
100                 AliESDFMD&       output);
101   /** 
102    * Scale the histograms to the total number of events 
103    * 
104    * @param dir     Where the output is 
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      * Clear this object
154      */
155     void Clear(const Option_t* ="") { fNHits = 0; } 
156     /** 
157      * Increase number of hits 
158      * 
159      */
160     void Incr() { fNHits++; } 
161     /** 
162      * Finish off 
163      * 
164      */
165     void Finish(); 
166     /** 
167      * Make output 
168      * 
169      * @param dir where to store 
170      */
171     void Output(TList* dir);
172     /** 
173      * Scale the histograms to the total number of events 
174      * 
175      * @param nEvents Number of events 
176      * @param dir     Where the output is 
177      */
178     void ScaleHistograms(TList* dir, Int_t nEvents);
179     TH1D*     fBefore;       // Distribution of signals before filter
180     TH1D*     fAfter;        // Distribution of signals after filter
181     TH1D*     fHits;         // Distribution of hit strips. 
182     Int_t     fNHits;        // Number of hit strips per event
183     ClassDef(RingHistos,1);
184   };
185   /** 
186    * Get the ring histogram container 
187    * 
188    * @param d Detector
189    * @param r Ring 
190    * 
191    * @return Ring histogram container 
192    */
193   RingHistos* GetRingHistos(UShort_t d, Char_t r) const;
194   /** 
195    * Get the signal in a strip 
196    * 
197    * @param fmd   ESD object
198    * @param d     Detector
199    * @param r     Ring 
200    * @param s     Sector 
201    * @param t     Strip
202    * 
203    * @return The energy signal 
204    */
205   Double_t SignalInStrip(const AliESDFMD& fmd, 
206                          UShort_t d,
207                          Char_t   r,
208                          UShort_t s,
209                          UShort_t t) const;
210   /** 
211    * The actual algorithm 
212    * 
213    * @param mult      The unfiltered signal in the strip
214    * @param eta       Psuedo rapidity 
215    * @param prevE     Previous strip signal (or 0)
216    * @param nextE     Next strip signal (or 0) 
217    * @param lowFlux   Whether this is a low flux event 
218    * @param d         Detector
219    * @param r         Ring 
220    * @param s         Sector 
221    * @param t         Strip
222    * @param usedPrev  Whether the previous strip was used in sharing or not
223    * @param usedThis  Wether this strip was used in sharing or not. 
224    * 
225    * @return The filtered signal in the strip
226    */
227   Double_t MultiplicityOfStrip(Double_t mult,
228                                Double_t eta,
229                                Double_t prevE,
230                                Double_t nextE,
231                                Bool_t   lowFlux,
232                                UShort_t d,
233                                Char_t   r,
234                                UShort_t s,
235                                UShort_t t,
236                                Bool_t&  usedPrev, 
237                                Bool_t&  usedThis);
238   /** 
239    * Angle correct the signal 
240    * 
241    * @param mult Angle Un-corrected Signal 
242    * @param eta  Pseudo-rapidity 
243    * 
244    * @return Angle corrected signal 
245    */
246   Double_t AngleCorrect(Double_t mult, Double_t eta) const;
247   /** 
248    * Angle de-correct the signal 
249    * 
250    * @param mult Angle corrected Signal 
251    * @param eta  Pseudo-rapidity 
252    * 
253    * @return Angle un-corrected signal 
254    */
255   Double_t DeAngleCorrect(Double_t mult, Double_t eta) const;
256   /**
257    * Get the high cut.  The high cut is defined as the 
258    * most-probably-value peak found from the energy distributions, minus 
259    * 2 times the width of the corresponding Landau.
260    */
261   virtual Double_t GetHighCut(UShort_t d, Char_t r, Double_t eta) const;
262
263   TList    fRingHistos;    // List of histogram containers
264   Double_t fLowCut;        // Low cut on sharing
265   Bool_t   fCorrectAngles; // Whether to work on angle corrected signals
266   Int_t    fDebug;         // Debug level 
267
268   ClassDef(AliFMDSharingFilter,1); //
269 };
270
271 #endif
272 // Local Variables:
273 //  mode: C++ 
274 // End: