AliPhysics  f05a842 (f05a842)
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
AliCaloTrackReader.cxx
Go to the documentation of this file.
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 // --- ROOT system ---
17 #include <TFile.h>
18 #include <TGeoManager.h>
19 #include <TStreamerInfo.h>
20 
21 // ---- ANALYSIS system ----
22 #include "AliMCEvent.h"
23 #include "AliAODMCHeader.h"
24 #include "AliGenPythiaEventHeader.h"
25 #include "AliGenCocktailEventHeader.h"
26 #include "AliGenHijingEventHeader.h"
27 #include "AliESDEvent.h"
28 #include "AliAODEvent.h"
29 #include "AliVTrack.h"
30 #include "AliVParticle.h"
31 #include "AliMixedEvent.h"
32 //#include "AliTriggerAnalysis.h"
33 #include "AliESDVZERO.h"
34 #include "AliVCaloCells.h"
35 #include "AliAnalysisManager.h"
36 #include "AliInputEventHandler.h"
37 #include "AliAODMCParticle.h"
38 #include "AliStack.h"
39 #include "AliLog.h"
40 #include "AliMultSelection.h"
41 
42 // ---- Detectors ----
43 #include "AliPHOSGeoUtils.h"
44 #include "AliEMCALGeometry.h"
45 #include "AliEMCALRecoUtils.h"
46 
47 // ---- CaloTrackCorr ---
48 #include "AliCalorimeterUtils.h"
49 #include "AliCaloTrackReader.h"
50 
51 // ---- Jets ----
52 #include "AliAODJet.h"
53 #include "AliAODJetEventBackground.h"
54 
58 
59 //________________________________________
61 //________________________________________
63 TObject(), fEventNumber(-1), //fCurrentFileName(""),
64 fDataType(0), fDebug(0),
65 fFiducialCut(0x0), fCheckFidCut(kFALSE),
66 fComparePtHardAndJetPt(0), fPtHardAndJetPtFactor(0),
67 fComparePtHardAndClusterPt(0),fPtHardAndClusterPtFactor(0),
68 fCTSPtMin(0), fEMCALPtMin(0), fPHOSPtMin(0),
69 fCTSPtMax(0), fEMCALPtMax(0), fPHOSPtMax(0),
70 fEMCALBadChMinDist(0), fPHOSBadChMinDist (0),
71 fEMCALNCellsCut(0), fPHOSNCellsCut(0),
72 fUseEMCALTimeCut(1), fUseParamTimeCut(0),
73 fUseTrackTimeCut(0), fAccessTrackTOF(0),
74 fEMCALTimeCutMin(-10000), fEMCALTimeCutMax(10000),
75 fEMCALParamTimeCutMin(), fEMCALParamTimeCutMax(),
76 fTrackTimeCutMin(-10000), fTrackTimeCutMax(10000),
77 fUseTrackDCACut(0),
78 fAODBranchList(0x0),
79 fCTSTracks(0x0), fEMCALClusters(0x0),
80 fDCALClusters(0x0), fPHOSClusters(0x0),
81 fEMCALCells(0x0), fPHOSCells(0x0),
82 fInputEvent(0x0), fOutputEvent(0x0),fMC(0x0),
83 fFillCTS(0), fFillEMCAL(0),
84 fFillDCAL(0), fFillPHOS(0),
85 fFillEMCALCells(0), fFillPHOSCells(0),
86 fRecalculateClusters(kFALSE),fCorrectELinearity(kTRUE),
87 fSelectEmbeddedClusters(kFALSE),
88 fSmearShowerShape(0), fSmearShowerShapeWidth(0), fRandom(),
89 fSmearingFunction(0), fSmearNLMMin(0), fSmearNLMMax(0),
90 fTrackStatus(0), fSelectSPDHitTracks(0),
91 fTrackMult(0), fTrackMultEtaCut(0.9),
92 fReadStack(kFALSE), fReadAODMCParticles(kFALSE),
93 fDeltaAODFileName(""), fFiredTriggerClassName(""),
94 
95 fEventTriggerMask(0), fMixEventTriggerMask(0), fEventTriggerAtSE(0),
96 fEventTrigMinBias(0), fEventTrigCentral(0),
97 fEventTrigSemiCentral(0), fEventTrigEMCALL0(0),
98 fEventTrigEMCALL1Gamma1(0), fEventTrigEMCALL1Gamma2(0),
99 fEventTrigEMCALL1Jet1(0), fEventTrigEMCALL1Jet2(0),
100 fBitEGA(0), fBitEJE(0),
101 
102 fEventType(-1),
103 fTaskName(""), fCaloUtils(0x0),
104 fWeightUtils(0x0), fEventWeight(1),
105 fMixedEvent(NULL), fNMixedEvent(0), fVertex(NULL),
106 fListMixedTracksEvents(), fListMixedCaloEvents(),
107 fLastMixedTracksEvent(-1), fLastMixedCaloEvent(-1),
108 fWriteOutputDeltaAOD(kFALSE),
109 fEMCALClustersListName(""), fZvtxCut(0.),
110 fAcceptFastCluster(kFALSE), fRemoveLEDEvents(kFALSE),
111 //Trigger rejection
112 fRemoveBadTriggerEvents(0), fTriggerPatchClusterMatch(1),
113 fTriggerPatchTimeWindow(), fTriggerL0EventThreshold(0),
114 fTriggerL1EventThreshold(0), fTriggerL1EventThresholdFix(0),
115 fTriggerClusterBC(0), fTriggerClusterIndex(0), fTriggerClusterId(0),
116 fIsExoticEvent(0), fIsBadCellEvent(0), fIsBadMaxCellEvent(0),
117 fIsTriggerMatch(0), fIsTriggerMatchOpenCut(),
118 fTriggerClusterTimeRecal(kTRUE), fRemoveUnMatchedTriggers(kTRUE),
119 fDoPileUpEventRejection(kFALSE), fDoV0ANDEventSelection(kFALSE),
120 fDoVertexBCEventSelection(kFALSE),
121 fDoRejectNoTrackEvents(kFALSE),
122 fUseEventsWithPrimaryVertex(kFALSE),
123 //fTriggerAnalysis (0x0),
124 fTimeStampEventSelect(0),
125 fTimeStampEventFracMin(0), fTimeStampEventFracMax(0),
126 fTimeStampRunMin(0), fTimeStampRunMax(0),
127 fNPileUpClusters(-1), fNNonPileUpClusters(-1), fNPileUpClustersCut(3),
128 fVertexBC(-200), fRecalculateVertexBC(0),
129 fUseAliCentrality(0), fCentralityClass(""), fCentralityOpt(0),
130 fEventPlaneMethod(""),
131 fAcceptOnlyHIJINGLabels(0), fNMCProducedMin(0), fNMCProducedMax(0),
132 fFillInputNonStandardJetBranch(kFALSE),
133 fNonStandardJets(new TClonesArray("AliAODJet",100)), fInputNonStandardJetBranchName("jets"),
134 fFillInputBackgroundJetBranch(kFALSE),
135 fBackgroundJets(0x0),fInputBackgroundJetBranchName("jets"),
136 fAcceptEventsWithBit(0), fRejectEventsWithBit(0), fRejectEMCalTriggerEventsWith2Tresholds(0),
137 fMomentum(), fOutputContainer(0x0), fEnergyHistogramNbins(0),
138 fhNEventsAfterCut(0)
139 {
140  for(Int_t i = 0; i < 8; i++) fhEMCALClusterCutsE [i]= 0x0 ;
141  for(Int_t i = 0; i < 7; i++) fhPHOSClusterCutsE [i]= 0x0 ;
142  for(Int_t i = 0; i < 6; i++) fhCTSTrackCutsPt [i]= 0x0 ;
143 
144  InitParameters();
145 }
146 
147 //_______________________________________
149 //_______________________________________
151 {
152  DeletePointers();
153 }
154 
155 //_______________________________________
158 //_______________________________________
160 {
161  delete fFiducialCut ;
162 
163  if(fAODBranchList)
164  {
165  fAODBranchList->Delete();
166  delete fAODBranchList ;
167  }
168 
169  if(fCTSTracks)
170  {
171  if(fDataType!=kMC)fCTSTracks->Clear() ;
172  else fCTSTracks->Delete() ;
173  delete fCTSTracks ;
174  }
175 
176  if(fEMCALClusters)
177  {
178  if(fDataType!=kMC)fEMCALClusters->Clear("C") ;
179  else fEMCALClusters->Delete() ;
180  delete fEMCALClusters ;
181  }
182 
183  if(fDCALClusters)
184  {
185  if(fDataType!=kMC)fDCALClusters->Clear("C") ;
186  else fDCALClusters->Delete() ;
187  delete fDCALClusters ;
188  }
189 
190  if(fPHOSClusters)
191  {
192  if(fDataType!=kMC)fPHOSClusters->Clear("C") ;
193  else fPHOSClusters->Delete() ;
194  delete fPHOSClusters ;
195  }
196 
197  if(fVertex)
198  {
199  for (Int_t i = 0; i < fNMixedEvent; i++)
200  {
201  delete [] fVertex[i] ;
202 
203  }
204  delete [] fVertex ;
205  }
206 
207  //delete fTriggerAnalysis;
208 
209  if(fNonStandardJets)
210  {
211  if(fDataType!=kMC) fNonStandardJets->Clear("C") ;
212  else fNonStandardJets->Delete() ;
213  delete fNonStandardJets ;
214  }
215  delete fBackgroundJets ;
216 
217  fRejectEventsWithBit.Reset();
218  fAcceptEventsWithBit.Reset();
219 
220  if ( fWeightUtils ) delete fWeightUtils ;
221 
222  // Pointers not owned, done by the analysis frame
223  // if(fInputEvent) delete fInputEvent ;
224  // if(fOutputEvent) delete fOutputEvent ;
225  // if(fMC) delete fMC ;
226  // Pointer not owned, deleted by maker
227  // if (fCaloUtils) delete fCaloUtils ;
228 }
229 
230 //____________________________________________________________
234 //____________________________________________________________
236 {
237  Float_t cut = fTrackDCACut[0]+fTrackDCACut[1]/TMath::Power(pt,fTrackDCACut[2]);
238 
239  if(TMath::Abs(dca) < cut)
240  return kTRUE;
241  else
242  return kFALSE;
243 }
244 
245 //_____________________________________________________
248 //_____________________________________________________
250 {
251  Int_t nAccept = fAcceptEventsWithBit.GetSize();
252 
253  //printf("N accept %d\n", nAccept);
254 
255  if( nAccept <= 0 )
256  return kTRUE ; // accept the event
257 
258  UInt_t trigFired = ((AliInputEventHandler*)(AliAnalysisManager::GetAnalysisManager()->GetInputEventHandler()))->IsEventSelected();
259 
260  for(Int_t ibit = 0; ibit < nAccept; ibit++)
261  {
262  Bool_t accept = (trigFired & fAcceptEventsWithBit.At(ibit));
263 
264  //printf("accept %d, ibit %d, bit %d \n",accept, ibit,fAcceptEventsWithBit.At(ibit));
265  if(accept) return kTRUE ; // accept the event
266  }
267 
268  return kFALSE ; // reject the event
269 }
270 
271 //_____________________________________________________
274 //_____________________________________________________
276 {
277  Int_t nReject = fRejectEventsWithBit.GetSize();
278 
279  //printf("N reject %d\n", nReject);
280 
281  if( nReject <= 0 )
282  return kTRUE ; // accept the event
283 
284  UInt_t trigFired = ((AliInputEventHandler*)(AliAnalysisManager::GetAnalysisManager()->GetInputEventHandler()))->IsEventSelected();
285 
286  for(Int_t ibit = 0; ibit < nReject; ibit++)
287  {
288  Bool_t reject = (trigFired & fRejectEventsWithBit.At(ibit));
289 
290  //printf("reject %d, ibit %d, bit %d \n",reject, ibit,fRejectEventsWithBit.At(ibit));
291  if(reject) return kFALSE ; // reject the event
292  }
293 
294  return kTRUE ; // accept the event
295 }
296 
297 //_____________________________________________
301 //_____________________________________________
303 {
304  //-----------------------------------------------------------
305  // Reject events depending on the trigger name
306  //-----------------------------------------------------------
307 
308  AliDebug(1,Form("FiredTriggerClass <%s>, selected class <%s>, compare name %d",
311 
312  if ( fFiredTriggerClassName != "" )
313  {
315  return kFALSE;
316  else
317  AliDebug(1,"Accepted triggered event");
318  }
319 
320  fhNEventsAfterCut->Fill(1.5);
321 
322  //-----------------------------------------------------------
323  // Reject events depending on the event species type
324  //-----------------------------------------------------------
325 
326  // Event types:
327  // kStartOfRun = 1, // START_OF_RUN
328  // kEndOfRun = 2, // END_OF_RUN
329  // kStartOfRunFiles = 3, // START_OF_RUN_FILES
330  // kEndOfRunFiles = 4, // END_OF_RUN_FILES
331  // kStartOfBurst = 5, // START_OF_BURST
332  // kEndOfBurst = 6, // END_OF_BURST
333  // kPhysicsEvent = 7, // PHYSICS_EVENT
334  // kCalibrationEvent = 8, // CALIBRATION_EVENT
335  // kFormatError = 9, // EVENT_FORMAT_ERROR
336  // kStartOfData = 10, // START_OF_DATA
337  // kEndOfData = 11, // END_OF_DATA
338  // kSystemSoftwareTriggerEvent = 12, // SYSTEM_SOFTWARE_TRIGGER_EVENT
339  // kDetectorSoftwareTriggerEvent = 13 // DETECTOR_SOFTWARE_TRIGGER_EVENT
340 
341  Int_t eventType = 0;
342  if(fInputEvent->GetHeader())
343  eventType = ((AliVHeader*)fInputEvent->GetHeader())->GetEventType();
344 
345  AliDebug(3,Form("Event type %d",eventType));
346 
347  // Select only Physics events in data, eventType = 7,
348  // usually done by physics selection
349  // MC not set, eventType =0, I think, so do not apply a value to fEventType by default
350  // LED events have eventType = 8, implemented a selection cut in the past
351  // but not really useful for EMCal data since LED are not reconstructed (unless wrongly assumed as physics)
352 
353  if ( fEventType >= 0 && eventType != fEventType ) return kFALSE ;
354 
355  AliDebug(1,"Pass event species selection");
356 
357  fhNEventsAfterCut->Fill(2.5);
358 
359  //-----------------------------------------------------------------
360  // In case of mixing analysis, select here the trigger of the event
361  //-----------------------------------------------------------------
362 
363  UInt_t isTrigger = kFALSE;
364  UInt_t isMB = kFALSE;
365 
366  if(!fEventTriggerAtSE)
367  {
368  // In case of mixing analysis, accept MB events, not only Trigger
369  // Track and cluster arrays filled for MB in order to create the pool in the corresponding analysis
370  // via de method in the base class FillMixedEventPool()
371 
372  AliAnalysisManager *manager = AliAnalysisManager::GetAnalysisManager();
373  AliInputEventHandler *inputHandler = dynamic_cast<AliInputEventHandler*>(manager->GetInputEventHandler());
374 
375  if(!inputHandler) return kFALSE ; // to content coverity
376 
377  isTrigger = inputHandler->IsEventSelected() & fEventTriggerMask;
378  isMB = inputHandler->IsEventSelected() & fMixEventTriggerMask;
379 
380  if(!isTrigger && !isMB) return kFALSE;
381 
382  //printf("Selected triggered event : %s\n",GetFiredTriggerClasses().Data());
383  AliDebug(0,"Pass uninteresting triggered events rejection in case of mixing analysis");
384 
385  fhNEventsAfterCut->Fill(3.5);
386  }
387 
388 
389  //-------------------------------------------------------------------------------------
390  // Reject or accept events depending on the trigger bit
391  //-------------------------------------------------------------------------------------
392 
395 
396  //printf("AliCaloTrackReader::FillInputEvent() - Accept event? %d, Reject event %d? \n",okA,okR);
397 
398  if(!okA || !okR) return kFALSE;
399 
400  AliDebug(1,"Pass event bit rejection");
401 
402  fhNEventsAfterCut->Fill(4.5);
403 
404  //----------------------------------------------------------------------
405  // Do not count events that were likely triggered by an exotic cluster
406  // or out BC cluster
407  //----------------------------------------------------------------------
408 
409  // Set a bit with the event kind, MB, L0, L1 ...
411 
412  // In case of Mixing, avoid checking the triggers in the min bias events
413  if(!fEventTriggerAtSE && (isMB && !isTrigger)) return kTRUE;
414 
416  {
418  {
419  // Reject triggered events when there is coincidence on both EMCal trigger thresholds,
420  // but the requested trigger is the low trigger threshold
421  if(IsEventEMCALL1Jet1 () && IsEventEMCALL1Jet2 () && fFiredTriggerClassName.Contains("EJ2")) return kFALSE;
422  if(IsEventEMCALL1Gamma1() && IsEventEMCALL1Gamma2() && fFiredTriggerClassName.Contains("EG2")) return kFALSE;
423  }
424 
425  //Get Patches that triggered
427 
428  MatchTriggerCluster(patches);
429 
430  patches.Reset();
431 
432  // If requested, remove badly triggeed events, but only when the EMCal trigger bit is set
434  {
435  AliDebug(1,Form("ACCEPT triggered event? \n exotic? %d - bad cell %d - bad Max cell %d - BC %d - Matched %d\n",
437  if (fIsExoticEvent) return kFALSE;
438  else if(fIsBadCellEvent) return kFALSE;
439  else if(fRemoveUnMatchedTriggers && !fIsTriggerMatch) return kFALSE ;
440  else if(fTriggerClusterBC != 0) return kFALSE;
441  AliDebug(1,Form("\t *** YES for %s",GetFiredTriggerClasses().Data()));
442  }
443 
444  AliDebug(1,"Pass EMCal triggered event rejection \n");
445 
446  fhNEventsAfterCut->Fill(5.5);
447  }
448 
449  //-------------------------------------------------------------------------------------
450  // Select events only fired by a certain trigger configuration if it is provided
451  //-------------------------------------------------------------------------------------
452 
453  if (GetFiredTriggerClasses().Contains("FAST") && !GetFiredTriggerClasses().Contains("ALL") && !fAcceptFastCluster)
454  {
455  AliDebug(1,Form("Do not count events from fast cluster, trigger name %s\n",fFiredTriggerClassName.Data()));
456  return kFALSE;
457 
458  fhNEventsAfterCut->Fill(6.5);
459  }
460 
461  //-------------------------------------------------------------------------------------
462  // Reject event if large clusters with large energy
463  // Use only for LHC11a data for the moment, and if input is clusterizer V1 or V1+unfolding
464  // If clusterzer NxN or V2 it does not help
465  //-------------------------------------------------------------------------------------
466 
467  //Int_t run = fInputEvent->GetRunNumber();
468 
469  if ( fRemoveLEDEvents )
470  {
472 
473  if(reject) return kFALSE;
474 
475  AliDebug(1,"Pass LED event rejection");
476 
477  fhNEventsAfterCut->Fill(7.5);
478  } // Remove LED events
479 
480  // All selection criteria passed, accept the event
481  return kTRUE ;
482 }
483 
484 //________________________________________________
489 //________________________________________________
491 {
492  //printf("AliCaloTrackReader::ComparePtHardAndJetPt() - GenHeaderName : %s\n",GetGenEventHeader()->ClassName());
493 
494  if(!strcmp(GetGenEventHeader()->ClassName(), "AliGenPythiaEventHeader"))
495  {
496  TParticle * jet = 0;
497  AliGenPythiaEventHeader* pygeh= (AliGenPythiaEventHeader*) GetGenEventHeader();
498  Int_t nTriggerJets = pygeh->NTriggerJets();
499  Float_t ptHard = pygeh->GetPtHard();
500 
501  AliDebug(1,Form("Njets: %d, pT Hard %f",nTriggerJets, ptHard));
502 
503  Float_t tmpjet[]={0,0,0,0};
504  for(Int_t ijet = 0; ijet< nTriggerJets; ijet++)
505  {
506  pygeh->TriggerJet(ijet, tmpjet);
507  jet = new TParticle(94, 21, -1, -1, -1, -1, tmpjet[0],tmpjet[1],tmpjet[2],tmpjet[3], 0,0,0,0);
508 
509  AliDebug(1,Form("jet %d; pycell jet pT %f",ijet, jet->Pt()));
510 
511  //Compare jet pT and pt Hard
512  if(jet->Pt() > fPtHardAndJetPtFactor * ptHard)
513  {
514  AliInfo(Form("Reject jet event with : pT Hard %2.2f, pycell jet pT %2.2f, rejection factor %1.1f\n",
515  ptHard, jet->Pt(), fPtHardAndJetPtFactor));
516  return kFALSE;
517  }
518  }
519 
520  if(jet) delete jet;
521  }
522 
523  return kTRUE ;
524 }
525 
526 //____________________________________________________
531 //____________________________________________________
533 {
534  if(!strcmp(GetGenEventHeader()->ClassName(), "AliGenPythiaEventHeader"))
535  {
536  AliGenPythiaEventHeader* pygeh= (AliGenPythiaEventHeader*) GetGenEventHeader();
537  Float_t ptHard = pygeh->GetPtHard();
538 
539  Int_t nclusters = fInputEvent->GetNumberOfCaloClusters();
540  for (Int_t iclus = 0; iclus < nclusters; iclus++)
541  {
542  AliVCluster * clus = fInputEvent->GetCaloCluster(iclus) ;
543  Float_t ecluster = clus->E();
544 
545  if(ecluster > fPtHardAndClusterPtFactor*ptHard)
546  {
547  AliInfo(Form("Reject : ecluster %2.2f, calo %d, factor %2.2f, ptHard %f",ecluster,clus->GetType(),fPtHardAndClusterPtFactor,ptHard));
548 
549  return kFALSE;
550  }
551  }
552 
553  }
554 
555  return kTRUE ;
556 }
557 
558 //___________________________________________________
561 //___________________________________________________
563 {
564 
565  fhNEventsAfterCut = new TH1I("hNEventsAfterCut", "Number of analyzed events", 18, 0, 18) ;
566  //fhNEventsAfterCut->SetXTitle("Selection");
567  fhNEventsAfterCut->SetYTitle("# events");
568  fhNEventsAfterCut->GetXaxis()->SetBinLabel(1 ,"1=Input");
569  fhNEventsAfterCut->GetXaxis()->SetBinLabel(2 ,"2=Trigger string");
570  fhNEventsAfterCut->GetXaxis()->SetBinLabel(3 ,"3=Event Type");
571  fhNEventsAfterCut->GetXaxis()->SetBinLabel(4 ,"4=Mixing Event");
572  fhNEventsAfterCut->GetXaxis()->SetBinLabel(5 ,"5=Trigger Bit");
573  fhNEventsAfterCut->GetXaxis()->SetBinLabel(6 ,"6=Good EMC Trigger");
574  fhNEventsAfterCut->GetXaxis()->SetBinLabel(7 ,"7=!Fast Cluster");
575  fhNEventsAfterCut->GetXaxis()->SetBinLabel(8 ,"8=!LED");
576  fhNEventsAfterCut->GetXaxis()->SetBinLabel(9 ,"9=PtHard-Jet");
577  fhNEventsAfterCut->GetXaxis()->SetBinLabel(10,"10=PtHard-Cluster");
578  fhNEventsAfterCut->GetXaxis()->SetBinLabel(11,"11=Time stamp");
579  fhNEventsAfterCut->GetXaxis()->SetBinLabel(12,"12=Z vertex");
580  fhNEventsAfterCut->GetXaxis()->SetBinLabel(13,"13=Primary vertex");
581  fhNEventsAfterCut->GetXaxis()->SetBinLabel(14,"14=Pile-up");
582  fhNEventsAfterCut->GetXaxis()->SetBinLabel(15,"15=V0AND");
583  fhNEventsAfterCut->GetXaxis()->SetBinLabel(16,"16=Centrality");
584  fhNEventsAfterCut->GetXaxis()->SetBinLabel(17,"17=Track multi.");
585  fhNEventsAfterCut->GetXaxis()->SetBinLabel(18,"18=TOF BC");
587 
588 
589  if(fFillEMCAL)
590  {
591  for(Int_t i = 0; i < 8; i++)
592  {
593  TString names[] = {"NoCut", "Corrected", "GoodCluster", "NonLinearity",
594  "EnergyAndFidutial", "Time", "NCells", "BadDist"};
595 
596  fhEMCALClusterCutsE[i] = new TH1F(Form("hEMCALReaderClusterCuts_%d_%s",i,names[i].Data()),
597  Form("EMCal %d, %s",i,names[i].Data()),
599  fhEMCALClusterCutsE[i]->SetYTitle("# clusters");
600  fhEMCALClusterCutsE[i]->SetXTitle("#it{E} (GeV)");
602  }
603  }
604 
605  if(fFillPHOS)
606  {
607  for(Int_t i = 0; i < 7; i++)
608  {
609  TString names[] = {"NoCut", "ExcludeCPV", "BorderCut", "FiducialCut", "EnergyCut", "NCells", "BadDist"};
610 
611  fhPHOSClusterCutsE[i] = new TH1F(Form("hPHOSReaderClusterCuts_%d_%s",i,names[i].Data()),
612  Form("PHOS Cut %d, %s",i,names[i].Data()),
614  fhPHOSClusterCutsE[i]->SetYTitle("# clusters");
615  fhPHOSClusterCutsE[i]->SetXTitle("#it{E} (GeV)");
617  }
618  }
619 
620  if(fFillCTS)
621  {
622  for(Int_t i = 0; i < 6; i++)
623  {
624  TString names[] = {"NoCut", "Status", "ESD_AOD", "TOF", "DCA","PtAcceptanceMult"};
625 
626  fhCTSTrackCutsPt[i] = new TH1F(Form("hCTSReaderClusterCuts_%d_%s",i,names[i].Data()),
627  Form("CTS Cut %d, %s",i,names[i].Data()),
629  fhCTSTrackCutsPt[i]->SetYTitle("# tracks");
630  fhCTSTrackCutsPt[i]->SetXTitle("#it{p}_{T} (GeV)");
632  }
633  }
634 
635  return fOutputContainer ;
636 }
637 
638 //_____________________________________________________
640 //_____________________________________________________
642 {
643  TString parList ; //this will be list of parameters used for this analysis.
644 
645  const Int_t buffersize = 255;
646  char onePar[buffersize] ;
647 
648  snprintf(onePar,buffersize,"--- Reader ---:") ;
649  parList+=onePar ;
650  snprintf(onePar,buffersize,"Data type: %d; zvertex cut %2.2f; EMC cluster name: <%s> ",fDataType, fZvtxCut, fEMCALClustersListName.Data()) ;
651  parList+=onePar ;
652  snprintf(onePar,buffersize,"Use detector: EMC %d, DCA %d, PHOS %d, CTS %d, EMCcells %d, PHOScells %d ; ",
654  snprintf(onePar,buffersize,"E-pT window: EMC (%2.1f,%2.1f), PHOS (%2.1f,%2.1f), CTS (%2.1f,%2.1f); ",
656  parList+=onePar ;
657  snprintf(onePar,buffersize,"Dist to bad channel: EMC > %2.1f, PHOS > %2.1f; ",fEMCALBadChMinDist,fPHOSBadChMinDist) ;
658  parList+=onePar ;
659  snprintf(onePar,buffersize,"N cells: EMC > %d, PHOS > %d; ",fEMCALNCellsCut,fPHOSNCellsCut) ;
660  parList+=onePar ;
661  snprintf(onePar,buffersize,"EMC time cut single window (%2.2f,%2.2f); ",fEMCALTimeCutMin,fEMCALTimeCutMax) ;
662  parList+=onePar ;
663  snprintf(onePar,buffersize,"Check: calo fid cut %d; ",fCheckFidCut) ;
664  parList+=onePar ;
665  snprintf(onePar,buffersize,"Track: status %d, multip. eta cut %1.1f, SPD hit %d; ",(Int_t) fTrackStatus, fTrackMultEtaCut, fSelectSPDHitTracks) ;
666  parList+=onePar ;
667 
668  if(fUseTrackDCACut)
669  {
670  snprintf(onePar,buffersize,"DCA cut ON, param (%2.4f,%2.4f,%2.4f); ",fTrackDCACut[0],fTrackDCACut[1],fTrackDCACut[2]) ;
671  parList+=onePar ;
672  }
673 
674  snprintf(onePar,buffersize,"Recalculate Clusters = %d, E linearity = %d; ",fRecalculateClusters, fCorrectELinearity) ;
675  parList+=onePar ;
676 
677  snprintf(onePar,buffersize,"SE trigger sel. %d, not? trigger Mask? %d, MB Trigger Mask for mixed %d; ",
679  parList+=onePar ;
680 
681  snprintf(onePar,buffersize,"Select fired trigger %s; Remove Bad trigger event %d, unmatched %d; Accept fastcluster %d, Reject LED %d ",
683  parList+=onePar ;
684 
686  {
687  snprintf(onePar,buffersize,"Accept HIJING only labels; ");
688  parList+=onePar ;
689  }
690 
692  {
693  snprintf(onePar,buffersize,"EMC M02 smear ON, function %d, param %2.4f, %d<=NLM<=%d; ",
695  parList+=onePar ;
696  }
697 
699  {
700  snprintf(onePar,buffersize,"jet pt / pt hard < %2.1f; ",fPtHardAndJetPtFactor);
701  parList+=onePar ;
702  }
703 
705  {
706  snprintf(onePar,buffersize,"cluster pt / pt hard < %2.2f",fPtHardAndClusterPtFactor);
707  parList+=onePar ;
708  }
709 
710  snprintf(onePar,buffersize,"Centrality: Class %s, Option %d, Bin [%d,%d]; New centrality %d; Event plane method %s; ",
712  parList+=onePar ;
713 
714  return new TObjString(parList) ;
715 }
716 
717 
718 //____________________________________________
720 //____________________________________________
722 {
723  if(fMC)
724  return fMC->Stack();
725  else
726  {
727  AliDebug(1,"Stack is not available");
728  return 0x0 ;
729  }
730 }
731 
732 //______________________________________________
734 //______________________________________________
736 {
737  if(fMC)
738  {
739  return fMC->Header();
740  }
741  else
742  {
743  AliInfo("Header is not available");
744  return 0x0 ;
745  }
746 }
747 
748 //____________________________________________________
752 //____________________________________________________
754 {
755  fNMCProducedMin = 0;
756  fNMCProducedMax = 0;
757 
758  if (ReadStack() && fMC)
759  {
760  AliGenEventHeader * eventHeader = fMC->GenEventHeader();
761 
762  if(!fAcceptOnlyHIJINGLabels) return ;
763 
764  // TODO Check if it works from here ...
765 
766  AliGenCocktailEventHeader *cocktail = dynamic_cast<AliGenCocktailEventHeader *>(eventHeader);
767 
768  if(!cocktail) return ;
769 
770  TList *genHeaders = cocktail->GetHeaders();
771 
772  Int_t nGenerators = genHeaders->GetEntries();
773  //printf("N generators %d \n", nGenerators);
774 
775  for(Int_t igen = 0; igen < nGenerators; igen++)
776  {
777  AliGenEventHeader * eventHeader2 = (AliGenEventHeader*)genHeaders->At(igen) ;
778  TString name = eventHeader2->GetName();
779 
780  //printf("Generator %d: Class Name %s, Name %s, title %s \n",igen, eventHeader2->ClassName(), name.Data(), eventHeader2->GetTitle());
781 
783  fNMCProducedMax+= eventHeader2->NProduced();
784 
785  if(name.Contains("Hijing",TString::kIgnoreCase)) return ;
786  }
787 
788  }
789  else if(ReadAODMCParticles() && GetAODMCHeader())
790  {
791  Int_t nGenerators = GetAODMCHeader()->GetNCocktailHeaders();
792  //printf("AliCaloTrackReader::GetGenEventHeader() - N headers %d\n",nGenerators);
793 
794  if( nGenerators <= 0) return ;
795 
796  if(!fAcceptOnlyHIJINGLabels) return ;
797 
798  for(Int_t igen = 0; igen < nGenerators; igen++)
799  {
800  AliGenEventHeader * eventHeader = GetAODMCHeader()->GetCocktailHeader(igen) ;
801  TString name = eventHeader->GetName();
802 
803  //printf("Generator %d: Class Name %s, Name %s, title %s \n",igen, eventHeader->ClassName(), name.Data(), eventHeader->GetTitle());
804 
806  fNMCProducedMax+= eventHeader->NProduced();
807 
808  if(name.Contains("Hijing",TString::kIgnoreCase)) return ;
809  }
810 
811  }
812 }
813 
814 //______________________________________________________________
817 //______________________________________________________________
818 AliGenEventHeader* AliCaloTrackReader::GetGenEventHeader() const
819 {
820  if (ReadStack() && fMC)
821  {
822  AliGenEventHeader * eventHeader = fMC->GenEventHeader();
823 
824  if(!fAcceptOnlyHIJINGLabels) return eventHeader ;
825 
826  // TODO Check if it works from here ...
827 
828  AliGenCocktailEventHeader *cocktail = dynamic_cast<AliGenCocktailEventHeader *>(eventHeader);
829 
830  if(!cocktail) return 0x0 ;
831 
832  TList *genHeaders = cocktail->GetHeaders();
833 
834  Int_t nGenerators = genHeaders->GetEntries();
835  //printf("N generators %d \n", nGenerators);
836 
837  for(Int_t igen = 0; igen < nGenerators; igen++)
838  {
839  AliGenEventHeader * eventHeader2 = (AliGenEventHeader*)genHeaders->At(igen) ;
840  TString name = eventHeader2->GetName();
841 
842  //printf("Generator %d: Class Name %s, Name %s, title %s \n",igen, eventHeader2->ClassName(), name.Data(), eventHeader2->GetTitle());
843 
844  if(name.Contains("Hijing",TString::kIgnoreCase)) return eventHeader2 ;
845  }
846 
847  return 0x0;
848 
849  }
850  else if(ReadAODMCParticles() && GetAODMCHeader())
851  {
852  Int_t nGenerators = GetAODMCHeader()->GetNCocktailHeaders();
853  //printf("AliCaloTrackReader::GetGenEventHeader() - N headers %d\n",nGenerators);
854 
855  if( nGenerators <= 0) return 0x0;
856 
857  if(!fAcceptOnlyHIJINGLabels) return GetAODMCHeader()->GetCocktailHeader(0);
858 
859  for(Int_t igen = 0; igen < nGenerators; igen++)
860  {
861  AliGenEventHeader * eventHeader = GetAODMCHeader()->GetCocktailHeader(igen) ;
862  TString name = eventHeader->GetName();
863 
864  //printf("Generator %d: Class Name %s, Name %s, title %s \n",igen, eventHeader->ClassName(), name.Data(), eventHeader->GetTitle());
865 
866  if(name.Contains("Hijing",TString::kIgnoreCase)) return eventHeader ;
867  }
868 
869  return 0x0;
870 
871  }
872  else
873  {
874  //printf("AliCaloTrackReader::GetGenEventHeader() - MC header not available! \n");
875  return 0x0;
876  }
877 }
878 
879 //_________________________________________________________
882 //_________________________________________________________
884 {
885  AliInfo("Input are not AODs");
886 
887  return NULL ;
888 }
889 
890 //________________________________________________________
893 //________________________________________________________
894 AliAODMCHeader* AliCaloTrackReader::GetAODMCHeader() const
895 {
896  AliInfo("Input are not AODs");
897 
898  return NULL ;
899 }
900 
901 //___________________________________________________________
909 //___________________________________________________________
910 Int_t AliCaloTrackReader::GetVertexBC(const AliVVertex * vtx)
911 {
912  Int_t vertexBC=vtx->GetBC();
913 
914  if(!fRecalculateVertexBC) return vertexBC;
915 
916  // Value not available, recalculate it.
917 
918  Double_t bz = fInputEvent->GetMagneticField();
919  Bool_t bc0 = kFALSE;
920  Int_t ntr = GetCTSTracks()->GetEntriesFast();
921  //printf("N Tracks %d\n",ntr);
922 
923  for(Int_t i = 0 ; i < ntr ; i++)
924  {
925  AliVTrack * track = (AliVTrack*) (GetCTSTracks()->At(i));
926 
927  //Check if has TOF info, if not skip
928  ULong_t status = track->GetStatus();
929  Bool_t okTOF = (status & AliVTrack::kTOFout) == AliVTrack::kTOFout ;
930  vertexBC = track->GetTOFBunchCrossing(bz);
931  Float_t pt = track->Pt();
932 
933  if(!okTOF) continue;
934 
935  // Get DCA x, y
936  Double_t dca[2] = {1e6,1e6};
937  Double_t covar[3] = {1e6,1e6,1e6};
938  track->PropagateToDCA(vtx,bz,100.,dca,covar);
939 
940  if(AcceptDCA(pt,dca[0]))
941  {
942  if (vertexBC !=0 && fVertexBC != AliVTrack::kTOFBCNA) return vertexBC;
943  else if(vertexBC == 0) bc0 = kTRUE;
944  }
945  }
946 
947  if( bc0 ) vertexBC = 0 ;
948  else vertexBC = AliVTrack::kTOFBCNA ;
949 
950  return vertexBC;
951 }
952 
953 //_____________________________
960 //_____________________________
962 {
963  return track->GetID();
964 }
965 
966 //_____________________________
969 //_____________________________
971 {
973  {
974  AliInfo("Cannot access stack and mcparticles at the same time, change them");
975  fReadStack = kFALSE;
976  fReadAODMCParticles = kFALSE;
977  }
978 
979  // Activate debug level in AliAnaWeights
980  if( fWeightUtils->GetDebug() >= 0 )
981  (AliAnalysisManager::GetAnalysisManager())->AddClassDebug(fWeightUtils->ClassName(), fWeightUtils->GetDebug());
982 }
983 
984 //_______________________________________
986 //_______________________________________
988 {
989  fDataType = kESD ;
990  fCTSPtMin = 0.1 ;
991  fEMCALPtMin = 0.1 ;
992  fPHOSPtMin = 0.1 ;
993  fCTSPtMax = 1000. ;
994  fEMCALPtMax = 1000. ;
995  fPHOSPtMax = 1000. ;
996 
997  fEMCALBadChMinDist = 0; // open, 2; // standard
998  fPHOSBadChMinDist = 0; // open, 2; // standard
999 
1000  fEMCALNCellsCut = 0; // open, 1; // standard
1001  fPHOSNCellsCut = 0; // open, 2; // standard
1002 
1003  //Track DCA cuts
1004  // dca_xy cut = 0.0105+0.0350/TMath::Power(pt,1.1);
1005  fTrackDCACut[0] = 0.0105;
1006  fTrackDCACut[1] = 0.0350;
1007  fTrackDCACut[2] = 1.1;
1008 
1009  //Do not filter the detectors input by default.
1010  fFillEMCAL = kFALSE;
1011  fFillDCAL = kFALSE;
1012  fFillPHOS = kFALSE;
1013  fFillCTS = kFALSE;
1014  fFillEMCALCells = kFALSE;
1015  fFillPHOSCells = kFALSE;
1016 
1017  fReadStack = kFALSE; // Check in the constructor of the other readers if it was set or in the configuration file
1018  fReadAODMCParticles = kFALSE; // Check in the constructor of the other readers if it was set or in the configuration file
1019  fDeltaAODFileName = "deltaAODPartCorr.root";
1021  fEventTriggerMask = AliVEvent::kAny;
1022  fMixEventTriggerMask = AliVEvent::kAnyINT;
1023  fEventTriggerAtSE = kTRUE; // Use only events that pass event selection at SE base class
1024 
1025  fAcceptFastCluster = kTRUE;
1026  fEventType = -1;
1027 
1028  //We want tracks fitted in the detectors:
1029  //fTrackStatus=AliESDtrack::kTPCrefit;
1030  //fTrackStatus|=AliESDtrack::kITSrefit;
1031  fTrackStatus = 0;
1032 
1033  fV0ADC[0] = 0; fV0ADC[1] = 0;
1034  fV0Mul[0] = 0; fV0Mul[1] = 0;
1035 
1036  fZvtxCut = 10.;
1037 
1038  fNMixedEvent = 1;
1039 
1040  fPtHardAndJetPtFactor = 7.;
1042 
1043  //Centrality
1044  fUseAliCentrality = kFALSE;
1045  fCentralityClass = "V0M";
1046  fCentralityOpt = 100;
1047  fCentralityBin[0] = fCentralityBin[1]=-1;
1048 
1049  fEventPlaneMethod = "V0";
1050 
1051  // Allocate memory (not sure this is the right place)
1052  fCTSTracks = new TObjArray();
1053  fEMCALClusters = new TObjArray();
1054  fDCALClusters = new TObjArray();
1055  fPHOSClusters = new TObjArray();
1056  //fTriggerAnalysis = new AliTriggerAnalysis;
1057  fAODBranchList = new TList ;
1058  fOutputContainer = new TList ;
1059 
1060  fEnergyHistogramNbins = 200;
1061  fEnergyHistogramLimit[0] = 0 ;
1062  fEnergyHistogramLimit[1] = 100;
1063 
1064  fPileUpParamSPD[0] = 3 ; fPileUpParamSPD[1] = 0.8 ;
1065  fPileUpParamSPD[2] = 3.0 ; fPileUpParamSPD[3] = 2.0 ; fPileUpParamSPD[4] = 5.0;
1066 
1067  // Parametrized time cut (LHC11d)
1070 
1071  // Parametrized time cut (LHC11c)
1072  //fEMCALParamTimeCutMin[0] =-5; fEMCALParamTimeCutMin[1] =-1 ; fEMCALParamTimeCutMin[2] = 1.87; fEMCALParamTimeCutMin[3] = 0.4;
1073  //fEMCALParamTimeCutMax[0] = 3.5; fEMCALParamTimeCutMax[1] = 50; fEMCALParamTimeCutMax[2] = 0.15; fEMCALParamTimeCutMax[3] = 1.6;
1074 
1075  fTimeStampRunMin = -1;
1076  fTimeStampRunMax = 1e12;
1079 
1080  for(Int_t i = 0; i < 19; i++)
1081  {
1082  fEMCalBCEvent [i] = 0;
1083  fEMCalBCEventCut[i] = 0;
1084  fTrackBCEvent [i] = 0;
1085  fTrackBCEventCut[i] = 0;
1086  }
1087 
1088  // Trigger match-rejection
1089  fTriggerPatchTimeWindow[0] = 8;
1090  fTriggerPatchTimeWindow[1] = 9;
1091 
1092  fTriggerClusterBC = -10000 ;
1095  fTriggerClusterIndex = -1;
1096  fTriggerClusterId = -1;
1097 
1098  //Jets
1101  if(!fNonStandardJets) fNonStandardJets = new TClonesArray("AliAODJet",100);
1104  if(!fBackgroundJets) fBackgroundJets = new AliAODJetEventBackground();
1105 
1106  fSmearShowerShapeWidth = 0.005;
1107  fSmearNLMMin = 1;
1108  fSmearNLMMax = 1;
1109 
1110  fWeightUtils = new AliAnaWeights() ;
1111  fEventWeight = 1 ;
1112 
1113 }
1114 
1115 //___________________________________________________
1120 //___________________________________________________
1122 {
1123  AliGenHijingEventHeader* hijingHeader = dynamic_cast<AliGenHijingEventHeader *> (GetGenEventHeader());
1124 
1125  //printf("header %p, label %d\n",hijingHeader,label);
1126 
1127  if(!hijingHeader || label < 0 ) return kFALSE;
1128 
1129 
1130  //printf("pass a), N produced %d\n",nproduced);
1131 
1132  if(label >= fNMCProducedMin && label < fNMCProducedMax)
1133  {
1134  //printf(" accept!, label is smaller than produced, N %d\n",nproduced);
1135 
1136  return kTRUE;
1137  }
1138 
1139  if(ReadStack())
1140  {
1141  if(!GetStack()) return kFALSE;
1142 
1143  Int_t nprimaries = GetStack()->GetNtrack();
1144 
1145  if(label > nprimaries) return kFALSE;
1146 
1147  TParticle * mom = GetStack()->Particle(label);
1148 
1149  Int_t iMom = label;
1150  Int_t iParent = mom->GetFirstMother();
1151  while(iParent!=-1)
1152  {
1153  if(iParent >= fNMCProducedMin && iParent < fNMCProducedMax)
1154  {
1155  //printf("\t accept, mother is %d \n",iParent)
1156  return kTRUE;
1157  }
1158 
1159  iMom = iParent;
1160  mom = GetStack()->Particle(iMom);
1161  iParent = mom->GetFirstMother();
1162  }
1163 
1164  return kFALSE ;
1165 
1166  } // ESD
1167  else
1168  {
1169  TClonesArray* mcparticles = GetAODMCParticles();
1170 
1171  if(!mcparticles) return kFALSE;
1172 
1173  Int_t nprimaries = mcparticles->GetEntriesFast();
1174 
1175  if(label > nprimaries) return kFALSE;
1176 
1177  //printf("pass b) N primaries %d \n",nprimaries);
1178 
1179  if(label >= fNMCProducedMin && label < fNMCProducedMax)
1180  {
1181  return kTRUE;
1182  }
1183 
1184  // Find grand parent, check if produced in the good range
1185  AliAODMCParticle * mom = (AliAODMCParticle *) mcparticles->At(label);
1186 
1187  Int_t iMom = label;
1188  Int_t iParent = mom->GetMother();
1189  while(iParent!=-1)
1190  {
1191  if(iParent >= fNMCProducedMin && iParent < fNMCProducedMax)
1192  {
1193  //printf("\t accept, mother is %d, with nProduced %d \n",iParent, nproduced);
1194  return kTRUE;
1195  }
1196 
1197  iMom = iParent;
1198  mom = (AliAODMCParticle *) mcparticles->At(iMom);
1199  iParent = mom->GetMother();
1200 
1201  }
1202 
1203  //printf("pass c), no match found \n");
1204 
1205  return kFALSE ;
1206 
1207  }//AOD
1208 }
1209 
1210 //__________________________________________________________________________
1213 //__________________________________________________________________________
1215 {
1216  // Parametrized cut depending on E
1217  if(fUseParamTimeCut)
1218  {
1221  //printf("tof %f, minCut %f, maxCut %f\n",tof,minCut,maxCut);
1222  if( tof < minCut || tof > maxCut ) return kFALSE ;
1223  }
1224 
1225  //In any case, the time should to be larger than the fixed window ...
1226  if( tof < fEMCALTimeCutMin || tof > fEMCALTimeCutMax ) return kFALSE ;
1227 
1228  return kTRUE ;
1229 }
1230 
1231 //________________________________________________
1234 //________________________________________________
1236 {
1237  return fInputEvent->IsPileupFromSPD((Int_t) fPileUpParamSPD[0] , fPileUpParamSPD[1] ,
1238  fPileUpParamSPD[2] , fPileUpParamSPD[3] , fPileUpParamSPD[4] );
1239  //printf("Param : %d, %2.2f, %2.2f, %2.2f, %2.2f\n",(Int_t) fPileUpParamSPD[0], fPileUpParamSPD[1], fPileUpParamSPD[2], fPileUpParamSPD[3], fPileUpParamSPD[4]);
1240 }
1241 
1242 //__________________________________________________
1244 //__________________________________________________
1246 {
1247  if(fNPileUpClusters > fNPileUpClustersCut) return kTRUE ;
1248  else return kFALSE;
1249 }
1250 
1251 //________________________________________________________
1253 //________________________________________________________
1255 {
1256  if( IsPileUpFromSPD() && IsPileUpFromEMCal()) return kTRUE ;
1257  else return kFALSE;
1258 }
1259 
1260 //_______________________________________________________
1262 //_______________________________________________________
1264 {
1265  if( IsPileUpFromSPD() || IsPileUpFromEMCal()) return kTRUE ;
1266  else return kFALSE;
1267 }
1268 
1269 //___________________________________________________________
1271 //___________________________________________________________
1273 {
1274  if( IsPileUpFromSPD() && !IsPileUpFromEMCal()) return kTRUE ;
1275  else return kFALSE;
1276 }
1277 
1278 //___________________________________________________________
1280 //___________________________________________________________
1282 {
1283  if( !IsPileUpFromSPD() && IsPileUpFromEMCal()) return kTRUE ;
1284  else return kFALSE;
1285 }
1286 
1287 //______________________________________________________________
1289 //______________________________________________________________
1291 {
1292  if( !IsPileUpFromSPD() && !IsPileUpFromEMCal()) return kTRUE ;
1293  else return kFALSE;
1294 }
1295 
1296 //___________________________________________________________________________________
1304 //___________________________________________________________________________________
1305 Bool_t AliCaloTrackReader::FillInputEvent(Int_t iEntry, const char * /*curFileName*/)
1306 {
1307  fEventNumber = iEntry;
1308  fTriggerClusterIndex = -1;
1309  fTriggerClusterId = -1;
1310  fIsTriggerMatch = kFALSE;
1311  fTriggerClusterBC = -10000;
1312  fIsExoticEvent = kFALSE;
1313  fIsBadCellEvent = kFALSE;
1314  fIsBadMaxCellEvent = kFALSE;
1315 
1316  fIsTriggerMatchOpenCut[0] = kFALSE ;
1317  fIsTriggerMatchOpenCut[1] = kFALSE ;
1318  fIsTriggerMatchOpenCut[2] = kFALSE ;
1319 
1320  //fCurrentFileName = TString(currentFileName);
1321  if(!fInputEvent)
1322  {
1323  AliInfo("Input event not available, skip event analysis");
1324  return kFALSE;
1325  }
1326 
1327  fhNEventsAfterCut->Fill(0.5);
1328 
1329  //-----------------------------------------------
1330  // Select the event depending on the trigger type
1331  // and other event characteristics
1332  // like the goodness of the EMCal trigger
1333  //-----------------------------------------------
1334 
1335  Bool_t accept = CheckEventTriggers();
1336  if(!accept) return kFALSE;
1337 
1338  AliDebug(1,"Pass Event trigger selection");
1339 
1340  //---------------------------------------------------------------------------
1341  // In case of analysis of events with jets, skip those with jet pt > 5 pt hard
1342  // To be used on for MC data in pT hard bins
1343  //---------------------------------------------------------------------------
1344 
1346  {
1347  if(!ComparePtHardAndJetPt()) return kFALSE ;
1348  AliDebug(1,"Pass Pt Hard - Jet rejection");
1349  fhNEventsAfterCut->Fill(8.5);
1350  }
1351 
1353  {
1354  if(!ComparePtHardAndClusterPt()) return kFALSE ;
1355  AliDebug(1,"Pass Pt Hard - Cluster rejection");
1356  fhNEventsAfterCut->Fill(9.5);
1357  }
1358 
1359  //------------------------------------------------------
1360  // Event rejection depending on time stamp
1361  //------------------------------------------------------
1362 
1364  {
1365  AliESDEvent* esd = dynamic_cast<AliESDEvent*> (fInputEvent);
1366  if(esd)
1367  {
1368  Int_t timeStamp = esd->GetTimeStamp();
1369  Float_t timeStampFrac = 1.*(timeStamp-fTimeStampRunMin) / (fTimeStampRunMax-fTimeStampRunMin);
1370 
1371  //printf("stamp0 %d, max0 %d, frac %f\n", timeStamp-fTimeStampRunMin,fTimeStampRunMax-fTimeStampRunMin, timeStampFrac);
1372 
1373  if(timeStampFrac < fTimeStampEventFracMin || timeStampFrac > fTimeStampEventFracMax) return kFALSE;
1374  }
1375 
1376  AliDebug(1,"Pass Time Stamp rejection");
1377  fhNEventsAfterCut->Fill(10.5);
1378  }
1379 
1380  //------------------------------------------------------
1381  // Event rejection depending on vertex, pileup, v0and
1382  //------------------------------------------------------
1383 
1384  FillVertexArray();
1385 
1386  //Reject events with Z vertex too large, only for SE analysis, if not, cut on the analysis code
1387  if(!GetMixedEvent() && TMath::Abs(fVertex[0][2]) > fZvtxCut) return kFALSE;
1388 
1389  fhNEventsAfterCut->Fill(11.5);
1390 
1392  {
1393  if( !CheckForPrimaryVertex() ) return kFALSE; // algorithm in ESD/AOD Readers
1394  if( TMath::Abs(fVertex[0][0] ) < 1.e-6 &&
1395  TMath::Abs(fVertex[0][1] ) < 1.e-6 &&
1396  TMath::Abs(fVertex[0][2] ) < 1.e-6 ) return kFALSE;
1397  }
1398 
1399  AliDebug(1,"Pass primary vertex rejection");
1400 
1401  fhNEventsAfterCut->Fill(12.5);
1402 
1403  //printf("Reader : IsPileUp %d, Multi %d\n",IsPileUpFromSPD(),fInputEvent->IsPileupFromSPDInMultBins());
1404 
1406  {
1407  // Do not analyze events with pileup
1408  Bool_t bPileup = IsPileUpFromSPD();
1409  //IsPileupFromSPDInMultBins() // method to try
1410  //printf("pile-up %d, %d, %2.2f, %2.2f, %2.2f, %2.2f\n",bPileup, (Int_t) fPileUpParamSPD[0], fPileUpParamSPD[1], fPileUpParamSPD[2], fPileUpParamSPD[3], fPileUpParamSPD[4]);
1411  if(bPileup) return kFALSE;
1412 
1413  AliDebug(1,"Pass Pile-Up event rejection");
1414 
1415  fhNEventsAfterCut->Fill(13.5);
1416  }
1417 
1419  {
1420  AliVVZERO* v0 = fInputEvent->GetVZEROData();
1421 
1422  Bool_t bV0AND = ((v0->GetV0ADecision()==1) && (v0->GetV0CDecision()==1));
1423  //bV0AND = fTriggerAnalysis->IsOfflineTriggerFired((AliESDEvent*)fInputEvent, AliTriggerAnalysis::kV0AND);
1424  //printf("V0AND event? %d\n",bV0AND);
1425 
1426  if(!bV0AND)
1427  {
1428  AliDebug(1,"Reject event by V0AND");
1429  return kFALSE;
1430  }
1431 
1432  AliDebug(1,"Pass V0AND event rejection");
1433 
1434  fhNEventsAfterCut->Fill(14.5);
1435  }
1436 
1437  //------------------------------------------------------
1438  // Check if there is a centrality value, PbPb analysis,
1439  // and if a centrality bin selection is requested
1440  //------------------------------------------------------
1441 
1442  //If we need a centrality bin, we select only those events in the corresponding bin.
1443  Int_t cen = -1;
1444  if ( fCentralityBin[0] >= 0 && fCentralityBin[1] >= 0 )
1445  {
1446  cen = GetEventCentrality();
1447 
1448  if(cen > fCentralityBin[1] || cen < fCentralityBin[0]) return kFALSE; //reject events out of bin.
1449 
1450  AliDebug(1,"Pass centrality rejection");
1451 
1452  fhNEventsAfterCut->Fill(15.5);
1453  }
1454 
1455  // Recover the weight assigned to the event, if provided
1456  // right now only for pT-hard bins and centrality depedent weights
1458  {
1460 
1461  fWeightUtils->SetPythiaEventHeader(((AliGenPythiaEventHeader*)GetGenEventHeader()));
1462 
1464  }
1465  //---------------------------------------------------------------------------
1466  // In case of MC analysis, set the range of interest in the MC particles list
1467  // The particle selection is done inside the FillInputDetector() methods
1468  //---------------------------------------------------------------------------
1470 
1471  //printf("N min %d, N max %d\n",fNMCProducedMin,fNMCProducedMax);
1472 
1473  //-------------------------------------------------------
1474  // Get the main vertex BC, in case not available
1475  // it is calculated in FillCTS checking the BC of tracks
1476  //------------------------------------------------------
1477  fVertexBC = fInputEvent->GetPrimaryVertex()->GetBC();
1478 
1479  //-----------------------------------------------
1480  // Fill the arrays with cluster/tracks/cells data
1481  //-----------------------------------------------
1482 
1483  if(fFillCTS)
1484  {
1485  FillInputCTS();
1486  //Accept events with at least one track
1487  if(fTrackMult == 0 && fDoRejectNoTrackEvents) return kFALSE ;
1488 
1489  fhNEventsAfterCut->Fill(16.5);
1490 
1491  AliDebug(1,"Pass rejection of null track events");
1492  }
1493 
1495  {
1496  if(fVertexBC != 0 && fVertexBC != AliVTrack::kTOFBCNA) return kFALSE ;
1497 
1498  AliDebug(1,"Pass rejection of events with vertex at BC!=0");
1499 
1500  fhNEventsAfterCut->Fill(17.5);
1501  }
1502 
1503  if(fFillEMCALCells)
1505 
1506  if(fFillPHOSCells)
1508 
1509  if(fFillEMCAL || fFillDCAL)
1510  FillInputEMCAL();
1511 
1512  if(fFillPHOS)
1513  FillInputPHOS();
1514 
1515  FillInputVZERO();
1516 
1517  //one specified jet branch
1522 
1523  AliDebug(1,"Event accepted for analysis");
1524 
1525  return kTRUE ;
1526 }
1527 
1528 //__________________________________________________
1531 //__________________________________________________
1533 {
1534  if(fUseAliCentrality)
1535  {
1536  if ( !GetCentrality() ) return -1;
1537 
1538  if (fCentralityOpt == 100) return (Int_t) GetCentrality()->GetCentralityPercentile(fCentralityClass); // 100 bins max
1539  else if(fCentralityOpt == 10) return GetCentrality()->GetCentralityClass10(fCentralityClass);// 10 bins max
1540  else if(fCentralityOpt == 20) return GetCentrality()->GetCentralityClass5(fCentralityClass); // 20 bins max
1541  else
1542  {
1543  AliInfo(Form("Unknown centrality option %d, use 10, 20 or 100\n",fCentralityOpt));
1544  return -1;
1545  }
1546  }
1547  else
1548  {
1549  if ( !GetMultSelCen() ) return -1;
1550 
1551  return GetMultSelCen()->GetMultiplicityPercentile(fCentralityClass, kTRUE); // returns centrality only for events used in calibration
1552 
1553  // equivalent to
1554  //GetMultSelCen()->GetMultiplicityPercentile("V0M", kFALSE); // returns centrality for any event
1555  //Int_t qual = GetMultSelCen()->GetEvSelCode(); if (qual ! = 0) cent = qual;
1556  }
1557 }
1558 
1559 //_____________________________________________________
1562 //_____________________________________________________
1564 {
1565  if( !GetEventPlane() ) return -1000;
1566 
1567  Float_t ep = GetEventPlane()->GetEventplane(GetEventPlaneMethod(), GetInputEvent());
1568 
1569  if(GetEventPlaneMethod()=="Q" && (ep < 0 || ep > TMath::Pi()))
1570  {
1571  AliDebug(1,Form("Bad EP for <Q> method : %f\n",ep));
1572  return -1000;
1573  }
1574  else if(GetEventPlaneMethod().Contains("V0") )
1575  {
1576  if((ep > TMath::Pi()/2 || ep < -TMath::Pi()/2))
1577  {
1578  AliDebug(1,Form("Bad EP for <%s> method : %f\n",GetEventPlaneMethod().Data(), ep));
1579  return -1000;
1580  }
1581 
1582  ep+=TMath::Pi()/2; // put same range as for <Q> method
1583  }
1584 
1585  AliDebug(3,Form("Event plane angle %f",ep));
1586 
1587 // if(fDebug > 0 )
1588 // {
1589 // if (ep > TMath::Pi()) printf("AliCaloTrackReader::GetEventPlaneAngle() - Too large angle = %f\n",ep);
1590 // else if(ep < 0 ) printf("AliCaloTrackReader::GetEventPlaneAngle() - Negative angle = %f\n" ,ep);
1591 // }
1592 
1593  return ep;
1594 }
1595 
1596 //__________________________________________________________
1598 //__________________________________________________________
1600 {
1601  vertex[0] = fVertex[0][0];
1602  vertex[1] = fVertex[0][1];
1603  vertex[2] = fVertex[0][2];
1604 }
1605 
1606 //__________________________________________________________________________
1608 //__________________________________________________________________________
1609 void AliCaloTrackReader::GetVertex(Double_t vertex[3], Int_t evtIndex) const
1610 {
1611  vertex[0] = fVertex[evtIndex][0];
1612  vertex[1] = fVertex[evtIndex][1];
1613  vertex[2] = fVertex[evtIndex][2];
1614 }
1615 
1616 //________________________________________
1619 //________________________________________
1621 {
1622  // Delete previous vertex
1623  if(fVertex)
1624  {
1625  for (Int_t i = 0; i < fNMixedEvent; i++)
1626  {
1627  delete [] fVertex[i] ;
1628  }
1629  delete [] fVertex ;
1630  }
1631 
1632  fVertex = new Double_t*[fNMixedEvent] ;
1633  for (Int_t i = 0; i < fNMixedEvent; i++)
1634  {
1635  fVertex[i] = new Double_t[3] ;
1636  fVertex[i][0] = 0.0 ;
1637  fVertex[i][1] = 0.0 ;
1638  fVertex[i][2] = 0.0 ;
1639  }
1640 
1641  if (!fMixedEvent)
1642  { // Single event analysis
1643  if(fDataType!=kMC)
1644  {
1645 
1646  if(fInputEvent->GetPrimaryVertex())
1647  {
1648  fInputEvent->GetPrimaryVertex()->GetXYZ(fVertex[0]);
1649  }
1650  else
1651  {
1652  AliWarning("NULL primary vertex");
1653  fVertex[0][0]=0.; fVertex[0][1]=0.; fVertex[0][2]=0.;
1654  }//Primary vertex pointer do not exist
1655 
1656  } else
1657  {// MC read event
1658  fVertex[0][0]=0.; fVertex[0][1]=0.; fVertex[0][2]=0.;
1659  }
1660 
1661  AliDebug(1,Form("Single Event Vertex : %f,%f,%f\n",fVertex[0][0],fVertex[0][1],fVertex[0][2]));
1662 
1663  } else
1664  { // MultiEvent analysis
1665  for (Int_t iev = 0; iev < fNMixedEvent; iev++)
1666  {
1667  if (fMixedEvent->GetVertexOfEvent(iev))
1668  fMixedEvent->GetVertexOfEvent(iev)->GetXYZ(fVertex[iev]);
1669  else
1670  AliWarning("No vertex found");
1671 
1672  AliDebug(1,Form("Multi Event %d Vertex : %f,%f,%f",iev,fVertex[iev][0],fVertex[iev][1],fVertex[iev][2]));
1673  }
1674  }
1675 }
1676 
1677 //_____________________________________
1683 //_____________________________________
1685 {
1686  AliDebug(1,"Begin");
1687 
1688  Double_t pTrack[3] = {0,0,0};
1689 
1690  Int_t nTracks = fInputEvent->GetNumberOfTracks() ;
1691  fTrackMult = 0;
1692  Int_t nstatus = 0;
1693  Double_t bz = GetInputEvent()->GetMagneticField();
1694 
1695  for(Int_t i = 0; i < 19; i++)
1696  {
1697  fTrackBCEvent [i] = 0;
1698  fTrackBCEventCut[i] = 0;
1699  }
1700 
1701  Bool_t bc0 = kFALSE;
1702  if(fRecalculateVertexBC) fVertexBC = AliVTrack::kTOFBCNA;
1703 
1704  for (Int_t itrack = 0; itrack < nTracks; itrack++)
1705  {
1706  AliVTrack * track = (AliVTrack*)fInputEvent->GetTrack(itrack) ; // retrieve track from esd
1707 
1708  if(fAcceptOnlyHIJINGLabels && !IsHIJINGLabel(track->GetLabel())) continue ;
1709 
1710  fhCTSTrackCutsPt[0]->Fill(track->Pt());
1711 
1712  //Select tracks under certain conditions, TPCrefit, ITSrefit ... check the set bits
1713  ULong_t status = track->GetStatus();
1714 
1715  if (fTrackStatus && !((status & fTrackStatus) == fTrackStatus))
1716  continue ;
1717 
1718  fhCTSTrackCutsPt[1]->Fill(track->Pt());
1719 
1720  nstatus++;
1721 
1722  //-------------------------
1723  // Select the tracks depending on cuts of AOD or ESD
1724  if(!SelectTrack(track, pTrack)) continue ;
1725 
1726  fhCTSTrackCutsPt[2]->Fill(track->Pt());
1727 
1728  //-------------------------
1729  // TOF cuts
1730  Bool_t okTOF = ( (status & AliVTrack::kTOFout) == AliVTrack::kTOFout ) ;
1731  Double_t tof = -1000;
1732  Int_t trackBC = -1000 ;
1733 
1734  if(fAccessTrackTOF)
1735  {
1736  if(okTOF)
1737  {
1738  trackBC = track->GetTOFBunchCrossing(bz);
1739  SetTrackEventBC(trackBC+9);
1740 
1741  tof = track->GetTOFsignal()*1e-3;
1742 
1743  //After selecting tracks with small DCA, pointing to vertex, set vertex BC depeding on tracks BC
1745  {
1746  if (trackBC != 0 && trackBC != AliVTrack::kTOFBCNA) fVertexBC = trackBC;
1747  else if(trackBC == 0) bc0 = kTRUE;
1748  }
1749 
1750  //In any case, the time should to be larger than the fixed window ...
1751  if( fUseTrackTimeCut && (trackBC !=0 || tof < fTrackTimeCutMin || tof > fTrackTimeCutMax) )
1752  {
1753  //printf("Remove track time %f and bc = %d\n",tof,trackBC);
1754  continue ;
1755  }
1756  //else printf("Accept track time %f and bc = %d\n",tof,trackBC);
1757  }
1758  }
1759 
1760  fhCTSTrackCutsPt[3]->Fill(track->Pt());
1761 
1762  //---------------------
1763  // DCA cuts
1764  //
1765  fMomentum.SetPxPyPzE(pTrack[0],pTrack[1],pTrack[2],0);
1766 
1767  if(fUseTrackDCACut)
1768  {
1769  Float_t dcaTPC =-999;
1770  //In case of AODs, TPC tracks cannot be propagated back to primary vertex,
1771  if( fDataType == kAOD ) dcaTPC = ((AliAODTrack*) track)->DCA();
1772 
1773  //normal way to get the dca, cut on dca_xy
1774  if(dcaTPC==-999)
1775  {
1776  Double_t dca[2] = {1e6,1e6};
1777  Double_t covar[3] = {1e6,1e6,1e6};
1778  Bool_t okDCA = track->PropagateToDCA(fInputEvent->GetPrimaryVertex(),bz,100.,dca,covar);
1779  if( okDCA) okDCA = AcceptDCA(fMomentum.Pt(),dca[0]);
1780  if(!okDCA)
1781  {
1782  //printf("AliCaloTrackReader::FillInputCTS() - Reject track pt %2.2f, dca_xy %2.4f\n",fMomentum.Pt(),dca[0]);
1783  continue ;
1784  }
1785  }
1786  }// DCA cuts
1787 
1788  fhCTSTrackCutsPt[4]->Fill(track->Pt());
1789 
1790  //-------------------------
1791  // Kinematic/acceptance cuts
1792  //
1793  // Count the tracks in eta < 0.9
1794  if(TMath::Abs(track->Eta())< fTrackMultEtaCut) fTrackMult++;
1795 
1796  if(fCTSPtMin > fMomentum.Pt() || fCTSPtMax < fMomentum.Pt()) continue ;
1797 
1798  // Check effect of cuts on track BC
1799  if(fAccessTrackTOF && okTOF) SetTrackEventBCcut(trackBC+9);
1800 
1801  if(fCheckFidCut && !fFiducialCut->IsInFiducialCut(fMomentum.Eta(),fMomentum.Phi(),kCTS)) continue;
1802 
1803  fhCTSTrackCutsPt[5]->Fill(track->Pt());
1804 
1805  // ------------------------------
1806  // Add selected tracks to array
1807  AliDebug(2,Form("Selected tracks pt %3.2f, phi %3.2f deg, eta %3.2f",
1808  fMomentum.Pt(),RadToDeg(GetPhi(fMomentum.Phi())),fMomentum.Eta()));
1809 
1810  fCTSTracks->Add(track);
1811 
1812  // TODO, check if remove
1813  if (fMixedEvent) track->SetID(itrack);
1814 
1815  }// track loop
1816 
1817  if( fRecalculateVertexBC && (fVertexBC == 0 || fVertexBC == AliVTrack::kTOFBCNA))
1818  {
1819  if( bc0 ) fVertexBC = 0 ;
1820  else fVertexBC = AliVTrack::kTOFBCNA ;
1821  }
1822 
1823  AliDebug(1,Form("AOD entries %d, input tracks %d, pass status %d, multipliticy %d", fCTSTracks->GetEntriesFast(), nTracks, nstatus, fTrackMult));//fCTSTracksNormalInputEntries);
1824 }
1825 
1826 //_______________________________________________________________________________
1844 //_______________________________________________________________________________
1846 {
1847  // Accept clusters with the proper label, TO DO, use the new more General methods!!!
1848  if(fAcceptOnlyHIJINGLabels && !IsHIJINGLabel( clus->GetLabel() )) return ;
1849 
1850  // TODO, not sure if needed anymore
1851  Int_t vindex = 0 ;
1852  if (fMixedEvent)
1853  vindex = fMixedEvent->EventIndexForCaloCluster(iclus);
1854 
1855  clus->GetMomentum(fMomentum, fVertex[vindex]);
1856 
1857  // No correction/cut applied yet
1858  fhEMCALClusterCutsE[0]->Fill(clus->E());
1859 
1860  //if( (fDebug > 2 && fMomentum.E() > 0.1) || fDebug > 10 )
1861  AliDebug(2,Form("Input cluster E %3.2f, pt %3.2f, phi %3.2f deg, eta %3.2f",
1862  fMomentum.E(),fMomentum.Pt(),RadToDeg(GetPhi(fMomentum.Phi())),fMomentum.Eta()));
1863 
1864  //---------------------------
1865  // Embedding case
1866  // TO BE REVISED
1868  {
1869  if(clus->GetNLabels()==0 || clus->GetLabel() < 0) return;
1870  //else printf("Embedded cluster, %d, n label %d label %d \n",iclus,clus->GetNLabels(),clus->GetLabel());
1871  }
1872 
1873  //--------------------------------------
1874  // Apply some corrections in the cluster
1875  //
1877  {
1878  //Recalibrate the cluster energy
1880  {
1882 
1883  clus->SetE(energy);
1884  //printf("Recalibrated Energy %f\n",clus->E());
1885 
1888 
1889  } // recalculate E
1890 
1891  //Recalculate distance to bad channels, if new list of bad channels provided
1893 
1894  //Recalculate cluster position
1895  if(GetCaloUtils()->IsRecalculationOfClusterPositionOn())
1896  {
1898  //clus->GetPosition(pos);
1899  //printf("After Corrections: e %f, x %f, y %f, z %f\n",clus->E(),pos[0],pos[1],pos[2]);
1900  }
1901 
1902  // Recalculate TOF
1903  if(GetCaloUtils()->GetEMCALRecoUtils()->IsTimeRecalibrationOn())
1904  {
1905  Double_t tof = clus->GetTOF();
1906  Float_t frac =-1;
1907  Int_t absIdMax = GetCaloUtils()->GetMaxEnergyCell(fEMCALCells, clus,frac);
1908 
1909  GetCaloUtils()->GetEMCALRecoUtils()->RecalibrateCellTime(absIdMax,fInputEvent->GetBunchCrossNumber(),tof);
1910 
1911  //additional L1 phase shift
1912  if(GetCaloUtils()->GetEMCALRecoUtils()->IsL1PhaseInTimeRecalibrationOn())
1913  {
1914  GetCaloUtils()->GetEMCALRecoUtils()->RecalibrateCellTimeL1Phase(GetCaloUtils()->GetEMCALGeometry()->GetSuperModuleNumber(absIdMax),
1915  fInputEvent->GetBunchCrossNumber(), tof);
1916  }
1917 
1918  clus->SetTOF(tof);
1919 
1920  }// Time recalibration
1921  }
1922 
1923  // Check effect of corrections
1924  fhEMCALClusterCutsE[1]->Fill(clus->E());
1925 
1926  //-----------------------------------------------------------------
1927  // Reject clusters with bad channels, close to borders and exotic
1928  //
1929  Bool_t goodCluster = GetCaloUtils()->GetEMCALRecoUtils()->IsGoodCluster(clus,
1930  GetCaloUtils()->GetEMCALGeometry(),
1931  GetEMCALCells(),fInputEvent->GetBunchCrossNumber());
1932 
1933  if(!goodCluster)
1934  {
1935  //if( (fDebug > 2 && fMomentum.E() > 0.1) || fDebug > 10 )
1936  AliDebug(2,Form("Bad cluster E %3.2f, pt %3.2f, phi %3.2f deg, eta %3.2f",
1937  fMomentum.E(),fMomentum.Pt(),RadToDeg(GetPhi(fMomentum.Phi())),fMomentum.Eta()));
1938 
1939  return;
1940  }
1941 
1942  // Check effect of bad cluster removal
1943  fhEMCALClusterCutsE[2]->Fill(clus->E());
1944 
1945  //Float_t pos[3];
1946  //clus->GetPosition(pos);
1947  //printf("Before Corrections: e %f, x %f, y %f, z %f\n",clus->E(),pos[0],pos[1],pos[2]);
1948 
1949  //--------------------------------------
1950  // Correct non linearity or smear energy
1951  //
1953  {
1955 
1956  //if( (fDebug > 5 && fMomentum.E() > 0.1) || fDebug > 10 )
1957  AliDebug(5,Form("Correct Non Lin: Old E %3.2f, New E %3.2f",
1958  fMomentum.E(),clus->E()));
1959 
1960  // In case of MC analysis, to match resolution/calibration in real data
1961  // Not needed anymore, just leave for MC studies on systematics
1962  if( GetCaloUtils()->GetEMCALRecoUtils()->IsClusterEnergySmeared() )
1963  {
1964  Float_t rdmEnergy = GetCaloUtils()->GetEMCALRecoUtils()->SmearClusterEnergy(clus);
1965 
1966  //if( (fDebug > 5 && fMomentum.E() > 0.1) || fDebug > 10 )
1967  AliDebug(5,Form("Smear energy: Old E %3.2f, New E %3.2f",clus->E(),rdmEnergy));
1968 
1969  clus->SetE(rdmEnergy);
1970  }
1971  }
1972 
1973  clus->GetMomentum(fMomentum, fVertex[vindex]);
1974 
1975  // Check effect linearity correction, energy smearing
1976  fhEMCALClusterCutsE[3]->Fill(clus->E());
1977 
1978  // Check the event BC depending on EMCal clustr before final cuts
1979  Double_t tof = clus->GetTOF()*1e9;
1980 
1981  Int_t bc = TMath::Nint(tof/50) + 9;
1982  //printf("tof %2.2f, bc+5=%d\n",tof,bc);
1983 
1984  SetEMCalEventBC(bc);
1985 
1986  //--------------------------------------
1987  // Apply some kinematical/acceptance cuts
1988  //
1989  if(fEMCALPtMin > clus->E() || fEMCALPtMax < clus->E()) return ;
1990 
1991  // Select cluster fiducial region
1992  //
1993  Bool_t bEMCAL = kFALSE;
1994  Bool_t bDCAL = kFALSE;
1995  if(fCheckFidCut)
1996  {
1997  if(fFillEMCAL && fFiducialCut->IsInFiducialCut(fMomentum.Eta(),fMomentum.Phi(),kEMCAL)) bEMCAL = kTRUE ;
1998  if(fFillDCAL && fFiducialCut->IsInFiducialCut(fMomentum.Eta(),fMomentum.Phi(),kDCAL )) bDCAL = kTRUE ;
1999  }
2000  else
2001  {
2002  bEMCAL = kTRUE;
2003  }
2004 
2005  //---------------------------------------------------------------------
2006  // Mask all cells in collumns facing ALICE thick material if requested
2007  //
2009  {
2010  Int_t absId = -1;
2011  Int_t iSupMod = -1;
2012  Int_t iphi = -1;
2013  Int_t ieta = -1;
2014  Bool_t shared = kFALSE;
2015  GetCaloUtils()->GetEMCALRecoUtils()->GetMaxEnergyCell(GetCaloUtils()->GetEMCALGeometry(), GetEMCALCells(),clus,absId,iSupMod,ieta,iphi,shared);
2016 
2017  AliDebug(2,Form("Masked collumn: cluster E %3.2f, pt %3.2f, phi %3.2f deg, eta %3.2f",
2018  fMomentum.E(),fMomentum.Pt(),RadToDeg(GetPhi(fMomentum.Phi())),fMomentum.Eta()));
2019 
2020 
2021  if(GetCaloUtils()->MaskFrameCluster(iSupMod, ieta)) return;
2022  }
2023 
2024  // Check effect of energy and fiducial cuts
2025  fhEMCALClusterCutsE[4]->Fill(clus->E());
2026 
2027 
2028  //------------------------------------------
2029  // Apply time cut, count EMCal BC before cut
2030  //
2031  SetEMCalEventBCcut(bc);
2032 
2033  if(!IsInTimeWindow(tof,clus->E()))
2034  {
2035  fNPileUpClusters++ ;
2036  if(fUseEMCALTimeCut)
2037  {
2038  AliDebug(2,Form("Out of time window E %3.2f, pt %3.2f, phi %3.2f deg, eta %3.2f, time %e",
2039  fMomentum.E(),fMomentum.Pt(),RadToDeg(GetPhi(fMomentum.Phi())),fMomentum.Eta(),tof));
2040 
2041  return ;
2042  }
2043  }
2044  else
2046 
2047  // Check effect of time cut
2048  fhEMCALClusterCutsE[5]->Fill(clus->E());
2049 
2050 
2051  //----------------------------------------------------
2052  // Apply N cells cut
2053  //
2054  if(clus->GetNCells() <= fEMCALNCellsCut && fDataType != AliCaloTrackReader::kMC) return ;
2055 
2056  // Check effect of n cells cut
2057  fhEMCALClusterCutsE[6]->Fill(clus->E());
2058 
2059  //----------------------------------------------------
2060  // Apply distance to bad channel cut
2061  //
2062  Double_t distBad = clus->GetDistanceToBadChannel() ; //Distance to bad channel
2063 
2064  if(distBad < 0.) distBad=9999. ; //workout strange convension dist = -1. ;
2065 
2066  if(distBad < fEMCALBadChMinDist) return ;
2067 
2068  // Check effect distance to bad channel cut
2069  fhEMCALClusterCutsE[7]->Fill(clus->E());
2070 
2071  //----------------------------------------------------
2072  // Smear the SS to try to match data and simulations,
2073  // do it only for simulations.
2074  //
2075  Int_t nMaxima = GetCaloUtils()->GetNumberOfLocalMaxima(clus, GetEMCALCells());
2076  // Int_t nMaxima = clus->GetNExMax(); // For Run2
2077  if( fSmearShowerShape && clus->GetNCells() > 2 &&
2078  nMaxima >= fSmearNLMMin && nMaxima <= fSmearNLMMax )
2079  {
2080  AliDebug(2,Form("Smear shower shape - Original: %2.4f\n", clus->GetM02()));
2082  {
2083  clus->SetM02( clus->GetM02() + fRandom.Landau(0, fSmearShowerShapeWidth) );
2084  }
2086  {
2087  if(iclus%3 == 0 && clus->GetM02() > 0.1) clus->SetM02( clus->GetM02() + fRandom.Landau(0.05, fSmearShowerShapeWidth) ); //fSmearShowerShapeWidth = 0.035
2088  }
2089  //clus->SetM02( fRandom.Landau(clus->GetM02(), fSmearShowerShapeWidth) );
2090  AliDebug(2,Form("Width %2.4f Smeared : %2.4f\n", fSmearShowerShapeWidth,clus->GetM02()));
2091  }
2092 
2093  //--------------------------------------------------------
2094  // Fill the corresponding array with the selected clusters
2095  // Usually just filling EMCal array with upper or lower clusters is enough,
2096  // but maybe we want to do EMCal-DCal correlations.
2097 
2098  //if((fDebug > 2 && fMomentum.E() > 0.1) || fDebug > 10)
2099  AliDebug(2,Form("Selected clusters (EMCAL%d, DCAL%d), E %3.2f, pt %3.2f, phi %3.2f deg, eta %3.2f",
2100  bEMCAL,bDCAL,fMomentum.E(),fMomentum.Pt(),RadToDeg(GetPhi(fMomentum.Phi())),fMomentum.Eta()));
2101 
2102 
2103  if (bEMCAL) fEMCALClusters->Add(clus);
2104  else if(bDCAL ) fDCALClusters ->Add(clus);
2105 
2106  // TODO, not sure if needed anymore
2107  if (fMixedEvent)
2108  clus->SetID(iclus) ;
2109 }
2110 
2111 //_______________________________________
2118 //_______________________________________
2120 {
2121  AliDebug(1,"Begin");
2122 
2123  // First recalibrate cells, time or energy
2124  // if(GetCaloUtils()->IsRecalibrationOn())
2125  // GetCaloUtils()->GetEMCALRecoUtils()->RecalibrateCells(GetCaloUtils()->GetEMCALGeometry(),
2126  // GetEMCALCells(),
2127  // fInputEvent->GetBunchCrossNumber());
2128 
2129  fNPileUpClusters = 0; // Init counter
2130  fNNonPileUpClusters = 0; // Init counter
2131  for(Int_t i = 0; i < 19; i++)
2132  {
2133  fEMCalBCEvent [i] = 0;
2134  fEMCalBCEventCut[i] = 0;
2135  }
2136 
2137  //Loop to select clusters in fiducial cut and fill container with aodClusters
2138  if(fEMCALClustersListName=="")
2139  {
2140  Int_t nclusters = fInputEvent->GetNumberOfCaloClusters();
2141  for (Int_t iclus = 0; iclus < nclusters; iclus++)
2142  {
2143  AliVCluster * clus = 0;
2144  if ( (clus = fInputEvent->GetCaloCluster(iclus)) )
2145  {
2146  if (clus->IsEMCAL())
2147  {
2148  FillInputEMCALAlgorithm(clus, iclus);
2149  }//EMCAL cluster
2150  }// cluster exists
2151  }// cluster loop
2152 
2153  //Recalculate track matching
2155 
2156  }//Get the clusters from the input event
2157  else
2158  {
2159  TClonesArray * clusterList = 0x0;
2160 
2161  if (fInputEvent->FindListObject(fEMCALClustersListName))
2162  {
2163  clusterList = dynamic_cast<TClonesArray*> (fInputEvent->FindListObject(fEMCALClustersListName));
2164  }
2165  else if(fOutputEvent)
2166  {
2167  clusterList = dynamic_cast<TClonesArray*> (fOutputEvent->FindListObject(fEMCALClustersListName));
2168  }
2169 
2170  if(!clusterList)
2171  {
2172  AliWarning(Form("Wrong name of list with clusters? <%s>",fEMCALClustersListName.Data()));
2173  return;
2174  }
2175 
2176  Int_t nclusters = clusterList->GetEntriesFast();
2177  for (Int_t iclus = 0; iclus < nclusters; iclus++)
2178  {
2179  AliVCluster * clus = dynamic_cast<AliVCluster*> (clusterList->At(iclus));
2180  //printf("E %f\n",clus->E());
2181  if (clus) FillInputEMCALAlgorithm(clus, iclus);
2182  else AliWarning("Null cluster in list!");
2183  }// cluster loop
2184 
2185  // Recalculate the pile-up time, in case long time clusters removed during clusterization
2186  //printf("Input event INIT : Pile-up clusters %d, NO pile-up %d\n",fNPileUpClusters,fNNonPileUpClusters);
2187 
2188  fNPileUpClusters = 0; // Init counter
2189  fNNonPileUpClusters = 0; // Init counter
2190  for(Int_t i = 0; i < 19; i++)
2191  {
2192  fEMCalBCEvent [i] = 0;
2193  fEMCalBCEventCut[i] = 0;
2194  }
2195 
2196  for (Int_t iclus = 0; iclus < fInputEvent->GetNumberOfCaloClusters(); iclus++)
2197  {
2198  AliVCluster * clus = 0;
2199 
2200  if ( (clus = fInputEvent->GetCaloCluster(iclus)) )
2201  {
2202  if (clus->IsEMCAL())
2203  {
2204 
2205  Float_t frac =-1;
2206  Int_t absIdMax = GetCaloUtils()->GetMaxEnergyCell(fEMCALCells, clus,frac);
2207  Double_t tof = clus->GetTOF();
2208  GetCaloUtils()->GetEMCALRecoUtils()->RecalibrateCellTime(absIdMax,fInputEvent->GetBunchCrossNumber(),tof);
2209  //additional L1 phase shift
2210  if(GetCaloUtils()->GetEMCALRecoUtils()->IsL1PhaseInTimeRecalibrationOn())
2211  {
2212  GetCaloUtils()->GetEMCALRecoUtils()->RecalibrateCellTimeL1Phase(GetCaloUtils()->GetEMCALGeometry()->GetSuperModuleNumber(absIdMax), fInputEvent->GetBunchCrossNumber(), tof);
2213  }
2214 
2215  tof*=1e9;
2216 
2217  //printf("Input event cluster : AbsIdMax %d, E %2.2f, time %2.2f \n", absIdMax,clus->E(),tof);
2218 
2219  //Reject clusters with bad channels, close to borders and exotic;
2220  if(!GetCaloUtils()->GetEMCALRecoUtils()->IsGoodCluster(clus,GetCaloUtils()->GetEMCALGeometry(),GetEMCALCells(),fInputEvent->GetBunchCrossNumber())) continue;
2221 
2222  Int_t bc = TMath::Nint(tof/50) + 9;
2223  SetEMCalEventBC(bc);
2224 
2225  if(fEMCALPtMin > clus->E() || fEMCALPtMax < clus->E()) continue ;
2226 
2227  clus->GetMomentum(fMomentum, fVertex[0]);
2228 
2229  if(fCheckFidCut && !fFiducialCut->IsInFiducialCut(fMomentum.Eta(),fMomentum.Phi(),kEMCAL)) return ;
2230 
2231  SetEMCalEventBCcut(bc);
2232 
2233  if(!IsInTimeWindow(tof,clus->E()))
2234  fNPileUpClusters++ ;
2235  else
2237 
2238  }
2239  }
2240  }
2241 
2242  //printf("Input event : Pile-up clusters %d, NO pile-up %d\n",fNPileUpClusters,fNNonPileUpClusters);
2243 
2244  // Recalculate track matching, not necessary if already done in the reclusterization task.
2245  // in case it was not done ...
2247 
2248  }
2249 
2250  AliDebug(1,Form("AOD entries %d, n pile-up clusters %d, n non pile-up %d", fEMCALClusters->GetEntriesFast(),fNPileUpClusters,fNNonPileUpClusters));
2251 }
2252 
2253 //_______________________________________
2255 //_______________________________________
2257 {
2258  AliDebug(1,"Begin");
2259 
2260  // Loop to select clusters in fiducial cut and fill container with aodClusters
2261  Int_t nclusters = fInputEvent->GetNumberOfCaloClusters();
2262  for (Int_t iclus = 0; iclus < nclusters; iclus++)
2263  {
2264  AliVCluster * clus = fInputEvent->GetCaloCluster(iclus) ;
2265  if ( !clus ) continue ;
2266 
2267  if ( !clus->IsPHOS() ) continue ;
2268 
2269  if(fAcceptOnlyHIJINGLabels && !IsHIJINGLabel(clus->GetLabel())) continue ;
2270 
2271  fhPHOSClusterCutsE[0]->Fill(clus->E());
2272 
2273  // Skip CPV input
2274  if( clus->GetType() == AliVCluster::kPHOSCharged ) continue ;
2275 
2276  fhPHOSClusterCutsE[1]->Fill(clus->E());
2277 
2278  //---------------------------------------------
2279  // Old feature, try to rely on PHOS tender
2280  //
2282  {
2283  // Recalibrate the cluster energy
2285  {
2286  Float_t energy = GetCaloUtils()->RecalibrateClusterEnergy(clus, (AliAODCaloCells*)GetPHOSCells());
2287  clus->SetE(energy);
2288  }
2289  }
2290 
2291  //----------------------------------------------------------------------------------
2292  // Check if the cluster contains any bad channel and if close to calorimeter borders
2293  //
2294  // Old feature, try to rely on PHOS tender
2295  if( GetCaloUtils()->ClusterContainsBadChannel(kPHOS,clus->GetCellsAbsId(), clus->GetNCells()))
2296  continue;
2297 
2298  if(!GetCaloUtils()->CheckCellFiducialRegion(clus, fInputEvent->GetPHOSCells()))
2299  continue;
2300 
2301  // TODO, add exotic cut???
2302 
2303  fhPHOSClusterCutsE[2]->Fill(clus->E());
2304 
2305  // TODO Dead code? remove?
2306  Int_t vindex = 0 ;
2307  if (fMixedEvent)
2308  vindex = fMixedEvent->EventIndexForCaloCluster(iclus);
2309 
2310  clus->GetMomentum(fMomentum, fVertex[vindex]);
2311 
2312  //----------------------------------------------------------------------------------
2313  // Remove clusters close to borders
2314  //
2316  continue ;
2317 
2318  fhPHOSClusterCutsE[3]->Fill(clus->E());
2319 
2320  //----------------------------------------------------------------------------------
2321  // Remove clusters with too low energy
2322  //
2323  if (fPHOSPtMin > fMomentum.E() || fPHOSPtMax < fMomentum.E() )
2324  continue ;
2325 
2326  fhPHOSClusterCutsE[4]->Fill(clus->E());
2327 
2328  //----------------------------------------------------
2329  // Apply N cells cut
2330  //
2331  if(clus->GetNCells() <= fPHOSNCellsCut && fDataType != AliCaloTrackReader::kMC) return ;
2332 
2333  // Check effect of n cells cut
2334  fhPHOSClusterCutsE[5]->Fill(clus->E());
2335 
2336  //----------------------------------------------------
2337  // Apply distance to bad channel cut
2338  //
2339  Double_t distBad = clus->GetDistanceToBadChannel() ; //Distance to bad channel
2340 
2341  if(distBad < 0.) distBad=9999. ; //workout strange convension dist = -1. ;
2342 
2343  if(distBad < fPHOSBadChMinDist) return ;
2344 
2345  // Check effect distance to bad channel cut
2346  fhPHOSClusterCutsE[6]->Fill(clus->E());
2347 
2348  // TODO, add time cut
2349 
2350  //----------------------------------------------------------------------------------
2351  // Add selected clusters to array
2352  //
2353  //if(fDebug > 2 && fMomentum.E() > 0.1)
2354  AliDebug(2,Form("Selected clusters E %3.2f, pt %3.2f, phi %3.2f deg, eta %3.2f",
2355  fMomentum.E(),fMomentum.Pt(),RadToDeg(GetPhi(fMomentum.Phi())),fMomentum.Eta()));
2356 
2357  fPHOSClusters->Add(clus);
2358 
2359  // TODO Dead code? remove?
2360  if (fMixedEvent)
2361  clus->SetID(iclus) ;
2362 
2363  } // esd/aod cluster loop
2364 
2365  AliDebug(1,Form("AOD entries %d",fPHOSClusters->GetEntriesFast())) ;
2366 }
2367 
2368 //____________________________________________
2370 //____________________________________________
2372 {
2373  fEMCALCells = fInputEvent->GetEMCALCells();
2374 }
2375 
2376 //___________________________________________
2378 //___________________________________________
2380 {
2381  fPHOSCells = fInputEvent->GetPHOSCells();
2382 }
2383 
2384 //_______________________________________
2387 //_______________________________________
2389 {
2390  AliVVZERO* v0 = fInputEvent->GetVZEROData();
2391  //printf("Init V0: ADC (%d,%d), Multiplicity (%d,%d) \n",fV0ADC[0],fV0ADC[1],fV0Mul[0],fV0Mul[1]);
2392 
2393  if (v0)
2394  {
2395  AliESDVZERO* esdV0 = dynamic_cast<AliESDVZERO*> (v0);
2396  for (Int_t i = 0; i < 32; i++)
2397  {
2398  if(esdV0)
2399  {//Only available in ESDs
2400  fV0ADC[0] += (Int_t)esdV0->GetAdcV0C(i);
2401  fV0ADC[1] += (Int_t)esdV0->GetAdcV0A(i);
2402  }
2403 
2404  fV0Mul[0] += (Int_t)v0->GetMultiplicityV0C(i);
2405  fV0Mul[1] += (Int_t)v0->GetMultiplicityV0A(i);
2406  }
2407 
2408  AliDebug(1,Form("ADC (%d,%d), Multiplicity (%d,%d)",fV0ADC[0],fV0ADC[1],fV0Mul[0],fV0Mul[1]));
2409  }
2410  else
2411  {
2412  AliDebug(1,"Cannot retrieve V0 ESD! Run w/ null V0 charges");
2413  }
2414 }
2415 
2416 //_________________________________________________
2420 //_________________________________________________
2422 {
2423  AliDebug(2,"Begin");
2424 
2425  //
2426  //check if branch name is given
2427  if(!fInputNonStandardJetBranchName.Length())
2428  {
2429  fInputEvent->Print();
2430  AliFatal("No non-standard jet branch name specified. Specify among existing ones.");
2431  }
2432 
2433  fNonStandardJets = dynamic_cast<TClonesArray*>(fInputEvent->FindListObject(fInputNonStandardJetBranchName.Data()));
2434 
2435  if(!fNonStandardJets)
2436  {
2437  //check if jet branch exist; exit if not
2438  fInputEvent->Print();
2439 
2440  AliFatal(Form("%s:%d no reconstructed jet array with name %s in AOD", (char*)__FILE__,__LINE__,fInputNonStandardJetBranchName.Data()));
2441  }
2442  else
2443  {
2444  AliDebug(1,Form("AOD input jets %d", fNonStandardJets->GetEntriesFast()));
2445  }
2446 }
2447 
2448 //_________________________________________________
2452 //_________________________________________________
2454 {
2455  AliDebug(1,"Begin");
2456  //
2457  //check if branch name is given
2458  if(!fInputBackgroundJetBranchName.Length())
2459  {
2460  fInputEvent->Print();
2461 
2462  AliFatal("No background jet branch name specified. Specify among existing ones.");
2463  }
2464 
2465  fBackgroundJets = (AliAODJetEventBackground*)(fInputEvent->FindListObject(fInputBackgroundJetBranchName.Data()));
2466 
2467  if(!fBackgroundJets)
2468  {
2469  //check if jet branch exist; exit if not
2470  fInputEvent->Print();
2471 
2472  AliFatal(Form("%s:%d no reconstructed jet array with name %s in AOD", (char*)__FILE__,__LINE__,fInputBackgroundJetBranchName.Data()));
2473  }
2474  else
2475  {
2476  AliDebug(1,"FillInputBackgroundJets");
2477  fBackgroundJets->Print("");
2478  }
2479 }
2480 
2481 //____________________________________________________________________
2487 //____________________________________________________________________
2489 {
2490  // init some variables
2491  Int_t trigtimes[30], globCol, globRow,ntimes, i;
2492  Int_t absId = -1; //[100];
2493  Int_t nPatch = 0;
2494 
2495  TArrayI patches(0);
2496 
2497  // get object pointer
2498  AliVCaloTrigger *caloTrigger = GetInputEvent()->GetCaloTrigger( "EMCAL" );
2499 
2500  if(!caloTrigger)
2501  {
2502  AliError("Trigger patches input (AliVCaloTrigger) not available in data!");
2503  return patches;
2504  }
2505 
2506  //printf("CaloTrigger Entries %d\n",caloTrigger->GetEntries() );
2507 
2508  // class is not empty
2509  if( caloTrigger->GetEntries() > 0 )
2510  {
2511  // must reset before usage, or the class will fail
2512  caloTrigger->Reset();
2513 
2514  // go throuth the trigger channels
2515  while( caloTrigger->Next() )
2516  {
2517  // get position in global 2x2 tower coordinates
2518  caloTrigger->GetPosition( globCol, globRow );
2519 
2520  //L0
2521  if(IsEventEMCALL0())
2522  {
2523  // get dimension of time arrays
2524  caloTrigger->GetNL0Times( ntimes );
2525 
2526  // no L0s in this channel
2527  // presence of the channel in the iterator still does not guarantee that L0 was produced!!
2528  if( ntimes < 1 )
2529  continue;
2530 
2531  // get timing array
2532  caloTrigger->GetL0Times( trigtimes );
2533  //printf("Get L0 patch : n times %d - trigger time window %d - %d\n",ntimes, tmin,tmax);
2534 
2535  // go through the array
2536  for( i = 0; i < ntimes; i++ )
2537  {
2538  // check if in cut - 8,9 shall be accepted in 2011
2539  if( trigtimes[i] >= tmin && trigtimes[i] <= tmax )
2540  {
2541  //printf("Accepted trigger time %d \n",trigtimes[i]);
2542  //if(nTrig > 99) continue;
2543  GetCaloUtils()->GetEMCALGeometry()->GetAbsFastORIndexFromPositionInEMCAL(globCol,globRow, absId);
2544  //printf("pass the time cut globCol %d, globRow %d absId %d\n",globCol,globRow, absId);
2545  patches.Set(nPatch+1);
2546  patches.AddAt(absId,nPatch++);
2547  }
2548  } // trigger time array
2549  }//L0
2550  else if(IsEventEMCALL1()) // L1
2551  {
2552  Int_t bit = 0;
2553  caloTrigger->GetTriggerBits(bit);
2554 
2555  Int_t sum = 0;
2556  caloTrigger->GetL1TimeSum(sum);
2557  //fBitEGA-=2;
2558  Bool_t isEGA1 = ((bit >> fBitEGA ) & 0x1) && IsEventEMCALL1Gamma1() ;
2559  Bool_t isEGA2 = ((bit >> (fBitEGA+1)) & 0x1) && IsEventEMCALL1Gamma2() ;
2560  Bool_t isEJE1 = ((bit >> fBitEJE ) & 0x1) && IsEventEMCALL1Jet1 () ;
2561  Bool_t isEJE2 = ((bit >> (fBitEJE+1)) & 0x1) && IsEventEMCALL1Jet2 () ;
2562 
2563  //if((bit>> fBitEGA )&0x1) printf("Trig Bit %d - bit %d - EG1 %d - EG2 %d\n",fBitEGA ,bit,IsEventEMCALL1Gamma1(),IsEventEMCALL1Gamma2());
2564  //if((bit>>(fBitEGA+1))&0x1) printf("Trig Bit %d - bit %d - EG1 %d - EG2 %d\n",fBitEGA+1,bit,IsEventEMCALL1Gamma1(),IsEventEMCALL1Gamma2());
2565 
2566  if(!isEGA1 && !isEJE1 && !isEGA2 && !isEJE2) continue;
2567 
2568  Int_t patchsize = -1;
2569  if (isEGA1 || isEGA2) patchsize = 2;
2570  else if (isEJE1 || isEJE2) patchsize = 16;
2571 
2572  //printf("**** Get L1 Patch: Bit %x, sum %d, patchsize %d, EGA1 %d, EGA2 %d, EJE1 %d, EJE2 %d, EGA bit %d, EJE bit %d, Trigger Gamma %d, Trigger Jet %d\n",
2573  // bit,sum,patchsize,isEGA1,isEGA2,isEJE1,isEJE2,fBitEGA,fBitEJE,IsEventEMCALL1Gamma(),IsEventEMCALL1Jet());
2574 
2575 
2576  // add 2x2 (EGA) or 16x16 (EJE) patches
2577  for(Int_t irow=0; irow < patchsize; irow++)
2578  {
2579  for(Int_t icol=0; icol < patchsize; icol++)
2580  {
2581  GetCaloUtils()->GetEMCALGeometry()->GetAbsFastORIndexFromPositionInEMCAL(globCol+icol,globRow+irow, absId);
2582  //printf("pass the time cut globCol %d, globRow %d absId %d\n",globCol,globRow, absId);
2583  patches.Set(nPatch+1);
2584  patches.AddAt(absId,nPatch++);
2585  }
2586  }
2587 
2588  } // L1
2589 
2590  } // trigger iterator
2591  } // go through triggers
2592 
2593  if(patches.GetSize()<=0) AliInfo(Form("No patch found! for triggers: %s and selected <%s>",
2595  //else printf(">>>>> N patches %d, test %d,first %d, last %d\n",patches.GetSize(), nPatch, patches.At(0), patches.At(patches.GetSize()-1));
2596 
2597  return patches;
2598 }
2599 
2600 //____________________________________________________________
2604 //____________________________________________________________
2606 {
2607  // Init info from previous event
2608  fTriggerClusterIndex = -1;
2609  fTriggerClusterId = -1;
2610  fTriggerClusterBC = -10000;
2611  fIsExoticEvent = kFALSE;
2612  fIsBadCellEvent = kFALSE;
2613  fIsBadMaxCellEvent = kFALSE;
2614 
2615  fIsTriggerMatch = kFALSE;
2616  fIsTriggerMatchOpenCut[0] = kFALSE;
2617  fIsTriggerMatchOpenCut[1] = kFALSE;
2618  fIsTriggerMatchOpenCut[2] = kFALSE;
2619 
2620  // Do only analysis for triggered events
2621  if(!IsEventEMCALL1() && !IsEventEMCALL0())
2622  {
2623  fTriggerClusterBC = 0;
2624  return;
2625  }
2626 
2627  //printf("***** Try to match trigger to cluster %d **** L0 %d, L1 %d\n",fTriggerPatchClusterMatch,IsEventEMCALL0(),IsEventEMCALL1());
2628 
2629  //Recover the list of clusters
2630  TClonesArray * clusterList = 0;
2631  if (fInputEvent->FindListObject(fEMCALClustersListName))
2632  {
2633  clusterList = dynamic_cast<TClonesArray*> (fInputEvent->FindListObject(fEMCALClustersListName));
2634  }
2635  else if(fOutputEvent)
2636  {
2637  clusterList = dynamic_cast<TClonesArray*> (fOutputEvent->FindListObject(fEMCALClustersListName));
2638  }
2639 
2640  // Get number of clusters and of trigger patches
2641  Int_t nclusters = fInputEvent->GetNumberOfCaloClusters();
2642  if(clusterList)
2643  nclusters = clusterList->GetEntriesFast();
2644 
2645  Int_t nPatch = patches.GetSize();
2646  Float_t exoDiffTime = GetCaloUtils()->GetEMCALRecoUtils()->GetExoticCellDiffTimeCut();
2647 
2648  //Init some variables used in the cluster loop
2649  Float_t tofPatchMax = 100000;
2650  Float_t ePatchMax =-1;
2651 
2652  Float_t tofMax = 100000;
2653  Float_t eMax =-1;
2654 
2655  Int_t clusMax =-1;
2656  Int_t idclusMax =-1;
2657  Bool_t badClMax = kFALSE;
2658  Bool_t badCeMax = kFALSE;
2659  Bool_t exoMax = kFALSE;
2660 // Int_t absIdMaxTrig= -1;
2661  Int_t absIdMaxMax = -1;
2662 
2663  Int_t nOfHighECl = 0 ;
2664 
2665  //
2666  // Check what is the trigger threshold
2667  // set minimu energym of candidate for trigger cluster
2668  //
2670 
2671  Float_t triggerThreshold = fTriggerL1EventThreshold;
2672  if(IsEventEMCALL0()) triggerThreshold = fTriggerL0EventThreshold;
2673  Float_t minE = triggerThreshold / 2.;
2674 
2675  // This method is not really suitable for JET trigger
2676  // but in case, reduce the energy cut since we do not trigger on high energy particle
2677  if(IsEventEMCALL1Jet() || minE < 1) minE = 1;
2678 
2679  AliDebug(1,Form("IsL1Trigger %d, IsL1JetTrigger? %d, IsL0Trigger %d, L1 threshold %2.1f, L0 threshold %2.1f, Min cluster E %2.2f",IsEventEMCALL1Jet(), IsEventEMCALL1(), IsEventEMCALL0(), fTriggerL1EventThreshold,fTriggerL0EventThreshold,minE));
2680 
2681  //
2682  // Loop on the clusters, check if there is any that falls into one of the patches
2683  //
2684  for (Int_t iclus = 0; iclus < nclusters; iclus++)
2685  {
2686  AliVCluster * clus = 0;
2687  if(clusterList) clus = (AliVCluster*) clusterList->At(iclus);
2688  else clus = fInputEvent->GetCaloCluster(iclus);
2689 
2690  if ( !clus ) continue ;
2691 
2692  if ( !clus->IsEMCAL() ) continue ;
2693 
2694  //Skip clusters with too low energy to be triggering
2695  if ( clus->E() < minE ) continue ;
2696 
2697  Float_t frac = -1;
2698  Int_t absIdMax = GetCaloUtils()->GetMaxEnergyCell(fInputEvent->GetEMCALCells(), clus,frac);
2699 
2700  Bool_t badCluster = GetCaloUtils()->GetEMCALRecoUtils()->ClusterContainsBadChannel(GetCaloUtils()->GetEMCALGeometry(),
2701  clus->GetCellsAbsId(),clus->GetNCells());
2702  UShort_t cellMax[] = {(UShort_t) absIdMax};
2703  Bool_t badCell = GetCaloUtils()->GetEMCALRecoUtils()->ClusterContainsBadChannel(GetCaloUtils()->GetEMCALGeometry(),cellMax,1);
2704 
2705  // if cell is bad, it can happen that time calibration is not available,
2706  // when calculating if it is exotic, this can make it to be exotic by default
2707  // open it temporarily for this cluster
2708  if(badCell)
2709  GetCaloUtils()->GetEMCALRecoUtils()->SetExoticCellDiffTimeCut(10000000);
2710 
2711  Bool_t exotic = GetCaloUtils()->GetEMCALRecoUtils()->IsExoticCluster(clus, fInputEvent->GetEMCALCells());
2712 
2713  // Set back the time cut on exotics
2714  if(badCell)
2715  GetCaloUtils()->GetEMCALRecoUtils()->SetExoticCellDiffTimeCut(exoDiffTime);
2716 
2717  // Energy threshold for exotic Ecross typically at 4 GeV,
2718  // for lower energy, check that there are more than 1 cell in the cluster
2719  if(!exotic && clus->GetNCells() < 2) exotic = kTRUE;
2720 
2721  Float_t energy = clus->E();
2722  Int_t idclus = clus->GetID();
2723 
2724  Double_t tof = clus->GetTOF();
2725  if(GetCaloUtils()->GetEMCALRecoUtils()->IsTimeRecalibrationOn() && fTriggerClusterTimeRecal){
2726  GetCaloUtils()->GetEMCALRecoUtils()->RecalibrateCellTime(absIdMax,fInputEvent->GetBunchCrossNumber(),tof);
2727  //additional L1 phase shift
2728  if(GetCaloUtils()->GetEMCALRecoUtils()->IsL1PhaseInTimeRecalibrationOn()){
2729  GetCaloUtils()->GetEMCALRecoUtils()->RecalibrateCellTimeL1Phase(GetCaloUtils()->GetEMCALGeometry()->GetSuperModuleNumber(absIdMax), fInputEvent->GetBunchCrossNumber(), tof);
2730  }
2731  }
2732  tof *=1.e9;
2733 
2734  //printf("cluster %d, ID %d, E %2.2f, tof %2.2f, AbsId max %d, exotic %d, bad Cluster %d, bad Cell %d\n",
2735  // iclus,idclus, energy,tof,absIdMax, exotic, badCluster,badCell);
2736 
2737  // Find the highest energy cluster, avobe trigger threshold
2738  // in the event in case no match to trigger is found
2739  if( energy > eMax )
2740  {
2741  tofMax = tof;
2742  eMax = energy;
2743  badClMax = badCluster;
2744  badCeMax = badCell;
2745  exoMax = exotic;
2746  clusMax = iclus;
2747  idclusMax = idclus;
2748  absIdMaxMax = absIdMax;
2749  }
2750 
2751  // count the good clusters in the event avobe the trigger threshold
2752  // to check the exotic events
2753  if(!badCluster && !exotic)
2754  nOfHighECl++;
2755 
2756  // Find match to trigger
2757  if(fTriggerPatchClusterMatch && nPatch>0)
2758  {
2759  for(Int_t iabsId =0; iabsId < nPatch; iabsId++)
2760  {
2761  Int_t absIDCell[4];
2762  GetCaloUtils()->GetEMCALGeometry()->GetCellIndexFromFastORIndex(patches.At(iabsId), absIDCell);
2763  //if(tof > 75 ) printf("E %2.2f TOF %2.2f Trigger patch %d, cells : %d, %d, %d, %d\n",
2764  // clus->E(),tof,patches.At(iabsId), absIDCell[0],absIDCell[1],absIDCell[2],absIDCell[3]);
2765 
2766  for(Int_t ipatch = 0; ipatch < 4; ipatch++)
2767  {
2768  if(absIdMax == absIDCell[ipatch])
2769  {
2770  //printf("*** Patches : absId %d, E %2.1f, tof %f \n",absIdMax,clus->E(), tof);
2771  if(energy > ePatchMax)
2772  {
2773  tofPatchMax = tof;
2774  ePatchMax = energy;
2775  fIsBadCellEvent = badCluster;
2776  fIsBadMaxCellEvent = badCell;
2777  fIsExoticEvent = exotic;
2778  fTriggerClusterIndex = iclus;
2779  fTriggerClusterId = idclus;
2780  fIsTriggerMatch = kTRUE;
2781 // absIdMaxTrig = absIdMax;
2782  }
2783  }
2784  }// cell patch loop
2785  }// trigger patch loop
2786  } // Do trigger patch matching
2787 
2788  }// Cluster loop
2789 
2790  // If there was no match, assign as trigger
2791  // the highest energy cluster in the event
2792  if(!fIsTriggerMatch)
2793  {
2794  tofPatchMax = tofMax;
2795  ePatchMax = eMax;
2796  fIsBadCellEvent = badClMax;
2797  fIsBadMaxCellEvent = badCeMax;
2798  fIsExoticEvent = exoMax;
2799  fTriggerClusterIndex = clusMax;
2800  fTriggerClusterId = idclusMax;
2801  }
2802 
2803  Double_t tofPatchMaxUS = TMath::Abs(tofPatchMax);
2804 
2805  if (tofPatchMaxUS < 28 ) fTriggerClusterBC = 0 ;
2806  else if(tofPatchMaxUS < 75 ) fTriggerClusterBC = 1 ;
2807  else if(tofPatchMaxUS < 125) fTriggerClusterBC = 2 ;
2808  else if(tofPatchMaxUS < 175) fTriggerClusterBC = 3 ;
2809  else if(tofPatchMaxUS < 225) fTriggerClusterBC = 4 ;
2810  else if(tofPatchMaxUS < 275) fTriggerClusterBC = 5 ;
2811  else
2812  {
2813  //printf("AliCaloTrackReader::MatchTriggerCluster() - Large BC - tof %2.3f - Index %d\n",tofPatchMaxUS,fTriggerClusterIndex);
2815  else
2816  {
2817  fTriggerClusterIndex = -2;
2818  fTriggerClusterId = -2;
2819  }
2820  }
2821 
2822  if(tofPatchMax < 0) fTriggerClusterBC*=-1;
2823 
2824 
2825  // printf("AliCaloTrackReader::MatchTriggerCluster(TArrayI patches) - Trigger cluster: index %d, ID %d, E = %2.2f, tof = %2.2f (BC = %d), bad cluster? %d, bad cell? %d, exotic? %d, patch match? %d, n High E cluster %d, absId Max %d\n",
2826  // fTriggerClusterIndex, fTriggerClusterId,ePatchMax, tofPatchMax,
2827  // fTriggerClusterBC, fIsBadCellEvent,fIsBadMaxCellEvent,fIsExoticEvent, fIsTriggerMatch, nOfHighECl,absIdMaxMax);
2828  //
2829  // if(!fIsTriggerMatch) printf("\t highest energy cluster: index %d, ID %d, E = %2.2f, tof = %2.2f, bad cluster? %d, bad cell? %d, exotic? %d\n",
2830  // clusMax, idclusMax, eMax,tofMax, badClMax, badCeMax,exoMax);
2831 
2832  //Redo matching but open cuts
2833  if(!fIsTriggerMatch && fTriggerClusterId >= 0)
2834  {
2835  // Open time patch time
2836  TArrayI patchOpen = GetTriggerPatches(7,10);
2837 
2838  Int_t patchAbsIdOpenTime = -1;
2839  for(Int_t iabsId =0; iabsId < patchOpen.GetSize(); iabsId++)
2840  {
2841  Int_t absIDCell[4];
2842  patchAbsIdOpenTime = patchOpen.At(iabsId);
2843  GetCaloUtils()->GetEMCALGeometry()->GetCellIndexFromFastORIndex(patchAbsIdOpenTime, absIDCell);
2844  //if(tof > 75 ) printf("E %2.2f TOF %2.2f Trigger patch %d, cells : %d, %d, %d, %d\n",
2845  // clus->E(),tof,patches.At(iabsId), absIDCell[0],absIDCell[1],absIDCell[2],absIDCell[3]);
2846 
2847  for(Int_t ipatch = 0; ipatch < 4; ipatch++)
2848  {
2849  if(absIdMaxMax == absIDCell[ipatch])
2850  {
2851  fIsTriggerMatchOpenCut[0] = kTRUE;
2852  break;
2853  }
2854  }// cell patch loop
2855  }// trigger patch loop
2856 
2857  // Check neighbour patches
2858  Int_t patchAbsId = -1;
2859  Int_t globalCol = -1;
2860  Int_t globalRow = -1;
2861  GetCaloUtils()->GetEMCALGeometry()->GetFastORIndexFromCellIndex(absIdMaxMax, patchAbsId);
2862  GetCaloUtils()->GetEMCALGeometry()->GetPositionInEMCALFromAbsFastORIndex(patchAbsId,globalCol,globalRow);
2863 
2864  // Check patches with strict time cut
2865  Int_t patchAbsIdNeigh = -1;
2866  for(Int_t icol = globalCol-1; icol <= globalCol+1; icol++)
2867  {
2868  if(icol < 0 || icol > 47) continue;
2869 
2870  for(Int_t irow = globalRow; irow <= globalRow+1; irow++)
2871  {
2872  if(irow < 0 || irow > 63) continue;
2873 
2874  GetCaloUtils()->GetEMCALGeometry()->GetAbsFastORIndexFromPositionInEMCAL(icol, irow, patchAbsIdNeigh);
2875 
2876  if ( patchAbsIdNeigh < 0 ) continue;
2877 
2878  for(Int_t iabsId =0; iabsId < patches.GetSize(); iabsId++)
2879  {
2880  if(patchAbsIdNeigh == patches.At(iabsId))
2881  {
2882  fIsTriggerMatchOpenCut[1] = kTRUE;
2883  break;
2884  }
2885  }// trigger patch loop
2886 
2887  }// row
2888  }// col
2889 
2890  // Check patches with open time cut
2891  Int_t patchAbsIdNeighOpenTime = -1;
2892  for(Int_t icol = globalCol-1; icol <= globalCol+1; icol++)
2893  {
2894  if(icol < 0 || icol > 47) continue;
2895 
2896  for(Int_t irow = globalRow; irow <= globalRow+1; irow++)
2897  {
2898  if(irow < 0 || irow > 63) continue;
2899 
2900  GetCaloUtils()->GetEMCALGeometry()->GetAbsFastORIndexFromPositionInEMCAL(icol, irow, patchAbsIdNeighOpenTime);
2901 
2902  if ( patchAbsIdNeighOpenTime < 0 ) continue;
2903 
2904  for(Int_t iabsId =0; iabsId < patchOpen.GetSize(); iabsId++)
2905  {
2906  if(patchAbsIdNeighOpenTime == patchOpen.At(iabsId))
2907  {
2908  fIsTriggerMatchOpenCut[2] = kTRUE;
2909  break;
2910  }
2911  }// trigger patch loop
2912 
2913  }// row
2914  }// col
2915 
2916  // printf("No match, new match: Open time %d-%d, open Neigh %d-%d, both open %d-%d\n",fIsTriggerMatchOpenCut[0],patchAbsIdOpenTime,
2917  // fIsTriggerMatchOpenCut[1],patchAbsIdNeigh,
2918  // fIsTriggerMatchOpenCut[2],patchAbsIdNeighOpenTime);
2919 
2920  patchOpen.Reset();
2921 
2922  }// No trigger match found
2923  //printf("Trigger BC %d, Id %d, Index %d\n",fTriggerClusterBC,fTriggerClusterId,fTriggerClusterIndex);
2924 }
2925 
2926 //_________________________________________________________
2930 //_________________________________________________________
2932 {
2934  {
2935  // get object pointer
2936  AliVCaloTrigger *caloTrigger = GetInputEvent()->GetCaloTrigger( "EMCAL" );
2937 
2938  if ( fBitEGA == 6 )
2939  {
2940  if (IsEventEMCALL1Gamma1()) fTriggerL1EventThreshold = 0.07874*caloTrigger->GetL1Threshold(1);
2941  else if(IsEventEMCALL1Gamma2()) fTriggerL1EventThreshold = 0.07874*caloTrigger->GetL1Threshold(3);
2942  else if(IsEventEMCALL1Jet1 ()) fTriggerL1EventThreshold = 0.07874*caloTrigger->GetL1Threshold(0);
2943  else if(IsEventEMCALL1Jet2 ()) fTriggerL1EventThreshold = 0.07874*caloTrigger->GetL1Threshold(2);
2944 
2945  // printf("L1 trigger Threshold Jet1 %f, Gamma1 %f, Jet2 %f, Gamma2 %f\n",
2946  // 0.07874*caloTrigger->GetL1Threshold(0),
2947  // 0.07874*caloTrigger->GetL1Threshold(1),
2948  // 0.07874*caloTrigger->GetL1Threshold(2),
2949  // 0.07874*caloTrigger->GetL1Threshold(3));
2950  }
2951  else
2952  {
2953  // Old AOD data format, in such case, order of thresholds different!!!
2954  if (IsEventEMCALL1Gamma1()) fTriggerL1EventThreshold = 0.07874*caloTrigger->GetL1Threshold(0);
2955  else if(IsEventEMCALL1Gamma2()) fTriggerL1EventThreshold = 0.07874*caloTrigger->GetL1Threshold(2);
2956  else if(IsEventEMCALL1Jet1 ()) fTriggerL1EventThreshold = 0.07874*caloTrigger->GetL1Threshold(1);
2957  else if(IsEventEMCALL1Jet2 ()) fTriggerL1EventThreshold = 0.07874*caloTrigger->GetL1Threshold(3);
2958 
2959  // printf("L1 trigger Threshold Jet1 %f, Gamma1 %f, Jet2 %f, Gamma2 %f\n",
2960  // 0.07874*caloTrigger->GetL1Threshold(1),
2961  // 0.07874*caloTrigger->GetL1Threshold(0),
2962  // 0.07874*caloTrigger->GetL1Threshold(3),
2963  // 0.07874*caloTrigger->GetL1Threshold(2));
2964  }
2965  }
2966 
2967  // Set L0 threshold, if not set by user
2969  {
2970  // Revise for periods > LHC11d
2971  Int_t runNumber = fInputEvent->GetRunNumber();
2972  if (runNumber < 146861) fTriggerL0EventThreshold = 3. ;
2973  else if(runNumber < 154000) fTriggerL0EventThreshold = 4. ;
2974  else if(runNumber < 165000) fTriggerL0EventThreshold = 5.5;
2975  else fTriggerL0EventThreshold = 2 ;
2976  }
2977 }
2978 
2979 //________________________________________________________
2981 //________________________________________________________
2982 void AliCaloTrackReader::Print(const Option_t * opt) const
2983 {
2984  if(! opt)
2985  return;
2986 
2987  printf("***** Print: %s %s ******\n", GetName(), GetTitle() ) ;
2988  printf("Task name : %s\n", fTaskName.Data()) ;
2989  printf("Data type : %d\n", fDataType) ;
2990  printf("CTS Min pT : %2.1f GeV/c\n", fCTSPtMin) ;
2991  printf("EMCAL Min pT : %2.1f GeV/c\n", fEMCALPtMin) ;
2992  printf("PHOS Min pT : %2.1f GeV/c\n", fPHOSPtMin) ;
2993  printf("CTS Max pT : %2.1f GeV/c\n", fCTSPtMax) ;
2994  printf("EMCAL Max pT : %2.1f GeV/c\n", fEMCALPtMax) ;
2995  printf("PHOS Max pT : %2.1f GeV/c\n", fPHOSPtMax) ;
2996  printf("EMCAL Bad Dist > %2.1f \n" , fEMCALBadChMinDist) ;
2997  printf("PHOS Bad Dist > %2.1f \n" , fPHOSBadChMinDist) ;
2998  printf("EMCAL N cells > %d \n" , fEMCALNCellsCut) ;
2999  printf("PHOS N cells > %d \n" , fPHOSNCellsCut) ;
3000  printf("EMCAL Time Cut: %3.1f < TOF < %3.1f\n", fEMCALTimeCutMin, fEMCALTimeCutMax);
3001  printf("Use CTS = %d\n", fFillCTS) ;
3002  printf("Use EMCAL = %d\n", fFillEMCAL) ;
3003  printf("Use DCAL = %d\n", fFillDCAL) ;
3004  printf("Use PHOS = %d\n", fFillPHOS) ;
3005  printf("Use EMCAL Cells = %d\n", fFillEMCALCells) ;
3006  printf("Use PHOS Cells = %d\n", fFillPHOSCells) ;
3007  printf("Track status = %d\n", (Int_t) fTrackStatus) ;
3008 
3009  printf("Track Mult Eta Cut = %2.2f\n", fTrackMultEtaCut) ;
3010  printf("Write delta AOD = %d\n", fWriteOutputDeltaAOD) ;
3011  printf("Recalculate Clusters = %d, E linearity = %d\n", fRecalculateClusters, fCorrectELinearity) ;
3012 
3013  printf("Use Triggers selected in SE base class %d; If not what Trigger Mask? %d; MB Trigger Mask for mixed %d \n",
3015 
3017  printf("Compare jet pt and pt hard to accept event, factor = %2.2f",fPtHardAndJetPtFactor);
3018 
3020  printf("Compare cluster pt and pt hard to accept event, factor = %2.2f",fPtHardAndClusterPtFactor);
3021 
3022  printf("Read Kine from, stack? %d, AOD ? %d \n", fReadStack, fReadAODMCParticles) ;
3023  printf("Delta AOD File Name = %s\n", fDeltaAODFileName.Data()) ;
3024  printf("Centrality: Class %s, Option %d, Bin [%d,%d] \n", fCentralityClass.Data(),fCentralityOpt,fCentralityBin[0], fCentralityBin[1]) ;
3025 
3026  printf(" \n") ;
3027 }
3028 
3029 //__________________________________________
3033 //__________________________________________
3035 {
3036  // Count number of cells with energy larger than 0.1 in SM3, cut on this number
3037  Int_t ncellsSM3 = 0;
3038  for(Int_t icell = 0; icell < fInputEvent->GetEMCALCells()->GetNumberOfCells(); icell++)
3039  {
3040  Int_t absID = fInputEvent->GetEMCALCells()->GetCellNumber(icell);
3041  Int_t sm = GetCaloUtils()->GetEMCALGeometry()->GetSuperModuleNumber(absID);
3042  if(fInputEvent->GetEMCALCells()->GetAmplitude(icell) > 0.1 && sm==3) ncellsSM3++;
3043  }
3044 
3045  Int_t ncellcut = 21;
3046  if(GetFiredTriggerClasses().Contains("EMC")) ncellcut = 35;
3047 
3048  if(ncellsSM3 >= ncellcut)
3049  {
3050  AliDebug(1,Form("Reject event with ncells in SM3 %d, cut %d, trig %s",
3051  ncellsSM3,ncellcut,GetFiredTriggerClasses().Data()));
3052  return kTRUE;
3053  }
3054 
3055  return kFALSE;
3056 }
3057 
3058 //_________________________________________________________
3062 //_________________________________________________________
3064 {
3065  if(label < 0) return ;
3066 
3067  AliAODEvent * evt = dynamic_cast<AliAODEvent*> (fInputEvent) ;
3068  if(!evt) return ;
3069 
3070  TClonesArray * arr = dynamic_cast<TClonesArray*>(evt->FindListObject("mcparticles")) ;
3071  if(!arr) return ;
3072 
3073  if(label < arr->GetEntriesFast())
3074  {
3075  AliAODMCParticle * particle = dynamic_cast<AliAODMCParticle *>(arr->At(label));
3076  if(!particle) return ;
3077 
3078  if(label == particle->Label()) return ; // label already OK
3079  //else printf("AliCaloTrackReader::RemapMCLabelForAODs() - Label %d - AOD stack %d \n",label, particle->Label());
3080  }
3081  //else printf("AliCaloTrackReader::RemapMCLabelForAODs() - Label %d > AOD labels %d \n",label, arr->GetEntriesFast());
3082 
3083  // loop on the particles list and check if there is one with the same label
3084  for(Int_t ind = 0; ind < arr->GetEntriesFast(); ind++ )
3085  {
3086  AliAODMCParticle * particle = dynamic_cast<AliAODMCParticle *>(arr->At(ind));
3087  if(!particle) continue ;
3088 
3089  if(label == particle->Label())
3090  {
3091  label = ind;
3092  //printf("AliAnalysisTaskEMCALClusterize::RemapMCLabelForAODs() - New Label Index %d \n",label);
3093  return;
3094  }
3095  }
3096 
3097  label = -1;
3098 
3099  //printf("AliCaloTrackReader::RemapMCLabelForAODs() - Label not found set to -1 \n");
3100 }
3101 
3102 //___________________________________
3104 //___________________________________
3106 {
3107  if(fCTSTracks) fCTSTracks -> Clear();
3108  if(fEMCALClusters) fEMCALClusters -> Clear("C");
3109  if(fPHOSClusters) fPHOSClusters -> Clear("C");
3110 
3111  fV0ADC[0] = 0; fV0ADC[1] = 0;
3112  fV0Mul[0] = 0; fV0Mul[1] = 0;
3113 
3114  if(fNonStandardJets) fNonStandardJets -> Clear("C");
3115  fBackgroundJets->Reset();
3116 }
3117 
3118 //___________________________________________
3122 //___________________________________________
3124 {
3125  fEventTrigMinBias = kFALSE;
3126  fEventTrigCentral = kFALSE;
3127  fEventTrigSemiCentral = kFALSE;
3128  fEventTrigEMCALL0 = kFALSE;
3129  fEventTrigEMCALL1Gamma1 = kFALSE;
3130  fEventTrigEMCALL1Gamma2 = kFALSE;
3131  fEventTrigEMCALL1Jet1 = kFALSE;
3132  fEventTrigEMCALL1Jet2 = kFALSE;
3133 
3134  AliDebug(1,Form("Select trigger mask bit %d - Trigger Event %s - Select <%s>",
3136 
3137  if(fEventTriggerMask <=0 )// in case no mask set
3138  {
3139  // EMC triggered event? Which type?
3140  if( GetFiredTriggerClasses().Contains("-B-") || GetFiredTriggerClasses().Contains("-S-") || GetFiredTriggerClasses().Contains("-I-") )
3141  {
3142  if ( GetFiredTriggerClasses().Contains("EGA" ) ||
3143  GetFiredTriggerClasses().Contains("EG1" ) )
3144  {
3145  fEventTrigEMCALL1Gamma1 = kTRUE;
3146  if( GetFiredTriggerClasses().Contains("EG1" ) && !fFiredTriggerClassName.Contains("EG1") ) fEventTrigEMCALL1Gamma1 = kFALSE;
3147  }
3148  else if( GetFiredTriggerClasses().Contains("EG2" ) )
3149  {
3150  fEventTrigEMCALL1Gamma2 = kTRUE;
3151  if( !fFiredTriggerClassName.Contains("EG2") ) fEventTrigEMCALL1Gamma2 = kFALSE;
3152  }
3153  else if( GetFiredTriggerClasses().Contains("EJE" ) ||
3154  GetFiredTriggerClasses().Contains("EJ1" ) )
3155  {
3156  fEventTrigEMCALL1Jet1 = kTRUE;
3157  if( GetFiredTriggerClasses().Contains("EJ1" ) && !fFiredTriggerClassName.Contains("EJ1") )
3158  fEventTrigEMCALL1Jet1 = kFALSE;
3159  }
3160  else if( GetFiredTriggerClasses().Contains("EJ2" ) )
3161  {
3162  fEventTrigEMCALL1Jet2 = kTRUE;
3163  if( !fFiredTriggerClassName.Contains("EJ2") ) fEventTrigEMCALL1Jet2 = kFALSE;
3164  }
3165  else if( GetFiredTriggerClasses().Contains("CEMC") &&
3166  !GetFiredTriggerClasses().Contains("EGA" ) &&
3167  !GetFiredTriggerClasses().Contains("EJE" ) &&
3168  !GetFiredTriggerClasses().Contains("EG1" ) &&
3169  !GetFiredTriggerClasses().Contains("EJ1" ) &&
3170  !GetFiredTriggerClasses().Contains("EG2" ) &&
3171  !GetFiredTriggerClasses().Contains("EJ2" ) )
3172  {
3173  fEventTrigEMCALL0 = kTRUE;
3174  }
3175 
3176  //Min bias event trigger?
3177  if (GetFiredTriggerClasses().Contains("CCENT_R2-B-NOPF-ALLNOTRD"))
3178  {
3179  fEventTrigCentral = kTRUE;
3180  }
3181  else if(GetFiredTriggerClasses().Contains("CSEMI_R1-B-NOPF-ALLNOTRD"))
3182  {
3183  fEventTrigSemiCentral = kTRUE;
3184  }
3185  else if((GetFiredTriggerClasses().Contains("CINT") || GetFiredTriggerClasses().Contains("CPBI2_B1") ) &&
3186  GetFiredTriggerClasses().Contains("-NOPF-ALLNOTRD") )
3187  {
3188  fEventTrigMinBias = kTRUE;
3189  }
3190  }
3191  }
3192  else
3193  {
3194  // EMC L1 Gamma
3195  if ( fEventTriggerMask & AliVEvent::kEMCEGA )
3196  {
3197  //printf("EGA trigger bit\n");
3198  if (GetFiredTriggerClasses().Contains("EG"))
3199  {
3200  if (GetFiredTriggerClasses().Contains("EGA")) fEventTrigEMCALL1Gamma1 = kTRUE;
3201  else
3202  {
3203  if(GetFiredTriggerClasses().Contains("EG1")) fEventTrigEMCALL1Gamma1 = kTRUE;
3204  if(GetFiredTriggerClasses().Contains("EG2")) fEventTrigEMCALL1Gamma2 = kTRUE;
3205  }
3206  }
3207  }
3208  // EMC L1 Jet
3209  else if( fEventTriggerMask & AliVEvent::kEMCEJE )
3210  {
3211  //printf("EGA trigger bit\n");
3212  if (GetFiredTriggerClasses().Contains("EJ"))
3213  {
3214  if (GetFiredTriggerClasses().Contains("EJE")) fEventTrigEMCALL1Jet1 = kTRUE;
3215  else
3216  {
3217  if(GetFiredTriggerClasses().Contains("EJ1")) fEventTrigEMCALL1Jet1 = kTRUE;
3218  if(GetFiredTriggerClasses().Contains("EJ2")) fEventTrigEMCALL1Jet2 = kTRUE;
3219  }
3220  }
3221  }
3222  // EMC L0
3223  else if((fEventTriggerMask & AliVEvent::kEMC7) ||
3224  (fEventTriggerMask & AliVEvent::kEMC1) )
3225  {
3226  //printf("L0 trigger bit\n");
3227  fEventTrigEMCALL0 = kTRUE;
3228  }
3229  // Min Bias Pb-Pb
3230  else if( fEventTriggerMask & AliVEvent::kCentral )
3231  {
3232  //printf("MB semi central trigger bit\n");
3233  fEventTrigSemiCentral = kTRUE;
3234  }
3235  // Min Bias Pb-Pb
3236  else if( fEventTriggerMask & AliVEvent::kSemiCentral )
3237  {
3238  //printf("MB central trigger bit\n");
3239  fEventTrigCentral = kTRUE;
3240  }
3241  // Min Bias pp, PbPb, pPb
3242  else if((fEventTriggerMask & AliVEvent::kMB ) ||
3243  (fEventTriggerMask & AliVEvent::kINT7) ||
3244  (fEventTriggerMask & AliVEvent::kINT8) ||
3245  (fEventTriggerMask & AliVEvent::kAnyINT) )
3246  {
3247  //printf("MB trigger bit\n");
3248  fEventTrigMinBias = kTRUE;
3249  }
3250  }
3251 
3252  AliDebug(1,Form("Event bits: \n \t MB %d, Cen %d, Sem %d, L0 %d, L1G1 %d, L1G2 %d, L1J1 %d, L1J2 %d",
3256 
3257  // L1 trigger bit
3258  if( fBitEGA == 0 && fBitEJE == 0 )
3259  {
3260  // Init the trigger bit once, correct depending on AliESD(AOD)CaloTrigger header version
3261 
3262  // Simpler way to do it ...
3263 // if( fInputEvent->GetRunNumber() < 172000 )
3264 // reader->SetEventTriggerL1Bit(4,5); // current LHC11 data
3265 // else
3266 // reader->SetEventTriggerL1Bit(6,8); // LHC12-13 data
3267 
3268  // Old values
3269  fBitEGA = 4;
3270  fBitEJE = 5;
3271 
3272  TFile* file = AliAnalysisManager::GetAnalysisManager()->GetTree()->GetCurrentFile();
3273 
3274  const TList *clist = file->GetStreamerInfoCache();
3275 
3276  if(clist)
3277  {
3278  TStreamerInfo *cinfo = (TStreamerInfo*)clist->FindObject("AliESDCaloTrigger");
3279  Int_t verid = 5; // newer ESD header version
3280  if(!cinfo)
3281  {
3282  cinfo = (TStreamerInfo*)clist->FindObject("AliAODCaloTrigger");
3283  verid = 3; // newer AOD header version
3284  }
3285 
3286  if(cinfo)
3287  {
3288  Int_t classversionid = cinfo->GetClassVersion();
3289  //printf("********* Header class version %d *********** \n",classversionid);
3290 
3291  if (classversionid >= verid)
3292  {
3293  fBitEGA = 6;
3294  fBitEJE = 8;
3295  }
3296  } else AliInfo("AliCaloTrackReader()::SetEventTriggerBit() - Streamer info for trigger class not available, bit not changed");
3297  } else AliInfo("AliCaloTrackReader::SetEventTriggerBit() - Streamer list not available!, bit not changed");
3298 
3299  } // set once the EJE, EGA trigger bit
3300 }
3301 
3302 //____________________________________________________________
3305 //____________________________________________________________
3306 void AliCaloTrackReader::SetInputEvent(AliVEvent* const input)
3307 {
3308  fInputEvent = input;
3309  fMixedEvent = dynamic_cast<AliMixedEvent*>(GetInputEvent()) ;
3310  if (fMixedEvent)
3311  fNMixedEvent = fMixedEvent->GetNumberOfEvents() ;
3312 
3313  //Delete previous vertex
3314  if(fVertex)
3315  {
3316  for (Int_t i = 0; i < fNMixedEvent; i++)
3317  {
3318  delete [] fVertex[i] ;
3319  }
3320  delete [] fVertex ;
3321  }
3322 
3323  fVertex = new Double_t*[fNMixedEvent] ;
3324  for (Int_t i = 0; i < fNMixedEvent; i++)
3325  {
3326  fVertex[i] = new Double_t[3] ;
3327  fVertex[i][0] = 0.0 ;
3328  fVertex[i][1] = 0.0 ;
3329  fVertex[i][2] = 0.0 ;
3330  }
3331 }
3332 
3333 
Bool_t IsPileUpFromSPD() const
Double_t fEventWeight
Weight assigned to the event when filling histograms.
Bool_t fUseTrackDCACut
Do DCA selection.
TArrayI GetTriggerPatches(Int_t tmin, Int_t tmax)
virtual void FillInputVZERO()
Int_t fV0ADC[2]
Integrated V0 signal.
Bool_t fComparePtHardAndClusterPt
In MonteCarlo, jet events, reject events with too large cluster energy.
AliAnaWeights * fWeightUtils
Pointer to AliAnaWeights.
AliCalorimeterUtils * GetCaloUtils() const
Float_t fTimeStampEventFracMin
Minimum value of time stamp fraction event.
Bool_t fReadAODMCParticles
Access kine information from filtered AOD MC particles.
double Double_t
Definition: External.C:58
virtual void FillInputNonStandardJets()
Double_t fEMCALTimeCutMax
Remove clusters/cells with time larger than this value, in ns.
Int_t fBitEJE
Trigger bit on VCaloTrigger for EJE.
TLorentzVector fMomentum
! Temporal TLorentzVector container, avoid declaration of TLorentzVectors per event.
Double_t fTimeStampRunMin
Minimum value of time stamp in run.
Bool_t fDoPileUpEventRejection
Select pile-up events by SPD.
void SetCentrality(Float_t cen)
Definition: AliAnaWeights.h:51
Bool_t fAcceptOnlyHIJINGLabels
Select clusters or tracks that where generated by HIJING, reject other generators in case of cocktail...
TObjArray * fPHOSClusters
Temporal array with PHOS CaloClusters.
Double_t fTrackDCACut[3]
Remove tracks with DCA larger than cut, parameters of function stored here.
Bool_t fUseEventsWithPrimaryVertex
Select events with primary vertex.
virtual AliVCaloCells * GetPHOSCells() const
Bool_t fIsBadCellEvent
Bad cell triggered event flag, any cell in cluster is bad.
Bool_t IsCorrectionOfClusterEnergyOn() const
Bool_t fEventTrigEMCALL1Gamma1
Event is L1-Gamma, threshold 1 on its name, it should correspond kEMCEGA.
virtual AliHeader * GetHeader() const
Bool_t IsEventEMCALL1Jet1() const
Bool_t IsEventEMCALL1Gamma1() const
AliEMCALRecoUtils * GetEMCALRecoUtils() const
Bool_t ReadAODMCParticles() const
Int_t fSmearNLMMin
Do smearing for clusters with at least this value.
TString fEventPlaneMethod
Name of event plane method, by default "Q".
Int_t fTrackBCEventCut[19]
Fill one entry per event if there is a track in a given BC, depend on track pT, acceptance cut...
Bool_t fDoVertexBCEventSelection
Select events with vertex on BC=0 or -100.
AliMixedEvent * fMixedEvent
! Mixed event object. This class is not the owner.
virtual AliVEvent * GetInputEvent() const
Bool_t IsPileUpFromSPDAndNotEMCal() const
Check if event is from pile-up determined by SPD and not by EMCal.
Bool_t IsEventEMCALL1() const
Float_t fPtHardAndClusterPtFactor
Factor between ptHard and cluster pT to reject/accept event.
Bool_t fAcceptFastCluster
Accept events from fast cluster, exclude these events for LHC11a.
Bool_t fSmearShowerShape
Smear shower shape (use in MC).
AliVEvent * fInputEvent
! pointer to esd or aod input.
Calculate the weight to the event to be applied when filling histograms.
Definition: AliAnaWeights.h:32
virtual void SetInputEvent(AliVEvent *input)
Double_t fTrackTimeCutMax
Remove tracks with time larger than this value, in ns.
Int_t fTriggerClusterBC
Event triggered by a cluster in BC -5 0 to 5.
virtual AliMultSelection * GetMultSelCen() const
TString fEMCALClustersListName
Alternative list of clusters produced elsewhere and not from InputEvent.
void RecalculateClusterTrackMatching(AliVEvent *event, TObjArray *clusterArray=0x0)
Float_t fPHOSBadChMinDist
Minimal distance to bad channel to accept cluster in PHOS, cm.
Bool_t fWriteOutputDeltaAOD
Write the created delta AOD objects into file.
Int_t fV0Mul[2]
Integrated V0 Multiplicity.
void RecalculateClusterDistanceToBadChannel(AliVCaloCells *cells, AliVCluster *clu)
Float_t fEMCALPtMin
pT Threshold on emcal clusters.
Bool_t fTriggerClusterTimeRecal
In case cluster already calibrated, do not try to recalibrate even if recalib on in AliEMCALRecoUtils...
Double_t ** fVertex
! Vertex array 3 dim for each mixed event buffer.
TH1F * fhCTSTrackCutsPt[6]
! Control histogram on the different CTS tracks selection cuts, pT
Int_t GetDebug() const
Definition: AliAnaWeights.h:91
UInt_t fEventTriggerMask
Select this triggerered event.
virtual Int_t GetEventCentrality() const
virtual Bool_t IsHIJINGLabel(Int_t label)
virtual AliGenEventHeader * GetGenEventHeader() const
virtual AliCentrality * GetCentrality() const
AliVCaloCells * fPHOSCells
! Temporal array with PHOS AliVCaloCells.
TList * fOutputContainer
! Output container with cut control histograms.
Bool_t IsEventEMCALL1Gamma2() const
virtual AliMixedEvent * GetMixedEvent() const
Int_t fEnergyHistogramNbins
Binning of the control histograms, min and max window.
Bool_t fFillInputBackgroundJetBranch
Flag to use data from background jets.
void SetTrackEventBC(Int_t bc)
virtual Bool_t ComparePtHardAndClusterPt()
TList * fAODBranchList
List with AOD branches created and needed in analysis.
void RemapMCLabelForAODs(Int_t &label)
Bool_t fEventTrigSemiCentral
Event is AliVEvent::kSemiCentral on its name, it should correspond to PbPb.
TRandom3 fRandom
! Random generator.
Bool_t AcceptDCA(Float_t pt, Float_t dca)
Bool_t IsPileUpFromNotSPDAndNotEMCal() const
Check if event not from pile-up determined neither by SPD nor by EMCal.
Bool_t fFillCTS
Use data from CTS.
virtual void InitParameters()
Initialize the parameters with default.
virtual void GetVertex(Double_t v[3]) const
Bool_t IsRecalibrationOn() const
virtual Bool_t FillInputEvent(Int_t iEntry, const char *currentFileName)
Float_t fPHOSPtMin
pT Threshold on phos clusters.
Bool_t fSelectEmbeddedClusters
Use only simulated clusters that come from embedding.
Bool_t fEventTrigMinBias
Event is min bias on its name, it should correspond to AliVEvent::kMB, AliVEvent::kAnyInt.
Float_t fEMCALParamTimeCutMin[4]
Remove clusters/cells with time smaller than parametrized value, in ns.
Int_t fEventNumber
Event number.
void RecalculateClusterPID(AliVCluster *clu)
TString fTaskName
Name of task that executes the analysis.
Bool_t fRemoveBadTriggerEvents
Remove triggered events because trigger was exotic, bad, or out of BC.
Bool_t IsPileUpFromSPDOrEMCal() const
Check if event is from pile-up determined by SPD or EMCal.
Bool_t IsPileUpFromEMCalAndNotSPD() const
Check if event is from pile-up determined by EMCal, not by SPD.
Bool_t fEventTrigEMCALL1Gamma2
Event is L1-Gamma, threshold 2 on its name, it should correspond kEMCEGA.
Bool_t fEventTrigEMCALL1Jet1
Event is L1-Gamma, threshold 1 on its name, it should correspond kEMCEGA.
Bool_t fFillEMCALCells
Use data from EMCAL.
Float_t fEnergyHistogramLimit[2]
Binning of the control histograms, number of bins.
Int_t fTriggerClusterId
Id of trigger cluster (cluster->GetID()).
Int_t fPHOSNCellsCut
Accept for the analysis PHOS clusters with more than fNCellsCut cells.
Float_t fCTSPtMax
pT Threshold on charged particles.
Double_t fEMCALParamTimeCutMax[4]
Remove clusters/cells with time larger than parametrized value, in ns.
virtual void FillInputEMCALCells()
Connects the array with EMCAL cells and the pointer.
Bool_t fFillPHOSCells
Use data from PHOS.
virtual AliVCaloCells * GetEMCALCells() const
Bool_t fRemoveLEDEvents
Remove events where LED was wrongly firing - EMCAL LHC11a.
AliEMCALGeometry * GetEMCALGeometry() const
Bool_t fIsBadMaxCellEvent
Bad cell triggered event flag, only max energy cell is bad.
int Int_t
Definition: External.C:63
void RecalculateClusterShowerShapeParameters(AliVCaloCells *cells, AliVCluster *clu)
Bool_t fSelectSPDHitTracks
Ensure that track hits SPD layers.
TString fFiredTriggerClassName
Name of trigger event type used to do the analysis.
virtual TClonesArray * GetAODMCParticles() const
Definition: External.C:204
TString GetFiredTriggerClasses() const
Bool_t ReadStack() const
unsigned int UInt_t
Definition: External.C:33
TObjArray * fEMCALClusters
Temporal array with EMCAL CaloClusters.
Bool_t IsEventEMCALL1Jet() const
Float_t fPHOSPtMax
pT Threshold on phos clusters.
Bool_t fAccessTrackTOF
Access the track TOF, in case of problems when accessing GetTOFBunchCrossing.
float Float_t
Definition: External.C:68
virtual Bool_t CheckForPrimaryVertex() const
Int_t fEMCalBCEvent[19]
Fill one entry per event if there is a cluster in a given BC.
TString fInputBackgroundJetBranchName
Name of background jet branch.
virtual AliEventplane * GetEventPlane() const
Bool_t fEventTriggerAtSE
Select triggered event at SE base task or here.
Float_t fEMCALPtMax
pT Threshold on emcal clusters.
Int_t fEventType
Set the event species: 7 physics, 0 MC, 8 LED (not useful now)
virtual Bool_t ComparePtHardAndJetPt()
Bool_t IsInFiducialCut(Float_t eta, Float_t phi, Int_t det) const
Bool_t fEventTrigCentral
Event is AliVEvent::kCentral on its name, it should correspond to PbPb.
virtual TObjString * GetListOfParameters()
Save parameters used for analysis in a string.
Float_t fTrackMultEtaCut
Track multiplicity eta cut.
Int_t fCentralityBin[2]
Minimum and maximum value of the centrality for the analysis.
virtual void FillInputPHOSCells()
Connects the array with PHOS cells and the pointer.
Base class for event, clusters and tracks filtering and preparation for the analysis.
TObjArray * fDCALClusters
Temporal array with DCAL CaloClusters, not needed in the normal case, use just EMCal array with DCal ...
Bool_t fUseTrackTimeCut
Do time cut selection.
virtual TString GetEventPlaneMethod() const
virtual Int_t GetTrackID(AliVTrack *track)
TArrayI fAcceptEventsWithBit
Accept events if trigger bit is on.
unsigned long ULong_t
Definition: External.C:38
TH1F * fhEMCALClusterCutsE[8]
! Control histogram on the different EMCal cluster selection cuts, E
virtual void Print(const Option_t *opt) const
Print some relevant parameters set for the analysis.
void MatchTriggerCluster(TArrayI patches)
Bool_t fTimeStampEventSelect
Select events within a fraction of data taking time.
Double_t fTimeStampRunMax
Maximum value of time stamp in run.
Double_t fEMCALTimeCutMin
Remove clusters/cells with time smaller than this value, in ns.
Bool_t fEventTrigEMCALL1Jet2
Event is L1-Gamma, threshold 2 on its name, it should correspond kEMCEGA.
void SetEMCalEventBCcut(Int_t bc)
Int_t fNPileUpClustersCut
Cut to select event as pile-up.
Bool_t fCheckFidCut
Do analysis for clusters in defined region.
virtual ~AliCaloTrackReader()
Destructor.
Bool_t fEventTrigEMCALL0
Event is EMCal L0 on its name, it should correspond to AliVEvent::kEMC7, AliVEvent::kEMC1.
Int_t GetNumberOfLocalMaxima(AliVCluster *cluster, AliVCaloCells *cells)
Find the number of local maxima in cluster.
Bool_t IsWeightSettingOn() const
Definition: AliAnaWeights.h:89
Int_t fTrackBCEvent[19]
Fill one entry per event if there is a track in a given BC.
virtual void FillInputEMCALAlgorithm(AliVCluster *clus, Int_t iclus)
Bool_t fComparePtHardAndJetPt
In MonteCarlo, jet events, reject fake events with wrong jet energy.
Int_t fNNonPileUpClusters
Number of clusters with time below 20 ns.
Int_t fNMixedEvent
Number of events in mixed event buffer.
Bool_t Data(TH1F *h, Double_t *rangefit, Bool_t writefit, Double_t &sgn, Double_t &errsgn, Double_t &bkg, Double_t &errbkg, Double_t &sgnf, Double_t &errsgnf, Double_t &sigmafit, Int_t &status)
Int_t fCentralityOpt
Option for the returned value of the centrality, possible options 5, 10, 100.
Float_t fZvtxCut
Cut on vertex position.
energy
void RecalculateClusterPosition(AliVCaloCells *cells, AliVCluster *clu)
AliCaloTrackReader()
Constructor. Initialize parameters.
Bool_t fTriggerPatchClusterMatch
Search for the trigger patch and check if associated cluster was the trigger.
Bool_t fUseParamTimeCut
Use simple or parametrized time cut.
Int_t GetNMaskCellColumns() const
AliFiducialCut * fFiducialCut
Acceptance cuts.
Bool_t fRejectEMCalTriggerEventsWith2Tresholds
Reject events EG2 also triggered by EG1 or EJ2 also triggered by EJ1.
TH1F * fhPHOSClusterCutsE[7]
! Control histogram on the different PHOS cluster selection cuts, E
virtual void FillInputEMCAL()
Bool_t fFillEMCAL
Use data from EMCAL.
Bool_t fFillPHOS
Use data from PHOS.
AliVCaloCells * fEMCALCells
! Temporal array with EMCAL AliVCaloCells.
virtual AliAODMCHeader * GetAODMCHeader() const
Int_t fEMCALNCellsCut
Accept for the analysis EMCAL clusters with more than fNCellsCut cells.
void CorrectClusterEnergy(AliVCluster *cl)
Correct cluster energy non linearity.
Float_t fCTSPtMin
pT Threshold on charged particles.
virtual AliStack * GetStack() const
Int_t fSmearNLMMax
Do smearing for clusters with at maximum this value.
Float_t fTriggerL0EventThreshold
L0 Threshold to look for triggered events, set outside.
Float_t fTimeStampEventFracMax
Maximum value of time stamp fraction event.
virtual void ResetLists()
Reset lists, called in AliAnaCaloTrackCorrMaker.
Int_t fNPileUpClusters
Number of clusters with time avobe 20 ns.
Int_t fTrackMult
Track multiplicity.
AliAODEvent * fOutputEvent
! pointer to aod output.
ClassImp(AliAnalysisTaskCRC) AliAnalysisTaskCRC
Bool_t fRecalculateClusters
Correct clusters, recalculate them if recalibration parameters is given.
Bool_t fDoRejectNoTrackEvents
Reject events with no selected tracks in event.
Bool_t IsEventEMCALL1Jet2() const
Float_t fEMCALBadChMinDist
Minimal distance to bad channel to accept cluster in EMCal, cell units.
Bool_t fReadStack
Access kine information from stack.
Bool_t fIsTriggerMatchOpenCut[3]
Could not match the event to a trigger patch?, retry opening cuts.
UInt_t fMixEventTriggerMask
Select this triggerered event for mixing, tipically kMB or kAnyINT.
Float_t RadToDeg(Float_t rad) const
TFile * file
virtual void FillVertexArray()
Bool_t IsInTimeWindow(Double_t tof, Float_t energy) const
Bool_t fRemoveUnMatchedTriggers
Analyze events where trigger patch and cluster where found or not.
virtual Double_t GetEventPlaneAngle() const
void SetPythiaEventHeader(AliGenPythiaEventHeader *py)
Definition: AliAnaWeights.h:79
TObjArray * fCTSTracks
Temporal array with tracks.
Int_t fTriggerPatchTimeWindow[2]
Trigger patch selection window.
unsigned short UShort_t
Definition: External.C:28
AliMCEvent * fMC
! Monte Carlo Event Handler.
TH1I * fhNEventsAfterCut
! Each bin represents number of events resulting after a given selection cut: vertex, trigger, ...
Float_t fPtHardAndJetPtFactor
Factor between ptHard and jet pT to reject/accept event.
const char Option_t
Definition: External.C:48
TString fDeltaAODFileName
Delta AOD file name.
Int_t GetVertexBC() const
Bool_t IsPileUpFromEMCal() const
Check if event is from pile-up determined by EMCal.
virtual Double_t GetWeight()
Bool_t fFillInputNonStandardJetBranch
Flag to use data from non standard jets.
TClonesArray * fNonStandardJets
! Temporal array with jets.
Int_t fEMCalBCEventCut[19]
Fill one entry per event if there is a cluster in a given BC, depend on cluster E, acceptance cut.
Int_t fTriggerClusterIndex
Index in clusters array of trigger cluster.
Bool_t fTriggerL1EventThresholdFix
L1 Threshold is fix and set outside.
bool Bool_t
Definition: External.C:53
Float_t fSmearShowerShapeWidth
Smear shower shape landau function "width" (use in MC).
Int_t fBitEGA
Trigger bit on VCaloTrigger for EGA.
virtual void FillInputBackgroundJets()
Bool_t fDoV0ANDEventSelection
Select events depending on V0AND.
AliAODJetEventBackground * fBackgroundJets
! Background jets.
Bool_t fCorrectELinearity
Correct cluster linearity, always on.
virtual TList * GetCreateControlHistograms()
Int_t fVertexBC
Vertex BC.
Bool_t fIsExoticEvent
Exotic trigger event flag.
TString fInputNonStandardJetBranchName
Name of non standard jet branch.
TArrayI fRejectEventsWithBit
Reject events if trigger bit is on.
Bool_t fUseEMCALTimeCut
Do time cut selection.
Float_t GetPhi(Float_t phi) const
Shift phi angle in case of negative value 360 degrees. Example TLorenzVector::Phi defined in -pi to p...
Int_t fNMCProducedMax
In case of cocktail, select particles in the list with label up to this value.
Int_t fDataType
Select MC: Kinematics, Data: ESD/AOD, MCData: Both.
virtual Bool_t SelectTrack(AliVTrack *, Double_t *)
Int_t GetMaxEnergyCell(AliVCaloCells *cells, AliVCluster *clu, Float_t &fraction) const
For a given CaloCluster, it gets the absId of the cell with maximum energy deposit.
Bool_t fFillDCAL
Use data from DCAL, not needed in the normal case, use just EMCal array with DCal limits...
void SetTrackEventBCcut(Int_t bc)
Bool_t fIsTriggerMatch
Could match the event to a trigger patch?
Float_t fTriggerL1EventThreshold
L1 Threshold to look for triggered events, set in data.
TString fCentralityClass
Name of selected centrality class.
ULong_t fTrackStatus
Track selection bit, select tracks refitted in TPC, ITS ...
Bool_t IsPileUpFromSPDAndEMCal() const
Check if event is from pile-up determined by SPD and EMCal.
virtual void FillInputPHOS()
Fill the array with PHOS filtered clusters.
Int_t fNMCProducedMin
In case of cocktail, select particles in the list with label from this value.
virtual TObjArray * GetCTSTracks() const
Bool_t fUseAliCentrality
Select as centrality estimator AliCentrality (Run1) or AliMultSelection (Run1 and Run2) ...
Int_t fSmearingFunction
Choice of smearing function. 0 no smearing. 1 smearing from Gustavo (Landau center at 0)...
Bool_t fRecalculateVertexBC
Recalculate vertex BC from tracks pointing to vertex.
Float_t RecalibrateClusterEnergy(AliVCluster *cluster, AliVCaloCells *cells)
Recalibrate the cluster energy, considering the recalibration map and the energy of the cells that co...
void SetEMCalEventBC(Int_t bc)
Bool_t reject
Bool_t CheckCellFiducialRegion(AliVCluster *cluster, AliVCaloCells *cells) const
Bool_t IsEventEMCALL0() const