AliPhysics  4e47bdd (4e47bdd)
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
AliAnalysisTaskFlavourJetCorrelations.cxx
Go to the documentation of this file.
1 /**************************************************************************
2 * Copyright(c) 1998-2009, 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 //
17 // Analysis Taks for reconstructed particle correlation
18 // (first implementation done for D mesons) with jets
19 // (use the so called Emcal framework)
20 //
21 //-----------------------------------------------------------------------
22 // Authors:
23 // C. Bianchin (Utrecht University) chiara.bianchin@cern.ch
24 // S. Antônio (University of São Paulo) antonio.silva@cern.ch
25 // A. Grelli (Utrecht University) a.grelli@uu.nl
26 // X. Zhang (LBNL) XMZhang@lbl.gov
27 //-----------------------------------------------------------------------
28 
29 #include <TDatabasePDG.h>
30 #include <TParticle.h>
31 #include "TROOT.h"
32 #include <THnSparse.h>
33 #include <TSystem.h>
34 #include <TObjectTable.h>
35 #include "AliMultSelection.h"
36 
38 #include "AliAODHandler.h"
39 #include "AliAnalysisManager.h"
40 #include "AliEmcalJet.h"
41 #include "AliJetContainer.h"
42 #include "AliAODRecoDecay.h"
43 #include "AliAODRecoCascadeHF.h"
45 #include "AliAODMCParticle.h"
46 #include "AliRDHFCutsD0toKpi.h"
48 #include "AliParticleContainer.h"
49 #include "AliEmcalParticle.h"
50 #include "AliLocalRhoParameter.h"
52 
54 
55 
56 //_______________________________________________________________________________
57 
60 fUseMCInfo(kTRUE),
61 fUseReco(kTRUE),
62 fCandidateType(),
63 fCorrelationMethod(),
64 fPDGmother(),
65 fNProngs(),
66 fPDGdaughters(),
67 fBranchName(),
68 fCuts(0),
69 fMinMass(),
70 fMaxMass(),
71 fCandidateArray(0),
72 fSideBandArray(0),
73 fAnalyseDBkg(kFALSE),
74 fBuildRM(kFALSE),
75 fNAxesBigSparse(9),
76 fUseCandArray(kFALSE),
77 fUseSBArray(kFALSE),
78 fhstat(),
79 fhCentDjet(),
80 fhPtJetTrks(),
81 fhPhiJetTrks(),
82 fhEtaJetTrks(),
83 fhPtJet(),
84 fhPhiJet(),
85 fhEtaJet(),
86 fhInvMassptD(),
87 fhDiffSideBand(),
88 fhInvMassptDbg(),
89 fhPtPion(),
90 fhsDphiz(),
91 fResponseMatrix()
92 
93 {
94  //
95  // Default ctor
96 }
97 
98 //_______________________________________________________________________________
99 
101 AliAnalysisTaskEmcalJet(name,kTRUE),
102 fUseMCInfo(kTRUE),
103 fUseReco(kTRUE),
104 fCandidateType(),
105 fCorrelationMethod(),
106 fPDGmother(),
107 fNProngs(),
108 fPDGdaughters(),
109 fBranchName(),
110 fCuts(0),
111 fMinMass(),
112 fMaxMass(),
113 fCandidateArray(0),
114 fSideBandArray(0),
115 fAnalyseDBkg(kFALSE),
116 fBuildRM(kFALSE),
117 fNAxesBigSparse(9),
118 fUseCandArray(kFALSE),
119 fUseSBArray(kFALSE),
120 fhstat(),
121 fhCentDjet(),
122 fhPtJetTrks(),
123 fhPhiJetTrks(),
124 fhEtaJetTrks(),
125 fhPtJet(),
126 fhPhiJet(),
127 fhEtaJet(),
128 fhInvMassptD(),
129 fhDiffSideBand(),
130 fhInvMassptDbg(),
131 fhPtPion(),
132 fhsDphiz(),
133 fResponseMatrix()
134 {
135  //
136  // Constructor. Initialization of Inputs and Outputs
137  //
138 
139  Info("AliAnalysisTaskFlavourJetCorrelations","Calling Constructor");
140  fCuts=cuts;
141  fCandidateType=candtype;
142  const Int_t nptbins=fCuts->GetNPtBins();
143  Float_t defaultSigmaD013[20]={0.012, 0.012, 0.012, 0.015, 0.015,0.018,0.018,0.020,0.020,0.030,0.030,0.037,0.040,0.040,0.040,0.040,0.040,0.040,0.040,0.040};
144 
145  switch(fCandidateType){
146  case 0:
147  fPDGmother=421;
148  fNProngs=2;
149  fPDGdaughters[0]=211;//pi
150  fPDGdaughters[1]=321;//K
151  fPDGdaughters[2]=0; //empty
152  fPDGdaughters[3]=0; //empty
153  fBranchName="D0toKpi";
154  break;
155  case 1:
156  fPDGmother=413;
157  fNProngs=3;
158  fPDGdaughters[1]=211;//pi soft
159  fPDGdaughters[0]=421;//D0
160  fPDGdaughters[2]=211;//pi fromD0
161  fPDGdaughters[3]=321; // K from D0
162  fBranchName="Dstar";
163 
164  if(nptbins<20){
165  for(Int_t ipt=0;ipt<nptbins;ipt++) fSigmaD0[ipt]= defaultSigmaD013[ipt];
166  } else {
167  AliFatal(Form("Default sigma D0 not enough for %d pt bins, use SetSigmaD0ForDStar to set them",nptbins));
168  }
169  break;
170  default:
171  printf("%d not accepted!!\n",fCandidateType);
172  break;
173  }
174 
177  if(fUseCandArray) DefineInput(1, TClonesArray::Class());
178  if(fUseSBArray) DefineInput(2, TClonesArray::Class());
179 
180  DefineOutput(1,TList::Class()); // histos
181  DefineOutput(2,AliRDHFCuts::Class()); // my cuts
182 
183 }
184 
185 //_______________________________________________________________________________
186 
188  //
189  // destructor
190  //
191 
192  Info("~AliAnalysisTaskFlavourJetCorrelations","Calling Destructor");
193 
194  delete fCuts;
195 
196 }
197 
198 //_______________________________________________________________________________
199 
201  //
202  // Initialization
203  //
204 
205  if(fDebug > 1) printf("AnalysisTaskRecoJetCorrelations::Init() \n");
206 
207  switch(fCandidateType){
208  case 0:
209  {
210  AliRDHFCutsD0toKpi* copyfCuts=new AliRDHFCutsD0toKpi(*(static_cast<AliRDHFCutsD0toKpi*>(fCuts)));
211  copyfCuts->SetName("AnalysisCutsDzero");
212  // Post the data
213  PostData(2,copyfCuts);
214  }
215  break;
216  case 1:
217  {
218  AliRDHFCutsDStartoKpipi* copyfCuts=new AliRDHFCutsDStartoKpipi(*(static_cast<AliRDHFCutsDStartoKpipi*>(fCuts)));
219  copyfCuts->SetName("AnalysisCutsDStar");
220  // Post the cuts
221  PostData(2,copyfCuts);
222  }
223  break;
224  default:
225  return;
226  }
227 
228  return;
229 }
230 
231 //_______________________________________________________________________________
232 
234  // output
235  Info("UserCreateOutputObjects","CreateOutputObjects of task %s\n", GetName());
237 
238  // define histograms
239  // the TList fOutput is already defined in AliAnalysisTaskEmcal::UserCreateOutputObjects()
241  PostData(1,fOutput);
242 
243  return;
244 }
245 
246 //_______________________________________________________________________________
247 
249 {
250  // user exec from AliAnalysisTaskEmcal is used
251 
252  // Load the event
253  AliAODEvent* aodEvent = dynamic_cast<AliAODEvent*>(fInputEvent);
254 
255  Int_t matchingAODdeltaAODlevel = AliRDHFCuts::CheckMatchingAODdeltaAODevents();
256  if (matchingAODdeltaAODlevel<=0) {
257  // AOD/deltaAOD trees have different number of entries || TProcessID do not match while it was required
258  return kFALSE;
259  }
260 
261  TClonesArray *arrayDStartoD0pi=0;
262 
263  if (!aodEvent && AODEvent() && IsStandardAOD()) {
264 
265  // In case there is an AOD handler writing a standard AOD, use the AOD
266  // event in memory rather than the input (ESD) event.
267  aodEvent = dynamic_cast<AliAODEvent*> (AODEvent());
268 
269  // in this case the braches in the deltaAOD (AliAOD.VertexingHF.root)
270  // have to taken from the AOD event hold by the AliAODExtension
271  AliAODHandler* aodHandler = (AliAODHandler*)
272  ((AliAnalysisManager::GetAnalysisManager())->GetOutputEventHandler());
273  if(aodHandler->GetExtensions()) {
274  AliAODExtension *ext = (AliAODExtension*)aodHandler->GetExtensions()->FindObject("AliAOD.VertexingHF.root");
275  AliAODEvent *aodFromExt = ext->GetAOD();
276  arrayDStartoD0pi=(TClonesArray*)aodFromExt->GetList()->FindObject(fBranchName.Data());
277  }
278  } else if(aodEvent){
279  arrayDStartoD0pi=(TClonesArray*)aodEvent->GetList()->FindObject(fBranchName.Data());
280  }
281 
282  if (!arrayDStartoD0pi) {
283  AliInfo(Form("Could not find array %s, skipping the event",fBranchName.Data()));
284  // return;
285  } else AliDebug(2, Form("Found %d vertices",arrayDStartoD0pi->GetEntriesFast()));
286 
287  TClonesArray* mcArray = 0x0;
288  if (fUseMCInfo) { //not used at the moment,uncomment return if you use
289  mcArray = dynamic_cast<TClonesArray*>(aodEvent->FindListObject(AliAODMCParticle::StdBranchName()));
290  if (!mcArray) {
291  printf("AliAnalysisTaskSEDStarSpectra::UserExec: MC particles not found!\n");
292  }
293  }
294 
295  //D meson candidates. Also background if is MC
296 
297  if(fUseCandArray)
298  {
299  fCandidateArray = dynamic_cast<TClonesArray*>(GetInputData(1));
300  if (!fCandidateArray) return kFALSE;
301  for(Int_t icand=0; icand<fCandidateArray->GetEntriesFast(); icand++)
302  {
303  fhstat->Fill(2);
304  }
305  }
306  if(fUseSBArray)
307  {
308  fSideBandArray = dynamic_cast<TClonesArray*>(GetInputData(2));
309  if (!fSideBandArray) return kFALSE;
310  }
311 
312  fhstat->Fill(0);
313 
314  // fix for temporary bug in ESDfilter
315  // the AODs with null vertex pointer didn't pass the PhysSel
316  if(!aodEvent->GetPrimaryVertex() || TMath::Abs(aodEvent->GetMagneticField())<0.001) return kFALSE;
317 
318  //Event selection
319  Bool_t iseventselected=fCuts->IsEventSelected(aodEvent);
320  TString firedTriggerClasses=((AliAODEvent*)aodEvent)->GetFiredTriggerClasses();
321  if(!iseventselected) return kFALSE;
322 
323  fhstat->Fill(1);
324  if(aodEvent->GetRunNumber()>200000)
325  {
326  Float_t lPercentile = 300;
327  AliMultSelection *MultSelection = 0x0;
328  MultSelection = (AliMultSelection*)aodEvent->FindListObject("MultSelection");
329  if(!MultSelection) {
330  //If you get this warning (and lPercentiles 300) please check that the AliMultSelectionTask actually ran (before your task)
331  AliWarning("AliMultSelection object not found!");
332  }else{
333  lPercentile = MultSelection->GetMultiplicityPercentile("V0M");
334  }
335 
336  fhCentDjet->Fill(lPercentile);
337  }
338  else fhCentDjet->Fill(fCent);
339 
340  AliJetContainer* JetCont = GetJetContainer(0);
341  if(!JetCont) return kFALSE;
342  AliParticleContainer *ParticlesCont = JetCont->GetParticleContainer();
343 
344  AliJetContainer* JetContSB = 0;
345  AliParticleContainer *ParticlesContSB = 0;
346  if(fAnalyseDBkg)
347  {
348  JetContSB = GetJetContainer(1);
349  if(!JetContSB) return kFALSE;
350  ParticlesContSB = JetContSB->GetParticleContainer();
351  }
352 
353  //Distribution of all particles in the event
354  Int_t ntrarr=ParticlesCont->GetNParticles();
355  for(Int_t i=0;i<ntrarr;i++)
356  {
357  AliVParticle* jetTrk= ParticlesCont->GetParticle(i);
358  if (!jetTrk) continue;
359  AliEmcalParticle* emcpart = dynamic_cast<AliEmcalParticle*>(jetTrk);
360  if (emcpart) jetTrk = emcpart->GetTrack();
361  fhPtJetTrks->Fill(jetTrk->Pt());
362  fhPhiJetTrks->Fill(jetTrk->Phi());
363  fhEtaJetTrks->Fill(jetTrk->Eta());
364  }
365 
366  JetCont->ResetCurrentID();
367  AliEmcalJet* jet=0;
368 
369  while ((jet = JetCont->GetNextJet()))
370  {
371  UInt_t rejectionReason = 0;
372  Bool_t OKjet = JetCont->AcceptJet(jet, rejectionReason);
373  if(!OKjet) {
374  fhstat->Fill(5);
375  continue;
376  }
377 
378 
379  Double_t JetPtCorr = jet->Pt() - jet->Area()*JetCont->GetRhoVal(); //background subtraction
380  if(fLocalRho)
381  {
382  JetPtCorr = jet->Pt() - jet->Area()*fLocalRho->GetLocalVal(jet->Phi(),JetCont->GetJetRadius(),JetCont->GetRhoVal()); //
383  }
384 
385  fhstat->Fill(3); //Jet accepted
386  fhPhiJet->Fill(jet->Phi());
387  fhEtaJet->Fill(jet->Eta());
388  fhPtJet->Fill(JetPtCorr);
389  }
390 
391  if(ParticlesCont->GetNParticles()>0) fhstat->Fill(2);
392 
394  {
395  if(ParticlesCont->GetNParticles()>0) ConstituentCorrelationMethod(kFALSE,aodEvent);
396  if(fAnalyseDBkg==kTRUE && ParticlesContSB->GetNParticles()>0) ConstituentCorrelationMethod(kTRUE,aodEvent);
397  }
398 
399  else if(fCorrelationMethod==kAngular)
400  {
401  if(fCandidateArray->GetEntriesFast()>0) AngularCorrelationMethod(kFALSE,aodEvent);
402  if(fAnalyseDBkg==kTRUE && fSideBandArray->GetEntriesFast()>0) AngularCorrelationMethod(kTRUE,aodEvent);
403  }
404 
405  PostData(1,fOutput);
406  return kTRUE;
407 }
409 {
410 
411  AliJetContainer* JetCont = 0;
412 
413  if(!IsBkg) JetCont = GetJetContainer(0);
414  else JetCont = GetJetContainer(1);
415 
416  Double_t rho = 0;
417  if(!JetCont->GetRhoName().IsNull()) rho = JetCont->GetRhoVal();
418 
419  AliEmcalJet *jet;
420 
421  GetHFJet(jet,IsBkg);
422 
423  if(jet)
424  {
425  if(fLocalRho) rho = fLocalRho->GetLocalVal(jet->Phi(),JetCont->GetJetRadius(),JetCont->GetRhoVal());
426  FillDJetHistograms(jet,rho,IsBkg,aodEvent);
427  }
428 
429 }
431 {
432  AliJetContainer* JetCont = GetJetContainer(0);
433 
434  Int_t ncand = 0;
435  if(!IsBkg) ncand = fCandidateArray->GetEntriesFast();
436  else ncand = fSideBandArray->GetEntriesFast();
437 
438  Double_t rho = 0;
439  if(!JetCont->GetRhoName().IsNull()) rho = JetCont->GetRhoVal();
440 
441  for(Int_t icand = 0; icand<ncand; icand++)
442  {
443  AliVParticle* charm=0x0;
444  if(!IsBkg) charm = (AliVParticle*)fCandidateArray->At(icand);
445  else charm = (AliVParticle*)fSideBandArray->At(icand);
446  if(!charm) continue;
447 
448  Int_t JetTag = AliEmcalJet::kD0;
450  //loop over jets
451  JetCont->ResetCurrentID();
452  AliEmcalJet* jet=0;
453  while ((jet = JetCont->GetNextJet()))
454  {
455  UInt_t rejectionReason = 0;
456  Bool_t OKjet = JetCont->AcceptJet(jet, rejectionReason);
457  if(!OKjet) continue;
458 
459  if(fLocalRho) rho = fLocalRho->GetLocalVal(jet->Phi(),JetCont->GetJetRadius(),JetCont->GetRhoVal());
460 
461  if(DeltaR(jet,charm,rho)<JetCont->GetJetRadius() && CheckDeltaR(jet,charm)<JetCont->GetJetRadius())
462  {
463  if(!IsBkg) jet->AddFlavourTag(JetTag);
464  jet->AddFlavourTrack(charm);
465  FillDJetHistograms(jet,rho,IsBkg,aodEvent);
466  }
467  }
468  }
469 
470 }
471 
473 {
474  AliJetContainer* JetContRec = GetJetContainer(0);
475 
476  Double_t rho = JetContRec->GetRhoVal();
477 
478  AliEmcalJet* MCjet = 0;
479 
480  FindMCJet(MCjet);
481 
482  if(!jet) AliDebug(2, "No Reconstructed Level Jet Found!");
483  else if(!MCjet) AliDebug(2, "No Generated Level Jet Found!");
484  else
485  {
486  if(fLocalRho) rho = fLocalRho->GetLocalVal(jet->Phi(),JetContRec->GetJetRadius(),JetContRec->GetRhoVal());
487  AliVParticle *Drec = jet->GetFlavourTrack();
488  AliVParticle *Dgen = MCjet->GetFlavourTrack();
489  Double_t zRec = Z(Drec,jet,rho);
490  Double_t zGen = Z(Dgen,MCjet,0);
491  Double_t JetPtRec = jet->Pt() - rho*jet->Area();
492  Double_t fillRM[6] = {zRec,JetPtRec,Drec->Pt(),zGen,MCjet->Pt(),Dgen->Pt()};
493  fResponseMatrix->Fill(fillRM,1.);
494  }
495 }
496 
497 //_______________________________________________________________________________
498 
500 {
501 
502  AliVParticle *Dmeson = jet->GetFlavourTrack(0);
503  Double_t JetPtCorr = jet->Pt() - rho*jet->Area();
504  Double_t z = 0;
505  if(rho>0) z = Z(Dmeson,jet,rho);
506  else z = Z(Dmeson,jet);
507 
508  if(IsBkg==kFALSE && fBuildRM==kTRUE) CreateResponseMatrix(jet);
509 
510  Bool_t bDInEMCalAcc=InEMCalAcceptance(Dmeson);
511  Bool_t bJetInEMCalAcc=InEMCalAcceptance(jet);
512 
514  {
515  AliAODRecoDecayHF* dzero=(AliAODRecoDecayHF*)Dmeson;
516  FillHistogramsD0JetCorr(dzero,z,Dmeson->Pt(),JetPtCorr,IsBkg,bDInEMCalAcc,bJetInEMCalAcc,aodEvent);
517  }
518  else if(fCandidateType==kDstartoKpipi)
519  {
521  FillHistogramsDstarJetCorr(dstar,z,Dmeson->Pt(),JetPtCorr,IsBkg,bDInEMCalAcc,bJetInEMCalAcc);
522  }
523 
524 
525 }
526 
528 {
529  AliJetContainer* JetCont = 0;
530 
531  if(!IsBkg) JetCont = GetJetContainer(0);
532  else JetCont = GetJetContainer(1);
533 
534  AliParticleContainer *ParticlesCont = JetCont->GetParticleContainer();
535 
536  Bool_t JetIsHF = kFALSE;
537 
538  JetCont->ResetCurrentID();
539  while ((jet = JetCont->GetNextJet()))
540  {
541  UInt_t rejectionReason = 0;
542  Bool_t OKjet = JetCont->AcceptJet(jet, rejectionReason);
543  if(!OKjet) continue;
544 
545  Int_t JetTag = AliEmcalJet::kD0;
546  TString recoDecayClassName("AliAODRecoDecayHF2Prong");
548  {
549  JetTag = AliEmcalJet::kDStar;
550  recoDecayClassName = "AliAODRecoCascadeHF";
551  }
552  //loop on jet particles
553  Int_t ntrjet= jet->GetNumberOfTracks();
554  for(Int_t itrk=0;itrk<ntrjet;itrk++)
555  {
556  AliVParticle* jetTrk=jet->TrackAt(itrk,ParticlesCont->GetArray());
557  if(!jetTrk) continue;
558  AliEmcalParticle* emcpart = dynamic_cast<AliEmcalParticle*>(jetTrk);
559  if(emcpart) jetTrk = emcpart->GetTrack();
560  if(strcmp(jetTrk->ClassName(),recoDecayClassName)==0)
561  {
562  JetIsHF = kTRUE;
563  if(!IsBkg) jet->AddFlavourTag(JetTag);
564  jet->AddFlavourTrack(jetTrk);
565  break;
566  }
567  } //end loop on jet tracks
568  if(JetIsHF) break;
569  } //end of jet loop
570 
571  if(!JetIsHF) jet = 0;
572 
573 }
574 //_______________________________________________________________________________
575 
577 {
578  Bool_t HFMCjet = kFALSE;
579 
580  AliJetContainer* mcjets = 0;
581 
582  if(!fAnalyseDBkg) mcjets = GetJetContainer(1);
583  else mcjets = GetJetContainer(2);
584 
585  AliParticleContainer *ParticlesCont = mcjets->GetParticleContainer();
586  mcjets->ResetCurrentID();
587 
588  Int_t njet=0;
589 
590  while ((mcjet = mcjets->GetNextAcceptJet()))
591  {
592  njet++;
593  //loop on jet particles
594  Int_t ntrjet= mcjet->GetNumberOfTracks();
595 
596  for(Int_t itrk=0;itrk<ntrjet;itrk++)
597  {
598  AliAODMCParticle* jetTrk=(AliAODMCParticle*)mcjet->TrackAt(itrk,ParticlesCont->GetArray());
599 
600  if(TMath::Abs(jetTrk->GetPdgCode())==fPDGmother)
601  {
602  HFMCjet=kTRUE;
603  mcjet->AddFlavourTrack(jetTrk);
604  break;
605  }
606  } //end loop on jet tracks
607  if(HFMCjet==kTRUE) break;
608  }
609 
610  if(!HFMCjet) mcjet=0;
611 }
612 
613 //_______________________________________________________________________________
614 
616 {
617  // The Terminate() function is the last function to be called during
618  // a query. It always runs on the client, it can be used to present
619  // the results graphically or save the results to file.
620 
621  Info("Terminate"," terminate");
622  AliAnalysisTaskSE::Terminate();
623 
624  fOutput = dynamic_cast<AliEmcalList*> (GetOutputData(1));
625  if (!fOutput) {
626  printf("ERROR: fOutput not available\n");
627  return;
628  }
629 }
630 
631 //_______________________________________________________________________________
632 
634  Float_t mass=0;
635  Int_t abspdg=TMath::Abs(pdg);
636 
637  mass=TDatabasePDG::Instance()->GetParticle(abspdg)->Mass();
638  // compute the Delta mass for the D*
640  Float_t mass1=0;
641  mass1=TDatabasePDG::Instance()->GetParticle(421)->Mass();
642  mass = mass-mass1;
643  }
644 
645  fMinMass = mass-range;
646  fMaxMass = mass+range;
647 
648  AliInfo(Form("Setting mass limits to %f, %f",fMinMass,fMaxMass));
649  if (fMinMass<0 || fMaxMass<=0 || fMaxMass<fMinMass) AliFatal("Wrong mass limits!\n");
650 }
651 
652 //_______________________________________________________________________________
653 
655  if(uplimit>lowlimit)
656  {
657  fMinMass = lowlimit;
658  fMaxMass = uplimit;
659  }
660  else{
661  printf("Error! Lower limit larger than upper limit!\n");
662  fMinMass = uplimit - uplimit*0.2;
663  fMaxMass = uplimit;
664  }
665 }
666 
667 //_______________________________________________________________________________
668 
670  if(nptbins>30) {
671  AliInfo("Maximum number of bins allowed is 30!");
672  return kFALSE;
673  }
674  if(!width) return kFALSE;
675  for(Int_t ipt=0;ipt<nptbins;ipt++) fSigmaD0[ipt]=width[ipt];
676  return kTRUE;
677 }
678 
679 //_______________________________________________________________________________
680 
682 
683  Double_t p[3],pj[3];
684  Bool_t okpp=part->PxPyPz(p);
685  Bool_t okpj=jet->PxPyPz(pj);
686 
687  if(!okpp || !okpj)
688  {
689  printf("Problems getting momenta\n");
690  return -999;
691  }
692 
693  //Background Subtraction
694  //It corrects the each component of the jet momentum for Z calculation
695 
696  pj[0] = jet->Px() - jet->Area()*(rho*TMath::Cos(jet->AreaPhi()));
697  pj[1] = jet->Py() - jet->Area()*(rho*TMath::Sin(jet->AreaPhi()));
698  pj[2] = jet->Pz() - jet->Area()*(rho*TMath::SinH(jet->AreaEta()));
699 
700  return Z(p,pj);
701 }
702 //_______________________________________________________________________________
703 
705 
706  Double_t p[3],pj[3];
707  Bool_t okpp=part->PxPyPz(p);
708  Bool_t okpj=jet->PxPyPz(pj);
709 
710  if(!okpp || !okpj)
711  {
712  printf("Problems getting momenta\n");
713  return -999;
714  }
715 
716  return Z(p,pj);
717 }
718 //_______________________________________________________________________________
720 
721  Double_t pjet2=pj[0]*pj[0]+pj[1]*pj[1]+pj[2]*pj[2];
722  Double_t z=(p[0]*pj[0]+p[1]*pj[1]+p[2]*pj[2])/(pjet2);
723  return z;
724 }
725 
726 
727 //_______________________________________________________________________________
729 
730  Double_t pjet2=pj[0]*pj[0]+pj[1]*pj[1];
731  Double_t z=(p[0]*pj[0]+p[1]*pj[1])/(pjet2);
732  return z;
733 }
734 
735 //_______________________________________________________________________________
736 
738 
739  // Statistics
740  Int_t nbins=8;
741  if(fUseMCInfo) nbins+=2;
742 
743  fhstat=new TH1I("hstat","Statistics",nbins,-0.5,nbins-0.5);
744  fhstat->GetXaxis()->SetBinLabel(1,"N ev anal");
745  fhstat->GetXaxis()->SetBinLabel(2,"N ev sel");
746  fhstat->GetXaxis()->SetBinLabel(3,"N cand sel");
747  fhstat->GetXaxis()->SetBinLabel(4,"N jets");
748  fhstat->GetXaxis()->SetBinLabel(5,"N cand in jet");
749  fhstat->GetXaxis()->SetBinLabel(6,"N jet rej");
750  fhstat->GetXaxis()->SetBinLabel(7,"N cand sel & !jet");
751  fhstat->GetXaxis()->SetBinLabel(8,"N jets & cand");
752  if(fUseMCInfo) {
753  fhstat->GetXaxis()->SetBinLabel(3,"N Signal sel & jet");
754  fhstat->GetXaxis()->SetBinLabel(5,"N Signal in jet");
755  fhstat->GetXaxis()->SetBinLabel(9,"N Bkg sel & jet");
756  fhstat->GetXaxis()->SetBinLabel(10,"N Bkg in jet");
757  }
758  fhstat->SetNdivisions(1);
759  fOutput->Add(fhstat);
760 
761  fhCentDjet=new TH1F("hCentDjet","Centrality",100,0,100);
762  fOutput->Add(fhCentDjet);
763 
764  const Int_t nbinsmass=300;
765  const Int_t nbinspttrack=500;
766  Int_t nbinsptjet=200;
767  const Int_t nbinsptD=100;
768  const Int_t nbinsphi=200;
769  const Int_t nbinseta=100;
770 
771  //binning for THnSparse
772  const Int_t nbinsSpsmass=120;
773  const Int_t nbinsSpsptjet=200;
774  const Int_t nbinsSpsptD=100;
775  const Int_t nbinsSpsz=160;
776 
777  const Float_t pttracklims[2]={0.,200.};
778  Float_t ptjetlims[2]={-50.,150.};
779  const Float_t ptDlims[2]={0.,50.};
780  const Float_t zlims[2]={-1.2,2};
781  const Float_t philims[2]={0.,6.3};
782  const Float_t etalims[2]={-1.5,1.5};
783 
784  // jet related fistograms
785 
786  fhPhiJetTrks = new TH1F("hPhiJetTrks","Jet tracks #phi distribution; #phi (rad)", nbinsphi,philims[0],philims[1]);
787  fhPhiJetTrks->Sumw2();
788  fhEtaJetTrks = new TH1F("hEtaJetTrks","Jet tracks #eta distribution; #eta", nbinseta,etalims[0],etalims[1]);
789  fhEtaJetTrks->Sumw2();
790  fhPtJetTrks = new TH1F("hPtJetTrks", "Jet tracks Pt distribution; p_{T} (GeV/c)",nbinspttrack,pttracklims[0],pttracklims[1]);
791  fhPtJetTrks->Sumw2();
792 
793  fhPhiJet = new TH1F("hPhiJet","Jet #phi distribution; #phi (rad)", nbinsphi,philims[0],philims[1]);
794  fhPhiJet->Sumw2();
795  fhEtaJet = new TH1F("hEtaJet","Jet #eta distribution; #eta", nbinseta,etalims[0],etalims[1]);
796  fhEtaJet->Sumw2();
797  fhPtJet = new TH1F("hPtJet", "Jet Pt distribution; p_{T} (GeV/c)",nbinsptjet,ptjetlims[0],ptjetlims[1]);
798  fhPtJet->Sumw2();
799 
800  fOutput->Add(fhPhiJetTrks);
801  fOutput->Add(fhEtaJetTrks);
802  fOutput->Add(fhPtJetTrks);
803  fOutput->Add(fhPhiJet);
804  fOutput->Add(fhEtaJet);
805  fOutput->Add(fhPtJet);
806 
808  {
809  if(fAnalyseDBkg){
810  fhDiffSideBand = new TH2F("hDiffSideBand","M(kpipi)-M(kpi) Side Band Background",nbinsmass,fMinMass,fMaxMass,nbinsptD, ptDlims[0],ptDlims[1]);
811  fhDiffSideBand->SetStats(kTRUE);
812  fhDiffSideBand->GetXaxis()->SetTitle("M(kpipi)-M(Kpi) GeV");
813  fhDiffSideBand->GetYaxis()->SetTitle("p_{t}^{D} (GeV/c)");
814  fhDiffSideBand->Sumw2();
815  fOutput->Add(fhDiffSideBand);
816  }
817 
818  fhPtPion = new TH1F("hPtPion","Primary pions candidates pt ",500,0,10);
819  fhPtPion->SetStats(kTRUE);
820  fhPtPion->GetXaxis()->SetTitle("GeV/c");
821  fhPtPion->GetYaxis()->SetTitle("Entries");
822  fhPtPion->Sumw2();
823  fOutput->Add(fhPtPion);
824 
825  }
826 
827 
828  fhInvMassptD = new TH2F("hInvMassptD","D (Delta R < Rjet) invariant mass distribution p_{T}^{j} > threshold",nbinsmass,fMinMass,fMaxMass,nbinsptD,ptDlims[0],ptDlims[1]);
829  fhInvMassptD->SetStats(kTRUE);
830  fhInvMassptD->GetXaxis()->SetTitle("mass (GeV)");
831  fhInvMassptD->GetYaxis()->SetTitle("#it{p}_{t}^{D} (GeV/c)");
832  fhInvMassptD->Sumw2();
833 
834  fOutput->Add(fhInvMassptD);
835 
836  if(fUseMCInfo){
837  fhInvMassptDbg = new TH2F("hInvMassptDbg","Background D (Delta R < Rjet) invariant mass distribution p_{T}^{j} > threshold",nbinsmass,fMinMass,fMaxMass,nbinsptD,ptDlims[0],ptDlims[1]);
838  fhInvMassptDbg->GetXaxis()->SetTitle(Form("%s (GeV)",(fCandidateType==kDstartoKpipi) ? "M(Kpipi)" : "M(Kpi)"));
839  fhInvMassptDbg->GetYaxis()->SetTitle("p_{t}^{D} (GeV/c)");
840  fhInvMassptDbg->Sumw2();
841  fOutput->Add(fhInvMassptDbg);
842 
843  }
844 
845  fhsDphiz=0x0; //definition below according to the switches
846 
847  if(fUseMCInfo){
848  AliInfo("Creating a 7 axes container (MB background candidates)");
849  const Int_t nAxis=7;
850  const Int_t nbinsSparse[nAxis]={nbinsSpsz,nbinsSpsptjet,nbinsSpsptD,nbinsSpsmass,2, 2, 2};
851  const Double_t minSparse[nAxis]={zlims[0],ptjetlims[0],ptDlims[0],fMinMass, -0.5,-0.5,-0.5};
852  const Double_t maxSparse[nAxis]={zlims[1],ptjetlims[1],ptDlims[1],fMaxMass, 1.5, 1.5 , 1.5};
853  fNAxesBigSparse=nAxis;
854  fhsDphiz=new THnSparseF("hsDphiz","Z, p_{T}^{jet}, p_{T}^{D}, mass. Bkg?, D in EMCal acc?, jet in EMCal acc?", nAxis, nbinsSparse, minSparse, maxSparse);
855 
856  } else{
857  AliInfo("Creating a 4 axes container");
858  const Int_t nAxis=4;
859  const Int_t nbinsSparse[nAxis]={nbinsSpsz,nbinsSpsptjet,nbinsSpsptD,nbinsSpsmass};
860  const Double_t minSparse[nAxis]={zlims[0],ptjetlims[0],ptDlims[0],fMinMass};
861  const Double_t maxSparse[nAxis]={zlims[1],ptjetlims[1],ptDlims[1],fMaxMass};
862  fNAxesBigSparse=nAxis;
863 
864  fhsDphiz=new THnSparseF("hsDphiz","Z, p_{T}^{jet}, p_{T}^{D}, mass.", nAxis, nbinsSparse, minSparse, maxSparse);
865  }
866 
867  if(!fhsDphiz) AliFatal("No THnSparse created");
868  fhsDphiz->Sumw2();
869 
870  fOutput->Add(fhsDphiz);
871 
872  if(fBuildRM==kTRUE)
873  {
874  const Int_t RMnbins[6] = {nbinsSpsz,nbinsSpsptjet,nbinsSpsptD,nbinsSpsz,nbinsSpsptjet,nbinsSpsptD};
875  const Double_t RMmin[6]={zlims[0],ptjetlims[0],ptDlims[0],zlims[0],ptjetlims[0],ptDlims[0]};
876  const Double_t RMmax[6]={zlims[1],ptjetlims[1],ptDlims[1],zlims[1],ptjetlims[1],ptDlims[1]};
877  fResponseMatrix = new THnSparseF("ResponseMatrix","z, jet pt, D pt: Rec and Gen",6,RMnbins,RMmin,RMmax);
878  fResponseMatrix->Sumw2();
879  fOutput->Add(fResponseMatrix);
880  }
881 
882  PostData(1, fOutput);
883 
884  return kTRUE;
885 }
886 
887 //_______________________________________________________________________________
888 
890 
891 
892  Double_t masses[2]={0.,0.};
893  Int_t pdgdaughtersD0[2]={211,321};//pi,K
894  Int_t pdgdaughtersD0bar[2]={321,211};//K,pi
895 
896  masses[0]=candidate->InvMass(fNProngs,(UInt_t*)pdgdaughtersD0); //D0
897  masses[1]=candidate->InvMass(fNProngs,(UInt_t*)pdgdaughtersD0bar); //D0bar
898 
899  Double_t *point=0x0;
900 
901  if(!fAnalyseDBkg)
902  {
903  point=new Double_t[5];
904  point[0]=z;
905  point[1]=ptj;
906  point[2]=ptD;
907  point[3]=masses[0];
908 
909  }
910  else
911  {
912  point=new Double_t[7];
913  point[0]=z;
914  point[1]=ptj;
915  point[2]=ptD;
916  point[3]=masses[0];
917  point[4]=static_cast<Double_t>(IsBkg ? 1 : 0);
918  point[5]=static_cast<Double_t>(bDInEMCalAcc ? 1 : 0);
919  point[6]=static_cast<Double_t>(bJetInEMCalAcc ? 1 : 0);
920 
921  }
922  Int_t isselected=fCuts->IsSelected(candidate,AliRDHFCuts::kAll,aodEvent);
923  if(isselected==1 || isselected==3)
924  {
925 
926  fhInvMassptD->Fill(masses[0],ptD);
927  fhsDphiz->Fill(point,1.);
928 
929  }
930  if(isselected>=2)
931  {
932  fhInvMassptD->Fill(masses[1],ptD);
933  point[3]=masses[1];
934  fhsDphiz->Fill(point,1.);
935 
936  }
937  delete[] point;
938 }
939 
940 //_______________________________________________________________________________
941 
943 
944  AliAODTrack *softpi = (AliAODTrack*)dstar->GetBachelor();
945  Double_t deltamass= dstar->DeltaInvMass();
946 
947 
948  fhPtPion->Fill(softpi->Pt());
949 
950  Double_t *point=0x0;
951  if(!fAnalyseDBkg)
952  {
953  point=new Double_t[5];
954  point[0]=z;
955  point[1]=ptj;
956  point[2]=ptD;
957  point[3]=deltamass;
958  }
959  else
960  {
961  point=new Double_t[7];
962  point[0]=z;
963  point[1]=ptj;
964  point[2]=ptD;
965  point[3]=deltamass;
966  point[4]=static_cast<Double_t>(IsBkg ? 1 : 0);
967  point[5]=static_cast<Double_t>(bDInEMCalAcc ? 1 : 0);
968  point[6]=static_cast<Double_t>(bJetInEMCalAcc ? 1 : 0);
969  }
970 
971  if(!point){
972  AliError(Form("Numer of THnSparse entries %d not valid", fNAxesBigSparse));
973  return;
974  }
975 
976 
977  fhInvMassptD->Fill(deltamass,ptD);
978  fhsDphiz->Fill(point,1.);
979  delete[] point;
980 }
981 
982 //_______________________________________________________________________________
983 
985 
986  Double_t pdgmass=0;
987  if(fCandidateType==kD0toKpi) pdgmass=TDatabasePDG::Instance()->GetParticle(421)->Mass();
988  if(fCandidateType==kDstartoKpipi) pdgmass=TDatabasePDG::Instance()->GetParticle(413)->Mass()-TDatabasePDG::Instance()->GetParticle(421)->Mass();
989 
990  Double_t *point=0x0;
991 
992  if(fNAxesBigSparse==5){
993  point=new Double_t[5];
994  point[0]=z;
995  point[1]=ptjet;
996  point[2]=ptD;
997  point[3]=pdgmass;
998  }
999  if(fNAxesBigSparse==7){
1000  point=new Double_t[7];
1001  point[0]=z;
1002  point[1]=ptjet;
1003  point[2]=ptD;
1004  point[3]=pdgmass;
1005  point[4]=1;
1006  point[5]=static_cast<Double_t>(bDInEMCalAcc ? 1 : 0);
1007  point[6]=static_cast<Double_t>(bJetInEMCalAcc ? 1 : 0);
1008  }
1009 
1010  if(!point){
1011  AliError(Form("Numer of THnSparse entries %d not valid", fNAxesBigSparse));
1012  return;
1013  }
1014 
1015 
1016  point[3]=pdgmass;
1017  fhsDphiz->Fill(point,1.);
1018 
1019  delete[] point;
1020 }
1021 
1022 //_______________________________________________________________________________
1023 
1025  //Calculate DeltaR between p1 and p2: DeltaR=sqrt(Delataphi^2+DeltaEta^2)
1026  //It recalculates the eta-phi values if it was asked for background subtraction of the jets
1027  if(!p1 || !p2) return -1;
1028 
1029  Double_t phi1=p1->Phi(),eta1=p1->Eta();
1030 
1031  if (rho>0)
1032  {
1033  Double_t pj[3];
1034  Bool_t okpj=p1->PxPyPz(pj);
1035  if(!okpj){
1036  printf("Problems getting momenta\n");
1037  return -999;
1038  }
1039  pj[0] = p1->Px() - p1->Area()*(rho*TMath::Cos(p1->AreaPhi()));
1040  pj[1] = p1->Py() - p1->Area()*(rho*TMath::Sin(p1->AreaPhi()));
1041  pj[2] = p1->Pz() - p1->Area()*(rho*TMath::SinH(p1->AreaEta()));
1042  //Image of the function Arccos(px/pt) where pt = sqrt(px*px+py*py) is:
1043  //[0,pi] if py > 0 and
1044  //[pi,2pi] if py < 0
1045  phi1 = TMath::ACos(pj[0]/TMath::Sqrt(pj[0]*pj[0]+pj[1]*pj[1]));
1046  if(pj[1]<0) phi1 = 2*TMath::Pi() - phi1;
1047  eta1 = TMath::ASinH(pj[2]/TMath::Sqrt(pj[0]*pj[0]+pj[1]*pj[1]));
1048  }
1049 
1050  Double_t phi2 = p2->Phi(),eta2 = p2->Eta() ;
1051 
1052  Double_t dPhi=TMath::Abs(phi1-phi2);
1053  if(dPhi>TMath::Pi()) dPhi = (2*TMath::Pi())-dPhi;
1054 
1055 
1056  Double_t dEta=eta1-eta2;
1057  Double_t deltaR=TMath::Sqrt(dEta*dEta + dPhi*dPhi );
1058  return deltaR;
1059 
1060 }
1061 //_______________________________________________________________________________
1063  //Calculate DeltaR between p1 and p2: DeltaR=sqrt(Delataphi^2+DeltaEta^2)
1064  if(!p1 || !p2) return -1;
1065 
1066  Double_t phi1=p1->Phi(),eta1=p1->Eta();
1067 
1068  Double_t phi2 = p2->Phi(),eta2 = p2->Eta() ;
1069 
1070  Double_t dPhi=TMath::Abs(phi1-phi2);
1071  if(dPhi>TMath::Pi()) dPhi = (2*TMath::Pi())-dPhi;
1072 
1073 
1074  Double_t dEta=eta1-eta2;
1075  Double_t deltaR=TMath::Sqrt(dEta*dEta + dPhi*dPhi );
1076  return deltaR;
1077 
1078 }
1079 
1080 //_______________________________________________________________________________
1081 
1083 
1084  Double_t ptD=candDstar->Pt();
1085  Int_t bin = fCuts->PtBin(ptD);
1086  if (bin < 0){
1087  // /PWGHF/vertexingHF/AliRDHFCuts::PtBin(Double_t) const may return values below zero depending on config.
1088  bin = 9999; // void result code for coverity (bin later in the code non-zero) - will coverity pick up on this?
1089  return -1; // out of bounds
1090  }
1091 
1092  Double_t invM=candDstar->InvMassD0();
1093  Double_t mPDGD0=TDatabasePDG::Instance()->GetParticle(421)->Mass();
1094 
1095  Float_t fourSigmal= mPDGD0-4.*fSigmaD0[bin] , sixSigmal= mPDGD0-8.*fSigmaD0[bin];
1096  Float_t fourSigmar= mPDGD0+4.*fSigmaD0[bin] , sixSigmar= mPDGD0+8.*fSigmaD0[bin];
1097 
1098  if((invM>=sixSigmal && invM<fourSigmal) || (invM>fourSigmar && invM<=sixSigmar)) return 1;
1099  else return 0;
1100 
1101 }
1102 
1103 //_______________________________________________________________________________
1104 
1106  //check eta phi of a VParticle: return true if it is in the EMCal acceptance, false otherwise
1107 
1108  Double_t phiEMCal[2]={1.405,3.135},etaEMCal[2]={-0.7,0.7};
1109  Bool_t binEMCal=kTRUE;
1110  Double_t phi=vpart->Phi(), eta=vpart->Eta();
1111  if(phi<phiEMCal[0] || phi>phiEMCal[1]) binEMCal=kFALSE;
1112  if(eta<etaEMCal[0] || eta>etaEMCal[1]) binEMCal=kFALSE;
1113  return binEMCal;
1114 
1115 
1116 }
Int_t pdg
void AddFlavourTag(Int_t tag)
Definition: AliEmcalJet.h:245
Double_t Area() const
Definition: AliEmcalJet.h:123
Double_t GetRhoVal() const
const TString & GetRhoName() const
double Double_t
Definition: External.C:58
Definition: External.C:236
Double_t DeltaInvMass() const
Jet is tagged to contain a D* meson.
Definition: AliEmcalJet.h:78
AliJetContainer * GetJetContainer(Int_t i=0) const
Double_t Eta() const
Definition: AliEmcalJet.h:114
Double_t Z(AliVParticle *part, AliEmcalJet *jet, Double_t rho) const
Double_t Py() const
Definition: AliEmcalJet.h:100
Double_t Phi() const
Definition: AliEmcalJet.h:110
Double_t mass
Int_t GetNParticles() const
Double_t GetLocalVal(Double_t phi, Double_t r, Double_t n) const
char Char_t
Definition: External.C:18
static Int_t CheckMatchingAODdeltaAODevents()
virtual Bool_t AcceptJet(Int_t i, UInt_t &rejectionReason) const
void FillHistogramsDstarJetCorr(AliAODRecoCascadeHF *dstar, Double_t z, Double_t ptD, Double_t ptj, Bool_t IsBkg, Bool_t bDInEMCalAcc, Bool_t bJetInEMCalAcc)
AliVTrack * GetTrack() const
void AngularCorrelationMethod(Bool_t IsBkg, AliAODEvent *aodEvent)
AliVParticle * GetFlavourTrack(Int_t i=0) const
Container for particles within the EMCAL framework.
Int_t TrackAt(Int_t idx) const
Definition: AliEmcalJet.h:153
UShort_t GetNumberOfTracks() const
Definition: AliEmcalJet.h:132
Double_t Px() const
Definition: AliEmcalJet.h:99
AliParticleContainer * GetParticleContainer() const
Double_t AreaEta() const
Definition: AliEmcalJet.h:125
int Int_t
Definition: External.C:63
void FillDJetHistograms(AliEmcalJet *jet, Double_t rho, Bool_t IsBkg, AliAODEvent *aodEvent)
Definition: External.C:204
unsigned int UInt_t
Definition: External.C:33
void FillHistogramsD0JetCorr(AliAODRecoDecayHF *candidate, Double_t z, Double_t ptD, Double_t ptj, Bool_t IsBkg, Bool_t bDInEMCalAcc, Bool_t bJetInEMCalAcc, AliAODEvent *aodEvent)
float Float_t
Definition: External.C:68
void AddFlavourTrack(AliVParticle *hftrack)
virtual AliVParticle * GetParticle(Int_t i=-1) const
virtual Bool_t Run()
Run function. This is the core function of the analysis and contains the user code. Therefore users have to implement this function.
AliAODTrack * GetBachelor() const
Double_t fCent
!event centrality
AliLocalRhoParameter * fLocalRho
! local event rho
Float_t CheckDeltaR(AliEmcalJet *p1, AliVParticle *p2) const
AliEmcalJet * GetNextAcceptJet()
ClassImp(AliAnalysisTaskFlavourJetCorrelations) AliAnalysisTaskFlavourJetCorrelations
Double_t AreaPhi() const
Definition: AliEmcalJet.h:126
Double_t Pt() const
Definition: AliEmcalJet.h:102
Enhanced TList-derived class that implements correct merging for pt_hard binned production.
Definition: AliEmcalList.h:25
AliEmcalJet * GetNextJet()
Bool_t IsEventSelected(AliVEvent *event)
Jet is tagged to contain a D0 meson.
Definition: AliEmcalJet.h:79
Float_t GetJetRadius() const
AliEmcalList * fOutput
!output list
void ConstituentCorrelationMethod(Bool_t IsBkg, AliAODEvent *aodEvent)
Bool_t IsSelected(TObject *obj)
Definition: AliRDHFCuts.h:281
Base task in the EMCAL jet framework.
Represent a jet reconstructed using the EMCal jet framework.
Definition: AliEmcalJet.h:44
Bool_t PxPyPz(Double_t p[3]) const
Definition: AliEmcalJet.h:104
Bool_t SetD0WidthForDStar(Int_t nptbins, Float_t *width)
Double_t Pz() const
Definition: AliEmcalJet.h:101
Double_t InvMassD0() const
const char Option_t
Definition: External.C:48
Int_t GetNPtBins() const
Definition: AliRDHFCuts.h:239
void UserCreateOutputObjects()
Main initialization function on the worker.
const Int_t nbins
bool Bool_t
Definition: External.C:53
void FillHistogramsMCGenDJetCorr(Double_t z, Double_t ptD, Double_t ptjet, Bool_t bDInEMCalAcc, Bool_t bJetInEMCalAcc)
Int_t PtBin(Double_t pt) const
Float_t DeltaR(AliEmcalJet *p1, AliVParticle *p2, Double_t rho) const
Int_t nptbins
Container for jet within the EMCAL jet framework.
TClonesArray * fSideBandArray
contains candidates selected by AliRDHFCuts
Bool_t fAnalyseDBkg
contains candidates selected by AliRDHFCuts::IsSelected(kTracks), to be used for side bands (DStar ca...