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 /////////////////////////////////////////////////////////////////////////////////////////////////////
  22 //     Class for emulation of the ALTRO chip (Altro digital Chain) in C++                          //
  23 //     Author: Roland Bramm                                                                        //
  24 //                                                                                                 //
  25 //     NOTE: This class has been modified to be conform with the coding conventions of the         //
  26 //           ALICE Off-line Project. Keywords for setting the mode of BSC1 were modified           //
  27 //           and are shown in the header file ...                                                  //
  28 //                           Stefan Rossegger, 8th february 2008                                   //
  29 /////////////////////////////////////////////////////////////////////////////////////////////////////
  30
  31 #include <AliTPCAltroEmulator.h>
  32 #include <TH1F.h>
  33 #include <TMath.h>
  34 #include <TSystem.h>
  35 #include <AliDAQ.h>
  36 #include <AliRawReader.h>
  37 #include <AliRawVEvent.h>
  38 #include <AliRawData.h>
  39 #include <AliRawVEquipment.h>
  40 #include <AliRawEquipmentHeader.h>
  41 #include <AliTPCRawStreamV3.h>
  42 #include <TCanvas.h>
  43
  44
  45 /**     @brief Consturctor of Altro Class
  46  *
  47  *      Consturctor of Altro Class, some variables are set.\n
  48  *      The input Data is altered, so after running the complete emulation you have the
  49  *      Altro Processed Data in the Channel Pointer.\n
  50  *
  51  *      @param timebins an <tt> int </tt> sets the length of the input Data (Channel)
  52  *      @param Channel an <tt> short* </tt> Pointer to a 1d Short_tArray with the input Data
  53  */
  54
  55
  56 ClassImp(AliTPCAltroEmulator)
  57
  58 AliTPCAltroEmulator::AliTPCAltroEmulator(Int_t timebins, short* Channel) :
  59   TNamed(),
  60   ftimebins(timebins),
  61 //  fChannelIn(Channel),
  62   fChannelShort(Channel),
  63   fADCkeep(0),
  64   fOnBSL1(0),
  65   fOnTCF(0),
  66   fOnBSL2(0),
  67   fOnClip(0),
  68   fOnZSU(0),
  69
  70   fConfiguredAltro(0),   // ConfiguredAltro
  71   fConfiguredBSL1(0),    // ConfiguredBSL1
  72   fConfiguredTCF(0),     // ConfiguredTCF
  73   fConfiguredTCFraw(0),     // ConfiguredTCF
  74   fConfiguredBSL2(0),    // ConfiguredBSL2
  75   fConfiguredZSU(0),     // ConfiguredZSU
  76   fBSL1mode(0),          // BSL1mode
  77   fBSL1ValuePeDestal(0), // BSL1ValuePeDestal
  78   fBSL1PedestalMem(0),   // BSL1PedestalMem
  79   fBSL1polarity(0),      // BSL1polarity
  80
  81   fTCFK1(0), // K1
  82   fTCFK2(0), // K2
  83   fTCFK3(0), // K3
  84   fTCFL1(0), // L1
  85   fTCFL2(0), // L2
  86   fTCFL3(0), // L3
  87
  88   fTCFK1Int(0), // K1Int
  89   fTCFK2Int(0), // K2Int
  90   fTCFK3Int(0), // K3Int
  91   fTCFL1Int(0), // L1Int
  92   fTCFL2Int(0), // L2Int
  93   fTCFL3Int(0), // L3Int
  94
  95   fBSL2HighThreshold(0), // BSL2HighThreshold
  96   fBSL2LowThreshold(0),  // BSL2LowThreshold
  97   fBSL2Offset(0),        // BSL2Offset
  98   fBSL2Presamples(0),    // BSL2Presamples(0),
  99   fBSL2Postsamples(0),   // BSL2Postsamples
 100
 101   fZSUThreshold(0),      // ZSUThreshold
 102
 103   fZSUMinSamplesaboveThreshold(0), // ZSUMinSamplesaboveThreshold
 104   fZSUPresamples(0),     // ZSUPresamples
 105   fZSUPostsamples(0),     // ZSUPostsamples
 106
 107   fReader(0),           // for Altro Emulation on Raw Reader
 108   fDecoder(0),
 109   fRunNumber(0),
 110   fDDLFolderName("/tmp/"),
 111   fOutputDateFileName("/tmp/tmp.date"),
 112   fOutputRootFileName("/tmp/tmp.root"),
 113   fIsRandom(kTRUE),
 114   fChannels(0),
 115   fCDHs(0),
 116   fADCs(0),
 117   fTrailers(0),
 118   fRawData(0) {
 119   //
 120   // Constructor of Altro Class
 121   //
 122
 123   fADCkeep = new Short_t[1024];
 124
 125 }
 126
 127
 128
 129 /**     @brief Destructor of Altro Class
 130  *
 131  *      Destructor of Altro Class\n
 132  */
 133 AliTPCAltroEmulator::~AliTPCAltroEmulator() {
 134   //
 135   // Destructor of Altro Class
 136   //
 137
 138   //  if(fConfiguredZSU == 1)
 139   delete[] fADCkeep;
 140
 141   delete[] fChannels;
 142   delete[] fCDHs    ;
 143   delete[] fADCs    ;
 144   delete[] fTrailers;
 145   delete[] fRawData ;
 146   delete fDecoder   ;
 147
 148 }
 149
 150
 151 /**  @brief Configures which modules of the Altro should be on.
 152  *
 153  *      Configures which modules of the Altro should be on. Each of the modules
 154  *      which are configured to be on, have to be configured later before running
 155  *      the emulation!\n
 156  *
 157  *      @param ONBaselineCorrection1 an <tt> Int_t </tt> Switch (0,1) to turn on the Base Line Correction 1 (BSL1) Module
 158  *      @param ONTailcancellation an <tt> Int_t </tt> Switch (0,1) to turn on the Tail Cancellation Filter (TCF) Module
 159  *      @param ONBaselineCorrection2 an <tt> Int_t </tt> Switch (0,1) to turn on the Moving Average Filter (BSL2) Module
 160  *      @param ONClipping an <tt> Int_t </tt> Switch (0,1) to turn on the Clipping Module. This is not possible in the real Altro, there it is always on.
 161  *      @param ONZerosuppression an <tt> Int_t </tt> Switch (0,1) to turn on the Zero Suppression (ZSU) Module
 162  *      @param ONDataFormatting an <tt> Int_t </tt> Switch (0,1) to turn on the Data Formatting on (not implemented)
 163  */
 164 void AliTPCAltroEmulator::ConfigAltro(Int_t ONBaselineCorrection1, Int_t ONTailcancellation, Int_t ONBaselineCorrection2, Int_t ONClipping, Int_t ONZerosuppression, Int_t ONDataFormatting){
 165   //
 166   // Configures which modules of the Altro should be on
 167   //
 168   fOnBSL1 = InRange(ONBaselineCorrection1,0,1,"AliTPCAltroEmulator::ConfigAltro","ONBaselineCorrection1");
 169   fOnTCF  = InRange(ONTailcancellation,0,1,"AliTPCAltroEmulator::ConfigAltro","ONTailcancellation");
 170   fOnBSL2 = InRange(ONBaselineCorrection2,0,1,"AliTPCAltroEmulator::ConfigAltro","ONBaselineCorrection2");
 171   fOnClip = InRange(ONClipping,0,1,"AliTPCAltroEmulator::ConfigAltro","ONClipping");
 172   fOnZSU = InRange(ONZerosuppression,0,1,"AliTPCAltroEmulator::ConfigAltro","ONZerosuppression");
 173   fConfiguredAltro = 1;
 174   if (!fConfiguredAltro) { //dummy code to avoid warning
 175     printf("%d\n",ONDataFormatting); // does not have to be checked
 176   }
 177 }
 178
 179 /**  @brief Configures the Base Line Correction 1 (BSL1) Module
 180  *
 181  *      Configures the Base Line Correction 1 (BSL1) Module. You dont have to build a proper pedestalMemory
 182  *      array, a pointer of the correct type is enough, of course you are not allowed to use Basline
 183  *      Correction Modes which need then the array ...\n
 184  *      All configurable values are "Range checked" and if out of the Range set to the nearest extreme.
 185  *      So the Emulation will work, but the result is maybe not the expected one.
 186  *
 187  *      @param mode an <tt> Int_t </tt> sets the mode of the Baseline Correction. See the Altro manual for a description
 188  *      @param ValuePeDestal an <tt> Int_t </tt> this is the baseline of the Channel.
 189  *      @param PedestalMem an <tt> *Int_t </tt> Pointer to a 1d Short_t Array with the pedestal memory Data
 190  *      @param polarity an <tt> Int_t </tt> Switch (0,1) for the polarity
 191  */
 192 void AliTPCAltroEmulator::ConfigBaselineCorrection1(Int_t mode, Int_t ValuePeDestal, Int_t *PedestalMem, Int_t polarity){
 193   //
 194   // Configures the Base Line Correction 1 (BSL1) Module
 195   //
 196   fBSL1mode          = InRange(mode,0,16,"AliTPCAltroEmulator::ConfigBaselineCorrection1","mode");
 197   fBSL1ValuePeDestal = InRange(ValuePeDestal,0,1023,"AliTPCAltroEmulator::BaselineCorrection1","ValuePeDestal");
 198   fBSL1PedestalMem = PedestalMem;
 199   fBSL1polarity = InRange(polarity,0,1,"AliTPCAltroEmulator::BaselineCorrection1","polarity");
 200   fConfiguredBSL1 = 1;
 201 }
 202
 203 /**  @brief Configures the Tail Cancellation Filter (TCF) Module
 204  *
 205  *      Configures the Tail Cancellation Filter (TCF) Module. You have to set the coefficients in the
 206  *      Integer version.\n
 207  *      To convert from Int_t to Float_t use (int)*(pow(2,-16)-1)
 208  *      To convert from Float_t to Int_t usw (Float_t)*(pow(2,16)-1)
 209  *      All configurable values are "Range checked" and if out of the Range set to the nearest extreme.
 210  *      So the Emulation will work, but the result is maybe not the expected one.
 211  *
 212  *      @param K1 an <tt> Int_t </tt> sets the K1 coeeficient of the TCF
 213  *      @param K2 an <tt> Int_t </tt> sets the K2 coeeficient of the TCF
 214  *      @param K3 an <tt> Int_t </tt> sets the K3 coeeficient of the TCF
 215  *      @param L1 an <tt> Int_t </tt> sets the L1 coeeficient of the TCF
 216  *      @param L2 an <tt> Int_t </tt> sets the L2 coeeficient of the TCF
 217  *      @param L3 an <tt> Int_t </tt> sets the L3 coeeficient of the TCF
 218  */
 219 void AliTPCAltroEmulator::ConfigTailCancellationFilter(Int_t K1, Int_t K2, Int_t K3, Int_t L1, Int_t L2, Int_t L3){
 220   //
 221   // Configures the Tail Cancellation Filter (TCF) Module
 222   //
 223   // conf from Int_t to fp:  (int)*(pow(2,-16)-1)
 224   //             backway:  (Float_t)*(pow(2,16)-1)
 225   fTCFK1Int = InRange(K1,0,65535,"AliTPCAltroEmulator::ConfigTailCancellationFilter","K1");
 226   fTCFK2Int = InRange(K2,0,65535,"AliTPCAltroEmulator::ConfigTailCancellationFilter","K2");
 227   fTCFK3Int = InRange(K3,0,65535,"AliTPCAltroEmulator::ConfigTailCancellationFilter","K3");
 228
 229   fTCFL1Int = InRange(L1,0,65535,"AliTPCAltroEmulator::ConfigTailCancellationFilter","L1");
 230   fTCFL2Int = InRange(L2,0,65535,"AliTPCAltroEmulator::ConfigTailCancellationFilter","L2");
 231   fTCFL3Int = InRange(L3,0,65535,"AliTPCAltroEmulator::ConfigTailCancellationFilter","L3");
 232   fConfiguredTCF = 1;
 233 }
 234 void AliTPCAltroEmulator::ConfigTailCancellationFilterForRAWfiles(const Int_t *K1, const Int_t *K2, const Int_t *K3,
 235                                                                   const Int_t *L1, const Int_t *L2, const Int_t *L3){
 236   //
 237   // Configures the Tail Cancellation Filter (TCF) Module - Different settings for IROC and OROC
 238   //
 239   // conf from Int_t to fp:  (int)*(pow(2,-16)-1)
 240   //             backway:  (Float_t)*(pow(2,16)-1)
 241
 242   // IROC
 243   fTCFK1IntROC[0] = InRange(K1[0],0,65535,"AliTPCAltroEmulator::ConfigTailCancellationFilter","K1[0]");
 244   fTCFK2IntROC[0] = InRange(K2[0],0,65535,"AliTPCAltroEmulator::ConfigTailCancellationFilter","K2[0]");
 245   fTCFK3IntROC[0] = InRange(K3[0],0,65535,"AliTPCAltroEmulator::ConfigTailCancellationFilter","K3[0]");
 246   fTCFL1IntROC[0] = InRange(L1[0],0,65535,"AliTPCAltroEmulator::ConfigTailCancellationFilter","L1[0]");
 247   fTCFL2IntROC[0] = InRange(L2[0],0,65535,"AliTPCAltroEmulator::ConfigTailCancellationFilter","L2[0]");
 248   fTCFL3IntROC[0] = InRange(L3[0],0,65535,"AliTPCAltroEmulator::ConfigTailCancellationFilter","L3[0]");
 249   // OROC
 250   fTCFK1IntROC[1] = InRange(K1[1],0,65535,"AliTPCAltroEmulator::ConfigTailCancellationFilter","K1[1]");
 251   fTCFK2IntROC[1] = InRange(K2[1],0,65535,"AliTPCAltroEmulator::ConfigTailCancellationFilter","K2[1]");
 252   fTCFK3IntROC[1] = InRange(K3[1],0,65535,"AliTPCAltroEmulator::ConfigTailCancellationFilter","K3[1]");
 253   fTCFL1IntROC[1] = InRange(L1[1],0,65535,"AliTPCAltroEmulator::ConfigTailCancellationFilter","L1[1]");
 254   fTCFL2IntROC[1] = InRange(L2[1],0,65535,"AliTPCAltroEmulator::ConfigTailCancellationFilter","L2[1]");
 255   fTCFL3IntROC[1] = InRange(L3[1],0,65535,"AliTPCAltroEmulator::ConfigTailCancellationFilter","L3[1]");
 256
 257
 258   fConfiguredTCFraw = 1;
 259 }
 260
 261
 262 /**  @brief Configures the Moving Average Filter (BSL2) Module
 263  *
 264  *      Configures the Moving Average Filter (BSL2) Module.
 265  *      All configurable values are "Range checked" and if out of the Range set to the nearest extreme.
 266  *      So the Emulation will work, but the result is maybe not the expected one.
 267  *
 268  *      @param HighThreshold an <tt> Int_t </tt> sets the high Threshold
 269  *      @param LowThreshold an <tt> Int_t </tt> sets the low Theshold
 270  *      @param Offset an <tt> Int_t </tt> sets the the offset which is added to the Signal
 271  *      @param Presamples an <tt> Int_t </tt> sets the number of pre samples excluded from the moving average caclulation
 272  *      @param Postsamples an <tt> Int_t </tt> sets the number of post samples excluded from the moving average caclulation
 273  */
 274 void AliTPCAltroEmulator::ConfigBaselineCorrection2(Int_t HighThreshold, Int_t LowThreshold, Int_t Offset, Int_t Presamples, Int_t Postsamples){
 275   //
 276   // Configures the Moving Average Filter (BSL2) Module
 277   //
 278   fBSL2HighThreshold = InRange(HighThreshold,0,1023,"AliTPCAltroEmulator::ConfigBaselineCorrection2","HighThreshold");
 279   fBSL2LowThreshold  = InRange(LowThreshold,0,1023,"AliTPCAltroEmulator::ConfigBaselineCorrection2","LowThreshold");
 280   fBSL2Offset        = InRange(Offset,0,1023,"AliTPCAltroEmulator::ConfigBaselineCorrection2","Offset");
 281   fBSL2Presamples    = InRange(Presamples,0,3,"AliTPCAltroEmulator::ConfigBaselineCorrection2","Presamples");
 282   fBSL2Postsamples   = InRange(Postsamples,0,15,"AliTPCAltroEmulator::ConfigBaselineCorrection2","Postsamples");
 283   fConfiguredBSL2 = 1;
 284 }
 285
 286 /**  @brief Configures the Zero Suppression Module (ZSU)
 287  *
 288  *      Configures the Zero Suppression Module (ZSU).
 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 Threshold an <tt> Int_t </tt> sets the Threshold
 293  *      @param MinSamplesaboveThreshold an <tt> Int_t </tt> sets the minimum number of samples which have to be greater than the threshold
 294  *      @param Presamples an <tt> Int_t </tt> sets the number of pre samples which are kept
 295  *      @param Postsamples an <tt> Int_t </tt> sets the number of post samples which are kept
 296  */
 297 void AliTPCAltroEmulator::ConfigZerosuppression(Int_t Threshold, Int_t MinSamplesaboveThreshold, Int_t Presamples, Int_t Postsamples){
 298   //
 299   // Configures the Zero Suppression Module (ZSU)
 300   //
 301   fZSUThreshold                = InRange(Threshold,0,1023,"AliTPCAltroEmulator::BaselineCorrection1","Threshold");
 302   fZSUMinSamplesaboveThreshold = InRange(MinSamplesaboveThreshold,1,3,"AliTPCAltroEmulator::BaselineCorrection1","MinSamplesaboveThreshold");
 303   fZSUPresamples               = InRange(Presamples,0,3,"AliTPCAltroEmulator::BaselineCorrection1","Presamples");
 304   fZSUPostsamples              = InRange(Postsamples,0,7,"AliTPCAltroEmulator::BaselineCorrection1","Postsamples");
 305
 306   for(Int_t i = 0; i < ftimebins; i++){
 307     fADCkeep[i] = 0;
 308   }
 309   fConfiguredZSU = 1;
 310 }
 311
 312 /**  @brief Prints the set Parameters, if module is configured
 313  *
 314  *      Prints the set Parameters, if module is configured.
 315  */
 316 void AliTPCAltroEmulator::PrintParameters(){
 317   //
 318   // Prints the set Parameters, if module is configured
 319   //
 320   cout << "+-------------------------------------------+" << endl;
 321   cout << "| Configured Parameters of the Altro Module |" << endl;
 322   cout << "+-------------------------------------------+" << endl << endl;
 323
 324   cout << "Parameters set in the Altro Modules:" << endl << endl;
 325   cout << "ONBaselineCorrection1: " << fOnBSL1 << endl;
 326   cout << "ONTailcancellation   : " << fOnTCF << endl;
 327   cout << "ONBaselineCorrection2: " << fOnBSL2 << endl;
 328   cout << "ONClipping           : " << fOnClip << endl;
 329   cout << "ONZerosuppression    : " << fOnZSU << endl << endl << endl;
 330   if(fConfiguredBSL1 == 1){
 331     cout << "Parameters set in the BSL1 (Baseline Correction 1) Module:" << endl << endl;
 332     cout << "mode                 : " << fBSL1mode << endl;
 333     cout << "ValuePeDestal        : " << fBSL1ValuePeDestal << endl;
 334     cout << "polarity             : " << fBSL1ValuePeDestal << endl << endl << endl;
 335   }else{
 336     cout << "BSL1 (Baseline Correction 1) Module not configured!" << endl << endl << endl;
 337   }
 338   if(fConfiguredTCF == 1){
 339     cout << "Parameters set in the TCF (TailCancellation Filter) Module:" << endl << endl;
 340     cout << "K1       (int|Float_t) : " << fTCFK1Int << " | " << fTCFK1Int/(Float_t)((1<<16)-1) << endl;
 341     cout << "K2       (int|Float_t) : " << fTCFK2Int << " | " << fTCFK2Int/(Float_t)((1<<16)-1) << endl;
 342     cout << "K3       (int|Float_t) : " << fTCFK3Int << " | " << fTCFK3Int/(Float_t)((1<<16)-1) << endl;
 343     cout << "L1       (int|Float_t) : " << fTCFL1Int << " | " << fTCFL1Int/(Float_t)((1<<16)-1) << endl;
 344     cout << "L2       (int|Float_t) : " << fTCFL2Int << " | " << fTCFL2Int/(Float_t)((1<<16)-1) << endl;
 345     cout << "L3       (int|Float_t) : " << fTCFL3Int << " | " << fTCFL3Int/(Float_t)((1<<16)-1) << endl << endl << endl;
 346   }else{
 347     cout << "TCF (TailCancellation Filter) Module not configured!" << endl << endl << endl;
 348   }
 349   if(fConfiguredBSL2 == 1){
 350     cout << "Parameters set in the BSL2 (Baseline Correction 2) Module:" << endl << endl;
 351     cout << "HighThreshold        : " << fBSL2HighThreshold << endl;
 352     cout << "LowThreshold         : " << fBSL2LowThreshold << endl;
 353     cout << "Offset               : " << fBSL2Offset << endl;
 354     cout << "Presamples           : " << fBSL2Presamples << endl;
 355     cout << "Postsamples          : " << fBSL2Postsamples << endl << endl << endl;
 356   }else{
 357     cout << "BSL2 (Baseline Correction 2) Module not configured!" << endl << endl << endl;
 358   }
 359   if(fConfiguredZSU == 1){
 360     cout << "Parameters set in the ZSU (Zero Suppression Unit) Module:" << endl << endl;
 361     cout << "Threshold            : " << fZSUThreshold << endl;
 362     cout << "MinSampaboveThreshold: " << fZSUMinSamplesaboveThreshold << endl;
 363     cout << "Presamples           : " << fZSUPresamples << endl;
 364     cout << "Postsamples          : " << fZSUPostsamples << endl << endl << endl;
 365   }else{
 366     cout << "ZSU (Zero Suppression Unit) Module not configured!" << endl << endl << endl;
 367   }
 368 }
 369
 370
 371 void AliTPCAltroEmulator::SetChannelData(Int_t timebins, Short_t* channelData) {
 372   //
 373   // Set channel data, for example a new channel
 374   //
 375
 376   ftimebins = timebins;
 377   fChannelShort = channelData;
 378
 379 }
 380
 381
 382 /**  @brief Runs the emulation of all configured Modules.
 383  *
 384  *      Runs the emulation of all configured Modules. This changes then the content of the
 385  *      input Array
 386  */
 387 void AliTPCAltroEmulator::RunEmulation(Int_t roc){
 388   //
 389   // Runs the emulation of all configured Modules.
 390   //
 391
 392   if (!fChannelShort) {
 393     printf("ERROR cant run Altro Emulation: Channel input not set.\nUse for example: SetChannelData(Int_t timebins, Short_t* Channel)\n");
 394     return;
 395   }
 396
 397   //cout << "AliTPCAltroEmulator::RunEmulation | start" << endl;
 398   if(fConfiguredAltro == 0){
 399     cout << "ERROR cant run Altro Emulation because not configured" << endl;
 400     return;
 401   }
 402
 403   //cout << "AliTPCAltroEmulator::RunEmulation | start BSL1 on: " << fOnBSL1 << " configures: " << fConfiguredBSL1 << endl;
 404   if(fOnBSL1 == 1){
 405     if(fConfiguredBSL1 == 1){
 406       BaselineCorrection1(fBSL1mode, fBSL1ValuePeDestal, fBSL1PedestalMem, fBSL1polarity);
 407     }else{
 408       cout << "ERROR cant run Baseline Correction 1 because not configured" << endl;
 409       return;
 410     }
 411   }
 412
 413   //cout << "AliTPCAltroEmulator::RunEmulation | start TCF on: " << fOnTCF << " configures: " << fConfiguredTCF << endl;
 414   if(fOnTCF == 1){
 415     if (roc==-1) { // use one set of TCF params
 416       if(fConfiguredTCF == 1){
 417         TailCancellationFilterFixedPoint(fTCFK1Int, fTCFK2Int, fTCFK3Int, fTCFL1Int, fTCFL2Int, fTCFL3Int);
 418       }else{
 419         cout << "ERROR cant run Tail Cancellation Filter because not configured" << endl;
 420         return;
 421       }
 422     } else { // use different TCF params for IROC and OROC
 423       if(fConfiguredTCFraw == 1){
 424         if (roc==0)      //IROC
 425           TailCancellationFilterFixedPoint(fTCFK1IntROC[0], fTCFK2IntROC[0], fTCFK3IntROC[0],
 426                                            fTCFL1IntROC[0], fTCFL2IntROC[0], fTCFL3IntROC[0]);
 427         else if (roc==1) // OROC
 428           TailCancellationFilterFixedPoint(fTCFK1IntROC[1], fTCFK2IntROC[1], fTCFK3IntROC[1],
 429                                            fTCFL1IntROC[1], fTCFL2IntROC[1], fTCFL3IntROC[1]);
 430         else
 431           cout << "ERROR cant run Tail Cancellation Filter because TCF settings for ROC not found" << endl;
 432       } else {
 433         cout << "ERROR cant run Tail Cancellation Filter because not configured (for RAW data files!)" << endl;
 434         return;
 435       }
 436
 437     }
 438   }
 439
 440   //cout << "AliTPCAltroEmulator::RunEmulation | start BSL2 on: " << fOnBSL2 << " configures: " << fConfiguredBSL2 << endl;
 441   if(fOnBSL2 == 1){
 442     if(fConfiguredBSL2 == 1){
 443       BaselineCorrection2RTL(fBSL2HighThreshold, fBSL2LowThreshold, fBSL2Offset, fBSL2Presamples, fBSL2Postsamples);
 444     }else{
 445       cout << "ERROR cant run Baseline Correction 2 because not configured" << endl;
 446       return;
 447     }
 448   }
 449   //cout << "AliTPCAltroEmulator::RunEmulation | start CLIP on: " << fOnClip << endl;
 450   if(fOnClip == 1){
 451     Clipping();
 452   }
 453   //cout << "AliTPCAltroEmulator::RunEmulation | start ZSU on: " << fOnZSU << " configures: " << fConfiguredZSU << endl;
 454   if(fOnZSU == 1){
 455     if(fConfiguredZSU == 1){
 456       Zerosuppression(fZSUThreshold,fZSUMinSamplesaboveThreshold,fZSUPresamples,fZSUPostsamples);
 457     }else{
 458       cout << "ERROR cant run Zero Suppression Unit because not configured" << endl;
 459       return;
 460     }
 461   }
 462
 463
 464
 465 }
 466
 467 void AliTPCAltroEmulator::BaselineCorrection1(Int_t mode, Int_t ValuePeDestal, Int_t *PedestalMem, Int_t polarity){
 468   //
 469   // BaselineCorrection1
 470   //
 471
 472   //VPD == 0 !!
 473   Int_t fixedPeDestal = 0;
 474
 475   // take first and last bins to calculate a mean pedestal value
 476   Int_t window = 3;
 477   Int_t meanPeDestal = 0;
 478   for(Int_t i = 0; i < window; i++) {
 479     meanPeDestal += fChannelShort[i];
 480     meanPeDestal += fChannelShort[ftimebins-1-i];
 481   }
 482   meanPeDestal /= (window*2);
 483
 484
 485   if(polarity ==1){
 486     for(Int_t i = 0; i < ftimebins; i++){
 487       fChannelShort[i]  = 1023 - fChannelShort[i];
 488     }
 489   }
 490
 491   switch(mode) {
 492   case kDINxFPD:
 493     for(Int_t i = 0; i < ftimebins; i++)
 494       fChannelShort[i]  = fChannelShort[i]  - fixedPeDestal;
 495     break;
 496   case kDINxFT:
 497     for(Int_t i = 0; i < ftimebins; i++)
 498       fChannelShort[i]  = fChannelShort[i]  - PedestalMem[i];
 499     break;
 500   case kDINxFDIN:
 501     for(Int_t i = 0; i < ftimebins; i++)
 502       fChannelShort[i]  = fChannelShort[i]  - PedestalMem[ fChannelShort[i] ];
 503     break;
 504   case kDINxFDINxVPD:
 505     for(Int_t i = 0; i < ftimebins; i++)
 506       fChannelShort[i]  = fChannelShort[i]  - PedestalMem[ fChannelShort[i] - ValuePeDestal];
 507     break;
 508   case kDINxVPDxFPD:
 509     for(Int_t i = 0; i < ftimebins; i++)
 510       fChannelShort[i]  = fChannelShort[i]  - ValuePeDestal - fixedPeDestal;
 511     break;
 512   case kDINxVPDxFT:
 513     for(Int_t i = 0; i < ftimebins; i++)
 514       fChannelShort[i]  = fChannelShort[i]  - ValuePeDestal - PedestalMem[i];
 515     break;
 516   case kDINxVPDxFDIN:
 517     for(Int_t i = 0; i < ftimebins; i++)
 518       fChannelShort[i]  = fChannelShort[i]  - ValuePeDestal - PedestalMem[ fChannelShort[i] ];
 519     break;
 520   case kDINxVPDxFDINxVPD:
 521     for(Int_t i = 0; i < ftimebins; i++)
 522       fChannelShort[i]  = fChannelShort[i]  - ValuePeDestal - PedestalMem[ fChannelShort[i] - ValuePeDestal ];
 523     break;
 524   case kFDINxFPD:
 525     for(Int_t i = 0; i < ftimebins; i++)
 526       fChannelShort[i]  = PedestalMem[ fChannelShort[i] ] - fixedPeDestal;
 527     break;
 528   case kFDINxVPDxFPD:
 529     for(Int_t i = 0; i < ftimebins; i++)
 530       fChannelShort[i]  = PedestalMem[ fChannelShort[i] - ValuePeDestal ] - fixedPeDestal;
 531     break;
 532   case kFTxFPD:
 533     for(Int_t i = 0; i < ftimebins; i++)
 534       fChannelShort[i]  = PedestalMem[i] - fixedPeDestal;
 535     break;
 536   case kDINxMPD:
 537     for(Int_t i = 0; i < ftimebins; i++)
 538       fChannelShort[i]  = fChannelShort[i] - meanPeDestal;
 539     break;
 540   }
 541 }
 542
 543 Int_t AliTPCAltroEmulator::Multiply36(Int_t P, Int_t N){
 544   //
 545   // multiply function to emulate the 36 bit fixed point multiplication of the Altro.
 546   //
 547   long long retval =0;
 548   long long temp = 0;
 549   long long vAX = 0;
 550   temp = (long long)P*(long long)N;
 551   vAX = (( Mask(temp,35,18) + ((long long)(-P)<<18) ) + Mask(temp,17,0));
 552   if ( Maskandshift(N,17,17) == 1){
 553     retval = ((Maskandshift(vAX,35,35)<<17) + Maskandshift(vAX,32,16));
 554   }else{
 555     retval = Maskandshift(temp,32,16);
 556   }
 557   return retval;
 558 }
 559 long long AliTPCAltroEmulator::Mask(long long in, Int_t left, Int_t right){
 560   //
 561   // mask
 562   //
 563   long long retval;
 564   long long pattern;
 565   long long length = abs(left - right)+1;
 566   pattern = ((1<<length)-1)<<right;
 567   retval = in&pattern;
 568   return retval;
 569 }
 570
 571 long long AliTPCAltroEmulator::Maskandshift(long long in, Int_t left, Int_t right){
 572   //
 573   // maskandshift
 574   //
 575   long long retval;
 576   long long pattern;
 577   long long length = abs(left - right)+1;
 578   pattern = ((1<<length)-1);
 579   retval = (in>>right)&pattern;
 580   return retval;
 581 }
 582
 583 void AliTPCAltroEmulator::TailCancellationFilterFixedPoint(Int_t K1, Int_t K2, Int_t K3, Int_t L1, Int_t L2, Int_t L3){
 584   //
 585   // TailCancellationFilterFixedPoint
 586   //
 587   Int_t c1n = 0, c2n = 0, c3n = 0;
 588   Int_t c1o = 0, c2o = 0, c3o = 0;
 589   Int_t d1  = 0, d2  = 0;
 590   Int_t dout = 0;
 591   Int_t din = 0;
 592   Int_t bit = 0;
 593
 594   //  printf("%5d %5d %5d %5d %5d %5d\n",K1,K2,K3,L1,L2,L3);
 595
 596   for(Int_t i = 0; i < ftimebins; i++){
 597     din = fChannelShort[i];
 598
 599     din = (din<<2);
 600     c1n             = Mask( (Mask(din,17,0) + Multiply36(K1,Mask(c1o,17,0)) ) ,17,0);
 601     d1              = Mask( (Mask(c1n,17,0) - Multiply36(L1,Mask(c1o,17,0)) ) ,17,0);
 602     //d1              = Mask( (Mask(c1n,17,0) + Mask(~Multiply36(L1,Mask(c1o,17,0))+1,17,0) ) ,17,0);
 603
 604     c2n             = Mask( (Mask(d1 ,17,0) + Multiply36(K2,Mask(c2o,17,0)) ) ,17,0);
 605     d2              = Mask( (Mask(c2n,17,0) - Multiply36(L2,Mask(c2o,17,0)) ) ,17,0);
 606     //d2              = Mask( (Mask(c2n,17,0) + Mask(~Multiply36(L2,Mask(c2o,17,0))+1,17,0) ) ,17,0);
 607
 608     c3n             = Mask( (Mask(d2 ,17,0) + Multiply36(K3,Mask(c3o,17,0)) ) ,17,0);
 609     dout            = Mask( (Mask(c3n,17,0) - Multiply36(L3,Mask(c3o,17,0)) ) ,17,0);
 610     //dout            = Mask( (Mask(c3n,17,0) + Mask(~Multiply36(L3,Mask(c3o,17,0))+1,17,0) ) ,17,0);
 611
 612     if( (Maskandshift(dout,2,2) == 1) || (Maskandshift(dout,1,1) == 1)){
 613       bit = 1;
 614     }else{
 615       bit = 0;
 616     }
 617
 618     dout = ((dout>>3)<<1) + bit;
 619     if(Maskandshift(dout,15,15) == 1){
 620       //is needed to get the correct coding when getting negative results
 621       dout = -Mask((-Mask(dout,9,0)),9,0);
 622     }else{
 623       dout = Mask(dout,9,0);
 624     }
 625
 626     fChannelShort[i] = (short) dout;
 627     c1o = c1n;
 628     c2o = c2n;
 629     c3o = c3n;
 630   }
 631 }
 632
 633 void AliTPCAltroEmulator::BaselineCorrection2RTL(Int_t HighThreshold, Int_t LowThreshold, Int_t Offset, Int_t Presamples, Int_t Postsamples){
 634   //
 635   // BaselineCorrection2RTL
 636   //
 637
 638   //cout << "Altro::BaselineCorrection2RTL | HighThreshold: " << HighThreshold << " LowThreshold: " << LowThreshold << " Offset: " << Offset << " Presamples: " << Presamples << " Postsamples: " << Postsamples << endl;
 639   //more or less direct "translation" of the hdl code.
 640   //Input signals
 641   Int_t din;
 642   Int_t dout;
 643   Int_t edges[6]; // = Postsamples*4 + Presamples;
 644   Int_t offset = Offset;
 645   Int_t thrlo = LowThreshold;//called thr_mau[19] ...
 646   Int_t thrhi = HighThreshold;
 647
 648   // Variables
 649   Int_t fOld[4]; //flag pipe
 650   Int_t fNew[4]; //flag pipe
 651   Int_t dOld[4]; //data pipe
 652   Int_t dNew[4]; //data pipe
 653   Int_t dxOld;
 654   Int_t dxNew;
 655   Int_t pstscnt; // Counter for Postsamples
 656   Int_t zOld[9]; // Filter stages
 657   Int_t zNew[9]; // Filter stages
 658   Int_t zxOld; //Accumulator stage
 659   Int_t zxNew; //Accumulator stage
 660   Int_t valcntOld; //Valid sample counter
 661   Int_t valcntNew = 0; //Valid sample counter
 662
 663   Int_t valid; //Valid flag
 664   Int_t fx; //postsample flag
 665   //Int_t s07; // differentiator result
 666   Int_t s8; // Acc + Diff result
 667   Int_t flag;
 668   //Int_t bsth; //baseline threshold
 669   //Int_t din_p; //Data input strictly positive
 670   Int_t bsl;
 671   //Int_t dx_bsls; // dx -bsl
 672   //Int_t dx_clip; // dxbsl clipped
 673   //Int_t bsl_of = 0;
 674
 675   //initialisation
 676   for(Int_t i = 0; i < 9 ; i++)
 677     zOld[i] = 0;
 678   for(Int_t i = 0; i < 4 ; i++){
 679     fOld[i] = 0;
 680     dOld[i] = 0;
 681   }
 682   dxOld= 0;
 683   pstscnt = 0;
 684   zxOld = 0;
 685   valcntOld = 0;
 686   valid = 0;
 687   for(Int_t i = 0; i < 2 ; i++){
 688     edges[i] = (Presamples&(1<<i))>>i;
 689   }
 690   for(Int_t i = 0; i < 4 ; i++){
 691     edges[(3-i)+2] = (Postsamples&(1<<i))>>i;
 692   }
 693   /*cout << "edges :";
 694     for(Int_t i = 0; i < 6 ; i++)
 695     cout << edges[i] << ":";
 696     cout << " Presamples: " << Presamples << " Postsamples: " << Postsamples << endl;*/
 697
 698   //Loop
 699   //cout << "AliTPCAltroEmulator::BaselineCorrection2_RTL | starting Loop" << endl;
 700   for(Int_t timebin = -12; timebin < ftimebins+10; timebin++){
 701     //cout << "AliTPCAltroEmulator::BaselineCorrection2_RTL | in Loop timebin: " << timebin << endl;
 702     din = GetElement(fChannelShort,timebin);
 703
 704     s8 = zxOld + (zOld[8] - zOld[0]);
 705
 706     if(valid == 1)
 707       bsl = s8>>3;// ...
 708     else
 709       bsl = 0;
 710
 711     //assign flag = (din_p > thrhi) | (thrlo > din_p);  // Signal samples between thresholds
 712     if( (din <= (bsl + thrhi)) && (din >= (bsl - thrlo)) )
 713       flag = 0;
 714     else
 715       flag = 1;
 716
 717     if(pstscnt == 0)
 718       fx = 0;
 719     else
 720       fx = 1;
 721
 722     if(valcntOld >= 12)
 723       valid = 1;
 724     else
 725       valid = 0;
 726
 727     fNew[3] = flag;
 728
 729     if( (fOld[3] == 1) || ( (flag == 1) && ( (edges[0] == 1) || (edges[1] == 1) ) ) ) //f[2] =  f[3] | (flag&(edges[0]|edges[1]));
 730       fNew[2] = 1;
 731     else
 732       fNew[2] = 0;
 733
 734     if( (fOld[2] == 1) || ( (edges[1] == 1) && (flag == 1) ) ) //               f[1] =  f[2] | (edges[1] & flag);
 735       fNew[1] = 1;
 736     else
 737       fNew[1] = 0;
 738
 739     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;
 740       fNew[0] = 1;
 741     else
 742       fNew[0] = 0;
 743
 744     dxNew = dOld[0];
 745     for(Int_t i = 0; i < 3; i++)
 746       dNew[i] = dOld[i+1];
 747     dNew[3] = din;
 748
 749     if( (fOld[1]==1) && (fOld[2]==0) )
 750       pstscnt = Postsamples;
 751     else if(fx == 1)
 752       pstscnt--;
 753
 754     if(fOld[0] == 0){
 755       if(valid == 0)
 756         valcntNew =  ++valcntOld;
 757
 758       zxNew = s8;
 759       for(Int_t i = 0; i < 8; i++)
 760         zNew[i] = zOld[i+1];
 761       zNew[8] = dOld[0];
 762     }else{
 763       zxNew = zxOld;
 764       for(Int_t i = 0; i < 9; i++)
 765         zNew[i] = zOld[i];
 766     }
 767     dout = dxOld - (bsl - offset);
 768     //if(dout <0)
 769     //  dout = 0;
 770
 771     SetElement(fChannelShort,timebin-5,(short)dout);
 772     //sim clockschange
 773     for(Int_t i = 0; i < 9 ; i++)
 774       zOld[i] = zNew[i];
 775     zxOld = zxNew;
 776     for(Int_t i = 0; i < 4 ; i++){
 777       fOld[i] = fNew[i];
 778       dOld[i] = dNew[i];
 779     }
 780     dxOld = dxNew;
 781     valcntOld = valcntNew;
 782   }
 783 }
 784
 785 void AliTPCAltroEmulator::Clipping(){
 786   //
 787   // implement if no BC2 clipping has to run
 788   //
 789   for(Int_t i = 0; i < ftimebins; i++){
 790     if(fChannelShort[i] < -1)
 791       fChannelShort[i] = -1;
 792   }
 793 }
 794
 795 void AliTPCAltroEmulator::Zerosuppression(Int_t Threshold, Int_t MinSamplesaboveThreshold, Int_t Presamples, Int_t Postsamples){
 796   //
 797   // add again altro feature
 798   //
 799
 800   //TODO: Implement "Altro zsu merging"
 801   //Int_t Postsamplecounter = 0;
 802   //Int_t setPostsample = 0;
 803
 804   for(Int_t i = 0; i < ftimebins; i++){
 805     if(fChannelShort[i] >= Threshold)
 806       fADCkeep[i] = 1;
 807     else
 808       fADCkeep[i] = 0;
 809   }
 810
 811   Int_t startofclustersequence = -1;
 812   Int_t endofClustersInSequence = -1;
 813
 814   for(Int_t i = 0; i < ftimebins; i++){
 815     if( (fADCkeep[i] == 1) && (GetElement(fADCkeep,i-1) == 0) ){
 816       startofclustersequence = i;
 817     }
 818     if( (fADCkeep[i] == 1) && (GetElement(fADCkeep,i+1) == 0) ){
 819       endofClustersInSequence = i;
 820     }
 821     //cout << i << " startofclustersequence: " << startofclustersequence << " endofClustersInSequence: " << endofClustersInSequence;
 822     if( (startofclustersequence != -1) && (endofClustersInSequence != -1) ){
 823       //cout << " found! " <<  (endofClustersInSequence - startofclustersequence + 1);
 824       if ( (endofClustersInSequence - startofclustersequence + 1) < MinSamplesaboveThreshold ){
 825         for(Int_t j = startofclustersequence; j <= endofClustersInSequence ; j++){
 826           fADCkeep[j] = 0;
 827         }
 828       }
 829       startofclustersequence = -1;
 830       endofClustersInSequence = -1;
 831     }
 832     //cout << endl;
 833   }
 834
 835   /*for(Int_t i = 0; i < ftimebins; i++){
 836     if( (GetElement(fADCkeep,i-1) == 1) && (GetElement(fADCkeep,i) == 0) && (GetElement(fADCkeep,i+1) == 1) ){
 837     SetElement(fADCkeep,i,1);
 838     }
 839     }*/
 840
 841   for(Int_t i = 0; i < ftimebins; i++){
 842     if( (fADCkeep[i] == 1) && (GetElement(fADCkeep,i-1) == 0) ){
 843       for(Int_t j = i-Presamples ; j <= i; j++){
 844         SetElement(fADCkeep,j,1);
 845       }
 846     }
 847   }
 848   for(Int_t i = ftimebins; i >= 0; i--){
 849     if( (fADCkeep[i] == 1) && (GetElement(fADCkeep,i+1) == 0) ){
 850       for(Int_t j = i ; j <= i+Postsamples; j++){
 851         SetElement(fADCkeep,j,1);
 852       }
 853     }
 854   }
 855   /*cout << " Postsamplecounter: " << Postsamplecounter;
 856     for(Int_t j = i+1 ; j <= i+Postsamples; j++){
 857     SetElement(fADCkeep,j,1);
 858     i+=Postsamples;
 859     }
 860     cout << endl;
 861     }
 862     cout << i << " ADCK: " << GetElement(fADCkeep,i);
 863     cout << " Postsam: " << Postsamplecounter << " ADCK: " << GetElement(fADCkeep,i);*/
 864
 865   for(Int_t i = 0; i < ftimebins; i++){
 866     if( (fADCkeep[i] == 1) && (GetElement(fADCkeep,i+1) == 0) && ( (GetElement(fADCkeep,i+3) == 1) || (GetElement(fADCkeep,i+2) == 1) ) ){
 867       SetElement(fADCkeep,i+1,1);
 868       SetElement(fADCkeep,i+2,1);
 869     }
 870   }
 871
 872   for(Int_t i = 0; i < ftimebins; i++){
 873     if( !GetKeepChannel(i) ) {
 874       SetElement(fChannelShort,i,-1); // set non relevant data to -1
 875     }
 876   }
 877
 878
 879 }
 880
 881 /**  @brief formats the data like the ALTRO. Result is a 64 bit array
 882  *
 883  *      formats the data like the ALTRO. Result is a 64 bit array
 884  *
 885  */
 886
 887 const void AliTPCAltroEmulator::DataFormater(){
 888   //
 889   // formats the data like the ALTRO. Result is a 64 bit array
 890   //
 891
 892
 893 }
 894
 895
 896 /**  @brief calculates the compression out of the bitmask
 897  *
 898  *      calculates the compression out of the bitmask with the set adc values
 899  *
 900  *      @return \c Float_t consisting of the compression factor
 901  */
 902 Float_t AliTPCAltroEmulator::CalculateCompression() {
 903   //
 904   // calculates the compression out of the bitmask
 905   //
 906
 907   // calculation is based on altro 10 bit words ..
 908   Int_t sample = 0;
 909   Int_t cluster = 0;
 910   Int_t data = 0;
 911   Float_t retval = 0.0;
 912
 913   for(Int_t i = 0; i < ftimebins; i++){
 914     if(fADCkeep[i] == 1){
 915       sample++;
 916     }
 917     if( (fADCkeep[i] == 1) && (GetElement(fADCkeep,i+1) == 0) ){
 918       cluster++;
 919     }
 920   }
 921   data = sample + cluster*2;
 922   data = data + data%4 + 4;
 923   if(data >0){
 924     retval = ftimebins / (Float_t)data;//num of timebins is equal to max number of samples
 925   }else{
 926     retval = 1.0;
 927   }
 928   return retval;
 929 }
 930
 931 const Short_t AliTPCAltroEmulator::GetElement(short* Array,Int_t index){
 932   //
 933   // GetElement of array
 934   //
 935   if (index < 0)
 936     return 0;
 937   else if(index >= ftimebins)
 938     return 0;
 939   else
 940     return Array[index];
 941 }
 942
 943 void AliTPCAltroEmulator::SetElement(short* Array,Int_t index,Short_t value){
 944   //
 945   // SetElement of array
 946   //
 947   if (index < 0)
 948     return;
 949   else if(index >= ftimebins)
 950     return;
 951   else
 952     Array[index] = value;
 953 }
 954
 955 const Int_t AliTPCAltroEmulator::InBand(Int_t ADC,Int_t bsl, Int_t LowThreshold, Int_t HighThreshold){
 956   //
 957   // check if it's within the band of search
 958   //
 959   Int_t fLow = bsl - LowThreshold;
 960   Int_t fHigh = bsl + HighThreshold;
 961   if( (ADC <= fHigh) && (ADC >= fLow) )
 962     return 1;
 963   else
 964     return 0;
 965 }
 966
 967 const Int_t AliTPCAltroEmulator::InRange(Int_t parameter,Int_t Low,Int_t High,const char *Module,const char *ParameterName){
 968   //
 969   // checks it it's within the range
 970   //
 971
 972   char out[255];
 973   Int_t retval;
 974   if(parameter > High){
 975     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);
 976     cout << out << endl;
 977     retval = High;
 978   }else if(parameter < Low){
 979     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);
 980     cout << out << endl;
 981     retval = Low;
 982   }else{
 983     retval = parameter;
 984   }
 985   return retval;
 986 }
 987
 988 Short_t AliTPCAltroEmulator::GetShortChannel(Int_t i){
 989   //
 990   // GetElement of channel
 991   //
 992   return GetElement(fChannelShort,i);
 993 }
 994
 995 Short_t AliTPCAltroEmulator::GetKeepChannel(Int_t i){
 996   //
 997   // GetElement of Keep Channel
 998   //
 999   return GetElement(fADCkeep,i);
1000 }
1001
1002 Bool_t AliTPCAltroEmulator::WriteEvent(Int_t ievent) {
1003   //
1004   // Write event to the DDL data folders
1005   //
1006
1007   for (Int_t ddlID=0;ddlID<216;++ddlID) {
1008     Bool_t  *channelsDDL=fChannels+ddlID*4096     ;
1009     Short_t *adcsDDL    =fADCs    +ddlID*4096*1024;
1010     UInt_t  *cdhDDL     =fCDHs    +ddlID*8        ;
1011     UInt_t  *trailerDDL =fTrailers+ddlID*9        ;
1012
1013     FILE *file=fopen(Form("%s/raw%d/TPC_%03d.ddl",
1014                           fDDLFolderName.Data(),ievent,768+ddlID),
1015                      "wb");
1016     if (!file) return kFALSE;
1017     Int_t i32;
1018     // write CDH (first word to be altered later)
1019     for (i32=0;i32<8;++i32)
1020       fRawData[i32]=cdhDDL[i32];
1021
1022     // process payload
1023     for (Int_t hwaddr=0;hwaddr<4096;++hwaddr) if (channelsDDL[hwaddr]) {
1024       Short_t *adcsChannel=adcsDDL+hwaddr*1024;
1025       // merge custers
1026       // TODO: acqusition window
1027       for (Int_t it=0;it<1024-3;++it) {
1028         if (adcsChannel[it]>=0&&adcsChannel[it+3]>=0) {
1029           if (adcsChannel[it+1]<0) {
1030             //      printf("merge");
1031             adcsChannel[it+1]=0;
1032           }
1033           if (adcsChannel[it+2]<0) {
1034             //      printf("merge");
1035             adcsChannel[it+2]=0;
1036           }
1037         }
1038       }
1039       Int_t i10=3;
1040       Int_t icw=0;
1041       Int_t its=1;
1042       Int_t cw =0;
1043       Int_t ts =0;
1044       for (Int_t it=1023;it>=0;--it) {
1045         Short_t w10=adcsChannel[it];
1046         if (w10>=0) {
1047           if (cw<0) {
1048             icw=i10++;
1049             its=i10++;
1050             cw =0    ;
1051             ts=it    ;
1052           }
1053           fRawData[i32+i10/3]|=w10<<(10*(2-i10%3));
1054           ++i10;
1055           ++cw;
1056         }
1057         else {
1058           if (cw>=0) {
1059             cw+=2;
1060             fRawData[i32+icw/3]|=cw <<(10*(2-icw%3));
1061             fRawData[i32+its/3]|=ts <<(10*(2-its%3));
1062             cw=-1;
1063           }
1064         }
1065       }
1066       fRawData[i32]=0x1<<30|(i10-3)<<16|hwaddr;
1067       i32+=(i10+2)/3;
1068
1069       // clean up
1070       for (Int_t i=0;i<1024;++i) adcsChannel[i]=-1;
1071       channelsDDL[hwaddr]=kFALSE;
1072     }
1073
1074     // write RCU trailer
1075     fRawData[i32]=0x2<<30|(i32-8);i32++;
1076     for (Int_t i=0;i<8;++i)
1077       fRawData[i32++]=trailerDDL[i];
1078
1079     // write first word of CDH
1080     fRawData[0]=i32*4;
1081
1082     Int_t nwritten=fwrite(fRawData,sizeof(UInt_t),i32,file);
1083     if (nwritten!=i32) return kFALSE;
1084
1085     // clean up
1086     do {fRawData[--i32]=0;} while (i32>0);
1087
1088     fclose(file);
1089   }
1090   return kTRUE;
1091 }
1092
1093 Bool_t AliTPCAltroEmulator::GDC2DDLs(AliRawVEvent *gdc,Int_t ievent) {
1094   //
1095   // Converte GDC data to DDL format
1096   //
1097   for(Int_t iLDC=0;iLDC<gdc->GetNSubEvents();++iLDC) {
1098     AliRawVEvent *ldc=gdc->GetSubEvent(iLDC);
1099     for(Int_t iEq=0;iEq<ldc->GetNEquipments();++iEq) {
1100       AliRawVEquipment *eq=ldc->GetEquipment(iEq);
1101       AliRawEquipmentHeader *eqHeader=eq->GetEquipmentHeader();
1102       Int_t eqSize=eqHeader->GetEquipmentSize();
1103       if (eqSize>0) {
1104         Int_t ddlIndex;
1105         Int_t detId=AliDAQ::DetectorIDFromDdlID(eqHeader->GetId(),ddlIndex);
1106         Int_t nwritten=0;
1107         FILE *ddlFile=fopen(Form("%s/raw%d/%s",
1108                                  fDDLFolderName.Data(),
1109                                  ievent,
1110                                  AliDAQ::DdlFileName(detId,ddlIndex)),
1111                             "wb");
1112         AliRawData *rawData=eq->GetRawData();
1113         if (ddlFile) {
1114           nwritten=fwrite(rawData->GetBuffer(),1,rawData->GetSize(),ddlFile);
1115           fclose(ddlFile);
1116         }
1117         if (nwritten<rawData->GetSize()) return kFALSE;
1118       }
1119     }
1120   }
1121   return kTRUE;
1122 }
1123
1124
1125 Bool_t AliTPCAltroEmulator::ConvertRawFilesToDate(Int_t nevents) {
1126   //
1127   //  Convertes Raw files to Date format
1128   //
1129
1130   // from $ALICE_ROOT/STEER/AliSimulation.cxx
1131
1132   char command[100];
1133   FILE *pipe;
1134
1135   printf(" RAW to DATE CONVERSION: Run Number %d\n",fRunNumber);
1136
1137   if (fRunNumber>0)
1138     pipe=gSystem->OpenPipe(Form("dateStream -c -s -D -o %s -C -# %d -run %d",
1139                                 fOutputDateFileName.Data(),
1140                                 nevents,
1141                                 fRunNumber),
1142                            "w");
1143   else
1144     pipe=gSystem->OpenPipe(Form("dateStream -c -s -D -o %s -C -# %d",
1145                                 fOutputDateFileName.Data(),
1146                                 nevents),
1147                            "w");
1148   if (!pipe) {
1149     fprintf(stderr,"error: cannot execute command: %s",command);
1150     return kFALSE;
1151   }
1152
1153   for (Int_t ievent=0;ievent<nevents;++ievent) {
1154     UInt_t detectorPattern = 0xFFFFFFFF;
1155     fprintf(pipe, "GDC DetectorPattern %u\n", detectorPattern);
1156
1157     Float_t ldc = 0;
1158     Int_t prevLDC = -1;
1159
1160     // loop over detectors and DDLs
1161     for (Int_t iDet = 0; iDet < AliDAQ::kNDetectors; iDet++) {
1162       if (!(iDet<=5 || iDet==17 )) continue;
1163       for (Int_t iDDL = 0; iDDL < AliDAQ::NumberOfDdls(iDet); iDDL++) {
1164         //      printf("iDet=%d, iDDL=%d, filenmae=%s\n",iDet,iDDL,filename);
1165         Int_t ddlID = AliDAQ::DdlID(iDet,iDDL);
1166         Int_t ldcID = Int_t(ldc + 0.0001);
1167         ldc += AliDAQ::NumberOfLdcs(iDet) / AliDAQ::NumberOfDdls(iDet);
1168
1169         // check existence and size of raw data file
1170         FILE* file = fopen(Form("%s/raw%d/%s",
1171                                 fDDLFolderName.Data(),
1172                                 ievent,
1173                                 AliDAQ::DdlFileName(iDet,iDDL)),
1174                            "rb");
1175         if (!file) continue;
1176         fseek(file, 0, SEEK_END);
1177         unsigned long size = ftell(file);
1178         fclose(file);
1179         if (!size) continue;
1180
1181         if (ldcID != prevLDC) {
1182           fprintf(pipe, " LDC Id %d\n", ldcID);
1183           prevLDC = ldcID;
1184         }
1185         fprintf(pipe,Form("  Equipment Id %d Payload %s/raw%d/%s\n",
1186                           ddlID,
1187                           fDDLFolderName.Data(),
1188                           ievent,
1189                           AliDAQ::DdlFileName(iDet,iDDL))
1190                 );
1191       }
1192     }
1193   }
1194   Int_t result = gSystem->ClosePipe(pipe);
1195   return (result == 0);
1196 }
1197
1198 void AliTPCAltroEmulator::InitBuffers() {
1199   //
1200   // Initialization of the Buffers
1201   //
1202   if (!fChannels) fChannels=new Bool_t [216*4096     ];
1203   if (!fCDHs    ) fCDHs    =new UInt_t [216*8        ];
1204   if (!fADCs    ) fADCs    =new Short_t[216*4096*1024];
1205   if (!fTrailers) fTrailers=new UInt_t [216*9        ];
1206   if (!fRawData ) fRawData =new UInt_t [  1*4096*1024]; // be save...
1207
1208   for (Int_t i=0;i<216*4096     ;++i) fChannels[i]=kFALSE;
1209   // no need to init CDHs
1210   for (Int_t i=0;i<216*4096*1024;++i) fADCs    [i]=-1    ;
1211   // no need to init trailers
1212   for (Int_t i=0;i<  1*4096*1024;++i) fRawData [i]= 0    ;
1213 }
1214
1215 Bool_t AliTPCAltroEmulator::ConvertDateToRoot() {
1216   //
1217   // convert a DATE file to a root file with the program "alimdc"
1218   //
1219
1220   // from $ALICE_ROOT/STEER/AliSimulation.cxx
1221
1222   printf(" DATE to ROOT CONVERSION: Run Number %d\n",fRunNumber);
1223
1224   // ALIMDC setup
1225   const Int_t kDBSize    = 2000000000; //2GB
1226   const Int_t kTagDBSize = 1000000000;
1227   const Bool_t kFilter = kFALSE;
1228   const Int_t kCompression = 1;
1229
1230   //  AliInfo(Form("converting DATE file %s to root file %s",
1231   //               dateFileName, rootFileName));
1232
1233   const char* rawDBFS[2] = { "/tmp/mdc1", "/tmp/mdc2" };
1234   const char* tagDBFS    = "/tmp/mdc1/tags";
1235
1236   // User defined file system locations
1237   if (gSystem->Getenv("ALIMDC_RAWDB1"))
1238     rawDBFS[0] = gSystem->Getenv("ALIMDC_RAWDB1");
1239   if (gSystem->Getenv("ALIMDC_RAWDB2"))
1240     rawDBFS[1] = gSystem->Getenv("ALIMDC_RAWDB2");
1241   if (gSystem->Getenv("ALIMDC_TAGDB"))
1242     tagDBFS = gSystem->Getenv("ALIMDC_TAGDB");
1243
1244   gSystem->Exec(Form("rm -rf %s",rawDBFS[0]));
1245   gSystem->Exec(Form("rm -rf %s",rawDBFS[1]));
1246   gSystem->Exec(Form("rm -rf %s",tagDBFS));
1247
1248   gSystem->Exec(Form("mkdir %s",rawDBFS[0]));
1249   gSystem->Exec(Form("mkdir %s",rawDBFS[1]));
1250   gSystem->Exec(Form("mkdir %s",tagDBFS));
1251
1252   Int_t result = gSystem->Exec(Form("alimdc %d %d %d %d %s",
1253                                     kDBSize, kTagDBSize, kFilter, kCompression, fOutputDateFileName.Data()));
1254   gSystem->Exec(Form("mv %s/*.root %s", rawDBFS[0],fOutputRootFileName.Data()));
1255
1256   gSystem->Exec(Form("rm -rf %s",rawDBFS[0]));
1257   gSystem->Exec(Form("rm -rf %s",rawDBFS[1]));
1258   gSystem->Exec(Form("rm -rf %s",tagDBFS));
1259
1260   return (result == 0);
1261 }
1262
1263 void AliTPCAltroEmulator::RunEmulationOnRAWdata(AliRawReader *reader, Int_t plotFlag) {
1264   //
1265   // Run the Altro Emulation on a full Raw data set (AliRawReader)
1266   // plus write the outcome in a RAW data format
1267   //
1268
1269   if (!reader) {
1270     printf("ERROR cant run Altro Emulation: AliRawReader is zero. No RAW data file.\n");
1271     return;
1272   }
1273
1274   fReader=reader;
1275   if (fDecoder) delete fDecoder;
1276   fDecoder=new AliTPCRawStreamV3(reader);
1277
1278   InitBuffers();
1279
1280   Int_t chanCount=0;
1281   TH1F hisO("DINO","DINO",1024,0,1024);
1282   TH1F his("DIN","DIN",1024,0,1024);
1283   his.GetYaxis()->SetRangeUser(-20,90);
1284   Short_t *data = new Short_t[1024];
1285   TCanvas *c1 =0;
1286   if (plotFlag) {
1287     c1 = new TCanvas("c1","c1");
1288     c1->SetGridx(); c1->SetGridy();
1289   }
1290
1291   // event loop
1292   Int_t ievent=0;
1293   while (fReader->NextEvent()) {
1294
1295     if (fReader->GetRunNumber()>0) fRunNumber=fReader->GetRunNumber();
1296     gSystem->Exec(Form("mkdir -p %s/raw%d/",fDDLFolderName.Data(),ievent));
1297     GDC2DDLs(const_cast<AliRawVEvent*>(fReader->GetEvent()),ievent);
1298
1299     Int_t ddlC =0;
1300     while (fDecoder->NextDDL()) {
1301       Int_t ddlID=fDecoder->GetDDLNumber();
1302       printf("ddl: %d (%d/216)\n",ddlID,++ddlC);
1303
1304       Bool_t  *channelsDDL=fChannels+ddlID*4096      ;
1305       Short_t *adcsDDL    =fADCs    +ddlID*4096*1024 ;
1306       UInt_t  *cdhDDL     =fCDHs    +ddlID*8         ;
1307       UInt_t  *trailerDDL =fTrailers+ddlID*9         ;
1308
1309       // CDH
1310       for (Int_t i=0;i<8;++i)
1311         // just to show how ugly it is...
1312         cdhDDL[i]=reinterpret_cast<UInt_t*>(const_cast<AliRawDataHeader*>(fReader->GetDataHeader()))[i];
1313
1314       // PAYLOAD
1315       while (fDecoder->NextChannel()) {
1316         Int_t hwaddr=fDecoder->GetHWAddress();
1317         Int_t sector=fDecoder->GetSector();
1318         Int_t row=fDecoder->GetRow();
1319         Int_t pad=fDecoder->GetPad();
1320         Short_t *adcsChannel=adcsDDL+hwaddr*1024;
1321         while (fDecoder->NextBunch()) {
1322           UInt_t          ts     =fDecoder->GetStartTimeBin();
1323           Int_t           cw     =fDecoder->GetBunchLength() ;
1324           const UShort_t *signals=fDecoder->GetSignals()     ;
1325           for (Int_t ci=0;ci<cw;++ci) {
1326             Short_t s=signals[ci];
1327             Int_t   t=ts-ci;
1328             // TODO aqcuisition window
1329             if (0<=t&&t<(1024-3)) {
1330               channelsDDL[hwaddr]=kTRUE;
1331               if (adcsChannel[t]<0)
1332                 adcsChannel[t]=s;
1333               else
1334                 adcsChannel[t]+=s;
1335               if (adcsChannel[t]>0x3ff)
1336                 adcsChannel[t]=0x3ff;
1337             }
1338           }
1339         }
1340
1341         // search start of aquisition
1342         Int_t t0 = 0;    while (adcsChannel[t0]==-1) t0++;
1343         // search end of aquisition
1344         Int_t tE = 1024; while (adcsChannel[tE]==-1) tE--;
1345
1346         // channel is complete - Perform Altro Emulation
1347         if (plotFlag!=0 && !(chanCount%plotFlag) ) {
1348           for (Int_t t=0; t<1024; t++) {
1349             his.SetBinContent(t+1,adcsChannel[t]);
1350           }
1351           his.SetTitle(Form("sig_sec%d_row%d_pad%d",sector,row,pad));
1352           his.SetStats(0); his.GetXaxis()->SetTitle("timebin");
1353           his.DrawCopy();
1354         }
1355
1356         // FEED THE ALTRO EMULATOR WITH CLEAN SIGNAL (no aquisition-window ghosts)
1357         Int_t timebins = tE-t0+1;
1358         for (Int_t t=t0;t<(t0+timebins);t++)
1359           data[t-t0]=adcsChannel[t];
1360         SetChannelData(timebins,data);
1361
1362         Int_t roc = (sector%36)>=18; // 0 for IROC, 1 for OROC
1363         RunEmulation(roc);
1364         for (Int_t t=t0;t<(t0+timebins);t++)
1365           adcsChannel[t]=data[t-t0];
1366
1367         if (plotFlag!=0 && !(chanCount%plotFlag) ) {
1368           for (Int_t t=0; t<1024; t++)
1369             hisO.SetBinContent(t+1,adcsChannel[t]);
1370           hisO.SetStats(0); hisO.SetLineColor(2);
1371           hisO.DrawCopy("same");
1372
1373           c1->SaveAs(Form("/tmp/sig_sec%02d_row%02d_pad%03d_%d%d%d%d%d.png",
1374                           sector,row,pad,fOnBSL1,fOnTCF,fOnBSL2,fOnClip,fOnZSU));
1375
1376           his.Reset();
1377           hisO.Reset();
1378
1379         }
1380         chanCount++;
1381
1382       }
1383
1384       // TRAILER
1385       UChar_t *rcuTrailer;
1386       fDecoder->GetRCUTrailerData(rcuTrailer);
1387       for (Int_t i=0;i<= /* (!) */ fDecoder->GetRCUTrailerSize()/4;++i)
1388         trailerDDL[i]=reinterpret_cast<UInt_t*>(rcuTrailer)[i]; // again: UGLY!
1389
1390     }
1391
1392     if (ddlC>0) WriteEvent(ievent++);
1393   }
1394
1395   delete[] data; // free space
1396
1397   // convert to date and back
1398   ConvertRawFilesToDate(ievent);
1399   ConvertDateToRoot();
1400
1401
1402 }