free arrays before of return in PropagateBack
[u/mrichter/AliRoot.git] / 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