]>
Commit | Line | Data |
---|---|---|
8f1cfb0c | 1 | #ifndef ALIFMDRECONSTRUCTOR_H |
2 | #define ALIFMDRECONSTRUCTOR_H | |
4347b38f | 3 | // |
4 | // Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights | |
5 | // reserved. | |
6 | // | |
121a60bd | 7 | // See cxx source for full Copyright notice |
4347b38f | 8 | // |
121a60bd | 9 | // AliFMDReconstructor.h |
4347b38f | 10 | // Task Class for making TreeR for FMD |
11 | // | |
121a60bd | 12 | //-- Authors: Evgeny Karpechev (INR) and Alla Maevskaia (INR) |
4347b38f | 13 | // Latest changes by Christian Holm Christensen <cholm@nbi.dk> |
121a60bd | 14 | /* $Id$ */ |
c2fc1258 | 15 | /** @file AliFMDReconstructor.h |
16 | @author Christian Holm Christensen <cholm@nbi.dk> | |
17 | @date Mon Mar 27 12:47:09 2006 | |
18 | @brief FMD reconstruction | |
19 | */ | |
8f1cfb0c | 20 | |
42403906 | 21 | //____________________________________________________________________ |
0d0e6995 | 22 | // Header guards in the header files speeds up the compilation |
23 | // considerably. Please leave them in. | |
24 | #ifndef ALIRECONSTRUCTOR_H | |
25 | # include <AliReconstructor.h> | |
26 | #endif | |
d76c31f4 | 27 | #include "AliLog.h" |
28 | ||
4347b38f | 29 | //____________________________________________________________________ |
1a1fdef7 | 30 | class TTree; |
4347b38f | 31 | class TClonesArray; |
4347b38f | 32 | class AliFMDDigit; |
33 | class AliRawReader; | |
af885e0f | 34 | class AliESDEvent; |
8f6ee336 | 35 | class AliESDFMD; |
818fff8d | 36 | class AliFMDRecoParam; |
9684be2f | 37 | class TH1; |
38 | ||
e802be3e | 39 | |
9f662337 | 40 | /** @defgroup FMD_rec Reconstruction */ |
4347b38f | 41 | //____________________________________________________________________ |
50b9d194 | 42 | /** |
43 | * @brief This is a class that reconstructs AliFMDRecPoint objects | |
44 | * from of Digits. | |
45 | * | |
46 | * This class reads either digits from a TClonesArray or raw data | |
47 | * from a DDL file (or similar), and applies calibrations to get | |
48 | * psuedo-inclusive multiplicities per strip. | |
49 | * | |
50 | * @ingroup FMD_rec | |
9f662337 | 51 | */ |
121a60bd | 52 | class AliFMDReconstructor: public AliReconstructor |
53 | { | |
4347b38f | 54 | public: |
50b9d194 | 55 | /** |
56 | * CTOR | |
57 | */ | |
4347b38f | 58 | AliFMDReconstructor(); |
50b9d194 | 59 | /** |
60 | * DTOR | |
61 | */ | |
56b1929b | 62 | virtual ~AliFMDReconstructor(); |
4347b38f | 63 | |
50b9d194 | 64 | /** |
65 | * Initialize the reconstructor. Here, we initialize the geometry | |
66 | * manager, and finds the local to global transformations from the | |
67 | * geometry. The calibration parameter manager is also | |
68 | * initialized (meaning that the calibration parameters is read | |
69 | * from CDB). | |
70 | */ | |
d76c31f4 | 71 | virtual void Init(); |
50b9d194 | 72 | /** |
73 | * Flag that we can convert raw data into digits. | |
74 | * | |
75 | * @return always @c true | |
76 | */ | |
1a1fdef7 | 77 | virtual Bool_t HasDigitConversion() const { return kTRUE; } |
50b9d194 | 78 | /** |
79 | * Convert raw data read from the AliRawReader @a reader into | |
80 | * digits. This is done using AliFMDRawReader and | |
81 | * AliFMDAltroReader. The digits are put in the passed TTree @a | |
82 | * digitsTree. | |
83 | * | |
84 | * @param reader Raw reader. | |
85 | * @param digitsTree Tree to store read digits in. | |
86 | */ | |
1a1fdef7 | 87 | virtual void ConvertDigits(AliRawReader* reader, TTree* digitsTree) const; |
50b9d194 | 88 | /** |
89 | * Reconstruct one event from the digits passed in @a digitsTree. | |
90 | * The member function creates AliFMDRecPoint objects and stores | |
91 | * them on the output tree @a clusterTree. An FMD ESD object is | |
92 | * created in parallel. | |
93 | * | |
94 | * @param digitsTree Tree holding the digits of this event | |
95 | * @param clusterTree Tree to store AliFMDRecPoint objects in. | |
96 | */ | |
1a1fdef7 | 97 | virtual void Reconstruct(TTree* digitsTree, TTree* clusterTree) const; |
50b9d194 | 98 | /** |
99 | * Not used | |
100 | * @todo Implement this, such that we'll reconstruct directly from | |
101 | * the read ADC values rather than going via an intermedant | |
102 | * TClonesArray of AliFMDDigits | |
103 | */ | |
ddaa8027 | 104 | virtual void Reconstruct(AliRawReader *, TTree*) const; |
50b9d194 | 105 | /** |
106 | * Put in the ESD data, the FMD ESD data. The object created by | |
107 | * the Reconstruct member function is copied to the ESD object. | |
108 | * | |
109 | * @param digitsTree Tree of digits for this event - not used | |
110 | * @param clusterTree Tree of reconstructed points for this event - | |
111 | * not used. | |
112 | * @param esd ESD object to store data in. | |
113 | */ | |
1a1fdef7 | 114 | virtual void FillESD(TTree* digitsTree, TTree* clusterTree, |
af885e0f | 115 | AliESDEvent* esd) const; |
50b9d194 | 116 | /** |
117 | * Forwards to above member function | |
118 | */ | |
ddaa8027 | 119 | virtual void FillESD(AliRawReader*, TTree* clusterTree, |
120 | AliESDEvent* esd) const; | |
faf80567 | 121 | |
122 | /** | |
123 | * Create SDigits from raw data | |
124 | * | |
125 | * @param reader The raw reader | |
126 | * @param sdigits Array to fill with AliFMDSDigit objects. | |
127 | */ | |
128 | virtual void Digitize(AliRawReader* reader, | |
129 | TClonesArray* sdigits) const; | |
130 | ||
50b9d194 | 131 | /** |
132 | * Not used | |
133 | */ | |
af885e0f | 134 | virtual void SetESD(AliESDEvent* esd) { fESD = esd; } |
50b9d194 | 135 | /** |
136 | * Set the noise factor | |
137 | * | |
138 | * @param f Factor to use | |
139 | */ | |
a9579262 | 140 | virtual void SetNoiseFactor(Float_t f=3) { fNoiseFactor = f; } |
50b9d194 | 141 | /** |
142 | * Set whether we should do angle correction or nor | |
143 | * | |
144 | * @param use If true, do angle correction | |
145 | */ | |
a9579262 | 146 | virtual void SetAngleCorrect(Bool_t use=kTRUE) { fAngleCorrect = use; } |
50b9d194 | 147 | /** |
148 | * Set whether we want to do diagnostics. If this is enabled, a | |
149 | * file named @c FMD.Diag.root will be made. It contains a set of | |
150 | * histograms for each event, filed in separate directories in the | |
151 | * file. The histograms are | |
152 | * @verbatim | |
153 | * diagStep1 Read ADC vs. Noise surpressed ADC | |
154 | * diagStep2 Noise surpressed ADC vs. calculated Energy dep. | |
155 | * diagStep3 Energy deposition vs. angle corrected Energy dep. | |
156 | * diagStep4 Energy deposition vs. calculated multiplicity | |
157 | * diagAll Read ADC vs. calculated multiplicity | |
158 | * @endverbatim | |
159 | * | |
160 | * @param use If true, make the diagnostics file | |
161 | */ | |
9684be2f | 162 | void SetDiagnose(Bool_t use=kTRUE) { fDiagnostics = use; } |
3d7ed4ed | 163 | |
4347b38f | 164 | protected: |
50b9d194 | 165 | /** |
166 | * Copy CTOR | |
167 | * | |
168 | * @param other Object to copy from. | |
169 | */ | |
3abc001d | 170 | AliFMDReconstructor(const AliFMDReconstructor&); //Not implemented |
50b9d194 | 171 | /** |
172 | * Assignment operator | |
173 | * | |
174 | * @param other Object to assign from | |
175 | * | |
176 | * @return reference to this object | |
177 | */ | |
3abc001d | 178 | AliFMDReconstructor& operator=(const AliFMDReconstructor&); //Not implemented |
50b9d194 | 179 | /** |
180 | * Try to get the vertex from either ESD or generator header. Sets | |
181 | * @c fCurrentVertex to the found Z posistion of the vertex (if | |
182 | * found), and sets the flag @c fVertexType accordingly | |
8983e5ae | 183 | * |
184 | * @param esd ESD structure to get Vz from | |
50b9d194 | 185 | */ |
8983e5ae | 186 | virtual void GetVertex(AliESDEvent* esd) const; |
50b9d194 | 187 | /** |
188 | * Process AliFMDDigit objects in @a digits. For each digit, find | |
189 | * the psuedo-rapidity @f$ \eta@f$, azimuthal angle @f$ \varphi@f$, | |
190 | * energy deposited @f$ E@f$, and psuedo-inclusive multiplicity @f$ | |
191 | * M@f$. | |
192 | * | |
193 | * @param digits Array of digits. | |
194 | */ | |
e802be3e | 195 | virtual void ProcessDigits(TClonesArray* digits) const; |
50b9d194 | 196 | /** |
197 | * Process a single digit | |
198 | * | |
199 | * @param digit Digiti to process | |
200 | */ | |
201 | virtual void ProcessDigit(AliFMDDigit* digit) const; | |
202 | /** | |
203 | * Process the signal from a single strip. | |
204 | * | |
205 | * @param det Detector number | |
206 | * @param rng Ring identifier | |
207 | * @param sec Sector number | |
208 | * @param str Strip number | |
209 | * @param adc Number of ADC counts for this strip | |
210 | */ | |
211 | virtual void ProcessSignal(UShort_t det, | |
212 | Char_t rng, | |
213 | UShort_t sec, | |
214 | UShort_t str, | |
215 | Short_t adc) const; | |
faf80567 | 216 | /** |
217 | * Process the signal from a single strip. | |
218 | * | |
219 | * @param sdigits Array to fill | |
220 | * @param det Detector number | |
221 | * @param rng Ring identifier | |
222 | * @param sec Sector number | |
223 | * @param str Strip number | |
224 | * @param sam Sample number | |
225 | * @param adc Number of ADC counts for this strip | |
226 | */ | |
227 | virtual void DigitizeSignal(TClonesArray* sdigits, | |
228 | UShort_t det, | |
229 | Char_t rng, | |
230 | UShort_t sec, | |
231 | UShort_t str, | |
232 | UShort_t sam, | |
233 | Short_t adc) const; | |
234 | /** | |
235 | * Subtract the pedestal off the ADC counts. | |
236 | * | |
237 | * @param det Detector number | |
238 | * @param rng Ring identifier | |
239 | * @param sec Sector number | |
240 | * @param str Strip number | |
241 | * @param adc ADC counts | |
242 | * @param noiseFactor If pedestal substracted pedestal is less then | |
243 | * this times the noise, then consider this to be 0. | |
244 | * @param zsEnabled Whether zero-suppression is on. | |
245 | * @param zsNoiseFactor Noise factor used in on-line pedestal | |
246 | * subtraction. | |
247 | * | |
248 | * @return The pedestal subtracted ADC counts (possibly 0), or @c | |
249 | * USHRT_MAX in case of problems. | |
250 | */ | |
251 | virtual UShort_t SubtractPedestal(UShort_t det, | |
252 | Char_t rng, | |
253 | UShort_t sec, | |
254 | UShort_t str, | |
255 | UShort_t adc, | |
256 | Float_t noiseFactor, | |
257 | Bool_t zsEnabled, | |
258 | UShort_t zsNoiseFactor) const; | |
50b9d194 | 259 | /** |
260 | * Substract pedestals from raw ADC in @a digit | |
261 | * | |
262 | * @param det Detector number | |
263 | * @param rng Ring identifier | |
264 | * @param sec Sector number | |
265 | * @param str Strip number | |
266 | * @param adc Number of ADC counts | |
267 | * | |
268 | * @return Pedestal subtracted ADC count. | |
269 | */ | |
270 | virtual UShort_t SubtractPedestal(UShort_t det, | |
271 | Char_t rng, | |
272 | UShort_t sec, | |
273 | UShort_t str, | |
274 | Short_t adc) const; | |
275 | /** | |
276 | * Converts number of ADC counts to energy deposited. This is | |
277 | * done by | |
278 | * @f[ | |
279 | * E_i = A_i g_i | |
280 | * @f] | |
281 | * where @f$ A_i@f$ is the pedestal subtracted ADC counts, and @f$ | |
282 | * g_i@f$ is the gain for the @f$ i^{\mbox{th}}@f$ strip. | |
283 | * | |
284 | * @param det Detector number | |
285 | * @param rng Ring identifier | |
286 | * @param sec Sector number | |
287 | * @param str Strip number | |
288 | * @param eta Psuedo-rapidity of digit. | |
289 | * @param count Pedestal subtracted ADC counts | |
290 | * | |
291 | * @return Energy deposited @f$ E_i@f$ | |
292 | */ | |
faf80567 | 293 | virtual Float_t Adc2Energy(UShort_t det, |
294 | Char_t rng, | |
295 | UShort_t sec, | |
296 | UShort_t str, | |
297 | UShort_t count) const; | |
298 | /** | |
299 | * Converts number of ADC counts to energy deposited. This is | |
300 | * done by | |
301 | * @f[ | |
302 | * E_i = A_i g_i | |
303 | * @f] | |
304 | * where @f$ A_i@f$ is the pedestal subtracted ADC counts, and @f$ | |
305 | * g_i@f$ is the gain for the @f$ i^{\mbox{th}}@f$ strip. | |
306 | * | |
307 | * @param det Detector number | |
308 | * @param rng Ring identifier | |
309 | * @param sec Sector number | |
310 | * @param str Strip number | |
311 | * @param eta Psuedo-rapidity of digit. | |
312 | * @param count Pedestal subtracted ADC counts | |
313 | * | |
314 | * @return Energy deposited @f$ E_i@f$ | |
315 | */ | |
50b9d194 | 316 | virtual Float_t Adc2Energy(UShort_t det, |
317 | Char_t rng, | |
318 | UShort_t sec, | |
319 | UShort_t str, | |
320 | Float_t eta, | |
8f6ee336 | 321 | UShort_t count) const; |
50b9d194 | 322 | /** |
323 | * Converts an energy signal to number of particles. In this | |
324 | * implementation, it's done by | |
325 | * @f[ | |
326 | * M_i = E_i / E_{\mbox{MIP}} | |
327 | * @f] | |
328 | * where @f$ E_i@f$ is the energy deposited, and | |
329 | * @f$ E_{\mbox{MIP}}@f$ is the average energy deposited by a | |
330 | * minimum ionizing particle | |
331 | * | |
332 | * @param det Detector number | |
333 | * @param rng Ring identifier | |
334 | * @param sec Sector number | |
335 | * @param str Strip number | |
336 | * @param eta On return, psuedo-rapidity @f$ \eta@f$ | |
337 | * @param phi On return, azimuthal angle @f$ \varphi@f$ | |
338 | * @param edep Energy deposited @f$ E_i@f$ | |
339 | * | |
340 | * @return Psuedo-inclusive multiplicity @f$ M@f$ | |
341 | */ | |
342 | virtual Float_t Energy2Multiplicity(UShort_t det, | |
343 | Char_t rng, | |
344 | UShort_t sec, | |
345 | UShort_t str, | |
346 | Float_t edep) const; | |
347 | /** | |
348 | * Calculate the physical coordinates psuedo-rapidity @f$ \eta@f$, | |
349 | * azimuthal angle @f$ \varphi@f$ of the strip corresponding to | |
350 | * the digit @a digit. This is done by using the information | |
351 | * obtained, and previously cached by AliFMDGeometry, from the | |
352 | * TGeoManager. | |
353 | * | |
354 | * @param det Detector number | |
355 | * @param rng Ring identifier | |
356 | * @param sec Sector number | |
357 | * @param str Strip number | |
358 | * @param eta On return, psuedo-rapidity @f$ \eta@f$ | |
359 | * @param phi On return, azimuthal angle @f$ \varphi@f$ | |
360 | */ | |
361 | virtual void PhysicalCoordinates(UShort_t det, | |
362 | Char_t rng, | |
363 | UShort_t sec, | |
364 | UShort_t str, | |
365 | Float_t& eta, | |
8f6ee336 | 366 | Float_t& phi) const; |
75609cab | 367 | /** |
368 | * Mark dead channels as invalid, and those that are marked as invalid | |
369 | * but are not dead, get the zero signal. | |
370 | * | |
371 | * @param esd ESD object to modify. | |
372 | */ | |
373 | void MarkDeadChannels(AliESDFMD* esd) const; | |
374 | ||
818fff8d | 375 | /** |
376 | * Set-up reconstructor to use values from reconstruction | |
377 | * parameters, if present, for this event. If the argument @a set | |
378 | * is @c false, then restore preset values. | |
379 | * | |
380 | * @param set | |
381 | */ | |
382 | virtual void UseRecoParam(Bool_t set=kTRUE) const; | |
383 | /** | |
384 | * Utility member function to get the reconstruction parameters for | |
385 | * this event | |
386 | * | |
387 | * @return Pointer to AliFMDRecoParam object or null if not | |
388 | * available. | |
389 | */ | |
390 | const AliFMDRecoParam* GetParameters() const; | |
391 | /** | |
392 | * Get the numeric identifier of this detector | |
393 | * | |
394 | * @return Should be 12 | |
395 | */ | |
396 | Int_t GetIdentifier() const; | |
9684be2f | 397 | enum Vertex_t { |
398 | kNoVertex, // Got no vertex | |
399 | kGenVertex, // Got generator vertex | |
400 | kESDVertex // Got ESD vertex | |
401 | }; | |
8f6ee336 | 402 | mutable TClonesArray* fMult; // Cache of RecPoints |
403 | mutable Int_t fNMult; // Number of entries in fMult | |
404 | mutable TTree* fTreeR; // Output tree | |
e802be3e | 405 | mutable Float_t fCurrentVertex; // Z-coordinate of primary vertex |
8f6ee336 | 406 | mutable AliESDFMD* fESDObj; // ESD output object |
818fff8d | 407 | mutable Float_t fNoiseFactor; // Factor of noise to check |
408 | mutable Bool_t fAngleCorrect; // Whether to angle correct | |
9684be2f | 409 | mutable Vertex_t fVertexType; // What kind of vertex we got |
af885e0f | 410 | AliESDEvent* fESD; // ESD object(?) |
9684be2f | 411 | Bool_t fDiagnostics; // Wheter to do diagnostics |
412 | TH1* fDiagStep1; // Diagnostics histogram | |
413 | TH1* fDiagStep2; // Diagnostics histogram | |
414 | TH1* fDiagStep3; // Diagnostics histogram | |
415 | TH1* fDiagStep4; // Diagnostics histogram | |
416 | TH1* fDiagAll; // Diagnostics histogram | |
5cf05dbb | 417 | mutable Bool_t fZS[3]; // Zero-suppredded? |
418 | mutable UShort_t fZSFactor[3]; // Noise factor for Zero-suppression | |
02a27b50 | 419 | private: |
d76c31f4 | 420 | |
421 | ClassDef(AliFMDReconstructor, 3) // class for the FMD reconstruction | |
121a60bd | 422 | }; |
423 | #endif | |
4347b38f | 424 | //____________________________________________________________________ |
425 | // | |
0d0e6995 | 426 | // Local Variables: |
427 | // mode: C++ | |
428 | // End: | |
429 | // | |
4347b38f | 430 | // EOF |
431 | // |