]> 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
Add the connected pad info to the simulation (Raphaelle)
[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");
224 fConfiguredAltro = 1;
7409c8db 225 if (!fConfiguredAltro) { //dummy code to avoid warning
226 printf("%d\n",ONDataFormatting); // does not have to be checked
227 }
eb7e0771 228}
229
230/** @brief Configures the Base Line Correction 1 (BSL1) Module
231 *
232 * Configures the Base Line Correction 1 (BSL1) Module. You dont have to build a proper pedestalMemory
233 * array, a pointer of the correct type is enough, of course you are not allowed to use Basline
234 * Correction Modes which need then the array ...\n
235 * All configurable values are "Range checked" and if out of the Range set to the nearest extreme.
236 * So the Emulation will work, but the result is maybe not the expected one.
237 *
238 * @param mode an <tt> int </tt> sets the mode of the Baseline Correction. See the Altro manual for a description
239 * @param ValuePeDestal an <tt> int </tt> this is the baseline of the Channel.
240 * @param PedestalMem an <tt> *int </tt> Pointer to a 1d short Array with the pedestal memory Data
241 * @param polarity an <tt> int </tt> Switch (0,1) for the polarity
242 */
243void AliTPCAltroEmulator::ConfigBaselineCorrection1(int mode, int ValuePeDestal, int *PedestalMem, int polarity){
244 //
245 // Configures the Base Line Correction 1 (BSL1) Module
246 //
247 fBSL1mode = InRange(mode,0,10,"AliTPCAltroEmulator::ConfigBaselineCorrection1","mode");
248 fBSL1ValuePeDestal = InRange(ValuePeDestal,0,1023,"AliTPCAltroEmulator::BaselineCorrection1","ValuePeDestal");
249 fBSL1PedestalMem = PedestalMem;
250 fBSL1polarity = InRange(polarity,0,1,"AliTPCAltroEmulator::BaselineCorrection1","polarity");
251 fConfiguredBSL1 = 1;
252}
253
254/** @brief Configures the Tail Cancellation Filter (TCF) Module
255 *
256 * Configures the Tail Cancellation Filter (TCF) Module. You have to set the coefficients in the
257 * Integer version.\n
258 * To convert from int to float use (int)*(pow(2,-16)-1)
259 * To convert from float to int usw (float)*(pow(2,16)-1)
260 * All configurable values are "Range checked" and if out of the Range set to the nearest extreme.
261 * So the Emulation will work, but the result is maybe not the expected one.
262 *
263 * @param K1 an <tt> int </tt> sets the K1 coeeficient of the TCF
264 * @param K2 an <tt> int </tt> sets the K2 coeeficient of the TCF
265 * @param K3 an <tt> int </tt> sets the K3 coeeficient of the TCF
266 * @param L1 an <tt> int </tt> sets the L1 coeeficient of the TCF
267 * @param L2 an <tt> int </tt> sets the L2 coeeficient of the TCF
268 * @param L3 an <tt> int </tt> sets the L3 coeeficient of the TCF
269 */
270void AliTPCAltroEmulator::ConfigTailCancellationFilter(int K1, int K2, int K3, int L1, int L2, int L3){
271 //
272 // Configures the Tail Cancellation Filter (TCF) Module
273 //
274 // conf from int to fp: (int)*(pow(2,-16)-1)
275 // backway: (float)*(pow(2,16)-1)
276 fTCFK1Int = InRange(K1,0,65535,"AliTPCAltroEmulator::ConfigTailCancellationFilter","K1");
277 fTCFK2Int = InRange(K2,0,65535,"AliTPCAltroEmulator::ConfigTailCancellationFilter","K2");
278 fTCFK3Int = InRange(K3,0,65535,"AliTPCAltroEmulator::ConfigTailCancellationFilter","K3");
279
280 fTCFL1Int = InRange(L1,0,65535,"AliTPCAltroEmulator::ConfigTailCancellationFilter","L1");
281 fTCFL2Int = InRange(L2,0,65535,"AliTPCAltroEmulator::ConfigTailCancellationFilter","L2");
282 fTCFL3Int = InRange(L3,0,65535,"AliTPCAltroEmulator::ConfigTailCancellationFilter","L3");
283 fConfiguredTCF = 1;
284}
285
286/** @brief Configures the Moving Average Filter (BSL2) Module
287 *
288 * Configures the Moving Average Filter (BSL2) Module.
289 * All configurable values are "Range checked" and if out of the Range set to the nearest extreme.
290 * So the Emulation will work, but the result is maybe not the expected one.
291 *
292 * @param HighThreshold an <tt> int </tt> sets the high Threshold
293 * @param LowThreshold an <tt> int </tt> sets the low Theshold
294 * @param Offset an <tt> int </tt> sets the the offset which is added to the Signal
295 * @param Presamples an <tt> int </tt> sets the number of pre samples excluded from the moving average caclulation
296 * @param Postsamples an <tt> int </tt> sets the number of post samples excluded from the moving average caclulation
297 */
298void AliTPCAltroEmulator::ConfigBaselineCorrection2(int HighThreshold, int LowThreshold, int Offset, int Presamples, int Postsamples){
299 //
300 // Configures the Moving Average Filter (BSL2) Module
301 //
302 fBSL2HighThreshold = InRange(HighThreshold,0,1023,"AliTPCAltroEmulator::ConfigBaselineCorrection2","HighThreshold");
303 fBSL2LowThreshold = InRange(LowThreshold,0,1023,"AliTPCAltroEmulator::ConfigBaselineCorrection2","LowThreshold");
304 fBSL2Offset = InRange(Offset,0,1023,"AliTPCAltroEmulator::ConfigBaselineCorrection2","Offset");
305 fBSL2Presamples = InRange(Presamples,0,3,"AliTPCAltroEmulator::ConfigBaselineCorrection2","Presamples");
306 fBSL2Postsamples = InRange(Postsamples,0,15,"AliTPCAltroEmulator::ConfigBaselineCorrection2","Postsamples");
307 fConfiguredBSL2 = 1;
308}
309
310/** @brief Configures the Zero Suppression Module (ZSU)
311 *
312 * Configures the Zero Suppression Module (ZSU).
313 * All configurable values are "Range checked" and if out of the Range set to the nearest extreme.
314 * So the Emulation will work, but the result is maybe not the expected one.
315 *
316 * @param Threshold an <tt> int </tt> sets the Threshold
317 * @param MinSamplesaboveThreshold an <tt> int </tt> sets the minimum number of samples which have to be greater than the threshold
318 * @param Presamples an <tt> int </tt> sets the number of pre samples which are kept
319 * @param Postsamples an <tt> int </tt> sets the number of post samples which are kept
320 */
321void AliTPCAltroEmulator::ConfigZerosuppression(int Threshold, int MinSamplesaboveThreshold, int Presamples, int Postsamples){
322 //
323 // Configures the Zero Suppression Module (ZSU)
324 //
325 fZSUThreshold = InRange(Threshold,0,1023,"AliTPCAltroEmulator::BaselineCorrection1","Threshold");
326 fZSUMinSamplesaboveThreshold = InRange(MinSamplesaboveThreshold,1,3,"AliTPCAltroEmulator::BaselineCorrection1","MinSamplesaboveThreshold");
327 fZSUPresamples = InRange(Presamples,0,3,"AliTPCAltroEmulator::BaselineCorrection1","Presamples");
328 fZSUPostsamples = InRange(Postsamples,0,7,"AliTPCAltroEmulator::BaselineCorrection1","Postsamples");
329 fADCkeep = (short *)calloc(sizeof(short),ftimebins);
330
331 for(int i = 0; i < ftimebins; i++){
332 fADCkeep[i] = 0;
333 }
334 fConfiguredZSU = 1;
335}
336
337/** @brief Prints the set Parameters, if module is configured
338 *
339 * Prints the set Parameters, if module is configured.
340 */
341void AliTPCAltroEmulator::PrintParameters(){
342 //
343 // Prints the set Parameters, if module is configured
344 //
345 cout << "+-------------------------------------------+" << endl;
346 cout << "| Configured Parameters of the Altro Module |" << endl;
347 cout << "+-------------------------------------------+" << endl << endl;
348
349 cout << "Parameters set in the Altro Modules:" << endl << endl;
350 cout << "ONBaselineCorrection1: " << fOnBSL1 << endl;
351 cout << "ONTailcancellation : " << fOnTCF << endl;
352 cout << "ONBaselineCorrection2: " << fOnBSL2 << endl;
353 cout << "ONClipping : " << fOnClip << endl;
354 cout << "ONZerosuppression : " << fOnZSU << endl << endl << endl;
355 if(fConfiguredBSL1 == 1){
356 cout << "Parameters set in the BSL1 (Baseline Correction 1) Module:" << endl << endl;
357 cout << "mode : " << fBSL1mode << endl;
358 cout << "ValuePeDestal : " << fBSL1ValuePeDestal << endl;
359 cout << "polarity : " << fBSL1ValuePeDestal << endl << endl << endl;
360 }else{
361 cout << "BSL1 (Baseline Correction 1) Module not configured!" << endl << endl << endl;
362 }
363 if(fConfiguredTCF == 1){
364 cout << "Parameters set in the TCF (TailCancellation Filter) Module:" << endl << endl;
365 cout << "K1 (int|float) : " << fTCFK1Int << " | " << fTCFK1Int/(float)((1<<16)-1) << endl;
366 cout << "K2 (int|float) : " << fTCFK2Int << " | " << fTCFK2Int/(float)((1<<16)-1) << endl;
367 cout << "K3 (int|float) : " << fTCFK3Int << " | " << fTCFK3Int/(float)((1<<16)-1) << endl;
368 cout << "L1 (int|float) : " << fTCFL1Int << " | " << fTCFL1Int/(float)((1<<16)-1) << endl;
369 cout << "L2 (int|float) : " << fTCFL2Int << " | " << fTCFL2Int/(float)((1<<16)-1) << endl;
370 cout << "L3 (int|float) : " << fTCFL3Int << " | " << fTCFL3Int/(float)((1<<16)-1) << endl << endl << endl;
371 }else{
372 cout << "TCF (TailCancellation Filter) Module not configured!" << endl << endl << endl;
373 }
374 if(fConfiguredBSL2 == 1){
375 cout << "Parameters set in the BSL2 (Baseline Correction 2) Module:" << endl << endl;
376 cout << "HighThreshold : " << fBSL2HighThreshold << endl;
377 cout << "LowThreshold : " << fBSL2LowThreshold << endl;
378 cout << "Offset : " << fBSL2Offset << endl;
379 cout << "Presamples : " << fBSL2Presamples << endl;
380 cout << "Postsamples : " << fBSL2Postsamples << endl << endl << endl;
381 }else{
382 cout << "BSL2 (Baseline Correction 2) Module not configured!" << endl << endl << endl;
383 }
384 if(fConfiguredZSU == 1){
385 cout << "Parameters set in the ZSU (Zero Suppression Unit) Module:" << endl << endl;
386 cout << "Threshold : " << fZSUThreshold << endl;
387 cout << "MinSampaboveThreshold: " << fZSUMinSamplesaboveThreshold << endl;
388 cout << "Presamples : " << fZSUPresamples << endl;
389 cout << "Postsamples : " << fZSUPostsamples << endl << endl << endl;
390 }else{
391 cout << "ZSU (Zero Suppression Unit) Module not configured!" << endl << endl << endl;
392 }
393}
394
395/** @brief Runs the emulation of all configured Modules.
396 *
397 * Runs the emulation of all configured Modules. This changes then the content of the
398 * input Array
399 */
400void AliTPCAltroEmulator::RunEmulation(){
401 //
402 // Runs the emulation of all configured Modules.
403 //
404
405 //cout << "AliTPCAltroEmulator::RunEmulation | start" << endl;
406 if(fConfiguredAltro == 0){
407 cout << "ERROR cant run Altro Emulation because not configured" << endl;
408 return;
409 }
410
411 //cout << "AliTPCAltroEmulator::RunEmulation | start BSL1 on: " << fOnBSL1 << " configures: " << fConfiguredBSL1 << endl;
412 if(fOnBSL1 == 1){
413 if(fConfiguredBSL1 == 1){
414 BaselineCorrection1(fBSL1mode, fBSL1ValuePeDestal, fBSL1PedestalMem, fBSL1polarity);
415 }else{
416 cout << "ERROR cant run Baseline Correction 1 because not configured" << endl;
417 return;
418 }
419 }
420
421 //cout << "AliTPCAltroEmulator::RunEmulation | start TCF on: " << fOnTCF << " configures: " << fConfiguredTCF << endl;
422 if(fOnTCF == 1){
423 if(fConfiguredTCF == 1){
424 TailCancellationFilterFixedPoint(fTCFK1Int, fTCFK2Int, fTCFK3Int, fTCFL1Int, fTCFL2Int, fTCFL3Int);
425 }else{
426 cout << "ERROR cant run Tail Cancellation Filter because not configured" << endl;
427 return;
428 }
429 }
430
431 //cout << "AliTPCAltroEmulator::RunEmulation | start BSL2 on: " << fOnBSL2 << " configures: " << fConfiguredBSL2 << endl;
432 if(fOnBSL2 == 1){
433 if(fConfiguredBSL2 == 1){
434 BaselineCorrection2RTL(fBSL2HighThreshold, fBSL2LowThreshold, fBSL2Offset, fBSL2Presamples, fBSL2Postsamples);
435 }else{
436 cout << "ERROR cant run Baseline Correction 2 because not configured" << endl;
437 return;
438 }
439 }
440 //cout << "AliTPCAltroEmulator::RunEmulation | start CLIP on: " << fOnClip << endl;
441 if(fOnClip == 1){
442 Clipping();
443 }
444 //cout << "AliTPCAltroEmulator::RunEmulation | start ZSU on: " << fOnZSU << " configures: " << fConfiguredZSU << endl;
445 if(fOnZSU == 1){
446 if(fConfiguredZSU == 1){
447 Zerosuppression(fZSUThreshold,fZSUMinSamplesaboveThreshold,fZSUPresamples,fZSUPostsamples);
448 }else{
449 cout << "ERROR cant run Zero Suppression Unit because not configured" << endl;
450 return;
451 }
452 }
453}
454
455void AliTPCAltroEmulator::BaselineCorrection1(int mode, int ValuePeDestal, int *PedestalMem, int polarity){
456 //
457 // BaselineCorrection1
458 //
459
460 //VPD == 0 !!
461 int fixedPeDestal = 0;
462
463 if(polarity ==1){
464 for(int i = 0; i < ftimebins; i++){
465 fChannelShort[i] = 1023 - fChannelShort[i];
466 }
467 }
468
469 switch(mode) {
470 case kDINxFPD:
471 for(int i = 0; i < ftimebins; i++)
472 fChannelShort[i] = fChannelShort[i] - fixedPeDestal;
473 break;
474 case kDINxFT:
475 for(int i = 0; i < ftimebins; i++)
476 fChannelShort[i] = fChannelShort[i] - PedestalMem[i];
477 break;
478 case kDINxFDIN:
479 for(int i = 0; i < ftimebins; i++)
480 fChannelShort[i] = fChannelShort[i] - PedestalMem[ fChannelShort[i] ];
481 break;
482 case kDINxFDINxVPD:
483 for(int i = 0; i < ftimebins; i++)
484 fChannelShort[i] = fChannelShort[i] - PedestalMem[ fChannelShort[i] - ValuePeDestal];
485 break;
486 case kDINxVPDxFPD:
487 for(int i = 0; i < ftimebins; i++)
488 fChannelShort[i] = fChannelShort[i] - ValuePeDestal - fixedPeDestal;
489 break;
490 case kDINxVPDxFT:
491 for(int i = 0; i < ftimebins; i++)
492 fChannelShort[i] = fChannelShort[i] - ValuePeDestal - PedestalMem[i];
493 break;
494 case kDINxVPDxFDIN:
495 for(int i = 0; i < ftimebins; i++)
496 fChannelShort[i] = fChannelShort[i] - ValuePeDestal - PedestalMem[ fChannelShort[i] ];
497 break;
498 case kDINxVPDxFDINxVPD:
499 for(int i = 0; i < ftimebins; i++)
500 fChannelShort[i] = fChannelShort[i] - ValuePeDestal - PedestalMem[ fChannelShort[i] - ValuePeDestal ];
501 break;
502 case kFDINxFPD:
503 for(int i = 0; i < ftimebins; i++)
504 fChannelShort[i] = PedestalMem[ fChannelShort[i] ] - fixedPeDestal;
505 break;
506 case kFDINxVPDxFPD:
507 for(int i = 0; i < ftimebins; i++)
508 fChannelShort[i] = PedestalMem[ fChannelShort[i] - ValuePeDestal ] - fixedPeDestal;
509 break;
510 case kFTxFPD:
511 for(int i = 0; i < ftimebins; i++)
512 fChannelShort[i] = PedestalMem[i] - fixedPeDestal;
513 break;
514 }
515}
516
517int AliTPCAltroEmulator::Multiply36(int P, int N){
518 //
519 // multiply function to emulate the 36 bit fixed point multiplication of the Altro.
520 //
521 long long retval =0;
522 long long temp = 0;
523 long long vAX = 0;
524 temp = (long long)P*(long long)N;
525 vAX = (( Mask(temp,35,18) + ((long long)(-P)<<18) ) + Mask(temp,17,0));
526 if ( Maskandshift(N,17,17) == 1){
527 retval = ((Maskandshift(vAX,35,35)<<17) + Maskandshift(vAX,32,16));
528 }else{
529 retval = Maskandshift(temp,32,16);
530 }
531 return retval;
532}
533long long AliTPCAltroEmulator::Mask(long long in, int left, int right){
534 //
535 //
536 //
537 long long retval;
538 long long pattern;
539 long long length = abs(left - right)+1;
540 pattern = ((1<<length)-1)<<right;
541 retval = in&pattern;
542 return retval;
543}
544
545long long AliTPCAltroEmulator::Maskandshift(long long in, int left, int right){
546 //
547 //
548 //
549 long long retval;
550 long long pattern;
551 long long length = abs(left - right)+1;
552 pattern = ((1<<length)-1);
553 retval = (in>>right)&pattern;
554 return retval;
555}
556
557void AliTPCAltroEmulator::TailCancellationFilterFixedPoint(int K1, int K2, int K3, int L1, int L2, int L3){
558 //
559 // TailCancellationFilterFixedPoint
560 //
561 int c1n = 0, c2n = 0, c3n = 0;
562 int c1o = 0, c2o = 0, c3o = 0;
563 int d1 = 0, d2 = 0;
564 int dout = 0;
565 int din = 0;
566 int bit = 0;
567 for(int i = 0; i < ftimebins; i++){
568 din = fChannelShort[i];
569
570 din = (din<<2);
571 c1n = Mask( (Mask(din,17,0) + Multiply36(K1,Mask(c1o,17,0)) ) ,17,0);
572 d1 = Mask( (Mask(c1n,17,0) - Multiply36(L1,Mask(c1o,17,0)) ) ,17,0);
573 //d1 = Mask( (Mask(c1n,17,0) + Mask(~Multiply36(L1,Mask(c1o,17,0))+1,17,0) ) ,17,0);
574
575 c2n = Mask( (Mask(d1 ,17,0) + Multiply36(K2,Mask(c2o,17,0)) ) ,17,0);
576 d2 = Mask( (Mask(c2n,17,0) - Multiply36(L2,Mask(c2o,17,0)) ) ,17,0);
577 //d2 = Mask( (Mask(c2n,17,0) + Mask(~Multiply36(L2,Mask(c2o,17,0))+1,17,0) ) ,17,0);
578
579 c3n = Mask( (Mask(d2 ,17,0) + Multiply36(K3,Mask(c3o,17,0)) ) ,17,0);
580 dout = Mask( (Mask(c3n,17,0) - Multiply36(L3,Mask(c3o,17,0)) ) ,17,0);
581 //dout = Mask( (Mask(c3n,17,0) + Mask(~Multiply36(L3,Mask(c3o,17,0))+1,17,0) ) ,17,0);
582
583 if( (Maskandshift(dout,2,2) == 1) || (Maskandshift(dout,1,1) == 1)){
584 bit = 1;
585 }else{
586 bit = 0;
587 }
588
589 dout = ((dout>>3)<<1) + bit;
590 if(Maskandshift(dout,15,15) == 1){
591 //is needed to get the correct coding when getting negative results
592 dout = -Mask((-Mask(dout,9,0)),9,0);
593 }else{
594 dout = Mask(dout,9,0);
595 }
596
597 fChannelShort[i] = (short) dout;
598 c1o = c1n;
599 c2o = c2n;
600 c3o = c3n;
601 }
602}
603
604void AliTPCAltroEmulator::BaselineCorrection2RTL(int HighThreshold, int LowThreshold, int Offset, int Presamples, int Postsamples){
605 //
606 // BaselineCorrection2RTL
607 //
608
609 //cout << "Altro::BaselineCorrection2RTL | HighThreshold: " << HighThreshold << " LowThreshold: " << LowThreshold << " Offset: " << Offset << " Presamples: " << Presamples << " Postsamples: " << Postsamples << endl;
610 //more or less direct "translation" of the hdl code.
611 //Input signals
612 int din;
613 int dout;
614 int edges[6]; // = Postsamples*4 + Presamples;
615 int offset = Offset;
616 int thrlo = LowThreshold;//called thr_mau[19] ...
617 int thrhi = HighThreshold;
618
619 // Variables
620 int fOld[4]; //flag pipe
621 int fNew[4]; //flag pipe
622 int dOld[4]; //data pipe
623 int dNew[4]; //data pipe
624 int dxOld;
625 int dxNew;
626 int pstscnt; // Counter for Postsamples
627 int zOld[9]; // Filter stages
628 int zNew[9]; // Filter stages
629 int zxOld; //Accumulator stage
630 int zxNew; //Accumulator stage
631 int valcntOld; //Valid sample counter
632 int valcntNew = 0; //Valid sample counter
633
634 int valid; //Valid flag
635 int fx; //postsample flag
636 //int s07; // differentiator result
637 int s8; // Acc + Diff result
638 int flag;
639 //int bsth; //baseline threshold
640 //int din_p; //Data input strictly positive
641 int bsl;
642 //int dx_bsls; // dx -bsl
643 //int dx_clip; // dxbsl clipped
644 //int bsl_of = 0;
645
646 //initialisation
647 for(int i = 0; i < 9 ; i++)
648 zOld[i] = 0;
649 for(int i = 0; i < 4 ; i++){
650 fOld[i] = 0;
651 dOld[i] = 0;
652 }
653 dxOld= 0;
654 pstscnt = 0;
655 zxOld = 0;
656 valcntOld = 0;
657 valid = 0;
658 for(int i = 0; i < 2 ; i++){
659 edges[i] = (Presamples&(1<<i))>>i;
660 }
661 for(int i = 0; i < 4 ; i++){
662 edges[(3-i)+2] = (Postsamples&(1<<i))>>i;
663 }
664 /*cout << "edges :";
665 for(int i = 0; i < 6 ; i++)
666 cout << edges[i] << ":";
667 cout << " Presamples: " << Presamples << " Postsamples: " << Postsamples << endl;*/
668
669 //Loop
670 //cout << "AliTPCAltroEmulator::BaselineCorrection2_RTL | starting Loop" << endl;
671 for(int timebin = -12; timebin < ftimebins+10; timebin++){
672 //cout << "AliTPCAltroEmulator::BaselineCorrection2_RTL | in Loop timebin: " << timebin << endl;
673 din = GetElement(fChannelShort,timebin);
674
675 s8 = zxOld + (zOld[8] - zOld[0]);
676
677 if(valid == 1)
678 bsl = s8>>3;// ...
679 else
680 bsl = 0;
681
682 //assign flag = (din_p > thrhi) | (thrlo > din_p); // Signal samples between thresholds
683 if( (din <= (bsl + thrhi)) && (din >= (bsl - thrlo)) )
684 flag = 0;
685 else
686 flag = 1;
687
688 if(pstscnt == 0)
689 fx = 0;
690 else
691 fx = 1;
692
693 if(valcntOld >= 12)
694 valid = 1;
695 else
696 valid = 0;
697
698 fNew[3] = flag;
699
700 if( (fOld[3] == 1) || ( (flag == 1) && ( (edges[0] == 1) || (edges[1] == 1) ) ) ) //f[2] = f[3] | (flag&(edges[0]|edges[1]));
701 fNew[2] = 1;
702 else
703 fNew[2] = 0;
704
705 if( (fOld[2] == 1) || ( (edges[1] == 1) && (flag == 1) ) ) // f[1] = f[2] | (edges[1] & flag);
706 fNew[1] = 1;
707 else
708 fNew[1] = 0;
709
710 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;
711 fNew[0] = 1;
712 else
713 fNew[0] = 0;
714
715 dxNew = dOld[0];
716 for(int i = 0; i < 3; i++)
717 dNew[i] = dOld[i+1];
718 dNew[3] = din;
719
720 if( (fOld[1]==1) && (fOld[2]==0) )
721 pstscnt = Postsamples;
722 else if(fx == 1)
723 pstscnt--;
724
725 if(fOld[0] == 0){
726 if(valid == 0)
727 valcntNew = ++valcntOld;
728
729 zxNew = s8;
730 for(int i = 0; i < 8; i++)
731 zNew[i] = zOld[i+1];
732 zNew[8] = dOld[0];
733 }else{
734 zxNew = zxOld;
735 for(int i = 0; i < 9; i++)
736 zNew[i] = zOld[i];
737 }
738 dout = dxOld - (bsl - offset);
739 //if(dout <0)
740 // dout = 0;
741
742 SetElement(fChannelShort,timebin-5,(short)dout);
743 //sim clockschange
744 for(int i = 0; i < 9 ; i++)
745 zOld[i] = zNew[i];
746 zxOld = zxNew;
747 for(int i = 0; i < 4 ; i++){
748 fOld[i] = fNew[i];
749 dOld[i] = dNew[i];
750 }
751 dxOld = dxNew;
752 valcntOld = valcntNew;
753 }
754}
755
756void AliTPCAltroEmulator::Clipping(){
757 //
758 // implement if no BC2 clipping has to run
759 //
760 for(int i = 0; i < ftimebins; i++){
761 if(fChannelShort[i] < 0)
762 fChannelShort[i] = 0;
763 }
764}
765
766void AliTPCAltroEmulator::Zerosuppression(int Threshold, int MinSamplesaboveThreshold, int Presamples, int Postsamples){
767 //
768 // add again altro feature
769 //
770
771 //TODO: Implement "Altro zsu merging"
772 //int Postsamplecounter = 0;
773 //int setPostsample = 0;
774 for(int i = 0; i < ftimebins; i++){
775 if(fChannelShort[i] >= Threshold){
776 fADCkeep[i] = 1;
777 }
778 }
779
780 int startofclustersequence = -1;
781 int endofClustersInSequence = -1;
782
783 for(int i = 0; i < ftimebins; i++){
784 if( (fADCkeep[i] == 1) && (GetElement(fADCkeep,i-1) == 0) ){
785 startofclustersequence = i;
786 }
787 if( (fADCkeep[i] == 1) && (GetElement(fADCkeep,i+1) == 0) ){
788 endofClustersInSequence = i;
789 }
790 //cout << i << " startofclustersequence: " << startofclustersequence << " endofClustersInSequence: " << endofClustersInSequence;
791 if( (startofclustersequence != -1) && (endofClustersInSequence != -1) ){
792 //cout << " found! " << (endofClustersInSequence - startofclustersequence + 1);
793 if ( (endofClustersInSequence - startofclustersequence + 1) < MinSamplesaboveThreshold ){
794 for(int j = startofclustersequence; j <= endofClustersInSequence ; j++){
795 fADCkeep[j] = 0;
796 }
797 }
798 startofclustersequence = -1;
799 endofClustersInSequence = -1;
800 }
801 //cout << endl;
802 }
803
804 /*for(int i = 0; i < ftimebins; i++){
805 if( (GetElement(fADCkeep,i-1) == 1) && (GetElement(fADCkeep,i) == 0) && (GetElement(fADCkeep,i+1) == 1) ){
806 SetElement(fADCkeep,i,1);
807 }
808 }*/
809
810 for(int i = 0; i < ftimebins; i++){
811 if( (fADCkeep[i] == 1) && (GetElement(fADCkeep,i-1) == 0) ){
812 for(int j = i-Presamples ; j <= i; j++){
813 SetElement(fADCkeep,j,1);
814 }
815 }
816 }
817 for(int i = ftimebins; i >= 0; i--){
818 if( (fADCkeep[i] == 1) && (GetElement(fADCkeep,i+1) == 0) ){
819 for(int j = i ; j <= i+Postsamples; j++){
820 SetElement(fADCkeep,j,1);
821 }
822 }
823 }
824 /*cout << " Postsamplecounter: " << Postsamplecounter;
825 for(int j = i+1 ; j <= i+Postsamples; j++){
826 SetElement(fADCkeep,j,1);
827 i+=Postsamples;
828 }
829 cout << endl;
830 }
831 cout << i << " ADCK: " << GetElement(fADCkeep,i);
832 cout << " Postsam: " << Postsamplecounter << " ADCK: " << GetElement(fADCkeep,i);*/
833
834 for(int i = 0; i < ftimebins; i++){
835 if( (fADCkeep[i] == 1) && (GetElement(fADCkeep,i+1) == 0) && ( (GetElement(fADCkeep,i+3) == 1) || (GetElement(fADCkeep,i+2) == 1) ) ){
836 SetElement(fADCkeep,i+1,1);
837 SetElement(fADCkeep,i+2,1);
838 }
839 }
840}
841
842/** @brief formats the data like the ALTRO. Result is a 64 bit array
843 *
844 * formats the data like the ALTRO. Result is a 64 bit array
845 *
846 */
847
848void AliTPCAltroEmulator::DataFormater(){
849 //
850 // formats the data like the ALTRO. Result is a 64 bit array
851 //
852
853
854}
855
856
857/** @brief calculates the compression out of the bitmask
858 *
859 * calculates the compression out of the bitmask with the set adc values
860 *
861 * @return \c float consisting of the compression factor
862 */
863float AliTPCAltroEmulator::CalculateCompression(){
864 //
865 // calculates the compression out of the bitmask
866 //
867
868 // calculation is based on altro 10 bit words ..
869 int sample = 0;
870 int cluster = 0;
871 int data = 0;
872 float retval = 0.0;
873
874 for(int i = 0; i < ftimebins; i++){
875 if(fADCkeep[i] == 1){
876 sample++;
877 }
878 if( (fADCkeep[i] == 1) && (GetElement(fADCkeep,i+1) == 0) ){
879 cluster++;
880 }
881 }
882 data = sample + cluster*2;
883 data = data + data%4 + 4;
884 if(data >0){
885 retval = ftimebins / (float)data;//num of timebins is equal to max number of samples
886 }else{
887 retval = 1.0;
888 }
889 return retval;
890}
891
892short AliTPCAltroEmulator::GetElement(short* Array,int index){
893 //
894 //
895 //
896 if (index < 0)
897 return 0;
898 else if(index >= ftimebins)
899 return 0;
900 else
901 return Array[index];
902}
903
904void AliTPCAltroEmulator::SetElement(short* Array,int index,short value){
905 //
906 //
907 //
908 if (index < 0)
909 return;
910 else if(index >= ftimebins)
911 return;
912 else
913 Array[index] = value;
914}
915
916int AliTPCAltroEmulator::InBand(int ADC,int bsl, int LowThreshold, int HighThreshold){
917 //
918 //
919 //
920 int fLow = bsl - LowThreshold;
921 int fHigh = bsl + HighThreshold;
922 if( (ADC <= fHigh) && (ADC >= fLow) )
923 return 1;
924 else
925 return 0;
926}
927
a6e0ebfe 928int AliTPCAltroEmulator::InRange(int parameter,int Low,int High,const char *Module,const char *ParameterName){
eb7e0771 929 //
930 //
931 //
932
933 char out[255];
934 int retval;
935 if(parameter > High){
936 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);
937 cout << out << endl;
938 retval = High;
939 }else if(parameter < Low){
940 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);
941 cout << out << endl;
942 retval = Low;
943 }else{
944 retval = parameter;
945 }
946 return retval;
947}
948
949short AliTPCAltroEmulator::GetShortChannel(int i){
950 //
951 //
952 //
953 return GetElement(fChannelShort,i);
954}
955
956short AliTPCAltroEmulator::GetKeepChannel(int i){
957 //
958 //
959 //
960 return GetElement(fADCkeep,i);
961}