]>
Commit | Line | Data |
---|---|---|
46b33a24 | 1 | // @(#) $Id$ |
2 | ||
3 | #ifndef ALIHLTPAD_H | |
4 | #define ALIHLTPAD_H | |
5 | /* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. * | |
6 | * See cxx source for full Copyright notice */ | |
7 | ||
8 | /** @file AliHLTTPCPad.h | |
9 | @author Matthias Richter | |
10 | @date | |
11 | @brief Container Class for TPC Pads. | |
12 | */ | |
13 | ||
14 | #include "AliHLTLogging.h" | |
15 | ||
16 | typedef Int_t AliHLTTPCSignal_t; | |
17 | ||
18 | /** | |
19 | * @class AliHLTTPCPad | |
20 | * The class is a container for the raw ADC data of one TPCS pad. In order to | |
21 | * avoid multiple unpacking/handling of the incoming raw data, the class holds | |
22 | * a copy of the incoming data for one event. The copy is released when the | |
23 | * end of the event was announced. | |
24 | * The class calculates the base line of a TPC channel. Currently, only the | |
25 | * average value is calculated, but further extension will include channel by | |
26 | * channel histograming. The baseline history is kept and used for baseline | |
27 | * re-evaluation and correction of subsequent events. | |
28 | * @ingroup alihlt_tpc | |
29 | */ | |
30 | class AliHLTTPCPad : public AliHLTLogging { | |
31 | public: | |
32 | /** standard constructor */ | |
33 | AliHLTTPCPad(); | |
34 | ||
35 | /** | |
36 | * Constructor | |
37 | * @param offset The number of bins to ignore at the beginning | |
38 | * of the channels | |
39 | * @param nofBins The total number of bins for one channel | |
40 | */ | |
41 | AliHLTTPCPad(Int_t offset, Int_t nofBins); | |
42 | ||
43 | /** not a valid copy constructor, defined according to effective C++ style */ | |
44 | AliHLTTPCPad(const AliHLTTPCPad&); | |
45 | /** not a valid assignment op, but defined according to effective C++ style */ | |
46 | AliHLTTPCPad& operator=(const AliHLTTPCPad&); | |
47 | /** standard destructor */ | |
48 | virtual ~AliHLTTPCPad(); | |
49 | ||
50 | /** | |
51 | * Set the address the pad. | |
52 | * The address consists of row and pad number. | |
53 | * @param rowno The row number | |
54 | * @param padno The pad number. | |
55 | */ | |
56 | Int_t SetID(Int_t rowno, Int_t padno); | |
57 | ||
58 | /** | |
59 | * Get the row number. | |
60 | */ | |
61 | Int_t GetRowNumber() const {return fRowNo;} | |
62 | ||
63 | /** | |
64 | * Get the pad number. | |
65 | */ | |
66 | Int_t GetPadNumber() const {return fPadNo;} | |
67 | ||
68 | /** | |
69 | * Start accumulation for a new event. | |
70 | * The class holds internally a history of the event data. The data can | |
71 | * be fetched from the class without unpacking the input stream again. | |
72 | * @return neg. error value if failed | |
73 | * - ENOMEM memory allocation failed | |
74 | * - EALREADY event data acquisition already started | |
75 | */ | |
76 | Int_t StartEvent(); | |
77 | ||
78 | /** | |
79 | * Check whether the event is started | |
80 | * @return 1 if started, 0 if not | |
81 | */ | |
82 | Int_t IsStarted() const { return fpRawData!=NULL;}; | |
83 | ||
84 | /** | |
85 | * Calculate the base line from the current event data. | |
86 | * Only available within an event cycle. <br> | |
87 | * The calculation requires a minimum number of bins which contribute | |
88 | * to the sum, which can be specified by @param reqMinCount. The base line | |
89 | * calculation will also be skipped if the number of contributing bins is | |
90 | * less than half of the total number of time bins. | |
91 | * @param reqMinCount the minimum number of bins contributing to the sum | |
92 | * @return neg. error value if failed | |
93 | * - ENODATA to little contributing bins | |
94 | * - ENOBUFS no raw data available | |
95 | */ | |
96 | Int_t CalculateBaseLine(Int_t reqMinCount=1); | |
97 | ||
98 | /** | |
99 | * Stop processing of one event. | |
100 | * The data history of the event will be released. | |
101 | * @return neg. error value if failed | |
102 | * - EBADF event not started | |
103 | */ | |
104 | Int_t StopEvent(); | |
105 | ||
106 | /** | |
107 | * Reset the base line history. | |
108 | * @return neg. error code if failed | |
109 | */ | |
110 | Int_t ResetHistory(); | |
111 | ||
112 | /** | |
113 | * Set threshold. | |
114 | * The threshold effects to corrected data, signals smaller than threshold | |
115 | * are suppressed. | |
116 | * @param thresh Threshold for signal correction | |
117 | * @return neg. error code if failed | |
118 | */ | |
119 | Int_t SetThreshold(AliHLTTPCSignal_t thresh); | |
120 | ||
121 | /** | |
122 | * Set the raw data value of a certain channel. | |
123 | * @param bin Channel number | |
124 | * @param value ADC value | |
125 | * @return neg. error value if failed | |
126 | * - ERANGE bin out of range | |
127 | * - BADF event cycle not started | |
128 | */ | |
129 | Int_t SetRawData(Int_t bin, AliHLTTPCSignal_t value); | |
130 | ||
131 | /** | |
132 | * Get the raw data value of the current bin. | |
133 | * The class holds the current read position which can be incremented by | |
134 | * @ref Next() and reseted by @ref Rewind(). | |
135 | * Raw data is only available within an event cycle. | |
136 | * @return raw data value | |
137 | */ | |
138 | AliHLTTPCSignal_t GetRawData() const {return GetRawData(fReadPos);} | |
139 | ||
140 | /** | |
141 | * Get the corrected data value the current bin. | |
142 | * Corrected raw data is only available within an event cycle. | |
143 | * The base line value is substracted from the bin's value and suppressed | |
144 | * by the threshold. Bins smaller than the first bin considered for base | |
145 | * line calculation return 0. | |
146 | * The class holds the current read position which can be incremented by | |
147 | * @ref Next() and reseted by @ref Rewind(). | |
148 | * @return corrected value | |
149 | */ | |
150 | AliHLTTPCSignal_t GetCorrectedData() const {return GetCorrectedData(fReadPos);} | |
151 | ||
152 | /** | |
153 | * Increment the read position. | |
154 | * @param bZeroSuppression skip all bins effected by the zero suppression | |
155 | * @return 1 if more data available, 0 if not | |
156 | */ | |
157 | Int_t Next(Int_t bZeroSuppression=kTRUE); | |
158 | ||
159 | /** | |
160 | * Rewind the read position. | |
161 | * The read position is set to the first bin over the zero suppression. | |
162 | * @param bZeroSuppression skip all bins effected by the zero suppression | |
163 | * @return 1 if more data available, 0 if not | |
164 | */ | |
165 | Int_t Rewind(Int_t bZeroSuppression=kTRUE); | |
166 | ||
167 | /** | |
168 | * Get the current read position. | |
169 | * @return read position, -1 if no data available | |
170 | */ | |
171 | Int_t GetCurrentPosition() const {return fReadPos<fNofBins?fReadPos:-1;} | |
172 | ||
173 | /** | |
174 | * Get the raw data value of a certain bin. | |
175 | * Raw data is only available within an event cycle. | |
176 | * @param bin Channel number | |
177 | * @return raw data value | |
178 | */ | |
179 | AliHLTTPCSignal_t GetRawData(Int_t bin) const; | |
180 | ||
181 | /** | |
182 | * Get the corrected data value of a certain bin. | |
183 | * Corrected raw data is only available within an event cycle. | |
184 | * The base line value is substracted from the bin's value and suppressed | |
185 | * by the threshold. Bins smaller than the first bin considered for base | |
186 | * line calculation return 0. | |
187 | * @param bin Channel number | |
188 | * @return corrected value | |
189 | */ | |
190 | AliHLTTPCSignal_t GetCorrectedData(Int_t bin) const; | |
191 | ||
192 | /** | |
193 | * Get the base line value of a certain channel. | |
194 | * @param bin Channel number | |
195 | * @param base line value at bin | |
196 | */ | |
197 | AliHLTTPCSignal_t GetBaseLine(Int_t bin) const; | |
198 | ||
199 | /** | |
200 | * Get the avarage base line value. | |
201 | * @return average base line value | |
202 | */ | |
203 | AliHLTTPCSignal_t GetAverage() const; | |
204 | ||
205 | /** | |
206 | * Get the size (number of time bins) of the pad | |
207 | * @return number of bins | |
208 | */ | |
209 | Int_t GetSize() const {return fNofBins;} | |
210 | ||
211 | private: | |
212 | /** | |
213 | * Add a value to the base line calculation. | |
214 | * The value is been added to the sum if it exceeds the current base line | |
215 | * and bin is equal or greater than the first bin for base line calculation. | |
216 | * @param bin Channel number | |
217 | * @param value ADC value | |
218 | */ | |
219 | Int_t AddBaseLineValue(Int_t bin, AliHLTTPCSignal_t value); | |
220 | ||
221 | /** The row number of the pad */ | |
222 | Int_t fRowNo; | |
223 | /** The pad number of the pad */ | |
224 | Int_t fPadNo; | |
225 | /** Threshold for zero suppression */ | |
226 | AliHLTTPCSignal_t fThreshold; | |
227 | /** The average base line value */ | |
228 | AliHLTTPCSignal_t fAverage; | |
229 | /** Number of events included in the base line calculation*/ | |
230 | Int_t fNofEvents; | |
231 | /** The sum within one event */ | |
232 | AliHLTTPCSignal_t fSum; | |
233 | /** The number of bins contributing to the sum */ | |
234 | Int_t fCount; | |
235 | /** The total number of bins already set during the event */ | |
236 | Int_t fTotal; | |
237 | /** The maximum base line value within one event */ | |
238 | AliHLTTPCSignal_t fBLMax; | |
239 | /** The bin for the maximum bl value within one event */ | |
240 | Int_t fBLMaxBin; | |
241 | /** The first bin included in the base line calculation */ | |
242 | Int_t fFirstBLBin; | |
243 | /** Number of bins */ | |
244 | Int_t fNofBins; | |
245 | ||
246 | /** The current read position */ | |
247 | Int_t fReadPos; | |
248 | ||
249 | /** The raw data history */ | |
250 | AliHLTTPCSignal_t* fpRawData; | |
251 | ||
252 | ClassDef(AliHLTTPCPad, 0) | |
253 | }; | |
254 | #endif |