Fix to avoid deleting cached CDB objects - modified fix by Peter.
[u/mrichter/AliRoot.git] / FMD / AliFMDRawReader.h
1 #ifndef ALIFMDRAWREADER_H
2 #define ALIFMDRAWREADER_H
3 /* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights
4  * reserved. 
5  *
6  * Latest changes by Christian Holm Christensen <cholm@nbi.dk>
7  *
8  * See cxx source for full Copyright notice                               
9  */
10 //____________________________________________________________________
11 // 
12 // Class to read ADC values from a AliRawReader object. 
13 // Note, that it uses an ALTRO reader, which is wrong. 
14 // Perhaps we need to implement it our selves
15 // 
16 /* $Id$ */
17 /** @file    AliFMDRawReader.h
18     @author  Christian Holm Christensen <cholm@nbi.dk>
19     @date    Mon Mar 27 12:45:23 2006
20     @brief   Class to read raw data 
21     @ingroup FMD_rec
22 */
23 #ifndef ROOT_TTask
24 # include <TTask.h>
25 #endif
26 #include "AliFMDUShortMap.h"
27
28 //____________________________________________________________________
29 class AliRawReader;
30 class AliAltroRawStreamV3;
31 class TTree;
32 class TClonesArray;
33 class TArrayS;
34 class AliFMDCalibSampleRate;
35 class AliFMDCalibStripRange;
36 class AliFMDUShortMap;
37
38 //____________________________________________________________________
39 /** @brief Class to read ALTRO formated raw data from an AliRawReader
40     object. 
41     @code 
42     AliRawReader*    reader    = new AliRawReaderFile(0);
43     AliFMDRawReader* fmdReader = new AliFMDRawReader(reader);
44     TClonesArray*    array     = new TClonesArray("AliFMDDigit");
45     fmdReader->ReadAdcs(array);
46     @endcode 
47     @ingroup FMD_rec
48 */
49 class AliFMDRawReader : public TTask 
50 {
51 public:
52   /** Number of possible DDLs */
53   enum { 
54     kNDDL = 3
55   };
56   enum { 
57     kBadSignal = 0x7FFF // Largest signed 16bit short integer
58   };
59   /** 
60    * CTOR 
61    *
62    * @param reader Raw reader
63    * @param array  Output tree 
64    */
65   AliFMDRawReader(AliRawReader* reader, TTree* array);
66   /** 
67    * DTOR 
68    */
69   virtual ~AliFMDRawReader() {}
70   /** 
71    * Read in, and store in output tree 
72    *
73    * @param option Not used 
74    */
75   virtual void   Exec(Option_t* option="");
76   /**
77    * Read ADC's into a TClonesArray of AliFMDDigit objects. 
78    *
79    * @param array       Array to read into 
80    * 
81    * @return @c true on success 
82    */
83   virtual Bool_t ReadAdcs(TClonesArray* array);
84   /** 
85    * Read ADCs into a unsigned short map. 
86    * 
87    * @param map Map to read into 
88    * 
89    * @return true on success 
90    */
91   virtual Bool_t ReadAdcs(AliFMDUShortMap& map);
92   /** 
93    * Read SOD event into passed objects.
94    * 
95    * @param samplerate   The sample rate object to fill
96    * @param striprange   The strip range object to fill
97    * @param pulseSize    The pulse size object to fill
98    * @param pulseLength  The pulse length (in events) object to fill
99    * 
100    * @return @c true on success
101    */  
102   virtual Bool_t ReadSODevent(AliFMDCalibSampleRate* samplerate, 
103                               AliFMDCalibStripRange* striprange, 
104                               TArrayS &pulseSize, 
105                               TArrayS &pulseLength, 
106                               Bool_t* detectors=0);
107   /** 
108    * Check of the data from DDL @a ddl is zero-suppressed
109    * 
110    * @param ddl DDL number (0-2)
111    * 
112    * @return @c true if the data from this DDL is zero-suppressed. 
113    */  
114   Bool_t IsZeroSuppressed(UShort_t ddl) const { return fZeroSuppress[ddl]; }
115   /** 
116    * The factor used to multiply the noise when making on-line
117    * pedestal subtraction.
118    * 
119    * @param ddl DDL number (0-2)
120    * 
121    * @return The factor used. 
122    */
123   UShort_t NoiseFactor(UShort_t ddl) const { return fNoiseFactor[ddl]; }
124
125   /** 
126    * Get the next signal
127    * 
128    * @param det  On return, the detector
129    * @param rng  On return, the ring
130    * @param sec  On return, the sector
131    * @param str  On return, the strip
132    * @param sam  On return, the sample
133    * @param rat  On return, the sample rate
134    * @param adc  On return, the ADC value
135    * @param zs   On return, whether zero-supp. is enabled
136    * @param fac  On return, the usd noise factor
137    * 
138    * @return 0 if there's no more data.  -1 if the read sample
139    * corresponds to a bad bunch in the channel.  Positive return
140    * values represent a bit mask of 
141    * - 0x1  New DDL 
142    * - 0x2  New Channel 
143    * - 0x4  New Bunch 
144    * - 0x8  New Sample 
145    */
146   Int_t NextSample(UShort_t& det, Char_t&   rng, UShort_t& sec, UShort_t& str,
147                     UShort_t& sam, UShort_t& rat, Short_t&  adc, 
148                     Bool_t&   zs,  UShort_t& fac);
149   /** 
150    * Get the next signal
151    * 
152    * @param det  On return, the detector
153    * @param rng  On return, the ring
154    * @param sec  On return, the sector
155    * @param str  On return, the strip
156    * @param adc  On return, the ADC value
157    * @param zs   On return, whether zero-supp. is enabled
158    * @param fac  On return, the usd noise factor
159    * 
160    * @return 0 if there's no more data.  -1 if the read sample
161    * corresponds to a bad bunch in the channel.  Positive return
162    * values represent a bit mask of 
163    * - 0x1  New DDL 
164    * - 0x2  New Channel 
165    * - 0x4  New Bunch 
166    * - 0x8  New Sample 
167    */
168   Int_t NextSignal(UShort_t& det, Char_t&   rng, 
169                    UShort_t& sec, UShort_t& str, 
170                    Short_t&  adc, Bool_t&   zs, 
171                    UShort_t& fac);
172   /** 
173    * Get number of read-out errors.  Note, that a channel marked as
174    * bad counts as 10 errors 
175    * 
176    * @param ddl DDL off set ([0,kNDDL-1])
177    * 
178    * @return Number of seen errors 
179    */
180   UShort_t GetNErrors(UShort_t ddl) const {return (ddl >= kNDDL ? 0 : fNErrors[ddl]);}
181   /** 
182    * Get the phase of the L1 signal 
183    * 
184    * @param ddl DDL number ([0,kNDDL-1])
185    * 
186    * @return Phase of the L1 signal in steps of 25ns. 
187    */
188   UShort_t GetL1Phase(UShort_t ddl) const {return (ddl >= kNDDL ? -1 : fL1Phase[ddl]);}
189   /** 
190    * Whether to keep a sample based on the rate used. 
191    * 
192    * @param samp Sample number 
193    * @param rate Over sampling rate
194    * 
195    * @return Whether to keep the sample or not
196    */
197   static Bool_t SelectSample(UShort_t samp, UShort_t rate);
198 protected:
199   /** 
200    * Copy constructor 
201    * 
202    * @param o Object to construct from
203    */  
204   AliFMDRawReader(const AliFMDRawReader& o) 
205     : TTask(o), 
206       fTree(0), 
207       fReader(0), 
208       fData(0),
209       fNbytes(0), 
210       fMinStrip(0), 
211       fMaxStrip(127),
212       fPreSamp(14+5),
213       fSeen(0)
214   {}
215   /** 
216    * Assignment operator
217    * 
218    * @return Reference to this object
219    */
220   AliFMDRawReader& operator=(const AliFMDRawReader&) { return *this; }
221   /** 
222    * Process a new DDL.  Sets the internal data members fZeroSuppress, 
223    * fSampleRate, and fNoiseFactor based on information in the RCU trailer. 
224    * 
225    * @param input Input stream
226    * @param det   On return, the detector number
227    * 
228    * @return negative value in case of problems, the DDL number otherwise
229    */
230   Int_t NewDDL(AliAltroRawStreamV3& input, UShort_t& det);
231   /** 
232    * Processs a new channel.  Sets the internal data members
233    * fMinStrip, fMaxStrip, and fPreSamp. 
234    * 
235    * @param input   Input stream
236    * @param det     Detector number
237    * @param ring    On return, the ring identifier 
238    * @param sec     On return, the sector number
239    * @param strbase On return, the strip base
240    * 
241    * @return negative value in case of problems, hardware address otherwise
242    */
243   Int_t NewChannel(const AliAltroRawStreamV3& input, 
244                    UShort_t det, Char_t&  ring, 
245                    UShort_t& sec, Short_t& strbase);
246   /** 
247    * Process a new bunch.
248    * 
249    * @param input    Input stream
250    * @param start    On input, the old start time. On return, the start time
251    * @param length   On return, the bunch length
252    * 
253    * @return true on success, false otherwise 
254    */
255   Bool_t NewBunch(const AliAltroRawStreamV3& input, 
256                   UShort_t&  start, UShort_t& length);
257   /** 
258    * Process a new timebin
259    * 
260    * @param input   Input stream
261    * @param i       Index into bunch data
262    * @param t       Time
263    * @param sec     Sector number
264    * @param strbase Base of strip numbers for this channel
265    * @param str     On return, the strip number
266    * @param samp    On return, the sample number
267    * 
268    * @return negative value in case of problems, ADC value otherwise
269    */  
270   Int_t NewSample(const AliAltroRawStreamV3& input, 
271                   Int_t i, UShort_t t, UShort_t sec,
272                   UShort_t  strbase, Short_t&  str, UShort_t& samp);
273
274   /** 
275    * 
276    * Get the number of words 
277    * 
278    * @return Number of 32bit words 
279    */
280   ULong_t GetNwords() const {return fNbytes / 4;}
281   /** 
282    * Get the next 32bit word from payload
283    * 
284    * @param idx Which 32bit word to get
285    * 
286    * @return 
287    */
288   UInt_t Get32bitWord(Int_t idx);
289   /** 
290    * Get short index for a given half-ring
291    * 
292    * @param det   Detector number
293    * @param ring  Ring identifer
294    * @param board Board number
295    * 
296    * @return 
297    */
298   Int_t GetHalfringIndex(UShort_t det, Char_t ring, UShort_t board) const;
299   TTree*          fTree;             //! Pointer to tree to read into 
300   AliRawReader*   fReader;           //! Pointer to raw reader 
301   UShort_t        fSampleRate[kNDDL];// The sample rate (if 0,infer from data)
302   UChar_t*        fData;             // Data pointer
303   ULong_t         fNbytes;           // Number of bytes
304   Bool_t          fZeroSuppress[kNDDL]; // Zero suppression flag
305   UShort_t        fNoiseFactor[kNDDL];  // Noise factor 
306   UShort_t        fMinStrip;        // Current minimum strip number (0)
307   UShort_t        fMaxStrip;        // Current maximum strip number (127)
308   UShort_t        fPreSamp;         // Current number of pre-samples (14+5)
309   AliFMDUShortMap fSeen;            // Seen strips 
310   UShort_t        fNErrors[kNDDL];  // Number of errors per DDL
311   UShort_t        fL1Phase[kNDDL];  // Number of errors per DDL
312   
313   ClassDef(AliFMDRawReader, 0) // Read FMD raw data into a cache 
314 };
315
316 #endif
317 //____________________________________________________________________
318 //
319 // Local Variables:
320 //   mode: C++
321 // End:
322 //
323 // EOF
324 //
325