Line data Source code
1 : // -*- Mode: C++ -*-
2 : // $Id$
3 :
4 : #ifndef ALIHLTTPCPAD_H
5 : #define ALIHLTTPCPAD_H
6 : //* This file is property of and copyright by the ALICE HLT Project *
7 : //* ALICE Experiment at CERN, All rights reserved. *
8 : //* See cxx source for full Copyright notice *
9 :
10 : /// @file AliHLTTPCPad.h
11 : /// @author Matthias Richter
12 : /// @date
13 : /// @brief Container Class for TPC Pads.
14 : ///
15 :
16 : #include "AliHLTLogging.h"
17 : #include "AliHLTTPCClusters.h"
18 : #include "AliHLTTPCDigitReader.h"
19 : #include "TH1F.h"
20 : #include <vector>
21 :
22 : struct AliHLTTPCDigitData;
23 :
24 : typedef Int_t AliHLTTPCSignal_t;
25 :
26 :
27 : /**
28 : * @class AliHLTTPCPad
29 : * The class is a container for the raw ADC data of one TPCS pad. In order to
30 : * avoid multiple unpacking/handling of the incoming raw data, the class holds
31 : * a copy of the incoming data for one event. The copy is released when the
32 : * end of the event was announced.
33 : * The class calculates the base line of a TPC channel. Currently, only the
34 : * average value is calculated, but further extension will include channel by
35 : * channel histograming. The baseline history is kept and used for baseline
36 : * re-evaluation and correction of subsequent events.
37 : * @ingroup alihlt_tpc
38 : */
39 : class AliHLTTPCPad : public AliHLTLogging {
40 : public:
41 : /** standard constructor */
42 : AliHLTTPCPad();
43 :
44 : /**
45 : * Constructor
46 : * @param dummy dummy determines if one need the raw data. If a dummy number is given, the pad object will be initialized without using memory for raw data
47 : */
48 : AliHLTTPCPad(Int_t dummy);
49 :
50 : /**
51 : * Constructor
52 : * @param offset The number of bins to ignore at the beginning
53 : * of the channels
54 : * @param nofBins The total number of bins for one channel
55 : */
56 : AliHLTTPCPad(Int_t offset, Int_t nofBins);
57 :
58 : /** standard destructor */
59 : virtual ~AliHLTTPCPad();
60 :
61 :
62 : struct AliClusterData
63 : {
64 : UInt_t fTotalCharge; //tot charge of cluster
65 : UInt_t fPad; //pad value
66 : UInt_t fTime; //time value
67 : ULong64_t fPad2; //for error in XY direction
68 : ULong64_t fTime2; //for error in Z direction
69 : UInt_t fMean; //mean in time
70 : UInt_t fFlags; //different flags
71 : UInt_t fChargeFalling; //for deconvolution
72 : UInt_t fLastCharge; //for deconvolution
73 : UInt_t fLastMergedPad; //dont merge twice per pad
74 : };
75 :
76 : typedef struct AliClusterData AliClusterData; //!
77 :
78 :
79 : /**
80 : * Set the address the pad.
81 : * The address consists of row and pad number.
82 : * @param rowno The row number
83 : * @param padno The pad number.
84 : */
85 : Int_t SetID(Int_t rowno, Int_t padno);
86 :
87 : /**
88 : * Get the row number.
89 : * @return Row number
90 : */
91 0 : Int_t GetRowNumber() const {return fRowNo;}
92 :
93 : /**
94 : * Get the pad number on the row.
95 : * @return Pad number on row
96 : */
97 0 : Int_t GetPadNumber() const {return fPadNo;}
98 :
99 : /**
100 : * Start accumulation for a new event.
101 : * The class holds internally a history of the event data. The data can
102 : * be fetched from the class without unpacking the input stream again.
103 : * @return neg. error value if failed
104 : * - ENOMEM memory allocation failed
105 : * - EALREADY event data acquisition already started
106 : */
107 : Int_t StartEvent();
108 :
109 : /**
110 : * Check whether the event is started
111 : * @return 1 if started, 0 if not
112 : */
113 0 : Int_t IsStarted() const { return fpRawData!=NULL;};
114 :
115 : /**
116 : * Calculate the base line from the current event data.
117 : * Only available within an event cycle. <br>
118 : * The calculation requires a minimum number of bins which contribute
119 : * to the sum, which can be specified by \e reqMinCount. The base line
120 : * calculation will also be skipped if the number of contributing bins is
121 : * less than half of the total number of time bins.
122 : * @param reqMinCount the minimum number of bins contributing to the sum
123 : * @return neg. error value if failed
124 : * - ENODATA to little contributing bins
125 : * - ENOBUFS no raw data available
126 : */
127 : Int_t CalculateBaseLine(Int_t reqMinCount=1);
128 :
129 : /**
130 : * Stop processing of one event.
131 : * The data history of the event will be released.
132 : * @return neg. error value if failed
133 : * - EBADF event not started
134 : */
135 : Int_t StopEvent();
136 :
137 : /**
138 : * Reset the base line history.
139 : * @return neg. error code if failed
140 : */
141 : Int_t ResetHistory();
142 :
143 : /**
144 : * Set threshold.
145 : * The threshold effects to corrected data, signals smaller than threshold
146 : * are suppressed.
147 : * @param thresh Threshold for signal correction
148 : * @return neg. error code if failed
149 : */
150 : Int_t SetThreshold(AliHLTTPCSignal_t thresh);
151 :
152 : /**
153 : * Set the raw data value of a certain channel.
154 : * @param bin Channel number
155 : * @param value ADC value
156 : * @return neg. error value if failed
157 : * - ERANGE bin out of range
158 : * - BADF event cycle not started
159 : */
160 : Int_t SetRawData(Int_t bin, AliHLTTPCSignal_t value);
161 :
162 : /**
163 : * Get the raw data value of the current bin.
164 : * The class holds the current read position which can be incremented by
165 : * @ref Next() and reseted by @ref Rewind().
166 : * Raw data is only available within an event cycle.
167 : * @return raw data value
168 : */
169 0 : AliHLTTPCSignal_t GetRawData() const {return GetRawData(fReadPos);}
170 :
171 : /**
172 : * Get the corrected data value the current bin.
173 : * Corrected raw data is only available within an event cycle.
174 : * The base line value is substracted from the bin's value and suppressed
175 : * by the threshold. Bins smaller than the first bin considered for base
176 : * line calculation return 0.
177 : * The class holds the current read position which can be incremented by
178 : * @ref Next() and reseted by @ref Rewind().
179 : * @return corrected value
180 : */
181 0 : AliHLTTPCSignal_t GetCorrectedData() const {return GetCorrectedData(fReadPos);}
182 :
183 : /**
184 : * Increment the read position.
185 : * @param bZeroSuppression skip all bins effected by the zero suppression
186 : * @return 1 if more data available, 0 if not
187 : */
188 : Int_t Next(Int_t bZeroSuppression=kTRUE);
189 :
190 : /**
191 : * Rewind the read position.
192 : * The read position is set to the first bin over the zero suppression.
193 : * @param bZeroSuppression skip all bins effected by the zero suppression
194 : * @return 1 if more data available, 0 if not
195 : */
196 : Int_t Rewind(Int_t bZeroSuppression=kTRUE);
197 :
198 : /**
199 : * Get the current read position.
200 : * @return read position, -1 if no data available
201 : */
202 0 : Int_t GetCurrentPosition() const {return fReadPos<fNofBins?fReadPos:-1;}
203 :
204 : /**
205 : * Get the raw data value of a certain bin.
206 : * Raw data is only available within an event cycle.
207 : * @param bin Channel number
208 : * @return raw data value
209 : */
210 : AliHLTTPCSignal_t GetRawData(Int_t bin) const;
211 :
212 : /**
213 : * Get the corrected data value of a certain bin.
214 : * Corrected raw data is only available within an event cycle.
215 : * The base line value is substracted from the bin's value and suppressed
216 : * by the threshold. Bins smaller than the first bin considered for base
217 : * line calculation return 0.
218 : * @param bin Channel number
219 : * @return corrected value
220 : */
221 : AliHLTTPCSignal_t GetCorrectedData(Int_t bin) const;
222 :
223 : /**
224 : * Get the base line value of a certain channel.
225 : * @param bin Channel number
226 : * @return base line value at bin
227 : */
228 : AliHLTTPCSignal_t GetBaseLine(Int_t bin) const;
229 :
230 : /**
231 : * Get the avarage base line value.
232 : * @return average base line value
233 : */
234 : AliHLTTPCSignal_t GetAverage() const;
235 :
236 : /**
237 : * Get the occupancy for the pad in fractions of 1
238 : * The occupancy is calculated from the number of time bins with non zero data
239 : * after zero suppression.
240 : * @return occupancy in percent
241 : */
242 : Float_t GetOccupancy() const;
243 :
244 : /**
245 : * Get the occupancy average for the pad in fractions of 1
246 : * The occupancy is calculated from the number of time bins with non zero data
247 : * after zero suppression and averaged over all events.
248 : * @return occupancy in percent
249 : */
250 : Float_t GetAveragedOccupancy() const;
251 :
252 : /**
253 : * Get the size (number of time bins) of the pad
254 : * @return number of bins
255 : */
256 0 : Int_t GetSize() const {return fNofBins;}
257 :
258 : /*
259 : * Clears the vector of cluster candidates.
260 : */
261 : void ClearCandidates();
262 :
263 : /**
264 : * Set the data array to -1
265 : */
266 : void SetDataToDefault();
267 :
268 : /**
269 : * Stores the signal in the data array, stores the timebin number of the signal,
270 : * and increments a counter.
271 : * @param bin Timebin nuber of signal
272 : * @param signal Size of signal
273 : */
274 : void SetDataSignal(Int_t bin,Int_t signal);
275 :
276 : /**
277 : * Returns the signal in the specified bin
278 : * @param bin Timebin number
279 : * @return Signal in the given timebin
280 : */
281 : Int_t GetDataSignal(Int_t bin) const;
282 :
283 : /**
284 : * Zerosuppression where one can choose wether one want to cut on sigma(default 3) or a given adc threshold above baseline
285 : * It works like this: Finds the signals above baseline+threshold, it then looks to the right of the signals adding the
286 : * the signal below threshold but over the average. It stops when the adc value rises (since you should expect a fall)
287 : * or if the signal in that bin is below average. It now does the same thing to the left.
288 : * This is a very timeconsuming approach(but good), and will likely only be used only for cosmics and laser.
289 : * If you use sigma approach you can give as input n sigma or stick with default=3. For channels with very large signals
290 : * the (value-average)² is not calculated when value-average>50. This is due to sigma shooting sky high for only a few values.
291 : * The method is checked with 2006 cosmics data, and it looks good.
292 : * If you want to use the threshold approach you HAVE to set nSigma=-1 and threshold>0. For example: If you want all signals
293 : * 30 adc counts above threshold you should call the function like this: ZeroSuppress(-1,30)
294 : * @param nRMS Specify nRMS threshold
295 : * @param threshold Specify what adc threshold above average (remember to give nRMS=-1 if you want to use this approach)
296 : * @param reqMinPoint Required minimum number of points to do zerosuppression default AliHLTTPCTransform::GetNTimeBins/2 (1024/2).
297 : * @param beginTime Lowest timebin value. Gating grid causes some problems in the first timebins.
298 : * @param endTime Highest timebin value.
299 : * @param timebinsLeft Timebins to include left of the signals above threshold (to include tails)
300 : * @param timebinsRight Timebins to include right of the signals above threshold (to include tails)
301 : * @param valueBelowAverage The number of adc-counts below the average value. (sometimes there can be useful to also add some signals below average for your signals, especially when there is a lot of noise) It means that more of the tails of the signal is added.
302 : * @param speedup Do not the full zero suppression but terminate if it is clear wheter the channel has some signal or not.
303 : */
304 : void ZeroSuppress(Double_t nRMS,Int_t threshold,Int_t reqMinPoint,Int_t beginTime,Int_t endTime,Int_t timebinsLeft, Int_t timebinsRight, Int_t valueBelowAverage, bool speedup=false);
305 :
306 : /**
307 : * Bool method which returns the timein number of the first signal and number of consecutive signals, used together with GetPointer(bin) to access data
308 : * @param time Refernence to timebin number
309 : * @param bunchSize Refernence to number of consecutive signals
310 : * @return True if there are more signals
311 : */
312 : Bool_t GetNextGoodSignal(Int_t &time,Int_t &bunchSize);
313 :
314 : /**
315 : * Returns number of signals added
316 : * @return Number of signals
317 : */
318 0 : UInt_t GetNAddedSignals(){return fSizeOfSignalPositionArray;}
319 :
320 : /**
321 : * Returns the pointer to the first data signal
322 : * @param bin Timebin number
323 : * @return pointer to data signal in bin
324 : */
325 0 : UInt_t* GetPointer(Int_t bin){return (UInt_t*)&fDataSignals[bin]; }
326 :
327 : /**
328 : * Adds cluster candidate to the fClusterCandidates.
329 : */
330 : void AddClusterCandidate(const AliHLTTPCClusters& candidate);
331 :
332 : /**
333 : * Adds the digits belonging to the candidate.
334 : */
335 : void AddCandidateDigits(const vector<AliHLTTPCDigitData>& candidateDigits);
336 :
337 :
338 : /**
339 : * Returns the digit vector belonging to the candidate
340 : */
341 : vector<AliHLTTPCDigitData> *GetCandidateDigits(Int_t candidateIndex);
342 :
343 0 : void ClearCandidateDigits(){fCandidateDigitsVector.clear();}
344 :
345 : /**
346 : * Prints the raw data og this pad.
347 : */
348 : void PrintRawData();
349 :
350 : /**
351 : * Vector of cluster candidates
352 : */
353 : vector<AliHLTTPCClusters> fClusterCandidates; //! transient
354 :
355 : /**
356 : * Vector of used clustercandidates, used so one do not use candidates multiple times
357 : */
358 : vector<Int_t> fUsedClusterCandidates; //! transient
359 : Bool_t fSelectedPad; //! transient
360 : AliHLTUInt16_t fHWAddress; //! transient
361 :
362 : private:
363 : /** copy constructor prohibited */
364 : AliHLTTPCPad(const AliHLTTPCPad&);
365 : /** assignment operator prohibited */
366 : AliHLTTPCPad& operator=(const AliHLTTPCPad&);
367 :
368 : /**
369 : * Add a value to the base line calculation.
370 : * The value is been added to the sum if it exceeds the current base line
371 : * and bin is equal or greater than the first bin for base line calculation.
372 : * @param bin Channel number
373 : * @param value ADC value
374 : */
375 : Int_t AddBaseLineValue(Int_t bin, AliHLTTPCSignal_t value);
376 :
377 : /** The row number of the pad */
378 : Int_t fRowNo; // see above
379 : /** The pad number of the pad */
380 : Int_t fPadNo; // see above
381 : /** Threshold for zero suppression */
382 : AliHLTTPCSignal_t fThreshold; // see above
383 : /** The average base line value */
384 : AliHLTTPCSignal_t fAverage; // see above
385 : /** Number of events included in the base line calculation*/
386 : Int_t fNofEvents; // see above
387 : /** The sum within one event */
388 : AliHLTTPCSignal_t fSum; // see above
389 : /** The number of bins contributing to the sum */
390 : Int_t fCount; // see above
391 : /** The total number of bins already set during the event */
392 : Int_t fTotal; // see above
393 : /** The maximum base line value within one event */
394 : AliHLTTPCSignal_t fBLMax; // see above
395 : /** The bin for the maximum bl value within one event */
396 : Int_t fBLMaxBin; // see above
397 : /** The minimum base line value within one event */
398 : AliHLTTPCSignal_t fBLMin; // see above
399 : /** The bin for the minimum bl value within one event */
400 : Int_t fBLMinBin; // see above
401 : /** The first bin included in the base line calculation */
402 : Int_t fFirstBLBin; // see above
403 : /** Number of bins */
404 : Int_t fNofBins; // see above
405 :
406 : /** The current read position */
407 : Int_t fReadPos; // see above
408 :
409 : /** The raw data history */
410 : AliHLTTPCSignal_t* fpRawData; //! transient
411 :
412 : /**
413 : * Array containing the data
414 : */
415 : AliHLTTPCSignal_t* fDataSignals; //! transient
416 :
417 : /**
418 : * Array containing info on which bins have signals
419 : */
420 : Int_t *fSignalPositionArray; //! transient
421 :
422 : /** Size of signals in fSignalPositionArray */
423 : Int_t fSizeOfSignalPositionArray; //! transient
424 :
425 : /** Number of good signals sent (good signals is signals surviving ZeroSuppression) */
426 : Int_t fNGoodSignalsSent;
427 :
428 : vector<vector<AliHLTTPCDigitData> > fCandidateDigitsVector;
429 :
430 6 : ClassDef(AliHLTTPCPad, 7)
431 : };
432 : #endif // ALIHLTTPCPAD_H
|
