Updates needed to make the trigger inputs compatible with the new constructors. The...
[u/mrichter/AliRoot.git] / TOF / AliTOFTrigger.cxx
1 /**************************************************************************
2  * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
3  *                                                                         *
4  * Author: The ALICE Off-line Project.                                    *
5  * Contributors are mentioned in the code where appropriate.              *
6  *                                                                        *
7  * Permission to use, copy, modify and distribute this software and its   *
8  * documentation strictly for non-commercial purposes is hereby granted   *
9  * without fee, provided that the above copyright notice appears in all   *
10  * copies and that both the copyright notice and this permission notice   *
11  * appear in the supporting documentation. The authors make no claims     *
12  * about the suitability of this software for any purpose. It is          *
13  * provided "as is" without express or implied warranty.                  *
14  **************************************************************************/
15
16 /* $Id$ */
17
18 /////////////////////////////////////////////////////////////////////
19 // 
20 //       Class performing TOF Trigger
21 //       Cosmic_Multi_muon: Cosmic Multi-Muonic Event Trigger (L0)
22 //       ppMB: p-p Minimum Bias Event Trigger (L0)
23 //       UltraPer_Coll: Ultra-Peripheral Collision Event Trigger (L0)
24 //       High_Mult: High Multiplicity Event Trigger (L0)
25 //       Jet: Events with Jet Topology Trigger (L1)
26 //
27 /////////////////////////////////////////////////////////////////////
28
29 #include <TClonesArray.h>
30
31 #include "AliLoader.h"
32 #include "AliLog.h"
33 #include "AliRunLoader.h"
34 #include "AliRun.h"
35 #include "AliTriggerInput.h"
36
37 #include "AliTOFdigit.h"
38 #include "AliTOFTrigger.h"
39
40 extern AliRun* gAlice;
41
42 //-------------------------------------------------------------------------
43 ClassImp(AliTOFTrigger)
44
45 //----------------------------------------------------------------------
46   AliTOFTrigger::AliTOFTrigger() : 
47     AliTriggerDetector(), 
48     fHighMultTh(1000),
49     fppMBTh(4),
50     fMultiMuonTh(2),
51     fUPTh(2),
52     fdeltaminpsi(150),
53     fdeltamaxpsi(170),
54     fdeltaminro(70),
55     fdeltamaxro(110),
56     fstripWindow(2)
57 {
58   //main ctor
59   for (Int_t i=0;i<kNLTM;i++){
60     for (Int_t j=0;j<kNLTMchannels;j++){
61       fLTMmatrix[i][j]=kFALSE;
62     }
63     if (i<kNCTTM){
64       for (Int_t j=0;j<kNCTTMchannels;j++){
65         fCTTMmatrixFront[i][j]=kFALSE;
66         fCTTMmatrixBack[i][j]=kFALSE;
67       }
68     }
69   }
70   SetName("TOF");
71   CreateInputs();
72 }
73 //----------------------------------------------------------------------
74 AliTOFTrigger::AliTOFTrigger(Int_t HighMultTh, Int_t ppMBTh, Int_t MultiMuonTh, Int_t UPTh, Float_t deltaminpsi, Float_t deltamaxpsi, Float_t deltaminro, Float_t deltamaxro, Int_t stripWindow) : 
75   AliTriggerDetector(),   
76   fHighMultTh(HighMultTh),
77   fppMBTh(ppMBTh),
78   fMultiMuonTh(MultiMuonTh),
79   fUPTh(UPTh),
80   fdeltaminpsi(deltaminpsi),
81   fdeltamaxpsi(deltamaxpsi),
82   fdeltaminro(deltaminro),
83   fdeltamaxro(deltamaxro),
84   fstripWindow(stripWindow)
85
86 {
87   //ctor with thresholds for triggers
88   for (Int_t i=0;i<kNLTM;i++){
89     for (Int_t j=0;j<kNLTMchannels;j++){
90       fLTMmatrix[i][j]=kFALSE;
91     }
92     if (i<kNCTTM){
93       for (Int_t j=0;j<kNCTTMchannels;j++){
94         fCTTMmatrixFront[i][j]=kFALSE;
95         fCTTMmatrixBack[i][j]=kFALSE;
96       }
97     }
98   }
99   SetName("TOF");
100   CreateInputs();
101 }
102
103 //____________________________________________________________________________ 
104
105 AliTOFTrigger::AliTOFTrigger(const AliTOFTrigger & tr):
106   AliTriggerDetector(),
107   fHighMultTh(0),
108   fppMBTh(0),
109   fMultiMuonTh(0),
110   fUPTh(0),
111   fdeltaminpsi(0),
112   fdeltamaxpsi(0),
113   fdeltaminro(0),
114   fdeltamaxro(0),
115   fstripWindow(0)
116 {
117   //copy ctor
118   fHighMultTh=tr.fHighMultTh;
119   fppMBTh=tr.fppMBTh;
120   fMultiMuonTh=tr.fMultiMuonTh;
121   fUPTh=tr.fUPTh;
122   fdeltaminpsi = tr.fdeltaminpsi;
123   fdeltamaxpsi = tr.fdeltamaxpsi;
124   fdeltaminro = tr.fdeltaminro;
125   fdeltamaxro = tr.fdeltamaxro;
126   fstripWindow = tr.fstripWindow;
127   for (Int_t i=0;i<kNLTM;i++){
128     for (Int_t j=0;j<kNLTMchannels;j++){
129       fLTMmatrix[i][j]=tr.fLTMmatrix[i][j];
130     }
131     if (i<kNCTTM){
132       for (Int_t j=0;j<kNCTTMchannels;j++){
133       fCTTMmatrixFront[i][j]=tr.fCTTMmatrixFront[i][j];
134       fCTTMmatrixBack[i][j]=tr.fCTTMmatrixBack[i][j];
135       }
136     }
137   }
138   SetName(tr.GetName());
139   CreateInputs();
140     //fInputs=&(tr.GetInputs());
141 }
142
143 //----------------------------------------------------------------------
144
145 void AliTOFTrigger::CreateInputs()
146 {
147   // creating inputs 
148   // Do not create inputs again!!
149    if( fInputs.GetEntriesFast() > 0 ) return;
150    
151    fInputs.AddLast(new AliTriggerInput("TOF_Cosmic_MultiMuon_L0","TOF",0));
152    fInputs.AddLast(new AliTriggerInput("TOF_pp_MB_L0","TOF",0));
153    fInputs.AddLast(new AliTriggerInput("TOF_UltraPer_Coll_L0","TOF",0));
154
155    fInputs.AddLast(new AliTriggerInput("TOF_High_Mult_L0","TOF",0));
156    fInputs.AddLast(new AliTriggerInput("TOF_Jet_L1","TOF",0));
157 }
158
159 //----------------------------------------------------------------------
160 void AliTOFTrigger::Trigger(){
161   //triggering method
162   CreateLTMMatrix();
163   Int_t nchonFront = 0;
164   Int_t nchonBack = 0;
165   Int_t nchonTot = 0;
166   Int_t nchonFrontBack = 0;
167   Int_t nchonFront1 = 0;
168   Int_t nchonBack1 = 0;
169   Int_t nchonFrontBack1 = 0;
170   Int_t mindeltapsi = (Int_t)fdeltaminpsi/10;
171   Int_t maxdeltapsi = (Int_t)fdeltamaxpsi/10;
172   Int_t mindeltaro = (Int_t)fdeltaminro/10;
173   Int_t maxdeltaro = (Int_t)fdeltamaxro/10;
174   for (Int_t i=0;i<kNCTTM;i++){
175     for (Int_t j=0;j<kNCTTMchannels;j++){
176       fCTTMmatrixFront[i][j]=kFALSE;
177       fCTTMmatrixBack[i][j]=kFALSE;
178     }
179   }
180   for (Int_t i=0;i<kNCTTM;i++){
181     for (Int_t j=0;j<kNCTTMchannels;j++){
182       fCTTMmatrixFront[i][j] = (fLTMmatrix[i][j*2] || fLTMmatrix[i][j*2+1]);
183       if (fCTTMmatrixFront[i][j]) nchonFront++; 
184     }
185   }
186
187   for (Int_t i=kNCTTM;i<(kNCTTM*2);i++){
188     for (Int_t j=0;j<kNCTTMchannels;j++){
189       fCTTMmatrixBack[i-kNCTTM][j] = (fLTMmatrix[i][j*2] || fLTMmatrix[i][j*2+1]);
190       if (fCTTMmatrixBack[i-kNCTTM][j]) nchonBack++; 
191     }
192   }
193
194   nchonTot = nchonFront + nchonBack;
195
196   //pp Minimum Bias Trigger
197   if (nchonTot >= fppMBTh) {
198     SetInput("TOF_pp_MB_L0");
199   }
200
201   //High Multiplicity Trigger
202   if (nchonTot >= fHighMultTh) {
203     SetInput("TOF_High_Mult_L0");
204   }
205
206   
207   //MultiMuon Trigger
208   nchonFront = 0;
209   nchonBack = 0;
210   nchonFrontBack = 0;
211
212   Bool_t boolCTTMor = kFALSE;
213
214   for (Int_t i=0;i<(kNCTTM/2);i++){
215     Int_t iopp = i+kNCTTM/2;
216     for (Int_t j=0;j<kNCTTMchannels;j++){
217       if (fCTTMmatrixFront[i][j]){
218         Int_t minj = j-fstripWindow;
219         Int_t maxj = j+fstripWindow;
220         if (minj<0) minj =0;
221         if (maxj>=kNCTTMchannels) maxj = kNCTTMchannels-1;
222         boolCTTMor = kFALSE;
223         for (Int_t k = minj;k<=maxj;k++){
224           boolCTTMor |= fCTTMmatrixFront[iopp][k];
225         } 
226         if (boolCTTMor) {
227           nchonFront++;
228         }
229       }
230     
231       if (fCTTMmatrixBack[i][j]){
232         Int_t minj = j-fstripWindow;
233         Int_t maxj = j+fstripWindow;
234         if (minj<0) minj =0;
235         if (maxj>=kNCTTMchannels) maxj =kNCTTMchannels-1;
236         boolCTTMor = kFALSE;
237         for (Int_t k = minj;k<=maxj;k++){
238           boolCTTMor |= fCTTMmatrixBack[iopp][k];
239         }
240         if (boolCTTMor) {
241           nchonBack++;
242         }
243       }
244     }
245   }
246
247   nchonFrontBack = nchonFront+nchonBack;
248
249   nchonFront1 = 0;
250   nchonBack1 = 0;
251   nchonFrontBack1 = 0;
252
253   boolCTTMor = kFALSE;
254   for (Int_t i=0;i<(kNCTTM/2);i++){
255     Int_t i2max = (kNCTTM-1)-i+1;
256     Int_t i2min = (kNCTTM-1)-i-1;
257     if (i2max >=kNCTTM) i2max = kNCTTM-1;
258     if (i2min==i) i2min = kNCTTM-1-i;
259     for (Int_t j=0;j<kNCTTMchannels;j++){
260       Int_t j2min = j-fstripWindow;
261       Int_t j2max = j+fstripWindow;
262       if (j2min<0) j2min =0;
263       if (j2max>=kNCTTMchannels) j2max =kNCTTMchannels-1;
264       if (fCTTMmatrixFront[i][j]){
265         boolCTTMor = kFALSE;
266         for (Int_t i2=i2min;i2<=i2max;i2++){
267           for (Int_t j2 = j2min;j2<=j2max;j2++){
268             boolCTTMor |= fCTTMmatrixFront[i2][j2];
269           } 
270           if (boolCTTMor) {
271             nchonFront++;
272           }
273         }
274       }
275       if (fCTTMmatrixBack[i][j]){
276         boolCTTMor = kFALSE;
277         for (Int_t i2=i2min;i2<=i2max;i2++){
278           for (Int_t j2 = j2min;j2<=j2max;j2++){
279             boolCTTMor |= fCTTMmatrixBack[i2][j2];
280           }
281         }
282         if (boolCTTMor) {
283           nchonBack++;
284         }
285       }
286     }
287   }
288
289   nchonFrontBack1 = nchonFront1+nchonBack1;
290
291   if (nchonFrontBack >= fMultiMuonTh || nchonFrontBack1 >= fMultiMuonTh) {
292     SetInput("TOF_Cosmic_MultiMuon_L0");
293   }
294
295   //Ultra-Peripheral collision Trigger
296   Bool_t boolpsi = kFALSE;
297   Bool_t boolro = kFALSE;
298   if (nchonTot == fUPTh){
299     for (Int_t i=0;i<kNCTTM;i++){
300       for (Int_t j=0;j<kNCTTMchannels;j++){
301         Int_t minipsi = i+mindeltapsi;
302         Int_t maxipsi = i+maxdeltapsi;
303         if (minipsi>=kNCTTM) minipsi = mindeltapsi-((kNCTTM-1)-i)-1;
304         if (maxipsi>=kNCTTM) maxipsi = maxdeltapsi-((kNCTTM-1)-i)-1;
305         Int_t miniro = i+mindeltaro;
306         Int_t maxiro = i+maxdeltaro;
307         if (miniro>=kNCTTM) miniro = mindeltaro-((kNCTTM-1)-i)-1;
308         if (maxiro>=kNCTTM) maxiro = maxdeltaro-((kNCTTM-1)-i)-1;
309         Int_t j2min = j-fstripWindow;
310         Int_t j2max = j+fstripWindow;
311         if (j2min<0) j2min =0;
312         if (j2max>=kNCTTMchannels) j2max =kNCTTMchannels-1;
313         if (fCTTMmatrixFront[i][j]){
314           for (Int_t i2=minipsi;i2<=maxipsi;i2++){
315             for (Int_t j2 = j2min;j2<=j2max;j2++){
316               if (fCTTMmatrixFront[i2][j2]) {
317                 SetInput("TOF_UltraPer_Coll_L0");
318                 boolpsi = kTRUE;
319                 //exiting loops
320                 j2 = j2max+1;
321                 i2 = maxipsi+1;
322                 j=kNCTTMchannels;
323                 i=kNCTTM;
324               }
325             }
326           }
327           if (!boolpsi){
328             for (Int_t i2=miniro;i2<=maxiro;i2++){
329               for (Int_t j2 = j2min;j2<=j2max;j2++){
330                 if (fCTTMmatrixFront[i2][j2]) {
331                   SetInput("TOF_UltraPer_Coll_L0");
332                   boolro = kTRUE;
333                   //exiting loops
334                   j2 = j2max+1;
335                   i2 = maxiro+1;
336                   j=kNCTTMchannels;
337                   i=kNCTTM;
338                 }
339               }
340             }
341           }
342         }
343           
344         else if (fCTTMmatrixBack[i][j]){
345           for (Int_t i2=minipsi;i2<=maxipsi;i2++){
346             for (Int_t j2 = j2min;j2<=j2max;j2++){
347               if (fCTTMmatrixBack[i2][j2]) {
348                 SetInput("TOF_UltraPer_Coll_L0");
349                 boolpsi = kTRUE;
350                 //exiting loops
351                 j2 = j2max+1;
352                 i2 = maxipsi+1;
353                 j=kNCTTMchannels;
354                 i=kNCTTM;
355               }
356             }
357           }
358           if (!boolpsi){
359             for (Int_t i2=miniro;i2<=maxiro;i2++){
360               for (Int_t j2 = j2min;j2<=j2max;j2++){
361                 if (fCTTMmatrixBack[i2][j2]) {
362                   SetInput("TOF_UltraPer_Coll_L0");
363                   boolro = kTRUE;
364                   //exiting loops
365                   j2 = j2max+1;
366                   i2 = maxiro+1;
367                   j=kNCTTMchannels;
368                   i=kNCTTM;
369                 }
370               }
371             }
372           } 
373         }
374       }
375     }
376   }
377 }
378 //-----------------------------------------------------------------------------
379 void AliTOFTrigger::CreateLTMMatrix(){
380   //creating LTMMatrix
381   //initialization
382   for (Int_t i=0;i<kNLTM;i++){
383     for (Int_t j=0;j<kNLTMchannels;j++){
384       fLTMmatrix[i][j]=kFALSE;
385     }
386   }
387   AliRunLoader *rl;
388   rl = gAlice->GetRunLoader();
389   
390   Int_t ncurrevent = rl->GetEventNumber();
391   rl->GetEvent(ncurrevent);
392   
393   AliLoader * tofLoader = rl->GetLoader("TOFLoader");
394   
395   tofLoader->LoadDigits("read");
396   TTree *treeD = tofLoader->TreeD();
397   if (treeD == 0x0)
398     {
399       AliFatal("AliTOFTrigger: Can not get TreeD");
400     }
401   
402   TBranch *branch = treeD->GetBranch("TOF");
403   if (!branch) { 
404     AliError("can't get the branch with the TOF digits !");
405     return;
406   }
407   TClonesArray *tofDigits =new TClonesArray("AliTOFdigit",  1000);
408   branch->SetAddress(&tofDigits);
409   treeD->GetEvent(0);
410   Int_t ndigits = tofDigits->GetEntriesFast();
411   Int_t detind[5]; //detector indexes: 0 -> sector
412   //                                   1 -> plate
413   //                                   2 -> strip
414   //                                   3 -> padz
415   //                                   4 -> padx
416   
417   for (Int_t i=0;i<ndigits;i++){
418     AliTOFdigit * digit = (AliTOFdigit*)tofDigits->UncheckedAt(i);
419     detind[0] = digit->GetSector();
420     detind[1] = digit->GetPlate();
421     detind[2] = digit->GetStrip();
422     detind[3] = digit->GetPadz();
423     detind[4] = digit->GetPadx();
424     
425     Int_t indexLTM[2] = {-1,-1};
426     GetLTMIndex(detind,indexLTM);
427
428     fLTMmatrix[indexLTM[0]][indexLTM[1]] = kTRUE;
429   }
430
431   tofLoader->UnloadDigits();
432 //   rl->UnloadgAlice();
433 }
434 //-----------------------------------------------------------------------------
435 void AliTOFTrigger::GetLTMIndex(Int_t *detind, Int_t *indexLTM){
436   //getting LTMmatrix indexes for current digit
437   if (detind[1]==0 || detind[1]==1 || (detind[1]==2 && detind[2]<=7)) {
438     if (detind[4]<24){
439       indexLTM[0] = detind[0]*2;
440     }
441     else {
442       indexLTM[0] = detind[0]*2+1;
443     }
444   }
445   else {
446     if (detind[4]<24){
447       indexLTM[0] = detind[0]*2+36;
448     }
449     else {
450       indexLTM[0] = (detind[0]*2+1)+36;
451     }
452   }
453
454   if (indexLTM[0]<36){ 
455     if (detind[1] ==0){
456       indexLTM[1] = detind[2];
457     }
458     else if (detind[1] ==1){
459       indexLTM[1] = detind[2]+19;
460     }
461     else if (detind[1] ==2){
462       indexLTM[1] = detind[2]+19*2;
463     }
464     else{
465       AliError("Smth Wrong!!!");
466     }
467   }
468   else {
469     if (detind[1] ==2){
470       indexLTM[1] = detind[2]-8;
471     }
472     else if (detind[1] ==3){
473       indexLTM[1] = detind[2]+7;
474     }
475     else if (detind[1] ==4){
476       indexLTM[1] = detind[2]+26;
477     }
478     else{
479       AliError("Smth Wrong!!!");
480     }
481   }
482 }
483