TOF/AliTOFTrigger.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 //       Class performing TOF Trigger
  21 //       Cosmic_Multi_muon: Cosmic Multi-Muonic Event Trigger (L0)
  22 //       ppMB: p-p Minimum Bias Event Trigger (L0)
  23 //       UltraPer_Coll: Ultra-Peripheral Collision Event Trigger (L0)
  24 //       High_Mult: High Multiplicity Event Trigger (L0)
  25 //       Jet: Events with Jet Topology Trigger (L1)
  26 //
  27 //       A.Silenzi: added CTTM map,
  28 //                        method to fill LTM matrix from raw data,
  29 //                        method to retrieve the TOF pre-trigger for TRD detector
  30 //
  31 //
  32 /////////////////////////////////////////////////////////////////////
  33
  34 #include <TClonesArray.h>
  35 #include <TTree.h>
  36 #include <TMath.h>
  37
  38 #include "AliLoader.h"
  39 #include "AliLog.h"
  40 #include "AliRunLoader.h"
  41 #include "AliRun.h"
  42 #include "AliTriggerInput.h"
  43 #include "AliRawReader.h"
  44
  45 #include "AliTOFRawStream.h"
  46 #include "AliTOFrawData.h"
  47 #include "AliTOFdigit.h"
  48 #include "AliTOFGeometry.h"
  49 #include "AliTOFTrigger.h"
  50 #include "AliTOFTriggerMask.h"
  51
  52 #include "AliCDBManager.h"
  53 #include "AliCDBEntry.h"
  54
  55
  56 extern AliRun* gAlice;
  57
  58 AliTOFGeometry* AliTOFTrigger::fgTofGeo = NULL; // TOF geometry needed to get the minimial arrival time for each channel
  59
  60 //-------------------------------------------------------------------------
  61 ClassImp(AliTOFTrigger)
  62
  63 //----------------------------------------------------------------------
  64   AliTOFTrigger::AliTOFTrigger() :
  65     AliTriggerDetector(),
  66     fHighMultTh(1000),
  67     fppMBTh(4),//4:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
  68     fMultiMuonTh(4),
  69     fUPTh(2),
  70     fdeltaminpsi(150), //150
  71     fdeltamaxpsi(170), //170
  72     fdeltaminro(70),
  73     fdeltamaxro(110),
  74     fstripWindow(2),
  75     fSel1(0),
  76     fSel2(0),
  77     fSel3(0),
  78     fSel4(0),
  79     fNCrateOn(0),
  80     fNMaxipadOn(0),
  81     fNMaxipadOnAll(0),
  82     fTOFTrigMask(0),
  83     fStartTimeHit(0.0),
  84     fTimeWidthTrigger(25.0)
  85
  86 {
  87   //main ctor
  88   for (Int_t i=0;i<kNCTTM;i++) fLTMarray[i] = kFALSE;
  89
  90   for (Int_t i=0;i<kNLTM;i++){
  91
  92     for (Int_t j=0;j<kNLTMchannels;j++){
  93       fLTMmatrix[i][j]=kFALSE;
  94     }
  95     if (i<kNCTTM){
  96       for (Int_t j=0;j<kNCTTMchannels;j++){
  97         fCTTMmatrixFront[i][j]=kFALSE;
  98         fCTTMmatrixBack[i][j]=kFALSE;
  99       }
 100     }
 101   }
 102
 103   fPowerMask[0] = 1;
 104   for(Int_t i=1;i <= kNCTTMchannels;i++){
 105       fPowerMask[i] = fPowerMask[i-1]*2;
 106   }
 107
 108   SetName("TOF");
 109   CreateInputs();
 110
 111 }
 112
 113 //----------------------------------------------------------------------
 114
 115 AliTOFTrigger::AliTOFTrigger(Int_t HighMultTh, Int_t ppMBTh, Int_t MultiMuonTh, Int_t UPTh, Float_t deltaminpsi, Float_t deltamaxpsi, Float_t deltaminro, Float_t deltamaxro, Int_t stripWindow,Float_t startTimeWindow,Float_t widthTimeWindow) :
 116   AliTriggerDetector(),
 117   fHighMultTh(HighMultTh),
 118   fppMBTh(ppMBTh),
 119   fMultiMuonTh(MultiMuonTh),
 120   fUPTh(UPTh),
 121   fdeltaminpsi(deltaminpsi),
 122   fdeltamaxpsi(deltamaxpsi),
 123   fdeltaminro(deltaminro),
 124   fdeltamaxro(deltamaxro),
 125   fstripWindow(stripWindow),
 126   fSel1(0),
 127   fSel2(0),
 128   fSel3(0),
 129   fSel4(0),
 130   fNCrateOn(0),
 131   fNMaxipadOn(0),
 132   fNMaxipadOnAll(0),
 133   fTOFTrigMask(0),
 134   fStartTimeHit(startTimeWindow),
 135   fTimeWidthTrigger(widthTimeWindow)
 136 {
 137   //ctor with thresholds for triggers
 138   for (Int_t i=0;i<kNCTTM;i++) fLTMarray[i] = kFALSE;
 139   for (Int_t i=0;i<kNLTM;i++){
 140     for (Int_t j=0;j<kNLTMchannels;j++){
 141       fLTMmatrix[i][j]=kFALSE;
 142     }
 143     if (i<kNCTTM){
 144       for (Int_t j=0;j<kNCTTMchannels;j++){
 145         fCTTMmatrixFront[i][j]=kFALSE;
 146         fCTTMmatrixBack[i][j]=kFALSE;
 147       }
 148     }
 149   }
 150
 151   fPowerMask[0] = 1;
 152   for(Int_t i=1;i <= kNCTTMchannels;i++){
 153       fPowerMask[i] = fPowerMask[i-1]*2;
 154   }
 155
 156   SetName("TOF");
 157   CreateInputs();
 158 }
 159
 160
 161 #if 0 /*** COPY CONSTRUCTOR SUPPRESSED **/
 162 //____________________________________________________________________________
 163
 164 AliTOFTrigger::AliTOFTrigger(const AliTOFTrigger & tr):
 165   AliTriggerDetector(tr),
 166   fHighMultTh(tr.fHighMultTh),
 167   fppMBTh(tr.fppMBTh),
 168   fMultiMuonTh(tr.fMultiMuonTh),
 169   fUPTh(tr.fUPTh),
 170   fdeltaminpsi(tr.fdeltaminpsi),
 171   fdeltamaxpsi(tr.fdeltamaxpsi),
 172   fdeltaminro(tr.fdeltaminro),
 173   fdeltamaxro(tr.fdeltamaxro),
 174   fstripWindow(tr.fstripWindow),
 175   fSel1(tr.fSel1),
 176   fSel2(tr.fSel2),
 177   fSel3(tr.fSel3),
 178   fSel4(tr.fSel4),
 179   fNCrateOn(tr.fNCrateOn),
 180   fNMaxipadOn(tr.fNMaxipadOn),
 181   fNMaxipadOnAll(tr.fNMaxipadOnAll),
 182   fTOFTrigMask(0)
 183 {
 184   //copy ctor
 185   for (Int_t i=0;i<kNCTTM;i++) fLTMarray[i] = kFALSE;
 186   for (Int_t i=0;i<kNLTM;i++){
 187     for (Int_t j=0;j<kNLTMchannels;j++){
 188       fLTMmatrix[i][j]=tr.fLTMmatrix[i][j];
 189     }
 190     if (i<kNCTTM){
 191       for (Int_t j=0;j<kNCTTMchannels;j++){
 192         fCTTMmatrixFront[i][j]=tr.fCTTMmatrixFront[i][j];
 193         fCTTMmatrixBack[i][j]=tr.fCTTMmatrixBack[i][j];
 194       }
 195     }
 196   }
 197
 198   fPowerMask[0] = 1;
 199   for(Int_t i=1;i <= kNCTTMchannels;i++){
 200       fPowerMask[i] = fPowerMask[i-1]*2;
 201   }
 202
 203   if(tr.fTOFTrigMask){
 204       fTOFTrigMask = new AliTOFTriggerMask();
 205       fTOFTrigMask->SetTriggerMaskArray(tr.fTOFTrigMask->GetTriggerMaskArray());
 206   }
 207
 208   SetName(tr.GetName());
 209   //fInputs=&(tr.GetInputs());
 210   CreateInputs();
 211
 212 }
 213 #endif /*** COPY CONTRUCTOR SUPPRESSED ***/
 214
 215 //----------------------------------------------------------------------
 216
 217 void AliTOFTrigger::CreateInputs()
 218 {
 219   // creating inputs
 220   // Do not create inputs again!!
 221   if( fInputs.GetEntriesFast() > 0 ) return;
 222
 223   LoadActiveMask();
 224
 225   fInputs.AddLast(new AliTriggerInput("TOF_Cosmic_MultiMuon_L0","TOF",0));
 226   fInputs.AddLast(new AliTriggerInput("0OIN","TOF",0)); // was "TOF_pp_MB_L0"
 227   fInputs.AddLast(new AliTriggerInput("0OM2","TOF",0)); // was "TOF_PbPb_MB2_L0"
 228   fInputs.AddLast(new AliTriggerInput("0OM3","TOF",0)); // was "TOF_PbPb_MB3_L0"
 229   fInputs.AddLast(new AliTriggerInput("0OUP","TOF",0)); // was "TOF_UltraPer_Coll_L0"
 230
 231   fInputs.AddLast(new AliTriggerInput("0OHM","TOF",0)); // was "TOF_High_Mult_L0"
 232   fInputs.AddLast(new AliTriggerInput("TOF_Jet_L1","TOF",0));
 233
 234 }
 235
 236 //----------------------------------------------------------------------
 237 void AliTOFTrigger::Trigger() {
 238   //triggering method
 239   fSel1=0;
 240   fSel2=0;
 241   fSel3=0;
 242   fSel4=0;
 243
 244   CreateLTMMatrix();
 245
 246   Int_t nchonFront = 0;
 247   Int_t nchonBack = 0;
 248   Int_t nchonTot = 0;
 249   Int_t nSectOn = 0; // °°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°
 250   Int_t DeSlots = -1;// °°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°
 251   Int_t AntiDeSlots = -1;// °°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°
 252   Int_t nchonFrontBack = 0;
 253   Int_t nchonFront1 = 0;
 254   Int_t nchonBack1 = 0;
 255   Int_t nchonFrontBack1 = 0;
 256   Int_t mindeltapsi = (Int_t)fdeltaminpsi/10;
 257   Int_t maxdeltapsi = (Int_t)fdeltamaxpsi/10;
 258   Int_t mindeltaro = (Int_t)fdeltaminro/10;
 259   Int_t maxdeltaro = (Int_t)fdeltamaxro/10;
 260
 261   for (Int_t i=0;i<kNCTTM;i++){
 262     for (Int_t j=0;j<kNCTTMchannels;j++){
 263       if (fCTTMmatrixFront[i][j]) nchonFront++;
 264     }
 265   }
 266
 267   for (Int_t i=kNCTTM;i<(kNCTTM*2);i++){
 268     for (Int_t j=0;j<kNCTTMchannels;j++){
 269       if (fCTTMmatrixBack[i-kNCTTM][j]) nchonBack++;
 270     }
 271   }
 272
 273   nchonTot = nchonFront + nchonBack;
 274 //  fNMaxipadOn = nchonTot;
 275   for(Int_t i=0;i<kNCTTM;i++) { if(fLTMarray[i]) nSectOn++; }
 276
 277   //pp Minimum Bias Trigger
 278   if (nchonTot >= fppMBTh) {
 279     SetInput("0OIN");
 280     fSel1=1;
 281     //printf("0OIN - MB\n");
 282   }
 283
 284   // PbPb MB
 285   if (nchonTot >= 2) {
 286     SetInput("0OM2");
 287     fSel2=1;
 288   }
 289   if (nchonTot >= 3) {
 290     SetInput("0OM3");
 291     fSel3=1;
 292   }
 293
 294   //High Multiplicity Trigger
 295   if (nchonTot >= fHighMultTh) {
 296     SetInput("0OHM");
 297     //printf("0OHM - High Mult\n");
 298   }
 299
 300
 301   //MultiMuon Trigger
 302   nchonFront = 0;
 303   nchonBack = 0;
 304   nchonFrontBack = 0;
 305
 306   Bool_t boolCTTMor = kFALSE;
 307
 308   for (Int_t i=0;i<(kNCTTM/2);i++){
 309     Int_t iopp = i+kNCTTM/2;
 310     for (Int_t j=0;j<kNCTTMchannels;j++){
 311       if (fCTTMmatrixFront[i][j]){
 312         Int_t minj = j-fstripWindow;
 313         Int_t maxj = j+fstripWindow;
 314         if (minj<0) minj =0;
 315         if (maxj>=kNCTTMchannels) maxj = kNCTTMchannels-1;
 316         boolCTTMor = kFALSE;
 317         for (Int_t k = minj;k<=maxj;k++){
 318           boolCTTMor |= fCTTMmatrixFront[iopp][k];
 319         }
 320         if (boolCTTMor) {
 321           nchonFront++;
 322         }
 323       }
 324
 325       if (fCTTMmatrixBack[i][j]){
 326         Int_t minj = j-fstripWindow;
 327         Int_t maxj = j+fstripWindow;
 328         if (minj<0) minj =0;
 329         if (maxj>=kNCTTMchannels) maxj =kNCTTMchannels-1;
 330         boolCTTMor = kFALSE;
 331         for (Int_t k = minj;k<=maxj;k++){
 332           boolCTTMor |= fCTTMmatrixBack[iopp][k];
 333         }
 334         if (boolCTTMor) {
 335           nchonBack++;
 336         }
 337       }
 338     }
 339   }
 340
 341   nchonFrontBack = nchonFront+nchonBack;
 342
 343   nchonFront1 = 0;
 344   nchonBack1 = 0;
 345   nchonFrontBack1 = 0;
 346
 347   boolCTTMor = kFALSE;
 348   for (Int_t i=0;i<(kNCTTM/2);i++){
 349     Int_t i2max = (kNCTTM-1)-i+1;
 350     Int_t i2min = (kNCTTM-1)-i-1;
 351     if (i2max >=kNCTTM) i2max = kNCTTM-1;
 352     if (i2min==i) i2min = kNCTTM-1-i;
 353     for (Int_t j=0;j<kNCTTMchannels;j++){
 354       Int_t j2min = j-fstripWindow;
 355       Int_t j2max = j+fstripWindow;
 356       if (j2min<0) j2min =0;
 357       if (j2max>=kNCTTMchannels) j2max =kNCTTMchannels-1;
 358       if (fCTTMmatrixFront[i][j]){
 359         boolCTTMor = kFALSE;
 360         for (Int_t i2=i2min;i2<=i2max;i2++){
 361           for (Int_t j2 = j2min;j2<=j2max;j2++){
 362             boolCTTMor |= fCTTMmatrixFront[i2][j2];
 363           }
 364           if (boolCTTMor) {
 365             nchonFront++;
 366           }
 367         }
 368       }
 369       if (fCTTMmatrixBack[i][j]){
 370           boolCTTMor = kFALSE;
 371           for (Int_t i2=i2min;i2<=i2max;i2++){
 372               for (Int_t j2 = j2min;j2<=j2max;j2++){
 373                   boolCTTMor |= fCTTMmatrixBack[i2][j2];
 374               }
 375           }
 376           if (boolCTTMor) {
 377               nchonBack++;
 378           }
 379       }
 380     }
 381   }
 382
 383   nchonFrontBack1 = nchonFront1+nchonBack1;
 384
 385   if (nchonFrontBack >= fMultiMuonTh || nchonFrontBack1 >= fMultiMuonTh) {
 386       SetInput("TOF_Cosmic_MultiMuon_L0");
 387   }
 388
 389   //Ultra-Peripheral collision Trigger
 390
 391   // °°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°
 392   // DeSlots = (k+1)_Array Element - k_Array Element
 393   // AntiDeSlots = kNCTTM - DeSlots
 394
 395   if((!fSel1))// && nchonFront < 4 && nchonBack < 4)
 396   {
 397       // printf("nHitMaxipad CLASSE: %i \n",fNMaxipadOn);
 398       // printf("Total Number per event of Switched-On sectors : %i \n", nSectOn);
 399       // printf("mindeltapsi %i \n", mindeltapsi);
 400       //printf("maxdeltapsi %i \n", maxdeltapsi);
 401       for(Int_t i = 0; i < kNCTTM; i++){
 402           if(fLTMarray[i]){
 403               // printf(" i-sect On:  %i\n",i);
 404               for(Int_t j = i+1; j < kNCTTM; j++){
 405                   if(fLTMarray[j]) {
 406                       //  printf(" j-sect On:  %i\n",j);
 407                       DeSlots = j-i;
 408                       AntiDeSlots = kNCTTM - DeSlots;
 409                       //printf("DeSlots = %i \n",DeSlots);
 410                       //printf("AntiDeSlots = %i \n",AntiDeSlots);
 411                       if(DeSlots >= mindeltapsi && DeSlots <= maxdeltapsi){
 412                           fSel4=1;
 413                           SetInput("0OUP");
 414                           //printf("trigger On with DeSlot \n");
 415                       }
 416                       if(AntiDeSlots >= mindeltapsi && AntiDeSlots <= maxdeltapsi){
 417                           fSel4=1;
 418                           SetInput("0OUP");
 419                           //printf("trigger On with AntiDeSlot \n");
 420                       }
 421
 422
 423                       if(DeSlots >= mindeltaro && DeSlots <= maxdeltaro){
 424                           fSel4=1;
 425                           SetInput("0OUP");
 426                           //printf("trigger On with DeSlot \n");
 427                       }
 428                       if(AntiDeSlots >= mindeltaro && AntiDeSlots <= maxdeltaro){
 429                           fSel4=1;
 430                           SetInput("0OUP");
 431                           //printf("trigger On with AntiDeSlot \n");
 432                       }
 433
 434                   }
 435
 436               }
 437           }
 438       }
 439   }
 440 }
 441
 442 //-----------------------------------------------------------------------------
 443 void AliTOFTrigger::CreateLTMMatrix() {
 444   //creating LTMMatrix
 445   //initialization
 446   CreateLTMMatrixFromDigits();
 447 }
 448
 449 //-------------------------------------------------------------------------
 450
 451 void AliTOFTrigger::CreateLTMMatrixFromDigits() {
 452   //
 453   // Create LTM matrix by TOF digits
 454   //
 455
 456   //initialization
 457   for (Int_t i=0;i<kNCTTM;i++) fLTMarray[i]= kFALSE;
 458   for (Int_t i=0;i<kNLTM;i++){
 459     for (Int_t j=0;j<kNLTMchannels;j++){
 460       fLTMmatrix[i][j]=kFALSE;
 461     }
 462   }
 463   for (Int_t i=0;i<kNCTTM;i++){
 464       for (Int_t j=0;j<kNCTTMchannels;j++){
 465           fCTTMmatrixFront[i][j]=kFALSE;
 466           fCTTMmatrixBack[i][j]=kFALSE;
 467       }
 468   }
 469
 470
 471   AliRunLoader *rl;
 472   rl = AliRunLoader::Instance();
 473
 474   Int_t ncurrevent = rl->GetEventNumber();
 475   rl->GetEvent(ncurrevent);
 476
 477   AliLoader * tofLoader = rl->GetLoader("TOFLoader");
 478
 479   tofLoader->LoadDigits("read");
 480   TTree *treeD = tofLoader->TreeD();
 481   if (treeD == 0x0) {
 482     AliFatal("AliTOFTrigger: Can not get TreeD");
 483     return;
 484   }
 485
 486   TBranch *branch = treeD->GetBranch("TOF");
 487   if (!branch) {
 488     AliError("can't get the branch with the TOF digits !");
 489     return;
 490   }
 491   TClonesArray *tofDigits =new TClonesArray("AliTOFdigit",  1000);
 492   branch->SetAddress(&tofDigits);
 493   treeD->GetEvent(0);
 494   Int_t ndigits = tofDigits->GetEntriesFast();
 495   Int_t detind[5]; //detector indexes: 0 -> sector
 496   //                                   1 -> plate(modulo)
 497   //                                   2 -> strip
 498   //                                   3 -> padz
 499   //                                   4 -> padx
 500
 501   if(! fgTofGeo) fgTofGeo = new AliTOFGeometry();
 502
 503
 504   for (Int_t i=0;i<ndigits;i++){
 505     AliTOFdigit * digit = (AliTOFdigit*)tofDigits->UncheckedAt(i);
 506     detind[0] = digit->GetSector();
 507     detind[1] = digit->GetPlate();
 508     detind[2] = digit->GetStrip();
 509     detind[3] = digit->GetPadz();
 510     detind[4] = digit->GetPadx();
 511
 512     Int_t indexLTM[2] = {-1,-1};
 513     GetLTMIndex(detind,indexLTM);
 514
 515     Float_t timedigit = digit->GetTdc()*AliTOFGeometry::TdcBinWidth()*1E-3; // time digit in ns
 516
 517     Float_t pos[3];
 518     fgTofGeo->GetPosPar(detind, pos);
 519     Float_t length = 0.;
 520     for (Int_t ic = 0; ic < 3; ic++) length += pos[ic] * pos[ic];
 521     length = TMath::Sqrt(length);
 522     timedigit -= length * 0.0333564095198152043; // subtract the minimal time in ns for the current channel
 523
 524     if(timedigit > fStartTimeHit - 0.5 && timedigit < fStartTimeHit + fTimeWidthTrigger - 0.5)
 525       fLTMmatrix[indexLTM[0]][indexLTM[1]] = kTRUE;
 526
 527 //    fLTMarray[indexLTM[0]%36] = kTRUE; //dimensione MAX array 36 = kNCTTM
 528   }
 529
 530
 531   tofLoader->UnloadDigits();
 532   //   rl->UnloadgAlice();
 533   CreateCTTMMatrix();
 534
 535 }
 536
 537 //-----------------------------------------------------------------------------
 538
 539 void AliTOFTrigger::CreateLTMMatrixFromRaw(AliRawReader *fRawReader) {
 540   //
 541   // Create LTM matrix by TOF raw data
 542   //
 543
 544   //initialization
 545   for (Int_t i=0;i<kNLTM;i++){
 546     for (Int_t j=0;j<kNLTMchannels;j++){
 547       fLTMmatrix[i][j]=kFALSE;
 548     }
 549   }
 550   for (Int_t i=0;i<kNCTTM;i++){
 551       for (Int_t j=0;j<kNCTTMchannels;j++){
 552           fCTTMmatrixFront[i][j]=kFALSE;
 553           fCTTMmatrixBack[i][j]=kFALSE;
 554       }
 555   }
 556
 557   if(fRawReader){
 558     AliTOFRawStream * tofRawStream = new AliTOFRawStream();
 559
 560     Int_t inholes = 0;
 561
 562     //if(!GetLoader()->TreeS()) {MakeTree("S");  MakeBranch("S");}
 563
 564     Clear();
 565     tofRawStream->SetRawReader(fRawReader);
 566
 567     //ofstream ftxt;
 568     //if (fVerbose==2) ftxt.open("TOFsdigitsRead.txt",ios::app);
 569
 570     TClonesArray staticRawData("AliTOFrawData",10000);
 571     staticRawData.Clear();
 572     TClonesArray * clonesRawData = &staticRawData;
 573
 574     Int_t dummy = -1;
 575     Int_t detectorIndex[5] = {-1, -1, -1, -1, -1};
 576     Int_t digit[2];
 577     //Int_t track = -1;
 578     //Int_t last = -1;
 579
 580     Int_t indexDDL = 0;
 581     Int_t iRawData = 0;
 582     AliTOFrawData *tofRawDatum = 0;
 583     for (indexDDL=0; indexDDL<AliDAQ::NumberOfDdls("TOF"); indexDDL++) {
 584
 585       fRawReader->Reset();
 586       tofRawStream->LoadRawDataBuffersV2(indexDDL);
 587
 588       clonesRawData = tofRawStream->GetRawData();
 589       if (clonesRawData->GetEntriesFast()!=0) AliInfo(Form(" TOF raw data number = %3d", clonesRawData->GetEntriesFast()));
 590       for (iRawData = 0; iRawData<clonesRawData->GetEntriesFast(); iRawData++) {
 591
 592         tofRawDatum = (AliTOFrawData*)clonesRawData->UncheckedAt(iRawData);
 593
 594         //if (tofRawDatum->GetTOT()==-1 || tofRawDatum->GetTOF()==-1) continue;
 595         if (tofRawDatum->GetTOF()==-1) continue;
 596
 597         SetBit(indexDDL, tofRawDatum->GetTRM(), tofRawDatum->GetTRMchain(),
 598                tofRawDatum->GetTDC(), tofRawDatum->GetTDCchannel());
 599
 600         dummy = detectorIndex[3];
 601         detectorIndex[3] = detectorIndex[4];//padz
 602         detectorIndex[4] = dummy;//padx
 603
 604         digit[0] = tofRawDatum->GetTOF();
 605         digit[1] = tofRawDatum->GetTOT();
 606
 607         dummy = detectorIndex[3];
 608         detectorIndex[3] = detectorIndex[4];//padx
 609         detectorIndex[4] = dummy;//padz
 610
 611         // Do not reconstruct anything in the holes
 612         if (detectorIndex[0]==13 || detectorIndex[0]==14 || detectorIndex[0]==15 ) { // sectors with holes
 613           if (detectorIndex[1]==2) { // plate with holes
 614             inholes++;
 615             continue;
 616           }
 617         }
 618
 619         tofRawDatum = 0;
 620       } // while loop
 621
 622       clonesRawData->Clear();
 623
 624     } // DDL Loop
 625
 626     //if (fVerbose==2) ftxt.close();
 627
 628     if (inholes) AliWarning(Form("Clusters in the TOF holes: %d",inholes));
 629     delete tofRawStream;
 630     tofRawStream = NULL;
 631
 632   }
 633
 634 }
 635
 636 //-----------------------------------------------------------------------------
 637 void AliTOFTrigger::GetLTMIndex(const Int_t * const detind, Int_t *indexLTM) {
 638   //
 639   // getting LTMmatrix indexes for current digit
 640   //
 641
 642   if (detind[1]==0 || detind[1]==1 || (detind[1]==2 && detind[2]<=7)) {
 643     if (detind[4]<24){
 644       indexLTM[0] = detind[0]*2;
 645     }
 646     else {
 647       indexLTM[0] = detind[0]*2+1;
 648     }
 649   }
 650   else {
 651     if (detind[4]<24){
 652       indexLTM[0] = detind[0]*2+36;
 653     }
 654     else {
 655       indexLTM[0] = (detind[0]*2+1)+36;
 656     }
 657   }
 658
 659   if (indexLTM[0]<36) {
 660     if (detind[1] ==0){
 661       indexLTM[1] = detind[2];
 662     }
 663     else if (detind[1] ==1){
 664       indexLTM[1] = detind[2]+19;
 665     }
 666     else if (detind[1] ==2){
 667       indexLTM[1] = detind[2]+19*2;
 668     }
 669     else{
 670       AliError("Smth Wrong!!!");
 671     }
 672   }
 673   else {
 674     if (detind[1] ==2){
 675       indexLTM[1] = detind[2]-8;
 676     }
 677     else if (detind[1] ==3){
 678       indexLTM[1] = detind[2]+7;
 679     }
 680     else if (detind[1] ==4){
 681       indexLTM[1] = detind[2]+26;
 682     }
 683     else{
 684       AliError("Smth Wrong!!!");
 685     }
 686   }
 687
 688 }
 689 //-------------------------------------------------------------------------
 690 /*
 691 // to be checked because of warning problems
 692 void AliTOFTrigger::PrintMap()
 693 {
 694   //
 695   //
 696   //
 697
 698   for(Int_t i = 0; i<kNLTM;i++) {
 699     if(i<36) {
 700       printf("| %d | %d |%d |%d |%d |%d |%d |%d |%d |%d |%d |%d |%d |%d |%d |%d |%d |%d |%d |%d |%d |%d |%d |%d |%d |\n",
 701              (fCTTMmatrixFront[i][0])?1:0,(fCTTMmatrixFront[i][1])?1:0,(fCTTMmatrixFront[i][2])?1:0, \
 702              (fCTTMmatrixFront[i][3])?1:0,(fCTTMmatrixFront[i][4])?1:0,(fCTTMmatrixFront[i][5])?1:0, \
 703              (fCTTMmatrixFront[i][6])?1:0,(fCTTMmatrixFront[i][7])?1:0,(fCTTMmatrixFront[i][8])?1:0, \
 704              (fCTTMmatrixFront[i][9])?1:0,(fCTTMmatrixFront[i][10])?1:0,(fCTTMmatrixFront[i][11])?1:0, \
 705              (fCTTMmatrixFront[i][12])?1:0,(fCTTMmatrixFront[i][13])?1:0,(fCTTMmatrixFront[i][14])?1:0, \
 706              (fCTTMmatrixFront[i][15])?1:0,(fCTTMmatrixFront[i][16])?1:0,(fCTTMmatrixFront[i][17])?1:0, \
 707              (fCTTMmatrixFront[i][18])?1:0,(fCTTMmatrixFront[i][19])?1:0,(fCTTMmatrixFront[i][20])?1:0, \
 708              (fCTTMmatrixFront[i][21])?1:0,(fCTTMmatrixFront[i][22])?1:0,(fCTTMmatrixFront[i][23])?1:0);
 709     } else {
 710       printf("| %d | %d |%d |%d |%d |%d |%d |%d |%d |%d |%d |%d |%d |%d |%d |%d |%d |%d |%d |%d |%d |%d |%d |%d |%d |\n",
 711              (fCTTMmatrixBack[i][0])?1:0,(fCTTMmatrixBack[i][1])?1:0,(fCTTMmatrixBack[i][2])?1:0, \
 712              (fCTTMmatrixBack[i][3])?1:0,(fCTTMmatrixBack[i][4])?1:0,(fCTTMmatrixBack[i][5])?1:0, \
 713              (fCTTMmatrixBack[i][6])?1:0,(fCTTMmatrixBack[i][7])?1:0,(fCTTMmatrixBack[i][8])?1:0, \
 714              (fCTTMmatrixBack[i][9])?1:0,(fCTTMmatrixBack[i][10])?1:0,(fCTTMmatrixBack[i][11])?1:0, \
 715              (fCTTMmatrixBack[i][12])?1:0,(fCTTMmatrixBack[i][13])?1:0,(fCTTMmatrixBack[i][14])?1:0, \
 716              (fCTTMmatrixBack[i][15])?1:0,(fCTTMmatrixBack[i][16])?1:0,(fCTTMmatrixBack[i][17])?1:0, \
 717              (fCTTMmatrixBack[i][18])?1:0,(fCTTMmatrixBack[i][19])?1:0,(fCTTMmatrixBack[i][20])?1:0, \
 718              (fCTTMmatrixBack[i][21])?1:0,(fCTTMmatrixBack[i][22])?1:0,(fCTTMmatrixBack[i][23])?1:0);
 719     }
 720   }
 721
 722 }
 723 */
 724 //-------------------------------------------------------------------------
 725
 726 void AliTOFTrigger::GetMapMatrix(Bool_t map[][24]) const
 727 {
 728   //
 729   // Returns CTTM map
 730   //
 731
 732   for(Int_t i = 0; i<kNLTM;i++)
 733     for(Int_t j = 0; j<kNCTTMchannels;j++)
 734       map[i][j]=(i<36)?fCTTMmatrixFront[i][j]:fCTTMmatrixBack[i-36][j];
 735
 736 }
 737 //-------------------------------------------------------------------------
 738
 739 void AliTOFTrigger::GetMap(Bool_t **map) const
 740 {
 741   //
 742   // Returns CTTM map
 743   //
 744
 745   for(Int_t i = 0; i<kNLTM;i++)
 746     for(Int_t j = 0; j<kNCTTMchannels;j++)
 747       map[i][j]=(i<36)?fCTTMmatrixFront[i][j]:fCTTMmatrixBack[i-36][j];
 748
 749 }
 750
 751
 752 //-------------------------------------------------------------------------
 753 void AliTOFTrigger::GetTRDmap(Bool_t **map) const
 754 {
 755   //
 756   // Retriev the bit map sent to the TRD detector
 757   //
 758
 759     for(int i = 0; i<kNLTM;i++)
 760         for(int j = 0; j<kNLTMtoTRDchannels;j++){
 761             map[i][j]=kFALSE;
 762         }
 763
 764     for(int i = 0; i<kNLTM/2;i++)
 765     for(int j = 0; j<AliTOFTrigger::kNCTTMchannels;j++){
 766         UInt_t uTRDbit=j/3;
 767         if(fCTTMmatrixFront[i][j]) map[i][uTRDbit]=kTRUE;
 768     }
 769   for(int i = kNLTM/2; i<kNLTM;i++)
 770       for(int j = 0; j<AliTOFTrigger::kNCTTMchannels;j++){
 771           UInt_t uTRDbit=j/3;
 772           if(fCTTMmatrixBack[i-kNLTM/2][j]) map[i][uTRDbit]=kTRUE;
 773     }
 774
 775 }
 776 //-------------------------------------------------------------------------
 777 void AliTOFTrigger::GetTRDmapMatrix(Bool_t map[][8]) const
 778 {
 779   //
 780   // Retriev the bit map sent to the TRD detector
 781   //
 782
 783     for(int i = 0; i<kNLTM;i++)
 784         for(int j = 0; j<kNLTMtoTRDchannels;j++){
 785             map[i][j]=kFALSE;
 786         }
 787
 788     for(int i = 0; i<kNLTM/2;i++)
 789     for(int j = 0; j<AliTOFTrigger::kNCTTMchannels;j++){
 790         UInt_t uTRDbit=j/3;
 791         if(fCTTMmatrixFront[i][j]) map[i][uTRDbit]=kTRUE;
 792     }
 793   for(int i = kNLTM/2; i<kNLTM;i++)
 794       for(int j = 0; j<AliTOFTrigger::kNCTTMchannels;j++){
 795           UInt_t uTRDbit=j/3;
 796           if(fCTTMmatrixBack[i-kNLTM/2][j]) map[i][uTRDbit]=kTRUE;
 797     }
 798
 799 }
 800
 801 //-------------------------------------------------------------------------
 802 void AliTOFTrigger::SetBit(Int_t *detind)
 803 {
 804   //
 805   // Sets CTTM map element corresponding to detector element 'detind'
 806   //
 807
 808   Int_t index[2];
 809   GetCTTMIndex(detind,index);
 810   if(index[0]<36)
 811     fCTTMmatrixFront[index[0]][index[1]]=kTRUE;
 812   else
 813     fCTTMmatrixBack[index[0]-36][index[1]]=kTRUE;
 814
 815 }
 816
 817 //-------------------------------------------------------------------------
 818 void AliTOFTrigger::SetBit(Int_t nDDL, Int_t nTRM, Int_t iChain,
 819                            Int_t iTDC, Int_t iCH)
 820 {
 821   //
 822   // Sets CTTM map element corresponding to equipment ID
 823   // labelled by number nDDL, nTRM, iChain, iTDC, iCH
 824   //
 825
 826     if(nTRM==3 && iTDC>=12 && iTDC<=14 && nDDL%2==1){ // DDL number to LTM number mapping
 827 //       getchar();
 828     Int_t iLTMindex=-1;
 829     Int_t iChannelIndex=-1;
 830     switch(nDDL%AliTOFGeometry::NDDL()){
 831     case 1:
 832       iLTMindex=1;
 833       break;
 834     case 3:
 835       iLTMindex=36;
 836       break;
 837     default:
 838       AliError("Call this function only if(nTRM==3 && iTDC>12 && iTDC<14 && nDDL%2==1) ");
 839       break;
 840     }
 841     iLTMindex+=2*(Int_t)(nDDL/AliTOFGeometry::NDDL());
 842     if(iChain==0 && nDDL<36)
 843       iLTMindex--;
 844     if(iChain==0 && nDDL>=36)
 845       iLTMindex++;
 846     iChannelIndex=iCH+iTDC*AliTOFGeometry::NCh()-12*AliTOFGeometry::NCh();
 847     Int_t index[2]={iLTMindex,iChannelIndex};
 848     if (index[0]<36){
 849       fCTTMmatrixFront[index[0]][index[1]]=kTRUE;
 850       fLTMmatrix[index[0]][index[1]*2]=kTRUE;
 851     }
 852     else{
 853         fCTTMmatrixBack[index[0]-36][index[1]]=kTRUE;
 854         fLTMmatrix[index[0]][index[1]*2]=kTRUE;
 855     }
 856     }
 857
 858 }
 859 //-------------------------------------------------------------------------
 860
 861 void AliTOFTrigger::ResetBit(Int_t *detind)
 862 {
 863   //
 864   // Sets CTTM map element corresponding to detector element 'detind'
 865   //
 866
 867   Int_t index[2];
 868   GetCTTMIndex(detind,index);
 869   if(index[0]<36)
 870     fCTTMmatrixFront[index[0]][index[1]]=kFALSE;
 871   else
 872     fCTTMmatrixBack[index[0]-36][index[1]]=kFALSE;
 873
 874 }
 875
 876 //-------------------------------------------------------------------------
 877 void AliTOFTrigger::ResetBit(Int_t nDDL, Int_t nTRM, Int_t iChain,
 878                              Int_t iTDC, Int_t iCH)
 879 {
 880   //
 881   // Sets CTTM map element corresponding to equipment ID
 882   // labelled by number nDDL, nTRM, iChain, iTDC, iCH
 883   //
 884
 885   if(nTRM==3 && iTDC>12 && iTDC<14 && nDDL%2==1){ // DDL number to LTM number mapping
 886     Int_t iLTMindex=-1;
 887     Int_t iChannelIndex=-1;
 888     switch(nDDL%AliTOFGeometry::NDDL()){
 889     case 1:
 890       iLTMindex=1;
 891       break;
 892     case 3:
 893       iLTMindex=36;
 894       break;
 895     default:
 896       AliError("Call this function only if(nTRM==3 && iTDC>12 && iTDC<14 && nDDL%2==1) ");
 897       break;
 898     }
 899     iLTMindex+=2*(Int_t)(nDDL/AliTOFGeometry::NDDL());
 900     if(iChain==0 && nDDL<36)
 901       iLTMindex--;
 902     if(iChain==0 && nDDL>=36)
 903       iLTMindex++;
 904     iChannelIndex=iCH+iTDC*AliTOFGeometry::NCh()-12*AliTOFGeometry::NCh();
 905     Int_t index[2]={iLTMindex,iChannelIndex};
 906     if (index[0]<36){
 907       fCTTMmatrixFront[index[0]][index[1]]=kFALSE;
 908     }
 909     else{
 910       fCTTMmatrixBack[index[0]-36][index[1]]=kFALSE;
 911     }
 912   }
 913   else
 914     AliError("Call this function only if(nTRM==3 && iTDC>12 && iTDC<14 && nDDL%2==1) ");
 915
 916 }
 917 //-------------------------------------------------------------------------
 918
 919 Bool_t AliTOFTrigger::GetBit(Int_t *detind)
 920 {
 921   //
 922   // Returns CTTM map element corresponding to detector element 'detind'
 923   //
 924
 925   Int_t index[2];
 926   GetCTTMIndex(detind,index);
 927   return (index[0]<36)?fCTTMmatrixFront[index[0]][index[1]]:fCTTMmatrixBack[index[0]-36][index[1]];
 928
 929 }
 930
 931 //-------------------------------------------------------------------------
 932 Bool_t AliTOFTrigger::GetBit(Int_t nDDL, Int_t nTRM, Int_t iChain,
 933                              Int_t iTDC, Int_t iCH)
 934 {
 935   //
 936   // Returns CTTM map element corresponding to equipment ID
 937   // labelled by number nDDL, nTRM, iChain, iTDC, iCH
 938   //
 939
 940   if ( !(nTRM==3 && iTDC>12 && iTDC<14 && nDDL%2==1) ) {
 941     AliWarning("Call this function only if(nTRM==3 && iTDC>12 && iTDC<14) ");
 942     return kFALSE;
 943   }
 944   //if (nTRM==3 && iTDC>12 && iTDC<14 && nDDL%2==1) { // DDL number to LTM number mapping
 945
 946   UInt_t iLTMindex=0;
 947   UInt_t iChannelindex=0;
 948   switch(nDDL%AliTOFGeometry::NDDL()) {
 949   case 1:
 950     iLTMindex=1;
 951     break;
 952   case 3:
 953     iLTMindex=36;
 954     break;
 955   default:
 956     AliError("something wrong");
 957     break;
 958   }
 959   iLTMindex+=2*(Int_t)(nDDL/AliTOFGeometry::NDDL());
 960
 961   if (iChain==1) return kFALSE; // AdC
 962
 963   if (nDDL<36)
 964     iLTMindex--;
 965   if (nDDL>=36)
 966     iLTMindex++;
 967   iChannelindex=iCH+iTDC*AliTOFGeometry::NCh()-12*AliTOFGeometry::NCh();
 968   Int_t index[2]={iLTMindex,iChannelindex};
 969   return (index[0]<36)?fCTTMmatrixFront[index[0]][index[1]]:fCTTMmatrixBack[index[0]-36][index[1]];
 970
 971 }
 972
 973 //-------------------------------------------------------------------------
 974
 975 void AliTOFTrigger::CreateCTTMMatrix() {
 976   //
 977   // Create CTTM bit map
 978   //
 979     Int_t fromTriggertoDCS[72] = {0,1,4,5,8,9,12,13,16,17,20,21,24,25,28,29,32,33,36,37,40,41,44,45,48,49,52,53,56,57,60,61,64,65,68,69,3,
 980                                   2,7,6,11,10,15,14,19,18,23,22,27,26,31,30,35,34,39,38,43,42,47,46,51,50,55,54,59,58,63,62,67,66,71,70};
 981
 982
 983     fNMaxipadOnAll=0;
 984     fNMaxipadOn=0;
 985
 986     for(Int_t i = 0; i<kNLTM;i++){
 987         UInt_t currentMask = fPowerMask[kNCTTMchannels]-1;
 988         if(fTOFTrigMask) currentMask=fTOFTrigMask->GetTriggerMask(fromTriggertoDCS[i]);
 989         if(i<kNCTTM){
 990             for(Int_t j = 0; j<kNCTTMchannels;j++){
 991                 fCTTMmatrixFront[i][j]=fLTMmatrix[i][2*j]||fLTMmatrix[i][2*j+1];
 992                 if(fCTTMmatrixFront[i][j]) fNMaxipadOnAll++;
 993                 if(!(currentMask & fPowerMask[j])) fCTTMmatrixFront[i][j]=0;
 994                 if(fCTTMmatrixFront[i][j]){
 995                     fNMaxipadOn++;
 996                     fLTMarray[i] = kTRUE;
 997                 }
 998             }
 999         }
1000         else{
1001             for(Int_t j = 0; j<kNCTTMchannels;j++){
1002                 fCTTMmatrixBack[i-kNCTTM][j]=fLTMmatrix[i][2*j]||fLTMmatrix[i][2*j+1];;
1003                 if(fCTTMmatrixBack[i-kNCTTM][j]) fNMaxipadOnAll++;
1004                 if(!(currentMask & fPowerMask[j])) fCTTMmatrixBack[i-kNCTTM][j]=0;
1005                 if(fCTTMmatrixBack[i-kNCTTM][j]){
1006                     fNMaxipadOn++;
1007                     fLTMarray[i-kNCTTM] = kTRUE;
1008                 }
1009             }
1010         }
1011     }
1012
1013     fNCrateOn = 0;
1014     for(Int_t j=0; j < kNCTTM; j++) {if(fLTMarray[j]) fNCrateOn++;}
1015
1016 }
1017 //-----------------------------------------------------------------------------
1018
1019 void AliTOFTrigger::GetCTTMIndex(Int_t *detind, Int_t *indexCTTM) {
1020   //
1021   // Returns CTTM index corresponding to the detector element detind
1022   //
1023
1024   GetLTMIndex(detind,indexCTTM);
1025   indexCTTM[1]/=2;
1026
1027 }
1028 //-----------------------------------------------------------------------------
1029 void AliTOFTrigger::LoadActiveMask(){
1030 //
1031 // Load OCDB current mask
1032 //
1033
1034     AliCDBManager *cdb = AliCDBManager::Instance();
1035     if(cdb->GetRun() < 0 || !(cdb->GetDefaultStorage())){
1036         if(!(cdb->GetDefaultStorage())){
1037             cdb->SetDefaultStorage("local://$ALICE_ROOT/OCDB");
1038             printf("AliTOFTrigger (WARNING): probably CDB first instance - Default Sorage set to \"local://$ALICE_ROOT/OCDB\"\n");
1039         }
1040         if(cdb->GetRun() < 0){
1041             cdb->SetRun(0);
1042          printf("AliTOFTrigger (WARNING): probably CDB first instance - number of run set to 0\n");
1043         }
1044     }
1045
1046     AliCDBEntry *cdbe = cdb->Get("TRIGGER/TOF/TriggerMask");
1047     if(!cdbe) return;
1048     fTOFTrigMask= (AliTOFTriggerMask *)cdbe->GetObject();
1049
1050 //     UInt_t maskArray[kNLTM];
1051 //     if(fTOFTrigMask == NULL) fTOFTrigMask = new AliTOFTriggerMask();
1052 //     for (Int_t k = 0; k < kNLTM ; k++) maskArray[k] = fPowerMask[kNCTTMchannels]-1;
1053 //     //for (Int_t k = 0; k < kNLTM ; k+=2) maskArray[k] = 0;
1054
1055 //     fTOFTrigMask->SetTriggerMaskArray(maskArray);
1056 }
1057
1058
1059 //-----------------------------------------------------------------------------
1060 AliTOFTrigger::~AliTOFTrigger()
1061 {
1062   // dtor
1063
1064 }
1065
1066 //-----------------------------------------------------------------------------
1067 AliTOFTrigger& AliTOFTrigger::operator=(const AliTOFTrigger &/*source*/)
1068 {
1069   // ass. op.
1070   return *this;
1071
1072 }
1073