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