Correct character constantness
[u/mrichter/AliRoot.git] / TPC / AliTPCAltroEmulator.cxx
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
42
43 ClassImp(AliTPCAltroEmulator)
44
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 {
94   //
95   // Constructor of Altro Class
96   //
97   /*
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;
113   */
114 }
115
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 {
166   //
167   // copy constructor of Altro Class
168   //
169
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");
224   fConfiguredAltro = 1;
225   if (!fConfiguredAltro) { //dummy code to avoid warning
226     printf("%d\n",ONDataFormatting); // does not have to be checked
227   }
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  */
243 void 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  */
270 void 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  */
298 void 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  */
321 void 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  */
341 void 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  */
400 void 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
455 void 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
517 int 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 }
533 long 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
545 long 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
557 void 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
604 void 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
756 void 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
766 void 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
848 void 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  */
863 float 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
892 short 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
904 void 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
916 int 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
928 int AliTPCAltroEmulator::InRange(int parameter,int Low,int High,const char *Module,const char *ParameterName){
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
949 short AliTPCAltroEmulator::GetShortChannel(int i){
950   //
951   //
952   //
953   return GetElement(fChannelShort,i);
954 }
955
956 short AliTPCAltroEmulator::GetKeepChannel(int i){
957   //
958   //
959   //
960   return GetElement(fADCkeep,i);
961 }