]>
Commit | Line | Data |
---|---|---|
7e4038b5 | 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> | |
9d99b0dd | 6 | #include "AliForwardUtil.h" |
7e4038b5 | 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: | |
e8bf1690 | 25 | * - AliFMDCorrELossFit |
7e4038b5 | 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 | * | |
e8bf1690 | 34 | * @ingroup pwg2_forward_algo |
7e4038b5 | 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 | ||
7e4038b5 | 68 | /** |
69 | * Set the low cut used for sharing | |
70 | * | |
71 | * @param lowCut Low cut | |
72 | */ | |
0bd4b00f | 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; } | |
ea3e5d95 | 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; } | |
7e4038b5 | 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; } | |
0bd4b00f | 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; } | |
7e4038b5 | 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 | |
7e4038b5 | 107 | * |
108 | * @return True on success, false otherwise | |
109 | */ | |
110 | Bool_t Filter(const AliESDFMD& input, | |
111 | Bool_t lowFlux, | |
ea3e5d95 | 112 | AliESDFMD& output); |
7e4038b5 | 113 | /** |
114 | * Scale the histograms to the total number of events | |
115 | * | |
c389303e | 116 | * @param dir Where the output is |
7e4038b5 | 117 | * @param nEvents Number of events |
118 | */ | |
e8bf1690 | 119 | virtual void ScaleHistograms(TList* dir, Int_t nEvents); |
7e4038b5 | 120 | |
9d99b0dd | 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 | */ | |
e8bf1690 | 128 | virtual void DefineOutput(TList* dir); |
0bd4b00f | 129 | /** |
130 | * Print information | |
131 | * | |
132 | * @param option Not used | |
133 | */ | |
e8bf1690 | 134 | virtual void Print(Option_t* option="") const; |
7e4038b5 | 135 | protected: |
136 | /** | |
137 | * Internal data structure to keep track of the histograms | |
138 | */ | |
9d99b0dd | 139 | struct RingHistos : public AliForwardUtil::RingHistos |
7e4038b5 | 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 | /** | |
c389303e | 171 | * Clear this object |
7e4038b5 | 172 | */ |
7e4038b5 | 173 | void Clear(const Option_t* ="") { fNHits = 0; } |
c389303e | 174 | /** |
175 | * Increase number of hits | |
176 | * | |
177 | */ | |
7e4038b5 | 178 | void Incr() { fNHits++; } |
c389303e | 179 | /** |
180 | * Finish off | |
181 | * | |
182 | */ | |
7e4038b5 | 183 | void Finish(); |
c389303e | 184 | /** |
185 | * Make output | |
186 | * | |
187 | * @param dir where to store | |
188 | */ | |
7e4038b5 | 189 | void Output(TList* dir); |
9d99b0dd | 190 | /** |
191 | * Scale the histograms to the total number of events | |
192 | * | |
193 | * @param nEvents Number of events | |
c389303e | 194 | * @param dir Where the output is |
9d99b0dd | 195 | */ |
196 | void ScaleHistograms(TList* dir, Int_t nEvents); | |
7e4038b5 | 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 | |
9d99b0dd | 201 | ClassDef(RingHistos,1); |
7e4038b5 | 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; | |
0bd4b00f | 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; | |
7e4038b5 | 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 | |
0bd4b00f | 291 | Short_t fNXi; // Number of xi's from Delta to stop merging |
ea3e5d95 | 292 | Int_t fDebug; // Debug level |
7e4038b5 | 293 | |
294 | ClassDef(AliFMDSharingFilter,1); // | |
295 | }; | |
296 | ||
297 | #endif | |
298 | // Local Variables: | |
299 | // mode: C++ | |
300 | // End: |