1 /**************************************************************************
2 * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
4 * Author: The ALICE Off-line Project. *
5 * Contributors are mentioned in the code where appropriate. *
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 **************************************************************************/
18 /////////////////////////////////////////////////////////////////////
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)
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
32 /////////////////////////////////////////////////////////////////////
34 #include <TClonesArray.h>
38 #include "AliLoader.h"
40 #include "AliRunLoader.h"
42 #include "AliTriggerInput.h"
43 #include "AliRawReader.h"
45 #include "AliTOFRawStream.h"
46 #include "AliTOFrawData.h"
47 #include "AliTOFdigit.h"
48 #include "AliTOFGeometry.h"
49 #include "AliTOFTrigger.h"
50 #include "AliTOFTriggerMask.h"
52 #include "AliCDBManager.h"
53 #include "AliCDBEntry.h"
56 extern AliRun* gAlice;
58 AliTOFTriggerMask* AliTOFTrigger:: fTOFTrigMap=NULL;
59 AliTOFTriggerMask* AliTOFTrigger:: fTOFTrigMask=NULL;
60 //-------------------------------------------------------------------------
61 ClassImp(AliTOFTrigger)
63 //----------------------------------------------------------------------
64 AliTOFTrigger::AliTOFTrigger() :
67 fppMBTh(4),//4:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
70 fdeltaminpsi(150), //150
71 fdeltamaxpsi(170), //170
83 fTimeWidthTrigger(25.0)
87 for (Int_t i=0;i<kNCTTM;i++) fLTMarray[i] = kFALSE;
89 for (Int_t i=0;i<kNLTM;i++){
91 for (Int_t j=0;j<kNLTMchannels;j++){
92 fLTMmatrix[i][j]=kFALSE;
95 for (Int_t j=0;j<kNCTTMchannels;j++){
96 fCTTMmatrixFront[i][j]=kFALSE;
97 fCTTMmatrixBack[i][j]=kFALSE;
103 for(Int_t i=1;i <= kNCTTMchannels;i++){
104 fPowerMask[i] = fPowerMask[i-1]*2;
110 if(!fTOFTrigMap) fTOFTrigMap = new AliTOFTriggerMask();
114 //----------------------------------------------------------------------
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),
120 fMultiMuonTh(MultiMuonTh),
122 fdeltaminpsi(deltaminpsi),
123 fdeltamaxpsi(deltamaxpsi),
124 fdeltaminro(deltaminro),
125 fdeltamaxro(deltamaxro),
126 fstripWindow(stripWindow),
134 fStartTimeHit(startTimeWindow),
135 fTimeWidthTrigger(widthTimeWindow)
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;
144 for (Int_t j=0;j<kNCTTMchannels;j++){
145 fCTTMmatrixFront[i][j]=kFALSE;
146 fCTTMmatrixBack[i][j]=kFALSE;
152 for(Int_t i=1;i <= kNCTTMchannels;i++){
153 fPowerMask[i] = fPowerMask[i-1]*2;
159 if(!fTOFTrigMap) fTOFTrigMap = new AliTOFTriggerMask();
163 #if 0 /*** COPY CONSTRUCTOR SUPPRESSED **/
164 //____________________________________________________________________________
166 AliTOFTrigger::AliTOFTrigger(const AliTOFTrigger & tr):
167 AliTriggerDetector(tr),
168 fHighMultTh(tr.fHighMultTh),
170 fMultiMuonTh(tr.fMultiMuonTh),
172 fdeltaminpsi(tr.fdeltaminpsi),
173 fdeltamaxpsi(tr.fdeltamaxpsi),
174 fdeltaminro(tr.fdeltaminro),
175 fdeltamaxro(tr.fdeltamaxro),
176 fstripWindow(tr.fstripWindow),
181 fNCrateOn(tr.fNCrateOn),
182 fNMaxipadOn(tr.fNMaxipadOn),
183 fNMaxipadOnAll(tr.fNMaxipadOnAll)
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];
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];
200 for(Int_t i=1;i <= kNCTTMchannels;i++){
201 fPowerMask[i] = fPowerMask[i-1]*2;
204 SetName(tr.GetName());
205 //fInputs=&(tr.GetInputs());
209 #endif /*** COPY CONTRUCTOR SUPPRESSED ***/
211 //----------------------------------------------------------------------
213 void AliTOFTrigger::CreateInputs()
216 // Do not create inputs again!!
217 if( fInputs.GetEntriesFast() > 0 ) return;
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
228 fInputs.AddLast(new AliTriggerInput("0OHM","TOF",0)); // was "TOF_High_Mult_L0"
229 fInputs.AddLast(new AliTriggerInput("TOF_Jet_L1","TOF",0));
233 //----------------------------------------------------------------------
234 void AliTOFTrigger::Trigger() {
235 fTOFTrigMap->ResetMask();
236 if(!fTOFTrigMask) LoadActiveMask();
246 Int_t nchonFront = 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;
261 for (Int_t i=0;i<kNCTTM;i++){
262 for (Int_t j=0;j<kNCTTMchannels;j++){
263 if (fCTTMmatrixFront[i][j]){
265 fTOFTrigMap->SetON(i,j);
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]){
274 fTOFTrigMap->SetON(i,j);
279 nchonTot = nchonFront + nchonBack;
280 // fNMaxipadOn = nchonTot;
281 for(Int_t i=0;i<kNCTTM;i++) { if(fLTMarray[i]) nSectOn++; }
283 //pp Minimum Bias Trigger
284 if (nchonTot >= fppMBTh) {
287 //printf("0OIN - MB\n");
300 //High Multiplicity Trigger
301 if (nchonTot >= fHighMultTh) {
303 //printf("0OHM - High Mult\n");
312 Bool_t boolCTTMor = kFALSE;
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;
321 if (maxj>=kNCTTMchannels) maxj = kNCTTMchannels-1;
323 for (Int_t k = minj;k<=maxj;k++){
324 boolCTTMor |= fCTTMmatrixFront[iopp][k];
331 if (fCTTMmatrixBack[i][j]){
332 Int_t minj = j-fstripWindow;
333 Int_t maxj = j+fstripWindow;
335 if (maxj>=kNCTTMchannels) maxj =kNCTTMchannels-1;
337 for (Int_t k = minj;k<=maxj;k++){
338 boolCTTMor |= fCTTMmatrixBack[iopp][k];
347 nchonFrontBack = nchonFront+nchonBack;
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]){
366 for (Int_t i2=i2min;i2<=i2max;i2++){
367 for (Int_t j2 = j2min;j2<=j2max;j2++){
368 boolCTTMor |= fCTTMmatrixFront[i2][j2];
375 if (fCTTMmatrixBack[i][j]){
377 for (Int_t i2=i2min;i2<=i2max;i2++){
378 for (Int_t j2 = j2min;j2<=j2max;j2++){
379 boolCTTMor |= fCTTMmatrixBack[i2][j2];
389 nchonFrontBack1 = nchonFront1+nchonBack1;
391 if (nchonFrontBack >= fMultiMuonTh || nchonFrontBack1 >= fMultiMuonTh) {
392 SetInput("TOF_Cosmic_MultiMuon_L0");
395 //Ultra-Peripheral collision Trigger
397 // °°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°
398 // DeSlots = (k+1)_Array Element - k_Array Element
399 // AntiDeSlots = kNCTTM - DeSlots
401 if((!fSel1))// && nchonFront < 4 && nchonBack < 4)
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++){
409 // printf(" i-sect On: %i\n",i);
410 for(Int_t j = i+1; j < kNCTTM; j++){
412 // printf(" j-sect On: %i\n",j);
414 AntiDeSlots = kNCTTM - DeSlots;
415 //printf("DeSlots = %i \n",DeSlots);
416 //printf("AntiDeSlots = %i \n",AntiDeSlots);
417 if(DeSlots >= mindeltapsi && DeSlots <= maxdeltapsi){
420 //printf("trigger On with DeSlot \n");
422 if(AntiDeSlots >= mindeltapsi && AntiDeSlots <= maxdeltapsi){
425 //printf("trigger On with AntiDeSlot \n");
429 if(DeSlots >= mindeltaro && DeSlots <= maxdeltaro){
432 //printf("trigger On with DeSlot \n");
434 if(AntiDeSlots >= mindeltaro && AntiDeSlots <= maxdeltaro){
437 //printf("trigger On with AntiDeSlot \n");
440 if(nchonTot >= 2 && nchonTot <= 6){
441 if(DeSlots >= 15 && DeSlots <= 18){
444 else if(AntiDeSlots >= 15 && AntiDeSlots <= 18){
455 //-----------------------------------------------------------------------------
456 void AliTOFTrigger::CreateLTMMatrix() {
459 CreateLTMMatrixFromDigits();
463 //-------------------------------------------------------------------------
465 void AliTOFTrigger::CreateLTMMatrixFromDigits() {
467 // Create LTM matrix by TOF digits
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;
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;
486 rl = AliRunLoader::Instance();
488 Int_t ncurrevent = rl->GetEventNumber();
489 rl->GetEvent(ncurrevent);
491 AliLoader * tofLoader = rl->GetLoader("TOFLoader");
493 tofLoader->LoadDigits("read");
494 TTree *treeD = tofLoader->TreeD();
496 AliFatal("AliTOFTrigger: Can not get TreeD");
500 TBranch *branch = treeD->GetBranch("TOF");
502 AliError("can't get the branch with the TOF digits !");
505 TClonesArray *tofDigits =new TClonesArray("AliTOFdigit", 1000);
506 branch->SetAddress(&tofDigits);
508 Int_t ndigits = tofDigits->GetEntriesFast();
509 Int_t detind[5]; //detector indexes: 0 -> sector
510 // 1 -> plate(modulo)
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();
523 Int_t indexLTM[2] = {-1,-1};
524 GetLTMIndex(detind,indexLTM);
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
530 AliTOFGeometry::GetPosPar(detind, pos);
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
536 if(timedigit > fStartTimeHit - 0.5 && timedigit < fStartTimeHit + fTimeWidthTrigger - 0.5)
537 fLTMmatrix[indexLTM[0]][indexLTM[1]] = kTRUE;
539 // fLTMarray[indexLTM[0]%36] = kTRUE; //dimensione MAX array 36 = kNCTTM
543 tofLoader->UnloadDigits();
544 // rl->UnloadgAlice();
548 //-----------------------------------------------------------------------------
550 void AliTOFTrigger::CreateLTMMatrixFromRaw(AliRawReader *fRawReader) {
552 // Create LTM matrix by TOF raw data
554 fTOFTrigMap->ResetMask();
557 for (Int_t i=0;i<kNLTM;i++){
558 for (Int_t j=0;j<kNLTMchannels;j++){
559 fLTMmatrix[i][j]=kFALSE;
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;
570 AliTOFRawStream * tofRawStream = new AliTOFRawStream();
574 //if(!GetLoader()->TreeS()) {MakeTree("S"); MakeBranch("S");}
577 tofRawStream->SetRawReader(fRawReader);
580 //if (fVerbose==2) ftxt.open("TOFsdigitsRead.txt",ios::app);
582 TClonesArray staticRawData("AliTOFrawData",10000);
583 staticRawData.Clear();
584 TClonesArray * clonesRawData = &staticRawData;
587 Int_t detectorIndex[5] = {-1, -1, -1, -1, -1};
594 AliTOFrawData *tofRawDatum = 0;
595 for (indexDDL=0; indexDDL<AliDAQ::NumberOfDdls("TOF"); indexDDL++) {
598 tofRawStream->LoadRawDataBuffersV2(indexDDL);
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++) {
604 tofRawDatum = (AliTOFrawData*)clonesRawData->UncheckedAt(iRawData);
606 //if (tofRawDatum->GetTOT()==-1 || tofRawDatum->GetTOF()==-1) continue;
607 if (tofRawDatum->GetTOF()==-1) continue;
609 SetBit(indexDDL, tofRawDatum->GetTRM(), tofRawDatum->GetTRMchain(),
610 tofRawDatum->GetTDC(), tofRawDatum->GetTDCchannel());
612 dummy = detectorIndex[3];
613 detectorIndex[3] = detectorIndex[4];//padz
614 detectorIndex[4] = dummy;//padx
616 digit[0] = tofRawDatum->GetTOF();
617 digit[1] = tofRawDatum->GetTOT();
619 dummy = detectorIndex[3];
620 detectorIndex[3] = detectorIndex[4];//padx
621 detectorIndex[4] = dummy;//padz
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
634 clonesRawData->Clear();
638 //if (fVerbose==2) ftxt.close();
640 if (inholes) AliWarning(Form("Clusters in the TOF holes: %d",inholes));
647 //-----------------------------------------------------------------------------
648 void AliTOFTrigger::PrepareTOFMapFromRaw(AliRawReader *fRawReader,Int_t deltaBC) {
650 // Create LTM matrix by TOF raw data
652 if(!fTOFTrigMap) fTOFTrigMap = new AliTOFTriggerMask();
653 fTOFTrigMap->ResetMask();
657 AliTOFRawStream * tofRawStream = new AliTOFRawStream();
659 tofRawStream->SetRawReader(fRawReader);
661 TClonesArray staticRawData("AliTOFrawData",10000);
662 staticRawData.Clear();
663 TClonesArray * clonesRawData = &staticRawData;
667 AliTOFrawData *tofRawDatum = 0;
668 for (indexDDL=0; indexDDL<AliDAQ::NumberOfDdls("TOF"); indexDDL++) {
671 tofRawStream->LoadRawDataBuffersV2(indexDDL);
673 clonesRawData = tofRawStream->GetRawData();
674 for (iRawData = 0; iRawData<clonesRawData->GetEntriesFast(); iRawData++) {
676 tofRawDatum = (AliTOFrawData*)clonesRawData->UncheckedAt(iRawData);
678 //if (tofRawDatum->GetTOT()==-1 || tofRawDatum->GetTOF()==-1) continue;
679 if (tofRawDatum->GetTOF()==-1) continue;
681 Int_t nTRM = tofRawDatum->GetTRM();
682 Int_t iChain = tofRawDatum->GetTRMchain();
683 Int_t iTDC = tofRawDatum->GetTDC();
684 Int_t iCH=tofRawDatum->GetTDCchannel();
686 if(nTRM==3 && iTDC>=12 && iTDC<=14 && indexDDL%2==1){ // DDL number to LTM number mapping
688 Int_t iChannelIndex=-1;
689 switch(indexDDL%AliTOFGeometry::NDDL()){
699 iLTMindex+=2*(Int_t)(indexDDL/AliTOFGeometry::NDDL());
700 if(iChain==0 && indexDDL<36)
702 if(iChain==0 && indexDDL>=36)
704 iChannelIndex=iCH+iTDC*AliTOFGeometry::NCh()-12*AliTOFGeometry::NCh();
705 Int_t index[2]={iLTMindex,iChannelIndex};
708 if(fTOFTrigMask->IsON(index[0],index[1]) && TMath::Abs(tofRawDatum->GetTOF()-deltaBC) < 400) fTOFTrigMap->SetON(index[0],index[1]);
714 clonesRawData->Clear();
725 //-----------------------------------------------------------------------------
726 void AliTOFTrigger::PrepareTOFMapFromDigit(TTree *treeD) {
727 if(!fTOFTrigMap) fTOFTrigMap = new AliTOFTriggerMask();
730 fTOFTrigMap->ResetMask();
735 TBranch *branch = treeD->GetBranch("TOF");
739 TClonesArray *tofDigits =new TClonesArray("AliTOFdigit", 1000);
740 branch->SetAddress(&tofDigits);
742 Int_t ndigits = tofDigits->GetEntriesFast();
743 Int_t detind[5]; //detector indexes: 0 -> sector
744 // 1 -> plate(modulo)
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();
757 Int_t indexLTM[2] = {-1,-1};
758 GetLTMIndex(detind,indexLTM);
760 if(fTOFTrigMask->IsON(indexLTM[0],indexLTM[1])) fTOFTrigMap->SetON(indexLTM[0],indexLTM[1]);
764 //-----------------------------------------------------------------------------
765 void AliTOFTrigger::GetLTMIndex(const Int_t * const detind, Int_t *indexLTM) {
767 // getting LTMmatrix indexes for current digit
770 if (detind[1]==0 || detind[1]==1 || (detind[1]==2 && detind[2]<=7)) {
772 indexLTM[0] = detind[0]*2;
775 indexLTM[0] = detind[0]*2+1;
780 indexLTM[0] = detind[0]*2+36;
783 indexLTM[0] = (detind[0]*2+1)+36;
787 if (indexLTM[0]<36) {
789 indexLTM[1] = detind[2];
791 else if (detind[1] ==1){
792 indexLTM[1] = detind[2]+19;
794 else if (detind[1] ==2){
795 indexLTM[1] = detind[2]+19*2;
798 // AliError("Smth Wrong!!!");
803 indexLTM[1] = detind[2]-8;
805 else if (detind[1] ==3){
806 indexLTM[1] = detind[2]+7;
808 else if (detind[1] ==4){
809 indexLTM[1] = detind[2]+26;
812 // AliError("Smth Wrong!!!");
817 //-------------------------------------------------------------------------
819 // to be checked because of warning problems
820 void AliTOFTrigger::PrintMap()
826 for(Int_t i = 0; i<kNLTM;i++) {
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);
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);
852 //-------------------------------------------------------------------------
854 void AliTOFTrigger::GetMapMatrix(Bool_t map[][24]) const
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];
865 //-------------------------------------------------------------------------
867 void AliTOFTrigger::GetMap(Bool_t **map) const
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];
880 //-------------------------------------------------------------------------
881 void AliTOFTrigger::GetTRDmap(Bool_t **map) const
884 // Retriev the bit map sent to the TRD detector
887 for(int i = 0; i<kNLTM;i++)
888 for(int j = 0; j<kNLTMtoTRDchannels;j++){
892 for(int i = 0; i<kNLTM/2;i++)
893 for(int j = 0; j<AliTOFTrigger::kNCTTMchannels;j++){
895 if(fCTTMmatrixFront[i][j]) map[i][uTRDbit]=kTRUE;
897 for(int i = kNLTM/2; i<kNLTM;i++)
898 for(int j = 0; j<AliTOFTrigger::kNCTTMchannels;j++){
900 if(fCTTMmatrixBack[i-kNLTM/2][j]) map[i][uTRDbit]=kTRUE;
904 //-------------------------------------------------------------------------
905 void AliTOFTrigger::GetTRDmapMatrix(Bool_t map[][8]) const
908 // Retriev the bit map sent to the TRD detector
911 for(int i = 0; i<kNLTM;i++)
912 for(int j = 0; j<kNLTMtoTRDchannels;j++){
916 for(int i = 0; i<kNLTM/2;i++)
917 for(int j = 0; j<AliTOFTrigger::kNCTTMchannels;j++){
919 if(fCTTMmatrixFront[i][j]) map[i][uTRDbit]=kTRUE;
921 for(int i = kNLTM/2; i<kNLTM;i++)
922 for(int j = 0; j<AliTOFTrigger::kNCTTMchannels;j++){
924 if(fCTTMmatrixBack[i-kNLTM/2][j]) map[i][uTRDbit]=kTRUE;
929 //-------------------------------------------------------------------------
930 void AliTOFTrigger::SetBit(Int_t *detind)
933 // Sets CTTM map element corresponding to detector element 'detind'
937 GetCTTMIndex(detind,index);
939 fCTTMmatrixFront[index[0]][index[1]]=kTRUE;
941 fCTTMmatrixBack[index[0]-36][index[1]]=kTRUE;
945 //-------------------------------------------------------------------------
946 void AliTOFTrigger::SetBit(Int_t nDDL, Int_t nTRM, Int_t iChain,
947 Int_t iTDC, Int_t iCH)
950 // Sets CTTM map element corresponding to equipment ID
951 // labelled by number nDDL, nTRM, iChain, iTDC, iCH
954 if(nTRM==3 && iTDC>=12 && iTDC<=14 && nDDL%2==1){ // DDL number to LTM number mapping
957 Int_t iChannelIndex=-1;
958 switch(nDDL%AliTOFGeometry::NDDL()){
966 AliError("Call this function only if(nTRM==3 && iTDC>12 && iTDC<14 && nDDL%2==1) ");
969 iLTMindex+=2*(Int_t)(nDDL/AliTOFGeometry::NDDL());
970 if(iChain==0 && nDDL<36)
972 if(iChain==0 && nDDL>=36)
974 iChannelIndex=iCH+iTDC*AliTOFGeometry::NCh()-12*AliTOFGeometry::NCh();
975 Int_t index[2]={iLTMindex,iChannelIndex};
977 fCTTMmatrixFront[index[0]][index[1]]=kTRUE;
978 fLTMmatrix[index[0]][index[1]*2]=kTRUE;
981 fCTTMmatrixBack[index[0]-36][index[1]]=kTRUE;
982 fLTMmatrix[index[0]][index[1]*2]=kTRUE;
987 //-------------------------------------------------------------------------
989 void AliTOFTrigger::ResetBit(Int_t *detind)
992 // Sets CTTM map element corresponding to detector element 'detind'
996 GetCTTMIndex(detind,index);
998 fCTTMmatrixFront[index[0]][index[1]]=kFALSE;
1000 fCTTMmatrixBack[index[0]-36][index[1]]=kFALSE;
1004 //-------------------------------------------------------------------------
1005 void AliTOFTrigger::ResetBit(Int_t nDDL, Int_t nTRM, Int_t iChain,
1006 Int_t iTDC, Int_t iCH)
1009 // Sets CTTM map element corresponding to equipment ID
1010 // labelled by number nDDL, nTRM, iChain, iTDC, iCH
1013 if(nTRM==3 && iTDC>12 && iTDC<14 && nDDL%2==1){ // DDL number to LTM number mapping
1015 Int_t iChannelIndex=-1;
1016 switch(nDDL%AliTOFGeometry::NDDL()){
1024 AliError("Call this function only if(nTRM==3 && iTDC>12 && iTDC<14 && nDDL%2==1) ");
1027 iLTMindex+=2*(Int_t)(nDDL/AliTOFGeometry::NDDL());
1028 if(iChain==0 && nDDL<36)
1030 if(iChain==0 && nDDL>=36)
1032 iChannelIndex=iCH+iTDC*AliTOFGeometry::NCh()-12*AliTOFGeometry::NCh();
1033 Int_t index[2]={iLTMindex,iChannelIndex};
1035 fCTTMmatrixFront[index[0]][index[1]]=kFALSE;
1038 fCTTMmatrixBack[index[0]-36][index[1]]=kFALSE;
1042 AliError("Call this function only if(nTRM==3 && iTDC>12 && iTDC<14 && nDDL%2==1) ");
1045 //-------------------------------------------------------------------------
1047 Bool_t AliTOFTrigger::GetBit(Int_t *detind)
1050 // Returns CTTM map element corresponding to detector element 'detind'
1054 GetCTTMIndex(detind,index);
1055 return (index[0]<36)?fCTTMmatrixFront[index[0]][index[1]]:fCTTMmatrixBack[index[0]-36][index[1]];
1059 //-------------------------------------------------------------------------
1060 Bool_t AliTOFTrigger::GetBit(Int_t nDDL, Int_t nTRM, Int_t iChain,
1061 Int_t iTDC, Int_t iCH)
1064 // Returns CTTM map element corresponding to equipment ID
1065 // labelled by number nDDL, nTRM, iChain, iTDC, iCH
1068 if ( !(nTRM==3 && iTDC>12 && iTDC<14 && nDDL%2==1) ) {
1069 AliWarning("Call this function only if(nTRM==3 && iTDC>12 && iTDC<14) ");
1072 //if (nTRM==3 && iTDC>12 && iTDC<14 && nDDL%2==1) { // DDL number to LTM number mapping
1075 UInt_t iChannelindex=0;
1076 switch(nDDL%AliTOFGeometry::NDDL()) {
1084 AliError("something wrong");
1087 iLTMindex+=2*(Int_t)(nDDL/AliTOFGeometry::NDDL());
1089 if (iChain==1) return kFALSE; // AdC
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]];
1101 //-------------------------------------------------------------------------
1103 void AliTOFTrigger::CreateCTTMMatrix() {
1105 // Create CTTM bit map
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};
1117 for(Int_t i = 0; i<kNLTM;i++){
1118 UInt_t currentMask = fPowerMask[kNCTTMchannels]-1;
1119 if(fTOFTrigMask) currentMask=fTOFTrigMask->GetTriggerMask(fromTriggertoDCS[i]);
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]){
1127 fLTMarray[i] = kTRUE;
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]){
1138 fLTMarray[i-kNCTTM] = kTRUE;
1145 for(Int_t j=0; j < kNCTTM; j++) {if(fLTMarray[j]) fNCrateOn++;}
1148 //-----------------------------------------------------------------------------
1150 void AliTOFTrigger::GetCTTMIndex(Int_t *detind, Int_t *indexCTTM) {
1152 // Returns CTTM index corresponding to the detector element detind
1155 GetLTMIndex(detind,indexCTTM);
1159 //-----------------------------------------------------------------------------
1160 void AliTOFTrigger::LoadActiveMask(){
1162 // Load OCDB current mask
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");
1171 if(cdb->GetRun() < 0){
1173 printf("AliTOFTrigger (WARNING): probably CDB first instance - number of run set to 0\n");
1177 AliCDBEntry *cdbe = cdb->Get("TRIGGER/TOF/TriggerMask");
1179 fTOFTrigMask= (AliTOFTriggerMask *)cdbe->GetObject();
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;
1186 // fTOFTrigMask->SetTriggerMaskArray(maskArray);
1190 //-----------------------------------------------------------------------------
1191 AliTOFTrigger::~AliTOFTrigger()
1197 //-----------------------------------------------------------------------------
1198 AliTOFTrigger& AliTOFTrigger::operator=(const AliTOFTrigger &/*source*/)