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