]> git.uio.no Git - u/mrichter/AliRoot.git/blame_incremental - TOF/AliTOFTrigger.cxx
git://git.uio.no / u / mrichter / AliRoot.git / blame_incremental
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (non-incremental) | history | HEAD
Coverity fix.
[u/mrichter/AliRoot.git] / TOF / AliTOFTrigger.cxx
... / ...
CommitLineData
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
55extern AliRun* gAlice;
56
57//-------------------------------------------------------------------------
58ClassImp(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
109AliTOFTrigger::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
156AliTOFTrigger::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
209void 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//----------------------------------------------------------------------
229void 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//-----------------------------------------------------------------------------
434void AliTOFTrigger::CreateLTMMatrix() {
435 //creating LTMMatrix
436 //initialization
437 CreateLTMMatrixFromDigits();
438}
439
440//-------------------------------------------------------------------------
441
442void 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
516void 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//-----------------------------------------------------------------------------
614void 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
669void 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
703void 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
716void 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//-------------------------------------------------------------------------
730void 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//-------------------------------------------------------------------------
754void 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//-------------------------------------------------------------------------
779void 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//-------------------------------------------------------------------------
795void 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
838void 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//-------------------------------------------------------------------------
854void 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
896Bool_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//-------------------------------------------------------------------------
909Bool_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
952void 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
996void 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//-----------------------------------------------------------------------------
1006void 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//-----------------------------------------------------------------------------
1037AliTOFTrigger::~AliTOFTrigger()
1038{
1039 // dtor
1040
1041}
1042
1043//-----------------------------------------------------------------------------
1044AliTOFTrigger& AliTOFTrigger::operator=(const AliTOFTrigger &/*source*/)
1045{
1046 // ass. op.
1047 return *this;
1048
1049}
1050