AliPhysics  97344c9 (97344c9)
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
AliAnalysisTaskChargedParticlesRef.cxx
Go to the documentation of this file.
1 /**************************************************************************
2  * Copyright(c) 1998-2015, 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 #include <algorithm>
16 #include <array>
17 #include <functional>
18 #include <iostream>
19 #include <map>
20 
21 #include <TMath.h>
22 #include <THistManager.h>
23 #include <TLinearBinning.h>
24 
25 #include "AliAnalysisDataContainer.h"
26 #include "AliAnalysisManager.h"
27 #include "AliAnalysisUtils.h"
28 #include "AliAODInputHandler.h"
29 #include "AliAODTrack.h"
31 #include "AliEMCALGeometry.h"
32 #include "AliEMCALRecoUtils.h"
33 #include "AliEMCALTriggerPatchInfo.h"
34 #include "AliEmcalTrackSelection.h"
35 #include "AliESDtrackCuts.h"
36 #include "AliESDEvent.h"
37 #include "AliInputEventHandler.h"
38 #include "AliPIDResponse.h"
39 #include "AliTOFPIDResponse.h"
40 #include "AliVEvent.h"
41 #include "AliVEventHandler.h"
42 #include "AliVVertex.h"
43 
46 
50 
51 namespace EMCalTriggerPtAnalysis {
52 
53 AliAnalysisTaskChargedParticlesRef::AliAnalysisTaskChargedParticlesRef() :
55  fTrackCuts(nullptr),
56  fYshift(0.465),
57  fEtaSign(1),
58  fEtaLabCut(-0.5, 0.5),
59  fEtaCmsCut(-2., 2.),
60  fPhiCut(0., TMath::TwoPi()),
61  fStudyPID(false),
62  fEnableSumw2(false)
63 {
64 }
65 
68  fTrackCuts(nullptr),
69  fYshift(0.465),
70  fEtaSign(1),
71  fEtaLabCut(-0.5, 0.5),
72  fEtaCmsCut(-2., 2.),
73  fPhiCut(0., TMath::TwoPi()),
74  fStudyPID(false),
75  fEnableSumw2(false)
76 {
77  SetNeedEmcalGeom(true);
78  SetCaloTriggerPatchInfoName("EmcalTriggers");
79 }
80 
82  //if(fTrackCuts) delete fTrackCuts;
83 }
84 
86  if(!fTrackCuts) InitializeTrackCuts("standard", fInputHandler->IsA() == AliAODInputHandler::Class());
87 }
88 
90 
91  PtBinning newbinning;
92  TString optionstring = fEnableSumw2 ? "s" : "";
93 
94  // Binning for the PID histogram
95  const int kdimPID = 3;
96  const int knbinsPID[kdimPID] = {1000, 200, 300};
97  const double kminPID[kdimPID] = {-100., 0., 0.}, kmaxPID[kdimPID] = {100., 200., 1.5};
98  std::array<TString, 2> charges = {"Pos", "Neg"};
99  for(auto trg : GetSupportedTriggers()){
100  fHistos->CreateTH1("hEventCount" + trg, "Event Counter for trigger class " + trg, 1, 0.5, 1.5, optionstring);
101  fHistos->CreateTH1("hVertexBefore" + trg, "Vertex distribution before z-cut for trigger class " + trg, 500, -50, 50, optionstring);
102  fHistos->CreateTH1("hVertexAfter" + trg, "Vertex distribution after z-cut for trigger class " + trg, 100, -10, 10, optionstring);
103 
104  fHistos->CreateTH3("hPtEtaPhiAll" + trg, "p_{t}-#eta-#phi distribution of all accepted tracks for trigger " + trg + " ; p_{t} (GeV/c); #eta; #phi", newbinning, TLinearBinning(64, -0.8, 0.8), TLinearBinning(100, 0., 2*TMath::Pi()), optionstring);
105  fHistos->CreateTH3("hPtEtaPhiEMCALAll" + trg, "p_{t}-#eta-#phi distribution of all accepted tracks pointing to the EMCAL for trigger " + trg + "; p_{t} (GeV/c); #eta; #phi", newbinning, TLinearBinning(64, -0.8, 0.8), TLinearBinning(100, 0., 2*TMath::Pi()), optionstring);
106  fHistos->CreateTH3("hPtEtaPhiCent" + trg, "p_{t}-#eta-#phi distribution of all accepted tracks for trigger " + trg + "; p_{t} (GeV/c); #eta; #phi", newbinning, TLinearBinning(64, -0.8, 0.8), TLinearBinning(100, 0., 2*TMath::Pi()), optionstring);
107  fHistos->CreateTH3("hPtEtaPhiEMCALCent" + trg, "p_{t}-#eta-#phi distribution of all accepted tracks pointing to the EMCAL for trigger " + trg + "; p_{t} (GeV/c); #eta; #phi", newbinning, TLinearBinning(64, -0.8, 0.8), TLinearBinning(100, 0., 2*TMath::Pi()), optionstring);
108 
109  for(const auto c : charges){
110  fHistos->CreateTH3("hPtEtaPhiAll" + c + trg, "p_{t}-#eta-#phi distribution of " + c + " accepted tracks for trigger " + trg + " ; p_{t} (GeV/c); #eta; #phi", newbinning, TLinearBinning(64, -0.8, 0.8), TLinearBinning(100, 0., 2*TMath::Pi()), optionstring);
111  fHistos->CreateTH3("hPtEtaPhiEMCALAll" + c + trg, "p_{t}-#eta-#phi distribution of " + c + " accepted tracks pointing to the EMCAL for trigger " + trg + "; p_{t} (GeV/c); #eta; #phi", newbinning, TLinearBinning(64, -0.8, 0.8), TLinearBinning(100, 0., 2*TMath::Pi()), optionstring);
112  fHistos->CreateTH3("hPtEtaPhiCent" + c + trg, "p_{t}-#eta-#phi distribution of " + c + " accepted tracks for trigger " + trg + "; p_{t} (GeV/c); #eta; #phi", newbinning, TLinearBinning(64, -0.8, 0.8), TLinearBinning(100, 0., 2*TMath::Pi()), optionstring);
113  fHistos->CreateTH3("hPtEtaPhiEMCALCent" + c + trg, "p_{t}-#eta-#phi distribution of " + c + " accepted tracks pointing to the EMCAL for trigger " + trg + "; p_{t} (GeV/c); #eta; #phi", newbinning, TLinearBinning(64, -0.8, 0.8), TLinearBinning(100, 0., 2*TMath::Pi()), optionstring);
114  }
115 
116  if(fStudyPID){
117  fHistos->CreateTH2(Form("hTPCdEdxEMCAL%s", trg.Data()), Form("TPC dE/dx of charged particles in the EMCAL region for trigger %s", trg.Data()), 400, -20., 20., 200, 0., 200., optionstring);
118  fHistos->CreateTH2(Form("hTOFBetaEMCAL%s", trg.Data()), Form("TOF beta of charged particles in the EMCAL region for trigger %s", trg.Data()), 400, -20., 20., 150, 0., 1.5, optionstring);
119  fHistos->CreateTHnSparse(Form("hPIDcorrEMCAL%s", trg.Data()), Form("Correlation of PID observables for Trigger %s", trg.Data()), kdimPID, knbinsPID, kminPID, kmaxPID, optionstring);
120  }
121  }
122 }
123 
125  Bool_t hasPIDresponse = fInputHandler->GetPIDResponse() != nullptr;
126  if(fStudyPID && !hasPIDresponse) AliErrorStream() << "PID requested but PID response not available" << std::endl;
127 
128 
129  // Loop over tracks, fill select particles
130  // Histograms
131  // - Full eta_{lab} (-0.8, 0.8), new binning
132  // - Full eta_{lab} (-0.8, 0.8), old binning
133  // - Eta distribution for tracks above 1, 2, 5, 10 GeV/c without eta cut
134  // - Central eta_{cms} (-0.3, -0.2), new binning,
135  // - Central eta_{cms} (-0.8, -0.2), old binning,
136  // - Eta distribution for tracks above 1, 2, 5, 10 GeV/c
137  // - Eta distribution for tracks above 1, 2, 5, 10 GeV/c with eta cut
138  AliVTrack *checktrack(nullptr);
139  int ptmin[5] = {1,2,5,10,20}; // for eta distributions
140  Bool_t isEMCAL(kFALSE);
141  Double_t etaEMCAL(0.), phiEMCAL(0.);
142  for(int itrk = 0; itrk < fInputEvent->GetNumberOfTracks(); ++itrk){
143  checktrack = dynamic_cast<AliVTrack *>(fInputEvent->GetTrack(itrk));
144  if(!checktrack) continue;
145  if(!fEtaLabCut.IsInRange(checktrack->Eta())) continue;
146  if(!fPhiCut.IsInRange(checktrack->Phi())) continue;
147  if(TMath::Abs(checktrack->Pt()) < 0.1) continue;
148  if(checktrack->IsA() == AliESDtrack::Class()){
149  AliESDtrack copytrack(*(static_cast<AliESDtrack *>(checktrack)));
150  AliEMCALRecoUtils::ExtrapolateTrackToEMCalSurface(&copytrack);
151  etaEMCAL = copytrack.GetTrackEtaOnEMCal();
152  phiEMCAL = copytrack.GetTrackPhiOnEMCal();
153  } else {
154  AliAODTrack copytrack(*(static_cast<AliAODTrack *>(checktrack)));
155  AliEMCALRecoUtils::ExtrapolateTrackToEMCalSurface(&copytrack);
156  etaEMCAL = copytrack.GetTrackEtaOnEMCal();
157  phiEMCAL = copytrack.GetTrackPhiOnEMCal();
158  }
159  Int_t supermoduleID = -1;
160  isEMCAL = fGeom->SuperModuleNumberFromEtaPhi(etaEMCAL, phiEMCAL, supermoduleID);
161  // Exclude supermodules 10 and 11 as they did not participate in the trigger
162  isEMCAL = isEMCAL && supermoduleID < 10;
163 
164  // Calculate eta in cms frame according
165  // EPJC74 (2014) 3054:
166  // eta_cms = - eta_lab - |yshift|
167  Double_t etacent = -1. * checktrack->Eta() - TMath::Abs(fYshift);
168  etacent *= fEtaSign;
169 
170  if(!fEtaCmsCut.IsInRange(etacent)) continue; // Apply eta-cent cut
171  if(!fTrackCuts->IsTrackAccepted(checktrack)) continue;
172 
173  // Charge separation
174  bool posCharge = checktrack->Charge() > 0;
175 
176  for(const auto &t : fSelectedTriggers){
177  FillTrackHistos(t, posCharge, checktrack->Pt(), checktrack->Eta() * fEtaSign, etacent, checktrack->Phi(), isEMCAL);
178  if(fStudyPID && hasPIDresponse)
179  if(isEMCAL) FillPIDHistos(t, *checktrack);
180  }
181  }
182  return true;
183 }
184 
186  // Apply vertex z cut
187  for(const auto &t : fSelectedTriggers){
188  Double_t weight = GetTriggerWeight(t);
189  fHistos->FillTH1(Form("hVertexBefore%s", t.Data()), fVertex[2], weight);
190  }
191 }
192 
194  for(const auto &t : fSelectedTriggers) {
195  Double_t weight = GetTriggerWeight(t);
196  // Fill Event counter and reference vertex distributions after event selection
197  fHistos->FillTH1(Form("hEventCount%s", t.Data()), 1, weight);
198  fHistos->FillTH1(Form("hVertexAfter%s", t.Data()), fVertex[2], weight);
199  }
200 }
201 
203  const TString &eventclass,
204  Bool_t posCharge,
205  Double_t pt,
206  Double_t etalab,
207  Double_t etacent,
208  Double_t phi,
209  Bool_t inEmcal
210  )
211 {
212  Double_t weight = GetTriggerWeight(eventclass);
213  TString chargelabel = posCharge ? "Pos" : "Neg";
214  AliDebugStream(1) << GetName() << ": Using weight " << weight << " for trigger " << eventclass << " in particle histograms." << std::endl;
215  double kinepointall[3] = {TMath::Abs(pt), etalab, phi}, kinepointcent[3] = {TMath::Abs(pt), etacent, phi};
216  fHistos->FillTH3("hPtEtaPhiAll" + eventclass, kinepointall, weight);
217  fHistos->FillTH3("hPtEtaPhiCent" + eventclass, kinepointcent, weight);
218  fHistos->FillTH3("hPtEtaPhiAll" + chargelabel + eventclass, kinepointall, weight);
219  fHistos->FillTH3("hPtEtaPhiCent" + chargelabel + eventclass, kinepointcent, weight);
220  if(inEmcal){
221  fHistos->FillTH3("hPtEtaPhiEMCALAll" + eventclass, kinepointall, weight);
222  fHistos->FillTH3("hPtEtaPhiEMCALCent" + eventclass, kinepointall, weight);
223  fHistos->FillTH3("hPtEtaPhiEMCALAll" + chargelabel + eventclass, kinepointall, weight);
224  fHistos->FillTH3("hPtEtaPhiEMCALCent" + chargelabel + eventclass, kinepointall, weight);
225  }
226 }
227 
229  const TString &eventclass,
230  const AliVTrack &trk
231 ) {
232  Double_t weight = GetTriggerWeight(eventclass);
233  AliDebugStream(1) << GetName() << ": Using weight " << weight << " for trigger " << eventclass << " in PID histograms." << std::endl;
234  AliPIDResponse *pid = fInputHandler->GetPIDResponse();
235  if(TMath::Abs(trk.Eta()) > 0.5) return;
236  if(!((trk.GetStatus() & AliVTrack::kTOFout) && (trk.GetStatus() & AliVTrack::kTIME))) return;
237 
238  double poverz = TMath::Abs(trk.P())/static_cast<double>(trk.Charge());
239  fHistos->FillTH2("hTPCdEdxEMCAL" + eventclass, poverz, trk.GetTPCsignal(), weight);
240  // correct for units - TOF in ps, track length in cm
241  Double_t trtime = (trk.GetTOFsignal() - pid->GetTOFResponse().GetTimeZero()) * 1e-12;
242  Double_t v = trk.GetIntegratedLength()/(100. * trtime);
243  Double_t beta = v / TMath::C();
244  fHistos->FillTH2("hTOFBetaEMCAL" + eventclass, poverz, beta, weight);
245  double datapoint[3] = {poverz, trk.GetTPCsignal(), beta};
246  fHistos->FillTHnSparse("hPIDcorrEMCAL" + eventclass, datapoint, weight);
247 }
248 
251 }
252 
254  AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager();
255 
256  TString taskname = "chargedParticleQA_" + suffix;
257 
259  mgr->AddTask(task);
260 
261  TString outfile(mgr->GetCommonFileName());
262  outfile += ":ChargedParticleQA_" + suffix;
263  TString containername = "TrackResults_" + suffix;
264 
265  task->ConnectInput(0, mgr->GetCommonInputContainer());
266  mgr->ConnectOutput(task, 1, mgr->CreateContainer(containername.Data(), TList::Class(), AliAnalysisManager::kOutputContainer, outfile.Data()));
267 
268  return task;
269 }
270 
272  AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager();
273 
275  mgr->AddTask(task);
276 
277  // Set Energy thresholds for additional patch selection:
278  // These are events with offline patches of a given type where the trigger reached already the plateau
279  // These numers are determined as:
280  // EMC7: 5 GeV
281  // EG1: 14 GeV
282  // EG2: 8 GeV
283  // EJ1: 22 GeV
284  // EJ2: 12 GeV
285  mgr->AddTask(task);
288  );
291  cutname,
292  mgr->GetInputEventHandler()->IsA() == AliAODInputHandler::Class()
293  )
294  );
295 
296  TString outfile(mgr->GetCommonFileName());
297  outfile += ":ChargedParticleQA_%s" + cutname;
298 
299  task->ConnectInput(0, mgr->GetCommonInputContainer());
300  mgr->ConnectOutput(task, 1, mgr->CreateContainer(Form("TrackResults_%s", cutname.Data()), TList::Class(), AliAnalysisManager::kOutputContainer, outfile.Data()));
301 
302  return task;
303 }
304 
307 {
308  this->SetMinimum(0.);
309  this->AddStep(1, 0.05);
310  this->AddStep(2, 0.1);
311  this->AddStep(4, 0.2);
312  this->AddStep(7, 0.5);
313  this->AddStep(16, 1);
314  this->AddStep(36, 2);
315  this->AddStep(40, 4);
316  this->AddStep(50, 5);
317  this->AddStep(100, 10);
318  this->AddStep(200, 20);
319 }
320 
321 } /* namespace EMCalTriggerPtAnalysis */
std::vector< TString > fSelectedTriggers
! Triggers selected for given event
double Double_t
Definition: External.C:58
Double_t fEtaSign
Sign of the eta distribution (swaps when beam directions swap): p-Pb: +1, Pb-p: -1.
Class creating a linear binning, used in the histogram manager.
static AliAnalysisTaskChargedParticlesRef * AddTaskChargedParticlesRef(const TString &suffix)
void FillTH2(const char *hname, double x, double y, double weight=1., Option_t *opt="")
void FillTH3(const char *hname, double x, double y, double z, double weight=1., Option_t *opt="")
TCanvas * c
Definition: TestFitELoss.C:172
void AddStep(Double_t max, Double_t binwidth)
void SetOfflineTriggerSelection(AliEmcalTriggerOfflineSelection *sel)
Set an offline trigger selection.
void SetCaloTriggerPatchInfoName(const char *n)
static AliEmcalTrackSelection * TrackCutsFactory(TString name, Bool_t isAOD)
Fully-configure EMCAL track selection independent of the data type.
void FillTHnSparse(const char *name, const double *x, double weight=1., Option_t *opt="")
static AliAnalysisTaskChargedParticlesRef * AddTaskChargedParticlesRefDefault(const TString &cutname="standard")
TH2 * CreateTH2(const char *name, const char *title, int nbinsx, double xmin, double xmax, int nbinsy, double ymin, double ymax, Option_t *opt="")
int Int_t
Definition: External.C:63
AliEMCALGeometry * fGeom
!emcal geometry
void FillTrackHistos(const TString &eventclass, Bool_t posCharge, Double_t pt, Double_t eta, Double_t etacent, Double_t phi, Bool_t inEmcal)
TH1 * CreateTH1(const char *name, const char *title, int nbins, double xmin, double xmax, Option_t *opt="")
Helper class creating user defined custom binning.
const Double_t ptmin
void FillTH1(const char *hname, double x, double weight=1., Option_t *opt="")
Declaration of class AliEMCalTriggerExtraCuts.
ClassImp(AliAnalysisTaskCRC) AliAnalysisTaskCRC
Double_t fVertex[3]
!event vertex
void FillPIDHistos(const TString &eventclass, const AliVTrack &track)
void SetNeedEmcalGeom(Bool_t n)
bool Bool_t
Definition: External.C:53
THnSparse * CreateTHnSparse(const char *name, const char *title, int ndim, const int *nbins, const double *min, const double *max, Option_t *opt="")
static AliEmcalTriggerOfflineSelection * TriggerSelectionFactory(Double_t el0, Double_t eg1, Double_t eg2, Double_t ej1, Double_t ej2, AliEmcalTriggerOfflineSelection::EmcalEnergyDefinition_t endef=AliEmcalTriggerOfflineSelection::kFEEEnergy)
Configures EMCAL trigger offline selection used to restrict EMCAL triggered sample.
TH3 * CreateTH3(const char *name, const char *title, int nbinsx, double xmin, double xmax, int nbinsy, double ymin, double ymax, int nbinsz, double zmin, double zmax, Option_t *opt="")
virtual bool IsTrackAccepted(AliVTrack *const trk)=0
void SetMinimum(Double_t min)