]> git.uio.no Git - u/mrichter/AliRoot.git/blame - TPC/AliTPCAltroEmulator.cxx
git://git.uio.no / u / mrichter / AliRoot.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Fix in documentation
[u/mrichter/AliRoot.git] / TPC / AliTPCAltroEmulator.cxx
CommitLineData
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
43ClassImp(AliTPCAltroEmulator)
44
b479e253 45AliTPCAltroEmulator::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
117AliTPCAltroEmulator::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 */
177AliTPCAltroEmulator::~AliTPCAltroEmulator(){
178 //
179 // Destructor of Altro Class
180 //
181
182 if(fConfiguredZSU == 1)
183 delete fADCkeep;
184}
185
186//_____________________________________________________________________________
187AliTPCAltroEmulator& 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 */
215void 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 */
241void 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 */
268void 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 */
296void 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 */
319void 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 */
339void 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 */
398void 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
453void 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
515int 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}
531long 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
543long 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
555void 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
602void 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
754void 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
764void 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
846void 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 */
861float 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
890short 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
902void 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
914int 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
926int 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
947short AliTPCAltroEmulator::GetShortChannel(int i){
948 //
949 //
950 //
951 return GetElement(fChannelShort,i);
952}
953
954short AliTPCAltroEmulator::GetKeepChannel(int i){
955 //
956 //
957 //
958 return GetElement(fADCkeep,i);
959}