]>
Commit | Line | Data |
---|---|---|
ffc57435 | 1 | #ifndef ALITRDSIGNALINDEX_H |
2 | #define ALITRDSIGNALINDEX_H | |
ca21baaa | 3 | |
4 | /* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. * | |
5 | * See cxx source for full Copyright notice */ | |
6 | ||
7 | /* $Id$ */ | |
8 | ||
9 | #include "TObject.h" | |
10 | ||
c8ab4518 | 11 | //////////////////////////////////////////////////////////////////////////// |
12 | // // | |
13 | // General container for data from TRD detector segments // | |
14 | // Adapted from AliDigits, origin M.Ivanov // | |
15 | // // | |
16 | // Author: // | |
17 | // Mateusz Ploskon (ploskon@ikf.uni-frankfurt.de) // | |
18 | // // | |
19 | //////////////////////////////////////////////////////////////////////////// | |
ca21baaa | 20 | |
ca21baaa | 21 | class AliTRDSignalIndex : public TObject |
22 | { | |
534529cb | 23 | protected: |
c8ab4518 | 24 | |
534529cb | 25 | union RowCol{ |
26 | Short_t rc; | |
27 | struct{ | |
28 | UChar_t col; | |
29 | Char_t row; | |
30 | }s; | |
31 | }; | |
32 | ||
33 | public: | |
ca21baaa | 34 | |
35 | AliTRDSignalIndex(); | |
36 | AliTRDSignalIndex(Int_t nrow, Int_t ncol,Int_t ntime); | |
37 | AliTRDSignalIndex(const AliTRDSignalIndex &d); | |
c8ab4518 | 38 | virtual ~AliTRDSignalIndex(); |
ca21baaa | 39 | AliTRDSignalIndex &operator=(const AliTRDSignalIndex &d); |
ca21baaa | 40 | |
e484a267 | 41 | void Copy(TObject &d) const; |
42 | void Allocate(const Int_t nrow, const Int_t ncol, const Int_t ntime); | |
43 | ||
44 | void Reset(); | |
45 | void ResetContentConditional(const Int_t nrow, const Int_t ncol, const Int_t ntime); | |
46 | void ResetContent(); | |
47 | void ResetCounters(); | |
ffc57435 | 48 | void ResetTbinCounter() const { }; |
e484a267 | 49 | |
50 | void ResetArrays(); | |
51 | ||
534529cb | 52 | // Store the index row-column as an interesting one |
1ab4da8c | 53 | inline void AddIndexRC(const Int_t row, const Int_t col); |
e484a267 | 54 | // Get the next pad (row and column) and return kTRUE on success |
1ab4da8c | 55 | inline Bool_t NextRCIndex(Int_t &row, Int_t &col); |
e484a267 | 56 | // Get the next timebin of a pad (row and column) and return kTRUE on success |
57 | Bool_t NextRCTbinIndex(Int_t &row, Int_t &col, Int_t &tbin); | |
58 | // Get the next active timebin and return kTRUE on success | |
59 | Bool_t NextTbinIndex(Int_t &tbin); | |
60 | ||
1ab4da8c | 61 | Bool_t CheckSorting(Int_t &row, Int_t &col); |
62 | ||
e484a267 | 63 | Int_t GetCurrentRow() const { return fCurrRow; } |
64 | Int_t GetCurrentCol() const { return fCurrCol; } | |
65 | Int_t GetCurrentTbin() const { return fCurrTbin; } | |
66 | ||
67 | Bool_t IsBoolIndex(Int_t row, Int_t col) const {return fBoolIndex[row*fNcols+col];}; | |
68 | void InitSortedIndex(); | |
69 | ||
70 | // Clear the array, actually destroy and recreate w/o allocating | |
71 | void ClearAll(); | |
72 | // Return kTRUE if array allocated and there is no need to call allocate | |
73 | Bool_t IsAllocated() const { if (!fBoolIndex) return kFALSE; | |
74 | if (fMaxLimit <= 0) return kFALSE; | |
75 | else return kTRUE;} | |
76 | ||
77 | void SetSM(const Int_t ix) { fSM = ix; } | |
78 | void SetStack(const Int_t ix) { fStack = ix; } | |
79 | void SetLayer(const Int_t ix) { fLayer = ix; } | |
80 | void SetDetNumber(const Int_t ix) { fDet = ix; } | |
c8ab4518 | 81 | |
e484a267 | 82 | Int_t GetDetNumber() const { return fDet; } // Get Det number |
83 | Int_t GetLayer() const { return fLayer; } // Layer position of the chamber in TRD | |
84 | Int_t GetStack() const { return fStack; } // Stack position of the chamber in TRD | |
85 | Int_t GetSM() const { return fSM; } // Super module of the TRD | |
534529cb | 86 | Short_t *GetArray() const { return (Short_t*)fSortedIndex; } // Get the array pointer for god knows what reason |
87 | Int_t GetNoOfIndexes() const { return fCountRC-1; } | |
ca21baaa | 88 | |
534529cb | 89 | Bool_t HasEntry() const { return fCountRC > 1 ? kTRUE : kFALSE; } // Return status if has an entry |
ca21baaa | 90 | |
e484a267 | 91 | Int_t GetNrow() const { return fNrows; } // Get Nrows |
92 | Int_t GetNcol() const { return fNcols; } // Get Ncols | |
93 | Int_t GetNtime() const { return fNtbins; } // Get Ntbins | |
ca21baaa | 94 | |
c8ab4518 | 95 | private: |
ca21baaa | 96 | |
c8ab4518 | 97 | Int_t fDet; // Detector number |
053767a4 | 98 | Int_t fLayer; // Layer position in the full TRD |
99 | Int_t fStack; // Stack position in the full TRD | |
c8ab4518 | 100 | Int_t fSM; // Super module - position in the full TRD |
ca21baaa | 101 | |
ffc57435 | 102 | Bool_t *fBoolIndex; // Indices |
534529cb | 103 | RowCol *fSortedIndex; // Sorted indices |
064d808d | 104 | Int_t fMaxLimit; // Max number of things in the array |
105 | Int_t fPositionRC; // Position in the SortedIndex | |
534529cb | 106 | Int_t fCountRC; // the number of added rc combinations |
064d808d | 107 | Bool_t fSortedWasInit; // Was SortedIndex initialized? |
ca21baaa | 108 | |
064d808d | 109 | Int_t fCurrRow; // Last Row read out of SortedIndex |
110 | Int_t fCurrCol; // Last Col read out of SortedIndex | |
111 | Int_t fCurrTbin; // Last outgiven Tbin | |
112 | ||
c8ab4518 | 113 | Int_t fNrows; // Number of rows in the chamber |
114 | Int_t fNcols; // Number of cols in the chamber | |
534529cb | 115 | Int_t fNtbins; // Number of tbins in the chamber |
ca21baaa | 116 | |
c8ab4518 | 117 | ClassDef(AliTRDSignalIndex,2) // Data container for one TRD detector segment |
ca21baaa | 118 | |
119 | }; | |
1ab4da8c | 120 | |
121 | void AliTRDSignalIndex::AddIndexRC(const Int_t row, const Int_t col) | |
122 | { | |
123 | // | |
124 | // Adds RC combination to array | |
125 | // | |
126 | ||
127 | const Int_t num=row*fNcols+col; | |
128 | if(fBoolIndex[num])return; | |
129 | fBoolIndex[num]=kTRUE; | |
130 | fSortedIndex[fCountRC].s.col=col; | |
131 | fSortedIndex[fCountRC].s.row=row; | |
132 | fCountRC++; | |
133 | } | |
134 | ||
135 | Bool_t AliTRDSignalIndex::NextRCIndex(Int_t &row, Int_t &col) | |
136 | { | |
137 | // | |
138 | // Returns next used RC combination | |
139 | // | |
140 | ||
c5304fc0 | 141 | if (!IsAllocated()) |
142 | return kFALSE; | |
143 | ||
1ab4da8c | 144 | if(fSortedIndex[fPositionRC].rc>-1){ |
145 | row = fCurrRow = fSortedIndex[fPositionRC].s.row; | |
146 | col = fCurrCol = fSortedIndex[fPositionRC].s.col; | |
147 | fPositionRC++; | |
148 | return kTRUE; | |
149 | } | |
150 | else | |
151 | return CheckSorting(row, col); | |
152 | } | |
153 | ||
ca21baaa | 154 | #endif |
064d808d | 155 | |
156 | /* | |
157 | Comment from 22 Dec 2008 | |
158 | ||
159 | The structure of the Index was changed. Now no Tbin is saved anymore, | |
160 | only RC combination are saved! (reasons see below) | |
161 | ||
162 | For the readout, all tbins for a RC combination must be read out to find | |
163 | the time bin of signal > 0. | |
164 | ||
165 | THE WRITING PROCEDURE: | |
166 | AddIndexTBin is now obsolate, use AddIndexRC instead as AddIndexTBin will | |
167 | be deleted in future. | |
168 | ||
169 | example that gives exactely the same output as before: | |
170 | as it was: | |
171 | AliTRDSignalIndexes *indexes; | |
172 | AliTRDarrayADC *Signal; //or AliTRDarraySignal *Signal; | |
173 | if(Signal->GetDataB(row, col, time)>0) | |
174 | indexes->AddIndexTBin(row, col, time); | |
175 | ||
176 | as it should be from no on: | |
177 | AliTRDSignalIndexes *indexes; | |
178 | AliTRDarrayADC *Signal; //or AliTRDarraySignal *Signal; | |
179 | if(Signal->GetDataB(row, col, time)>0) | |
180 | indexes->AddIndexRC(row, col); | |
181 | ||
182 | ||
183 | ||
184 | THE READING PROCEDURE: | |
185 | In most cases you can leave anything as it is. | |
186 | See more in the example. | |
187 | ||
188 | example: | |
189 | as it was: | |
190 | AliTRDSignalIndexes *indexes; | |
191 | AliTRDarraySignal *Signal; | |
192 | while(indexes->NextRCTbinIndex(row, col, time)) | |
193 | {...} | |
194 | ||
195 | as it should be from no on to get the exactely the same output as before: | |
196 | AliTRDSignalIndexes *indexes; | |
197 | AliTRDarraySignal *Signal; | |
198 | while(indexes->NextRCTbinIndex(row, col, time)) | |
199 | if(Signal->GetData(row, col, time)>0) | |
200 | {...} | |
201 | ||
202 | as it should be idealy: | |
203 | AliTRDSignalIndexes *indexes; | |
204 | AliTRDarraySignal *Signal; | |
205 | for(time = 0; time < Ntime; time++) | |
206 | while(indexes->NextRCIndex(row, col, time)) | |
207 | if(Signal->GetData(row, col, time)>0) | |
208 | {...} | |
209 | ||
210 | ||
211 | REASON OF THE CHANGES: | |
212 | ||
213 | The array saved the information nicely, but it turned out that sorting | |
214 | the array by column would have many benefits. | |
215 | I.e. it is crucial for fivePadClusters and it if much faster to allocate. | |
216 | But the sorting is not fast if the tbin is also saved. | |
217 | Moreover the tbin information was alsmost useless because, | |
218 | whenever an RC index existed, many of the possible tbins where used. | |
219 | ||
220 | Theodor Rascanu | |
221 | ||
222 | */ |