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 >= mindeltaro && DeSlots <= maxdeltaro){
 437                           SetInput("0OMU");
 438                         }
 439                         else if(AntiDeSlots >= mindeltaro && AntiDeSlots <= maxdeltaro){
 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 }
 456
 457 //-------------------------------------------------------------------------
 458
 459 void AliTOFTrigger::CreateLTMMatrixFromDigits() {
 460   //
 461   // Create LTM matrix by TOF digits
 462   //
 463
 464   //initialization
 465   for (Int_t i=0;i<kNCTTM;i++) fLTMarray[i]= kFALSE;
 466   for (Int_t i=0;i<kNLTM;i++){
 467     for (Int_t j=0;j<kNLTMchannels;j++){
 468       fLTMmatrix[i][j]=kFALSE;
 469     }
 470   }
 471   for (Int_t i=0;i<kNCTTM;i++){
 472       for (Int_t j=0;j<kNCTTMchannels;j++){
 473           fCTTMmatrixFront[i][j]=kFALSE;
 474           fCTTMmatrixBack[i][j]=kFALSE;
 475       }
 476   }
 477
 478
 479   AliRunLoader *rl;
 480   rl = AliRunLoader::Instance();
 481
 482   Int_t ncurrevent = rl->GetEventNumber();
 483   rl->GetEvent(ncurrevent);
 484
 485   AliLoader * tofLoader = rl->GetLoader("TOFLoader");
 486
 487   tofLoader->LoadDigits("read");
 488   TTree *treeD = tofLoader->TreeD();
 489   if (treeD == 0x0) {
 490     AliFatal("AliTOFTrigger: Can not get TreeD");
 491     return;
 492   }
 493
 494   TBranch *branch = treeD->GetBranch("TOF");
 495   if (!branch) {
 496     AliError("can't get the branch with the TOF digits !");
 497     return;
 498   }
 499   TClonesArray *tofDigits =new TClonesArray("AliTOFdigit",  1000);
 500   branch->SetAddress(&tofDigits);
 501   treeD->GetEvent(0);
 502   Int_t ndigits = tofDigits->GetEntriesFast();
 503   Int_t detind[5]; //detector indexes: 0 -> sector
 504   //                                   1 -> plate(modulo)
 505   //                                   2 -> strip
 506   //                                   3 -> padz
 507   //                                   4 -> padx
 508
 509   if(! fgTofGeo) fgTofGeo = new AliTOFGeometry();
 510
 511
 512   for (Int_t i=0;i<ndigits;i++){
 513     AliTOFdigit * digit = (AliTOFdigit*)tofDigits->UncheckedAt(i);
 514     detind[0] = digit->GetSector();
 515     detind[1] = digit->GetPlate();
 516     detind[2] = digit->GetStrip();
 517     detind[3] = digit->GetPadz();
 518     detind[4] = digit->GetPadx();
 519
 520     Int_t indexLTM[2] = {-1,-1};
 521     GetLTMIndex(detind,indexLTM);
 522
 523     Float_t timedigit = digit->GetTdc()*AliTOFGeometry::TdcBinWidth()*1E-3; // time digit in ns
 524
 525     Float_t pos[3];
 526     fgTofGeo->GetPosPar(detind, pos);
 527     Float_t length = 0.;
 528     for (Int_t ic = 0; ic < 3; ic++) length += pos[ic] * pos[ic];
 529     length = TMath::Sqrt(length);
 530     timedigit -= length * 0.0333564095198152043; // subtract the minimal time in ns for the current channel
 531
 532     if(timedigit > fStartTimeHit - 0.5 && timedigit < fStartTimeHit + fTimeWidthTrigger - 0.5)
 533       fLTMmatrix[indexLTM[0]][indexLTM[1]] = kTRUE;
 534
 535 //    fLTMarray[indexLTM[0]%36] = kTRUE; //dimensione MAX array 36 = kNCTTM
 536   }
 537
 538
 539   tofLoader->UnloadDigits();
 540   //   rl->UnloadgAlice();
 541   CreateCTTMMatrix();
 542
 543 }
 544
 545 //-----------------------------------------------------------------------------
 546
 547 void AliTOFTrigger::CreateLTMMatrixFromRaw(AliRawReader *fRawReader) {
 548   //
 549   // Create LTM matrix by TOF raw data
 550   //
 551
 552   //initialization
 553   for (Int_t i=0;i<kNLTM;i++){
 554     for (Int_t j=0;j<kNLTMchannels;j++){
 555       fLTMmatrix[i][j]=kFALSE;
 556     }
 557   }
 558   for (Int_t i=0;i<kNCTTM;i++){
 559       for (Int_t j=0;j<kNCTTMchannels;j++){
 560           fCTTMmatrixFront[i][j]=kFALSE;
 561           fCTTMmatrixBack[i][j]=kFALSE;
 562       }
 563   }
 564
 565   if(fRawReader){
 566     AliTOFRawStream * tofRawStream = new AliTOFRawStream();
 567
 568     Int_t inholes = 0;
 569
 570     //if(!GetLoader()->TreeS()) {MakeTree("S");  MakeBranch("S");}
 571
 572     Clear();
 573     tofRawStream->SetRawReader(fRawReader);
 574
 575     //ofstream ftxt;
 576     //if (fVerbose==2) ftxt.open("TOFsdigitsRead.txt",ios::app);
 577
 578     TClonesArray staticRawData("AliTOFrawData",10000);
 579     staticRawData.Clear();
 580     TClonesArray * clonesRawData = &staticRawData;
 581
 582     Int_t dummy = -1;
 583     Int_t detectorIndex[5] = {-1, -1, -1, -1, -1};
 584     Int_t digit[2];
 585     //Int_t track = -1;
 586     //Int_t last = -1;
 587
 588     Int_t indexDDL = 0;
 589     Int_t iRawData = 0;
 590     AliTOFrawData *tofRawDatum = 0;
 591     for (indexDDL=0; indexDDL<AliDAQ::NumberOfDdls("TOF"); indexDDL++) {
 592
 593       fRawReader->Reset();
 594       tofRawStream->LoadRawDataBuffersV2(indexDDL);
 595
 596       clonesRawData = tofRawStream->GetRawData();
 597       if (clonesRawData->GetEntriesFast()!=0) AliInfo(Form(" TOF raw data number = %3d", clonesRawData->GetEntriesFast()));
 598       for (iRawData = 0; iRawData<clonesRawData->GetEntriesFast(); iRawData++) {
 599
 600         tofRawDatum = (AliTOFrawData*)clonesRawData->UncheckedAt(iRawData);
 601
 602         //if (tofRawDatum->GetTOT()==-1 || tofRawDatum->GetTOF()==-1) continue;
 603         if (tofRawDatum->GetTOF()==-1) continue;
 604
 605         SetBit(indexDDL, tofRawDatum->GetTRM(), tofRawDatum->GetTRMchain(),
 606                tofRawDatum->GetTDC(), tofRawDatum->GetTDCchannel());
 607
 608         dummy = detectorIndex[3];
 609         detectorIndex[3] = detectorIndex[4];//padz
 610         detectorIndex[4] = dummy;//padx
 611
 612         digit[0] = tofRawDatum->GetTOF();
 613         digit[1] = tofRawDatum->GetTOT();
 614
 615         dummy = detectorIndex[3];
 616         detectorIndex[3] = detectorIndex[4];//padx
 617         detectorIndex[4] = dummy;//padz
 618
 619         // Do not reconstruct anything in the holes
 620         if (detectorIndex[0]==13 || detectorIndex[0]==14 || detectorIndex[0]==15 ) { // sectors with holes
 621           if (detectorIndex[1]==2) { // plate with holes
 622             inholes++;
 623             continue;
 624           }
 625         }
 626
 627         tofRawDatum = 0;
 628       } // while loop
 629
 630       clonesRawData->Clear();
 631
 632     } // DDL Loop
 633
 634     //if (fVerbose==2) ftxt.close();
 635
 636     if (inholes) AliWarning(Form("Clusters in the TOF holes: %d",inholes));
 637     delete tofRawStream;
 638     tofRawStream = NULL;
 639
 640   }
 641
 642 }
 643
 644 //-----------------------------------------------------------------------------
 645 void AliTOFTrigger::GetLTMIndex(const Int_t * const detind, Int_t *indexLTM) {
 646   //
 647   // getting LTMmatrix indexes for current digit
 648   //
 649
 650   if (detind[1]==0 || detind[1]==1 || (detind[1]==2 && detind[2]<=7)) {
 651     if (detind[4]<24){
 652       indexLTM[0] = detind[0]*2;
 653     }
 654     else {
 655       indexLTM[0] = detind[0]*2+1;
 656     }
 657   }
 658   else {
 659     if (detind[4]<24){
 660       indexLTM[0] = detind[0]*2+36;
 661     }
 662     else {
 663       indexLTM[0] = (detind[0]*2+1)+36;
 664     }
 665   }
 666
 667   if (indexLTM[0]<36) {
 668     if (detind[1] ==0){
 669       indexLTM[1] = detind[2];
 670     }
 671     else if (detind[1] ==1){
 672       indexLTM[1] = detind[2]+19;
 673     }
 674     else if (detind[1] ==2){
 675       indexLTM[1] = detind[2]+19*2;
 676     }
 677     else{
 678       AliError("Smth Wrong!!!");
 679     }
 680   }
 681   else {
 682     if (detind[1] ==2){
 683       indexLTM[1] = detind[2]-8;
 684     }
 685     else if (detind[1] ==3){
 686       indexLTM[1] = detind[2]+7;
 687     }
 688     else if (detind[1] ==4){
 689       indexLTM[1] = detind[2]+26;
 690     }
 691     else{
 692       AliError("Smth Wrong!!!");
 693     }
 694   }
 695
 696 }
 697 //-------------------------------------------------------------------------
 698 /*
 699 // to be checked because of warning problems
 700 void AliTOFTrigger::PrintMap()
 701 {
 702   //
 703   //
 704   //
 705
 706   for(Int_t i = 0; i<kNLTM;i++) {
 707     if(i<36) {
 708       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",
 709              (fCTTMmatrixFront[i][0])?1:0,(fCTTMmatrixFront[i][1])?1:0,(fCTTMmatrixFront[i][2])?1:0, \
 710              (fCTTMmatrixFront[i][3])?1:0,(fCTTMmatrixFront[i][4])?1:0,(fCTTMmatrixFront[i][5])?1:0, \
 711              (fCTTMmatrixFront[i][6])?1:0,(fCTTMmatrixFront[i][7])?1:0,(fCTTMmatrixFront[i][8])?1:0, \
 712              (fCTTMmatrixFront[i][9])?1:0,(fCTTMmatrixFront[i][10])?1:0,(fCTTMmatrixFront[i][11])?1:0, \
 713              (fCTTMmatrixFront[i][12])?1:0,(fCTTMmatrixFront[i][13])?1:0,(fCTTMmatrixFront[i][14])?1:0, \
 714              (fCTTMmatrixFront[i][15])?1:0,(fCTTMmatrixFront[i][16])?1:0,(fCTTMmatrixFront[i][17])?1:0, \
 715              (fCTTMmatrixFront[i][18])?1:0,(fCTTMmatrixFront[i][19])?1:0,(fCTTMmatrixFront[i][20])?1:0, \
 716              (fCTTMmatrixFront[i][21])?1:0,(fCTTMmatrixFront[i][22])?1:0,(fCTTMmatrixFront[i][23])?1:0);
 717     } else {
 718       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",
 719              (fCTTMmatrixBack[i][0])?1:0,(fCTTMmatrixBack[i][1])?1:0,(fCTTMmatrixBack[i][2])?1:0, \
 720              (fCTTMmatrixBack[i][3])?1:0,(fCTTMmatrixBack[i][4])?1:0,(fCTTMmatrixBack[i][5])?1:0, \
 721              (fCTTMmatrixBack[i][6])?1:0,(fCTTMmatrixBack[i][7])?1:0,(fCTTMmatrixBack[i][8])?1:0, \
 722              (fCTTMmatrixBack[i][9])?1:0,(fCTTMmatrixBack[i][10])?1:0,(fCTTMmatrixBack[i][11])?1:0, \
 723              (fCTTMmatrixBack[i][12])?1:0,(fCTTMmatrixBack[i][13])?1:0,(fCTTMmatrixBack[i][14])?1:0, \
 724              (fCTTMmatrixBack[i][15])?1:0,(fCTTMmatrixBack[i][16])?1:0,(fCTTMmatrixBack[i][17])?1:0, \
 725              (fCTTMmatrixBack[i][18])?1:0,(fCTTMmatrixBack[i][19])?1:0,(fCTTMmatrixBack[i][20])?1:0, \
 726              (fCTTMmatrixBack[i][21])?1:0,(fCTTMmatrixBack[i][22])?1:0,(fCTTMmatrixBack[i][23])?1:0);
 727     }
 728   }
 729
 730 }
 731 */
 732 //-------------------------------------------------------------------------
 733
 734 void AliTOFTrigger::GetMapMatrix(Bool_t map[][24]) const
 735 {
 736   //
 737   // Returns CTTM map
 738   //
 739
 740   for(Int_t i = 0; i<kNLTM;i++)
 741     for(Int_t j = 0; j<kNCTTMchannels;j++)
 742       map[i][j]=(i<36)?fCTTMmatrixFront[i][j]:fCTTMmatrixBack[i-36][j];
 743
 744 }
 745 //-------------------------------------------------------------------------
 746
 747 void AliTOFTrigger::GetMap(Bool_t **map) const
 748 {
 749   //
 750   // Returns CTTM map
 751   //
 752
 753   for(Int_t i = 0; i<kNLTM;i++)
 754     for(Int_t j = 0; j<kNCTTMchannels;j++)
 755       map[i][j]=(i<36)?fCTTMmatrixFront[i][j]:fCTTMmatrixBack[i-36][j];
 756
 757 }
 758
 759
 760 //-------------------------------------------------------------------------
 761 void AliTOFTrigger::GetTRDmap(Bool_t **map) const
 762 {
 763   //
 764   // Retriev the bit map sent to the TRD detector
 765   //
 766
 767     for(int i = 0; i<kNLTM;i++)
 768         for(int j = 0; j<kNLTMtoTRDchannels;j++){
 769             map[i][j]=kFALSE;
 770         }
 771
 772     for(int i = 0; i<kNLTM/2;i++)
 773     for(int j = 0; j<AliTOFTrigger::kNCTTMchannels;j++){
 774         UInt_t uTRDbit=j/3;
 775         if(fCTTMmatrixFront[i][j]) map[i][uTRDbit]=kTRUE;
 776     }
 777   for(int i = kNLTM/2; i<kNLTM;i++)
 778       for(int j = 0; j<AliTOFTrigger::kNCTTMchannels;j++){
 779           UInt_t uTRDbit=j/3;
 780           if(fCTTMmatrixBack[i-kNLTM/2][j]) map[i][uTRDbit]=kTRUE;
 781     }
 782
 783 }
 784 //-------------------------------------------------------------------------
 785 void AliTOFTrigger::GetTRDmapMatrix(Bool_t map[][8]) const
 786 {
 787   //
 788   // Retriev the bit map sent to the TRD detector
 789   //
 790
 791     for(int i = 0; i<kNLTM;i++)
 792         for(int j = 0; j<kNLTMtoTRDchannels;j++){
 793             map[i][j]=kFALSE;
 794         }
 795
 796     for(int i = 0; i<kNLTM/2;i++)
 797     for(int j = 0; j<AliTOFTrigger::kNCTTMchannels;j++){
 798         UInt_t uTRDbit=j/3;
 799         if(fCTTMmatrixFront[i][j]) map[i][uTRDbit]=kTRUE;
 800     }
 801   for(int i = kNLTM/2; i<kNLTM;i++)
 802       for(int j = 0; j<AliTOFTrigger::kNCTTMchannels;j++){
 803           UInt_t uTRDbit=j/3;
 804           if(fCTTMmatrixBack[i-kNLTM/2][j]) map[i][uTRDbit]=kTRUE;
 805     }
 806
 807 }
 808
 809 //-------------------------------------------------------------------------
 810 void AliTOFTrigger::SetBit(Int_t *detind)
 811 {
 812   //
 813   // Sets CTTM map element corresponding to detector element 'detind'
 814   //
 815
 816   Int_t index[2];
 817   GetCTTMIndex(detind,index);
 818   if(index[0]<36)
 819     fCTTMmatrixFront[index[0]][index[1]]=kTRUE;
 820   else
 821     fCTTMmatrixBack[index[0]-36][index[1]]=kTRUE;
 822
 823 }
 824
 825 //-------------------------------------------------------------------------
 826 void AliTOFTrigger::SetBit(Int_t nDDL, Int_t nTRM, Int_t iChain,
 827                            Int_t iTDC, Int_t iCH)
 828 {
 829   //
 830   // Sets CTTM map element corresponding to equipment ID
 831   // labelled by number nDDL, nTRM, iChain, iTDC, iCH
 832   //
 833
 834     if(nTRM==3 && iTDC>=12 && iTDC<=14 && nDDL%2==1){ // DDL number to LTM number mapping
 835 //       getchar();
 836     Int_t iLTMindex=-1;
 837     Int_t iChannelIndex=-1;
 838     switch(nDDL%AliTOFGeometry::NDDL()){
 839     case 1:
 840       iLTMindex=1;
 841       break;
 842     case 3:
 843       iLTMindex=36;
 844       break;
 845     default:
 846       AliError("Call this function only if(nTRM==3 && iTDC>12 && iTDC<14 && nDDL%2==1) ");
 847       break;
 848     }
 849     iLTMindex+=2*(Int_t)(nDDL/AliTOFGeometry::NDDL());
 850     if(iChain==0 && nDDL<36)
 851       iLTMindex--;
 852     if(iChain==0 && nDDL>=36)
 853       iLTMindex++;
 854     iChannelIndex=iCH+iTDC*AliTOFGeometry::NCh()-12*AliTOFGeometry::NCh();
 855     Int_t index[2]={iLTMindex,iChannelIndex};
 856     if (index[0]<36){
 857       fCTTMmatrixFront[index[0]][index[1]]=kTRUE;
 858       fLTMmatrix[index[0]][index[1]*2]=kTRUE;
 859     }
 860     else{
 861         fCTTMmatrixBack[index[0]-36][index[1]]=kTRUE;
 862         fLTMmatrix[index[0]][index[1]*2]=kTRUE;
 863     }
 864     }
 865
 866 }
 867 //-------------------------------------------------------------------------
 868
 869 void AliTOFTrigger::ResetBit(Int_t *detind)
 870 {
 871   //
 872   // Sets CTTM map element corresponding to detector element 'detind'
 873   //
 874
 875   Int_t index[2];
 876   GetCTTMIndex(detind,index);
 877   if(index[0]<36)
 878     fCTTMmatrixFront[index[0]][index[1]]=kFALSE;
 879   else
 880     fCTTMmatrixBack[index[0]-36][index[1]]=kFALSE;
 881
 882 }
 883
 884 //-------------------------------------------------------------------------
 885 void AliTOFTrigger::ResetBit(Int_t nDDL, Int_t nTRM, Int_t iChain,
 886                              Int_t iTDC, Int_t iCH)
 887 {
 888   //
 889   // Sets CTTM map element corresponding to equipment ID
 890   // labelled by number nDDL, nTRM, iChain, iTDC, iCH
 891   //
 892
 893   if(nTRM==3 && iTDC>12 && iTDC<14 && nDDL%2==1){ // DDL number to LTM number mapping
 894     Int_t iLTMindex=-1;
 895     Int_t iChannelIndex=-1;
 896     switch(nDDL%AliTOFGeometry::NDDL()){
 897     case 1:
 898       iLTMindex=1;
 899       break;
 900     case 3:
 901       iLTMindex=36;
 902       break;
 903     default:
 904       AliError("Call this function only if(nTRM==3 && iTDC>12 && iTDC<14 && nDDL%2==1) ");
 905       break;
 906     }
 907     iLTMindex+=2*(Int_t)(nDDL/AliTOFGeometry::NDDL());
 908     if(iChain==0 && nDDL<36)
 909       iLTMindex--;
 910     if(iChain==0 && nDDL>=36)
 911       iLTMindex++;
 912     iChannelIndex=iCH+iTDC*AliTOFGeometry::NCh()-12*AliTOFGeometry::NCh();
 913     Int_t index[2]={iLTMindex,iChannelIndex};
 914     if (index[0]<36){
 915       fCTTMmatrixFront[index[0]][index[1]]=kFALSE;
 916     }
 917     else{
 918       fCTTMmatrixBack[index[0]-36][index[1]]=kFALSE;
 919     }
 920   }
 921   else
 922     AliError("Call this function only if(nTRM==3 && iTDC>12 && iTDC<14 && nDDL%2==1) ");
 923
 924 }
 925 //-------------------------------------------------------------------------
 926
 927 Bool_t AliTOFTrigger::GetBit(Int_t *detind)
 928 {
 929   //
 930   // Returns CTTM map element corresponding to detector element 'detind'
 931   //
 932
 933   Int_t index[2];
 934   GetCTTMIndex(detind,index);
 935   return (index[0]<36)?fCTTMmatrixFront[index[0]][index[1]]:fCTTMmatrixBack[index[0]-36][index[1]];
 936
 937 }
 938
 939 //-------------------------------------------------------------------------
 940 Bool_t AliTOFTrigger::GetBit(Int_t nDDL, Int_t nTRM, Int_t iChain,
 941                              Int_t iTDC, Int_t iCH)
 942 {
 943   //
 944   // Returns CTTM map element corresponding to equipment ID
 945   // labelled by number nDDL, nTRM, iChain, iTDC, iCH
 946   //
 947
 948   if ( !(nTRM==3 && iTDC>12 && iTDC<14 && nDDL%2==1) ) {
 949     AliWarning("Call this function only if(nTRM==3 && iTDC>12 && iTDC<14) ");
 950     return kFALSE;
 951   }
 952   //if (nTRM==3 && iTDC>12 && iTDC<14 && nDDL%2==1) { // DDL number to LTM number mapping
 953
 954   UInt_t iLTMindex=0;
 955   UInt_t iChannelindex=0;
 956   switch(nDDL%AliTOFGeometry::NDDL()) {
 957   case 1:
 958     iLTMindex=1;
 959     break;
 960   case 3:
 961     iLTMindex=36;
 962     break;
 963   default:
 964     AliError("something wrong");
 965     break;
 966   }
 967   iLTMindex+=2*(Int_t)(nDDL/AliTOFGeometry::NDDL());
 968
 969   if (iChain==1) return kFALSE; // AdC
 970
 971   if (nDDL<36)
 972     iLTMindex--;
 973   if (nDDL>=36)
 974     iLTMindex++;
 975   iChannelindex=iCH+iTDC*AliTOFGeometry::NCh()-12*AliTOFGeometry::NCh();
 976   Int_t index[2]={iLTMindex,iChannelindex};
 977   return (index[0]<36)?fCTTMmatrixFront[index[0]][index[1]]:fCTTMmatrixBack[index[0]-36][index[1]];
 978
 979 }
 980
 981 //-------------------------------------------------------------------------
 982
 983 void AliTOFTrigger::CreateCTTMMatrix() {
 984   //
 985   // Create CTTM bit map
 986   //
 987     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,
 988                                   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};
 989
 990
 991     fNMaxipadOnAll=0;
 992     fNMaxipadOn=0;
 993
 994     for(Int_t i = 0; i<kNLTM;i++){
 995         UInt_t currentMask = fPowerMask[kNCTTMchannels]-1;
 996         if(fTOFTrigMask) currentMask=fTOFTrigMask->GetTriggerMask(fromTriggertoDCS[i]);
 997         if(i<kNCTTM){
 998             for(Int_t j = 0; j<kNCTTMchannels;j++){
 999                 fCTTMmatrixFront[i][j]=fLTMmatrix[i][2*j]||fLTMmatrix[i][2*j+1];
1000                 if(fCTTMmatrixFront[i][j]) fNMaxipadOnAll++;
1001                 if(!(currentMask & fPowerMask[j])) fCTTMmatrixFront[i][j]=0;
1002                 if(fCTTMmatrixFront[i][j]){
1003                     fNMaxipadOn++;
1004                     fLTMarray[i] = kTRUE;
1005                 }
1006             }
1007         }
1008         else{
1009             for(Int_t j = 0; j<kNCTTMchannels;j++){
1010                 fCTTMmatrixBack[i-kNCTTM][j]=fLTMmatrix[i][2*j]||fLTMmatrix[i][2*j+1];;
1011                 if(fCTTMmatrixBack[i-kNCTTM][j]) fNMaxipadOnAll++;
1012                 if(!(currentMask & fPowerMask[j])) fCTTMmatrixBack[i-kNCTTM][j]=0;
1013                 if(fCTTMmatrixBack[i-kNCTTM][j]){
1014                     fNMaxipadOn++;
1015                     fLTMarray[i-kNCTTM] = kTRUE;
1016                 }
1017             }
1018         }
1019     }
1020
1021     fNCrateOn = 0;
1022     for(Int_t j=0; j < kNCTTM; j++) {if(fLTMarray[j]) fNCrateOn++;}
1023
1024 }
1025 //-----------------------------------------------------------------------------
1026
1027 void AliTOFTrigger::GetCTTMIndex(Int_t *detind, Int_t *indexCTTM) {
1028   //
1029   // Returns CTTM index corresponding to the detector element detind
1030   //
1031
1032   GetLTMIndex(detind,indexCTTM);
1033   indexCTTM[1]/=2;
1034
1035 }
1036 //-----------------------------------------------------------------------------
1037 void AliTOFTrigger::LoadActiveMask(){
1038 //
1039 // Load OCDB current mask
1040 //
1041
1042     AliCDBManager *cdb = AliCDBManager::Instance();
1043     if(cdb->GetRun() < 0 || !(cdb->GetDefaultStorage())){
1044         if(!(cdb->GetDefaultStorage())){
1045             cdb->SetDefaultStorage("local://$ALICE_ROOT/OCDB");
1046             printf("AliTOFTrigger (WARNING): probably CDB first instance - Default Sorage set to \"local://$ALICE_ROOT/OCDB\"\n");
1047         }
1048         if(cdb->GetRun() < 0){
1049             cdb->SetRun(0);
1050          printf("AliTOFTrigger (WARNING): probably CDB first instance - number of run set to 0\n");
1051         }
1052     }
1053
1054     AliCDBEntry *cdbe = cdb->Get("TRIGGER/TOF/TriggerMask");
1055     if(!cdbe) return;
1056     fTOFTrigMask= (AliTOFTriggerMask *)cdbe->GetObject();
1057
1058 //     UInt_t maskArray[kNLTM];
1059 //     if(fTOFTrigMask == NULL) fTOFTrigMask = new AliTOFTriggerMask();
1060 //     for (Int_t k = 0; k < kNLTM ; k++) maskArray[k] = fPowerMask[kNCTTMchannels]-1;
1061 //     //for (Int_t k = 0; k < kNLTM ; k+=2) maskArray[k] = 0;
1062
1063 //     fTOFTrigMask->SetTriggerMaskArray(maskArray);
1064 }
1065
1066
1067 //-----------------------------------------------------------------------------
1068 AliTOFTrigger::~AliTOFTrigger()
1069 {
1070   // dtor
1071
1072 }
1073
1074 //-----------------------------------------------------------------------------
1075 AliTOFTrigger& AliTOFTrigger::operator=(const AliTOFTrigger &/*source*/)
1076 {
1077   // ass. op.
1078   return *this;
1079
1080 }
1081