]>
Commit | Line | Data |
---|---|---|
eb7e0771 | 1 | /** @file Altro.C |
2 | * @brief The Altro class implements the Altro digital Chain in C++ | |
3 | * | |
4 | * This Class represents a C++ version of the ALTRO. For a complete Documentation of the Altro | |
5 | * Look at : http://ep-ed-alice-tpc.web.cern.ch/ep-ed-alice-tpc/altro_chip.htm\n | |
6 | * Due to the fact that the real ALTRO constantly samples in between the recorded events, | |
7 | * it has the knowledge on what happened in the period. This affects the BSL1, TCF and BSL2 module. | |
8 | * In the BSL1 the ALTRO follows slow baseline drifts e.g. temperature change, the TCF has a infinite | |
9 | * (IIR Filter) memory of "old samples" i.e. a cluster at the start of a readout cycle will be treated | |
10 | * differently, and the BSL2 has a 8 step pipeline. The ALTRO Class can't emulate this behavior, | |
11 | * since the data is not recorded.\n | |
12 | * | |
13 | * @author Roland Bramm | |
14 | * @version $LastChangedRevision: 688 $ | |
15 | * @date $LastChangedDate: 2005-12-16 14:07:11 +0100 (Fri, 16 Dec 2005) $ | |
16 | * | |
17 | * \verbinclude Altro/Altro.C.log | |
18 | * | |
19 | */ | |
20 | ///////////////////////////////////////////////////////////////////////////////////////////////////// | |
21 | // Class for emulation of the ALTRO chip (Altro digital Chain) in C++ // | |
22 | // Author: Roland Bramm // | |
23 | // // | |
24 | // NOTE: This class has been modified to be conform with the coding conventions of the // | |
25 | // ALICE Off-line Project. Keywords for setting the mode of BSC1 were modified // | |
26 | // and are shown in the header file ... // | |
27 | // Stefan Rossegger, 8th february 2008 // | |
28 | ///////////////////////////////////////////////////////////////////////////////////////////////////// | |
29 | ||
30 | #include "AliTPCAltroEmulator.h" | |
31 | ||
32 | /** @brief Consturctor of Altro Class | |
33 | * | |
34 | * Consturctor of Altro Class, some variables are set.\n | |
35 | * The input Data is altered, so after running the complete emulation you have the | |
36 | * Altro Processed Data in the Channel Pointer.\n | |
37 | * | |
38 | * @param timebins an <tt> int </tt> sets the length of the input Data (Channel) | |
39 | * @param Channel an <tt> short* </tt> Pointer to a 1d short Array with the input Data | |
40 | */ | |
41 | ||
9389f9a4 | 42 | |
43 | ClassImp(AliTPCAltroEmulator) | |
44 | ||
b479e253 | 45 | AliTPCAltroEmulator::AliTPCAltroEmulator(int timebins, short* Channel) : |
46 | TNamed(), | |
47 | ftimebins(timebins), | |
48 | // fChannelIn(Channel), | |
49 | fChannelShort(Channel), | |
50 | fADCkeep(0), | |
51 | fOnBSL1(0), | |
52 | fOnTCF(0), | |
53 | fOnBSL2(0), | |
54 | fOnClip(0), | |
55 | fOnZSU(0), | |
56 | ||
57 | fConfiguredAltro(0), // ConfiguredAltro | |
58 | fConfiguredBSL1(0), // ConfiguredBSL1 | |
59 | fConfiguredTCF(0), // ConfiguredTCF | |
60 | fConfiguredBSL2(0), // ConfiguredBSL2 | |
61 | fConfiguredZSU(0), // ConfiguredZSU | |
62 | fBSL1mode(0), // BSL1mode | |
63 | fBSL1ValuePeDestal(0), // BSL1ValuePeDestal | |
64 | fBSL1PedestalMem(0), // BSL1PedestalMem | |
65 | fBSL1polarity(0), // BSL1polarity | |
66 | ||
67 | fTCFK1(0), // K1 | |
68 | fTCFK2(0), // K2 | |
69 | fTCFK3(0), // K3 | |
70 | fTCFL1(0), // L1 | |
71 | fTCFL2(0), // L2 | |
72 | fTCFL3(0), // L3 | |
73 | ||
74 | fTCFK1Int(0), // K1Int | |
75 | fTCFK2Int(0), // K2Int | |
76 | fTCFK3Int(0), // K3Int | |
77 | fTCFL1Int(0), // L1Int | |
78 | fTCFL2Int(0), // L2Int | |
79 | fTCFL3Int(0), // L3Int | |
80 | ||
81 | fBSL2HighThreshold(0), // BSL2HighThreshold | |
82 | fBSL2LowThreshold(0), // BSL2LowThreshold | |
83 | fBSL2Offset(0), // BSL2Offset | |
84 | fBSL2Presamples(0), // BSL2Presamples(0), | |
85 | fBSL2Postsamples(0), // BSL2Postsamples | |
86 | ||
87 | fZSUThreshold(0), // ZSUThreshold | |
88 | ||
89 | fZSUMinSamplesaboveThreshold(0), // ZSUMinSamplesaboveThreshold | |
90 | fZSUPresamples(0), // ZSUPresamples | |
91 | fZSUPostsamples(0) // ZSUPostsamples | |
92 | ||
93 | { | |
eb7e0771 | 94 | // |
95 | // Constructor of Altro Class | |
96 | // | |
b479e253 | 97 | /* |
eb7e0771 | 98 | ftimebins = timebins; |
99 | ||
100 | fChannelShort = Channel; | |
101 | ||
102 | fOnBSL1 = 0; | |
103 | fOnTCF = 0; | |
104 | fOnBSL2 = 0; | |
105 | fOnClip = 0; | |
106 | fOnZSU = 0; | |
107 | ||
108 | fConfiguredAltro = 0; | |
109 | fConfiguredBSL1 = 0; | |
110 | fConfiguredTCF = 0; | |
111 | fConfiguredBSL2 = 0; | |
112 | fConfiguredZSU = 0; | |
b479e253 | 113 | */ |
eb7e0771 | 114 | } |
115 | ||
b479e253 | 116 | |
117 | AliTPCAltroEmulator::AliTPCAltroEmulator(const AliTPCAltroEmulator &altro): | |
118 | TNamed(), | |
119 | ftimebins(altro.ftimebins), | |
120 | // fChannelIn(Channel), | |
121 | fChannelShort(altro.fChannelShort), | |
122 | fADCkeep(0), | |
123 | fOnBSL1(0), | |
124 | fOnTCF(0), | |
125 | fOnBSL2(0), | |
126 | fOnClip(0), | |
127 | fOnZSU(0), | |
128 | ||
129 | fConfiguredAltro(0), // ConfiguredAltro | |
130 | fConfiguredBSL1(0), // ConfiguredBSL1 | |
131 | fConfiguredTCF(0), // ConfiguredTCF | |
132 | fConfiguredBSL2(0), // ConfiguredBSL2 | |
133 | fConfiguredZSU(0), // ConfiguredZSU | |
134 | fBSL1mode(0), // BSL1mode | |
135 | fBSL1ValuePeDestal(0), // BSL1ValuePeDestal | |
136 | fBSL1PedestalMem(0), // BSL1PedestalMem | |
137 | fBSL1polarity(0), // BSL1polarity | |
138 | ||
139 | fTCFK1(0), // K1 | |
140 | fTCFK2(0), // K2 | |
141 | fTCFK3(0), // K3 | |
142 | fTCFL1(0), // L1 | |
143 | fTCFL2(0), // L2 | |
144 | fTCFL3(0), // L3 | |
145 | ||
146 | fTCFK1Int(0), // K1Int | |
147 | fTCFK2Int(0), // K2Int | |
148 | fTCFK3Int(0), // K3Int | |
149 | fTCFL1Int(0), // L1Int | |
150 | fTCFL2Int(0), // L2Int | |
151 | fTCFL3Int(0), // L3Int | |
152 | ||
153 | fBSL2HighThreshold(0), // BSL2HighThreshold | |
154 | fBSL2LowThreshold(0), // BSL2LowThreshold | |
155 | fBSL2Offset(0), // BSL2Offset | |
156 | fBSL2Presamples(0), // BSL2Presamples(0), | |
157 | fBSL2Postsamples(0), // BSL2Postsamples | |
158 | ||
159 | fZSUThreshold(0), // ZSUThreshold | |
160 | ||
161 | fZSUMinSamplesaboveThreshold(0), // ZSUMinSamplesaboveThreshold | |
162 | fZSUPresamples(0), // ZSUPresamples | |
163 | fZSUPostsamples(0) // ZSUPostsamples | |
164 | ||
165 | { | |
eb7e0771 | 166 | // |
167 | // copy constructor of Altro Class | |
168 | // | |
b479e253 | 169 | |
eb7e0771 | 170 | } |
171 | ||
172 | ||
173 | /** @brief Destructor of Altro Class | |
174 | * | |
175 | * Destructor of Altro Class\n | |
176 | */ | |
177 | AliTPCAltroEmulator::~AliTPCAltroEmulator(){ | |
178 | // | |
179 | // Destructor of Altro Class | |
180 | // | |
181 | ||
182 | if(fConfiguredZSU == 1) | |
183 | delete fADCkeep; | |
184 | } | |
185 | ||
186 | //_____________________________________________________________________________ | |
187 | AliTPCAltroEmulator& AliTPCAltroEmulator::operator = (const AliTPCAltroEmulator &source) | |
188 | { | |
189 | // | |
190 | // AliTPCAltroEmulator assignment operator | |
191 | // | |
192 | ||
193 | if (&source == this) return *this; | |
194 | new (this) AliTPCAltroEmulator(source); | |
195 | ||
196 | return *this; | |
197 | ||
198 | } | |
199 | ||
200 | ||
201 | ||
202 | /** @brief Configures which modules of the Altro should be on. | |
203 | * | |
204 | * Configures which modules of the Altro should be on. Each of the modules | |
205 | * which are configured to be on, have to be configured later before running | |
206 | * the emulation!\n | |
207 | * | |
208 | * @param ONBaselineCorrection1 an <tt> int </tt> Switch (0,1) to turn on the Base Line Correction 1 (BSL1) Module | |
209 | * @param ONTailcancellation an <tt> int </tt> Switch (0,1) to turn on the Tail Cancellation Filter (TCF) Module | |
210 | * @param ONBaselineCorrection2 an <tt> int </tt> Switch (0,1) to turn on the Moving Average Filter (BSL2) Module | |
211 | * @param ONClipping an <tt> int </tt> Switch (0,1) to turn on the Clipping Module. This is not possible in the real Altro, there it is always on. | |
212 | * @param ONZerosuppression an <tt> int </tt> Switch (0,1) to turn on the Zero Suppression (ZSU) Module | |
213 | * @param ONDataFormatting an <tt> int </tt> Switch (0,1) to turn on the Data Formatting on (not implemented) | |
214 | */ | |
215 | void AliTPCAltroEmulator::ConfigAltro(int ONBaselineCorrection1, int ONTailcancellation, int ONBaselineCorrection2, int ONClipping, int ONZerosuppression, int ONDataFormatting){ | |
216 | // | |
217 | // Configures which modules of the Altro should be on | |
218 | // | |
219 | fOnBSL1 = InRange(ONBaselineCorrection1,0,1,"AliTPCAltroEmulator::ConfigAltro","ONBaselineCorrection1"); | |
220 | fOnTCF = InRange(ONTailcancellation,0,1,"AliTPCAltroEmulator::ConfigAltro","ONTailcancellation"); | |
221 | fOnBSL2 = InRange(ONBaselineCorrection2,0,1,"AliTPCAltroEmulator::ConfigAltro","ONBaselineCorrection2"); | |
222 | fOnClip = InRange(ONClipping,0,1,"AliTPCAltroEmulator::ConfigAltro","ONClipping"); | |
223 | fOnZSU = InRange(ONZerosuppression,0,1,"AliTPCAltroEmulator::ConfigAltro","ONZerosuppression"); | |
b479e253 | 224 | ONDataFormatting; // does not have to be checked |
eb7e0771 | 225 | fConfiguredAltro = 1; |
226 | } | |
227 | ||
228 | /** @brief Configures the Base Line Correction 1 (BSL1) Module | |
229 | * | |
230 | * Configures the Base Line Correction 1 (BSL1) Module. You dont have to build a proper pedestalMemory | |
231 | * array, a pointer of the correct type is enough, of course you are not allowed to use Basline | |
232 | * Correction Modes which need then the array ...\n | |
233 | * All configurable values are "Range checked" and if out of the Range set to the nearest extreme. | |
234 | * So the Emulation will work, but the result is maybe not the expected one. | |
235 | * | |
236 | * @param mode an <tt> int </tt> sets the mode of the Baseline Correction. See the Altro manual for a description | |
237 | * @param ValuePeDestal an <tt> int </tt> this is the baseline of the Channel. | |
238 | * @param PedestalMem an <tt> *int </tt> Pointer to a 1d short Array with the pedestal memory Data | |
239 | * @param polarity an <tt> int </tt> Switch (0,1) for the polarity | |
240 | */ | |
241 | void AliTPCAltroEmulator::ConfigBaselineCorrection1(int mode, int ValuePeDestal, int *PedestalMem, int polarity){ | |
242 | // | |
243 | // Configures the Base Line Correction 1 (BSL1) Module | |
244 | // | |
245 | fBSL1mode = InRange(mode,0,10,"AliTPCAltroEmulator::ConfigBaselineCorrection1","mode"); | |
246 | fBSL1ValuePeDestal = InRange(ValuePeDestal,0,1023,"AliTPCAltroEmulator::BaselineCorrection1","ValuePeDestal"); | |
247 | fBSL1PedestalMem = PedestalMem; | |
248 | fBSL1polarity = InRange(polarity,0,1,"AliTPCAltroEmulator::BaselineCorrection1","polarity"); | |
249 | fConfiguredBSL1 = 1; | |
250 | } | |
251 | ||
252 | /** @brief Configures the Tail Cancellation Filter (TCF) Module | |
253 | * | |
254 | * Configures the Tail Cancellation Filter (TCF) Module. You have to set the coefficients in the | |
255 | * Integer version.\n | |
256 | * To convert from int to float use (int)*(pow(2,-16)-1) | |
257 | * To convert from float to int usw (float)*(pow(2,16)-1) | |
258 | * All configurable values are "Range checked" and if out of the Range set to the nearest extreme. | |
259 | * So the Emulation will work, but the result is maybe not the expected one. | |
260 | * | |
261 | * @param K1 an <tt> int </tt> sets the K1 coeeficient of the TCF | |
262 | * @param K2 an <tt> int </tt> sets the K2 coeeficient of the TCF | |
263 | * @param K3 an <tt> int </tt> sets the K3 coeeficient of the TCF | |
264 | * @param L1 an <tt> int </tt> sets the L1 coeeficient of the TCF | |
265 | * @param L2 an <tt> int </tt> sets the L2 coeeficient of the TCF | |
266 | * @param L3 an <tt> int </tt> sets the L3 coeeficient of the TCF | |
267 | */ | |
268 | void AliTPCAltroEmulator::ConfigTailCancellationFilter(int K1, int K2, int K3, int L1, int L2, int L3){ | |
269 | // | |
270 | // Configures the Tail Cancellation Filter (TCF) Module | |
271 | // | |
272 | // conf from int to fp: (int)*(pow(2,-16)-1) | |
273 | // backway: (float)*(pow(2,16)-1) | |
274 | fTCFK1Int = InRange(K1,0,65535,"AliTPCAltroEmulator::ConfigTailCancellationFilter","K1"); | |
275 | fTCFK2Int = InRange(K2,0,65535,"AliTPCAltroEmulator::ConfigTailCancellationFilter","K2"); | |
276 | fTCFK3Int = InRange(K3,0,65535,"AliTPCAltroEmulator::ConfigTailCancellationFilter","K3"); | |
277 | ||
278 | fTCFL1Int = InRange(L1,0,65535,"AliTPCAltroEmulator::ConfigTailCancellationFilter","L1"); | |
279 | fTCFL2Int = InRange(L2,0,65535,"AliTPCAltroEmulator::ConfigTailCancellationFilter","L2"); | |
280 | fTCFL3Int = InRange(L3,0,65535,"AliTPCAltroEmulator::ConfigTailCancellationFilter","L3"); | |
281 | fConfiguredTCF = 1; | |
282 | } | |
283 | ||
284 | /** @brief Configures the Moving Average Filter (BSL2) Module | |
285 | * | |
286 | * Configures the Moving Average Filter (BSL2) Module. | |
287 | * All configurable values are "Range checked" and if out of the Range set to the nearest extreme. | |
288 | * So the Emulation will work, but the result is maybe not the expected one. | |
289 | * | |
290 | * @param HighThreshold an <tt> int </tt> sets the high Threshold | |
291 | * @param LowThreshold an <tt> int </tt> sets the low Theshold | |
292 | * @param Offset an <tt> int </tt> sets the the offset which is added to the Signal | |
293 | * @param Presamples an <tt> int </tt> sets the number of pre samples excluded from the moving average caclulation | |
294 | * @param Postsamples an <tt> int </tt> sets the number of post samples excluded from the moving average caclulation | |
295 | */ | |
296 | void AliTPCAltroEmulator::ConfigBaselineCorrection2(int HighThreshold, int LowThreshold, int Offset, int Presamples, int Postsamples){ | |
297 | // | |
298 | // Configures the Moving Average Filter (BSL2) Module | |
299 | // | |
300 | fBSL2HighThreshold = InRange(HighThreshold,0,1023,"AliTPCAltroEmulator::ConfigBaselineCorrection2","HighThreshold"); | |
301 | fBSL2LowThreshold = InRange(LowThreshold,0,1023,"AliTPCAltroEmulator::ConfigBaselineCorrection2","LowThreshold"); | |
302 | fBSL2Offset = InRange(Offset,0,1023,"AliTPCAltroEmulator::ConfigBaselineCorrection2","Offset"); | |
303 | fBSL2Presamples = InRange(Presamples,0,3,"AliTPCAltroEmulator::ConfigBaselineCorrection2","Presamples"); | |
304 | fBSL2Postsamples = InRange(Postsamples,0,15,"AliTPCAltroEmulator::ConfigBaselineCorrection2","Postsamples"); | |
305 | fConfiguredBSL2 = 1; | |
306 | } | |
307 | ||
308 | /** @brief Configures the Zero Suppression Module (ZSU) | |
309 | * | |
310 | * Configures the Zero Suppression Module (ZSU). | |
311 | * All configurable values are "Range checked" and if out of the Range set to the nearest extreme. | |
312 | * So the Emulation will work, but the result is maybe not the expected one. | |
313 | * | |
314 | * @param Threshold an <tt> int </tt> sets the Threshold | |
315 | * @param MinSamplesaboveThreshold an <tt> int </tt> sets the minimum number of samples which have to be greater than the threshold | |
316 | * @param Presamples an <tt> int </tt> sets the number of pre samples which are kept | |
317 | * @param Postsamples an <tt> int </tt> sets the number of post samples which are kept | |
318 | */ | |
319 | void AliTPCAltroEmulator::ConfigZerosuppression(int Threshold, int MinSamplesaboveThreshold, int Presamples, int Postsamples){ | |
320 | // | |
321 | // Configures the Zero Suppression Module (ZSU) | |
322 | // | |
323 | fZSUThreshold = InRange(Threshold,0,1023,"AliTPCAltroEmulator::BaselineCorrection1","Threshold"); | |
324 | fZSUMinSamplesaboveThreshold = InRange(MinSamplesaboveThreshold,1,3,"AliTPCAltroEmulator::BaselineCorrection1","MinSamplesaboveThreshold"); | |
325 | fZSUPresamples = InRange(Presamples,0,3,"AliTPCAltroEmulator::BaselineCorrection1","Presamples"); | |
326 | fZSUPostsamples = InRange(Postsamples,0,7,"AliTPCAltroEmulator::BaselineCorrection1","Postsamples"); | |
327 | fADCkeep = (short *)calloc(sizeof(short),ftimebins); | |
328 | ||
329 | for(int i = 0; i < ftimebins; i++){ | |
330 | fADCkeep[i] = 0; | |
331 | } | |
332 | fConfiguredZSU = 1; | |
333 | } | |
334 | ||
335 | /** @brief Prints the set Parameters, if module is configured | |
336 | * | |
337 | * Prints the set Parameters, if module is configured. | |
338 | */ | |
339 | void AliTPCAltroEmulator::PrintParameters(){ | |
340 | // | |
341 | // Prints the set Parameters, if module is configured | |
342 | // | |
343 | cout << "+-------------------------------------------+" << endl; | |
344 | cout << "| Configured Parameters of the Altro Module |" << endl; | |
345 | cout << "+-------------------------------------------+" << endl << endl; | |
346 | ||
347 | cout << "Parameters set in the Altro Modules:" << endl << endl; | |
348 | cout << "ONBaselineCorrection1: " << fOnBSL1 << endl; | |
349 | cout << "ONTailcancellation : " << fOnTCF << endl; | |
350 | cout << "ONBaselineCorrection2: " << fOnBSL2 << endl; | |
351 | cout << "ONClipping : " << fOnClip << endl; | |
352 | cout << "ONZerosuppression : " << fOnZSU << endl << endl << endl; | |
353 | if(fConfiguredBSL1 == 1){ | |
354 | cout << "Parameters set in the BSL1 (Baseline Correction 1) Module:" << endl << endl; | |
355 | cout << "mode : " << fBSL1mode << endl; | |
356 | cout << "ValuePeDestal : " << fBSL1ValuePeDestal << endl; | |
357 | cout << "polarity : " << fBSL1ValuePeDestal << endl << endl << endl; | |
358 | }else{ | |
359 | cout << "BSL1 (Baseline Correction 1) Module not configured!" << endl << endl << endl; | |
360 | } | |
361 | if(fConfiguredTCF == 1){ | |
362 | cout << "Parameters set in the TCF (TailCancellation Filter) Module:" << endl << endl; | |
363 | cout << "K1 (int|float) : " << fTCFK1Int << " | " << fTCFK1Int/(float)((1<<16)-1) << endl; | |
364 | cout << "K2 (int|float) : " << fTCFK2Int << " | " << fTCFK2Int/(float)((1<<16)-1) << endl; | |
365 | cout << "K3 (int|float) : " << fTCFK3Int << " | " << fTCFK3Int/(float)((1<<16)-1) << endl; | |
366 | cout << "L1 (int|float) : " << fTCFL1Int << " | " << fTCFL1Int/(float)((1<<16)-1) << endl; | |
367 | cout << "L2 (int|float) : " << fTCFL2Int << " | " << fTCFL2Int/(float)((1<<16)-1) << endl; | |
368 | cout << "L3 (int|float) : " << fTCFL3Int << " | " << fTCFL3Int/(float)((1<<16)-1) << endl << endl << endl; | |
369 | }else{ | |
370 | cout << "TCF (TailCancellation Filter) Module not configured!" << endl << endl << endl; | |
371 | } | |
372 | if(fConfiguredBSL2 == 1){ | |
373 | cout << "Parameters set in the BSL2 (Baseline Correction 2) Module:" << endl << endl; | |
374 | cout << "HighThreshold : " << fBSL2HighThreshold << endl; | |
375 | cout << "LowThreshold : " << fBSL2LowThreshold << endl; | |
376 | cout << "Offset : " << fBSL2Offset << endl; | |
377 | cout << "Presamples : " << fBSL2Presamples << endl; | |
378 | cout << "Postsamples : " << fBSL2Postsamples << endl << endl << endl; | |
379 | }else{ | |
380 | cout << "BSL2 (Baseline Correction 2) Module not configured!" << endl << endl << endl; | |
381 | } | |
382 | if(fConfiguredZSU == 1){ | |
383 | cout << "Parameters set in the ZSU (Zero Suppression Unit) Module:" << endl << endl; | |
384 | cout << "Threshold : " << fZSUThreshold << endl; | |
385 | cout << "MinSampaboveThreshold: " << fZSUMinSamplesaboveThreshold << endl; | |
386 | cout << "Presamples : " << fZSUPresamples << endl; | |
387 | cout << "Postsamples : " << fZSUPostsamples << endl << endl << endl; | |
388 | }else{ | |
389 | cout << "ZSU (Zero Suppression Unit) Module not configured!" << endl << endl << endl; | |
390 | } | |
391 | } | |
392 | ||
393 | /** @brief Runs the emulation of all configured Modules. | |
394 | * | |
395 | * Runs the emulation of all configured Modules. This changes then the content of the | |
396 | * input Array | |
397 | */ | |
398 | void AliTPCAltroEmulator::RunEmulation(){ | |
399 | // | |
400 | // Runs the emulation of all configured Modules. | |
401 | // | |
402 | ||
403 | //cout << "AliTPCAltroEmulator::RunEmulation | start" << endl; | |
404 | if(fConfiguredAltro == 0){ | |
405 | cout << "ERROR cant run Altro Emulation because not configured" << endl; | |
406 | return; | |
407 | } | |
408 | ||
409 | //cout << "AliTPCAltroEmulator::RunEmulation | start BSL1 on: " << fOnBSL1 << " configures: " << fConfiguredBSL1 << endl; | |
410 | if(fOnBSL1 == 1){ | |
411 | if(fConfiguredBSL1 == 1){ | |
412 | BaselineCorrection1(fBSL1mode, fBSL1ValuePeDestal, fBSL1PedestalMem, fBSL1polarity); | |
413 | }else{ | |
414 | cout << "ERROR cant run Baseline Correction 1 because not configured" << endl; | |
415 | return; | |
416 | } | |
417 | } | |
418 | ||
419 | //cout << "AliTPCAltroEmulator::RunEmulation | start TCF on: " << fOnTCF << " configures: " << fConfiguredTCF << endl; | |
420 | if(fOnTCF == 1){ | |
421 | if(fConfiguredTCF == 1){ | |
422 | TailCancellationFilterFixedPoint(fTCFK1Int, fTCFK2Int, fTCFK3Int, fTCFL1Int, fTCFL2Int, fTCFL3Int); | |
423 | }else{ | |
424 | cout << "ERROR cant run Tail Cancellation Filter because not configured" << endl; | |
425 | return; | |
426 | } | |
427 | } | |
428 | ||
429 | //cout << "AliTPCAltroEmulator::RunEmulation | start BSL2 on: " << fOnBSL2 << " configures: " << fConfiguredBSL2 << endl; | |
430 | if(fOnBSL2 == 1){ | |
431 | if(fConfiguredBSL2 == 1){ | |
432 | BaselineCorrection2RTL(fBSL2HighThreshold, fBSL2LowThreshold, fBSL2Offset, fBSL2Presamples, fBSL2Postsamples); | |
433 | }else{ | |
434 | cout << "ERROR cant run Baseline Correction 2 because not configured" << endl; | |
435 | return; | |
436 | } | |
437 | } | |
438 | //cout << "AliTPCAltroEmulator::RunEmulation | start CLIP on: " << fOnClip << endl; | |
439 | if(fOnClip == 1){ | |
440 | Clipping(); | |
441 | } | |
442 | //cout << "AliTPCAltroEmulator::RunEmulation | start ZSU on: " << fOnZSU << " configures: " << fConfiguredZSU << endl; | |
443 | if(fOnZSU == 1){ | |
444 | if(fConfiguredZSU == 1){ | |
445 | Zerosuppression(fZSUThreshold,fZSUMinSamplesaboveThreshold,fZSUPresamples,fZSUPostsamples); | |
446 | }else{ | |
447 | cout << "ERROR cant run Zero Suppression Unit because not configured" << endl; | |
448 | return; | |
449 | } | |
450 | } | |
451 | } | |
452 | ||
453 | void AliTPCAltroEmulator::BaselineCorrection1(int mode, int ValuePeDestal, int *PedestalMem, int polarity){ | |
454 | // | |
455 | // BaselineCorrection1 | |
456 | // | |
457 | ||
458 | //VPD == 0 !! | |
459 | int fixedPeDestal = 0; | |
460 | ||
461 | if(polarity ==1){ | |
462 | for(int i = 0; i < ftimebins; i++){ | |
463 | fChannelShort[i] = 1023 - fChannelShort[i]; | |
464 | } | |
465 | } | |
466 | ||
467 | switch(mode) { | |
468 | case kDINxFPD: | |
469 | for(int i = 0; i < ftimebins; i++) | |
470 | fChannelShort[i] = fChannelShort[i] - fixedPeDestal; | |
471 | break; | |
472 | case kDINxFT: | |
473 | for(int i = 0; i < ftimebins; i++) | |
474 | fChannelShort[i] = fChannelShort[i] - PedestalMem[i]; | |
475 | break; | |
476 | case kDINxFDIN: | |
477 | for(int i = 0; i < ftimebins; i++) | |
478 | fChannelShort[i] = fChannelShort[i] - PedestalMem[ fChannelShort[i] ]; | |
479 | break; | |
480 | case kDINxFDINxVPD: | |
481 | for(int i = 0; i < ftimebins; i++) | |
482 | fChannelShort[i] = fChannelShort[i] - PedestalMem[ fChannelShort[i] - ValuePeDestal]; | |
483 | break; | |
484 | case kDINxVPDxFPD: | |
485 | for(int i = 0; i < ftimebins; i++) | |
486 | fChannelShort[i] = fChannelShort[i] - ValuePeDestal - fixedPeDestal; | |
487 | break; | |
488 | case kDINxVPDxFT: | |
489 | for(int i = 0; i < ftimebins; i++) | |
490 | fChannelShort[i] = fChannelShort[i] - ValuePeDestal - PedestalMem[i]; | |
491 | break; | |
492 | case kDINxVPDxFDIN: | |
493 | for(int i = 0; i < ftimebins; i++) | |
494 | fChannelShort[i] = fChannelShort[i] - ValuePeDestal - PedestalMem[ fChannelShort[i] ]; | |
495 | break; | |
496 | case kDINxVPDxFDINxVPD: | |
497 | for(int i = 0; i < ftimebins; i++) | |
498 | fChannelShort[i] = fChannelShort[i] - ValuePeDestal - PedestalMem[ fChannelShort[i] - ValuePeDestal ]; | |
499 | break; | |
500 | case kFDINxFPD: | |
501 | for(int i = 0; i < ftimebins; i++) | |
502 | fChannelShort[i] = PedestalMem[ fChannelShort[i] ] - fixedPeDestal; | |
503 | break; | |
504 | case kFDINxVPDxFPD: | |
505 | for(int i = 0; i < ftimebins; i++) | |
506 | fChannelShort[i] = PedestalMem[ fChannelShort[i] - ValuePeDestal ] - fixedPeDestal; | |
507 | break; | |
508 | case kFTxFPD: | |
509 | for(int i = 0; i < ftimebins; i++) | |
510 | fChannelShort[i] = PedestalMem[i] - fixedPeDestal; | |
511 | break; | |
512 | } | |
513 | } | |
514 | ||
515 | int AliTPCAltroEmulator::Multiply36(int P, int N){ | |
516 | // | |
517 | // multiply function to emulate the 36 bit fixed point multiplication of the Altro. | |
518 | // | |
519 | long long retval =0; | |
520 | long long temp = 0; | |
521 | long long vAX = 0; | |
522 | temp = (long long)P*(long long)N; | |
523 | vAX = (( Mask(temp,35,18) + ((long long)(-P)<<18) ) + Mask(temp,17,0)); | |
524 | if ( Maskandshift(N,17,17) == 1){ | |
525 | retval = ((Maskandshift(vAX,35,35)<<17) + Maskandshift(vAX,32,16)); | |
526 | }else{ | |
527 | retval = Maskandshift(temp,32,16); | |
528 | } | |
529 | return retval; | |
530 | } | |
531 | long long AliTPCAltroEmulator::Mask(long long in, int left, int right){ | |
532 | // | |
533 | // | |
534 | // | |
535 | long long retval; | |
536 | long long pattern; | |
537 | long long length = abs(left - right)+1; | |
538 | pattern = ((1<<length)-1)<<right; | |
539 | retval = in&pattern; | |
540 | return retval; | |
541 | } | |
542 | ||
543 | long long AliTPCAltroEmulator::Maskandshift(long long in, int left, int right){ | |
544 | // | |
545 | // | |
546 | // | |
547 | long long retval; | |
548 | long long pattern; | |
549 | long long length = abs(left - right)+1; | |
550 | pattern = ((1<<length)-1); | |
551 | retval = (in>>right)&pattern; | |
552 | return retval; | |
553 | } | |
554 | ||
555 | void AliTPCAltroEmulator::TailCancellationFilterFixedPoint(int K1, int K2, int K3, int L1, int L2, int L3){ | |
556 | // | |
557 | // TailCancellationFilterFixedPoint | |
558 | // | |
559 | int c1n = 0, c2n = 0, c3n = 0; | |
560 | int c1o = 0, c2o = 0, c3o = 0; | |
561 | int d1 = 0, d2 = 0; | |
562 | int dout = 0; | |
563 | int din = 0; | |
564 | int bit = 0; | |
565 | for(int i = 0; i < ftimebins; i++){ | |
566 | din = fChannelShort[i]; | |
567 | ||
568 | din = (din<<2); | |
569 | c1n = Mask( (Mask(din,17,0) + Multiply36(K1,Mask(c1o,17,0)) ) ,17,0); | |
570 | d1 = Mask( (Mask(c1n,17,0) - Multiply36(L1,Mask(c1o,17,0)) ) ,17,0); | |
571 | //d1 = Mask( (Mask(c1n,17,0) + Mask(~Multiply36(L1,Mask(c1o,17,0))+1,17,0) ) ,17,0); | |
572 | ||
573 | c2n = Mask( (Mask(d1 ,17,0) + Multiply36(K2,Mask(c2o,17,0)) ) ,17,0); | |
574 | d2 = Mask( (Mask(c2n,17,0) - Multiply36(L2,Mask(c2o,17,0)) ) ,17,0); | |
575 | //d2 = Mask( (Mask(c2n,17,0) + Mask(~Multiply36(L2,Mask(c2o,17,0))+1,17,0) ) ,17,0); | |
576 | ||
577 | c3n = Mask( (Mask(d2 ,17,0) + Multiply36(K3,Mask(c3o,17,0)) ) ,17,0); | |
578 | dout = Mask( (Mask(c3n,17,0) - Multiply36(L3,Mask(c3o,17,0)) ) ,17,0); | |
579 | //dout = Mask( (Mask(c3n,17,0) + Mask(~Multiply36(L3,Mask(c3o,17,0))+1,17,0) ) ,17,0); | |
580 | ||
581 | if( (Maskandshift(dout,2,2) == 1) || (Maskandshift(dout,1,1) == 1)){ | |
582 | bit = 1; | |
583 | }else{ | |
584 | bit = 0; | |
585 | } | |
586 | ||
587 | dout = ((dout>>3)<<1) + bit; | |
588 | if(Maskandshift(dout,15,15) == 1){ | |
589 | //is needed to get the correct coding when getting negative results | |
590 | dout = -Mask((-Mask(dout,9,0)),9,0); | |
591 | }else{ | |
592 | dout = Mask(dout,9,0); | |
593 | } | |
594 | ||
595 | fChannelShort[i] = (short) dout; | |
596 | c1o = c1n; | |
597 | c2o = c2n; | |
598 | c3o = c3n; | |
599 | } | |
600 | } | |
601 | ||
602 | void AliTPCAltroEmulator::BaselineCorrection2RTL(int HighThreshold, int LowThreshold, int Offset, int Presamples, int Postsamples){ | |
603 | // | |
604 | // BaselineCorrection2RTL | |
605 | // | |
606 | ||
607 | //cout << "Altro::BaselineCorrection2RTL | HighThreshold: " << HighThreshold << " LowThreshold: " << LowThreshold << " Offset: " << Offset << " Presamples: " << Presamples << " Postsamples: " << Postsamples << endl; | |
608 | //more or less direct "translation" of the hdl code. | |
609 | //Input signals | |
610 | int din; | |
611 | int dout; | |
612 | int edges[6]; // = Postsamples*4 + Presamples; | |
613 | int offset = Offset; | |
614 | int thrlo = LowThreshold;//called thr_mau[19] ... | |
615 | int thrhi = HighThreshold; | |
616 | ||
617 | // Variables | |
618 | int fOld[4]; //flag pipe | |
619 | int fNew[4]; //flag pipe | |
620 | int dOld[4]; //data pipe | |
621 | int dNew[4]; //data pipe | |
622 | int dxOld; | |
623 | int dxNew; | |
624 | int pstscnt; // Counter for Postsamples | |
625 | int zOld[9]; // Filter stages | |
626 | int zNew[9]; // Filter stages | |
627 | int zxOld; //Accumulator stage | |
628 | int zxNew; //Accumulator stage | |
629 | int valcntOld; //Valid sample counter | |
630 | int valcntNew = 0; //Valid sample counter | |
631 | ||
632 | int valid; //Valid flag | |
633 | int fx; //postsample flag | |
634 | //int s07; // differentiator result | |
635 | int s8; // Acc + Diff result | |
636 | int flag; | |
637 | //int bsth; //baseline threshold | |
638 | //int din_p; //Data input strictly positive | |
639 | int bsl; | |
640 | //int dx_bsls; // dx -bsl | |
641 | //int dx_clip; // dxbsl clipped | |
642 | //int bsl_of = 0; | |
643 | ||
644 | //initialisation | |
645 | for(int i = 0; i < 9 ; i++) | |
646 | zOld[i] = 0; | |
647 | for(int i = 0; i < 4 ; i++){ | |
648 | fOld[i] = 0; | |
649 | dOld[i] = 0; | |
650 | } | |
651 | dxOld= 0; | |
652 | pstscnt = 0; | |
653 | zxOld = 0; | |
654 | valcntOld = 0; | |
655 | valid = 0; | |
656 | for(int i = 0; i < 2 ; i++){ | |
657 | edges[i] = (Presamples&(1<<i))>>i; | |
658 | } | |
659 | for(int i = 0; i < 4 ; i++){ | |
660 | edges[(3-i)+2] = (Postsamples&(1<<i))>>i; | |
661 | } | |
662 | /*cout << "edges :"; | |
663 | for(int i = 0; i < 6 ; i++) | |
664 | cout << edges[i] << ":"; | |
665 | cout << " Presamples: " << Presamples << " Postsamples: " << Postsamples << endl;*/ | |
666 | ||
667 | //Loop | |
668 | //cout << "AliTPCAltroEmulator::BaselineCorrection2_RTL | starting Loop" << endl; | |
669 | for(int timebin = -12; timebin < ftimebins+10; timebin++){ | |
670 | //cout << "AliTPCAltroEmulator::BaselineCorrection2_RTL | in Loop timebin: " << timebin << endl; | |
671 | din = GetElement(fChannelShort,timebin); | |
672 | ||
673 | s8 = zxOld + (zOld[8] - zOld[0]); | |
674 | ||
675 | if(valid == 1) | |
676 | bsl = s8>>3;// ... | |
677 | else | |
678 | bsl = 0; | |
679 | ||
680 | //assign flag = (din_p > thrhi) | (thrlo > din_p); // Signal samples between thresholds | |
681 | if( (din <= (bsl + thrhi)) && (din >= (bsl - thrlo)) ) | |
682 | flag = 0; | |
683 | else | |
684 | flag = 1; | |
685 | ||
686 | if(pstscnt == 0) | |
687 | fx = 0; | |
688 | else | |
689 | fx = 1; | |
690 | ||
691 | if(valcntOld >= 12) | |
692 | valid = 1; | |
693 | else | |
694 | valid = 0; | |
695 | ||
696 | fNew[3] = flag; | |
697 | ||
698 | if( (fOld[3] == 1) || ( (flag == 1) && ( (edges[0] == 1) || (edges[1] == 1) ) ) ) //f[2] = f[3] | (flag&(edges[0]|edges[1])); | |
699 | fNew[2] = 1; | |
700 | else | |
701 | fNew[2] = 0; | |
702 | ||
703 | if( (fOld[2] == 1) || ( (edges[1] == 1) && (flag == 1) ) ) // f[1] = f[2] | (edges[1] & flag); | |
704 | fNew[1] = 1; | |
705 | else | |
706 | fNew[1] = 0; | |
707 | ||
708 | if( ( (fOld[1] == 1) || ( (flag == 1) && (edges[0] == 1) && (edges[1] == 1) ) || (fx==1) ) && (valid==1) ) // f[0] = (f[1] | (edges[1] & edges[0] & flag) | fx) & valid; | |
709 | fNew[0] = 1; | |
710 | else | |
711 | fNew[0] = 0; | |
712 | ||
713 | dxNew = dOld[0]; | |
714 | for(int i = 0; i < 3; i++) | |
715 | dNew[i] = dOld[i+1]; | |
716 | dNew[3] = din; | |
717 | ||
718 | if( (fOld[1]==1) && (fOld[2]==0) ) | |
719 | pstscnt = Postsamples; | |
720 | else if(fx == 1) | |
721 | pstscnt--; | |
722 | ||
723 | if(fOld[0] == 0){ | |
724 | if(valid == 0) | |
725 | valcntNew = ++valcntOld; | |
726 | ||
727 | zxNew = s8; | |
728 | for(int i = 0; i < 8; i++) | |
729 | zNew[i] = zOld[i+1]; | |
730 | zNew[8] = dOld[0]; | |
731 | }else{ | |
732 | zxNew = zxOld; | |
733 | for(int i = 0; i < 9; i++) | |
734 | zNew[i] = zOld[i]; | |
735 | } | |
736 | dout = dxOld - (bsl - offset); | |
737 | //if(dout <0) | |
738 | // dout = 0; | |
739 | ||
740 | SetElement(fChannelShort,timebin-5,(short)dout); | |
741 | //sim clockschange | |
742 | for(int i = 0; i < 9 ; i++) | |
743 | zOld[i] = zNew[i]; | |
744 | zxOld = zxNew; | |
745 | for(int i = 0; i < 4 ; i++){ | |
746 | fOld[i] = fNew[i]; | |
747 | dOld[i] = dNew[i]; | |
748 | } | |
749 | dxOld = dxNew; | |
750 | valcntOld = valcntNew; | |
751 | } | |
752 | } | |
753 | ||
754 | void AliTPCAltroEmulator::Clipping(){ | |
755 | // | |
756 | // implement if no BC2 clipping has to run | |
757 | // | |
758 | for(int i = 0; i < ftimebins; i++){ | |
759 | if(fChannelShort[i] < 0) | |
760 | fChannelShort[i] = 0; | |
761 | } | |
762 | } | |
763 | ||
764 | void AliTPCAltroEmulator::Zerosuppression(int Threshold, int MinSamplesaboveThreshold, int Presamples, int Postsamples){ | |
765 | // | |
766 | // add again altro feature | |
767 | // | |
768 | ||
769 | //TODO: Implement "Altro zsu merging" | |
770 | //int Postsamplecounter = 0; | |
771 | //int setPostsample = 0; | |
772 | for(int i = 0; i < ftimebins; i++){ | |
773 | if(fChannelShort[i] >= Threshold){ | |
774 | fADCkeep[i] = 1; | |
775 | } | |
776 | } | |
777 | ||
778 | int startofclustersequence = -1; | |
779 | int endofClustersInSequence = -1; | |
780 | ||
781 | for(int i = 0; i < ftimebins; i++){ | |
782 | if( (fADCkeep[i] == 1) && (GetElement(fADCkeep,i-1) == 0) ){ | |
783 | startofclustersequence = i; | |
784 | } | |
785 | if( (fADCkeep[i] == 1) && (GetElement(fADCkeep,i+1) == 0) ){ | |
786 | endofClustersInSequence = i; | |
787 | } | |
788 | //cout << i << " startofclustersequence: " << startofclustersequence << " endofClustersInSequence: " << endofClustersInSequence; | |
789 | if( (startofclustersequence != -1) && (endofClustersInSequence != -1) ){ | |
790 | //cout << " found! " << (endofClustersInSequence - startofclustersequence + 1); | |
791 | if ( (endofClustersInSequence - startofclustersequence + 1) < MinSamplesaboveThreshold ){ | |
792 | for(int j = startofclustersequence; j <= endofClustersInSequence ; j++){ | |
793 | fADCkeep[j] = 0; | |
794 | } | |
795 | } | |
796 | startofclustersequence = -1; | |
797 | endofClustersInSequence = -1; | |
798 | } | |
799 | //cout << endl; | |
800 | } | |
801 | ||
802 | /*for(int i = 0; i < ftimebins; i++){ | |
803 | if( (GetElement(fADCkeep,i-1) == 1) && (GetElement(fADCkeep,i) == 0) && (GetElement(fADCkeep,i+1) == 1) ){ | |
804 | SetElement(fADCkeep,i,1); | |
805 | } | |
806 | }*/ | |
807 | ||
808 | for(int i = 0; i < ftimebins; i++){ | |
809 | if( (fADCkeep[i] == 1) && (GetElement(fADCkeep,i-1) == 0) ){ | |
810 | for(int j = i-Presamples ; j <= i; j++){ | |
811 | SetElement(fADCkeep,j,1); | |
812 | } | |
813 | } | |
814 | } | |
815 | for(int i = ftimebins; i >= 0; i--){ | |
816 | if( (fADCkeep[i] == 1) && (GetElement(fADCkeep,i+1) == 0) ){ | |
817 | for(int j = i ; j <= i+Postsamples; j++){ | |
818 | SetElement(fADCkeep,j,1); | |
819 | } | |
820 | } | |
821 | } | |
822 | /*cout << " Postsamplecounter: " << Postsamplecounter; | |
823 | for(int j = i+1 ; j <= i+Postsamples; j++){ | |
824 | SetElement(fADCkeep,j,1); | |
825 | i+=Postsamples; | |
826 | } | |
827 | cout << endl; | |
828 | } | |
829 | cout << i << " ADCK: " << GetElement(fADCkeep,i); | |
830 | cout << " Postsam: " << Postsamplecounter << " ADCK: " << GetElement(fADCkeep,i);*/ | |
831 | ||
832 | for(int i = 0; i < ftimebins; i++){ | |
833 | if( (fADCkeep[i] == 1) && (GetElement(fADCkeep,i+1) == 0) && ( (GetElement(fADCkeep,i+3) == 1) || (GetElement(fADCkeep,i+2) == 1) ) ){ | |
834 | SetElement(fADCkeep,i+1,1); | |
835 | SetElement(fADCkeep,i+2,1); | |
836 | } | |
837 | } | |
838 | } | |
839 | ||
840 | /** @brief formats the data like the ALTRO. Result is a 64 bit array | |
841 | * | |
842 | * formats the data like the ALTRO. Result is a 64 bit array | |
843 | * | |
844 | */ | |
845 | ||
846 | void AliTPCAltroEmulator::DataFormater(){ | |
847 | // | |
848 | // formats the data like the ALTRO. Result is a 64 bit array | |
849 | // | |
850 | ||
851 | ||
852 | } | |
853 | ||
854 | ||
855 | /** @brief calculates the compression out of the bitmask | |
856 | * | |
857 | * calculates the compression out of the bitmask with the set adc values | |
858 | * | |
859 | * @return \c float consisting of the compression factor | |
860 | */ | |
861 | float AliTPCAltroEmulator::CalculateCompression(){ | |
862 | // | |
863 | // calculates the compression out of the bitmask | |
864 | // | |
865 | ||
866 | // calculation is based on altro 10 bit words .. | |
867 | int sample = 0; | |
868 | int cluster = 0; | |
869 | int data = 0; | |
870 | float retval = 0.0; | |
871 | ||
872 | for(int i = 0; i < ftimebins; i++){ | |
873 | if(fADCkeep[i] == 1){ | |
874 | sample++; | |
875 | } | |
876 | if( (fADCkeep[i] == 1) && (GetElement(fADCkeep,i+1) == 0) ){ | |
877 | cluster++; | |
878 | } | |
879 | } | |
880 | data = sample + cluster*2; | |
881 | data = data + data%4 + 4; | |
882 | if(data >0){ | |
883 | retval = ftimebins / (float)data;//num of timebins is equal to max number of samples | |
884 | }else{ | |
885 | retval = 1.0; | |
886 | } | |
887 | return retval; | |
888 | } | |
889 | ||
890 | short AliTPCAltroEmulator::GetElement(short* Array,int index){ | |
891 | // | |
892 | // | |
893 | // | |
894 | if (index < 0) | |
895 | return 0; | |
896 | else if(index >= ftimebins) | |
897 | return 0; | |
898 | else | |
899 | return Array[index]; | |
900 | } | |
901 | ||
902 | void AliTPCAltroEmulator::SetElement(short* Array,int index,short value){ | |
903 | // | |
904 | // | |
905 | // | |
906 | if (index < 0) | |
907 | return; | |
908 | else if(index >= ftimebins) | |
909 | return; | |
910 | else | |
911 | Array[index] = value; | |
912 | } | |
913 | ||
914 | int AliTPCAltroEmulator::InBand(int ADC,int bsl, int LowThreshold, int HighThreshold){ | |
915 | // | |
916 | // | |
917 | // | |
918 | int fLow = bsl - LowThreshold; | |
919 | int fHigh = bsl + HighThreshold; | |
920 | if( (ADC <= fHigh) && (ADC >= fLow) ) | |
921 | return 1; | |
922 | else | |
923 | return 0; | |
924 | } | |
925 | ||
926 | int AliTPCAltroEmulator::InRange(int parameter,int Low,int High,char *Module,char *ParameterName){ | |
927 | // | |
928 | // | |
929 | // | |
930 | ||
931 | char out[255]; | |
932 | int retval; | |
933 | if(parameter > High){ | |
934 | sprintf(out,"Error | %s | Parameter %s is to big, has to be %d <= %s <= %d, is %d, now set to %d",Module,ParameterName,Low,ParameterName,High,parameter,High); | |
935 | cout << out << endl; | |
936 | retval = High; | |
937 | }else if(parameter < Low){ | |
938 | sprintf(out,"Error | %s | Parameter %s is to small, has to be %d <= %s <= %d, is %d, now set to %d",Module,ParameterName,Low,ParameterName,High,parameter,Low); | |
939 | cout << out << endl; | |
940 | retval = Low; | |
941 | }else{ | |
942 | retval = parameter; | |
943 | } | |
944 | return retval; | |
945 | } | |
946 | ||
947 | short AliTPCAltroEmulator::GetShortChannel(int i){ | |
948 | // | |
949 | // | |
950 | // | |
951 | return GetElement(fChannelShort,i); | |
952 | } | |
953 | ||
954 | short AliTPCAltroEmulator::GetKeepChannel(int i){ | |
955 | // | |
956 | // | |
957 | // | |
958 | return GetElement(fADCkeep,i); | |
959 | } |