AliPhysics  95775ff (95775ff)
 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 fFillInputNonStandardJetBranch(kFALSE),
132 fNonStandardJets(new TClonesArray("AliAODJet",100)), fInputNonStandardJetBranchName("jets"),
133 fFillInputBackgroundJetBranch(kFALSE),
134 fBackgroundJets(0x0),fInputBackgroundJetBranchName("jets"),
135 fAcceptEventsWithBit(0), fRejectEventsWithBit(0), fRejectEMCalTriggerEventsWith2Tresholds(0),
136 fMomentum(), fOutputContainer(0x0), fEnergyHistogramNbins(0),
137 fhNEventsAfterCut(0), fNMCGenerToAccept(0), fMCGenerEventHeaderToAccept("")
138 {
139  for(Int_t i = 0; i < 8; i++) fhEMCALClusterCutsE [i]= 0x0 ;
140  for(Int_t i = 0; i < 7; i++) fhPHOSClusterCutsE [i]= 0x0 ;
141  for(Int_t i = 0; i < 6; i++) fhCTSTrackCutsPt [i]= 0x0 ;
142  for(Int_t j = 0; j < 5; j++) { fMCGenerToAccept [j] = ""; fMCGenerIndexToAccept[j] = -1; }
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 //_____________________________________________________
276 //_____________________________________________________
278 {
279  if( !fMC || fNMCGenerToAccept <= 0 ) return kTRUE;
280 
281  TString genName;
282  Int_t genIndex;
283  genIndex = GetCocktailGeneratorAndIndex(mcLabel, genName);
284  //fMC->GetCocktailGenerator(mcLabel,genName);
285 
286  Bool_t generOK = kFALSE;
287  for(Int_t ig = 0; ig < fNMCGenerToAccept; ig++)
288  {
289  if ( fMCGenerToAccept[ig].Contains(genName) ) generOK = kTRUE;
290 
291  if ( generOK && fMCGenerIndexToAccept[ig] >= 0 && fMCGenerToAccept[ig] != genIndex) generOK = kFALSE;
292  }
293 
294  if ( !generOK ) AliDebug(1, Form("skip label %d, gen %s",mcLabel,genName.Data()) );
295 
296  return generOK;
297 }
298 
299 //_____________________________________________________________________
307 //_____________________________________________________________________
309 {
310  //method that gives the generator for a given particle with label index (or that of the corresponding primary)
311  AliVParticle* mcpart0 = (AliVParticle*) GetMC()->GetTrack(index);
312  Int_t genIndex = -1;
313 
314  if(!mcpart0)
315  {
316  printf("AliMCEvent-BREAK: No valid AliMCParticle at label %i\n",index);
317  return -1;
318  }
319 
320  nameGen = GetGeneratorNameAndIndex(index,genIndex);
321 
322  if(nameGen.Contains("nococktailheader") ) return -1;
323 
324  Int_t lab=index;
325 
326  while(nameGen.IsWhitespace())
327  {
328  AliVParticle* mcpart = (AliVParticle*) GetMC()->GetTrack(lab);
329 
330  if(!mcpart)
331  {
332  printf("AliMCEvent-BREAK: No valid AliMCParticle at label %i\n",lab);
333  break;
334  }
335 
336  Int_t mother=0;
337  mother = mcpart->GetMother();
338 
339  if(mother<0)
340  {
341  printf("AliMCEvent - BREAK: Reached primary particle without valid mother\n");
342  break;
343  }
344 
345  AliVParticle* mcmom = (AliVParticle*) GetMC()->GetTrack(mother);
346  if(!mcmom)
347  {
348  printf("AliMCEvent-BREAK: No valid AliMCParticle mother at label %i\n",mother);
349  break;
350  }
351 
352  lab=mother;
353 
354  nameGen = GetGeneratorNameAndIndex(mother,genIndex);
355  }
356 
357  return genIndex;
358 }
359 //_____________________________________________________________________
367 //_____________________________________________________________________
369 {
370  Int_t nsumpart = GetMC()->GetNumberOfPrimaries();
371 
372  genIndex = -1;
373 
374  TList* lh = GetMC()->GetCocktailList();
375  if(!lh)
376  {
377  TString noheader="nococktailheader";
378  return noheader;
379  }
380 
381  Int_t nh = lh->GetEntries();
382 
383  for (Int_t i = nh-1; i >= 0; i--)
384  {
385  AliGenEventHeader* gh = (AliGenEventHeader*)lh->At(i);
386 
387  TString genname = gh->GetName();
388 
389  Int_t npart=gh->NProduced();
390 
391  if (i == 0) npart = nsumpart;
392 
393  if(index < nsumpart && index >= (nsumpart-npart))
394  {
395  genIndex = i ;
396  return genname;
397  }
398 
399  nsumpart-=npart;
400  }
401 
402  TString empty="";
403  return empty;
404 }
405 
406 
407 //_____________________________________________________
410 //_____________________________________________________
412 {
413  Int_t nReject = fRejectEventsWithBit.GetSize();
414 
415  //printf("N reject %d\n", nReject);
416 
417  if( nReject <= 0 )
418  return kTRUE ; // accept the event
419 
420  UInt_t trigFired = ((AliInputEventHandler*)(AliAnalysisManager::GetAnalysisManager()->GetInputEventHandler()))->IsEventSelected();
421 
422  for(Int_t ibit = 0; ibit < nReject; ibit++)
423  {
424  Bool_t reject = (trigFired & fRejectEventsWithBit.At(ibit));
425 
426  //printf("reject %d, ibit %d, bit %d \n",reject, ibit,fRejectEventsWithBit.At(ibit));
427  if(reject) return kFALSE ; // reject the event
428  }
429 
430  return kTRUE ; // accept the event
431 }
432 
433 //_____________________________________________
437 //_____________________________________________
439 {
440  //-----------------------------------------------------------
441  // Reject events depending on the trigger name
442  //-----------------------------------------------------------
443 
444  AliDebug(1,Form("FiredTriggerClass <%s>, selected class <%s>, compare name %d",
447 
448  if ( fFiredTriggerClassName != "" )
449  {
451  return kFALSE;
452  else
453  AliDebug(1,"Accepted triggered event");
454  }
455 
456  fhNEventsAfterCut->Fill(1.5);
457 
458  //-----------------------------------------------------------
459  // Reject events depending on the event species type
460  //-----------------------------------------------------------
461 
462  // Event types:
463  // kStartOfRun = 1, // START_OF_RUN
464  // kEndOfRun = 2, // END_OF_RUN
465  // kStartOfRunFiles = 3, // START_OF_RUN_FILES
466  // kEndOfRunFiles = 4, // END_OF_RUN_FILES
467  // kStartOfBurst = 5, // START_OF_BURST
468  // kEndOfBurst = 6, // END_OF_BURST
469  // kPhysicsEvent = 7, // PHYSICS_EVENT
470  // kCalibrationEvent = 8, // CALIBRATION_EVENT
471  // kFormatError = 9, // EVENT_FORMAT_ERROR
472  // kStartOfData = 10, // START_OF_DATA
473  // kEndOfData = 11, // END_OF_DATA
474  // kSystemSoftwareTriggerEvent = 12, // SYSTEM_SOFTWARE_TRIGGER_EVENT
475  // kDetectorSoftwareTriggerEvent = 13 // DETECTOR_SOFTWARE_TRIGGER_EVENT
476 
477  Int_t eventType = 0;
478  if(fInputEvent->GetHeader())
479  eventType = ((AliVHeader*)fInputEvent->GetHeader())->GetEventType();
480 
481  AliDebug(3,Form("Event type %d",eventType));
482 
483  // Select only Physics events in data, eventType = 7,
484  // usually done by physics selection
485  // MC not set, eventType =0, I think, so do not apply a value to fEventType by default
486  // LED events have eventType = 8, implemented a selection cut in the past
487  // but not really useful for EMCal data since LED are not reconstructed (unless wrongly assumed as physics)
488 
489  if ( fEventType >= 0 && eventType != fEventType ) return kFALSE ;
490 
491  AliDebug(1,"Pass event species selection");
492 
493  fhNEventsAfterCut->Fill(2.5);
494 
495  //-----------------------------------------------------------------
496  // In case of mixing analysis, select here the trigger of the event
497  //-----------------------------------------------------------------
498 
499  UInt_t isTrigger = kFALSE;
500  UInt_t isMB = kFALSE;
501 
502  if(!fEventTriggerAtSE)
503  {
504  // In case of mixing analysis, accept MB events, not only Trigger
505  // Track and cluster arrays filled for MB in order to create the pool in the corresponding analysis
506  // via de method in the base class FillMixedEventPool()
507 
508  AliAnalysisManager *manager = AliAnalysisManager::GetAnalysisManager();
509  AliInputEventHandler *inputHandler = dynamic_cast<AliInputEventHandler*>(manager->GetInputEventHandler());
510 
511  if(!inputHandler) return kFALSE ; // to content coverity
512 
513  isTrigger = inputHandler->IsEventSelected() & fEventTriggerMask;
514  isMB = inputHandler->IsEventSelected() & fMixEventTriggerMask;
515 
516  if(!isTrigger && !isMB) return kFALSE;
517 
518  //printf("Selected triggered event : %s\n",GetFiredTriggerClasses().Data());
519  AliDebug(0,"Pass uninteresting triggered events rejection in case of mixing analysis");
520 
521  fhNEventsAfterCut->Fill(3.5);
522  }
523 
524 
525  //-------------------------------------------------------------------------------------
526  // Reject or accept events depending on the trigger bit
527  //-------------------------------------------------------------------------------------
528 
531 
532  //printf("AliCaloTrackReader::FillInputEvent() - Accept event? %d, Reject event %d? \n",okA,okR);
533 
534  if(!okA || !okR) return kFALSE;
535 
536  AliDebug(1,"Pass event bit rejection");
537 
538  fhNEventsAfterCut->Fill(4.5);
539 
540  //----------------------------------------------------------------------
541  // Do not count events that were likely triggered by an exotic cluster
542  // or out BC cluster
543  //----------------------------------------------------------------------
544 
545  // Set a bit with the event kind, MB, L0, L1 ...
547 
548  // In case of Mixing, avoid checking the triggers in the min bias events
549  if(!fEventTriggerAtSE && (isMB && !isTrigger)) return kTRUE;
550 
552  {
554  {
555  // Reject triggered events when there is coincidence on both EMCal trigger thresholds,
556  // but the requested trigger is the low trigger threshold
557  if(IsEventEMCALL1Jet1 () && IsEventEMCALL1Jet2 () && fFiredTriggerClassName.Contains("EJ2")) return kFALSE;
558  if(IsEventEMCALL1Gamma1() && IsEventEMCALL1Gamma2() && fFiredTriggerClassName.Contains("EG2")) return kFALSE;
559  }
560 
561  //Get Patches that triggered
563 
564  MatchTriggerCluster(patches);
565 
566  patches.Reset();
567 
568  // If requested, remove badly triggeed events, but only when the EMCal trigger bit is set
570  {
571  AliDebug(1,Form("ACCEPT triggered event? \n exotic? %d - bad cell %d - bad Max cell %d - BC %d - Matched %d\n",
573  if (fIsExoticEvent) return kFALSE;
574  else if(fIsBadCellEvent) return kFALSE;
575  else if(fRemoveUnMatchedTriggers && !fIsTriggerMatch) return kFALSE ;
576  else if(fTriggerClusterBC != 0) return kFALSE;
577  AliDebug(1,Form("\t *** YES for %s",GetFiredTriggerClasses().Data()));
578  }
579 
580  AliDebug(1,"Pass EMCal triggered event rejection \n");
581 
582  fhNEventsAfterCut->Fill(5.5);
583  }
584 
585  //-------------------------------------------------------------------------------------
586  // Select events only fired by a certain trigger configuration if it is provided
587  //-------------------------------------------------------------------------------------
588 
589  if (GetFiredTriggerClasses().Contains("FAST") && !GetFiredTriggerClasses().Contains("ALL") && !fAcceptFastCluster)
590  {
591  AliDebug(1,Form("Do not count events from fast cluster, trigger name %s\n",fFiredTriggerClassName.Data()));
592  return kFALSE;
593 
594  fhNEventsAfterCut->Fill(6.5);
595  }
596 
597  //-------------------------------------------------------------------------------------
598  // Reject event if large clusters with large energy
599  // Use only for LHC11a data for the moment, and if input is clusterizer V1 or V1+unfolding
600  // If clusterzer NxN or V2 it does not help
601  //-------------------------------------------------------------------------------------
602 
603  //Int_t run = fInputEvent->GetRunNumber();
604 
605  if ( fRemoveLEDEvents )
606  {
608 
609  if(reject) return kFALSE;
610 
611  AliDebug(1,"Pass LED event rejection");
612 
613  fhNEventsAfterCut->Fill(7.5);
614  } // Remove LED events
615 
616  // All selection criteria passed, accept the event
617  return kTRUE ;
618 }
619 
620 //________________________________________________
625 //________________________________________________
627 {
628  //printf("AliCaloTrackReader::ComparePtHardAndJetPt() - GenHeaderName : %s\n",GetGenEventHeader()->ClassName());
629 
630  if(!strcmp(GetGenEventHeader()->ClassName(), "AliGenPythiaEventHeader"))
631  {
632  TParticle * jet = 0;
633  AliGenPythiaEventHeader* pygeh= (AliGenPythiaEventHeader*) GetGenEventHeader();
634  Int_t nTriggerJets = pygeh->NTriggerJets();
635  Float_t ptHard = pygeh->GetPtHard();
636 
637  AliDebug(1,Form("Njets: %d, pT Hard %f",nTriggerJets, ptHard));
638 
639  Float_t tmpjet[]={0,0,0,0};
640  for(Int_t ijet = 0; ijet< nTriggerJets; ijet++)
641  {
642  pygeh->TriggerJet(ijet, tmpjet);
643  jet = new TParticle(94, 21, -1, -1, -1, -1, tmpjet[0],tmpjet[1],tmpjet[2],tmpjet[3], 0,0,0,0);
644 
645  AliDebug(1,Form("jet %d; pycell jet pT %f",ijet, jet->Pt()));
646 
647  //Compare jet pT and pt Hard
648  if(jet->Pt() > fPtHardAndJetPtFactor * ptHard)
649  {
650  AliInfo(Form("Reject jet event with : pT Hard %2.2f, pycell jet pT %2.2f, rejection factor %1.1f\n",
651  ptHard, jet->Pt(), fPtHardAndJetPtFactor));
652  return kFALSE;
653  }
654  }
655 
656  if(jet) delete jet;
657  }
658 
659  return kTRUE ;
660 }
661 
662 //____________________________________________________
667 //____________________________________________________
669 {
670  if(!strcmp(GetGenEventHeader()->ClassName(), "AliGenPythiaEventHeader"))
671  {
672  AliGenPythiaEventHeader* pygeh= (AliGenPythiaEventHeader*) GetGenEventHeader();
673  Float_t ptHard = pygeh->GetPtHard();
674 
675  Int_t nclusters = fInputEvent->GetNumberOfCaloClusters();
676  for (Int_t iclus = 0; iclus < nclusters; iclus++)
677  {
678  AliVCluster * clus = fInputEvent->GetCaloCluster(iclus) ;
679  Float_t ecluster = clus->E();
680 
681  if(ecluster > fPtHardAndClusterPtFactor*ptHard)
682  {
683  AliInfo(Form("Reject : ecluster %2.2f, calo %d, factor %2.2f, ptHard %f",ecluster,clus->GetType(),fPtHardAndClusterPtFactor,ptHard));
684 
685  return kFALSE;
686  }
687  }
688 
689  }
690 
691  return kTRUE ;
692 }
693 
694 //___________________________________________________
697 //___________________________________________________
699 {
700 
701  fhNEventsAfterCut = new TH1I("hNEventsAfterCut", "Number of analyzed events", 19, 0, 19) ;
702  //fhNEventsAfterCut->SetXTitle("Selection");
703  fhNEventsAfterCut->SetYTitle("# events");
704  fhNEventsAfterCut->GetXaxis()->SetBinLabel(1 ,"1=Input");
705  fhNEventsAfterCut->GetXaxis()->SetBinLabel(2 ,"2=Trigger string");
706  fhNEventsAfterCut->GetXaxis()->SetBinLabel(3 ,"3=Event Type");
707  fhNEventsAfterCut->GetXaxis()->SetBinLabel(4 ,"4=Mixing Event");
708  fhNEventsAfterCut->GetXaxis()->SetBinLabel(5 ,"5=Trigger Bit");
709  fhNEventsAfterCut->GetXaxis()->SetBinLabel(6 ,"6=Good EMC Trigger");
710  fhNEventsAfterCut->GetXaxis()->SetBinLabel(7 ,"7=!Fast Cluster");
711  fhNEventsAfterCut->GetXaxis()->SetBinLabel(8 ,"8=!LED");
712  fhNEventsAfterCut->GetXaxis()->SetBinLabel(9 ,"9=Time stamp");
713  fhNEventsAfterCut->GetXaxis()->SetBinLabel(10,"10=Z vertex");
714  fhNEventsAfterCut->GetXaxis()->SetBinLabel(11,"11=Primary vertex");
715  fhNEventsAfterCut->GetXaxis()->SetBinLabel(12,"12=Pile-up");
716  fhNEventsAfterCut->GetXaxis()->SetBinLabel(13,"13=V0AND");
717  fhNEventsAfterCut->GetXaxis()->SetBinLabel(14,"14=Centrality");
718  fhNEventsAfterCut->GetXaxis()->SetBinLabel(15,"15=GenHeader");
719  fhNEventsAfterCut->GetXaxis()->SetBinLabel(16,"16=PtHard-Jet");
720  fhNEventsAfterCut->GetXaxis()->SetBinLabel(17,"17=PtHard-Cluster");
721  fhNEventsAfterCut->GetXaxis()->SetBinLabel(18,"18=Track multi.");
722  fhNEventsAfterCut->GetXaxis()->SetBinLabel(19,"19=TOF BC");
724 
725 
726  if(fFillEMCAL)
727  {
728  for(Int_t i = 0; i < 8; i++)
729  {
730  TString names[] = {"NoCut", "Corrected", "GoodCluster", "NonLinearity",
731  "EnergyAndFidutial", "Time", "NCells", "BadDist"};
732 
733  fhEMCALClusterCutsE[i] = new TH1F(Form("hEMCALReaderClusterCuts_%d_%s",i,names[i].Data()),
734  Form("EMCal %d, %s",i,names[i].Data()),
736  fhEMCALClusterCutsE[i]->SetYTitle("# clusters");
737  fhEMCALClusterCutsE[i]->SetXTitle("#it{E} (GeV)");
739  }
740  }
741 
742  if(fFillPHOS)
743  {
744  for(Int_t i = 0; i < 7; i++)
745  {
746  TString names[] = {"NoCut", "ExcludeCPV", "BorderCut", "FiducialCut", "EnergyCut", "NCells", "BadDist"};
747 
748  fhPHOSClusterCutsE[i] = new TH1F(Form("hPHOSReaderClusterCuts_%d_%s",i,names[i].Data()),
749  Form("PHOS Cut %d, %s",i,names[i].Data()),
751  fhPHOSClusterCutsE[i]->SetYTitle("# clusters");
752  fhPHOSClusterCutsE[i]->SetXTitle("#it{E} (GeV)");
754  }
755  }
756 
757  if(fFillCTS)
758  {
759  for(Int_t i = 0; i < 6; i++)
760  {
761  TString names[] = {"NoCut", "Status", "ESD_AOD", "TOF", "DCA","PtAcceptanceMult"};
762 
763  fhCTSTrackCutsPt[i] = new TH1F(Form("hCTSReaderClusterCuts_%d_%s",i,names[i].Data()),
764  Form("CTS Cut %d, %s",i,names[i].Data()),
766  fhCTSTrackCutsPt[i]->SetYTitle("# tracks");
767  fhCTSTrackCutsPt[i]->SetXTitle("#it{p}_{T} (GeV)");
769  }
770  }
771 
772  return fOutputContainer ;
773 }
774 
775 //_____________________________________________________
777 //_____________________________________________________
779 {
780  TString parList ; //this will be list of parameters used for this analysis.
781 
782  const Int_t buffersize = 255;
783  char onePar[buffersize] ;
784 
785  snprintf(onePar,buffersize,"--- Reader ---:") ;
786  parList+=onePar ;
787  snprintf(onePar,buffersize,"Data type: %d; zvertex cut %2.2f; EMC cluster name: <%s> ",fDataType, fZvtxCut, fEMCALClustersListName.Data()) ;
788  parList+=onePar ;
789  snprintf(onePar,buffersize,"Use detector: EMC %d, DCA %d, PHOS %d, CTS %d, EMCcells %d, PHOScells %d ; ",
791  snprintf(onePar,buffersize,"E-pT window: EMC (%2.1f,%2.1f), PHOS (%2.1f,%2.1f), CTS (%2.1f,%2.1f); ",
793  parList+=onePar ;
794  snprintf(onePar,buffersize,"Dist to bad channel: EMC > %2.1f, PHOS > %2.1f; ",fEMCALBadChMinDist,fPHOSBadChMinDist) ;
795  parList+=onePar ;
796  snprintf(onePar,buffersize,"N cells: EMC > %d, PHOS > %d; ",fEMCALNCellsCut,fPHOSNCellsCut) ;
797  parList+=onePar ;
798  snprintf(onePar,buffersize,"EMC time cut single window (%2.2f,%2.2f); ",fEMCALTimeCutMin,fEMCALTimeCutMax) ;
799  parList+=onePar ;
800  snprintf(onePar,buffersize,"Check: calo fid cut %d; ",fCheckFidCut) ;
801  parList+=onePar ;
802  snprintf(onePar,buffersize,"Track: status %d, multip. eta cut %1.1f, SPD hit %d; ",(Int_t) fTrackStatus, fTrackMultEtaCut, fSelectSPDHitTracks) ;
803  parList+=onePar ;
804 
805  if(fUseTrackDCACut)
806  {
807  snprintf(onePar,buffersize,"DCA cut ON, param (%2.4f,%2.4f,%2.4f); ",fTrackDCACut[0],fTrackDCACut[1],fTrackDCACut[2]) ;
808  parList+=onePar ;
809  }
810 
811  snprintf(onePar,buffersize,"Recalculate Clusters = %d, E linearity = %d; ",fRecalculateClusters, fCorrectELinearity) ;
812  parList+=onePar ;
813 
814  snprintf(onePar,buffersize,"SE trigger sel. %d, not? trigger Mask? %d, MB Trigger Mask for mixed %d; ",
816  parList+=onePar ;
817 
818  snprintf(onePar,buffersize,"Select fired trigger %s; Remove Bad trigger event %d, unmatched %d; Accept fastcluster %d, Reject LED %d ",
820  parList+=onePar ;
821 
823  {
824  snprintf(onePar,buffersize,"Accept only labels from: ");
825  parList+=onePar ;
826  for(Int_t i = 0; i< fNMCGenerToAccept; i++)
827  parList+=(fMCGenerToAccept[i]+" ") ;
828 
829  snprintf(onePar,buffersize,"; ");
830  parList+=onePar ;
831  }
832 
834  {
835  snprintf(onePar,buffersize,"EMC M02 smear ON, function %d, param %2.4f, %d<=NLM<=%d; ",
837  parList+=onePar ;
838  }
839 
841  {
842  snprintf(onePar,buffersize,"jet pt / pt hard < %2.1f; ",fPtHardAndJetPtFactor);
843  parList+=onePar ;
844  }
845 
847  {
848  snprintf(onePar,buffersize,"cluster pt / pt hard < %2.2f",fPtHardAndClusterPtFactor);
849  parList+=onePar ;
850  }
851 
852  snprintf(onePar,buffersize,"Centrality: Class %s, Option %d, Bin [%d,%d]; New centrality %d; Event plane method %s; ",
854  parList+=onePar ;
855 
856  return new TObjString(parList) ;
857 }
858 
859 
860 //____________________________________________
862 //____________________________________________
864 {
865  if(fMC)
866  return fMC->Stack();
867  else
868  {
869  AliDebug(1,"Stack is not available");
870  return 0x0 ;
871  }
872 }
873 
874 //______________________________________________
876 //______________________________________________
878 {
879  if(fMC)
880  {
881  return fMC->Header();
882  }
883  else
884  {
885  AliInfo("Header is not available");
886  return 0x0 ;
887  }
888 }
889 
890 //______________________________________________________________
892 //______________________________________________________________
893 AliGenEventHeader* AliCaloTrackReader::GetGenEventHeader() const
894 {
895  if (ReadStack() && fMC)
896  {
897  AliGenEventHeader * eventHeader = fMC->GenEventHeader();
898 
899  if(fMCGenerEventHeaderToAccept=="") return eventHeader ;
900 
901  AliGenCocktailEventHeader *cocktail = dynamic_cast<AliGenCocktailEventHeader *>(eventHeader);
902 
903  if(!cocktail) return 0x0 ;
904 
905  TList *genHeaders = cocktail->GetHeaders();
906 
907  Int_t nGenerators = genHeaders->GetEntries();
908 
909  for(Int_t igen = 0; igen < nGenerators; igen++)
910  {
911  AliGenEventHeader * eventHeader2 = (AliGenEventHeader*)genHeaders->At(igen) ;
912  TString name = eventHeader2->GetName();
913  //printf("ESD Event header %d %s\n",igen,name.Data());
914 
915  if(name.Contains(fMCGenerEventHeaderToAccept,TString::kIgnoreCase))
916  return eventHeader2 ;
917  }
918 
919  return 0x0;
920 
921  }
922  else if(ReadAODMCParticles() && GetAODMCHeader())
923  {
924  Int_t nGenerators = GetAODMCHeader()->GetNCocktailHeaders();
925 
926  if( nGenerators <= 0) return 0x0;
927 
928  if(fMCGenerEventHeaderToAccept=="") return GetAODMCHeader()->GetCocktailHeader(0);
929 
930  for(Int_t igen = 0; igen < nGenerators; igen++)
931  {
932  AliGenEventHeader * eventHeader = GetAODMCHeader()->GetCocktailHeader(igen) ;
933  TString name = eventHeader->GetName();
934  //printf("AOD Event header %d %s\n",igen,name.Data());
935 
936  if(name.Contains(fMCGenerEventHeaderToAccept,TString::kIgnoreCase))
937  return eventHeader ;
938  }
939 
940  return 0x0;
941 
942  }
943  else
944  {
945  return 0x0;
946  }
947 }
948 
949 //_________________________________________________________
952 //_________________________________________________________
954 {
955  AliInfo("Input are not AODs");
956 
957  return NULL ;
958 }
959 
960 //________________________________________________________
963 //________________________________________________________
964 AliAODMCHeader* AliCaloTrackReader::GetAODMCHeader() const
965 {
966  AliInfo("Input are not AODs");
967 
968  return NULL ;
969 }
970 
971 //___________________________________________________________
979 //___________________________________________________________
980 Int_t AliCaloTrackReader::GetVertexBC(const AliVVertex * vtx)
981 {
982  Int_t vertexBC=vtx->GetBC();
983 
984  if(!fRecalculateVertexBC) return vertexBC;
985 
986  // Value not available, recalculate it.
987 
988  Double_t bz = fInputEvent->GetMagneticField();
989  Bool_t bc0 = kFALSE;
990  Int_t ntr = GetCTSTracks()->GetEntriesFast();
991  //printf("N Tracks %d\n",ntr);
992 
993  for(Int_t i = 0 ; i < ntr ; i++)
994  {
995  AliVTrack * track = (AliVTrack*) (GetCTSTracks()->At(i));
996 
997  //Check if has TOF info, if not skip
998  ULong_t status = track->GetStatus();
999  Bool_t okTOF = (status & AliVTrack::kTOFout) == AliVTrack::kTOFout ;
1000  vertexBC = track->GetTOFBunchCrossing(bz);
1001  Float_t pt = track->Pt();
1002 
1003  if(!okTOF) continue;
1004 
1005  // Get DCA x, y
1006  Double_t dca[2] = {1e6,1e6};
1007  Double_t covar[3] = {1e6,1e6,1e6};
1008  track->PropagateToDCA(vtx,bz,100.,dca,covar);
1009 
1010  if(AcceptDCA(pt,dca[0]))
1011  {
1012  if (vertexBC !=0 && fVertexBC != AliVTrack::kTOFBCNA) return vertexBC;
1013  else if(vertexBC == 0) bc0 = kTRUE;
1014  }
1015  }
1016 
1017  if( bc0 ) vertexBC = 0 ;
1018  else vertexBC = AliVTrack::kTOFBCNA ;
1019 
1020  return vertexBC;
1021 }
1022 
1023 //_____________________________
1030 //_____________________________
1032 {
1033  return track->GetID();
1034 }
1035 
1036 //_____________________________
1039 //_____________________________
1041 {
1043  {
1044  AliInfo("Cannot access stack and mcparticles at the same time, change them");
1045  fReadStack = kFALSE;
1046  fReadAODMCParticles = kFALSE;
1047  }
1048 
1049  // Activate debug level in AliAnaWeights
1050  if( fWeightUtils->GetDebug() >= 0 )
1051  (AliAnalysisManager::GetAnalysisManager())->AddClassDebug(fWeightUtils->ClassName(), fWeightUtils->GetDebug());
1052 }
1053 
1054 //_______________________________________
1056 //_______________________________________
1058 {
1059  fDataType = kESD ;
1060  fCTSPtMin = 0.1 ;
1061  fEMCALPtMin = 0.1 ;
1062  fPHOSPtMin = 0.1 ;
1063  fCTSPtMax = 1000. ;
1064  fEMCALPtMax = 1000. ;
1065  fPHOSPtMax = 1000. ;
1066 
1067  fEMCALBadChMinDist = 0; // open, 2; // standard
1068  fPHOSBadChMinDist = 0; // open, 2; // standard
1069 
1070  fEMCALNCellsCut = 0; // open, 1; // standard
1071  fPHOSNCellsCut = 0; // open, 2; // standard
1072 
1073  //Track DCA cuts
1074  // dca_xy cut = 0.0105+0.0350/TMath::Power(pt,1.1);
1075  fTrackDCACut[0] = 0.0105;
1076  fTrackDCACut[1] = 0.0350;
1077  fTrackDCACut[2] = 1.1;
1078 
1079  //Do not filter the detectors input by default.
1080  fFillEMCAL = kFALSE;
1081  fFillDCAL = kFALSE;
1082  fFillPHOS = kFALSE;
1083  fFillCTS = kFALSE;
1084  fFillEMCALCells = kFALSE;
1085  fFillPHOSCells = kFALSE;
1086 
1087  fReadStack = kFALSE; // Check in the constructor of the other readers if it was set or in the configuration file
1088  fReadAODMCParticles = kFALSE; // Check in the constructor of the other readers if it was set or in the configuration file
1089  fDeltaAODFileName = "deltaAODPartCorr.root";
1091  fEventTriggerMask = AliVEvent::kAny;
1092  fMixEventTriggerMask = AliVEvent::kAnyINT;
1093  fEventTriggerAtSE = kTRUE; // Use only events that pass event selection at SE base class
1094 
1095  fAcceptFastCluster = kTRUE;
1096  fEventType = -1;
1097 
1098  //We want tracks fitted in the detectors:
1099  //fTrackStatus=AliESDtrack::kTPCrefit;
1100  //fTrackStatus|=AliESDtrack::kITSrefit;
1101  fTrackStatus = 0;
1102 
1103  fV0ADC[0] = 0; fV0ADC[1] = 0;
1104  fV0Mul[0] = 0; fV0Mul[1] = 0;
1105 
1106  fZvtxCut = 10.;
1107 
1108  fNMixedEvent = 1;
1109 
1110  fPtHardAndJetPtFactor = 7.;
1112 
1113  //Centrality
1114  fUseAliCentrality = kFALSE;
1115  fCentralityClass = "V0M";
1116  fCentralityOpt = 100;
1117  fCentralityBin[0] = fCentralityBin[1]=-1;
1118 
1119  fEventPlaneMethod = "V0";
1120 
1121  // Allocate memory (not sure this is the right place)
1122  fCTSTracks = new TObjArray();
1123  fEMCALClusters = new TObjArray();
1124  fDCALClusters = new TObjArray();
1125  fPHOSClusters = new TObjArray();
1126  //fTriggerAnalysis = new AliTriggerAnalysis;
1127  fAODBranchList = new TList ;
1128  fOutputContainer = new TList ;
1129 
1130  fEnergyHistogramNbins = 200;
1131  fEnergyHistogramLimit[0] = 0 ;
1132  fEnergyHistogramLimit[1] = 100;
1133 
1134  fPileUpParamSPD[0] = 3 ; fPileUpParamSPD[1] = 0.8 ;
1135  fPileUpParamSPD[2] = 3.0 ; fPileUpParamSPD[3] = 2.0 ; fPileUpParamSPD[4] = 5.0;
1136 
1137  // Parametrized time cut (LHC11d)
1140 
1141  // Parametrized time cut (LHC11c)
1142  //fEMCALParamTimeCutMin[0] =-5; fEMCALParamTimeCutMin[1] =-1 ; fEMCALParamTimeCutMin[2] = 1.87; fEMCALParamTimeCutMin[3] = 0.4;
1143  //fEMCALParamTimeCutMax[0] = 3.5; fEMCALParamTimeCutMax[1] = 50; fEMCALParamTimeCutMax[2] = 0.15; fEMCALParamTimeCutMax[3] = 1.6;
1144 
1145  fTimeStampRunMin = -1;
1146  fTimeStampRunMax = 1e12;
1149 
1150  for(Int_t i = 0; i < 19; i++)
1151  {
1152  fEMCalBCEvent [i] = 0;
1153  fEMCalBCEventCut[i] = 0;
1154  fTrackBCEvent [i] = 0;
1155  fTrackBCEventCut[i] = 0;
1156  }
1157 
1158  // Trigger match-rejection
1159  fTriggerPatchTimeWindow[0] = 8;
1160  fTriggerPatchTimeWindow[1] = 9;
1161 
1162  fTriggerClusterBC = -10000 ;
1165  fTriggerClusterIndex = -1;
1166  fTriggerClusterId = -1;
1167 
1168  //Jets
1171  if(!fNonStandardJets) fNonStandardJets = new TClonesArray("AliAODJet",100);
1174  if(!fBackgroundJets) fBackgroundJets = new AliAODJetEventBackground();
1175 
1176  fSmearShowerShapeWidth = 0.005;
1177  fSmearNLMMin = 1;
1178  fSmearNLMMax = 1;
1179 
1180  fWeightUtils = new AliAnaWeights() ;
1181  fEventWeight = 1 ;
1182 
1183 }
1184 
1185 //__________________________________________________________________________
1188 //__________________________________________________________________________
1190 {
1191  // Parametrized cut depending on E
1192  if(fUseParamTimeCut)
1193  {
1196  //printf("tof %f, minCut %f, maxCut %f\n",tof,minCut,maxCut);
1197  if( tof < minCut || tof > maxCut ) return kFALSE ;
1198  }
1199 
1200  //In any case, the time should to be larger than the fixed window ...
1201  if( tof < fEMCALTimeCutMin || tof > fEMCALTimeCutMax ) return kFALSE ;
1202 
1203  return kTRUE ;
1204 }
1205 
1206 //________________________________________________
1209 //________________________________________________
1211 {
1212  return fInputEvent->IsPileupFromSPD((Int_t) fPileUpParamSPD[0] , fPileUpParamSPD[1] ,
1213  fPileUpParamSPD[2] , fPileUpParamSPD[3] , fPileUpParamSPD[4] );
1214  //printf("Param : %d, %2.2f, %2.2f, %2.2f, %2.2f\n",(Int_t) fPileUpParamSPD[0], fPileUpParamSPD[1], fPileUpParamSPD[2], fPileUpParamSPD[3], fPileUpParamSPD[4]);
1215 }
1216 
1217 //__________________________________________________
1219 //__________________________________________________
1221 {
1222  if(fNPileUpClusters > fNPileUpClustersCut) return kTRUE ;
1223  else return kFALSE;
1224 }
1225 
1226 //________________________________________________________
1228 //________________________________________________________
1230 {
1231  if( IsPileUpFromSPD() && IsPileUpFromEMCal()) return kTRUE ;
1232  else return kFALSE;
1233 }
1234 
1235 //_______________________________________________________
1237 //_______________________________________________________
1239 {
1240  if( IsPileUpFromSPD() || IsPileUpFromEMCal()) return kTRUE ;
1241  else return kFALSE;
1242 }
1243 
1244 //___________________________________________________________
1246 //___________________________________________________________
1248 {
1249  if( IsPileUpFromSPD() && !IsPileUpFromEMCal()) return kTRUE ;
1250  else return kFALSE;
1251 }
1252 
1253 //___________________________________________________________
1255 //___________________________________________________________
1257 {
1258  if( !IsPileUpFromSPD() && IsPileUpFromEMCal()) return kTRUE ;
1259  else return kFALSE;
1260 }
1261 
1262 //______________________________________________________________
1264 //______________________________________________________________
1266 {
1267  if( !IsPileUpFromSPD() && !IsPileUpFromEMCal()) return kTRUE ;
1268  else return kFALSE;
1269 }
1270 
1271 //___________________________________________________________________________________
1279 //___________________________________________________________________________________
1280 Bool_t AliCaloTrackReader::FillInputEvent(Int_t iEntry, const char * /*curFileName*/)
1281 {
1282  fEventNumber = iEntry;
1283  fTriggerClusterIndex = -1;
1284  fTriggerClusterId = -1;
1285  fIsTriggerMatch = kFALSE;
1286  fTriggerClusterBC = -10000;
1287  fIsExoticEvent = kFALSE;
1288  fIsBadCellEvent = kFALSE;
1289  fIsBadMaxCellEvent = kFALSE;
1290 
1291  fIsTriggerMatchOpenCut[0] = kFALSE ;
1292  fIsTriggerMatchOpenCut[1] = kFALSE ;
1293  fIsTriggerMatchOpenCut[2] = kFALSE ;
1294 
1295  //fCurrentFileName = TString(currentFileName);
1296  if(!fInputEvent)
1297  {
1298  AliInfo("Input event not available, skip event analysis");
1299  return kFALSE;
1300  }
1301 
1302  fhNEventsAfterCut->Fill(0.5);
1303 
1304  //-----------------------------------------------
1305  // Select the event depending on the trigger type
1306  // and other event characteristics
1307  // like the goodness of the EMCal trigger
1308  //-----------------------------------------------
1309 
1310  Bool_t accept = CheckEventTriggers();
1311  if(!accept) return kFALSE;
1312 
1313  AliDebug(1,"Pass Event trigger selection");
1314 
1315 
1316  //------------------------------------------------------
1317  // Event rejection depending on time stamp
1318  //------------------------------------------------------
1319 
1321  {
1322  AliESDEvent* esd = dynamic_cast<AliESDEvent*> (fInputEvent);
1323  if(esd)
1324  {
1325  Int_t timeStamp = esd->GetTimeStamp();
1326  Float_t timeStampFrac = 1.*(timeStamp-fTimeStampRunMin) / (fTimeStampRunMax-fTimeStampRunMin);
1327 
1328  //printf("stamp0 %d, max0 %d, frac %f\n", timeStamp-fTimeStampRunMin,fTimeStampRunMax-fTimeStampRunMin, timeStampFrac);
1329 
1330  if(timeStampFrac < fTimeStampEventFracMin || timeStampFrac > fTimeStampEventFracMax) return kFALSE;
1331  }
1332 
1333  AliDebug(1,"Pass Time Stamp rejection");
1334  fhNEventsAfterCut->Fill(8.5);
1335  }
1336 
1337  //------------------------------------------------------
1338  // Event rejection depending on vertex, pileup, v0and
1339  //------------------------------------------------------
1340 
1341  FillVertexArray();
1342 
1343  //Reject events with Z vertex too large, only for SE analysis, if not, cut on the analysis code
1344  if(!GetMixedEvent() && TMath::Abs(fVertex[0][2]) > fZvtxCut) return kFALSE;
1345 
1346  fhNEventsAfterCut->Fill(9.5);
1347 
1349  {
1350  if( !CheckForPrimaryVertex() ) return kFALSE; // algorithm in ESD/AOD Readers
1351  if( TMath::Abs(fVertex[0][0] ) < 1.e-6 &&
1352  TMath::Abs(fVertex[0][1] ) < 1.e-6 &&
1353  TMath::Abs(fVertex[0][2] ) < 1.e-6 ) return kFALSE;
1354  }
1355 
1356  AliDebug(1,"Pass primary vertex rejection");
1357 
1358  fhNEventsAfterCut->Fill(10.5);
1359 
1360  //printf("Reader : IsPileUp %d, Multi %d\n",IsPileUpFromSPD(),fInputEvent->IsPileupFromSPDInMultBins());
1361 
1363  {
1364  // Do not analyze events with pileup
1365  Bool_t bPileup = IsPileUpFromSPD();
1366  //IsPileupFromSPDInMultBins() // method to try
1367  //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]);
1368  if(bPileup) return kFALSE;
1369 
1370  AliDebug(1,"Pass Pile-Up event rejection");
1371 
1372  fhNEventsAfterCut->Fill(11.5);
1373  }
1374 
1376  {
1377  AliVVZERO* v0 = fInputEvent->GetVZEROData();
1378 
1379  Bool_t bV0AND = ((v0->GetV0ADecision()==1) && (v0->GetV0CDecision()==1));
1380  //bV0AND = fTriggerAnalysis->IsOfflineTriggerFired((AliESDEvent*)fInputEvent, AliTriggerAnalysis::kV0AND);
1381  //printf("V0AND event? %d\n",bV0AND);
1382 
1383  if(!bV0AND)
1384  {
1385  AliDebug(1,"Reject event by V0AND");
1386  return kFALSE;
1387  }
1388 
1389  AliDebug(1,"Pass V0AND event rejection");
1390 
1391  fhNEventsAfterCut->Fill(12.5);
1392  }
1393 
1394  //------------------------------------------------------
1395  // Check if there is a centrality value, PbPb analysis,
1396  // and if a centrality bin selection is requested
1397  //------------------------------------------------------
1398 
1399  //If we need a centrality bin, we select only those events in the corresponding bin.
1400  Int_t cen = -1;
1401  if ( fCentralityBin[0] >= 0 && fCentralityBin[1] >= 0 )
1402  {
1403  cen = GetEventCentrality();
1404 
1405  if(cen > fCentralityBin[1] || cen <= fCentralityBin[0]) return kFALSE; //reject events out of bin.
1406 
1407  AliDebug(1,"Pass centrality rejection");
1408 
1409  fhNEventsAfterCut->Fill(13.5);
1410  }
1411 
1412  //----------------------------------------------------------------
1413  // Reject the event if the event header name is not
1414  // the one requested among the possible generators.
1415  // Needed in case of cocktail MC generation with multiple options.
1416  //----------------------------------------------------------------
1418  return kFALSE;
1419 
1420  fhNEventsAfterCut->Fill(14.5);
1421 
1422  //---------------------------------------------------------------------------
1423  // In case of analysis of events with jets, skip those with jet pt > 5 pt hard
1424  // To be used on for MC data in pT hard bins
1425  //---------------------------------------------------------------------------
1426 
1428  {
1429  if(!ComparePtHardAndJetPt()) return kFALSE ;
1430  AliDebug(1,"Pass Pt Hard - Jet rejection");
1431  fhNEventsAfterCut->Fill(15.5);
1432  }
1433 
1435  {
1436  if(!ComparePtHardAndClusterPt()) return kFALSE ;
1437  AliDebug(1,"Pass Pt Hard - Cluster rejection");
1438  fhNEventsAfterCut->Fill(16.5);
1439  }
1440 
1441  //------------------------------------------------------------------
1442  // Recover the weight assigned to the event, if provided
1443  // right now only for pT-hard bins and centrality depedent weights
1444  //------------------------------------------------------------------
1446  {
1448 
1449  fWeightUtils->SetPythiaEventHeader(((AliGenPythiaEventHeader*)GetGenEventHeader()));
1450 
1452  }
1453 
1454  //-------------------------------------------------------
1455  // Get the main vertex BC, in case not available
1456  // it is calculated in FillCTS checking the BC of tracks
1457  //------------------------------------------------------
1458  fVertexBC = fInputEvent->GetPrimaryVertex()->GetBC();
1459 
1460  //-----------------------------------------------
1461  // Fill the arrays with cluster/tracks/cells data
1462  //-----------------------------------------------
1463 
1464  if(fFillCTS)
1465  {
1466  FillInputCTS();
1467  //Accept events with at least one track
1468  if(fTrackMult == 0 && fDoRejectNoTrackEvents) return kFALSE ;
1469 
1470  fhNEventsAfterCut->Fill(17.5);
1471 
1472  AliDebug(1,"Pass rejection of null track events");
1473  }
1474 
1476  {
1477  if(fVertexBC != 0 && fVertexBC != AliVTrack::kTOFBCNA) return kFALSE ;
1478 
1479  AliDebug(1,"Pass rejection of events with vertex at BC!=0");
1480 
1481  fhNEventsAfterCut->Fill(18.5);
1482  }
1483 
1484  if(fFillEMCALCells)
1486 
1487  if(fFillPHOSCells)
1489 
1490  if(fFillEMCAL || fFillDCAL)
1491  FillInputEMCAL();
1492 
1493  if(fFillPHOS)
1494  FillInputPHOS();
1495 
1496  FillInputVZERO();
1497 
1498  //one specified jet branch
1503 
1504  AliDebug(1,"Event accepted for analysis");
1505 
1506  return kTRUE ;
1507 }
1508 
1509 //__________________________________________________
1512 //__________________________________________________
1514 {
1515  if(fUseAliCentrality)
1516  {
1517  if ( !GetCentrality() ) return -1;
1518 
1519  AliDebug(1,Form("Cent. Percentile: V0M %2.2f, CL0 %2.2f, CL1 %2.2f; selected class %s",
1520  GetCentrality()->GetCentralityPercentile("V0M"),
1521  GetCentrality()->GetCentralityPercentile("CL0"),
1522  GetCentrality()->GetCentralityPercentile("CL1"),
1523  fCentralityClass.Data()));
1524 
1525  if (fCentralityOpt == 100) return (Int_t) GetCentrality()->GetCentralityPercentile(fCentralityClass); // 100 bins max
1526  else if(fCentralityOpt == 10) return GetCentrality()->GetCentralityClass10(fCentralityClass);// 10 bins max
1527  else if(fCentralityOpt == 20) return GetCentrality()->GetCentralityClass5(fCentralityClass); // 20 bins max
1528  else
1529  {
1530  AliInfo(Form("Unknown centrality option %d, use 10, 20 or 100\n",fCentralityOpt));
1531  return -1;
1532  }
1533  }
1534  else
1535  {
1536  if ( !GetMultSelCen() ) return -1;
1537 
1538  AliDebug(1,Form("Mult. Percentile: V0M %2.2f, CL0 %2.2f, CL1 %2.2f; selected class %s",
1539  GetMultSelCen()->GetMultiplicityPercentile("V0M",1),
1540  GetMultSelCen()->GetMultiplicityPercentile("CL0",1),
1541  GetMultSelCen()->GetMultiplicityPercentile("CL1",1),
1542  fCentralityClass.Data()));
1543 
1544  return GetMultSelCen()->GetMultiplicityPercentile(fCentralityClass, kTRUE); // returns centrality only for events used in calibration
1545 
1546  // equivalent to
1547  //GetMultSelCen()->GetMultiplicityPercentile("V0M", kFALSE); // returns centrality for any event
1548  //Int_t qual = GetMultSelCen()->GetEvSelCode(); if (qual ! = 0) cent = qual;
1549  }
1550 }
1551 
1552 //_____________________________________________________
1555 //_____________________________________________________
1557 {
1558  if( !GetEventPlane() ) return -1000;
1559 
1560  Float_t ep = GetEventPlane()->GetEventplane(GetEventPlaneMethod(), GetInputEvent());
1561 
1562  if(GetEventPlaneMethod()=="Q" && (ep < 0 || ep > TMath::Pi()))
1563  {
1564  AliDebug(1,Form("Bad EP for <Q> method : %f\n",ep));
1565  return -1000;
1566  }
1567  else if(GetEventPlaneMethod().Contains("V0") )
1568  {
1569  if((ep > TMath::Pi()/2 || ep < -TMath::Pi()/2))
1570  {
1571  AliDebug(1,Form("Bad EP for <%s> method : %f\n",GetEventPlaneMethod().Data(), ep));
1572  return -1000;
1573  }
1574 
1575  ep+=TMath::Pi()/2; // put same range as for <Q> method
1576  }
1577 
1578  AliDebug(3,Form("Event plane angle %f",ep));
1579 
1580 // if(fDebug > 0 )
1581 // {
1582 // if (ep > TMath::Pi()) printf("AliCaloTrackReader::GetEventPlaneAngle() - Too large angle = %f\n",ep);
1583 // else if(ep < 0 ) printf("AliCaloTrackReader::GetEventPlaneAngle() - Negative angle = %f\n" ,ep);
1584 // }
1585 
1586  return ep;
1587 }
1588 
1589 //__________________________________________________________
1591 //__________________________________________________________
1593 {
1594  vertex[0] = fVertex[0][0];
1595  vertex[1] = fVertex[0][1];
1596  vertex[2] = fVertex[0][2];
1597 }
1598 
1599 //__________________________________________________________________________
1601 //__________________________________________________________________________
1602 void AliCaloTrackReader::GetVertex(Double_t vertex[3], Int_t evtIndex) const
1603 {
1604  vertex[0] = fVertex[evtIndex][0];
1605  vertex[1] = fVertex[evtIndex][1];
1606  vertex[2] = fVertex[evtIndex][2];
1607 }
1608 
1609 //________________________________________
1612 //________________________________________
1614 {
1615  // Delete previous vertex
1616  if(fVertex)
1617  {
1618  for (Int_t i = 0; i < fNMixedEvent; i++)
1619  {
1620  delete [] fVertex[i] ;
1621  }
1622  delete [] fVertex ;
1623  }
1624 
1625  fVertex = new Double_t*[fNMixedEvent] ;
1626  for (Int_t i = 0; i < fNMixedEvent; i++)
1627  {
1628  fVertex[i] = new Double_t[3] ;
1629  fVertex[i][0] = 0.0 ;
1630  fVertex[i][1] = 0.0 ;
1631  fVertex[i][2] = 0.0 ;
1632  }
1633 
1634  if (!fMixedEvent)
1635  { // Single event analysis
1636  if(fDataType!=kMC)
1637  {
1638 
1639  if(fInputEvent->GetPrimaryVertex())
1640  {
1641  fInputEvent->GetPrimaryVertex()->GetXYZ(fVertex[0]);
1642  }
1643  else
1644  {
1645  AliWarning("NULL primary vertex");
1646  fVertex[0][0]=0.; fVertex[0][1]=0.; fVertex[0][2]=0.;
1647  }//Primary vertex pointer do not exist
1648 
1649  } else
1650  {// MC read event
1651  fVertex[0][0]=0.; fVertex[0][1]=0.; fVertex[0][2]=0.;
1652  }
1653 
1654  AliDebug(1,Form("Single Event Vertex : %f,%f,%f\n",fVertex[0][0],fVertex[0][1],fVertex[0][2]));
1655 
1656  } else
1657  { // MultiEvent analysis
1658  for (Int_t iev = 0; iev < fNMixedEvent; iev++)
1659  {
1660  if (fMixedEvent->GetVertexOfEvent(iev))
1661  fMixedEvent->GetVertexOfEvent(iev)->GetXYZ(fVertex[iev]);
1662  else
1663  AliWarning("No vertex found");
1664 
1665  AliDebug(1,Form("Multi Event %d Vertex : %f,%f,%f",iev,fVertex[iev][0],fVertex[iev][1],fVertex[iev][2]));
1666  }
1667  }
1668 }
1669 
1670 //_____________________________________
1676 //_____________________________________
1678 {
1679  AliDebug(1,"Begin");
1680 
1681  Double_t pTrack[3] = {0,0,0};
1682 
1683  Int_t nTracks = fInputEvent->GetNumberOfTracks() ;
1684  fTrackMult = 0;
1685  Int_t nstatus = 0;
1686  Double_t bz = GetInputEvent()->GetMagneticField();
1687 
1688  for(Int_t i = 0; i < 19; i++)
1689  {
1690  fTrackBCEvent [i] = 0;
1691  fTrackBCEventCut[i] = 0;
1692  }
1693 
1694  Bool_t bc0 = kFALSE;
1695  if(fRecalculateVertexBC) fVertexBC = AliVTrack::kTOFBCNA;
1696 
1697  for (Int_t itrack = 0; itrack < nTracks; itrack++)
1698  {
1699  AliVTrack * track = (AliVTrack*)fInputEvent->GetTrack(itrack) ; // retrieve track from esd
1700 
1701  if ( !AcceptParticleMCLabel( TMath::Abs(track->GetLabel()) ) ) continue ;
1702 
1703  fhCTSTrackCutsPt[0]->Fill(track->Pt());
1704 
1705  //Select tracks under certain conditions, TPCrefit, ITSrefit ... check the set bits
1706  ULong_t status = track->GetStatus();
1707 
1708  if (fTrackStatus && !((status & fTrackStatus) == fTrackStatus))
1709  continue ;
1710 
1711  fhCTSTrackCutsPt[1]->Fill(track->Pt());
1712 
1713  nstatus++;
1714 
1715  //-------------------------
1716  // Select the tracks depending on cuts of AOD or ESD
1717  if(!SelectTrack(track, pTrack)) continue ;
1718 
1719  fhCTSTrackCutsPt[2]->Fill(track->Pt());
1720 
1721  //-------------------------
1722  // TOF cuts
1723  Bool_t okTOF = ( (status & AliVTrack::kTOFout) == AliVTrack::kTOFout ) ;
1724  Double_t tof = -1000;
1725  Int_t trackBC = -1000 ;
1726 
1727  if(fAccessTrackTOF)
1728  {
1729  if(okTOF)
1730  {
1731  trackBC = track->GetTOFBunchCrossing(bz);
1732  SetTrackEventBC(trackBC+9);
1733 
1734  tof = track->GetTOFsignal()*1e-3;
1735 
1736  //After selecting tracks with small DCA, pointing to vertex, set vertex BC depeding on tracks BC
1738  {
1739  if (trackBC != 0 && trackBC != AliVTrack::kTOFBCNA) fVertexBC = trackBC;
1740  else if(trackBC == 0) bc0 = kTRUE;
1741  }
1742 
1743  //In any case, the time should to be larger than the fixed window ...
1744  if( fUseTrackTimeCut && (trackBC !=0 || tof < fTrackTimeCutMin || tof > fTrackTimeCutMax) )
1745  {
1746  //printf("Remove track time %f and bc = %d\n",tof,trackBC);
1747  continue ;
1748  }
1749  //else printf("Accept track time %f and bc = %d\n",tof,trackBC);
1750  }
1751  }
1752 
1753  fhCTSTrackCutsPt[3]->Fill(track->Pt());
1754 
1755  //---------------------
1756  // DCA cuts
1757  //
1758  fMomentum.SetPxPyPzE(pTrack[0],pTrack[1],pTrack[2],0);
1759 
1760  if(fUseTrackDCACut)
1761  {
1762  Float_t dcaTPC =-999;
1763  //In case of AODs, TPC tracks cannot be propagated back to primary vertex,
1764  if( fDataType == kAOD ) dcaTPC = ((AliAODTrack*) track)->DCA();
1765 
1766  //normal way to get the dca, cut on dca_xy
1767  if(dcaTPC==-999)
1768  {
1769  Double_t dca[2] = {1e6,1e6};
1770  Double_t covar[3] = {1e6,1e6,1e6};
1771  Bool_t okDCA = track->PropagateToDCA(fInputEvent->GetPrimaryVertex(),bz,100.,dca,covar);
1772  if( okDCA) okDCA = AcceptDCA(fMomentum.Pt(),dca[0]);
1773  if(!okDCA)
1774  {
1775  //printf("AliCaloTrackReader::FillInputCTS() - Reject track pt %2.2f, dca_xy %2.4f\n",fMomentum.Pt(),dca[0]);
1776  continue ;
1777  }
1778  }
1779  }// DCA cuts
1780 
1781  fhCTSTrackCutsPt[4]->Fill(track->Pt());
1782 
1783  //-------------------------
1784  // Kinematic/acceptance cuts
1785  //
1786  // Count the tracks in eta < 0.9
1787  if(TMath::Abs(track->Eta())< fTrackMultEtaCut) fTrackMult++;
1788 
1789  if(fCTSPtMin > fMomentum.Pt() || fCTSPtMax < fMomentum.Pt()) continue ;
1790 
1791  // Check effect of cuts on track BC
1792  if(fAccessTrackTOF && okTOF) SetTrackEventBCcut(trackBC+9);
1793 
1794  if(fCheckFidCut && !fFiducialCut->IsInFiducialCut(fMomentum.Eta(),fMomentum.Phi(),kCTS)) continue;
1795 
1796  fhCTSTrackCutsPt[5]->Fill(track->Pt());
1797 
1798  // ------------------------------
1799  // Add selected tracks to array
1800  AliDebug(2,Form("Selected tracks pt %3.2f, phi %3.2f deg, eta %3.2f",
1801  fMomentum.Pt(),RadToDeg(GetPhi(fMomentum.Phi())),fMomentum.Eta()));
1802 
1803  fCTSTracks->Add(track);
1804 
1805  // TODO, check if remove
1806  if (fMixedEvent) track->SetID(itrack);
1807 
1808  }// track loop
1809 
1810  if( fRecalculateVertexBC && (fVertexBC == 0 || fVertexBC == AliVTrack::kTOFBCNA))
1811  {
1812  if( bc0 ) fVertexBC = 0 ;
1813  else fVertexBC = AliVTrack::kTOFBCNA ;
1814  }
1815 
1816  AliDebug(1,Form("AOD entries %d, input tracks %d, pass status %d, multipliticy %d", fCTSTracks->GetEntriesFast(), nTracks, nstatus, fTrackMult));//fCTSTracksNormalInputEntries);
1817 }
1818 
1819 //_______________________________________________________________________________
1837 //_______________________________________________________________________________
1839 {
1840  // Accept clusters with the proper label
1841  if ( clus->GetLabel() >= 0 ) // -1 corresponds to noisy MC
1842  {
1843  if ( !AcceptParticleMCLabel(clus->GetLabel()) ) return ;
1844  }
1845 
1846  // TODO, not sure if needed anymore
1847  Int_t vindex = 0 ;
1848  if (fMixedEvent)
1849  vindex = fMixedEvent->EventIndexForCaloCluster(iclus);
1850 
1851  clus->GetMomentum(fMomentum, fVertex[vindex]);
1852 
1853  // No correction/cut applied yet
1854  fhEMCALClusterCutsE[0]->Fill(clus->E());
1855 
1856  //if( (fDebug > 2 && fMomentum.E() > 0.1) || fDebug > 10 )
1857  AliDebug(2,Form("Input cluster E %3.2f, pt %3.2f, phi %3.2f deg, eta %3.2f",
1858  fMomentum.E(),fMomentum.Pt(),RadToDeg(GetPhi(fMomentum.Phi())),fMomentum.Eta()));
1859 
1860  //---------------------------
1861  // Embedding case
1862  // TO BE REVISED
1864  {
1865  if(clus->GetNLabels()==0 || clus->GetLabel() < 0) return;
1866  //else printf("Embedded cluster, %d, n label %d label %d \n",iclus,clus->GetNLabels(),clus->GetLabel());
1867  }
1868 
1869  //--------------------------------------
1870  // Apply some corrections in the cluster
1871  //
1873  {
1874  //Recalibrate the cluster energy
1876  {
1878 
1879  clus->SetE(energy);
1880  //printf("Recalibrated Energy %f\n",clus->E());
1881 
1884 
1885  } // recalculate E
1886 
1887  //Recalculate distance to bad channels, if new list of bad channels provided
1889 
1890  //Recalculate cluster position
1891  if(GetCaloUtils()->IsRecalculationOfClusterPositionOn())
1892  {
1894  //clus->GetPosition(pos);
1895  //printf("After Corrections: e %f, x %f, y %f, z %f\n",clus->E(),pos[0],pos[1],pos[2]);
1896  }
1897 
1898  // Recalculate TOF
1899  if(GetCaloUtils()->GetEMCALRecoUtils()->IsTimeRecalibrationOn())
1900  {
1901  Double_t tof = clus->GetTOF();
1902  Float_t frac =-1;
1903  Int_t absIdMax = GetCaloUtils()->GetMaxEnergyCell(fEMCALCells, clus,frac);
1904 
1905  GetCaloUtils()->GetEMCALRecoUtils()->RecalibrateCellTime(absIdMax,fInputEvent->GetBunchCrossNumber(),tof);
1906 
1907  //additional L1 phase shift
1908  if(GetCaloUtils()->GetEMCALRecoUtils()->IsL1PhaseInTimeRecalibrationOn())
1909  {
1910  GetCaloUtils()->GetEMCALRecoUtils()->RecalibrateCellTimeL1Phase(GetCaloUtils()->GetEMCALGeometry()->GetSuperModuleNumber(absIdMax),
1911  fInputEvent->GetBunchCrossNumber(), tof);
1912  }
1913 
1914  clus->SetTOF(tof);
1915 
1916  }// Time recalibration
1917  }
1918 
1919  // Check effect of corrections
1920  fhEMCALClusterCutsE[1]->Fill(clus->E());
1921 
1922  //-----------------------------------------------------------------
1923  // Reject clusters with bad channels, close to borders and exotic
1924  //
1925  Bool_t goodCluster = GetCaloUtils()->GetEMCALRecoUtils()->IsGoodCluster(clus,
1926  GetCaloUtils()->GetEMCALGeometry(),
1927  GetEMCALCells(),fInputEvent->GetBunchCrossNumber());
1928 
1929  if(!goodCluster)
1930  {
1931  //if( (fDebug > 2 && fMomentum.E() > 0.1) || fDebug > 10 )
1932  AliDebug(2,Form("Bad cluster E %3.2f, pt %3.2f, phi %3.2f deg, eta %3.2f",
1933  fMomentum.E(),fMomentum.Pt(),RadToDeg(GetPhi(fMomentum.Phi())),fMomentum.Eta()));
1934 
1935  return;
1936  }
1937 
1938  // Check effect of bad cluster removal
1939  fhEMCALClusterCutsE[2]->Fill(clus->E());
1940 
1941  //Float_t pos[3];
1942  //clus->GetPosition(pos);
1943  //printf("Before Corrections: e %f, x %f, y %f, z %f\n",clus->E(),pos[0],pos[1],pos[2]);
1944 
1945  //--------------------------------------
1946  // Correct non linearity or smear energy
1947  //
1949  {
1951 
1952  //if( (fDebug > 5 && fMomentum.E() > 0.1) || fDebug > 10 )
1953  AliDebug(5,Form("Correct Non Lin: Old E %3.2f, New E %3.2f",
1954  fMomentum.E(),clus->E()));
1955 
1956  // In case of MC analysis, to match resolution/calibration in real data
1957  // Not needed anymore, just leave for MC studies on systematics
1958  if( GetCaloUtils()->GetEMCALRecoUtils()->IsClusterEnergySmeared() )
1959  {
1960  Float_t rdmEnergy = GetCaloUtils()->GetEMCALRecoUtils()->SmearClusterEnergy(clus);
1961 
1962  //if( (fDebug > 5 && fMomentum.E() > 0.1) || fDebug > 10 )
1963  AliDebug(5,Form("Smear energy: Old E %3.2f, New E %3.2f",clus->E(),rdmEnergy));
1964 
1965  clus->SetE(rdmEnergy);
1966  }
1967  }
1968 
1969  clus->GetMomentum(fMomentum, fVertex[vindex]);
1970 
1971  // Check effect linearity correction, energy smearing
1972  fhEMCALClusterCutsE[3]->Fill(clus->E());
1973 
1974  // Check the event BC depending on EMCal clustr before final cuts
1975  Double_t tof = clus->GetTOF()*1e9;
1976 
1977  Int_t bc = TMath::Nint(tof/50) + 9;
1978  //printf("tof %2.2f, bc+5=%d\n",tof,bc);
1979 
1980  SetEMCalEventBC(bc);
1981 
1982  //--------------------------------------
1983  // Apply some kinematical/acceptance cuts
1984  //
1985  if(fEMCALPtMin > clus->E() || fEMCALPtMax < clus->E()) return ;
1986 
1987  // Select cluster fiducial region
1988  //
1989  Bool_t bEMCAL = kFALSE;
1990  Bool_t bDCAL = kFALSE;
1991  if(fCheckFidCut)
1992  {
1993  if(fFillEMCAL && fFiducialCut->IsInFiducialCut(fMomentum.Eta(),fMomentum.Phi(),kEMCAL)) bEMCAL = kTRUE ;
1994  if(fFillDCAL && fFiducialCut->IsInFiducialCut(fMomentum.Eta(),fMomentum.Phi(),kDCAL )) bDCAL = kTRUE ;
1995  }
1996  else
1997  {
1998  bEMCAL = kTRUE;
1999  }
2000 
2001  //---------------------------------------------------------------------
2002  // Mask all cells in collumns facing ALICE thick material if requested
2003  //
2005  {
2006  Int_t absId = -1;
2007  Int_t iSupMod = -1;
2008  Int_t iphi = -1;
2009  Int_t ieta = -1;
2010  Bool_t shared = kFALSE;
2011  GetCaloUtils()->GetEMCALRecoUtils()->GetMaxEnergyCell(GetCaloUtils()->GetEMCALGeometry(), GetEMCALCells(),clus,absId,iSupMod,ieta,iphi,shared);
2012 
2013  AliDebug(2,Form("Masked collumn: cluster E %3.2f, pt %3.2f, phi %3.2f deg, eta %3.2f",
2014  fMomentum.E(),fMomentum.Pt(),RadToDeg(GetPhi(fMomentum.Phi())),fMomentum.Eta()));
2015 
2016 
2017  if(GetCaloUtils()->MaskFrameCluster(iSupMod, ieta)) return;
2018  }
2019 
2020  // Check effect of energy and fiducial cuts
2021  fhEMCALClusterCutsE[4]->Fill(clus->E());
2022 
2023 
2024  //------------------------------------------
2025  // Apply time cut, count EMCal BC before cut
2026  //
2027  SetEMCalEventBCcut(bc);
2028 
2029  if(!IsInTimeWindow(tof,clus->E()))
2030  {
2031  fNPileUpClusters++ ;
2032  if(fUseEMCALTimeCut)
2033  {
2034  AliDebug(2,Form("Out of time window E %3.2f, pt %3.2f, phi %3.2f deg, eta %3.2f, time %e",
2035  fMomentum.E(),fMomentum.Pt(),RadToDeg(GetPhi(fMomentum.Phi())),fMomentum.Eta(),tof));
2036 
2037  return ;
2038  }
2039  }
2040  else
2042 
2043  // Check effect of time cut
2044  fhEMCALClusterCutsE[5]->Fill(clus->E());
2045 
2046 
2047  //----------------------------------------------------
2048  // Apply N cells cut
2049  //
2050  if(clus->GetNCells() <= fEMCALNCellsCut && fDataType != AliCaloTrackReader::kMC) return ;
2051 
2052  // Check effect of n cells cut
2053  fhEMCALClusterCutsE[6]->Fill(clus->E());
2054 
2055  //----------------------------------------------------
2056  // Apply distance to bad channel cut
2057  //
2058  Double_t distBad = clus->GetDistanceToBadChannel() ; //Distance to bad channel
2059 
2060  if(distBad < 0.) distBad=9999. ; //workout strange convension dist = -1. ;
2061 
2062  if(distBad < fEMCALBadChMinDist) return ;
2063 
2064  // Check effect distance to bad channel cut
2065  fhEMCALClusterCutsE[7]->Fill(clus->E());
2066 
2067  //----------------------------------------------------
2068  // Smear the SS to try to match data and simulations,
2069  // do it only for simulations.
2070  //
2071  Int_t nMaxima = GetCaloUtils()->GetNumberOfLocalMaxima(clus, GetEMCALCells());
2072  // Int_t nMaxima = clus->GetNExMax(); // For Run2
2073  if( fSmearShowerShape && clus->GetNCells() > 2 &&
2074  nMaxima >= fSmearNLMMin && nMaxima <= fSmearNLMMax )
2075  {
2076  AliDebug(2,Form("Smear shower shape - Original: %2.4f\n", clus->GetM02()));
2078  {
2079  clus->SetM02( clus->GetM02() + fRandom.Landau(0, fSmearShowerShapeWidth) );
2080  }
2082  {
2083  if(iclus%3 == 0 && clus->GetM02() > 0.1) clus->SetM02( clus->GetM02() + fRandom.Landau(0.05, fSmearShowerShapeWidth) ); //fSmearShowerShapeWidth = 0.035
2084  }
2085  else if (fSmearingFunction == kNoSmearing)
2086  {
2087  clus->SetM02( clus->GetM02() );
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  TString genName;
2263  for (Int_t iclus = 0; iclus < nclusters; iclus++)
2264  {
2265  AliVCluster * clus = fInputEvent->GetCaloCluster(iclus) ;
2266  if ( !clus ) continue ;
2267 
2268  if ( !clus->IsPHOS() ) continue ;
2269 
2270  if(clus->GetLabel() >=0 ) // -1 corresponds to noisy MC
2271  {
2272  if ( !AcceptParticleMCLabel(clus->GetLabel()) ) continue ;
2273  }
2274 
2275  fhPHOSClusterCutsE[0]->Fill(clus->E());
2276 
2277  // Skip CPV input
2278  if( clus->GetType() == AliVCluster::kPHOSCharged ) continue ;
2279 
2280  fhPHOSClusterCutsE[1]->Fill(clus->E());
2281 
2282  //---------------------------------------------
2283  // Old feature, try to rely on PHOS tender
2284  //
2286  {
2287  // Recalibrate the cluster energy
2289  {
2290  Float_t energy = GetCaloUtils()->RecalibrateClusterEnergy(clus, (AliAODCaloCells*)GetPHOSCells());
2291  clus->SetE(energy);
2292  }
2293  }
2294 
2295  //----------------------------------------------------------------------------------
2296  // Check if the cluster contains any bad channel and if close to calorimeter borders
2297  //
2298  // Old feature, try to rely on PHOS tender
2299  if( GetCaloUtils()->ClusterContainsBadChannel(kPHOS,clus->GetCellsAbsId(), clus->GetNCells()))
2300  continue;
2301 
2302  if(!GetCaloUtils()->CheckCellFiducialRegion(clus, fInputEvent->GetPHOSCells()))
2303  continue;
2304 
2305  // TODO, add exotic cut???
2306 
2307  fhPHOSClusterCutsE[2]->Fill(clus->E());
2308 
2309  // TODO Dead code? remove?
2310  Int_t vindex = 0 ;
2311  if (fMixedEvent)
2312  vindex = fMixedEvent->EventIndexForCaloCluster(iclus);
2313 
2314  clus->GetMomentum(fMomentum, fVertex[vindex]);
2315 
2316  //----------------------------------------------------------------------------------
2317  // Remove clusters close to borders
2318  //
2320  continue ;
2321 
2322  fhPHOSClusterCutsE[3]->Fill(clus->E());
2323 
2324  //----------------------------------------------------------------------------------
2325  // Remove clusters with too low energy
2326  //
2327  if (fPHOSPtMin > fMomentum.E() || fPHOSPtMax < fMomentum.E() )
2328  continue ;
2329 
2330  fhPHOSClusterCutsE[4]->Fill(clus->E());
2331 
2332  //----------------------------------------------------
2333  // Apply N cells cut
2334  //
2335  if(clus->GetNCells() <= fPHOSNCellsCut && fDataType != AliCaloTrackReader::kMC) return ;
2336 
2337  // Check effect of n cells cut
2338  fhPHOSClusterCutsE[5]->Fill(clus->E());
2339 
2340  //----------------------------------------------------
2341  // Apply distance to bad channel cut
2342  //
2343  Double_t distBad = clus->GetDistanceToBadChannel() ; //Distance to bad channel
2344 
2345  if(distBad < 0.) distBad=9999. ; //workout strange convension dist = -1. ;
2346 
2347  if(distBad < fPHOSBadChMinDist) return ;
2348 
2349  // Check effect distance to bad channel cut
2350  fhPHOSClusterCutsE[6]->Fill(clus->E());
2351 
2352  // TODO, add time cut
2353 
2354  //----------------------------------------------------------------------------------
2355  // Add selected clusters to array
2356  //
2357  //if(fDebug > 2 && fMomentum.E() > 0.1)
2358  AliDebug(2,Form("Selected clusters E %3.2f, pt %3.2f, phi %3.2f deg, eta %3.2f",
2359  fMomentum.E(),fMomentum.Pt(),RadToDeg(GetPhi(fMomentum.Phi())),fMomentum.Eta()));
2360 
2361  fPHOSClusters->Add(clus);
2362 
2363  // TODO Dead code? remove?
2364  if (fMixedEvent)
2365  clus->SetID(iclus) ;
2366 
2367  } // esd/aod cluster loop
2368 
2369  AliDebug(1,Form("AOD entries %d",fPHOSClusters->GetEntriesFast())) ;
2370 }
2371 
2372 //____________________________________________
2374 //____________________________________________
2376 {
2377  fEMCALCells = fInputEvent->GetEMCALCells();
2378 }
2379 
2380 //___________________________________________
2382 //___________________________________________
2384 {
2385  fPHOSCells = fInputEvent->GetPHOSCells();
2386 }
2387 
2388 //_______________________________________
2391 //_______________________________________
2393 {
2394  AliVVZERO* v0 = fInputEvent->GetVZEROData();
2395  //printf("Init V0: ADC (%d,%d), Multiplicity (%d,%d) \n",fV0ADC[0],fV0ADC[1],fV0Mul[0],fV0Mul[1]);
2396 
2397  if (v0)
2398  {
2399  AliESDVZERO* esdV0 = dynamic_cast<AliESDVZERO*> (v0);
2400  for (Int_t i = 0; i < 32; i++)
2401  {
2402  if(esdV0)
2403  {//Only available in ESDs
2404  fV0ADC[0] += (Int_t)esdV0->GetAdcV0C(i);
2405  fV0ADC[1] += (Int_t)esdV0->GetAdcV0A(i);
2406  }
2407 
2408  fV0Mul[0] += (Int_t)v0->GetMultiplicityV0C(i);
2409  fV0Mul[1] += (Int_t)v0->GetMultiplicityV0A(i);
2410  }
2411 
2412  AliDebug(1,Form("ADC (%d,%d), Multiplicity (%d,%d)",fV0ADC[0],fV0ADC[1],fV0Mul[0],fV0Mul[1]));
2413  }
2414  else
2415  {
2416  AliDebug(1,"Cannot retrieve V0 ESD! Run w/ null V0 charges");
2417  }
2418 }
2419 
2420 //_________________________________________________
2424 //_________________________________________________
2426 {
2427  AliDebug(2,"Begin");
2428 
2429  //
2430  //check if branch name is given
2431  if(!fInputNonStandardJetBranchName.Length())
2432  {
2433  fInputEvent->Print();
2434  AliFatal("No non-standard jet branch name specified. Specify among existing ones.");
2435  }
2436 
2437  fNonStandardJets = dynamic_cast<TClonesArray*>(fInputEvent->FindListObject(fInputNonStandardJetBranchName.Data()));
2438 
2439  if(!fNonStandardJets)
2440  {
2441  //check if jet branch exist; exit if not
2442  fInputEvent->Print();
2443 
2444  AliFatal(Form("%s:%d no reconstructed jet array with name %s in AOD", (char*)__FILE__,__LINE__,fInputNonStandardJetBranchName.Data()));
2445  }
2446  else
2447  {
2448  AliDebug(1,Form("AOD input jets %d", fNonStandardJets->GetEntriesFast()));
2449  }
2450 }
2451 
2452 //_________________________________________________
2456 //_________________________________________________
2458 {
2459  AliDebug(1,"Begin");
2460  //
2461  //check if branch name is given
2462  if(!fInputBackgroundJetBranchName.Length())
2463  {
2464  fInputEvent->Print();
2465 
2466  AliFatal("No background jet branch name specified. Specify among existing ones.");
2467  }
2468 
2469  fBackgroundJets = (AliAODJetEventBackground*)(fInputEvent->FindListObject(fInputBackgroundJetBranchName.Data()));
2470 
2471  if(!fBackgroundJets)
2472  {
2473  //check if jet branch exist; exit if not
2474  fInputEvent->Print();
2475 
2476  AliFatal(Form("%s:%d no reconstructed jet array with name %s in AOD", (char*)__FILE__,__LINE__,fInputBackgroundJetBranchName.Data()));
2477  }
2478  else
2479  {
2480  AliDebug(1,"FillInputBackgroundJets");
2481  fBackgroundJets->Print("");
2482  }
2483 }
2484 
2485 //____________________________________________________________________
2491 //____________________________________________________________________
2493 {
2494  // init some variables
2495  Int_t trigtimes[30], globCol, globRow,ntimes, i;
2496  Int_t absId = -1; //[100];
2497  Int_t nPatch = 0;
2498 
2499  TArrayI patches(0);
2500 
2501  // get object pointer
2502  AliVCaloTrigger *caloTrigger = GetInputEvent()->GetCaloTrigger( "EMCAL" );
2503 
2504  if(!caloTrigger)
2505  {
2506  AliError("Trigger patches input (AliVCaloTrigger) not available in data!");
2507  return patches;
2508  }
2509 
2510  //printf("CaloTrigger Entries %d\n",caloTrigger->GetEntries() );
2511 
2512  // class is not empty
2513  if( caloTrigger->GetEntries() > 0 )
2514  {
2515  // must reset before usage, or the class will fail
2516  caloTrigger->Reset();
2517 
2518  // go throuth the trigger channels
2519  while( caloTrigger->Next() )
2520  {
2521  // get position in global 2x2 tower coordinates
2522  caloTrigger->GetPosition( globCol, globRow );
2523 
2524  //L0
2525  if(IsEventEMCALL0())
2526  {
2527  // get dimension of time arrays
2528  caloTrigger->GetNL0Times( ntimes );
2529 
2530  // no L0s in this channel
2531  // presence of the channel in the iterator still does not guarantee that L0 was produced!!
2532  if( ntimes < 1 )
2533  continue;
2534 
2535  // get timing array
2536  caloTrigger->GetL0Times( trigtimes );
2537  //printf("Get L0 patch : n times %d - trigger time window %d - %d\n",ntimes, tmin,tmax);
2538 
2539  // go through the array
2540  for( i = 0; i < ntimes; i++ )
2541  {
2542  // check if in cut - 8,9 shall be accepted in 2011
2543  if( trigtimes[i] >= tmin && trigtimes[i] <= tmax )
2544  {
2545  //printf("Accepted trigger time %d \n",trigtimes[i]);
2546  //if(nTrig > 99) continue;
2547  GetCaloUtils()->GetEMCALGeometry()->GetAbsFastORIndexFromPositionInEMCAL(globCol,globRow, absId);
2548  //printf("pass the time cut globCol %d, globRow %d absId %d\n",globCol,globRow, absId);
2549  patches.Set(nPatch+1);
2550  patches.AddAt(absId,nPatch++);
2551  }
2552  } // trigger time array
2553  }//L0
2554  else if(IsEventEMCALL1()) // L1
2555  {
2556  Int_t bit = 0;
2557  caloTrigger->GetTriggerBits(bit);
2558 
2559  Int_t sum = 0;
2560  caloTrigger->GetL1TimeSum(sum);
2561  //fBitEGA-=2;
2562  Bool_t isEGA1 = ((bit >> fBitEGA ) & 0x1) && IsEventEMCALL1Gamma1() ;
2563  Bool_t isEGA2 = ((bit >> (fBitEGA+1)) & 0x1) && IsEventEMCALL1Gamma2() ;
2564  Bool_t isEJE1 = ((bit >> fBitEJE ) & 0x1) && IsEventEMCALL1Jet1 () ;
2565  Bool_t isEJE2 = ((bit >> (fBitEJE+1)) & 0x1) && IsEventEMCALL1Jet2 () ;
2566 
2567  //if((bit>> fBitEGA )&0x1) printf("Trig Bit %d - bit %d - EG1 %d - EG2 %d\n",fBitEGA ,bit,IsEventEMCALL1Gamma1(),IsEventEMCALL1Gamma2());
2568  //if((bit>>(fBitEGA+1))&0x1) printf("Trig Bit %d - bit %d - EG1 %d - EG2 %d\n",fBitEGA+1,bit,IsEventEMCALL1Gamma1(),IsEventEMCALL1Gamma2());
2569 
2570  if(!isEGA1 && !isEJE1 && !isEGA2 && !isEJE2) continue;
2571 
2572  Int_t patchsize = -1;
2573  if (isEGA1 || isEGA2) patchsize = 2;
2574  else if (isEJE1 || isEJE2) patchsize = 16;
2575 
2576  //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",
2577  // bit,sum,patchsize,isEGA1,isEGA2,isEJE1,isEJE2,fBitEGA,fBitEJE,IsEventEMCALL1Gamma(),IsEventEMCALL1Jet());
2578 
2579 
2580  // add 2x2 (EGA) or 16x16 (EJE) patches
2581  for(Int_t irow=0; irow < patchsize; irow++)
2582  {
2583  for(Int_t icol=0; icol < patchsize; icol++)
2584  {
2585  GetCaloUtils()->GetEMCALGeometry()->GetAbsFastORIndexFromPositionInEMCAL(globCol+icol,globRow+irow, absId);
2586  //printf("pass the time cut globCol %d, globRow %d absId %d\n",globCol,globRow, absId);
2587  patches.Set(nPatch+1);
2588  patches.AddAt(absId,nPatch++);
2589  }
2590  }
2591 
2592  } // L1
2593 
2594  } // trigger iterator
2595  } // go through triggers
2596 
2597  if(patches.GetSize()<=0) AliInfo(Form("No patch found! for triggers: %s and selected <%s>",
2599  //else printf(">>>>> N patches %d, test %d,first %d, last %d\n",patches.GetSize(), nPatch, patches.At(0), patches.At(patches.GetSize()-1));
2600 
2601  return patches;
2602 }
2603 
2604 //____________________________________________________________
2608 //____________________________________________________________
2610 {
2611  // Init info from previous event
2612  fTriggerClusterIndex = -1;
2613  fTriggerClusterId = -1;
2614  fTriggerClusterBC = -10000;
2615  fIsExoticEvent = kFALSE;
2616  fIsBadCellEvent = kFALSE;
2617  fIsBadMaxCellEvent = kFALSE;
2618 
2619  fIsTriggerMatch = kFALSE;
2620  fIsTriggerMatchOpenCut[0] = kFALSE;
2621  fIsTriggerMatchOpenCut[1] = kFALSE;
2622  fIsTriggerMatchOpenCut[2] = kFALSE;
2623 
2624  // Do only analysis for triggered events
2625  if(!IsEventEMCALL1() && !IsEventEMCALL0())
2626  {
2627  fTriggerClusterBC = 0;
2628  return;
2629  }
2630 
2631  //printf("***** Try to match trigger to cluster %d **** L0 %d, L1 %d\n",fTriggerPatchClusterMatch,IsEventEMCALL0(),IsEventEMCALL1());
2632 
2633  //Recover the list of clusters
2634  TClonesArray * clusterList = 0;
2635  if (fInputEvent->FindListObject(fEMCALClustersListName))
2636  {
2637  clusterList = dynamic_cast<TClonesArray*> (fInputEvent->FindListObject(fEMCALClustersListName));
2638  }
2639  else if(fOutputEvent)
2640  {
2641  clusterList = dynamic_cast<TClonesArray*> (fOutputEvent->FindListObject(fEMCALClustersListName));
2642  }
2643 
2644  // Get number of clusters and of trigger patches
2645  Int_t nclusters = fInputEvent->GetNumberOfCaloClusters();
2646  if(clusterList)
2647  nclusters = clusterList->GetEntriesFast();
2648 
2649  Int_t nPatch = patches.GetSize();
2650  Float_t exoDiffTime = GetCaloUtils()->GetEMCALRecoUtils()->GetExoticCellDiffTimeCut();
2651 
2652  //Init some variables used in the cluster loop
2653  Float_t tofPatchMax = 100000;
2654  Float_t ePatchMax =-1;
2655 
2656  Float_t tofMax = 100000;
2657  Float_t eMax =-1;
2658 
2659  Int_t clusMax =-1;
2660  Int_t idclusMax =-1;
2661  Bool_t badClMax = kFALSE;
2662  Bool_t badCeMax = kFALSE;
2663  Bool_t exoMax = kFALSE;
2664 // Int_t absIdMaxTrig= -1;
2665  Int_t absIdMaxMax = -1;
2666 
2667  Int_t nOfHighECl = 0 ;
2668 
2669  //
2670  // Check what is the trigger threshold
2671  // set minimu energym of candidate for trigger cluster
2672  //
2674 
2675  Float_t triggerThreshold = fTriggerL1EventThreshold;
2676  if(IsEventEMCALL0()) triggerThreshold = fTriggerL0EventThreshold;
2677  Float_t minE = triggerThreshold / 2.;
2678 
2679  // This method is not really suitable for JET trigger
2680  // but in case, reduce the energy cut since we do not trigger on high energy particle
2681  if(IsEventEMCALL1Jet() || minE < 1) minE = 1;
2682 
2683  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));
2684 
2685  //
2686  // Loop on the clusters, check if there is any that falls into one of the patches
2687  //
2688  for (Int_t iclus = 0; iclus < nclusters; iclus++)
2689  {
2690  AliVCluster * clus = 0;
2691  if(clusterList) clus = (AliVCluster*) clusterList->At(iclus);
2692  else clus = fInputEvent->GetCaloCluster(iclus);
2693 
2694  if ( !clus ) continue ;
2695 
2696  if ( !clus->IsEMCAL() ) continue ;
2697 
2698  //Skip clusters with too low energy to be triggering
2699  if ( clus->E() < minE ) continue ;
2700 
2701  Float_t frac = -1;
2702  Int_t absIdMax = GetCaloUtils()->GetMaxEnergyCell(fInputEvent->GetEMCALCells(), clus,frac);
2703 
2704  Bool_t badCluster = GetCaloUtils()->GetEMCALRecoUtils()->ClusterContainsBadChannel(GetCaloUtils()->GetEMCALGeometry(),
2705  clus->GetCellsAbsId(),clus->GetNCells());
2706  UShort_t cellMax[] = {(UShort_t) absIdMax};
2707  Bool_t badCell = GetCaloUtils()->GetEMCALRecoUtils()->ClusterContainsBadChannel(GetCaloUtils()->GetEMCALGeometry(),cellMax,1);
2708 
2709  // if cell is bad, it can happen that time calibration is not available,
2710  // when calculating if it is exotic, this can make it to be exotic by default
2711  // open it temporarily for this cluster
2712  if(badCell)
2713  GetCaloUtils()->GetEMCALRecoUtils()->SetExoticCellDiffTimeCut(10000000);
2714 
2715  Bool_t exotic = GetCaloUtils()->GetEMCALRecoUtils()->IsExoticCluster(clus, fInputEvent->GetEMCALCells());
2716 
2717  // Set back the time cut on exotics
2718  if(badCell)
2719  GetCaloUtils()->GetEMCALRecoUtils()->SetExoticCellDiffTimeCut(exoDiffTime);
2720 
2721  // Energy threshold for exotic Ecross typically at 4 GeV,
2722  // for lower energy, check that there are more than 1 cell in the cluster
2723  if(!exotic && clus->GetNCells() < 2) exotic = kTRUE;
2724 
2725  Float_t energy = clus->E();
2726  Int_t idclus = clus->GetID();
2727 
2728  Double_t tof = clus->GetTOF();
2729  if(GetCaloUtils()->GetEMCALRecoUtils()->IsTimeRecalibrationOn() && fTriggerClusterTimeRecal){
2730  GetCaloUtils()->GetEMCALRecoUtils()->RecalibrateCellTime(absIdMax,fInputEvent->GetBunchCrossNumber(),tof);
2731  //additional L1 phase shift
2732  if(GetCaloUtils()->GetEMCALRecoUtils()->IsL1PhaseInTimeRecalibrationOn()){
2733  GetCaloUtils()->GetEMCALRecoUtils()->RecalibrateCellTimeL1Phase(GetCaloUtils()->GetEMCALGeometry()->GetSuperModuleNumber(absIdMax), fInputEvent->GetBunchCrossNumber(), tof);
2734  }
2735  }
2736  tof *=1.e9;
2737 
2738  //printf("cluster %d, ID %d, E %2.2f, tof %2.2f, AbsId max %d, exotic %d, bad Cluster %d, bad Cell %d\n",
2739  // iclus,idclus, energy,tof,absIdMax, exotic, badCluster,badCell);
2740 
2741  // Find the highest energy cluster, avobe trigger threshold
2742  // in the event in case no match to trigger is found
2743  if( energy > eMax )
2744  {
2745  tofMax = tof;
2746  eMax = energy;
2747  badClMax = badCluster;
2748  badCeMax = badCell;
2749  exoMax = exotic;
2750  clusMax = iclus;
2751  idclusMax = idclus;
2752  absIdMaxMax = absIdMax;
2753  }
2754 
2755  // count the good clusters in the event avobe the trigger threshold
2756  // to check the exotic events
2757  if(!badCluster && !exotic)
2758  nOfHighECl++;
2759 
2760  // Find match to trigger
2761  if(fTriggerPatchClusterMatch && nPatch>0)
2762  {
2763  for(Int_t iabsId =0; iabsId < nPatch; iabsId++)
2764  {
2765  Int_t absIDCell[4];
2766  GetCaloUtils()->GetEMCALGeometry()->GetCellIndexFromFastORIndex(patches.At(iabsId), absIDCell);
2767  //if(tof > 75 ) printf("E %2.2f TOF %2.2f Trigger patch %d, cells : %d, %d, %d, %d\n",
2768  // clus->E(),tof,patches.At(iabsId), absIDCell[0],absIDCell[1],absIDCell[2],absIDCell[3]);
2769 
2770  for(Int_t ipatch = 0; ipatch < 4; ipatch++)
2771  {
2772  if(absIdMax == absIDCell[ipatch])
2773  {
2774  //printf("*** Patches : absId %d, E %2.1f, tof %f \n",absIdMax,clus->E(), tof);
2775  if(energy > ePatchMax)
2776  {
2777  tofPatchMax = tof;
2778  ePatchMax = energy;
2779  fIsBadCellEvent = badCluster;
2780  fIsBadMaxCellEvent = badCell;
2781  fIsExoticEvent = exotic;
2782  fTriggerClusterIndex = iclus;
2783  fTriggerClusterId = idclus;
2784  fIsTriggerMatch = kTRUE;
2785 // absIdMaxTrig = absIdMax;
2786  }
2787  }
2788  }// cell patch loop
2789  }// trigger patch loop
2790  } // Do trigger patch matching
2791 
2792  }// Cluster loop
2793 
2794  // If there was no match, assign as trigger
2795  // the highest energy cluster in the event
2796  if(!fIsTriggerMatch)
2797  {
2798  tofPatchMax = tofMax;
2799  ePatchMax = eMax;
2800  fIsBadCellEvent = badClMax;
2801  fIsBadMaxCellEvent = badCeMax;
2802  fIsExoticEvent = exoMax;
2803  fTriggerClusterIndex = clusMax;
2804  fTriggerClusterId = idclusMax;
2805  }
2806 
2807  Double_t tofPatchMaxUS = TMath::Abs(tofPatchMax);
2808 
2809  if (tofPatchMaxUS < 28 ) fTriggerClusterBC = 0 ;
2810  else if(tofPatchMaxUS < 75 ) fTriggerClusterBC = 1 ;
2811  else if(tofPatchMaxUS < 125) fTriggerClusterBC = 2 ;
2812  else if(tofPatchMaxUS < 175) fTriggerClusterBC = 3 ;
2813  else if(tofPatchMaxUS < 225) fTriggerClusterBC = 4 ;
2814  else if(tofPatchMaxUS < 275) fTriggerClusterBC = 5 ;
2815  else
2816  {
2817  //printf("AliCaloTrackReader::MatchTriggerCluster() - Large BC - tof %2.3f - Index %d\n",tofPatchMaxUS,fTriggerClusterIndex);
2819  else
2820  {
2821  fTriggerClusterIndex = -2;
2822  fTriggerClusterId = -2;
2823  }
2824  }
2825 
2826  if(tofPatchMax < 0) fTriggerClusterBC*=-1;
2827 
2828 
2829  // 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",
2830  // fTriggerClusterIndex, fTriggerClusterId,ePatchMax, tofPatchMax,
2831  // fTriggerClusterBC, fIsBadCellEvent,fIsBadMaxCellEvent,fIsExoticEvent, fIsTriggerMatch, nOfHighECl,absIdMaxMax);
2832  //
2833  // 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",
2834  // clusMax, idclusMax, eMax,tofMax, badClMax, badCeMax,exoMax);
2835 
2836  //Redo matching but open cuts
2837  if(!fIsTriggerMatch && fTriggerClusterId >= 0)
2838  {
2839  // Open time patch time
2840  TArrayI patchOpen = GetTriggerPatches(7,10);
2841 
2842  Int_t patchAbsIdOpenTime = -1;
2843  for(Int_t iabsId =0; iabsId < patchOpen.GetSize(); iabsId++)
2844  {
2845  Int_t absIDCell[4];
2846  patchAbsIdOpenTime = patchOpen.At(iabsId);
2847  GetCaloUtils()->GetEMCALGeometry()->GetCellIndexFromFastORIndex(patchAbsIdOpenTime, absIDCell);
2848  //if(tof > 75 ) printf("E %2.2f TOF %2.2f Trigger patch %d, cells : %d, %d, %d, %d\n",
2849  // clus->E(),tof,patches.At(iabsId), absIDCell[0],absIDCell[1],absIDCell[2],absIDCell[3]);
2850 
2851  for(Int_t ipatch = 0; ipatch < 4; ipatch++)
2852  {
2853  if(absIdMaxMax == absIDCell[ipatch])
2854  {
2855  fIsTriggerMatchOpenCut[0] = kTRUE;
2856  break;
2857  }
2858  }// cell patch loop
2859  }// trigger patch loop
2860 
2861  // Check neighbour patches
2862  Int_t patchAbsId = -1;
2863  Int_t globalCol = -1;
2864  Int_t globalRow = -1;
2865  GetCaloUtils()->GetEMCALGeometry()->GetFastORIndexFromCellIndex(absIdMaxMax, patchAbsId);
2866  GetCaloUtils()->GetEMCALGeometry()->GetPositionInEMCALFromAbsFastORIndex(patchAbsId,globalCol,globalRow);
2867 
2868  // Check patches with strict time cut
2869  Int_t patchAbsIdNeigh = -1;
2870  for(Int_t icol = globalCol-1; icol <= globalCol+1; icol++)
2871  {
2872  if(icol < 0 || icol > 47) continue;
2873 
2874  for(Int_t irow = globalRow; irow <= globalRow+1; irow++)
2875  {
2876  if(irow < 0 || irow > 63) continue;
2877 
2878  GetCaloUtils()->GetEMCALGeometry()->GetAbsFastORIndexFromPositionInEMCAL(icol, irow, patchAbsIdNeigh);
2879 
2880  if ( patchAbsIdNeigh < 0 ) continue;
2881 
2882  for(Int_t iabsId =0; iabsId < patches.GetSize(); iabsId++)
2883  {
2884  if(patchAbsIdNeigh == patches.At(iabsId))
2885  {
2886  fIsTriggerMatchOpenCut[1] = kTRUE;
2887  break;
2888  }
2889  }// trigger patch loop
2890 
2891  }// row
2892  }// col
2893 
2894  // Check patches with open time cut
2895  Int_t patchAbsIdNeighOpenTime = -1;
2896  for(Int_t icol = globalCol-1; icol <= globalCol+1; icol++)
2897  {
2898  if(icol < 0 || icol > 47) continue;
2899 
2900  for(Int_t irow = globalRow; irow <= globalRow+1; irow++)
2901  {
2902  if(irow < 0 || irow > 63) continue;
2903 
2904  GetCaloUtils()->GetEMCALGeometry()->GetAbsFastORIndexFromPositionInEMCAL(icol, irow, patchAbsIdNeighOpenTime);
2905 
2906  if ( patchAbsIdNeighOpenTime < 0 ) continue;
2907 
2908  for(Int_t iabsId =0; iabsId < patchOpen.GetSize(); iabsId++)
2909  {
2910  if(patchAbsIdNeighOpenTime == patchOpen.At(iabsId))
2911  {
2912  fIsTriggerMatchOpenCut[2] = kTRUE;
2913  break;
2914  }
2915  }// trigger patch loop
2916 
2917  }// row
2918  }// col
2919 
2920  // printf("No match, new match: Open time %d-%d, open Neigh %d-%d, both open %d-%d\n",fIsTriggerMatchOpenCut[0],patchAbsIdOpenTime,
2921  // fIsTriggerMatchOpenCut[1],patchAbsIdNeigh,
2922  // fIsTriggerMatchOpenCut[2],patchAbsIdNeighOpenTime);
2923 
2924  patchOpen.Reset();
2925 
2926  }// No trigger match found
2927  //printf("Trigger BC %d, Id %d, Index %d\n",fTriggerClusterBC,fTriggerClusterId,fTriggerClusterIndex);
2928 }
2929 
2930 //_________________________________________________________
2934 //_________________________________________________________
2936 {
2938  {
2939  // get object pointer
2940  AliVCaloTrigger *caloTrigger = GetInputEvent()->GetCaloTrigger( "EMCAL" );
2941 
2942  if ( fBitEGA == 6 )
2943  {
2944  if (IsEventEMCALL1Gamma1()) fTriggerL1EventThreshold = 0.07874*caloTrigger->GetL1Threshold(1);
2945  else if(IsEventEMCALL1Gamma2()) fTriggerL1EventThreshold = 0.07874*caloTrigger->GetL1Threshold(3);
2946  else if(IsEventEMCALL1Jet1 ()) fTriggerL1EventThreshold = 0.07874*caloTrigger->GetL1Threshold(0);
2947  else if(IsEventEMCALL1Jet2 ()) fTriggerL1EventThreshold = 0.07874*caloTrigger->GetL1Threshold(2);
2948 
2949  // printf("L1 trigger Threshold Jet1 %f, Gamma1 %f, Jet2 %f, Gamma2 %f\n",
2950  // 0.07874*caloTrigger->GetL1Threshold(0),
2951  // 0.07874*caloTrigger->GetL1Threshold(1),
2952  // 0.07874*caloTrigger->GetL1Threshold(2),
2953  // 0.07874*caloTrigger->GetL1Threshold(3));
2954  }
2955  else
2956  {
2957  // Old AOD data format, in such case, order of thresholds different!!!
2958  if (IsEventEMCALL1Gamma1()) fTriggerL1EventThreshold = 0.07874*caloTrigger->GetL1Threshold(0);
2959  else if(IsEventEMCALL1Gamma2()) fTriggerL1EventThreshold = 0.07874*caloTrigger->GetL1Threshold(2);
2960  else if(IsEventEMCALL1Jet1 ()) fTriggerL1EventThreshold = 0.07874*caloTrigger->GetL1Threshold(1);
2961  else if(IsEventEMCALL1Jet2 ()) fTriggerL1EventThreshold = 0.07874*caloTrigger->GetL1Threshold(3);
2962 
2963  // printf("L1 trigger Threshold Jet1 %f, Gamma1 %f, Jet2 %f, Gamma2 %f\n",
2964  // 0.07874*caloTrigger->GetL1Threshold(1),
2965  // 0.07874*caloTrigger->GetL1Threshold(0),
2966  // 0.07874*caloTrigger->GetL1Threshold(3),
2967  // 0.07874*caloTrigger->GetL1Threshold(2));
2968  }
2969  }
2970 
2971  // Set L0 threshold, if not set by user
2973  {
2974  // Revise for periods > LHC11d
2975  Int_t runNumber = fInputEvent->GetRunNumber();
2976  if (runNumber < 146861) fTriggerL0EventThreshold = 3. ;
2977  else if(runNumber < 154000) fTriggerL0EventThreshold = 4. ;
2978  else if(runNumber < 165000) fTriggerL0EventThreshold = 5.5;
2979  else fTriggerL0EventThreshold = 2 ;
2980  }
2981 }
2982 
2983 //________________________________________________________
2985 //________________________________________________________
2986 void AliCaloTrackReader::Print(const Option_t * opt) const
2987 {
2988  if(! opt)
2989  return;
2990 
2991  printf("***** Print: %s %s ******\n", GetName(), GetTitle() ) ;
2992  printf("Task name : %s\n", fTaskName.Data()) ;
2993  printf("Data type : %d\n", fDataType) ;
2994  printf("CTS Min pT : %2.1f GeV/c\n", fCTSPtMin) ;
2995  printf("EMCAL Min pT : %2.1f GeV/c\n", fEMCALPtMin) ;
2996  printf("PHOS Min pT : %2.1f GeV/c\n", fPHOSPtMin) ;
2997  printf("CTS Max pT : %2.1f GeV/c\n", fCTSPtMax) ;
2998  printf("EMCAL Max pT : %2.1f GeV/c\n", fEMCALPtMax) ;
2999  printf("PHOS Max pT : %2.1f GeV/c\n", fPHOSPtMax) ;
3000  printf("EMCAL Bad Dist > %2.1f \n" , fEMCALBadChMinDist) ;
3001  printf("PHOS Bad Dist > %2.1f \n" , fPHOSBadChMinDist) ;
3002  printf("EMCAL N cells > %d \n" , fEMCALNCellsCut) ;
3003  printf("PHOS N cells > %d \n" , fPHOSNCellsCut) ;
3004  printf("EMCAL Time Cut: %3.1f < TOF < %3.1f\n", fEMCALTimeCutMin, fEMCALTimeCutMax);
3005  printf("Use CTS = %d\n", fFillCTS) ;
3006  printf("Use EMCAL = %d\n", fFillEMCAL) ;
3007  printf("Use DCAL = %d\n", fFillDCAL) ;
3008  printf("Use PHOS = %d\n", fFillPHOS) ;
3009  printf("Use EMCAL Cells = %d\n", fFillEMCALCells) ;
3010  printf("Use PHOS Cells = %d\n", fFillPHOSCells) ;
3011  printf("Track status = %d\n", (Int_t) fTrackStatus) ;
3012 
3013  printf("Track Mult Eta Cut = %2.2f\n", fTrackMultEtaCut) ;
3014  printf("Write delta AOD = %d\n", fWriteOutputDeltaAOD) ;
3015  printf("Recalculate Clusters = %d, E linearity = %d\n", fRecalculateClusters, fCorrectELinearity) ;
3016 
3017  printf("Use Triggers selected in SE base class %d; If not what Trigger Mask? %d; MB Trigger Mask for mixed %d \n",
3019 
3021  printf("Compare jet pt and pt hard to accept event, factor = %2.2f",fPtHardAndJetPtFactor);
3022 
3024  printf("Compare cluster pt and pt hard to accept event, factor = %2.2f",fPtHardAndClusterPtFactor);
3025 
3026  printf("Read Kine from, stack? %d, AOD ? %d \n", fReadStack, fReadAODMCParticles) ;
3027  printf("Delta AOD File Name = %s\n", fDeltaAODFileName.Data()) ;
3028  printf("Centrality: Class %s, Option %d, Bin [%d,%d] \n", fCentralityClass.Data(),fCentralityOpt,fCentralityBin[0], fCentralityBin[1]) ;
3029 
3030  printf(" \n") ;
3031 }
3032 
3033 //__________________________________________
3037 //__________________________________________
3039 {
3040  // Count number of cells with energy larger than 0.1 in SM3, cut on this number
3041  Int_t ncellsSM3 = 0;
3042  for(Int_t icell = 0; icell < fInputEvent->GetEMCALCells()->GetNumberOfCells(); icell++)
3043  {
3044  Int_t absID = fInputEvent->GetEMCALCells()->GetCellNumber(icell);
3045  Int_t sm = GetCaloUtils()->GetEMCALGeometry()->GetSuperModuleNumber(absID);
3046  if(fInputEvent->GetEMCALCells()->GetAmplitude(icell) > 0.1 && sm==3) ncellsSM3++;
3047  }
3048 
3049  Int_t ncellcut = 21;
3050  if(GetFiredTriggerClasses().Contains("EMC")) ncellcut = 35;
3051 
3052  if(ncellsSM3 >= ncellcut)
3053  {
3054  AliDebug(1,Form("Reject event with ncells in SM3 %d, cut %d, trig %s",
3055  ncellsSM3,ncellcut,GetFiredTriggerClasses().Data()));
3056  return kTRUE;
3057  }
3058 
3059  return kFALSE;
3060 }
3061 
3062 //_________________________________________________________
3066 //_________________________________________________________
3068 {
3069  if(label < 0) return ;
3070 
3071  AliAODEvent * evt = dynamic_cast<AliAODEvent*> (fInputEvent) ;
3072  if(!evt) return ;
3073 
3074  TClonesArray * arr = dynamic_cast<TClonesArray*>(evt->FindListObject("mcparticles")) ;
3075  if(!arr) return ;
3076 
3077  if(label < arr->GetEntriesFast())
3078  {
3079  AliAODMCParticle * particle = dynamic_cast<AliAODMCParticle *>(arr->At(label));
3080  if(!particle) return ;
3081 
3082  if(label == particle->Label()) return ; // label already OK
3083  //else printf("AliCaloTrackReader::RemapMCLabelForAODs() - Label %d - AOD stack %d \n",label, particle->Label());
3084  }
3085  //else printf("AliCaloTrackReader::RemapMCLabelForAODs() - Label %d > AOD labels %d \n",label, arr->GetEntriesFast());
3086 
3087  // loop on the particles list and check if there is one with the same label
3088  for(Int_t ind = 0; ind < arr->GetEntriesFast(); ind++ )
3089  {
3090  AliAODMCParticle * particle = dynamic_cast<AliAODMCParticle *>(arr->At(ind));
3091  if(!particle) continue ;
3092 
3093  if(label == particle->Label())
3094  {
3095  label = ind;
3096  //printf("AliAnalysisTaskEMCALClusterize::RemapMCLabelForAODs() - New Label Index %d \n",label);
3097  return;
3098  }
3099  }
3100 
3101  label = -1;
3102 
3103  //printf("AliCaloTrackReader::RemapMCLabelForAODs() - Label not found set to -1 \n");
3104 }
3105 
3106 //___________________________________
3108 //___________________________________
3110 {
3111  if(fCTSTracks) fCTSTracks -> Clear();
3112  if(fEMCALClusters) fEMCALClusters -> Clear("C");
3113  if(fPHOSClusters) fPHOSClusters -> Clear("C");
3114 
3115  fV0ADC[0] = 0; fV0ADC[1] = 0;
3116  fV0Mul[0] = 0; fV0Mul[1] = 0;
3117 
3118  if(fNonStandardJets) fNonStandardJets -> Clear("C");
3119  fBackgroundJets->Reset();
3120 }
3121 
3122 //___________________________________________
3126 //___________________________________________
3128 {
3129  fEventTrigMinBias = kFALSE;
3130  fEventTrigCentral = kFALSE;
3131  fEventTrigSemiCentral = kFALSE;
3132  fEventTrigEMCALL0 = kFALSE;
3133  fEventTrigEMCALL1Gamma1 = kFALSE;
3134  fEventTrigEMCALL1Gamma2 = kFALSE;
3135  fEventTrigEMCALL1Jet1 = kFALSE;
3136  fEventTrigEMCALL1Jet2 = kFALSE;
3137 
3138  AliDebug(1,Form("Select trigger mask bit %d - Trigger Event %s - Select <%s>",
3140 
3141  if(fEventTriggerMask <=0 )// in case no mask set
3142  {
3143  // EMC triggered event? Which type?
3144  if( GetFiredTriggerClasses().Contains("-B-") || GetFiredTriggerClasses().Contains("-S-") || GetFiredTriggerClasses().Contains("-I-") )
3145  {
3146  if ( GetFiredTriggerClasses().Contains("EGA" ) ||
3147  GetFiredTriggerClasses().Contains("EG1" ) )
3148  {
3149  fEventTrigEMCALL1Gamma1 = kTRUE;
3150  if( GetFiredTriggerClasses().Contains("EG1" ) && !fFiredTriggerClassName.Contains("EG1") ) fEventTrigEMCALL1Gamma1 = kFALSE;
3151  }
3152  else if( GetFiredTriggerClasses().Contains("EG2" ) )
3153  {
3154  fEventTrigEMCALL1Gamma2 = kTRUE;
3155  if( !fFiredTriggerClassName.Contains("EG2") ) fEventTrigEMCALL1Gamma2 = kFALSE;
3156  }
3157  else if( GetFiredTriggerClasses().Contains("EJE" ) ||
3158  GetFiredTriggerClasses().Contains("EJ1" ) )
3159  {
3160  fEventTrigEMCALL1Jet1 = kTRUE;
3161  if( GetFiredTriggerClasses().Contains("EJ1" ) && !fFiredTriggerClassName.Contains("EJ1") )
3162  fEventTrigEMCALL1Jet1 = kFALSE;
3163  }
3164  else if( GetFiredTriggerClasses().Contains("EJ2" ) )
3165  {
3166  fEventTrigEMCALL1Jet2 = kTRUE;
3167  if( !fFiredTriggerClassName.Contains("EJ2") ) fEventTrigEMCALL1Jet2 = kFALSE;
3168  }
3169  else if( GetFiredTriggerClasses().Contains("CEMC") &&
3170  !GetFiredTriggerClasses().Contains("EGA" ) &&
3171  !GetFiredTriggerClasses().Contains("EJE" ) &&
3172  !GetFiredTriggerClasses().Contains("EG1" ) &&
3173  !GetFiredTriggerClasses().Contains("EJ1" ) &&
3174  !GetFiredTriggerClasses().Contains("EG2" ) &&
3175  !GetFiredTriggerClasses().Contains("EJ2" ) )
3176  {
3177  fEventTrigEMCALL0 = kTRUE;
3178  }
3179 
3180  //Min bias event trigger?
3181  if (GetFiredTriggerClasses().Contains("CCENT_R2-B-NOPF-ALLNOTRD"))
3182  {
3183  fEventTrigCentral = kTRUE;
3184  }
3185  else if(GetFiredTriggerClasses().Contains("CSEMI_R1-B-NOPF-ALLNOTRD"))
3186  {
3187  fEventTrigSemiCentral = kTRUE;
3188  }
3189  else if((GetFiredTriggerClasses().Contains("CINT") || GetFiredTriggerClasses().Contains("CPBI2_B1") ) &&
3190  GetFiredTriggerClasses().Contains("-NOPF-ALLNOTRD") )
3191  {
3192  fEventTrigMinBias = kTRUE;
3193  }
3194  }
3195  }
3196  else
3197  {
3198  // EMC L1 Gamma
3199  if ( fEventTriggerMask & AliVEvent::kEMCEGA )
3200  {
3201  //printf("EGA trigger bit\n");
3202  if (GetFiredTriggerClasses().Contains("EG"))
3203  {
3204  if (GetFiredTriggerClasses().Contains("EGA")) fEventTrigEMCALL1Gamma1 = kTRUE;
3205  else
3206  {
3207  if(GetFiredTriggerClasses().Contains("EG1")) fEventTrigEMCALL1Gamma1 = kTRUE;
3208  if(GetFiredTriggerClasses().Contains("EG2")) fEventTrigEMCALL1Gamma2 = kTRUE;
3209  }
3210  }
3211  }
3212  // EMC L1 Jet
3213  else if( fEventTriggerMask & AliVEvent::kEMCEJE )
3214  {
3215  //printf("EGA trigger bit\n");
3216  if (GetFiredTriggerClasses().Contains("EJ"))
3217  {
3218  if (GetFiredTriggerClasses().Contains("EJE")) fEventTrigEMCALL1Jet1 = kTRUE;
3219  else
3220  {
3221  if(GetFiredTriggerClasses().Contains("EJ1")) fEventTrigEMCALL1Jet1 = kTRUE;
3222  if(GetFiredTriggerClasses().Contains("EJ2")) fEventTrigEMCALL1Jet2 = kTRUE;
3223  }
3224  }
3225  }
3226  // EMC L0
3227  else if((fEventTriggerMask & AliVEvent::kEMC7) ||
3228  (fEventTriggerMask & AliVEvent::kEMC1) )
3229  {
3230  //printf("L0 trigger bit\n");
3231  fEventTrigEMCALL0 = kTRUE;
3232  }
3233  // Min Bias Pb-Pb
3234  else if( fEventTriggerMask & AliVEvent::kCentral )
3235  {
3236  //printf("MB semi central trigger bit\n");
3237  fEventTrigSemiCentral = kTRUE;
3238  }
3239  // Min Bias Pb-Pb
3240  else if( fEventTriggerMask & AliVEvent::kSemiCentral )
3241  {
3242  //printf("MB central trigger bit\n");
3243  fEventTrigCentral = kTRUE;
3244  }
3245  // Min Bias pp, PbPb, pPb
3246  else if((fEventTriggerMask & AliVEvent::kMB ) ||
3247  (fEventTriggerMask & AliVEvent::kINT7) ||
3248  (fEventTriggerMask & AliVEvent::kINT8) ||
3249  (fEventTriggerMask & AliVEvent::kAnyINT) )
3250  {
3251  //printf("MB trigger bit\n");
3252  fEventTrigMinBias = kTRUE;
3253  }
3254  }
3255 
3256  AliDebug(1,Form("Event bits: \n \t MB %d, Cen %d, Sem %d, L0 %d, L1G1 %d, L1G2 %d, L1J1 %d, L1J2 %d",
3260 
3261  // L1 trigger bit
3262  if( fBitEGA == 0 && fBitEJE == 0 )
3263  {
3264  // Init the trigger bit once, correct depending on AliESD(AOD)CaloTrigger header version
3265 
3266  // Simpler way to do it ...
3267 // if( fInputEvent->GetRunNumber() < 172000 )
3268 // reader->SetEventTriggerL1Bit(4,5); // current LHC11 data
3269 // else
3270 // reader->SetEventTriggerL1Bit(6,8); // LHC12-13 data
3271 
3272  // Old values
3273  fBitEGA = 4;
3274  fBitEJE = 5;
3275 
3276  TFile* file = AliAnalysisManager::GetAnalysisManager()->GetTree()->GetCurrentFile();
3277 
3278  const TList *clist = file->GetStreamerInfoCache();
3279 
3280  if(clist)
3281  {
3282  TStreamerInfo *cinfo = (TStreamerInfo*)clist->FindObject("AliESDCaloTrigger");
3283  Int_t verid = 5; // newer ESD header version
3284  if(!cinfo)
3285  {
3286  cinfo = (TStreamerInfo*)clist->FindObject("AliAODCaloTrigger");
3287  verid = 3; // newer AOD header version
3288  }
3289 
3290  if(cinfo)
3291  {
3292  Int_t classversionid = cinfo->GetClassVersion();
3293  //printf("********* Header class version %d *********** \n",classversionid);
3294 
3295  if (classversionid >= verid)
3296  {
3297  fBitEGA = 6;
3298  fBitEJE = 8;
3299  }
3300  } else AliInfo("AliCaloTrackReader()::SetEventTriggerBit() - Streamer info for trigger class not available, bit not changed");
3301  } else AliInfo("AliCaloTrackReader::SetEventTriggerBit() - Streamer list not available!, bit not changed");
3302 
3303  } // set once the EJE, EGA trigger bit
3304 }
3305 
3306 //____________________________________________________________
3309 //____________________________________________________________
3310 void AliCaloTrackReader::SetInputEvent(AliVEvent* const input)
3311 {
3312  fInputEvent = input;
3313  fMixedEvent = dynamic_cast<AliMixedEvent*>(GetInputEvent()) ;
3314  if (fMixedEvent)
3315  fNMixedEvent = fMixedEvent->GetNumberOfEvents() ;
3316 
3317  //Delete previous vertex
3318  if(fVertex)
3319  {
3320  for (Int_t i = 0; i < fNMixedEvent; i++)
3321  {
3322  delete [] fVertex[i] ;
3323  }
3324  delete [] fVertex ;
3325  }
3326 
3327  fVertex = new Double_t*[fNMixedEvent] ;
3328  for (Int_t i = 0; i < fNMixedEvent; i++)
3329  {
3330  fVertex[i] = new Double_t[3] ;
3331  fVertex[i][0] = 0.0 ;
3332  fVertex[i][1] = 0.0 ;
3333  fVertex[i][2] = 0.0 ;
3334  }
3335 }
3336 
3337 
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()
virtual AliMCEvent * GetMC() const
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:60
TObjArray * fPHOSClusters
Temporal array with PHOS CaloClusters.
TString GetGeneratorNameAndIndex(Int_t index, Int_t &genIndex) const
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.
energy
Definition: HFPtSpectrum.C:44
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:33
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.
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:47
UInt_t fEventTriggerMask
Select this triggerered event.
virtual Int_t GetEventCentrality() const
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.
Int_t GetCocktailGeneratorAndIndex(Int_t index, TString &nameGen) const
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.
Int_t fNMCGenerToAccept
Number of MC generators that should not be included in analysis.
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()
void RecalculateClusterTrackMatching(AliVEvent *event, TObjArray *clusterArray=0x0, AliMCEvent *mc=0x0)
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.
TString fMCGenerToAccept[5]
List with name of generators that should not be included.
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:77
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.
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:82
TObjArray * fCTSTracks
Temporal array with tracks.
Int_t fTriggerPatchTimeWindow[2]
Trigger patch selection window.
unsigned short UShort_t
Definition: External.C:28
Bool_t AcceptParticleMCLabel(Int_t mcLabel) const
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.
TString fMCGenerEventHeaderToAccept
Accept events that contain at least this event header name.
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 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.
Int_t fMCGenerIndexToAccept[5]
List with index of generators that should not be included.
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.
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