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