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