TRD/AliTRDptrgParam.cxx

   1 /**************************************************************************
   2  * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
   3  *                                                                        *
   4  * Author: The ALICE Off-line Project.                                    *
   5  * Contributors are mentioned in the code where appropriate.              *
   6  *                                                                        *
   7  * Permission to use, copy, modify and distribute this software and its   *
   8  * documentation strictly for non-commercial purposes is hereby granted   *
   9  * without fee, provided that the above copyright notice appears in all   *
  10  * copies and that both the copyright notice and this permission notice   *
  11  * appear in the supporting documentation. The authors make no claims     *
  12  * about the suitability of this software for any purpose. It is          *
  13  * provided "as is" without express or implied warranty.                  *
  14  **************************************************************************/
  15
  16 /* $Id$ */
  17
  18 ////////////////////////////////////////////////////////////////////////////
  19 //
  20 //  Parameters for Pre-Trigger Simulation
  21 //
  22 //  Author: F. Reidt (Felix.Reidt@cern.ch)
  23 //
  24 //  This class controls the parameters used by the pretrigger simulation.
  25 //  A configuration file ca be loaded by calling LoadConfigurationFromFile()
  26 //  The generation of look up tables is also done in this class and has to
  27 //  be done only once after a configuration file was loaded.
  28 //  If no configuration file was loaded, the standard
  29 //  configuration in LoadStandardConfiguration() would be used.
  30 //
  31 ////////////////////////////////////////////////////////////////////////////
  32 #include "TArrayI.h"
  33 #include "TObjString.h"
  34 #include "TString.h"
  35
  36 #include <fstream>
  37
  38 #include "AliLog.h"
  39
  40 #include "AliTRDptrgParam.h"
  41
  42 ClassImp(AliTRDptrgParam)
  43
  44 AliTRDptrgParam *AliTRDptrgParam::fgInstance = 0;
  45
  46
  47 //______________________________________________________________________________
  48 AliTRDptrgParam::AliTRDptrgParam()
  49   : TObject(),
  50     fTLMUInputStretch(0),
  51     fTLMUcmatrices(0x0),
  52     fTLMUmultiplicity(0x0),
  53     fTLMUoutput(0x0),
  54     fFEBT0Thresholds(0x0),
  55     fFEBT0Multiplicities(0x0),
  56     fFEBT0LUTs(0x0),
  57     fFEBV0Thresholds(0x0),
  58     fFEBV0Multiplicities(0x0),
  59     fFEBV0LUTs(0x0),
  60     fCBLUTs(0x0),
  61     fCBALUTequX(TString()),
  62     fCBALUTequY(TString()),
  63     fCBCLUTequX(TString()),
  64     fCBCLUTequY(TString()),
  65     fCBBLUTequX(TString()),
  66     fCBBLUTequY(TString()),
  67     fPTmasks(AliTRDptrgPTmasks())
  68 {
  69   // ctor
  70
  71   // initialize coincidence matrices
  72   this->fTLMUcmatrices = new UInt_t*[3];
  73   for (UInt_t iMatrix = 0; iMatrix < 3; iMatrix++) {
  74     this->fTLMUcmatrices[iMatrix] = new UInt_t[18];
  75     for (UInt_t iSlice = 0; iSlice < 18; iSlice++) {
  76       this->fTLMUcmatrices[iMatrix][iSlice] = 0;
  77     }
  78   }
  79
  80   // initialize multiplicity slices
  81   this->fTLMUmultiplicity = new UInt_t*[9];
  82   for (UInt_t iSlice = 0; iSlice < 9; iSlice++) {
  83     this->fTLMUmultiplicity[iSlice] = new UInt_t[2];
  84     this->fTLMUmultiplicity[iSlice][0] = 577; // disabled
  85     this->fTLMUmultiplicity[iSlice][1] = 0;
  86   }
  87
  88   // initialize output muxer
  89   this->fTLMUoutput = new Int_t*[8];
  90   for (UInt_t iBit = 0; iBit < 8; iBit++) {
  91     this->fTLMUoutput[iBit] = new Int_t[2];
  92     this->fTLMUoutput[iBit][0] = -1; // cmatrix disabled
  93     this->fTLMUoutput[iBit][1] = -1; // multslice disabled
  94   }
  95
  96   // initialize T0 FEB thresholds
  97   this->fFEBT0Thresholds = new UInt_t*[2];
  98   this->fFEBT0Thresholds[0] = new UInt_t[12];
  99   this->fFEBT0Thresholds[1] = new UInt_t[12];
 100   for (Int_t iChan = 0; iChan < 12; iChan++) {
 101     this->fFEBT0Thresholds[0][iChan] = 4294967295U;
 102     this->fFEBT0Thresholds[1][iChan] = 4294967295U;
 103     // writing 2^32-1 disables the input because all used adcs have
 104     // less than 32 bits
 105   }
 106
 107   // initialize T0 Multiplicity
 108   this->fFEBT0Multiplicities = new UInt_t**[2];
 109   this->fFEBT0Multiplicities[0] = new UInt_t*[2];
 110   this->fFEBT0Multiplicities[1] = new UInt_t*[2];
 111   this->fFEBT0Multiplicities[0][0] = new UInt_t[2];
 112   this->fFEBT0Multiplicities[0][1] = new UInt_t[2];
 113   this->fFEBT0Multiplicities[1][0] = new UInt_t[2];
 114   this->fFEBT0Multiplicities[1][1] = new UInt_t[2];
 115   this->fFEBT0Multiplicities[0][0][0] = 4294967295U;
 116   this->fFEBT0Multiplicities[0][0][1] = 4294967295U;
 117   this->fFEBT0Multiplicities[0][1][0] = 4294967295U;
 118   this->fFEBT0Multiplicities[0][1][1] = 4294967295U;
 119   this->fFEBT0Multiplicities[1][0][0] = 4294967295U;
 120   this->fFEBT0Multiplicities[1][0][1] = 4294967295U;
 121   this->fFEBT0Multiplicities[1][1][0] = 4294967295U;
 122   this->fFEBT0Multiplicities[1][1][1] = 4294967295U;
 123   // writing 2^32-1 disables the input because all used adcs have
 124   // less than 32 bits
 125
 126   // initialize T0 LUTs
 127   // this->fFEBT0LUTs = 0x0; (done in member initialization list)
 128   // further initialization is done in AliTRDptrgParam::GenerateLUTs()
 129
 130
 131   // initialize V0 FEB Thresholds
 132   this->fFEBV0Thresholds = new UInt_t**[2];
 133   for (UInt_t iPosition = 0; iPosition < 2; iPosition++) {
 134     this->fFEBV0Thresholds[iPosition] = new UInt_t*[4];
 135     for (UInt_t iCard = 0; iCard < 4; iCard++) {
 136       this->fFEBV0Thresholds[iPosition][iCard] = new UInt_t[8];
 137       for (UInt_t iChannel = 0; iChannel < 8; iChannel++) {
 138         this->fFEBV0Thresholds[iPosition][iCard][iChannel] = 4294967295U;
 139       }
 140     }
 141   }
 142
 143   // initialize V0 Multiplicities
 144   this->fFEBV0Multiplicities = new UInt_t***[2];
 145   for (UInt_t iPosition = 0; iPosition < 2; iPosition++) {
 146     this->fFEBV0Multiplicities[iPosition] = new UInt_t**[4];
 147     for (UInt_t iCard = 0; iCard < 4; iCard++) {
 148       this->fFEBV0Multiplicities[iPosition][iCard] = new UInt_t*[2];
 149       for (UInt_t iLUT = 0; iLUT < 2; iLUT++) {
 150         this->fFEBV0Multiplicities[iPosition][iCard][iLUT] = new UInt_t[2];
 151         this->fFEBV0Multiplicities[iPosition][iCard][iLUT][0] = 4294967295U;
 152         this->fFEBV0Multiplicities[iPosition][iCard][iLUT][1] = 0x0;
 153       }
 154     }
 155   }
 156
 157   // initialize V0 LUTs
 158   //  this->fFEBV0LUTs = 0x0; (done in member initialization list)
 159   // further initialization is done in AliTRDptrgParam::GenerateLUTs()
 160
 161   // initialize CB LUTs
 162   // this->fCBLUTs = 0x0; (done in member initialization list)
 163   // further initialization is done in AliTRDptrgParam::GenerateLUTs()
 164
 165   this->LoadStandardConfiguration(); // load standard configuration
 166 }
 167
 168 //______________________________________________________________________________
 169 AliTRDptrgParam::~AliTRDptrgParam()
 170 {
 171   // dtor
 172
 173   // delete coincidence matrices
 174   if (this->fTLMUcmatrices != 0x0) {
 175     for (UInt_t iMatrix = 0; iMatrix < 3; iMatrix++) {
 176       if (this->fTLMUcmatrices[iMatrix] != 0x0) {
 177         delete[] this->fTLMUcmatrices[iMatrix];
 178         this->fTLMUcmatrices[iMatrix] = 0x0;
 179       }
 180     }
 181     delete[] this->fTLMUcmatrices;
 182     this->fTLMUcmatrices = 0x0;
 183   }
 184
 185   // delete multiplicity slices
 186   if (this->fTLMUmultiplicity != 0x0) {
 187     for (UInt_t iSlice = 0; iSlice < 9; iSlice++) {
 188       if (this->fTLMUmultiplicity[iSlice] != 0x0) {
 189         delete[] this->fTLMUmultiplicity[iSlice];
 190         this->fTLMUmultiplicity[iSlice] = 0x0;
 191       }
 192     }
 193     delete[] this->fTLMUmultiplicity;
 194     this->fTLMUmultiplicity = 0x0;
 195   }
 196
 197   // delete output mux
 198   if (this->fTLMUoutput != 0x0) {
 199     for (UInt_t iBit = 0; iBit < 8; iBit++) {
 200       if (this->fTLMUoutput[iBit] != 0x0) {
 201         delete[] this->fTLMUoutput[iBit];
 202         this->fTLMUoutput[iBit] = 0x0;
 203       }
 204     }
 205     delete[] this->fTLMUoutput;
 206     this->fTLMUoutput = 0x0;
 207   }
 208
 209   // delete T0 FEB thresholds
 210   if (this->fFEBT0Thresholds != 0x0) {
 211     if (this->fFEBT0Thresholds[0] != 0x0) {
 212       delete[] this->fFEBT0Thresholds[0];
 213       this->fFEBT0Thresholds[0] = 0x0;
 214     }
 215     if (this->fFEBT0Thresholds[1] != 0x0) {
 216       delete[] this->fFEBT0Thresholds[1];
 217       this->fFEBT0Thresholds[1] = 0x0;
 218     }
 219     delete[] this->fFEBT0Thresholds;
 220     this->fFEBT0Thresholds = 0x0;
 221   }
 222
 223   // delete T0 multiplicities
 224   if (this->fFEBT0Multiplicities != 0x0) {
 225     for (UInt_t iPosition = 0; iPosition < 2; iPosition++) {
 226       if (this->fFEBT0Multiplicities[iPosition] != 0x0) {
 227         for (UInt_t iLUT = 0; iLUT < 2; iLUT++) {
 228           if (this->fFEBT0Multiplicities[iPosition][iLUT] != 0x0) {
 229             delete[] this->fFEBT0Multiplicities[iPosition][iLUT];
 230             this->fFEBT0Multiplicities[iPosition][iLUT] = 0x0;
 231           }
 232         }
 233         delete[] this->fFEBT0Multiplicities[iPosition];
 234         this->fFEBT0Multiplicities[iPosition] = 0x0;
 235       }
 236     }
 237     delete[] this->fFEBT0Multiplicities;
 238     this->fFEBT0Multiplicities = 0x0;
 239   }
 240
 241   // delete T0 LUTs
 242   if (this->fFEBT0LUTs != 0x0) {
 243     for (UInt_t iPosition = 0; iPosition < 2; iPosition++) {
 244       if (this->fFEBT0LUTs[iPosition] != 0x0) {
 245         for (UInt_t iLUT = 0; iLUT < 2; iLUT++) {
 246           if (this->fFEBT0LUTs[iPosition][iLUT] != 0x0) {
 247             delete[] this->fFEBT0LUTs[iPosition][iLUT];
 248             this->fFEBT0LUTs[iPosition][iLUT] = 0x0;
 249           }
 250         }
 251         delete[] this->fFEBT0LUTs[iPosition];
 252         this->fFEBT0LUTs[iPosition] = 0x0;
 253       }
 254     }
 255     delete[] this->fFEBT0LUTs;
 256     this->fFEBT0LUTs = 0x0;
 257   }
 258
 259   // delete V0 FEB thresholds
 260   if (this->fFEBV0Thresholds != 0x0) {
 261     for (UInt_t iPosition = 0; iPosition < 2; iPosition++) {
 262       if (this->fFEBV0Thresholds[iPosition] != 0x0) {
 263         for (UInt_t iCard = 0; iCard < 4; iCard++) {
 264           if (this->fFEBV0Thresholds[iPosition][iCard] != 0x0) {
 265             delete[] this->fFEBV0Thresholds[iPosition][iCard];
 266             this->fFEBV0Thresholds[iPosition][iCard] = 0x0;
 267           }
 268         }
 269         delete[] this->fFEBV0Thresholds[iPosition];
 270         this->fFEBV0Thresholds[iPosition] = 0x0;
 271       }
 272     }
 273     delete[] this->fFEBV0Thresholds;
 274     this->fFEBV0Thresholds = 0x0;
 275   }
 276
 277   // delete V0 multiplicities
 278   if (this->fFEBV0Multiplicities != 0x0) {
 279     for (UInt_t iPosition = 0; iPosition < 2; iPosition++) {
 280       if (this->fFEBV0Multiplicities[iPosition] != 0x0) {
 281         for (UInt_t iCard = 0; iCard < 4; iCard++) {
 282           if (this->fFEBV0Multiplicities[iPosition][iCard] != 0x0) {
 283             for (UInt_t iLUT = 0; iLUT < 2; iLUT++) {
 284               if (this->fFEBV0Multiplicities[iPosition][iCard][iLUT] != 0x0) {
 285                 delete[] this->fFEBV0Multiplicities[iPosition][iCard][iLUT];
 286                 this->fFEBV0Multiplicities[iPosition][iCard][iLUT] = 0x0;
 287               }
 288             }
 289             delete[] this->fFEBV0Multiplicities[iPosition][iCard];
 290             this->fFEBV0Multiplicities[iPosition][iCard] = 0x0;
 291           }
 292         }
 293         delete[] this->fFEBV0Multiplicities[iPosition];
 294         this->fFEBV0Multiplicities[iPosition] = 0x0;
 295       }
 296     }
 297     delete[] this->fFEBV0Multiplicities;
 298     this->fFEBV0Multiplicities = 0x0;
 299   }
 300
 301   // delete V0 LUTs
 302   if (this->fFEBV0LUTs != 0x0) {
 303     for (UInt_t iPosition = 0; iPosition < 2; iPosition++) {
 304       if (this->fFEBV0LUTs[iPosition] != 0x0) {
 305         for (UInt_t iCard = 0; iCard < 4; iCard++) {
 306           if (this->fFEBV0LUTs[iPosition][iCard] != 0x0) {
 307             for (UInt_t iLUT = 0; iLUT < 2; iLUT++) {
 308               if (this->fFEBV0LUTs[iPosition][iCard][iLUT] != 0x0) {
 309                 delete[] this->fFEBV0LUTs[iPosition][iCard][iLUT];
 310                 this->fFEBV0LUTs[iPosition][iCard][iLUT] = 0x0;
 311               }
 312             }
 313             delete[] this->fFEBV0LUTs[iPosition][iCard];
 314             this->fFEBV0LUTs[iPosition][iCard] = 0x0;
 315           }
 316         }
 317         delete[] this->fFEBV0LUTs[iPosition];
 318         this->fFEBV0LUTs[iPosition] = 0x0;
 319       }
 320     }
 321     delete[] this->fFEBV0LUTs;
 322     this->fFEBV0LUTs = 0x0;
 323   }
 324
 325   // delete CB LUTs
 326   if (this->fCBLUTs != 0x0) {
 327     for (UInt_t iCB = 0; iCB < 3; iCB++) {
 328       if (this->fCBLUTs[iCB] != 0x0) {
 329         for (UInt_t iLUT = 0; iLUT < 2; iLUT++) {
 330           if (this->fCBLUTs[iCB][iLUT] != 0x0) {
 331             delete[] this->fCBLUTs[iCB][iLUT];
 332             this->fCBLUTs[iCB][iLUT] = 0x0;
 333           }
 334         }
 335         delete[] this->fCBLUTs[iCB];
 336         this->fCBLUTs[iCB] = 0x0;
 337       }
 338     }
 339     delete[] this->fCBLUTs;
 340     this->fCBLUTs = 0x0;
 341   }
 342 }
 343
 344 //______________________________________________________________________________
 345 Int_t AliTRDptrgParam::CheckVariables() const
 346 {
 347   // checks whether variables are deleted early enough
 348
 349   // check coincidence matrices
 350   if (this->fTLMUcmatrices != 0x0) {
 351     for (UInt_t iMatrix = 0; iMatrix < 3; iMatrix++) {
 352       if (this->fTLMUcmatrices[iMatrix] == 0x0) {
 353         return -1;
 354       }
 355     }
 356   }
 357   else {
 358     return -2;
 359   }
 360
 361   // check multiplicity slices
 362   if (this->fTLMUmultiplicity != 0x0) {
 363     for (UInt_t iSlice = 0; iSlice < 9; iSlice++) {
 364       if (this->fTLMUmultiplicity[iSlice] == 0x0) {
 365         return -3;
 366       }
 367     }
 368   }
 369   else {
 370     return -4;
 371   }
 372
 373   // check output mux
 374   if (this->fTLMUoutput != 0x0) {
 375     for (UInt_t iBit = 0; iBit < 8; iBit++) {
 376       if (this->fTLMUoutput[iBit] == 0x0) {
 377         return -5;
 378       }
 379     }
 380   }
 381   else {
 382     return -6;
 383   }
 384
 385   // delete T0 FEB thresholds
 386   if (this->fFEBT0Thresholds != 0x0) {
 387     if (this->fFEBT0Thresholds[0] == 0x0) {
 388       return -7;
 389     }
 390     if (this->fFEBT0Thresholds[1] == 0x0) {
 391       return -8;
 392     }
 393   }
 394   else {
 395     return -9;
 396   }
 397
 398   // delete T0 multiplicities
 399   if (this->fFEBT0Multiplicities != 0x0) {
 400     for (UInt_t iPosition = 0; iPosition < 2; iPosition++) {
 401       if (this->fFEBT0Multiplicities[iPosition] != 0x0) {
 402         for (UInt_t iLUT = 0; iLUT < 2; iLUT++) {
 403           if (this->fFEBT0Multiplicities[iPosition][iLUT] == 0x0) {
 404             return -10;
 405           }
 406         }
 407       }
 408       else {
 409         return -11;
 410       }
 411     }
 412   }
 413   else {
 414     return -12;
 415   }
 416
 417
 418   // delete T0 LUTs
 419   if (this->fFEBT0LUTs != 0x0) {
 420     for (UInt_t iPosition = 0; iPosition < 2; iPosition++) {
 421       if (this->fFEBT0LUTs[iPosition] != 0x0) {
 422         for (UInt_t iLUT = 0; iLUT < 2; iLUT++) {
 423           if (this->fFEBT0LUTs[iPosition][iLUT] == 0x0) {
 424             return -13;
 425           }
 426         }
 427       }
 428       else {
 429         return -14;
 430       }
 431     }
 432   }
 433   else {
 434     return -15;
 435   }
 436
 437   // delete V0 FEB thresholds
 438   if (this->fFEBV0Thresholds != 0x0) {
 439     for (UInt_t iPosition = 0; iPosition < 2; iPosition++) {
 440       if (this->fFEBV0Thresholds[iPosition] != 0x0) {
 441         for (UInt_t iCard = 0; iCard < 4; iCard++) {
 442           if (this->fFEBV0Thresholds[iPosition][iCard] == 0x0) {
 443             return -16;
 444           }
 445         }
 446       }
 447       else {
 448         return -17;
 449       }
 450     }
 451   }
 452   else {
 453     return -18;
 454   }
 455
 456   // delete V0 multiplicities
 457   if (this->fFEBV0Multiplicities != 0x0) {
 458     for (UInt_t iPosition = 0; iPosition < 2; iPosition++) {
 459       if (this->fFEBV0Multiplicities[iPosition] != 0x0) {
 460         for (UInt_t iCard = 0; iCard < 4; iCard++) {
 461           if (this->fFEBV0Multiplicities[iPosition][iCard] != 0x0) {
 462             for (UInt_t iLUT = 0; iLUT < 2; iLUT++) {
 463               if (this->fFEBV0Multiplicities[iPosition][iCard][iLUT] == 0x0) {
 464                 return -19;
 465               }
 466             }
 467           }
 468           else {
 469             return -20;
 470           }
 471         }
 472       }
 473       else {
 474         return -21;
 475       }
 476     }
 477   }
 478   else {
 479     return -22;
 480   }
 481
 482   // delete V0 LUTs
 483   if (this->fFEBV0LUTs != 0x0) {
 484     for (UInt_t iPosition = 0; iPosition < 2; iPosition++) {
 485       if (this->fFEBV0LUTs[iPosition] != 0x0) {
 486         for (UInt_t iCard = 0; iCard < 4; iCard++) {
 487           if (this->fFEBV0LUTs[iPosition][iCard] != 0x0) {
 488             for (UInt_t iLUT = 0; iLUT < 2; iLUT++) {
 489               if (this->fFEBV0LUTs[iPosition][iCard][iLUT] == 0x0) {
 490                 return -23;
 491               }
 492             }
 493           }
 494           else {
 495             return -24;
 496           }
 497         }
 498       }
 499       else {
 500         return -25;
 501       }
 502     }
 503   }
 504   else {
 505     return -26;
 506   }
 507
 508   // delete CB LUTs
 509   if (this->fCBLUTs != 0x0) {
 510     for (UInt_t iCB = 0; iCB < 3; iCB++) {
 511       if (this->fCBLUTs[iCB] != 0x0) {
 512         for (UInt_t iLUT = 0; iLUT < 2; iLUT++) {
 513           if (this->fCBLUTs[iCB][iLUT] == 0x0) {
 514             return -27;
 515           }
 516         }
 517       }
 518       else {
 519         return -28;
 520       }
 521     }
 522   }
 523   else {
 524     return -29;
 525   }
 526   return 0;
 527 }
 528
 529 //______________________________________________________________________________
 530 AliTRDptrgParam* AliTRDptrgParam::Instance()
 531 {
 532   // get (or create) the single instance
 533
 534   if (fgInstance == 0)
 535     fgInstance = new AliTRDptrgParam();
 536
 537   return fgInstance;
 538 }
 539
 540 //______________________________________________________________________________
 541 void AliTRDptrgParam::Terminate()
 542 {
 543   // destruct the instance
 544
 545   if (fgInstance != 0) {
 546     delete fgInstance;
 547     fgInstance = 0x0;
 548   }
 549 }
 550
 551 //______________________________________________________________________________
 552 void AliTRDptrgParam::LoadStandardConfiguration() {
 553   // loads a standard configuration parameters for testing
 554
 555   // TLMU Input Masks
 556   for (UInt_t iSM = 0; iSM < 18; iSM++) {
 557     this->fTLMUInputMask[iSM] = 0xFFFFFFFF; // enable all input bits
 558   }
 559
 560   // TLMU Input Stretch
 561   this->fTLMUInputStretch = 0; // not used in simulation
 562
 563   // TLMU Coincidence Matrices
 564   //
 565   // Matrix 0: Back-To-Back
 566   // Matrix 1: Back-To-Back +/-1
 567   // Matrix 2: Back-To-Back +/-2
 568   for (UInt_t iMatrix = 0; iMatrix < 3; iMatrix++) {
 569     for (UInt_t iSlice = 0; iSlice < 18; iSlice++) {
 570       if (iMatrix == 0) {
 571         if (iSlice < 9) {
 572           this->fTLMUcmatrices[iMatrix][iSlice] = 0x201 << iSlice;
 573           // Back-To-Back
 574           AliDebug(5, Form("fTLMUcmatrices[%d][%d]=0x%x",iMatrix,iSlice,
 575                            this->fTLMUcmatrices[iMatrix][iSlice]));
 576         }
 577         // because of symmetrie the other slices are not necessary
 578       }
 579       else if (iMatrix == 1)  {
 580         // Back-To-Back +/- 1
 581         if (iSlice < 8) {
 582           this->fTLMUcmatrices[iMatrix][iSlice] = 0x381 << iSlice;
 583         }
 584         else if (iSlice == 8) {
 585           this->fTLMUcmatrices[iMatrix][iSlice] = 0x30101;
 586         }
 587         else if (iSlice == 9) {
 588           this->fTLMUcmatrices[iMatrix][iSlice] = 0x20203;
 589         }
 590         else {
 591           this->fTLMUcmatrices[iMatrix][iSlice] = 0x407 << (iSlice - 10);
 592         }
 593         AliDebug(5, Form("fTLMUcmatrices[%d][%d]=0x%x",iMatrix,iSlice,
 594                          this->fTLMUcmatrices[iMatrix][iSlice]));
 595       }
 596       else if (iMatrix == 2) {
 597         // Back-To-Back +/-2
 598         if (iSlice < 7 ) {
 599           this->fTLMUcmatrices[iMatrix][iSlice] = 0xF81 << iSlice;
 600         }
 601         else if (iSlice == 7) {
 602           this->fTLMUcmatrices[iMatrix][iSlice] = 0x3C081;
 603         }
 604         else if (iSlice == 8) {
 605           this->fTLMUcmatrices[iMatrix][iSlice] = 0x38103;
 606         }
 607         else if (iSlice == 9) {
 608           this->fTLMUcmatrices[iMatrix][iSlice] = 0x30207;
 609         }
 610         else if (iSlice == 10) {
 611           this->fTLMUcmatrices[iMatrix][iSlice] = 0x2040F;
 612         }
 613         else {
 614           this->fTLMUcmatrices[iMatrix][iSlice] = 0x81F << (iSlice - 11);
 615         }
 616         AliDebug(5, Form("fTLMUcmatrices[%d][%d]=0x%x",iMatrix,iSlice,
 617                          this->fTLMUcmatrices[iMatrix][iSlice]));
 618       }
 619     }
 620   }
 621
 622   // TLMU Mulitplicity
 623   this->fTLMUmultiplicity[0][0] = 0;
 624   this->fTLMUmultiplicity[0][1] = 10;
 625   this->fTLMUmultiplicity[1][0] = 10;
 626   this->fTLMUmultiplicity[1][1] = 25;
 627   this->fTLMUmultiplicity[2][0] = 25;
 628   this->fTLMUmultiplicity[2][1] = 50;
 629   this->fTLMUmultiplicity[3][0] = 50;
 630   this->fTLMUmultiplicity[3][1] = 100;
 631   this->fTLMUmultiplicity[4][0] = 100;
 632   this->fTLMUmultiplicity[4][1] = 200;
 633   this->fTLMUmultiplicity[5][0] = 200;
 634   this->fTLMUmultiplicity[5][1] = 350;
 635   this->fTLMUmultiplicity[6][0] = 350;
 636   this->fTLMUmultiplicity[6][1] = 400;
 637   this->fTLMUmultiplicity[7][0] = 400;
 638   this->fTLMUmultiplicity[7][1] = 576;
 639   this->fTLMUmultiplicity[8][0] = 100;
 640   this->fTLMUmultiplicity[8][1] = 576;
 641
 642   // TLMU output
 643   this->fTLMUoutput[0][0] = 0;
 644   this->fTLMUoutput[1][0] = 1;
 645   this->fTLMUoutput[2][0] = 2;
 646   this->fTLMUoutput[3][1] = 0;
 647   this->fTLMUoutput[4][1] = 1;
 648   this->fTLMUoutput[5][1] = 2;
 649   this->fTLMUoutput[6][1] = 3;
 650   this->fTLMUoutput[7][1] = 8;
 651
 652   // T0 FEB Thresholds
 653   for (UInt_t iChannel = 0; iChannel < 12; iChannel++) {
 654     this->fFEBT0Thresholds[0][iChannel] = 10;
 655     this->fFEBT0Thresholds[1][iChannel] = 10;
 656   }
 657
 658   // T0 Multiplicities
 659   for (UInt_t iPosition = 0; iPosition < 2; iPosition++) {
 660     for (UInt_t iLUT = 0; iLUT < 2; iLUT++) {
 661       if (iLUT == 0) {
 662         this->fFEBT0Multiplicities[iPosition][iLUT][0] = 0;
 663       }
 664       else {
 665         this->fFEBT0Multiplicities[iPosition][iLUT][0] = 5;
 666       }
 667       this->fFEBT0Multiplicities[iPosition][iLUT][1] = 0xFFF;
 668     }
 669   }
 670
 671   // V0 FEB Thresholds
 672   for (UInt_t iPosition = 0; iPosition < 2; iPosition++) {
 673     for (UInt_t iCard = 0; iCard < 4; iCard++) {
 674       for (UInt_t iChannel = 0; iChannel < 8; iChannel++) {
 675         this->fFEBV0Thresholds[iPosition][iCard][iChannel] = 10;
 676       }
 677     }
 678   }
 679
 680   // V0 Multiplicities
 681   for (UInt_t iPosition = 0; iPosition < 2; iPosition++) {
 682     for (UInt_t iCard = 0; iCard < 4; iCard++) {
 683       for (UInt_t iLUT = 0; iLUT < 2; iLUT++) {
 684         if (iLUT == 0) {
 685           this->fFEBV0Multiplicities[iPosition][iCard][iLUT][0] = 0;
 686         }
 687         else {
 688           this->fFEBV0Multiplicities[iPosition][iCard][iLUT][0] = 3;
 689         }
 690         this->fFEBV0Multiplicities[iPosition][iCard][iLUT][1] = 0xFF;
 691       }
 692     }
 693   }
 694
 695   // CB-A LUT equations
 696   this->fCBALUTequX = "T0_0 || (V0-0_0 || V0-1_0 || V0-2_0 || V0-3_0)";
 697   this->fCBALUTequY = "!T0_1 && !V0-0_1 && !V0-1_1 && !V0-2_1 && !V0-3_1";
 698
 699   // CB-C LUT equations
 700   this->fCBCLUTequX = "T0_0 || ( V0-0_0 || V0-1_0 || V0-2_0 || V0-3_0 )";
 701   this->fCBCLUTequY = "!T0_1 && !V0-0_1 && !V0-1_1 && !V0-2_1 && !V0-3_1";
 702
 703   // CB-B LUT equations
 704   this->fCBBLUTequX = "( CB-A_1 || CB-C_1 ) && TLMU_7";
 705   this->fCBBLUTequY = "( CB-A_1 || CB-C_1 ) && TLMU_7";
 706
 707   // PT output mask
 708   this->fPTmasks.fLUTs[0] = kTRUE;
 709   this->fPTmasks.fLUTs[1] = kTRUE;
 710   this->fPTmasks.fCBA[0] = kTRUE;
 711   this->fPTmasks.fCBC[0] = kTRUE;
 712   for (Int_t i = 1; i < 8; i++) {
 713     this->fPTmasks.fTLMU[i] = kTRUE;
 714   }
 715
 716   return;
 717 }
 718
 719 //______________________________________________________________________________
 720 Bool_t AliTRDptrgParam::LoadConfigurationFromFile(TString filename) {
 721   // Reads pretrigger configuration file and forwards identifiers and values
 722   // to the corresponding parser functions
 723   // This method is only checking for certain keywords at the beginning of a
 724   // line in the config file
 725
 726   ifstream inputFile;
 727   inputFile.open(filename.Data());
 728   TString line;
 729   TString identifier;
 730   TString value;
 731   std::string str;
 732
 733
 734   if (inputFile.is_open())
 735   {
 736     AliDebug(5, "---- Reading configuration file ----");
 737     while (getline(inputFile, str)) {
 738       line = str;
 739
 740       AliDebug(5, Form("line: %s\n", line.Data()));
 741       if (line.Index("TLMU") == 0) {
 742         this->PrepareLine(line, identifier, value);
 743         if (!this->ParseTLMU(identifier, value)) {
 744           return kFALSE;
 745         }
 746       }
 747       else if (line.Index("FEB") == 0) {
 748         this->PrepareLine(line, identifier, value);
 749         if (!this->ParseFEB(identifier, value)) {
 750           return kFALSE;
 751         }
 752       }
 753       else if (line.Index("CBB") == 0) {
 754         this->PrepareLine(line, identifier, value);
 755         if (!this->ParseCBB(identifier, value)) {
 756           return kFALSE;
 757         }
 758       }
 759       else if ((line.Index("CBA") == 0) ||
 760                (line.Index("CBC") == 0)) {
 761         this->PrepareLine(line, identifier, value);
 762         if (!this->ParseCBAC(identifier, value)) {
 763           return kFALSE;
 764         }
 765       }
 766     }
 767     AliDebug(5, "---- Finished reading configuration file ----");
 768     inputFile.close();
 769     return kTRUE;
 770   }
 771   else
 772   {
 773     AliDebug(5, "Error opening configuration file");
 774     return kFALSE;
 775   }
 776   return kTRUE;
 777 }
 778
 779
 780 //______________________________________________________________________________
 781 Int_t AliTRDptrgParam::GenerateLUTs() {
 782   // generates all LUTs defined inside this object, this schould called only
 783   // once, after configuration is loaded in order to save cpu time
 784
 785   // generation method:
 786   // walk through address space
 787   // mask address with input mask =>  get multiplicity of masked value
 788   // if (multiplicity of masked value) > multiplicity condition
 789   // write 1 in LUT
 790
 791   // T0
 792   this->fFEBT0LUTs = new Int_t**[2]; // 2 A + C side
 793   for (UInt_t iPosition = 0; iPosition < 2; iPosition++) {
 794     // iPosition = 0 -> A, iPosition = 1 -> C
 795     this->fFEBT0LUTs[iPosition] = new Int_t*[2]; // 2 LUTs per side
 796     for (UInt_t iLUT = 0; iLUT < 2; iLUT++) {
 797       // LUT with 12 input channels 2^12=4096
 798       this->fFEBT0LUTs[iPosition][iLUT] = new Int_t[4096];
 799       AliDebug(5, Form("Generate FEBT0LUT[%d][%d]: (0x%x)>%d", iPosition, iLUT,
 800                        this->fFEBT0Multiplicities[iPosition][iLUT][1],
 801                        this->fFEBT0Multiplicities[iPosition][iLUT][0]));
 802       for (UInt_t iEntry = 0; iEntry < 4096; iEntry++) {
 803         // Check whether that entry belongs to a multiplicity exceeding the
 804         // threshold
 805         if (this->GetMultiplicity(iEntry &
 806               this->fFEBT0Multiplicities[iPosition][iLUT][1]) >
 807             this->fFEBT0Multiplicities[iPosition][iLUT][0]) {
 808           this->fFEBT0LUTs[iPosition][iLUT][iEntry] = 1;
 809         }
 810         else {
 811           // initialize LUT (not done before !)
 812           this->fFEBT0LUTs[iPosition][iLUT][iEntry] = 0;
 813         }
 814         AliDebug(10, Form("FEBT0LUTs[%d][%d][0x%x]=%d", iPosition, iLUT, iEntry,
 815                          this->fFEBT0LUTs[iPosition][iLUT][iEntry]));
 816       }
 817       AliDebug(5, Form("Generated FEBT0LUTs[%d][%d]", iPosition, iLUT));
 818     }
 819   }
 820
 821   // V0
 822   this->fFEBV0LUTs = new Int_t***[2]; // 2 A + C side
 823   for (UInt_t iPosition = 0; iPosition < 2; iPosition++) {
 824     // iPosition = 0 -> A, iPosition = 1 -> C
 825     this->fFEBV0LUTs[iPosition] = new Int_t**[4]; // 4 FEBs per side
 826     for (UInt_t iFEB = 0; iFEB < 4; iFEB++) {
 827       this->fFEBV0LUTs[iPosition][iFEB] = new Int_t*[2]; // 2 LUTs per FEB
 828       for (UInt_t iLUT = 0; iLUT < 2; iLUT++) {
 829       // LUT with 10 input channels 2^10=1024
 830         this->fFEBV0LUTs[iPosition][iFEB][iLUT] = new Int_t[1024];
 831         AliDebug(5, Form("Generate FEBV0LUT[%d][%d][%d]: (0x%x)>%d", iPosition,
 832                          iFEB, iLUT,
 833                          this->fFEBV0Multiplicities[iPosition][iFEB][iLUT][1],
 834                          this->fFEBV0Multiplicities[iPosition][iFEB][iLUT][0]));
 835         for (UInt_t iEntry = 0; iEntry < 1024; iEntry++) {
 836           // Check whether that entry belongs to a multiplicity exceeding the
 837           // threshold
 838           if (this->GetMultiplicity(iEntry &
 839                 this->fFEBV0Multiplicities[iPosition][iFEB][iLUT][1]) >
 840               this->fFEBV0Multiplicities[iPosition][iFEB][iLUT][0]) {
 841             this->fFEBV0LUTs[iPosition][iFEB][iLUT][iEntry] = 1;
 842           }
 843           else {
 844             // initialize LUT (not done before !)
 845             this->fFEBV0LUTs[iPosition][iFEB][iLUT][iEntry] = 0;
 846           }
 847           AliDebug(10, Form("FEBV0LUTs[%d][%d][%d][0x%x]=%d", iPosition, iFEB,
 848                             iLUT, iEntry,
 849                             this->fFEBV0LUTs[iPosition][iFEB][iLUT][iEntry]));
 850         }
 851         AliDebug(5, Form("Generated FEBV0LUTs[%d][%d][%d]", iPosition, iFEB,
 852                          iLUT));
 853       }
 854     }
 855   }
 856
 857   // ControlBoxes (CB-x)
 858   // initialize LUTs
 859   this->fCBLUTs = new Int_t**[3];
 860   for (Int_t iCB = 0; iCB < 3; iCB++) {
 861     this->fCBLUTs[iCB] = new Int_t*[2];
 862     this->fCBLUTs[iCB][0] = 0x0;
 863     this->fCBLUTs[iCB][1] = 0x0;
 864   }
 865
 866   // CB-A (CB = 1 / kA)
 867   this->fCBLUTs[1][0] = this->GenerateLUTbasedOnEq(this->fCBALUTequX, 10, 1);
 868   for (Int_t iEntry = 0; iEntry < 1024; iEntry++) {
 869     AliDebug(10, Form("fCBLUTs[@A][0]=%d", this->fCBLUTs[1][0]));
 870   }
 871   this->fCBLUTs[1][1] = this->GenerateLUTbasedOnEq(this->fCBALUTequY, 10, 1);
 872   for (Int_t iEntry = 0; iEntry < 1024; iEntry++) {
 873     AliDebug(10, Form("fCBLUTs[@A][1]=%d", this->fCBLUTs[1][1]));
 874   }
 875
 876   // CB-C (CB = 2 / kC)
 877   this->fCBLUTs[2][0] = this->GenerateLUTbasedOnEq(this->fCBCLUTequX, 10, 1);
 878   for (Int_t iEntry = 0; iEntry < 1024; iEntry++) {
 879     AliDebug(6, Form("fCBLUTs[@C][0]=%d", this->fCBLUTs[2][0]));
 880   }
 881   this->fCBLUTs[2][1] = this->GenerateLUTbasedOnEq(this->fCBCLUTequY, 10, 1);
 882   for (Int_t iEntry = 0; iEntry < 1024; iEntry++) {
 883     AliDebug(10, Form("fCBLUTs[@C][1]=%d", this->fCBLUTs[2][0]));
 884   }
 885
 886   // CB-B (CB = 0 / kB)
 887   this->fCBLUTs[0][0] = this->GenerateLUTbasedOnEq(this->fCBALUTequX, 12, 1);
 888   for (Int_t iEntry = 0; iEntry < 4096; iEntry++) {
 889     AliDebug(10, Form("fCBLUTs[@B][0]=%d", this->fCBLUTs[0][0]));
 890   }
 891   this->fCBLUTs[0][1] = this->GenerateLUTbasedOnEq(this->fCBALUTequY, 12, 1);
 892
 893   for (Int_t iEntry = 0; iEntry < 4096; iEntry++) {
 894     AliDebug(10, Form("fCBLUTs[@B][1]=%d", this->fCBLUTs[0][1]));
 895   }
 896
 897   AliDebug(5, "LUTs were generated!");
 898   return 0;
 899 }
 900
 901 //______________________________________________________________________________
 902 UInt_t AliTRDptrgParam::GetMultiplicity(UInt_t BitVector) const {
 903   // returns the multiplicity of a given bit vector
 904
 905   UInt_t result = 0;
 906   UInt_t temp = 0x01;
 907   for (UInt_t iBit = 0; iBit < 32; iBit++) {
 908     if (BitVector & temp) {
 909       result++;
 910     }
 911     temp <<= 1;
 912   }
 913
 914   return result;
 915 }
 916
 917 //______________________________________________________________________________
 918 UInt_t AliTRDptrgParam::GetMultiplicity(Int_t BitVector) const {
 919   // returns the multiplicity of a given bit vector
 920
 921   UInt_t result = 0;
 922   UInt_t temp = 0x01;
 923   for (UInt_t iBit = 0; iBit < 32; iBit++) {
 924     if (BitVector & temp) {
 925       result++;
 926     }
 927     temp <<= 1;
 928   }
 929
 930   return result;
 931 }
 932
 933 //______________________________________________________________________________
 934 //
 935 //      Configuration file parsing (helper functions)
 936 //______________________________________________________________________________
 937
 938 //______________________________________________________________________________
 939 void AliTRDptrgParam::PrepareLine(TString line, TString& identifier,
 940                                   TString& value) {
 941   // Prepares a line for parsing
 942   // divide identifier and value
 943
 944   // clear identifier and value
 945   identifier.Clear();
 946   value.Clear();
 947
 948   Int_t iLetter = 0;
 949   while ((line[iLetter] != ' ') && (line[iLetter] != '\t') &&
 950          (line[iLetter] != '#') && (iLetter < line.Length())) {
 951     // read identifier
 952     identifier += line[iLetter];
 953     iLetter++;
 954   }
 955   while (((line[iLetter] == ' ') || (line[iLetter] == '\t')) &&
 956          (iLetter < line.Length()) && (line[iLetter] != '#')) {
 957     // omit whitespaces and tabs in between
 958     iLetter++;
 959   }
 960   while(iLetter < line.Length()) {
 961     // read value or equation and remove white spaces and tabs
 962     //if ((line[iLetter] != ' ') && (line[iLetter] != '\t') &&
 963     //    (line[iLetter] != '#')) {
 964     if (line[iLetter] != '#') {
 965       value += line[iLetter];
 966     }
 967     iLetter++;
 968   }
 969 }
 970
 971 //______________________________________________________________________________
 972 TString AliTRDptrgParam::CleanTString(TString string) {
 973   // Removes white spaces and tabs
 974
 975   TString result;
 976   result.Clear();
 977   for (Int_t iLetter = 0; iLetter < string.Length(); iLetter++) {
 978     if ((string[iLetter] != ' ') && (string[iLetter] != '\t')) {
 979       result += string[iLetter];
 980     }
 981   }
 982   AliDebug(5, Form("Cleaned string: %s", result.Data()));
 983   return result;
 984 }
 985
 986 //______________________________________________________________________________
 987 void AliTRDptrgParam::SplitUpValues(TString value, TObjArray& arr) {
 988   // splits up multiple values into a TObjArray
 989
 990   TString temp;
 991   temp.Clear();
 992   temp.Resize(0);
 993   for (Int_t iLetter = 0; iLetter < value.Length(); iLetter++) {
 994     if ((value[iLetter] != ' ') && (value[iLetter] != '\t')) {
 995       // add another letter
 996       temp += value[iLetter];
 997     }
 998     else {
 999       // seperator found: white space or tabs
1000       if (temp.Length()) {
1001         TObjString* t = new TObjString(temp.Data());
1002         arr.Add(t);
1003         temp.Clear();
1004         temp.Resize(0);
1005       }
1006     }
1007   }
1008   if (temp.Length() != 0) { // TODO
1009     TObjString* t = new TObjString(temp.Data());
1010     arr.Add(t);
1011   }
1012 }
1013
1014 //______________________________________________________________________________
1015 UInt_t AliTRDptrgParam::BinaryTStringToInt(TString number) const {
1016   // converts a binary TString to an integer
1017   UInt_t temp = 0x01;
1018   UInt_t result = 0x0;
1019   for (Int_t i = number.Length() - 1; i >= 0; i--) {
1020     if (number[i] == '1') {
1021       result |= temp;
1022       temp <<= 1;
1023     }
1024     else if (number[i] == '0')  {
1025       temp <<= 1;
1026     }
1027   }
1028   return result;
1029 }
1030
1031 //______________________________________________________________________________
1032 Bool_t AliTRDptrgParam::ParseMultiplicityCondition(TString condition,
1033                                                    UInt_t* threshold,
1034                                                    UInt_t* mask) {
1035   // converts a string formed like "M(1111_1111)>4" to a input mask and a
1036   // multiplicity threshold
1037
1038   // check whether condition is starting with "M(
1039   if ((condition[0] != 'M') || ( condition[1] != '(')) {
1040     return kFALSE;
1041   }
1042
1043   TString maskStr = "";
1044   Int_t iLetter = 0;
1045
1046   // extract input mask
1047   while (condition[iLetter] != ')') {
1048     maskStr += condition[iLetter++];
1049   }
1050   (*mask) = BinaryTStringToInt(maskStr);
1051   if ((*mask) == 0) { // TODO find a better method to detected parser errors
1052     AliDebug(5, Form("Invalid input mask: %s,[%s]", maskStr.Data(),
1053                       condition.Data()));
1054     return kFALSE;
1055   }
1056
1057   // ensure that ')' is followed by a '>'
1058   if (condition[++iLetter] != '>') {
1059     AliDebug(5, Form("multiplicity condition is incorrectly formed: %s",
1060                      condition.Data()));
1061     return kFALSE;
1062   }
1063   iLetter++; // move on to the first digit
1064
1065   TString thresholdStr = "";
1066   // gain threshold string
1067   while (((condition[iLetter] != ' ') || (condition[iLetter] != '\t')) &&
1068          (iLetter < condition.Length())) {
1069     thresholdStr += condition[iLetter++];
1070   }
1071   (*threshold) = thresholdStr.Atoi(); // convert string to integer
1072   AliDebug(5, Form("mask: 0x%x, multiplicity threshold: %d", (*mask),
1073                    (*threshold)));
1074   return kTRUE;
1075 }
1076
1077 //______________________________________________________________________________
1078 Bool_t AliTRDptrgParam::ParseFEB(TString identifier, TString value) {
1079   // Parse FEB configuration
1080
1081   //------------------------------------------
1082   if (identifier.Index("FEB/T0/A/THR") == 0) {
1083     // FEB T0 thresholds at A side
1084
1085     TObjArray arr;
1086     arr.Clear();
1087     SplitUpValues(value, arr);
1088
1089     if (arr.GetEntries() != 12) {
1090       AliError("Wrong FEB T0 Threshold count, it must be 12 channels!");
1091       return kFALSE;
1092     }
1093     for (Int_t iValue = 0; iValue < arr.GetEntries(); iValue++) {
1094       this->fFEBT0Thresholds[0][iValue] =
1095         (dynamic_cast<TObjString*>(arr[iValue])->GetString()).Atoi();
1096       AliDebug(5, Form("FEB/T0/A/THR[%d]=%d", iValue,
1097                        this->fFEBT0Thresholds[0][iValue]));
1098     }
1099     return kTRUE;
1100   }
1101
1102   //-----------------------------------------------
1103   else if (identifier.Index("FEB/T0/C/THR") == 0) {
1104     // FEB T0 thresholds at c side
1105
1106     TObjArray arr;
1107     arr.Clear();
1108     SplitUpValues(value, arr);
1109
1110     if (arr.GetEntries() != 12) {
1111       AliError("Wrong FEB T0 Threshold count, it must be 12 channels!");
1112       return kFALSE;
1113     }
1114     for (Int_t iValue = 0; iValue < arr.GetEntries(); iValue++) {
1115       this->fFEBT0Thresholds[1][iValue] =
1116         (dynamic_cast<TObjString*>(arr[iValue])->GetString()).Atoi();
1117       AliDebug(5, Form("FEB/T0/C/THR[%d]=%d", iValue,
1118                        this->fFEBT0Thresholds[1][iValue]));
1119     }
1120     return kTRUE;
1121   }
1122
1123   //--------------------------------------------------
1124   else if ((identifier.Index("FEB/V0/A0/THR") == 0) ||
1125       (identifier.Index("FEB/V0/A1/THR") == 0) ||
1126       (identifier.Index("FEB/V0/A2/THR") == 0) ||
1127       (identifier.Index("FEB/V0/A3/THR") == 0)) {
1128     // FEB V0 thresholds at a side (cards 0,1,2,3)
1129
1130     TString cardIDstr = identifier(8, 1);
1131     Int_t cardID = cardIDstr.Atoi();
1132
1133     TObjArray arr;
1134     arr.Clear();
1135     SplitUpValues(value, arr);
1136
1137     if (arr.GetEntries() != 8) {
1138       AliError("Wrong FEB V0 Threshold count, it must be 8 channels!");
1139       return kFALSE;
1140     }
1141     for (Int_t iValue = 0; iValue < arr.GetEntries(); iValue++) {
1142       this->fFEBV0Thresholds[0][cardID][iValue] =
1143         (dynamic_cast<TObjString*>(arr[iValue])->GetString()).Atoi();
1144       AliDebug(5, Form("FEB/V0/A%d/THR[%d]=%d", cardID, iValue,
1145                        this->fFEBV0Thresholds[0][cardID][iValue]));
1146     }
1147   }
1148
1149   //--------------------------------------------------
1150   else if ((identifier.Index("FEB/V0/C0/THR") == 0) ||
1151       (identifier.Index("FEB/V0/C1/THR") == 0) ||
1152       (identifier.Index("FEB/V0/C2/THR") == 0) ||
1153       (identifier.Index("FEB/V0/C3/THR") == 0)) {
1154     // FEB V0 thresholds at c side (cards 0,1,2,3)
1155
1156     TString cardIDstr = identifier(8, 1);
1157     Int_t cardID = cardIDstr.Atoi();
1158
1159     TObjArray arr;
1160     arr.Clear();
1161     SplitUpValues(value, arr);
1162
1163     if (arr.GetEntries() != 8) {
1164       AliError("Wrong FEB V0 Threshold count, it must be 8 channels!");
1165       return kFALSE;
1166     }
1167     for (Int_t iValue = 0; iValue < arr.GetEntries(); iValue++) {
1168       this->fFEBV0Thresholds[1][cardID][iValue] =
1169         (dynamic_cast<TObjString*>(arr[iValue])->GetString()).Atoi();
1170       AliDebug(5, Form("FEB/V0/C%d/THR[%d]=%d", cardID, iValue,
1171                        this->fFEBV0Thresholds[1][cardID][iValue]));
1172     }
1173   }
1174
1175   //-----------------------------------------------
1176   else if (identifier.Index("FEB/T0/A/LUT") == 0) {
1177     // FEB T0 look up tables at A side
1178
1179     TString lutIDstr = identifier(13, 1);
1180     Int_t lutID = lutIDstr.Atoi();
1181
1182     UInt_t val = 0;
1183     UInt_t mask = 0;
1184     ParseMultiplicityCondition(value, &val, &mask);
1185     this->fFEBT0Multiplicities[0][lutID][0] = val;
1186     this->fFEBT0Multiplicities[0][lutID][1] = mask;
1187     AliDebug(5, Form("FEBT0Multiplicities[0/A][%d][val] = %d", lutID, val));
1188     AliDebug(5, Form("FEBT0Multiplicities[0/A][%d][mask] = %d", lutID, mask));
1189
1190     return kTRUE;
1191   }
1192
1193   //-----------------------------------------------
1194   else if (identifier.Index("FEB/T0/C/LUT") == 0) {
1195     // FEB T0 look up tables at C side
1196
1197     TString lutIDstr = identifier(13, 1);
1198     Int_t lutID = lutIDstr.Atoi();
1199
1200     UInt_t val = 0;
1201     UInt_t mask = 0;
1202     ParseMultiplicityCondition(value, &val, &mask);
1203     this->fFEBT0Multiplicities[1][lutID][0] = val;
1204     this->fFEBT0Multiplicities[1][lutID][1] = mask;
1205     AliDebug(5, Form("FEBT0Multiplicities[1/C][%d][val] = %d", lutID, val));
1206     AliDebug(5, Form("FEBT0Multiplicities[1/C][%d][mask] = %d", lutID, mask));
1207
1208     return kTRUE;
1209   }
1210
1211   //--------------------------------------------------
1212   else if ((identifier.Index("FEB/V0/A0/LUT") == 0) ||
1213            (identifier.Index("FEB/V0/A1/LUT") == 0) ||
1214            (identifier.Index("FEB/V0/A2/LUT") == 0) ||
1215            (identifier.Index("FEB/V0/A3/LUT") == 0)) {
1216     // FEB V0 look up tables at A side
1217
1218     TString cardIDstr = identifier(8, 1);
1219     Int_t cardID = cardIDstr.Atoi();
1220
1221     TString lutIDstr = identifier(14, 1);
1222     Int_t lutID = lutIDstr.Atoi();
1223
1224     UInt_t val = 0;
1225     UInt_t mask = 0;
1226     ParseMultiplicityCondition(value, &val, &mask);
1227     this->fFEBV0Multiplicities[0][cardID][lutID][0] = val;
1228     this->fFEBV0Multiplicities[0][cardID][lutID][1] = mask;
1229     AliDebug(5, Form("FEBV0Multiplicities[0/A][%d][%d][val] = %d", cardID,
1230                      lutID, val));
1231     AliDebug(5, Form("FEBV0Multiplicities[0/A][%d][%d][mask] = %d", cardID,
1232                      lutID, mask));
1233
1234     return kTRUE;
1235   }
1236
1237   //--------------------------------------------------
1238   else if ((identifier.Index("FEB/V0/C0/LUT") == 0) ||
1239            (identifier.Index("FEB/V0/C1/LUT") == 0) ||
1240            (identifier.Index("FEB/V0/C2/LUT") == 0) ||
1241            (identifier.Index("FEB/V0/C3/LUT") == 0)) {
1242     // FEB V0 look up tables at C side
1243
1244     TString cardIDstr = identifier(8, 1);
1245     Int_t cardID = cardIDstr.Atoi();
1246
1247     TString lutIDstr = identifier(14, 1);
1248     Int_t lutID = lutIDstr.Atoi();
1249
1250     UInt_t val = 0;
1251     UInt_t mask = 0;
1252     ParseMultiplicityCondition(value, &val, &mask);
1253     this->fFEBV0Multiplicities[1][cardID][lutID][0] = val;
1254     this->fFEBV0Multiplicities[1][cardID][lutID][1] = mask;
1255     AliDebug(5, Form("FEBV0Multiplicities[1/C][%d][%d][val] = %d", cardID,
1256                      lutID, val));
1257     AliDebug(5, Form("FEBV0Multiplicities[1/C][%d][%d][mask] = %d", cardID,
1258                      lutID, mask));
1259
1260     return kTRUE;
1261   }
1262   return kTRUE;
1263 }
1264
1265 //______________________________________________________________________________
1266 Bool_t AliTRDptrgParam::ParseCBAC(TString identifier, TString value) {
1267   // Parse CB-A and CB-C configuration
1268
1269   if (identifier.Index("CBA/LUT/") == 0) {
1270     // parse CB-A's logical equations
1271
1272     TString eqIDstr = identifier(8, 1);
1273     Int_t eqID = eqIDstr.Atoi();
1274
1275     if (eqID == 0) {
1276       this->fCBALUTequX = this->CleanTString(value);
1277       AliDebug(5, Form("fCBALUTequX=%s", this->fCBALUTequX.Data()));
1278     }
1279     else if(eqID == 1) {
1280       this->fCBALUTequY= this->CleanTString(value);
1281       AliDebug(5, Form("fCBALUTequY=%s", this->fCBALUTequY.Data()));
1282     }
1283     return kTRUE;
1284   }
1285
1286   else if (identifier.Index("CBC/LUT/") == 0) {
1287     // parse CB-C's logical equations
1288
1289     TString eqIDstr = identifier(8, 1);
1290     Int_t eqID = eqIDstr.Atoi();
1291
1292     if (eqID == 0) {
1293       this->fCBCLUTequX = this->CleanTString(value);
1294       AliDebug(5, Form("fCBCLUTequX=%s", this->fCBCLUTequX.Data()));
1295     }
1296     else if(eqID == 1) {
1297       this->fCBCLUTequY= this->CleanTString(value);
1298       AliDebug(5, Form("fCBCLUTequY=%s", this->fCBCLUTequY.Data()));
1299     }
1300   }
1301
1302   return kTRUE;
1303 }
1304
1305 //______________________________________________________________________________
1306 Bool_t AliTRDptrgParam::ParseCBB(TString identifier, TString value) {
1307   // Parse CBB configuration
1308
1309   if (identifier.Index("CBB/LUT/") == 0) {
1310     // parse CB-B's logical equations
1311
1312     TString eqIDstr = identifier(8, 1);
1313     Int_t eqID = eqIDstr.Atoi();
1314
1315     if (eqID == 0) {
1316       this->fCBBLUTequX = this->CleanTString(value);
1317       AliDebug(5, Form("fCBBLUTequX=%s", this->fCBBLUTequX.Data()));
1318     }
1319     else if(eqID == 1) {
1320       this->fCBBLUTequY= this->CleanTString(value);
1321       AliDebug(5, Form("fCBBLUTequY=%s", this->fCBBLUTequY.Data()));
1322     }
1323     return kTRUE;
1324   }
1325
1326   // PT masks
1327   else if (identifier.Index("CBB/PT/MASK/CB-A_0") == 0) { // CB-A_0
1328     if (value.Index("YES") == 0) {
1329       this->fPTmasks.fCBA[0] = kTRUE;
1330     }
1331     else {
1332       this->fPTmasks.fCBA[0] = kFALSE;
1333     }
1334     AliDebug(5, Form("CBB/PT/MASK/CB-A_0=%d", this->fPTmasks.fCBA[0]));
1335     return kTRUE;
1336   }
1337   else if (identifier.Index("CBB/PT/MASK/CB-A_1") == 0) { // CB-A_1
1338     if (value.Index("YES") == 0) {
1339       this->fPTmasks.fCBA[1] = kTRUE;
1340     }
1341     else {
1342       this->fPTmasks.fCBA[1] = kFALSE;
1343     }
1344     AliDebug(5, Form("CBB/PT/MASK/CB-A_1=%d", this->fPTmasks.fCBA[1]));
1345     return kTRUE;
1346   }
1347   else if (identifier.Index("CBB/PT/MASK/CB-C_0") == 0) { // CB-C_0
1348     if (value.Index("YES") == 0) {
1349       this->fPTmasks.fCBC[0] = kTRUE;
1350     }
1351     else {
1352       this->fPTmasks.fCBC[0] = kFALSE;
1353     }
1354     AliDebug(5, Form("CBB/PT/MASK/CB-C_0=%d",this->fPTmasks.fCBC[0]));
1355     return kTRUE;
1356   }
1357   else if (identifier.Index("CBB/PT/MASK/CB-C_1") == 0) { // CB-C_1
1358     if (value.Index("YES") == 0) {
1359       this->fPTmasks.fCBC[1] = kTRUE;
1360     }
1361     else {
1362       this->fPTmasks.fCBC[1] = kFALSE;
1363     }
1364     AliDebug(5, Form("CBB/PT/MASK/CB-C_1=%d", this->fPTmasks.fCBC[1]));
1365     return kTRUE;
1366   }
1367   else if (identifier.Index("CBB/PT/MASK/CB-B_0") == 0) { // CB-B_0
1368     if (value.Index("YES") == 0) {
1369       this->fPTmasks.fLUTs[0] = kTRUE;
1370     }
1371     else {
1372       this->fPTmasks.fLUTs[0] = kFALSE;
1373     }
1374     AliDebug(5, Form("CBB/PT/MASK/CB-B_0=%d",this->fPTmasks.fLUTs[0]));
1375     return kTRUE;
1376   }
1377   else if (identifier.Index("CBB/PT/MASK/CB-B_1") == 0) { // CB-B_1
1378     if (value.Index("YES") == 0) {
1379       this->fPTmasks.fLUTs[1] = kTRUE;
1380     }
1381     else {
1382       this->fPTmasks.fLUTs[1] = kFALSE;
1383     }
1384     AliDebug(5, Form("CBB/PT/MASK/CB-B_1/=%d", this->fPTmasks.fLUTs[1]));
1385     return kTRUE;
1386   }
1387   else if (identifier.Index("BB/PT/MASK/TLMU_") == 0) {
1388     TString indexStr = identifier(16, 1);
1389     Int_t index = indexStr.Atoi();
1390     if (value.Index("YES") == 0) {
1391       this->fPTmasks.fTLMU[index] = kTRUE;
1392     }
1393     else {
1394       this->fPTmasks.fTLMU[index] = kFALSE;
1395     }
1396     AliDebug(5, Form("CBB/PT/MASK/TLMU_%d=%d", index,
1397                      this->fPTmasks.fTLMU[index]));
1398     return kTRUE;
1399   }
1400   return kTRUE;
1401 }
1402
1403 //______________________________________________________________________________
1404 Bool_t AliTRDptrgParam::ParseTLMU(TString identifier, TString value) {
1405   // Parse TLMU configuration
1406
1407   if (identifier.Index("TLMU/IMASK/SEC") == 0) {
1408     // TLMU input masks
1409     TString indexStr = identifier(14,2);
1410     Int_t index = indexStr.Atoi();
1411     if ((index < 0) || (index > 17)) {
1412       AliDebug(5, "Wrong section index in TLMU input mask");
1413       return kFALSE;
1414     }
1415     this->fTLMUInputMask[index] = BinaryTStringToInt(value);
1416     AliDebug(5, Form("%d %x\n", index, this->fTLMUInputMask[index]));
1417     return kTRUE;
1418   }
1419
1420   //-----------------------------------------------
1421   else if (identifier.Index("TLMU/CMATRIX") == 0) {
1422     // TLMU coincidence matrices
1423
1424     // matrix index
1425     TString matrixIndexStr = identifier(12,1);
1426     Int_t matrixIndex = matrixIndexStr.Atoi();
1427     // entry index
1428     TString indexStr = identifier(17,2);
1429     Int_t index = indexStr.Atoi();
1430     this->fTLMUcmatrices[matrixIndex][index] = BinaryTStringToInt(value);
1431     AliDebug(5, Form("%d 0x%x\n", matrixIndex,
1432                      this->fTLMUcmatrices[matrixIndex][index]));
1433     return kTRUE;
1434   }
1435
1436   //---------------------------------------------
1437   else if (identifier.Index("TLMU/MCNTR") == 0) {
1438     // TLMU multiplicity counter setup
1439
1440     TString indexStr = identifier(10,1);
1441     Int_t index = indexStr.Atoi();
1442     TObjArray arr;
1443
1444     SplitUpValues(value, arr);
1445
1446     TString t0 = (dynamic_cast<TObjString*>(arr[0]))->GetString();
1447     TString t1 = (dynamic_cast<TObjString*>(arr[1]))->GetString();
1448
1449     this->fTLMUmultiplicity[index][0] = t0.Atoi();
1450     this->fTLMUmultiplicity[index][1] = t1.Atoi();
1451
1452     AliDebug(5, Form("%d: %d  %d", index, this->fTLMUmultiplicity[index][0],
1453                      this->fTLMUmultiplicity[index][1]));
1454
1455     return kTRUE;
1456   }
1457
1458   //----------------------------------------------
1459   else if (identifier.Index("TLMU/OUTMUX") == 0) {
1460     // TLMU output signal assignment
1461     TObjArray arr;
1462     SplitUpValues(value, arr);
1463
1464     if (arr.GetEntries() > 8) {
1465       AliError("Too many TLMU output signals assigned");
1466       return kFALSE;
1467     }
1468
1469     for (Int_t iEntry = 0; iEntry < arr.GetEntries(); iEntry++) {
1470       TString t = (dynamic_cast<TObjString*>(arr[iEntry]))->GetString();
1471
1472       TString indexStr = t(2,1);
1473       if (t.Index("CM") == 0) { // coincidence matrix
1474         this->fTLMUoutput[iEntry][0] = indexStr.Atoi();
1475       }
1476       else if (t.Index("MC") == 0) { // multiplicity
1477         this->fTLMUoutput[iEntry][1] = indexStr.Atoi();
1478       }
1479       AliDebug(5, Form("TLMU output: cm = %d, mc = %d",
1480                        this->fTLMUoutput[iEntry][0],
1481                        this->fTLMUoutput[iEntry][1]));
1482     }
1483     return kTRUE;
1484   }
1485   return kTRUE;
1486 }
1487
1488 //______________________________________________________________________________
1489 //
1490 //       Logical Equation to LUT processing (helper functions)
1491 //______________________________________________________________________________
1492
1493 //______________________________________________________________________________
1494 Int_t AliTRDptrgParam::LookUp(TString* const identifier) const {
1495   // Transforms identifier into look up table address bit
1496   //
1497   // this function has to be extended/changed when different identifiers for
1498   // other equations and destination LUTs should be used
1499
1500   if (identifier->CompareTo("T0_0", TString::kIgnoreCase) == 0)
1501     return 0x001;
1502   else if (identifier->CompareTo("T0_1", TString::kIgnoreCase) == 0)
1503     return 0x002;
1504   else if (identifier->CompareTo("V0-0_0", TString::kIgnoreCase) == 0)
1505     return 0x004;
1506   else if (identifier->CompareTo("V0-0_1", TString::kIgnoreCase) == 0)
1507     return 0x008;
1508   else if (identifier->CompareTo("V0-1_0", TString::kIgnoreCase) == 0)
1509     return 0x010;
1510   else if (identifier->CompareTo("V0-1_1", TString::kIgnoreCase) == 0)
1511     return 0x020;
1512   else if (identifier->CompareTo("V0-2_0", TString::kIgnoreCase) == 0)
1513     return 0x040;
1514   else if (identifier->CompareTo("V0-2_1", TString::kIgnoreCase) == 0)
1515     return 0x080;
1516   else if (identifier->CompareTo("V0-3_0", TString::kIgnoreCase) == 0)
1517     return 0x100;
1518   else if (identifier->CompareTo("V0-3_1", TString::kIgnoreCase) == 0)
1519     return 0x200;
1520   else if (identifier->CompareTo("CB-A_0", TString::kIgnoreCase) == 0)
1521     return 0x001;
1522   else if (identifier->CompareTo("CB-A_1", TString::kIgnoreCase) == 0)
1523     return 0x002;
1524   else if (identifier->CompareTo("CB-C_0", TString::kIgnoreCase) == 0)
1525     return 0x004;
1526   else if (identifier->CompareTo("CB-C_1", TString::kIgnoreCase) == 0)
1527     return 0x008;
1528   else if (identifier->CompareTo("TLMU_0", TString::kIgnoreCase) == 0)
1529     return 0x010;
1530   else if (identifier->CompareTo("TLMU_1", TString::kIgnoreCase) == 0)
1531     return 0x020;
1532   else if (identifier->CompareTo("TLMU_2", TString::kIgnoreCase) == 0)
1533     return 0x040;
1534   else if (identifier->CompareTo("TLMU_3", TString::kIgnoreCase) == 0)
1535     return 0x080;
1536   else if (identifier->CompareTo("TLMU_4", TString::kIgnoreCase) == 0)
1537     return 0x100;
1538   else if (identifier->CompareTo("TLMU_5", TString::kIgnoreCase) == 0)
1539     return 0x200;
1540   else if (identifier->CompareTo("TLMU_6", TString::kIgnoreCase) == 0)
1541     return 0x400;
1542   else if (identifier->CompareTo("TLMU_7", TString::kIgnoreCase) == 0)
1543     return 0x100;
1544   else return 0x0; // Error
1545 }
1546
1547 //______________________________________________________________________________
1548 void AliTRDptrgParam::MergeResults(TArrayI*& partResult1, TArrayI*& partResult2,
1549                                    TArrayI*& results,
1550                                    TArrayI*& signalsInvolved1,
1551                                    TArrayI*& signalsInvolved2,
1552                                    TArrayI*& signalsInvolved,
1553                                    Bool_t useOR) {
1554   // merges result and signal involved arrays
1555   // uses logical OR (or=kTRUE) and AND (or==kFALSE) as merging function
1556
1557   // check whether input data is valid
1558   if ((partResult1 == 0x0) || (partResult2 == 0x0) ||
1559       (signalsInvolved1 == 0x0) || (signalsInvolved2 == 0x0)) {
1560     AliError("fatal logical equation processing error!");
1561   }
1562
1563   // allocate results and signalsInvolved
1564   results = new TArrayI(0);
1565   signalsInvolved = new TArrayI(0);
1566
1567   // merge arrays (necessary for OR and AND)
1568   for (Int_t i = 0; i < partResult1->GetSize(); i++) {
1569     for (Int_t j = 0; j < partResult2->GetSize(); j++) {
1570       results->Set(results->GetSize() + 1); // increment size
1571       (*results)[results->GetSize() - 1] =  // add combination
1572         (*partResult1)[i] | (*partResult2)[j];
1573
1574       signalsInvolved->Set(signalsInvolved->GetSize() + 1);
1575       (*signalsInvolved)[signalsInvolved->GetSize() - 1] =
1576          (*signalsInvolved1)[i] | (*signalsInvolved2)[j];
1577     }
1578   }
1579
1580   if (useOR) { // only necessary for OR
1581     // add partResult1
1582     for (Int_t i = 0; i < partResult1->GetSize(); i++) {
1583       results->Set(results->GetSize() + 1);
1584       (*results)[results->GetSize() - 1] = (*partResult1)[i];
1585
1586       signalsInvolved->Set(signalsInvolved->GetSize() + 1);
1587       (*signalsInvolved)[signalsInvolved->GetSize()-1] = (*signalsInvolved1)[i];
1588     }
1589     // add partResult2
1590     for (Int_t i = 0; i < partResult2->GetSize(); i++) {
1591       results->Set(results->GetSize() + 1);
1592       (*results)[results->GetSize() - 1] = (*partResult2)[i];
1593
1594       signalsInvolved->Set(signalsInvolved->GetSize() + 1);
1595       (*signalsInvolved)[signalsInvolved->GetSize()-1] = (*signalsInvolved2)[i];
1596     }
1597   }
1598
1599   // debug output
1600   AliDebug(5, "merging results: ");
1601   for (Int_t i = 0; i < results->GetSize(); i++) {
1602     AliDebug(5, Form("0x%x 0x%x", (*results)[i], (*signalsInvolved)[i]));
1603   }
1604
1605   // free memory
1606   delete partResult1;
1607   partResult1 = 0x0;
1608   delete partResult2;
1609   partResult2 = 0x0;
1610 }
1611
1612 //______________________________________________________________________________
1613 void AliTRDptrgParam::ConvertLogicalEqToBitVectors(TString eq,
1614                                                    TArrayI*& results,
1615                                                    TArrayI*& signalsInvolved) {
1616   // converts a logical equation to a LUT
1617   //
1618   // input string must not contain white spaces or tabs
1619   // only identifiers, ||, &&, (, ) and ! are allowed
1620   //
1621   // neglected signals are assumed to be zero in this function
1622   // this problem is solved by "void CheckSignalsInvolved(...)"
1623
1624   AliDebug(5, Form("eq: %s", eq.Data()));
1625
1626   // temporary variables used before/while merging
1627   TArrayI* partResult1 = 0x0;
1628   TArrayI* partResult2 = 0x0;
1629   TArrayI* partResult3 = 0x0;
1630   TArrayI* partResult4 = 0x0;
1631   TArrayI* signalsInvolved1 = 0x0;
1632   TArrayI* signalsInvolved2 = 0x0;
1633   TArrayI* signalsInvolved3 = 0x0;
1634   TArrayI* signalsInvolved4 = 0x0;
1635
1636   Int_t iChar = 0; // counter variable
1637
1638   // variables needed for correct operator order (&& before ||!)
1639   Int_t foundORbefore = -1; // found an || in that string (-1 = not found)
1640   Int_t foundAND = -1; // found an &&
1641   Int_t foundORafter = -1; // found a second OR after &&
1642
1643   // variables needed for correct bracket processing
1644   Int_t enteredBrackets = 0; // indicates in which bracket layer the parser is
1645   Int_t bracketLevelAtZero = -1; // when enteredBrackets = 0 was reached first
1646   // after it ascended
1647
1648   while ((iChar < eq.Length())) { //--------------------------------------------
1649     // walk through string
1650
1651     // operators ---------------------------------------------------------------
1652     if ((enteredBrackets == 0 ) && (eq[iChar] != '(') && (eq[iChar] != ')'))  {
1653       // '|'
1654       if (eq[iChar] == '|') {
1655         if (eq[iChar + 1] == '|') { // ||
1656           iChar++; // jump to the next charakter
1657           if (foundAND == -1) {
1658             foundORbefore = iChar;
1659           }
1660           else if ((foundORafter == -1) && (foundAND != -1)) {
1661             foundORafter = iChar;
1662           }
1663         }
1664         else { // bit-wise and not supported
1665           AliError(Form("LogicalEquation incorrect: %s", eq.Data()));
1666           AliError("bit-wise AND (&) not supported for now");
1667           return;
1668         }
1669       }
1670       // '&'
1671       else if (eq[iChar] == '&') {
1672         if (eq[iChar] == '&') { // ||
1673           iChar++; // jump to the next charakter
1674           if (foundAND == -1) {
1675             foundAND = iChar;
1676           }
1677         }
1678         else { // bit-wise or not supported
1679           AliError(Form("LogicalEquation incorrect: %s", eq.Data()));
1680           AliError("bit-wise OR (|) not supported for now");
1681           return;
1682         }
1683       }
1684     }
1685     // brackets ----------------------------------------------------------------
1686     // '('
1687     if (eq[iChar] == '(') {
1688       enteredBrackets++;
1689     }
1690     // ')'
1691     else if (eq[iChar] == ')') {
1692       enteredBrackets--;
1693       if (enteredBrackets < 0) {
1694         AliError(Form("LogicalEquation incorrect: %s", eq.Data()));
1695         AliError("Too many )s");
1696       }
1697       if ((enteredBrackets == 0) && (bracketLevelAtZero == -1) &&
1698           (foundAND == -1) && (foundORbefore == -1)) {
1699         // needed to detected equations encapsulated in brackets: (...)
1700         bracketLevelAtZero = iChar;
1701       }
1702     }
1703     iChar++; // go on to the next letter/char
1704   } //--------------------------------------------------------------------------
1705
1706   if (bracketLevelAtZero == (eq.Length() - 1)) { // strip ( ) and process again
1707     ConvertLogicalEqToBitVectors(eq(1, eq.Length() -2), results,
1708                                  signalsInvolved);
1709     return;
1710   }
1711   else if (foundAND == -1) { // no AND
1712     if (foundORbefore != -1) { // only OR / || found and no AND
1713       ConvertLogicalEqToBitVectors(eq(0, foundORbefore-1), partResult1,
1714                                    signalsInvolved1);
1715       ConvertLogicalEqToBitVectors(eq(foundORbefore+1,
1716                                       eq.Length()-foundORbefore-1),
1717                                    partResult2, signalsInvolved2);
1718
1719       MergeResults(partResult1, partResult2, results, signalsInvolved1,
1720                    signalsInvolved2, signalsInvolved, kTRUE);
1721       return;
1722     }
1723     else { // only identifier remained!
1724       results = new TArrayI(1);
1725       signalsInvolved = new TArrayI(1);
1726       if (eq[0] != '!') { // identifier without negation
1727         (*results)[0] = LookUp(&eq);
1728         (*signalsInvolved)[0] = (*results)[0];
1729       }
1730       else { // identifier with negation
1731         (*results)[0] = 0;
1732         TString eqNegated = eq(1, eq.Length()-1);
1733         (*signalsInvolved)[0] = LookUp(&eqNegated);
1734       }
1735       return;
1736     }
1737   }
1738   // found single or multiple AND / &&
1739   else if ((foundORafter != -1) && (foundORbefore != -1)) {
1740     // found: ...||...&&...||...
1741     ConvertLogicalEqToBitVectors(eq(0, foundORbefore-1), partResult1,
1742                                  signalsInvolved1);
1743     ConvertLogicalEqToBitVectors(eq(foundORbefore+1,
1744                                     foundORafter-foundORbefore-2),
1745                                  partResult2, signalsInvolved2);
1746     ConvertLogicalEqToBitVectors(eq(foundORafter+1, eq.Length()-foundORafter-1),
1747                                  partResult3, signalsInvolved3);
1748
1749     // merge: 4 = 1 || 2
1750     MergeResults(partResult1, partResult2, partResult4, signalsInvolved1,
1751                  signalsInvolved2, signalsInvolved4, kTRUE);
1752     // merge results = 3 || 4
1753     MergeResults(partResult3, partResult4, results, signalsInvolved3,
1754                  signalsInvolved4, signalsInvolved, kTRUE);
1755     return;
1756   }
1757   else if (foundORbefore != -1) {
1758     // found ...||...&&...
1759     ConvertLogicalEqToBitVectors(eq(0, foundORbefore - 1), partResult1,
1760                                  signalsInvolved1);
1761     ConvertLogicalEqToBitVectors(eq(foundORbefore+1,
1762                                     eq.Length()-foundORbefore-1),
1763                                  partResult2, signalsInvolved2);
1764
1765     MergeResults(partResult1, partResult2, results, signalsInvolved1,
1766                  signalsInvolved2, signalsInvolved, kTRUE);
1767     return;
1768   }
1769   else if (foundORafter != -1) {
1770     // found  ...&&...||...
1771     ConvertLogicalEqToBitVectors(eq(0, foundORafter - 1), partResult1,
1772                                  signalsInvolved1);
1773     ConvertLogicalEqToBitVectors(eq(foundORafter+1,
1774                                     eq.Length()-foundORafter-1),
1775                                  partResult2, signalsInvolved2);
1776
1777     MergeResults(partResult1, partResult2, results, signalsInvolved1,
1778                  signalsInvolved2, signalsInvolved, kTRUE);
1779     return;
1780   }
1781   else /* if (foundAND != -1)*/ { // found ...&&...
1782     ConvertLogicalEqToBitVectors(eq(0, foundAND-1), partResult1,
1783                                  signalsInvolved1);
1784     ConvertLogicalEqToBitVectors(eq(foundAND+1, eq.Length()-foundAND-1),
1785                                  partResult2, signalsInvolved2);
1786
1787     MergeResults(partResult1, partResult2, results, signalsInvolved1,
1788                  signalsInvolved2, signalsInvolved, kFALSE);
1789     return;
1790   }
1791
1792   AliError("Logical equation parser error!");
1793   return;
1794 }
1795
1796 //______________________________________________________________________________
1797 void AliTRDptrgParam::CheckSignalsInvolved(TArrayI*& results,
1798                                            TArrayI*& signalsInvolved,
1799                                            Int_t inputWidth) {
1800   // checks whether all input signals are taken into account
1801   //
1802   // this function is needed to be able to write equations which contain not all
1803   // possible signals and which are not mentioned in the equation do not effect
1804   // the result
1805   // X=B&&C=(A||!A)&&B&&C
1806
1807   // this routine is quite inefficient but working O((2^inputWidth)^3)
1808
1809   // generate mask:
1810   Int_t temp = 0x1;
1811   Int_t mask = 0x0;
1812   for (Int_t iSignal = 0; iSignal < inputWidth; iSignal++) {
1813     mask |= temp;
1814     temp <<= 1; // move temp to the next bit
1815   }
1816
1817   for (Int_t iResult = 0; iResult < results->GetSize(); iResult++) {
1818     // tricky: size of results increases while loop is iterating
1819     // that is needed to generate all valid input signal combinations
1820     if (mask != (*signalsInvolved)[iResult]) {
1821       // not all input signals are taken into account
1822       Int_t inputSignal = 0x1;
1823       for (Int_t iSignal = 0; iSignal < inputWidth; iSignal++) {
1824         if (!(inputSignal & (*signalsInvolved)[iResult])) {
1825           Int_t newInvolvedSignalCombination =
1826             (*signalsInvolved)[iResult] | inputSignal;
1827           Int_t newResult = inputSignal | (*results)[iResult];
1828           Bool_t signalCombinationAlreadyEnlisted = kFALSE;
1829           for (Int_t iEntry = 0; iEntry < signalsInvolved->GetSize(); iEntry++){
1830             // this loop is needed to reduce the amount of equal entries in
1831             // signalsInvolved
1832             // maybe a table with all possible input values could reduce the
1833             // computional effort, but this would consume a lot of ram
1834             if ((signalsInvolved->At(iEntry) == newInvolvedSignalCombination) &&
1835                 (results->At(iEntry) == newResult)) {
1836               signalCombinationAlreadyEnlisted = kTRUE;
1837               break;
1838             }
1839           }
1840           if (!signalCombinationAlreadyEnlisted) {
1841             results->Set(results->GetSize() + 1);
1842             (*results)[results->GetSize() - 1] = inputSignal |
1843                                                  (*results)[iResult];
1844             // add variant with active bit, variant with inactive signal
1845             // is already containt in the results array
1846
1847             // update signalsInvolved:
1848             signalsInvolved->Set(signalsInvolved->GetSize() + 1);
1849             (*signalsInvolved)[signalsInvolved->GetSize() - 1] =
1850               (*signalsInvolved)[iResult] | inputSignal;
1851           }
1852         }
1853         inputSignal <<= 1; // move temp to the next input signal
1854       }
1855     }
1856   }
1857   return;
1858 }
1859
1860 //______________________________________________________________________________
1861 Int_t* AliTRDptrgParam::GenerateLUTbasedOnEq(TString eq, Int_t inputWidth,
1862                                              Int_t initValue) {
1863   // Processes the conversion of a logical equation to a look up table
1864
1865   TArrayI* results = 0x0;
1866   TArrayI* signalsInvolved = 0x0;
1867
1868   ConvertLogicalEqToBitVectors(eq, results, signalsInvolved);
1869   // generate bit vectors
1870
1871   CheckSignalsInvolved(results, signalsInvolved, inputWidth);
1872   // add bit vectors for signals which are not taken into account
1873
1874   Int_t lutSize =  0x1 << inputWidth; // 2^inputwidth elements
1875   Int_t* resultingLUT = new Int_t[lutSize]; // create LUT
1876   for (Int_t iLUTentry = 0; iLUTentry < lutSize; iLUTentry++) { // init LUT
1877     resultingLUT[iLUTentry] = 0;
1878   }
1879   for (Int_t iEntry = 0; iEntry < results->GetSize(); iEntry++) {
1880     resultingLUT[(*results)[iEntry]] = initValue;
1881   }
1882
1883   if (results != 0x0) {
1884     delete results;
1885     results = 0x0;
1886   }
1887   if (signalsInvolved != 0x0) {
1888     delete signalsInvolved;
1889     signalsInvolved = 0x0;
1890   }
1891
1892   return resultingLUT;
1893 }
1894
1895 //______________________________________________________________________________
1896 //___ GETTER FUNCTIONS__________________________________________________________
1897 //______________________________________________________________________________
1898 UInt_t* AliTRDptrgParam::GetFEBT0Thresholds(AliTRDptrgFEBPosition_t FEBposition)
1899   const
1900 {
1901   // get T0 FEB Thresholds
1902   return this->fFEBT0Thresholds[FEBposition - 1];
1903   // 0 kB, 1= kA, 2, kC => -1 because T0FEBs are only in position kA and kC
1904 }
1905
1906 //_____________________________________________________________________________
1907 Int_t* AliTRDptrgParam::GetFEBT0LUT(AliTRDptrgFEBPosition_t FEBposition,
1908                                     Int_t iLUT) {
1909   // get T0 FEB LUTs
1910   if (this->fFEBT0LUTs == 0x0) {
1911     this->GenerateLUTs();
1912   }
1913   return this->fFEBT0LUTs[FEBposition - 1][iLUT];
1914   // 0 kB, 1= kA, 2, kC => -1 because T0FEBs are only in position kA and kC
1915 }
1916
1917 //______________________________________________________________________________
1918 UInt_t* AliTRDptrgParam::GetFEBV0Thresholds(AliTRDptrgFEBPosition_t FEBposition,
1919                                            Int_t iCard) const {
1920   // get V0 FEB Thresholds
1921   return this->fFEBV0Thresholds[FEBposition - 1][iCard];
1922   // 0 kB, 1= kA, 2, kC => -1 because T0FEBs are only in position kA and kC
1923 }
1924
1925 //______________________________________________________________________________
1926 Int_t* AliTRDptrgParam::GetFEBV0LUT(AliTRDptrgFEBPosition_t FEBposition,
1927                                     Int_t iCard, Int_t iLUT) {
1928   // get V0 FEB LUTs
1929   if (this->fFEBV0LUTs == 0x0) {
1930     this->GenerateLUTs();
1931   }
1932   return this->fFEBV0LUTs[FEBposition - 1][iCard][iLUT];
1933   // 0 kB, 1= kA, 2, kC => -1 because T0FEBs are only in position kA and kC
1934 }
1935
1936 //______________________________________________________________________________
1937 Int_t* AliTRDptrgParam::GetCBLUT(UInt_t iCB, Int_t LUTid) {
1938   // return control box LUT
1939   // iCB: 0 = B, 1 = A, 2 = C
1940   if (this->fCBLUTs == 0x0) {
1941     this->GenerateLUTs();
1942   }
1943   return this->fCBLUTs[iCB][LUTid];
1944 }
1945