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