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