Coverity fixes (24641, 24642)
[u/mrichter/AliRoot.git] / ANALYSIS / ANALYSISalice / AliTriggerAnalysis.cxx
1 /* $Id: AliTriggerAnalysis.cxx 35782 2009-10-22 11:54:31Z jgrosseo $ */
2
3 /**************************************************************************
4  * Copyright(c) 1998-2009, ALICE Experiment at CERN, All rights reserved. *
5  *                                                                        *
6  * Author: The ALICE Off-line Project.                                    *
7  * Contributors are mentioned in the code where appropriate.              *
8  *                                                                        *
9  * Permission to use, copy, modify and distribute this software and its   *
10  * documentation strictly for non-commercial purposes is hereby granted   *
11  * without fee, provided that the above copyright notice appears in all   *
12  * copies and that both the copyright notice and this permission notice   *
13  * appear in the supporting documentation. The authors make no claims     *
14  * about the suitability of this software for any purpose. It is          *
15  * provided "as is" without express or implied warranty.                  *
16  **************************************************************************/
17
18 //-------------------------------------------------------------------------
19 //                      Implementation of   Class AliTriggerAnalysis
20 //   This class provides function to check if events have been triggered based on the data in the ESD
21 //   The trigger bits, trigger class inputs and only the data (offline trigger) can be used
22 //   Origin: Jan Fiete Grosse-Oetringhaus, CERN
23 //-------------------------------------------------------------------------
24
25 #include "TH1F.h"
26 #include "TH2F.h"
27 #include "TList.h"
28 #include "TIterator.h"
29 #include "TParameter.h"
30 #include "TMap.h"
31 #include "TRandom.h"
32 #include "AliTriggerAnalysis.h"
33 #include "AliLog.h"
34 #include "AliVEvent.h"
35 #include "AliESDEvent.h"
36 #include "AliMultiplicity.h"
37 #include "AliESDVZERO.h"
38 #include "AliESDZDC.h"
39 #include "AliESDFMD.h"
40 #include "AliESDVertex.h"
41 #include "AliESDtrackCuts.h"
42 #include "AliDAQ.h"
43 #include "AliESDTrdTrack.h"
44 #include "AliVCaloTrigger.h"
45
46 ClassImp(AliTriggerAnalysis)
47
48 AliTriggerAnalysis::AliTriggerAnalysis() :
49 fSPDGFOThreshold(2),
50 fSPDGFOEfficiency(0),
51 fV0TimeOffset(0),
52 fV0AdcThr(0),
53 fV0HwAdcThr(2.5),
54 fV0HwWinLow(61.5),
55 fV0HwWinHigh(86.5),
56 fZDCCutRefSum(-568.5),
57 fZDCCutRefDelta(-2.1),
58 fZDCCutSigmaSum(3.25),
59 fZDCCutSigmaDelta(2.25),
60 fZDCCutRefSumCorr(-65.5),
61 fZDCCutRefDeltaCorr(-2.1),
62 fZDCCutSigmaSumCorr(6.0),
63 fZDCCutSigmaDeltaCorr(1.2),
64 fZDCCutZNATimeCorrMin(0.0),
65 fZDCCutZNATimeCorrMax(2.0),
66 fZDCCutZNCTimeCorrMin(0.0),
67 fZDCCutZNCTimeCorrMax(5.0),
68 fASPDCvsTCut(65),
69 fBSPDCvsTCut(4),
70 fTRDptHSE(3.),
71 fTRDpidHSE(144),
72 fTRDptHQU(2.),
73 fTRDpidHQU(164.),
74 fTRDptHEE(3.),
75 fTRDpidHEE(144),
76 fTRDminSectorHEE(6),
77 fTRDmaxSectorHEE(8),
78 fTRDptHJT(3.),
79 fTRDnHJT(3),
80 fDoFMD(kTRUE),
81 fFMDLowCut(0.2),
82 fFMDHitCut(0.5),
83 fHistBitsSPD(0),
84 fHistFiredBitsSPD(0),
85 fHistSPDClsVsTrk(0),
86 fHistV0A(0),
87 fHistV0C(0),
88 fHistZDC(0),
89 fHistTDCZDC(0),
90 fHistTimeZDC(0),
91 fHistTimeCorrZDC(0),
92 fHistFMDA(0),
93 fHistFMDC(0),
94 fHistFMDSingle(0),
95 fHistFMDSum(0),
96 fHistT0(0),
97 fTriggerClasses(0),
98 fMC(kFALSE),
99 fEsdTrackCuts(0),
100 fTPCOnly(kFALSE)
101 {
102   // constructor
103 }
104
105 //-------------------------------------------------------------------------------------------------
106 AliTriggerAnalysis::~AliTriggerAnalysis(){
107   // destructor
108   if (fHistBitsSPD)      { delete fHistBitsSPD;      fHistBitsSPD = 0;      }
109   if (fHistFiredBitsSPD) { delete fHistFiredBitsSPD; fHistFiredBitsSPD = 0; }
110   if (fHistSPDClsVsTrk)  { delete fHistSPDClsVsTrk;  fHistSPDClsVsTrk = 0;  }
111   if (fHistV0A)          { delete fHistV0A;          fHistV0A = 0;          }
112   if (fHistV0C)          { delete fHistV0C;          fHistV0C = 0;          }
113   if (fHistZDC)          { delete fHistZDC;          fHistZDC = 0;          }
114   if (fHistTDCZDC)       { delete fHistTDCZDC;       fHistTDCZDC = 0;       }
115   if (fHistTimeZDC)      { delete fHistTimeZDC;      fHistTimeZDC = 0;      }
116   if (fHistTimeCorrZDC)  { delete fHistTimeCorrZDC;  fHistTimeCorrZDC = 0;  }
117   if (fHistFMDA)         { delete fHistFMDA;         fHistFMDA = 0;         }
118   if (fHistFMDC)         { delete fHistFMDC;         fHistFMDC = 0;         }
119   if (fHistFMDSingle)    { delete fHistFMDSingle;    fHistFMDSingle = 0;    }
120   if (fHistFMDSum)       { delete fHistFMDSum;       fHistFMDSum = 0;       }
121   if (fHistT0)           { delete fHistT0;           fHistT0 = 0;           }
122   if (fEsdTrackCuts)     { delete fEsdTrackCuts;     fEsdTrackCuts =0;      }
123   if (fTriggerClasses)   { fTriggerClasses->DeleteAll(); delete fTriggerClasses; fTriggerClasses = 0; }
124 }
125
126
127 //-------------------------------------------------------------------------------------------------
128 void AliTriggerAnalysis::EnableHistograms(Bool_t isLowFlux){
129   // creates the monitoring histograms 
130   // dynamical range of histograms can be adapted for pp and pPb via isLowFlux flag)
131   // TODO check limits for FMD
132   
133   Int_t nBins  = isLowFlux ?  600 : 1202;
134   Int_t nBinsX = isLowFlux ?  100 :  300;
135   Int_t nBinsY = isLowFlux ?  500 : 1000;
136   Float_t xMax = isLowFlux ?  400 : 2999.5;
137   Float_t yMax = isLowFlux ? 4000 : 9999.5;
138   
139   // do not add these hists to the directory
140   Bool_t oldStatus = TH1::AddDirectoryStatus();
141   TH1::AddDirectory(kFALSE); 
142   fHistBitsSPD      = new TH2F("fHistBitsSPD", "SPD GFO;number of fired chips (offline);number of fired chips (hardware)", nBins, -1.5, -1.5 + nBins, nBins, -1.5, -1.5+nBins);
143   fHistFiredBitsSPD = new TH1F("fHistFiredBitsSPD", "SPD GFO Hardware;chip number;events", 1200, -0.5, 1199.5);
144   fHistSPDClsVsTrk  = new TH2F("fHistSPDClsVsTrk", "SPD Clusters vs Tracklets; n tracklets; n clusters", nBinsX, -0.5, xMax, nBinsY, -0.5, yMax);
145   fHistV0A          = new TH1F("fHistV0A", "V0A;leading time (ns);events", 400, -100, 100);
146   fHistV0C          = new TH1F("fHistV0C", "V0C;leading time (ns);events", 400, -100, 100);
147   fHistZDC          = new TH1F("fHistZDC", "ZDC;trigger bits;events", 8, -1.5, 6.5);
148   fHistTDCZDC       = new TH1F("fHistTDCZDC", "ZDC;TDC bits;events", 32, -0.5, 32-0.5);
149   fHistTimeZDC      = new TH2F("fHistTimeZDC", "ZDC;TDC timing C-A;TDC timing C+A", 120,-30,30,120,-600,-540);
150   fHistTimeCorrZDC  = new TH2F("fHistTimeCorrZDC", "ZDC;Corrected TDC timing C-A; Corrected TDC timing C+A", 120,-30,30,260,-100,30);
151   fHistFMDA         = new TH1F("fHistFMDA", "FMDA;combinations above threshold;events", 102, -1.5, 100.5);
152   fHistFMDC         = new TH1F("fHistFMDC", "FMDC;combinations above threshold;events", 102, -1.5, 100.5);
153   fHistFMDSingle    = new TH1F("fHistFMDSingle", "FMD single;multiplicity value;counts", 1000, 0, 10);
154   fHistFMDSum       = new TH1F("fHistFMDSum", "FMD sum;multiplicity value;counts", 1000, 0, 10);
155   fHistT0           = new TH1F("fHistT0", "T0;time (ns);events", 100, -25, 25);
156   fTriggerClasses = new TMap;
157   fTriggerClasses->SetOwner();
158   TH1::AddDirectory(oldStatus);
159 }
160
161
162 //-------------------------------------------------------------------------------------------------
163 const char* AliTriggerAnalysis::GetTriggerName(Trigger trigger){
164   // returns the name of the requested trigger
165   // the returned string will only be valid until the next call to this function [not thread-safe]
166   
167   static TString str;
168   
169   UInt_t triggerNoFlags = (UInt_t) trigger % (UInt_t) kStartOfFlags;
170   
171   switch (triggerNoFlags)  {
172     case kAcceptAll :      str = "ACCEPT ALL (bypass!)";      break;
173     case kMB1 :            str = "MB1";                       break;
174     case kMB2 :            str = "MB2";                       break;
175     case kMB3 :            str = "MB3";                       break;
176     case kSPDGFO :         str = "SPD GFO";                   break;
177     case kSPDGFOBits :     str = "SPD GFO Bits";              break;
178     case kSPDGFOL0 :       str = "SPD GFO L0 (first layer)";  break;
179     case kSPDGFOL1 :       str = "SPD GFO L1 (second layer)"; break;
180     case kSPDClsVsTrkBG :  str = "Cluster vs Tracklets";      break;
181     case kV0A :            str = "V0 A BB";                   break;
182     case kV0C :            str = "V0 C BB";                   break;
183     case kV0OR :           str = "V0 OR BB";                  break;
184     case kV0AND :          str = "V0 AND BB";                 break;
185     case kV0ABG :          str = "V0 A BG";                   break;
186     case kV0CBG :          str = "V0 C BG";                   break;
187     case kZDC :            str = "ZDC";                       break;
188     case kZDCA :           str = "ZDC A";                     break;
189     case kZDCC :           str = "ZDC C";                     break;
190     case kZNA :            str = "ZN A";                      break;
191     case kZNC :            str = "ZN C";                      break;
192     case kZNABG :          str = "ZN A BG";                   break;
193     case kZNCBG :          str = "ZN C BG";                   break;
194     case kFMDA :           str = "FMD A";                     break;
195     case kFMDC :           str = "FMD C";                     break;
196     case kFPANY :          str = "SPD GFO | V0 | ZDC | FMD";  break;
197     case kNSD1 :           str = "NSD1";                      break;
198     case kMB1Prime:        str = "MB1prime";                  break;
199     case kZDCTDCA :        str = "ZDC TDC A";                 break;
200     case kZDCTDCC :        str = "ZDC TDC C";                 break;
201     case kZDCTime :        str = "ZDC Time Cut";              break;
202     case kCentral :        str = "V0 Central";                break;
203     case kSemiCentral :    str = "V0 Semi-central";           break;
204     case kEmcalL0 :        str = "EMCAL";                     break;
205     case kTRDHCO :         str = "TRD cosmics";               break;
206     case kTRDHJT :         str = "TRD Jet";                   break;
207     case kTRDHSE :         str = "TRD Single Electron";       break;
208     case kTRDHQU :         str = "TRD Quarkonia";             break;
209     case kTRDHEE :         str = "TRD Dielectron";            break;
210     default:               str = "";                          break;
211   }
212   if (trigger & kOfflineFlag) str += " OFFLINE";  
213   if (trigger & kOneParticle) str += " OneParticle";  
214   if (trigger & kOneTrack)    str += " OneTrack";  
215   return str;
216 }
217
218
219 //-------------------------------------------------------------------------------------------------
220 Bool_t AliTriggerAnalysis::IsTriggerFired(const AliESDEvent* aEsd, Trigger trigger){
221   // checks if an event has been triggered
222   if (trigger & kOfflineFlag) return IsOfflineTriggerFired(aEsd, trigger);
223   return IsTriggerBitFired(aEsd, trigger);
224 }
225
226
227 //-------------------------------------------------------------------------------------------------
228 Bool_t AliTriggerAnalysis::IsTriggerBitFired(const AliESDEvent* /*aEsd*/, Trigger /*trigger*/) const { 
229   AliFatal("This IsTriggerBitFired function is obsolete.\n"); 
230   return 0; 
231 }
232
233
234 //-------------------------------------------------------------------------------------------------
235 Bool_t AliTriggerAnalysis::IsTriggerBitFired(const AliESDEvent* aEsd, ULong64_t tclass) const {
236   // Checks if corresponding bit in mask is on
237   ULong64_t trigmask = aEsd->GetTriggerMask();
238   return (trigmask & (1ull << (tclass-1)));
239 }
240
241
242 //-------------------------------------------------------------------------------------------------
243 Int_t AliTriggerAnalysis::EvaluateTrigger(const AliESDEvent* aEsd, Trigger trigger){
244   // evaluates a given trigger
245   // trigger combinations are not supported, for that see IsOfflineTriggerFired
246
247   UInt_t triggerNoFlags = (UInt_t) trigger % (UInt_t) kStartOfFlags;
248   Bool_t offline = trigger & kOfflineFlag;
249   
250   if (!offline) {
251     if ( triggerNoFlags==kT0BG
252       || triggerNoFlags==kT0Pileup
253       || triggerNoFlags==kSPDClsVsTrkBG
254       || triggerNoFlags==kZDCA
255       || triggerNoFlags==kZDCC
256       || triggerNoFlags==kZDCTDCA
257       || triggerNoFlags==kZDCTDCC
258       || triggerNoFlags==kZDCTime
259       || triggerNoFlags==kZNA
260       || triggerNoFlags==kZNC
261       || triggerNoFlags==kZNABG
262       || triggerNoFlags==kZNCBG
263       || triggerNoFlags==kFMDA
264       || triggerNoFlags==kFMDC
265       || triggerNoFlags==kTPCLaserWarmUp
266       || triggerNoFlags==kTPCHVdip
267       || triggerNoFlags==kIncompleteEvent
268       || triggerNoFlags==kEMCAL
269       || triggerNoFlags==kEmcalL0
270       || triggerNoFlags==kEmcalL1GammaHigh
271       || triggerNoFlags==kEmcalL1GammaLow
272       || triggerNoFlags==kEmcalL1JetHigh
273       || triggerNoFlags==kEmcalL1JetLow
274       || triggerNoFlags==kTRDHCO
275       || triggerNoFlags==kTRDHJT
276       || triggerNoFlags==kTRDHSE
277       || triggerNoFlags==kTRDHQU
278       || triggerNoFlags==kTRDHEE
279       ) AliFatal(Form("Online trigger not available for trigger %d", triggerNoFlags));
280   } else {
281     if (  triggerNoFlags==kCTPV0A 
282         ||triggerNoFlags==kCTPV0C
283         ||triggerNoFlags==kCentral
284         ||triggerNoFlags==kSemiCentral
285       ) AliFatal(Form("Offline trigger not available for trigger %d", triggerNoFlags));
286   }
287   
288   switch (triggerNoFlags) {
289     case kCTPV0A:          return aEsd->GetHeader()->IsTriggerInputFired("V0A");
290     case kCTPV0C:          return aEsd->GetHeader()->IsTriggerInputFired("V0C");
291     case kSPDGFO:          return SPDFiredChips(aEsd, !offline, kFALSE, 0); 
292     case kSPDGFOL0:        return SPDFiredChips(aEsd, !offline, kFALSE, 1);
293     case kSPDGFOL1:        return SPDFiredChips(aEsd, !offline, kFALSE, 2);
294     case kSPDClsVsTrkBG:   return IsSPDClusterVsTrackletBG(aEsd);
295     case kV0A:             return V0Trigger(aEsd, kASide, !offline) == kV0BB; 
296     case kV0C:             return V0Trigger(aEsd, kCSide, !offline) == kV0BB;
297     case kV0ABG:           return V0Trigger(aEsd, kASide, !offline) == kV0BG;
298     case kV0CBG:           return V0Trigger(aEsd, kCSide, !offline) == kV0BG;
299     case kT0:              return T0Trigger(aEsd, !offline) == kT0BB;
300     case kT0BG:            return T0Trigger(aEsd, !offline) == kT0DecBG;
301     case kT0Pileup:        return T0Trigger(aEsd, !offline) == kT0DecPileup;
302     case kZDCA:            return ZDCTrigger(aEsd, kASide);
303     case kZDCC:            return ZDCTrigger(aEsd, kCSide);
304     case kZDCTDCA:         return ZDCTDCTrigger(aEsd, kASide);
305     case kZDCTDCC:         return ZDCTDCTrigger(aEsd, kCSide);
306     case kZDCTime:         return ZDCTimeTrigger(aEsd);
307     case kZNA:             return ZDCTDCTrigger(aEsd,kASide,kTRUE,kFALSE,kFALSE);
308     case kZNC:             return ZDCTDCTrigger(aEsd,kCSide,kTRUE,kFALSE,kFALSE);
309     case kZNABG:           return ZDCTimeBGTrigger(aEsd,kASide);
310     case kZNCBG:           return ZDCTimeBGTrigger(aEsd,kCSide);
311     case kFMDA:            return FMDTrigger(aEsd, kASide);
312     case kFMDC:            return FMDTrigger(aEsd, kCSide);
313     case kTPCLaserWarmUp:  return IsLaserWarmUpTPCEvent(aEsd);
314     case kTPCHVdip:        return IsHVdipTPCEvent(aEsd);
315     case kIncompleteEvent: return IsIncompleteEvent(aEsd);
316     case kEMCAL:           return EMCALCellsTrigger(aEsd);
317     case kEmcalL0:         return EMCALTrigger(aEsd,kEmcalL0);
318     case kEmcalL1GammaHigh:return EMCALTrigger(aEsd,kEmcalL1GammaHigh);
319     case kEmcalL1GammaLow: return EMCALTrigger(aEsd,kEmcalL1GammaLow);
320     case kEmcalL1JetHigh:  return EMCALTrigger(aEsd,kEmcalL1JetHigh);
321     case kEmcalL1JetLow:   return EMCALTrigger(aEsd,kEmcalL1JetLow);
322     case kTRDHCO:          return TRDTrigger(aEsd,kTRDHCO);
323     case kTRDHJT:          return TRDTrigger(aEsd,kTRDHJT);
324     case kTRDHSE:          return TRDTrigger(aEsd,kTRDHSE);
325     case kTRDHQU:          return TRDTrigger(aEsd,kTRDHQU);
326     case kTRDHEE:          return TRDTrigger(aEsd,kTRDHEE);
327     case kCentral: {
328       if (!aEsd->GetVZEROData()) { AliWarning("V0 centrality trigger bits were not filled!"); return kFALSE; }
329       if (!aEsd->GetVZEROData()->TestBit(AliESDVZERO::kTriggerChargeBitsFilled)) return kFALSE;
330       return aEsd->GetVZEROData()->GetTriggerBits() & (1<<AliESDVZERO::kCTA2andCTC2);
331     }
332     case kSemiCentral: {
333       if (!aEsd->GetVZEROData()) { AliWarning("V0 centrality trigger bits were not filled!"); return kFALSE; }
334       if (!aEsd->GetVZEROData()->TestBit(AliESDVZERO::kTriggerChargeBitsFilled)) return kFALSE;
335       return aEsd->GetVZEROData()->GetTriggerBits() & (1<<AliESDVZERO::kCTA1andCTC1);
336     }
337     default: AliFatal(Form("Trigger type %d not implemented", triggerNoFlags));
338   }
339   return kFALSE;
340 }
341
342
343 //-------------------------------------------------------------------------------------------------
344 Bool_t AliTriggerAnalysis::IsOfflineTriggerFired(const AliESDEvent* aEsd, Trigger trigger){
345   // checks if an event has been triggered "offline"
346   UInt_t triggerNoFlags = (UInt_t) trigger % (UInt_t) kStartOfFlags;
347   
348   Bool_t decision = kFALSE;
349   switch (triggerNoFlags) {
350     case kAcceptAll:        decision = kTRUE; break;
351     case kMB1:              decision = SPDGFOTrigger(aEsd, 0) ||  V0Trigger(aEsd, kASide, kFALSE) == kV0BB || V0Trigger(aEsd, kCSide, kFALSE) == kV0BB;  break;
352     case kMB2:              decision = SPDGFOTrigger(aEsd, 0) && (V0Trigger(aEsd, kASide, kFALSE) == kV0BB || V0Trigger(aEsd, kCSide, kFALSE) == kV0BB); break;
353     case kMB3:              decision = SPDGFOTrigger(aEsd, 0) &&  V0Trigger(aEsd, kASide, kFALSE) == kV0BB && V0Trigger(aEsd, kCSide, kFALSE) == kV0BB;  break;
354     case kSPDGFO:           decision = SPDGFOTrigger(aEsd, 0); break;
355     case kSPDGFOBits:       decision = SPDGFOTrigger(aEsd, 1); break;
356     case kV0A:              decision = V0Trigger(aEsd, kASide, kFALSE) == kV0BB; break;
357     case kV0C:              decision = V0Trigger(aEsd, kCSide, kFALSE) == kV0BB; break;
358     case kV0OR:             decision = V0Trigger(aEsd, kASide, kFALSE) == kV0BB || V0Trigger(aEsd, kCSide, kFALSE) == kV0BB; break;
359     case kV0AND:            decision = V0Trigger(aEsd, kASide, kFALSE) == kV0BB && V0Trigger(aEsd, kCSide, kFALSE) == kV0BB; break;
360     case kV0ABG:            decision = V0Trigger(aEsd, kASide, kFALSE) == kV0BG; break;
361     case kV0CBG:            decision = V0Trigger(aEsd, kCSide, kFALSE) == kV0BG; break;
362     case kZDC:              decision = ZDCTrigger(aEsd, kASide) || ZDCTrigger(aEsd, kCentralBarrel) || ZDCTrigger(aEsd, kCSide); break;
363     case kZDCA:             decision = ZDCTrigger(aEsd, kASide); break;
364     case kZDCC:             decision = ZDCTrigger(aEsd, kCSide); break;
365     case kZNA:              decision = ZDCTDCTrigger(aEsd,kASide,kTRUE,kFALSE,kFALSE); break;
366     case kZNC:              decision = ZDCTDCTrigger(aEsd,kCSide,kTRUE,kFALSE,kFALSE); break;
367     case kZNABG:            decision = ZDCTimeBGTrigger(aEsd,kASide); break;
368     case kZNCBG:            decision = ZDCTimeBGTrigger(aEsd,kCSide); break;
369     case kFMDA:             decision = FMDTrigger(aEsd, kASide); break;
370     case kFMDC:             decision = FMDTrigger(aEsd, kCSide); break;
371     case kEMCAL:            decision = EMCALCellsTrigger(aEsd); break;
372     case kEmcalL0:          decision = EMCALTrigger(aEsd,kEmcalL0);          break;
373     case kEmcalL1GammaHigh: decision = EMCALTrigger(aEsd,kEmcalL1GammaHigh); break;
374     case kEmcalL1GammaLow:  decision = EMCALTrigger(aEsd,kEmcalL1GammaLow);  break;
375     case kEmcalL1JetHigh:   decision = EMCALTrigger(aEsd,kEmcalL1JetHigh);   break;
376     case kEmcalL1JetLow:    decision = EMCALTrigger(aEsd,kEmcalL1JetLow);    break;
377     case kTRDHCO:           decision = TRDTrigger(aEsd,kTRDHCO); break;
378     case kTRDHJT:           decision = TRDTrigger(aEsd,kTRDHJT); break;
379     case kTRDHSE:           decision = TRDTrigger(aEsd,kTRDHSE); break;
380     case kTRDHQU:           decision = TRDTrigger(aEsd,kTRDHQU); break;
381     case kTRDHEE:           decision = TRDTrigger(aEsd,kTRDHEE); break;
382     case kNSD1:             decision = SPDFiredChips(aEsd, 0) >= 5 || (V0Trigger(aEsd, kASide, kFALSE) == kV0BB && V0Trigger(aEsd, kCSide, kFALSE) == kV0BB); break;
383     case kFPANY:            decision |= SPDGFOTrigger(aEsd, 0); 
384                             decision |= V0Trigger(aEsd, kASide, kFALSE) == kV0BB;
385                             decision |= V0Trigger(aEsd, kCSide, kFALSE) == kV0BB;
386                             decision |= ZDCTrigger(aEsd, kASide);
387                             decision |= ZDCTrigger(aEsd, kCentralBarrel);
388                             decision |= ZDCTrigger(aEsd, kCSide);
389                             decision |= FMDTrigger(aEsd, kASide);
390                             decision |= FMDTrigger(aEsd, kCSide);
391                             break; 
392     case kMB1Prime:         decision |= SPDGFOTrigger(aEsd, 0) && V0Trigger(aEsd, kASide, kFALSE) == kV0BB;
393                             decision |= SPDGFOTrigger(aEsd, 0) && V0Trigger(aEsd, kCSide, kFALSE) == kV0BB;
394                             decision |= V0Trigger(aEsd, kASide, kFALSE) == kV0BB && V0Trigger(aEsd, kCSide, kFALSE) == kV0BB;
395                             break; 
396     default:                AliFatal(Form("Trigger type %d not implemented", triggerNoFlags));
397   }
398   
399   // hadron-level requirement: SPD tracklets
400   if (decision && (trigger & kOneParticle))  {
401     decision = kFALSE;
402     
403     const AliESDVertex* vertex = aEsd->GetPrimaryVertexSPD();
404     const AliMultiplicity* mult = aEsd->GetMultiplicity();
405     
406     if (mult && vertex && vertex->GetNContributors() > 0 && (!vertex->IsFromVertexerZ() || vertex->GetDispersion() < 0.02) && TMath::Abs(vertex->GetZ()) < 5.5)    {
407       for (Int_t i=0; i<mult->GetNumberOfTracklets(); ++i) {
408         if (TMath::Abs(mult->GetEta(i)) < 1) {
409           decision = kTRUE;
410           break;
411         }
412       }
413     }
414   }
415   
416   // hadron level requirement: TPC tracks
417   if (decision && (trigger & kOneTrack)) {
418     decision = kFALSE;
419     const AliESDVertex* vertex =0x0;
420     vertex = aEsd->GetPrimaryVertexTracks();
421     if (!vertex || vertex->GetNContributors() <= 0) vertex = aEsd->GetPrimaryVertexSPD();
422     Float_t ptmin, ptmax;
423     fEsdTrackCuts->GetPtRange(ptmin,ptmax);
424     AliDebug(3, Form("ptmin = %f, ptmax = %f\n",ptmin, ptmax));
425     
426     if (vertex && vertex->GetNContributors() > 0 && (!vertex->IsFromVertexerZ() || vertex->GetDispersion() < 0.02) && TMath::Abs(vertex->GetZ()) < 10.) {
427       AliDebug(3,Form("Check on the vertex passed\n"));
428       for (Int_t i=0; i<aEsd->GetNumberOfTracks(); ++i){
429         if (fTPCOnly == kFALSE){
430           if (fEsdTrackCuts->AcceptTrack(aEsd->GetTrack(i))){
431             AliDebug(2, Form("pt of track = %f --> check passed\n",aEsd->GetTrack(i)->Pt()));
432             decision = kTRUE;
433             break;
434           }
435         }
436         else {
437           // TPC only tracks
438           AliESDtrack *tpcTrack = fEsdTrackCuts->GetTPCOnlyTrack((AliESDEvent*)aEsd, i);
439           if (!tpcTrack){
440             AliDebug(3,Form("track %d is NOT a TPC track",i));
441             continue;
442           }
443           else{
444             AliDebug(3,Form("track %d IS a TPC track",i));
445             if (!(fEsdTrackCuts->AcceptTrack(tpcTrack))) {
446               AliDebug(2, Form("TPC track %d NOT ACCEPTED, pt = %f, eta = %f",i,tpcTrack->Pt(), tpcTrack->Eta()));
447               delete tpcTrack; tpcTrack = 0x0;
448               continue;
449             } // end if the TPC track is not accepted
450             else{
451               AliDebug(2, Form("TPC track %d ACCEPTED, pt = %f, eta = %f",i,tpcTrack->Pt(), tpcTrack->Eta()));
452               decision = kTRUE;
453               delete tpcTrack; tpcTrack = 0x0;
454               break;
455             } // end if the TPC track is accepted
456           } // end if it is a TPC track
457         } // end if you are looking at TPC only tracks                  
458       } // end loop on tracks
459     } // end check on vertex
460     else{
461       AliDebug(4,Form("Check on the vertex not passed\n"));
462       for (Int_t i=0; i<aEsd->GetNumberOfTracks(); ++i){
463         if (fEsdTrackCuts->AcceptTrack(aEsd->GetTrack(i))){
464           AliDebug(4,Form("pt of track = %f --> check would be passed if the vertex was ok\n",aEsd->GetTrack(i)->Pt()));
465           break;
466         }
467       }
468     }
469     if (!decision) AliDebug(3,("Check for kOneTrack NOT passed\n"));
470   }
471   
472   return decision;
473 }
474
475
476
477 //-------------------------------------------------------------------------------------------------
478 Int_t AliTriggerAnalysis::SPDFiredChips(const AliESDEvent* aEsd, Int_t origin, Bool_t fillHists, Int_t layer){
479   // returns the number of fired chips in the SPD
480   //
481   // origin = 0 --> aEsd->GetMultiplicity()->GetNumberOfFiredChips() (filled from clusters)
482   // origin = 1 --> aEsd->GetMultiplicity()->TestFastOrFiredChips() (from hardware bits)
483   // layer  = 0 --> both layers
484   // layer  = 1 --> inner
485   // layer  = 2 --> outer
486   
487   const AliMultiplicity* mult = aEsd->GetMultiplicity();
488   if (!mult) { AliFatal("AliMultiplicity not available"); return 0; }
489   
490   if (origin == 0) {
491     if (layer == 0) return mult->GetNumberOfFiredChips(0) + mult->GetNumberOfFiredChips(1);
492     return mult->GetNumberOfFiredChips(layer-1); 
493   }
494   
495   if (origin == 1) {
496     Int_t nChips = 0;
497     Int_t firstChip = 0;
498     Int_t lastChip  = 1200;
499     if(layer == 1) lastChip  = 400;
500     if(layer == 2) firstChip = 400;
501
502     for (Int_t i=firstChip; i<lastChip; i++) {
503       if (mult->TestFastOrFiredChips(i)) {
504         // efficiency simulation (if enabled)
505         if (fSPDGFOEfficiency) if (gRandom->Uniform() > fSPDGFOEfficiency->GetBinContent(i+1)) continue;
506         nChips++;
507         if (fillHists) fHistFiredBitsSPD->Fill(i);
508       }
509     }
510     return nChips;
511   }
512   
513   return -1;
514 }
515
516
517 //-------------------------------------------------------------------------------------------------
518 Int_t AliTriggerAnalysis::SSDClusters(const AliVEvent* event){ 
519   return event->GetNumberOfITSClusters(4)+event->GetNumberOfITSClusters(5); 
520 }
521
522
523 //-------------------------------------------------------------------------------------------------
524 AliTriggerAnalysis::V0Decision AliTriggerAnalysis::V0Trigger(const AliESDEvent* aEsd, AliceSide side, Bool_t online, Bool_t fillHists){
525   // Returns the V0 trigger decision in V0A | V0C
526   //
527   // Returns kV0Fake if the calculated average time is in a window where neither BB nor BG is expected. 
528   // The rate of such triggers can be used to estimate the background. Note that the rate has to be 
529   // rescaled with the size of the windows (numerical values see below in the code)
530   //
531   // argument 'online' is used as a switch between online and offline trigger algorithms
532   //
533   // Based on an algorithm by Cvetan Cheshkov
534   
535   AliESDVZERO* esdV0 = aEsd->GetVZEROData();
536   if (!esdV0) { AliError("AliESDVZERO not available");  return kV0Invalid; }
537   if (side != kASide && side != kCSide) return kV0Invalid;
538   
539   AliDebug(2,Form("In V0Trigger: %f %f",esdV0->GetV0ATime(),esdV0->GetV0CTime()));
540   
541   Int_t begin = (side == kASide) ? 32 :  0;
542   Int_t end   = (side == kASide) ? 64 : 32;
543   
544   if (esdV0->TestBit(AliESDVZERO::kDecisionFilled)) {
545     if (online) {
546       if (esdV0->TestBit(AliESDVZERO::kOnlineBitsFilled)) {
547         for (Int_t i = begin; i < end; ++i) if (esdV0->GetBBFlag(i)) return kV0BB;
548         for (Int_t i = begin; i < end; ++i) if (esdV0->GetBGFlag(i)) return kV0BG;
549         return kV0Empty;
550       }
551       else {
552         AliWarning("V0 online trigger analysis is not yet available!");
553         return kV0BB;
554       }
555     }
556     else {
557       if (fillHists) {
558         if (side == kASide && fHistV0A) fHistV0A->Fill(esdV0->GetV0ATime());
559         if (side == kCSide && fHistV0C) fHistV0C->Fill(esdV0->GetV0CTime());
560       }
561       if      (side == kASide) return (V0Decision) esdV0->GetV0ADecision();
562       else if (side == kCSide) return (V0Decision) esdV0->GetV0CDecision();
563     }
564   }
565   
566   Float_t time = 0;
567   Float_t weight = 0;
568   if (fMC) {
569     Int_t runRange;
570     if      (aEsd->GetRunNumber() <= 104803) runRange = 0;
571     else if (aEsd->GetRunNumber() <= 104876) runRange = 1;
572     else runRange = 2;
573     
574     Float_t factors[3][64] = {
575       /*104792-104803*/ {4.6,5.9,6.3,6.0,4.7,5.9,4.9,5.4,4.8,4.1,4.9,4.6,4.5,5.5,5.1,5.8,4.3,4.0,4.0,3.3,3.1,2.9,3.0,5.6,3.3,4.9,3.9,5.3,4.1,4.4,3.9,5.5,5.7,9.5,5.1,5.3,6.6,7.1,8.9,4.4,4.1,5.9,9.0,4.5,4.1,6.0,4.7,7.1,4.2,4.7,3.9,6.3,5.9,4.8,4.7,4.5,4.7,5.4,5.8,5.0,5.1,5.9,5.3,3.6},
576       /*104841-104876*/ {4.6,4.8,4.9,4.8,4.3,4.9,4.4,4.5,4.6,5.0,4.7,4.6,4.7,4.6,4.6,5.5,4.7,4.5,4.7,5.0,6.5,7.6,5.3,4.9,5.5,4.8,4.6,4.9,4.5,4.5,4.6,4.9,5.7,9.8,4.9,5.2,7.1,7.1,8.1,4.4,4.0,6.0,8.3,4.6,4.2,5.6,4.6,6.4,4.4,4.7,4.5,6.5,6.0,4.7,4.5,4.4,4.8,5.5,5.9,5.3,5.0,5.7,5.1,3.6},
577       /*104890-104892*/ {4.7,5.2,4.8,5.0,4.4,5.0,4.4,4.6,4.6,4.5,4.4,4.6,4.5,4.6,4.8,5.5,4.8,4.5,4.4,4.3,5.4,7.7,5.6,5.0,5.4,4.3,4.5,4.8,4.5,4.5,4.6,5.3,5.7,9.6,4.9,5.4,6.1,7.2,8.6,4.4,4.0,5.4,8.8,4.4,4.2,5.8,4.7,6.7,4.3,4.7,4.0,6.1,6.0,4.9,4.8,4.6,4.7,5.2,5.7,5.0,5.0,5.8,5.3,3.6}
578     };
579     Float_t dA = 77.4 - 11.0;
580     Float_t dC = 77.4 - 2.9;
581     // Time misalignment
582     Float_t timeShift[64] = {0.477957 , 0.0889999 , 0.757669 , 0.205439 , 0.239666 , -0.183705 , 0.442873 , -0.281366 , 0.260976 , 0.788995 , 0.974758 , 0.548532 , 0.495023 , 0.868472 , 0.661167 , 0.358307 , 0.221243 , 0.530179 , 1.26696 , 1.33082 , 1.27086 , 1.77133 , 1.10253 , 0.634806 , 2.14838 , 1.50212 , 1.59253 , 1.66122 , 1.16957 , 1.52056 , 1.47791 , 1.81905 , -1.94123 , -1.29124 , -2.16045 , -1.78939 , -3.11111 , -1.87178 , -1.57671 , -1.70311 , -1.81208 , -1.94475 , -2.53058 , -1.7042 , -2.08109 , -1.84416 , -0.61073 , -1.77145 , 0.16999 , -0.0585339 , 0.00401133 , 0.397726 , 0.851111 , 0.264187 , 0.59573 , -0.158263 , 0.584362 , 1.20835 , 0.927573 , 1.13895 , 0.64648 , 2.18747 , 1.68909 , 0.451194};
583     Float_t dA2 = 2.8, dC2 = 3.3;
584     
585     if (online) {
586       for (Int_t i = begin; i < end; ++i) {
587         Float_t tempAdc = esdV0->GetAdc(i)/factors[runRange][i];
588         Float_t tempTime = (i >= 32) ? esdV0->GetTime(i)+dA+timeShift[i]+dA2 : esdV0->GetTime(i)+dC+timeShift[i]+dC2;
589         if (esdV0->GetTime(i) >= 1e-6 && tempTime > fV0HwWinLow && tempTime < fV0HwWinHigh && tempAdc > fV0HwAdcThr) return kV0BB;
590       }
591       return kV0Empty;
592     }
593     else {
594       for (Int_t i = begin; i < end; ++i) {
595         Float_t tempAdc = esdV0->GetAdc(i)/factors[runRange][i];
596         Float_t tempTime = (i >= 32) ? esdV0->GetTime(i)+dA : esdV0->GetTime(i)+dC;
597         Float_t tempRawTime = (i >= 32) ? esdV0->GetTime(i)+dA+timeShift[i]+dA2 : esdV0->GetTime(i)+dC+timeShift[i]+dC2;
598         if (esdV0->GetTime(i) >= 1e-6 && tempRawTime < 125.0 && tempAdc > fV0AdcThr) {
599           weight += 1.0;
600           time += tempTime;
601         }
602       }
603     }
604   }
605   else {
606     if (online) {
607       for (Int_t i = begin; i < end; ++i) {
608         if (esdV0->GetTime(i) >= 1e-6 && esdV0->GetTime(i) > fV0HwWinLow && esdV0->GetTime(i) < fV0HwWinHigh && esdV0->GetAdc(i) > fV0HwAdcThr) return kV0BB;
609       }
610       return kV0Empty;
611     }
612     else {
613       for (Int_t i = begin; i < end; ++i) {
614         if (esdV0->GetTime(i) > 1e-6 && esdV0->GetAdc(i) > fV0AdcThr) {
615           Float_t correctedTime = V0CorrectLeadingTime(i, esdV0->GetTime(i), esdV0->GetAdc(i),aEsd->GetRunNumber());
616           Float_t timeWeight = V0LeadingTimeWeight(esdV0->GetAdc(i));
617           time += correctedTime*timeWeight;
618           weight += timeWeight;
619         }
620       }
621     }
622   }
623   
624   if (weight > 0) time /= weight;
625   time += fV0TimeOffset;
626   
627   if (fillHists) {
628     if (side == kASide && fHistV0A) fHistV0A->Fill(time);
629     if (side == kCSide && fHistV0C) fHistV0C->Fill(time);
630   }
631   
632   if (side == kASide) {
633     if (time > 68 && time < 100)  return kV0BB;
634     if (time > 54 && time < 57.5) return kV0BG;
635     if (time > 57.5 && time < 68) return kV0Fake;
636   }
637   if (side == kCSide) {
638     if (time > 75.5 && time < 100) return kV0BB;
639     if (time > 69.5 && time < 73)  return kV0BG; 
640     if (time > 55 && time < 69.5)  return kV0Fake;
641   }
642   
643   return kV0Empty;
644 }
645
646
647 //-------------------------------------------------------------------------------------------------
648 Float_t AliTriggerAnalysis::V0CorrectLeadingTime(Int_t i, Float_t time, Float_t adc, Int_t runNumber) const {
649   // Correct for slewing and align the channels
650   // Authors: Cvetan Cheshkov / Raphael Tieulent
651   if (time == 0) return 0;
652
653   // Time alignment
654   Float_t timeShift[64] = {0.477957 , 0.0889999 , 0.757669 , 0.205439 , 0.239666 , -0.183705 , 0.442873 , -0.281366 , 0.260976 , 0.788995 , 0.974758 , 0.548532 , 0.495023 , 0.868472 , 0.661167 , 0.358307 , 0.221243 , 0.530179 , 1.26696 , 1.33082 , 1.27086 , 1.77133 , 1.10253 , 0.634806 , 2.14838 , 1.50212 , 1.59253 , 1.66122 , 1.16957 , 1.52056 , 1.47791 , 1.81905 , -1.94123 , -1.29124 , -2.16045 , -1.78939 , -3.11111 , -1.87178 , -1.57671 , -1.70311 , -1.81208 , -1.94475 , -2.53058 , -1.7042 , -2.08109 , -1.84416 , -0.61073 , -1.77145 , 0.16999 , -0.0585339 , 0.00401133 , 0.397726 , 0.851111 , 0.264187 , 0.59573 , -0.158263 , 0.584362 , 1.20835 , 0.927573 , 1.13895 , 0.64648 , 2.18747 , 1.68909 , 0.451194};
655   
656   if(runNumber < 106031) time -= timeShift[i];
657   
658   // Slewing correction
659   if (adc == 0) return time;
660   
661   Double_t p1 = 1.57345e+1;
662   Double_t p2 =-4.25603e-1;
663   
664   if(runNumber >= 106031) adc *= (2.5/4.0);
665   return (time - p1*TMath::Power(adc,p2));
666 }
667
668
669 //-------------------------------------------------------------------------------------------------
670 Float_t AliTriggerAnalysis::V0LeadingTimeWeight(Float_t adc) const {
671   if (adc < 1e-6) return 0;
672   
673   Float_t p1 = 40.211;
674   Float_t p2 =-4.25603e-1;
675   Float_t p3 = 0.5646;
676   
677   return 1./(p1*p1*TMath::Power(adc,2.*(p2-1.))+p3*p3);
678 }
679
680
681 //-------------------------------------------------------------------------------------------------
682 Bool_t AliTriggerAnalysis::ZDCTDCTrigger(const AliESDEvent* aEsd, AliceSide side, Bool_t useZN, Bool_t useZP, Bool_t fillHists) const{
683   // Returns if ZDC triggered, based on TDC information 
684   
685   AliESDZDC *esdZDC = aEsd->GetESDZDC();
686   
687   Bool_t zdcNA = kFALSE;
688   Bool_t zdcNC = kFALSE;
689   Bool_t zdcPA = kFALSE;
690   Bool_t zdcPC = kFALSE;
691   
692   if (fMC) { // If it's MC, we use the energy
693     Double_t minEnergy = 0;
694     zdcNA = esdZDC->GetZDCN2Energy()>minEnergy;
695     zdcNC = esdZDC->GetZDCN1Energy()>minEnergy;
696     zdcPA = esdZDC->GetZDCP2Energy()>minEnergy;
697     zdcPC = esdZDC->GetZDCP1Energy()>minEnergy;
698   }
699   else {
700     Bool_t tdc[32] = {kFALSE};
701     for(Int_t itdc=0; itdc<32; itdc++){
702       for(Int_t i=0; i<4; i++) tdc[itdc] |= esdZDC->GetZDCTDCData(itdc, i)!=0;
703       if(fillHists && tdc[itdc]) fHistTDCZDC->Fill(itdc);
704     }
705     zdcNA = tdc[12];
706     zdcNC = tdc[10];
707     zdcPA = tdc[13];
708     zdcPC = tdc[11];
709   }
710   
711   if (side == kASide) return ((useZP && zdcPA) || (useZN && zdcNA)); 
712   if (side == kCSide) return ((useZP && zdcPC) || (useZN && zdcNC)); 
713   return kFALSE;
714 }
715
716
717 //-------------------------------------------------------------------------------------------------
718 Bool_t AliTriggerAnalysis::ZDCTimeTrigger(const AliESDEvent *aEsd, Bool_t fillHists) const {
719   // This method implements a selection based on the timing in both sides of zdcN
720   // It can be used in order to eliminate parasitic collisions
721   AliESDZDC *esdZDC = aEsd->GetESDZDC();
722   
723   if(fMC) {
724     UInt_t esdFlag =  esdZDC->GetESDQuality();
725     Bool_t znaFired  = (esdFlag & 0x01) == 0x01;
726     Bool_t zncFired  = (esdFlag & 0x10) == 0x10;
727     return znaFired | zncFired;
728   }
729   else {
730     for(Int_t i=0;i<4;++i) {
731       if (esdZDC->GetZDCTDCData(10,i)==0) continue;
732       Float_t tdcC = 0.025*(esdZDC->GetZDCTDCData(10,i)-esdZDC->GetZDCTDCData(14,i)); 
733       Float_t tdcCcorr = esdZDC->GetZDCTDCCorrected(10,i); 
734       for(Int_t j=0;j<4;++j) {
735         if (esdZDC->GetZDCTDCData(12,j)==0) continue;
736         Float_t tdcA = 0.025*(esdZDC->GetZDCTDCData(12,j)-esdZDC->GetZDCTDCData(14,j));
737         Float_t tdcAcorr = esdZDC->GetZDCTDCCorrected(12,j);
738         if(fillHists) {
739           fHistTimeZDC->Fill(tdcC-tdcA,tdcC+tdcA);
740           fHistTimeCorrZDC->Fill(tdcCcorr-tdcAcorr,tdcCcorr+tdcAcorr);
741         }
742         if (esdZDC->TestBit(AliESDZDC::kCorrectedTDCFilled)) {
743           if (TMath::Power((tdcCcorr-tdcAcorr-fZDCCutRefDeltaCorr)/fZDCCutSigmaDeltaCorr,2.)+
744               TMath::Power((tdcCcorr+tdcAcorr-fZDCCutRefSumCorr  )/fZDCCutSigmaSumCorr,2.) < 1.) return kTRUE;
745         }
746         else {
747           if (TMath::Power((tdcC-tdcA-fZDCCutRefDelta)/fZDCCutSigmaDelta,2.)+
748               TMath::Power((tdcC+tdcA-fZDCCutRefSum  )/fZDCCutSigmaSum,2.  )<1.0) return kTRUE;
749         }
750       }
751     }
752   }
753   return kFALSE;
754 }
755
756
757 //-------------------------------------------------------------------------------------------------
758 Bool_t AliTriggerAnalysis::ZDCTimeBGTrigger(const AliESDEvent *aEsd, AliceSide side) const{
759   // This method implements a selection based on the timing in zdcN
760   // It can be used in order to flag background
761   if(fMC) return kFALSE;
762   
763   AliESDZDC* zdcData = aEsd->GetESDZDC();
764   Bool_t znabadhit = kFALSE;
765   Bool_t zncbadhit = kFALSE;
766   
767   Float_t tdcCcorr=999, tdcAcorr=999;
768   for(Int_t i = 0; i < 4; ++i) {
769     if (zdcData->GetZDCTDCData(10,i)==0) continue;
770     tdcCcorr = TMath::Abs(zdcData->GetZDCTDCCorrected(10,i));
771     if(tdcCcorr<fZDCCutZNCTimeCorrMax && tdcCcorr>fZDCCutZNCTimeCorrMin) zncbadhit = kTRUE;
772   }
773   for(Int_t i = 0; i < 4; ++i) {
774     if (zdcData->GetZDCTDCData(12,i)==0) continue;
775     tdcAcorr = TMath::Abs(zdcData->GetZDCTDCCorrected(12,i));
776     if(tdcAcorr<fZDCCutZNATimeCorrMax && tdcAcorr>fZDCCutZNATimeCorrMin) znabadhit = kTRUE;
777   }
778   
779   if (side == kASide) return znabadhit;
780   if (side == kCSide) return zncbadhit;
781
782   return kFALSE;
783 }
784
785
786 //-------------------------------------------------------------------------------------------------
787 Bool_t AliTriggerAnalysis::ZDCTrigger(const AliESDEvent* aEsd, AliceSide side) const {
788   // Returns if ZDC triggered
789   
790   AliESDZDC* zdcData = aEsd->GetESDZDC();
791   UInt_t quality = zdcData->GetESDQuality();
792
793   // from Nora's presentation, general first physics meeting 16.10.09
794   static UInt_t zpc  = 0x20;
795   static UInt_t znc  = 0x10;
796   static UInt_t zem1 = 0x08;
797   static UInt_t zem2 = 0x04;
798   static UInt_t zpa  = 0x02;
799   static UInt_t zna  = 0x01;
800   
801   if (side == kASide         && ((quality & zpa)  || (quality & zna ))) return kTRUE;
802   if (side == kCentralBarrel && ((quality & zem1) || (quality & zem2))) return kTRUE;
803   if (side == kCSide         && ((quality & zpc)  || (quality & znc ))) return kTRUE;
804   
805   return kFALSE;
806 }
807
808
809 //-------------------------------------------------------------------------------------------------
810 Int_t AliTriggerAnalysis::FMDHitCombinations(const AliESDEvent* aEsd, AliceSide side, Bool_t fillHists){
811   // returns number of hit combinations above threshold
812   // Authors: FMD team, Hans Dalsgaard (code merged from FMD/AliFMDOfflineTrigger)
813   if (!fDoFMD) return -1;
814   
815   // Workaround for AliESDEvent::GetFMDData is not const!
816   const AliESDFMD* fmdData = (const_cast<AliESDEvent*>(aEsd))->GetFMDData();
817   if (!fmdData) {
818     AliError("AliESDFMD not available");
819     return -1;
820   }
821   
822   Int_t detFrom = (side == kASide) ? 1 : 3;
823   Int_t detTo   = (side == kASide) ? 2 : 3;
824   
825   Int_t triggers = 0;
826   Float_t totalMult = 0;
827   for (UShort_t det=detFrom;det<=detTo;det++) {
828     Int_t nRings = (det == 1 ? 1 : 2);
829     for (UShort_t ir = 0; ir < nRings; ir++) {
830       Char_t   ring = (ir == 0 ? 'I' : 'O');
831       UShort_t nsec = (ir == 0 ? 20  : 40);
832       UShort_t nstr = (ir == 0 ? 512 : 256);
833       for (UShort_t sec =0; sec < nsec;  sec++) {
834         for (UShort_t strip = 0; strip < nstr; strip++) {
835           Float_t mult = fmdData->Multiplicity(det,ring,sec,strip);
836           if (mult == AliESDFMD::kInvalidMult) continue;
837           if (fillHists) fHistFMDSingle->Fill(mult);
838           if (mult > fFMDLowCut)
839             totalMult = totalMult + mult;
840           else {
841             if (totalMult > fFMDHitCut) triggers++;
842             if (fillHists) fHistFMDSum->Fill(totalMult);
843             totalMult = 0;
844           }
845         }
846       }
847     }
848   }
849   return triggers;
850 }
851
852
853 //-------------------------------------------------------------------------------------------------
854 Bool_t AliTriggerAnalysis::FMDTrigger(const AliESDEvent* aEsd, AliceSide side){
855   // Returns if the FMD triggered
856   // Authors: FMD team, Hans Dalsgaard (code merged from FMD/AliFMDOfflineTrigger)
857   return FMDHitCombinations(aEsd, side, kFALSE);
858 }
859
860
861 //-------------------------------------------------------------------------------------------------
862 AliTriggerAnalysis::T0Decision AliTriggerAnalysis::T0Trigger(const AliESDEvent* aEsd, Bool_t online, Bool_t fillHists){
863   // Returns the T0 TVDC trigger decision
864   //  
865   // argument 'online' is used as a switch between online and offline trigger algorithms
866   // in online mode return 0TVX 
867   // in offline mode in addition check pile-up and background :
868   // pile-up readed from ESD: check if TVDC (0TVX module name) has more 1 hit;
869   // backgroud flag readed from ESD : check in given time interval OrA and OrC were correct but TVDC not  
870   // 
871   // Based on an algorithm by Alla Maevskaya 
872   
873   const AliESDTZERO* esdT0 = aEsd->GetESDTZERO();
874   if (!esdT0) {
875     AliError("AliESDTZERO not available");
876     return kT0Invalid;
877   }
878
879   Float_t  tvdc0 = esdT0->GetTVDC(0);
880   if(fillHists) fHistT0->Fill(tvdc0);
881   
882   if (online) {
883     if( aEsd->GetHeader()->IsTriggerInputFired("0TVX")) return kT0BB;
884   }
885   else {
886     if (esdT0->GetPileupFlag()) return kT0DecPileup;
887     if (esdT0->GetBackgroundFlag()) return kT0DecBG;
888     if (tvdc0>-5 && tvdc0<5 && tvdc0!=0) return kT0BB; 
889   }
890   
891   if (fMC) if(esdT0->GetT0zVertex()>-12.3 && esdT0->GetT0zVertex() < 10.3) return kT0BB; 
892   return kT0Empty;
893 }
894
895 //-------------------------------------------------------------------------------------------------
896 Bool_t AliTriggerAnalysis::EMCALCellsTrigger(const AliESDEvent *aEsd){
897   //
898   // Returns the EMCAL trigger decision
899   // so far only implemented for LHC11a data
900   // see http://alisoft.cern.ch/viewvc/trunk/PWGGA/EMCALTasks/AliEmcalPhysicsSelection.cxx?view=markup&root=AliRoot Revision 56136
901   //
902   
903   Bool_t isFired = kTRUE;
904   const Int_t runNumber = aEsd->GetRunNumber();
905   
906   /*
907   // Load EMCAL branches from the manager
908   AliAnalysisManager *am = AliAnalysisManager::GetAnalysisManager();
909   am->LoadBranch("EMCALCells.");
910   am->LoadBranch("CaloClusters");
911    */
912   
913   // Get EMCAL cells
914   AliVCaloCells *cells = aEsd->GetEMCALCells();
915   const Short_t nCells = cells->GetNumberOfCells();
916   
917   // count cells above threshold per sm
918   Int_t nCellCount[10] = {0,0,0,0,0,0,0,0,0,0};
919   for(Int_t iCell=0; iCell<nCells; ++iCell) {
920     Short_t cellId = cells->GetCellNumber(iCell);
921     Double_t cellE = cells->GetCellAmplitude(cellId);
922     Int_t sm       = cellId / (24*48);
923     if (cellE>0.1)
924       ++nCellCount[sm];
925   }
926   
927   // Trigger decision for LHC11a
928   Bool_t isLedEvent = kFALSE;
929   if ((runNumber>=144871) && (runNumber<=146860)) {
930     if (nCellCount[4] > 100)
931       isLedEvent = kTRUE;
932     else {
933       if ((runNumber>=146858) && (runNumber<=146860)) {
934         if (nCellCount[3]>=35)
935           isLedEvent = kTRUE;
936       }
937     }
938   }
939   
940   if (isLedEvent) {
941     isFired = kFALSE;
942   }
943   
944   return isFired;
945 }
946
947
948 //----------------------------------------------------------------------------------------------------
949 Bool_t AliTriggerAnalysis::TRDTrigger(const AliESDEvent *esd, Trigger trigger){
950   // evaluate the TRD trigger conditions,
951   // so far HCO, HSE, HQU, HJT, HEE
952   if(trigger!=kTRDHCO && trigger!=kTRDHJT && trigger!=kTRDHSE && trigger!=kTRDHQU && trigger!=kTRDHEE) {
953     AliWarning("Beware you are erroneously trying to use this function (wrong trigger)");
954     return kFALSE;
955   }
956   
957   Int_t nTrdTracks = esd->GetNumberOfTrdTracks();
958   if (nTrdTracks<=0) return kFALSE;
959   if      (trigger==kTRDHCO) return kTRUE;
960   else if (trigger!=kTRDHJT) {
961     for (Int_t iTrack = 0; iTrack < nTrdTracks; ++iTrack) {
962       AliESDTrdTrack *trdTrack = esd->GetTrdTrack(iTrack);
963       if (!trdTrack) continue;
964       // for the electron triggers we only consider matched tracks
965       if(trigger==kTRDHQU) if (TMath::Abs(trdTrack->Pt())>fTRDptHQU && trdTrack->GetPID()>fTRDpidHQU) return kTRUE;
966       if(trigger==kTRDHSE) if (TMath::Abs(trdTrack->Pt())>fTRDptHSE && trdTrack->GetPID()>fTRDpidHSE) return kTRUE; 
967       if(trigger==kTRDHEE) if (TMath::Abs(trdTrack->Pt())>fTRDptHSE && trdTrack->GetPID()>fTRDpidHSE && trdTrack->GetSector()>=fTRDminSectorHEE && trdTrack->GetSector()<=fTRDmaxSectorHEE) return kTRUE;
968     }
969   } 
970   else if (trigger==kTRDHJT) {
971     Int_t nTracks[90] = { 0 }; // stack-wise counted number of tracks above pt threshold
972     for (Int_t iTrack = 0; iTrack < nTrdTracks; ++iTrack) {
973       AliESDTrdTrack *trdTrack = esd->GetTrdTrack(iTrack);    
974       if (!trdTrack) continue;
975       Int_t globalStack = 5*trdTrack->GetSector() + trdTrack->GetStack();
976       // stack-wise counting of tracks above pt threshold for jet trigger
977       if (TMath::Abs(trdTrack->GetPt()) >= fTRDptHJT) ++nTracks[globalStack];
978     }
979     // check if HJT condition is fulfilled in any stack
980     for (Int_t iStack = 0; iStack < 90; iStack++) if (nTracks[iStack] >= fTRDnHJT) return kTRUE;
981   }
982   return kFALSE;
983 }
984
985
986 //-------------------------------------------------------------------------------------------------
987 Bool_t AliTriggerAnalysis::EMCALTrigger(const AliVEvent* event, Trigger trigger){
988   AliVCaloTrigger* emcalTrigger = event->GetCaloTrigger("EMCAL");
989   if (!emcalTrigger) return kFALSE;
990   Int_t emcalTriggerBits = 0;
991   emcalTrigger->GetTriggerBits(emcalTriggerBits);
992   if      (trigger==kEmcalL0         ) { return emcalTriggerBits & 1<<0; }
993   else if (trigger==kEmcalL1GammaHigh) { return emcalTriggerBits & 1<<1; }
994   else if (trigger==kEmcalL1GammaLow ) { return emcalTriggerBits & 1<<2; }
995   else if (trigger==kEmcalL1JetHigh  ) { return emcalTriggerBits & 1<<3; }
996   else if (trigger==kEmcalL1JetLow   ) { return emcalTriggerBits & 1<<4; }
997   else {
998     AliWarning("Beware you are erroneously trying to use this function (wrong trigger)");
999     return kFALSE;
1000   }
1001   return kFALSE;
1002 }
1003
1004
1005 //-------------------------------------------------------------------------------------------------
1006 Bool_t AliTriggerAnalysis::IsSPDClusterVsTrackletBG(const AliVEvent* event, Bool_t fillHists){
1007   // rejects BG based on the cluster vs tracklet correlation
1008   // returns true if the event is BG
1009   const AliVMultiplicity* mult = event->GetMultiplicity();
1010   if (!mult) { AliFatal("No multiplicity object"); return 0; }
1011   Int_t ntracklet   = mult->GetNumberOfTracklets();
1012   Int_t spdClusters = event->GetNumberOfITSClusters(0) + event->GetNumberOfITSClusters(1);
1013   if(fillHists) fHistSPDClsVsTrk->Fill(ntracklet,spdClusters);
1014   return spdClusters > Float_t(fASPDCvsTCut) + Float_t(ntracklet)*fBSPDCvsTCut;
1015 }
1016
1017
1018 //-------------------------------------------------------------------------------------------------
1019 Bool_t AliTriggerAnalysis::IsLaserWarmUpTPCEvent(const AliESDEvent* esd){
1020   // This function flags noisy TPC events which can happen during laser warm-up.
1021   Int_t trackCounter = 0;
1022   for (Int_t i=0; i<esd->GetNumberOfTracks(); ++i) {
1023     AliESDtrack *track = esd->GetTrack(i);
1024     if (!track) continue;
1025     if (track->GetTPCNcls() < 30) continue;
1026     if (TMath::Abs(track->Eta()) > 0.005) continue;
1027     if (track->Pt() < 4) continue;
1028     if (track->GetKinkIndex(0) > 0) continue;
1029     UInt_t status = track->GetStatus();
1030     if ((status&AliESDtrack::kITSrefit)==AliESDtrack::kITSrefit) continue; // explicitly ask for tracks without ITS refit
1031     if ((status&AliESDtrack::kTPCrefit)!=AliESDtrack::kTPCrefit) continue;
1032     if (track->GetTPCsignal() > 10) continue;          // explicitly ask for tracks without dE/dx
1033     trackCounter++;
1034   }
1035   if (trackCounter > 15) return kTRUE;
1036   return kFALSE;
1037 }
1038
1039
1040 //-------------------------------------------------------------------------------------------------
1041 Bool_t AliTriggerAnalysis::IsHVdipTPCEvent(const AliESDEvent* esd) {
1042   // This function flags events in which the TPC chamber HV is not at its nominal value
1043   if (fMC) return kFALSE; // there are no dip events in MC
1044   if (!esd->IsDetectorOn(AliDAQ::kTPC)) return kTRUE;
1045   return kFALSE;
1046 }
1047
1048
1049 //-------------------------------------------------------------------------------------------------
1050 Bool_t AliTriggerAnalysis::IsIncompleteEvent(const AliESDEvent* esd){
1051   // Check whether the event is incomplete 
1052   // (due to DAQ-HLT issues, it could be only part of the event was saved)
1053   if (fMC) return kFALSE; // there are no incomplete events on MC
1054   if ((esd->GetEventType() == 7) &&
1055       (esd->GetDAQDetectorPattern() & (1<<4)) &&
1056       !(esd->GetDAQAttributes() & (1<<7))) return kTRUE;
1057   return kFALSE;
1058 }
1059
1060
1061 //-------------------------------------------------------------------------------------------------
1062 Long64_t AliTriggerAnalysis::Merge(TCollection* list){
1063   // Merge a list of objects with this (needed for PROOF).
1064   // Returns the number of merged objects (including this).
1065   if (!list) return 0;
1066   if (list->IsEmpty()) return 1;
1067   TIterator* iter = list->MakeIterator();
1068   TObject* obj;
1069   
1070   // collections of all histograms
1071   const Int_t nHists = 14;
1072   TList collections[nHists];
1073   
1074   Int_t count = 0;
1075   while ((obj = iter->Next())) {
1076     AliTriggerAnalysis* entry = dynamic_cast<AliTriggerAnalysis*> (obj);
1077     if (entry == 0) continue;
1078     Int_t n = 0;
1079     collections[n++].Add(entry->fHistV0A);
1080     collections[n++].Add(entry->fHistV0C);
1081     collections[n++].Add(entry->fHistZDC);
1082     collections[n++].Add(entry->fHistTDCZDC);
1083     collections[n++].Add(entry->fHistTimeZDC);
1084     collections[n++].Add(entry->fHistTimeCorrZDC);
1085     collections[n++].Add(entry->fHistFMDA);
1086     collections[n++].Add(entry->fHistFMDC);
1087     collections[n++].Add(entry->fHistFMDSingle);
1088     collections[n++].Add(entry->fHistFMDSum);
1089     collections[n++].Add(entry->fHistBitsSPD);
1090     collections[n++].Add(entry->fHistFiredBitsSPD);
1091     collections[n++].Add(entry->fHistSPDClsVsTrk);
1092     collections[n++].Add(entry->fHistT0);
1093     
1094     // merge fTriggerClasses
1095     TIterator* iter2 = entry->fTriggerClasses->MakeIterator();
1096     TObjString* obj2 = 0;
1097     while ((obj2 = dynamic_cast<TObjString*> (iter2->Next()))) {
1098       TParameter<Long64_t>* param2 = static_cast<TParameter<Long64_t>*> (entry->fTriggerClasses->GetValue(obj2));
1099       TParameter<Long64_t>* param1 = dynamic_cast<TParameter<Long64_t>*> (fTriggerClasses->GetValue(obj2));
1100       if (param1) { param1->SetVal(param1->GetVal() + param2->GetVal()); }
1101       else {        
1102         param1 = dynamic_cast<TParameter<Long64_t>*> (param2->Clone());
1103         fTriggerClasses->Add(new TObjString(obj2->String()), param1);
1104       }
1105     }
1106     delete iter2;
1107     count++;
1108   }
1109   
1110   Int_t n = 0;
1111   fHistV0A->Merge(&collections[n++]);
1112   fHistV0C->Merge(&collections[n++]);
1113   fHistZDC->Merge(&collections[n++]);
1114   fHistTDCZDC->Merge(&collections[n++]);
1115   if (fHistTimeZDC)     fHistTimeZDC->Merge(&collections[n++]);     else n++;
1116   if (fHistTimeCorrZDC) fHistTimeCorrZDC->Merge(&collections[n++]); else n++;
1117   fHistFMDA->Merge(&collections[n++]);
1118   fHistFMDC->Merge(&collections[n++]);
1119   fHistFMDSingle->Merge(&collections[n++]);
1120   fHistFMDSum->Merge(&collections[n++]);
1121   fHistBitsSPD->Merge(&collections[n++]);
1122   fHistFiredBitsSPD->Merge(&collections[n++]);
1123   fHistSPDClsVsTrk->Merge(&collections[n++]);
1124   fHistT0->Merge(&collections[n++]);
1125   delete iter;
1126   return count+1;
1127 }
1128
1129
1130 //-------------------------------------------------------------------------------------------------
1131 void AliTriggerAnalysis::FillHistograms(const AliESDEvent* aEsd){
1132   // fills the histograms with the info from the ESD
1133   
1134   fHistBitsSPD->Fill(SPDFiredChips(aEsd, 0), SPDFiredChips(aEsd, 1, kTRUE));
1135   
1136   V0Trigger(aEsd, kASide, kFALSE, kTRUE);
1137   V0Trigger(aEsd, kCSide, kFALSE, kTRUE);
1138   T0Trigger(aEsd, kFALSE, kTRUE);
1139   ZDCTDCTrigger(aEsd,kASide,kFALSE,kFALSE,kTRUE);
1140   ZDCTimeTrigger(aEsd,kTRUE);
1141   IsSPDClusterVsTrackletBG(aEsd, kTRUE);
1142   
1143   AliESDZDC* zdcData = aEsd->GetESDZDC();
1144   if (zdcData)  {
1145     UInt_t quality = zdcData->GetESDQuality();
1146     
1147     // from Nora's presentation, general first physics meeting 16.10.09
1148     static UInt_t zpc  = 0x20;
1149     static UInt_t znc  = 0x10;
1150     static UInt_t zem1 = 0x08;
1151     static UInt_t zem2 = 0x04;
1152     static UInt_t zpa  = 0x02;
1153     static UInt_t zna  = 0x01;
1154     
1155     fHistZDC->Fill(1, (quality & zna)  ? 1 : 0);
1156     fHistZDC->Fill(2, (quality & zpa)  ? 1 : 0);
1157     fHistZDC->Fill(3, (quality & zem2) ? 1 : 0);
1158     fHistZDC->Fill(4, (quality & zem1) ? 1 : 0);
1159     fHistZDC->Fill(5, (quality & znc)  ? 1 : 0);
1160     fHistZDC->Fill(6, (quality & zpc)  ? 1 : 0);
1161   }
1162   else {
1163     fHistZDC->Fill(-1);
1164     AliError("AliESDZDC not available");
1165   }
1166   
1167   if (fDoFMD) {
1168     fHistFMDA->Fill(FMDHitCombinations(aEsd, kASide, kTRUE));
1169     fHistFMDC->Fill(FMDHitCombinations(aEsd, kCSide, kTRUE));
1170   }
1171 }
1172
1173
1174 //-------------------------------------------------------------------------------------------------
1175 void AliTriggerAnalysis::SaveHistograms() const {
1176   // write histograms to current directory
1177   if (fHistBitsSPD)      fHistBitsSPD->Write();
1178   if (fHistFiredBitsSPD) fHistFiredBitsSPD->Write();
1179   if (fHistV0A)          fHistV0A->Write();
1180   if (fHistV0C)          fHistV0C->Write();
1181   if (fHistZDC)          fHistZDC->Write();
1182   if (fHistTDCZDC)       fHistTDCZDC->Write();
1183   if (fHistTimeZDC)      fHistTimeZDC->Write();
1184   if (fHistTimeCorrZDC)  fHistTimeCorrZDC->Write();
1185   if (fHistFMDA)         fHistFMDA->Write();
1186   if (fHistFMDC)         fHistFMDC->Write();
1187   if (fHistFMDSingle)    fHistFMDSingle->Write();
1188   if (fHistFMDSum)       fHistFMDSum->Write();
1189   if (fSPDGFOEfficiency) fSPDGFOEfficiency->Write("fSPDGFOEfficiency");
1190   if (fHistSPDClsVsTrk)  fHistSPDClsVsTrk->Write("fHistSPDClsVsTrk");
1191   if (fHistT0)           fHistT0->Write("fHistT0");
1192   fTriggerClasses->Write("fTriggerClasses", TObject::kSingleKey);
1193 }
1194
1195
1196 //-------------------------------------------------------------------------------------------------
1197 void AliTriggerAnalysis::FillTriggerClasses(const AliESDEvent* aEsd){
1198   // fills trigger classes map
1199   TParameter<Long64_t>* count = dynamic_cast<TParameter<Long64_t>*> (fTriggerClasses->GetValue(aEsd->GetFiredTriggerClasses().Data()));
1200   if (!count) {
1201     count = new TParameter<Long64_t>(aEsd->GetFiredTriggerClasses(), 0);
1202     fTriggerClasses->Add(new TObjString(aEsd->GetFiredTriggerClasses().Data()), count);
1203   }
1204   count->SetVal(count->GetVal() + 1);
1205 }
1206
1207
1208 //-------------------------------------------------------------------------------------------------
1209 void AliTriggerAnalysis::PrintTriggerClasses() const {
1210   // print trigger classes
1211   
1212   Printf("Trigger Classes:");
1213   Printf("Event count for trigger combinations:");
1214   TMap singleTrigger;
1215   singleTrigger.SetOwner();
1216   TIterator* iter = fTriggerClasses->MakeIterator();
1217   TObjString* obj = 0;
1218   while ((obj = dynamic_cast<TObjString*> (iter->Next()))) {
1219     TParameter<Long64_t>* param = static_cast<TParameter<Long64_t>*> (fTriggerClasses->GetValue(obj));
1220     Printf(" %s: %ld triggers", obj->String().Data(), (Long_t)param->GetVal());
1221     TObjArray* tokens = obj->String().Tokenize(" ");
1222     for (Int_t i=0; i<tokens->GetEntries(); i++) {
1223       TParameter<Long64_t>* count = dynamic_cast<TParameter<Long64_t>*> (singleTrigger.GetValue(((TObjString*) tokens->At(i))->String().Data()));
1224       if (!count) {
1225         count = new TParameter<Long64_t>(((TObjString*) tokens->At(i))->String().Data(), 0);
1226         singleTrigger.Add(new TObjString(((TObjString*) tokens->At(i))->String().Data()), count);
1227       }
1228       count->SetVal(count->GetVal() + param->GetVal());
1229     }
1230     delete tokens;
1231   }
1232   delete iter;
1233   
1234   Printf("Event count for single trigger:");
1235   iter = singleTrigger.MakeIterator();
1236   while ((obj = dynamic_cast<TObjString*> (iter->Next()))) {
1237     TParameter<Long64_t>* param = static_cast<TParameter<Long64_t>*> (singleTrigger.GetValue(obj));
1238     Printf("  %s: %ld triggers", obj->String().Data(), (Long_t)param->GetVal());
1239   }
1240   delete iter;
1241   singleTrigger.DeleteAll();
1242 }