AliPhysics  64f4410 (64f4410)
AliAnalysisTaskJetShapeDeriv.cxx
Go to the documentation of this file.
1 #include <TRandom3.h>
2 #include <TH1F.h>
3 #include <TH2F.h>
4 #include <TH3F.h>
5 #include <THnSparse.h>
6 #include <TLorentzVector.h>
7 
8 #include <AliParticleContainer.h>
9 #include <AliJetContainer.h>
10 #include <AliRhoParameter.h>
11 #include <AliEmcalJet.h>
12 
14 
16 
17 //________________________________________________________________________
20  fM1st(0),
21  fM2nd(0),
22  fDeriv1st(0),
23  fDeriv2nd(0),
24  fPartialExclusion(0),
25  fh2MSubPtSubAll(0x0),
26  fh2PtTrueSubFacV1(0x0),
27  fh2PtRawSubFacV1(0x0),
28  fh2PtCorrSubFacV1(0x0),
29  fh2NConstSubFacV1(0x0),
30  fh2PtTrueSubFacV2(0x0),
31  fh2PtRawSubFacV2(0x0),
32  fh2PtCorrSubFacV2(0x0),
33  fh2NConstSubFacV2(0x0)
34 
35 {
36  // Default constructor.
37 
38  fh2MSubPtSubAll = new TH2F*[fNcentBins];
39  fh2PtTrueSubFacV1 = new TH2F*[fNcentBins];
40  fh2PtRawSubFacV1 = new TH2F*[fNcentBins];
41  fh2PtCorrSubFacV1 = new TH2F*[fNcentBins];
42  fh2NConstSubFacV1 = new TH2F*[fNcentBins];
43  fh2PtTrueSubFacV2 = new TH2F*[fNcentBins];
44  fh2PtRawSubFacV2 = new TH2F*[fNcentBins];
45  fh2PtCorrSubFacV2 = new TH2F*[fNcentBins];
46  fh2NConstSubFacV2 = new TH2F*[fNcentBins];
47 
48  for (Int_t i = 0; i < fNcentBins; i++) {
49  fh2MSubPtSubAll[i] = 0;
50  fh2PtTrueSubFacV1[i] = 0;
51  fh2PtRawSubFacV1[i] = 0;
52  fh2PtCorrSubFacV1[i] = 0;
53  fh2NConstSubFacV1[i] = 0;
54  fh2PtTrueSubFacV2[i] = 0;
55  fh2PtRawSubFacV2[i] = 0;
56  fh2PtCorrSubFacV2[i] = 0;
57  fh2NConstSubFacV2[i] = 0;
58  }
59 
60 }
61 
62 //________________________________________________________________________
65  fM1st(0),
66  fM2nd(0),
67  fDeriv1st(0),
68  fDeriv2nd(0),
69  fPartialExclusion(0),
70  fh2MSubPtSubAll(0x0),
71  fh2PtTrueSubFacV1(0x0),
72  fh2PtRawSubFacV1(0x0),
73  fh2PtCorrSubFacV1(0x0),
74  fh2NConstSubFacV1(0x0),
75  fh2PtTrueSubFacV2(0x0),
76  fh2PtRawSubFacV2(0x0),
77  fh2PtCorrSubFacV2(0x0),
78  fh2NConstSubFacV2(0x0)
79 
80 {
81  // Standard constructor.
82 
92 
93  for (Int_t i = 0; i < fNcentBins; i++) {
94  fh2MSubPtSubAll[i] = 0;
95  fh2PtTrueSubFacV1[i] = 0;
96  fh2PtRawSubFacV1[i] = 0;
97  fh2PtCorrSubFacV1[i] = 0;
98  fh2NConstSubFacV1[i] = 0;
99  fh2PtTrueSubFacV2[i] = 0;
100  fh2PtRawSubFacV2[i] = 0;
101  fh2PtCorrSubFacV2[i] = 0;
102  fh2NConstSubFacV2[i] = 0;
103  }
104 
105 }
106 
107 //________________________________________________________________________
109 {
110  // Destructor.
111 }
112 
113 //________________________________________________________________________
115 {
116  // Create user output.
117 
119 
120  const Int_t nBinsPt = 200;
121  const Double_t minPt = -50.;
122  const Double_t maxPt = 150.;
123 
124  Int_t nBinsM = 100;
125  Double_t minM = -20.;
126  Double_t maxM = 80.;
127  if(fSmallSyst) maxM = 40.;
128  if(fJetMassVarType==kRatMPt) {
129  nBinsM = 100;
130  minM = -0.2;
131  maxM = 0.8;
132  }
133 
134  Int_t nBinsDM = 100;
135  Double_t minDM = -25.;
136  Double_t maxDM = 25.;
137  if(fJetMassVarType==kRatMPt) {
138  nBinsDM = 100;
139  minDM = -0.5;
140  maxDM = 0.5;
141  }
142  Int_t nBinsDpT = 100;
143  Double_t minDpT = -50.;
144  Double_t maxDpT = 50.;
145 
146  const Int_t nBinsDRToLJ = 20; //distance to leading jet in Pb-Pb only event
147  const Double_t minDRToLJ = 0.;
148  const Double_t maxDRToLJ = 1.;
149 
150  const Int_t nBinsPtLead = 20;
151  const Double_t minPtLead = 0.;
152  const Double_t maxPtLead = 20.;
153 
154  const Int_t nBinsV1 = 60;
155  const Double_t minV1 = -60.;
156  const Double_t maxV1 = 0.;
157 
158  const Int_t nBinsV2 = 60;
159  const Double_t minV2 = -30.;
160  const Double_t maxV2 = 0.;
161 
162  const Int_t nBinsdMr = 200;
163  const Double_t mindMr = -2.;
164  const Double_t maxdMr = 2.;
165  Double_t *binsdMr = new Double_t[nBinsdMr+1];
166  for(Int_t i=0; i<=nBinsdMr; i++) binsdMr[i]=(Double_t)mindMr + (maxdMr-mindMr)/nBinsdMr*(Double_t)i ;
167 
168  //These are good for pPb
169  Int_t nBinsRho = 50;
170  Double_t minRho = 0.;
171  Double_t maxRho = 20.;
172  Int_t nBinsRhom = 50;
173  Double_t minRhom = 0.;
174  Double_t maxRhom = 1.;
175 
176 
177  const Int_t nBinsSparse2 = 8;
178  //#it{M}_{det} - #it{M}_{part}; #it{p}_{T,det} - #it{p}_{T,part}; #it{M}_{det}; #it{M}_{unsub}; #it{p}_{T,det}; #it{p}_{T,unsub}; #rho ; #rho_{m}
179  const Int_t nBins2[nBinsSparse2] = {nBinsDM, nBinsDpT, nBinsM, nBinsM, nBinsPt, nBinsPt, nBinsRho, nBinsRhom};
180  const Double_t xmin2[nBinsSparse2] = {minDM, minDpT, minM, minM, minPt, minPt, minRho, minRhom};
181  const Double_t xmax2[nBinsSparse2] = {maxDM, maxDpT, maxM, maxM, maxPt, maxPt, maxRho, maxRhom};
182 
183  TString histName = "";
184  TString histTitle = "";
185  TString varName = "#it{M}_{jet}";
186  if(fJetMassVarType==kRatMPt) varName = "#it{M}_{jet}/#it{p}_{T,jet}";
187 
188  for(Int_t i = 0; i < fNcentBins; i++){
189  histName = Form("fh2MSubPtSubAll_%d",i);
190  histTitle = Form("fh2MSubPtSubAll_%d;%s;#it{p}_{T, sub}",i,varName.Data());
191 
192  fh2MSubPtSubAll[i] = new TH2F(histName.Data(),histTitle.Data(),nBinsM,minM,maxM,nBinsPt,minPt,maxPt);
193  fOutput->Add(fh2MSubPtSubAll[i]);
194 
195  //derivative histograms
196  histName = Form("fh2PtTrueSubFacV1_%d",i);
197  histTitle = Form("fh2PtTrueSubFacV1_%d;#it{p}_{T,true};-(#rho+#rho_{m})V_{1}",i);
198  fh2PtTrueSubFacV1[i] = new TH2F(histName.Data(),histTitle.Data(),nBinsPt,minPt,maxPt,nBinsV1,minV1,maxV1);
199  fOutput->Add(fh2PtTrueSubFacV1[i]);
200 
201  histName = Form("fh2PtRawSubFacV1_%d",i);
202  histTitle = Form("fh2PtRawSubFacV1_%d;#it{p}_{T,raw};-(#rho+#rho_{m})V_{1}",i);
203  fh2PtRawSubFacV1[i] = new TH2F(histName.Data(),histTitle.Data(),nBinsPt,minPt,maxPt,nBinsV1,minV1,maxV1);
204  fOutput->Add(fh2PtRawSubFacV1[i]);
205 
206  histName = Form("fh2PtCorrSubFacV1_%d",i);
207  histTitle = Form("fh2PtCorrSubFacV1_%d;#it{p}_{T,corr};-(#rho+#rho_{m})V_{1}",i);
208  fh2PtCorrSubFacV1[i] = new TH2F(histName.Data(),histTitle.Data(),nBinsPt,minPt,maxPt,nBinsV1,minV1,maxV1);
209  fOutput->Add(fh2PtCorrSubFacV1[i]);
210 
211  histName = Form("fh2NConstSubFacV1_%d",i);
212  histTitle = Form("fh2NConstSubFacV1_%d;#it{N}_{const};-(#rho+#rho_{m})V_{1}",i);
213  fh2NConstSubFacV1[i] = new TH2F(histName.Data(),histTitle.Data(),nBinsPt,minPt,maxPt,100,0.,200.);
214  fOutput->Add(fh2NConstSubFacV1[i]);
215 
216  histName = Form("fh2PtTrueSubFacV2_%d",i);
217  histTitle = Form("fh2PtTrueSubFacV2_%d;#it{p}_{T,true};0.5(#rho+#rho_{m})^{2}V_{2}",i);
218  fh2PtTrueSubFacV2[i] = new TH2F(histName.Data(),histTitle.Data(),nBinsPt,minPt,maxPt,nBinsV2,minV2,maxV2);
219  fOutput->Add(fh2PtTrueSubFacV2[i]);
220 
221  histName = Form("fh2PtRawSubFacV2_%d",i);
222  histTitle = Form("fh2PtRawSubFacV2_%d;#it{p}_{T,raw};0.5(#rho+#rho_{m})^{2}V_{2}",i);
223  fh2PtRawSubFacV2[i] = new TH2F(histName.Data(),histTitle.Data(),nBinsPt,minPt,maxPt,nBinsV2,minV2,maxV2);
224  fOutput->Add(fh2PtRawSubFacV2[i]);
225 
226  histName = Form("fh2PtCorrSubFacV2_%d",i);
227  histTitle = Form("fh2PtCorrSubFacV2_%d;#it{p}_{T,corr};0.5(#rho+#rho_{m})^{2}V_{2}",i);
228  fh2PtCorrSubFacV2[i] = new TH2F(histName.Data(),histTitle.Data(),nBinsPt,minPt,maxPt,nBinsV2,minV2,maxV2);
229  fOutput->Add(fh2PtCorrSubFacV2[i]);
230 
231  histName = Form("fh2NConstSubFacV2_%d",i);
232  histTitle = Form("fh2NConstSubFacV2_%d;#it{N}_{const};0.5(#rho+#rho_{m})^{2}V_{2}",i);
233  fh2NConstSubFacV2[i] = new TH2F(histName.Data(),histTitle.Data(),nBinsPt,minPt,maxPt,100,0.,200.);
234  fOutput->Add(fh2NConstSubFacV2[i]);
235  }
236 
237  if(fCreateTree) {
238  fTreeJetBkg->Branch("fM1st", &fM1st, "fM1st/F");
239  fTreeJetBkg->Branch("fM2nd", &fM2nd, "fM2nd/F");
240  fTreeJetBkg->Branch("fDeriv1st", &fDeriv1st, "fDeriv1st/F");
241  fTreeJetBkg->Branch("fDeriv2nd", &fDeriv2nd, "fDeriv2nd/F");
242  }
243  PostData(1, fOutput); // Post data for ALL output slots > 0 here.
244  //if(fCreateTree) PostData(2,fTreeJetBkg);
245 }
246 
247 //________________________________________________________________________
248 //Bool_t AliAnalysisTaskJetShapeDeriv::Run()
249 //{
250 // // Run analysis code here, if needed. It will be executed before FillHistograms().
251 //
252 // return kTRUE;
253 //}
254 
255 //________________________________________________________________________
257 {
258  // Fill histograms.
259  AliEmcalJet *jet1 = NULL; //AA jet
260  AliEmcalJet *jet2 = NULL; //Embedded Pythia jet
261  AliEmcalJet *jetR = NULL; //true jet for response matrix
262  AliEmcalJet *jetO = NULL; //hard-ish jet to avoid overlap of single track with
263  AliVParticle *vpe = NULL; //embedded particle
264 
266  if(!jetCont){
267  Printf("Jet Container %d not found, return", fContainerBase);
268  return kFALSE;
269  }
270  //Printf("FillHistograms::Jet container %p", jetCont);
272 
273  if(fOverlap && !jetContO){
274  Printf("Jet Container %d not found, return", fContainerOverlap);
275  return kFALSE;
276  }
278  //if(trackCont) Printf("Ci sono");
279 
280 
281  for(Int_t i=0; i<trackCont->GetNParticles(); i++){
282  AliVParticle *vp= static_cast<AliVParticle*>(trackCont->GetAcceptParticle(i));
283  if(!vp) continue;
284  fhpTTracksCont->Fill(vp->Pt());
285  }
286 
287  //rho
288  AliRhoParameter* rhoParam = dynamic_cast<AliRhoParameter*>(InputEvent()->FindListObject(jetCont->GetRhoName()));
289  fRho = 0;
290  if (!rhoParam) {
291  AliError(Form("%s: Could not retrieve rho %s (some histograms will be filled with zero)!", GetName(), jetCont->GetRhoName().Data()));
292 
293  } else fRho = rhoParam->GetVal();
294  //rhom
295  AliRhoParameter* rhomParam = dynamic_cast<AliRhoParameter*>(InputEvent()->FindListObject(jetCont->GetRhoMassName()));
296  fRhoM = 0;
297  if (!rhomParam) {
298  AliError(Form("%s: Could not retrieve rho_m %s (some histograms will be filled with zero)!", GetName(), jetCont->GetRhoMassName().Data()));
299 
300  } else fRhoM = rhomParam->GetVal();
301 
302  //Get leading jet in Pb-Pb event without embedded objects
304  AliEmcalJet *jetL = NULL;
305  if(jetContNoEmb) jetL = jetContNoEmb->GetLeadingJet("rho");
306 
307  jetCont->ResetCurrentID();
308  while((jet1 = jetCont->GetNextAcceptJet())) {
309  jet2 = NULL;
310  if(jet1->GetTagStatus()<1 || !jet1->GetTaggedJet())
311  continue;
312  //print constituents of different jet containers
313  //jet1
314 
315  for(Int_t i=0; i<jet1->GetNumberOfTracks(); i++) {
316  AliVParticle *vp = static_cast<AliVParticle*>(jet1->TrackAt(i, jetCont->GetParticleContainer()->GetArray()));
317  // if (vp->TestBits(TObject::kBitMask) != (Int_t)(TObject::kBitMask) ) continue;
318  //Int_t lab = TMath::Abs(vp->GetLabel());
319  if(vp) fhpTTracksJet1 -> Fill(vp->Pt());
320  }
322  Double_t mUnsubjet1 = jet1->M();
323  Double_t ptjet1 = jet1->Pt()-fRho*jet1->Area();
324  Double_t ptUnsubjet1 = jet1->Pt();
325  Double_t var = mjet1;
326 
327  if(fJetMassVarType==kRatMPt) {
328  if(ptjet1>0. || ptjet1<0.) var = mjet1/ptjet1;
329  else var = -999.;
330  }
331 
332  //Fill histograms for all AA jets
333  fh2MSubPtRawAll[fCentBin]->Fill(var,ptUnsubjet1);
334  fh2MSubPtSubAll[fCentBin]->Fill(var,ptjet1);
336  fh2PtCorrSubFacV1[fCentBin]->Fill(jet1->Pt()-fRho*jet1->Area(),-1.*(fRho+fRhoM)*jet1->GetShapeProperties()->GetFirstDerivative());
339  fh2PtCorrSubFacV2[fCentBin]->Fill(jet1->Pt()-fRho*jet1->Area(),0.5*(fRho+fRhoM)*(fRho+fRhoM)*jet1->GetShapeProperties()->GetSecondDerivative());
341 
342  Double_t fraction = 0.;
343  fMatch = 0;
344  fJet2Vec->SetPtEtaPhiM(0.,0.,0.,0.);
345  if(fSingleTrackEmb) {
346  vpe = GetEmbeddedConstituent(jet1);
347  if(vpe) {
348  Bool_t reject = kFALSE;
349  if(fPartialExclusion) {
350 
351  TRandom3 rnd;
352  rnd.SetSeed(0);
353 
354  Double_t ncoll = 6.88; //GetNColl(); //check it out from AliAnalysisTaskDeltaPt and possibly refine
355 
356  Double_t prob = 0.;
357  if(ncoll>0)
358  prob = 1./ncoll;
359 
360  if(rnd.Rndm()<=prob) reject = kTRUE; //reject cone
361  }
362  if(fOverlap){
363  Int_t Njets = jetContO->GetNAcceptedJets();
364  fhNJetsSelEv->Fill(Njets);
365  jetContO->ResetCurrentID();
366  while((jetO = jetContO->GetNextAcceptJet())){
367  //print constituents of different jet containers
368  //jetO
369  //Printf("N particle %d",jetO->GetNumberOfTracks());
370  for(Int_t i=0; i<jetO->GetNumberOfTracks(); i++) {
371  AliVParticle* vp = static_cast<AliVParticle*>(jetO->TrackAt(i, jetContO->GetParticleContainer()->GetArray()));
372  // if (vp->TestBits(TObject::kBitMask) != (Int_t)(TObject::kBitMask) ) continue;
373  //Int_t lab = TMath::Abs(vp->GetLabel());
374  if(vp) fhpTTracksJetO -> Fill(vp->Pt());
375  }
376 
377  Double_t deltaR = jetO->DeltaR(vpe);
378  fhRjetTrvspTj->Fill(deltaR, jetO->Pt());
379  fhJetEtaPhiOvl->Fill(jetO->Eta(), jetO->Phi());
380  if( deltaR < fRadius) {
381  reject = kTRUE;
382  break;
383  }
384  }
385  }
386  if(!reject){
387  fJet2Vec->SetPxPyPzE(vpe->Px(),vpe->Py(),vpe->Pz(),vpe->E());
388  fMatch = 1;
389  }
390  }
391  } else {
392 
393  jet2 = jet1->ClosestJet();
394  fraction = jetCont->GetFractionSharedPt(jet1);
395  fMatch = 1;
396  if(fMinFractionShared>0.) {
397  if(fraction>fMinFractionShared) {
398  fJet2Vec->SetPxPyPzE(jet2->Px(),jet2->Py(),jet2->Pz(),jet2->E());
399  fMatch = 1;
400 
401  //choose jet type for true axis of response matrix
403  jetR = jet2;
404  else if(fResponseReference==kPart)
405  jetR = jet2->GetTaggedJet();
406  } else
407  fMatch = 0;
408  }
409  }
410 
411  //Fill histograms for matched jets
412  fh2MSubMatch[fCentBin]->Fill(var,fMatch);
413  if(fMatch==1) {
414  fhJetSubMatchEtaPhiPt->Fill(jet1->Eta(), jet1->Phi(), ptjet1);
415  Double_t drToLJ = -1.;
416  if(jetL) drToLJ = jet1->DeltaR(jetL);
417  if(fSingleTrackEmb && vpe)
418  drToLJ = jet1->DeltaR(vpe);
419  fh3MSubPtRawDRMatch[fCentBin]->Fill(var,ptjet1,drToLJ);
420  Double_t var2 = 0.;
421  Double_t mJetR = 0.;
422  Double_t ptJetR = 0.;
423  if(jetR) {
424  mJetR = jetR->M();
425  var2 = jetR->M();
426  ptJetR = jetR->Pt();
427  }
428  if(fSingleTrackEmb && vpe) {
429  if(fFromTree){
430  Int_t exit = MatchEmbeddedConstituentWithParticleLevel(); //here is GetEntry
431 
432  if(exit>0) {
433  //mJetR = fVecP->M();
434  var2 = fVecP->M();
435  ptJetR = fVecP->Pt();
436  }
437  } else{
438  //mJetR = vpe->M();
439  var2 = vpe->M();
440  ptJetR = vpe->Pt();
441  }
442  }
443 
444  if(fJetMassVarType==kRatMPt) {
445  if(ptJetR>0. || ptJetR<0.) var2 /= ptJetR;
446  }
447  fh3MSubPtTrueLeadPt[fCentBin]->Fill(var,ptJetR,jet1->MaxTrackPt());
448  fh3MTruePtTrueLeadPt[fCentBin]->Fill(var2,ptJetR,jet1->MaxTrackPt());
449  fh3PtTrueDeltaMLeadPt[fCentBin]->Fill(ptJetR,var-var2,jet1->MaxTrackPt());
450  if(var2>0.) fh3PtTrueDeltaMRelLeadPt[fCentBin]->Fill(ptJetR,(var-var2)/var2,jet1->MaxTrackPt());
451  if(fFromTree){
452  Double_t varsp[10] = {var,var2,ptjet1,ptJetR, fVecD->M(), fVecD->Pt(), fRho, fRhoM, mUnsubjet1, ptUnsubjet1};
453  fhnMassResponse[fCentBin]->Fill(varsp);
454  } else {
455  Double_t varsp[9] = {var,var2,ptjet1,ptJetR,jet1->MaxTrackPt(), fRho, fRhoM, mUnsubjet1, ptUnsubjet1};//MRec,MTrue,PtRec,PtTrue,PtLeadRec
456  fhnMassResponse[fCentBin]->Fill(varsp);
457  }
458 
459  if(!fCreateTree){
460  Double_t varsp1[6];
461  varsp1[0] = var-var2;
462  varsp1[1] = ptjet1-ptJetR;
463  varsp1[2] = var;
464  varsp1[3] = var2;
465  varsp1[4] = ptjet1;
466  varsp1[5] = ptJetR;
467 
468  //fhnDeltaMass[fCentBin]->Fill(varsp1);
469 
470  //#it{M}_{det} - #it{M}_{part}; #it{p}_{T,det} - #it{p}_{T,part}; #it{M}_{unsub} - #it{M}_{part}; #it{p}_{T,unsub} - #it{p}_{T,part}; #it{M}_{det}; #it{M}_{unsub}; #it{p}_{T,det}; #it{p}_{T,unsub}; #rho ; #rho_{m}
471  Double_t varsp2[10] = {var-var2, ptjet1-ptJetR, mUnsubjet1 - var2, ptUnsubjet1 - ptJetR, var2, mUnsubjet1, ptjet1, ptUnsubjet1, fRho, fRhoM};
472  fhnDeltaMassAndBkgInfo->Fill(varsp2);
473 
474  Double_t varsp3[6] = {(var-var2)/var2, (ptjet1-ptJetR)/ptJetR, var2, ptJetR, fRho, fRhoM};
475  fhnResolution->Fill(varsp3);
476  }
477  }
478  if(fCreateTree) {
479 
480  fJet1Vec->SetPxPyPzE(jet1->Px(),jet1->Py(),jet1->Pz(),jet1->E());
481  fArea = (Float_t)jet1->Area();
482  fAreaPhi = (Float_t)jet1->AreaPhi();
483  fAreaEta = (Float_t)jet1->AreaEta();
484  fNConst = (Int_t)jet1->GetNumberOfTracks();
489  fTreeJetBkg->Fill();
490  }
491  }
492  return kTRUE;
493 }
494 
495 //________________________________________________________________________
496 //AliVParticle* AliAnalysisTaskJetShapeDeriv::GetEmbeddedConstituent(AliEmcalJet *jet) {
497 //
498 // AliJetContainer *jetCont = GetJetContainer(fContainerBase);
499 // //Printf("JEt container %p", jetCont);
500 // AliVParticle *vp = 0x0;
501 // AliVParticle *vpe = 0x0; //embedded particle
502 // Int_t nc = 0;
503 // for(Int_t i=0; i<jet->GetNumberOfTracks(); i++) {
504 // vp = static_cast<AliVParticle*>(jet->TrackAt(i, jetCont->GetParticleContainer()->GetArray()));
505 // // if (vp->TestBits(TObject::kBitMask) != (Int_t)(TObject::kBitMask) ) continue;
506 // //Printf("vp %p", vp);
507 // if(!vp) continue;
508 // Int_t lab = TMath::Abs(vp->GetLabel());
509 // if (lab < fMinLabelEmb || lab > fMaxLabelEmb)
510 // continue;
511 // if(!vpe) vpe = vp;
512 // else if(vp->Pt()>vpe->Pt()) vpe = vp;
513 // nc++;
514 // }
515 //
516 // AliDebug(11,Form("Found %d embedded particles",nc));
517 // return vpe;
518 //}
519 
520 
TH3F ** fh3PtTrueDeltaMLeadPt
! true jet pT vs (Msub - Mtrue) vs LeadPt for matched jets
Double_t Area() const
Definition: AliEmcalJet.h:130
const TString & GetRhoName() const
double Double_t
Definition: External.C:58
AliEmcalJet * GetTaggedJet() const
Definition: AliEmcalJet.h:337
TH2F ** fh2PtCorrSubFacV2
! subtracted pT vs 0.5(rho+rhom)^2*V2
Definition: External.C:236
AliEmcalJet * ClosestJet() const
Definition: AliEmcalJet.h:327
AliJetContainer * GetJetContainer(Int_t i=0) const
Int_t GetTagStatus() const
Definition: AliEmcalJet.h:338
TH2F ** fh2NConstSubFacV1
! N constituents vs -(rho+rhom)*V1
Double_t Eta() const
Definition: AliEmcalJet.h:121
Bool_t fSmallSyst
flag for the axes ranges in pPb
Double_t Py() const
Definition: AliEmcalJet.h:107
Double_t Phi() const
Definition: AliEmcalJet.h:117
Int_t GetNParticles() const
Bool_t FillHistograms()
Function filling histograms.
TH2F ** fh2PtCorrSubFacV1
! subtracted pT vs -(rho+rhom)*V1
THnSparse * fhnDeltaMassAndBkgInfo
! DeltaM, DeltapT bkg-unsubtracted M and pT, rho and rhom
TH2F ** fh2PtTrueSubFacV2
! true pT vs 0.5(rho+rhom)^2*V2
Int_t fCentBin
!event centrality bin
TH3F * fhJetSubMatchEtaPhiPt
! eta, phi, pt distribution of jet subtracted and matched
Double_t E() const
Definition: AliEmcalJet.h:119
Bool_t fPartialExclusion
randomly esclude areas according to Ncoll
Container for particles within the EMCAL framework.
Float_t fM2nd
2nd order subtracted jet mass
Int_t TrackAt(Int_t idx) const
Definition: AliEmcalJet.h:160
UShort_t GetNumberOfTracks() const
Definition: AliEmcalJet.h:139
TH3F ** fh3MSubPtTrueLeadPt
! subtracted jet mass vs true jet pT vs LeadPt for matched jets for matched jets
Double_t Px() const
Definition: AliEmcalJet.h:106
TH2F * fhJetEtaPhiOvl
! eta-phi distribution of the selected signal jets
AliParticleContainer * GetParticleContainer(Int_t i=0) const
Get particle container attached to this task.
const TString & GetRhoMassName() const
Int_t fContainerOverlap
jets (jetO) with a pT cut selection to reject overlapping embedded single track (used only in single ...
AliParticleContainer * GetParticleContainer() const
AliEmcalJet * GetLeadingJet(const char *opt="")
TLorentzVector * fVecD
! vector with detector level jet
TH2F ** fh2NConstSubFacV2
! N constituents vs 0.5(rho+rhom)^2*V2
Double_t AreaEta() const
Definition: AliEmcalJet.h:132
TH2F ** fh2PtTrueSubFacV1
! true pT vs -(rho+rhom)*V1
int Int_t
Definition: External.C:63
float Float_t
Definition: External.C:68
Double_t fRadius
Radius that define overlap.
TLorentzVector * fJet1Vec
jet1(AA) vector
Int_t fNcentBins
how many centrality bins
Double_t MaxTrackPt() const
Definition: AliEmcalJet.h:155
virtual AliVParticle * GetAcceptParticle(Int_t i=-1) const
ResponseReference fResponseReference
true axis of response matrix
TH2F ** fh2MSubPtSubAll
! subtracted jet mass vs subtracted jet pT
TH3F ** fh3MSubPtRawDRMatch
! subtracted jet mass vs subtracted jet pT vs distance to leading Pb-Pb jet
TH2F ** fh2PtRawSubFacV1
! raw pT vs -(rho+rhom)*V1
AliEmcalJet * GetNextAcceptJet()
Double_t DeltaR(const AliVParticle *part) const
Double_t AreaPhi() const
Definition: AliEmcalJet.h:133
THnSparse ** fhnMassResponse
! Msub vs Mtrue vs PtCorr vs PtTrue vs DR
Double_t fMinFractionShared
only fill histos for jets if shared fraction larger than X
Double_t Pt() const
Definition: AliEmcalJet.h:109
TH1F * fhNJetsSelEv
! number of selected signal jets per event
Bool_t fOverlap
activate the check on overlap between single particle embedded and jetO (jet with a pT of at least 5 ...
TH3F ** fh3MTruePtTrueLeadPt
! true jet mass vs true jet pT vs LeadPt for matched jets for matched jets
JetMassVarType fJetMassVarType
observable to use
TH2F ** fh2MSubMatch
! subtracted jet mass vs match index (0: no match; 1:match)
AliEmcalList * fOutput
!output list
THnSparse * fhnResolution
! Contains mass and pT resolution
Float_t fM1st
1st order subtracted jet mass
Int_t fMatch
1: matched to MC jet; 0: no match
TTree * fTreeJetBkg
! tree with jet and bkg variables
TH2F ** fh2MSubPtRawAll
! subtracted jet mass vs subtracted jet pT
Represent a jet reconstructed using the EMCal jet framework.
Definition: AliEmcalJet.h:51
AliVParticle * GetEmbeddedConstituent(AliEmcalJet *jet)
Double_t Pz() const
Definition: AliEmcalJet.h:108
Int_t fNConst
N constituents in jet1.
Background fluctuation studies: dMdpT spectrum for PYTHIA and single track embedding for derivative s...
Double_t GetFractionSharedPt(const AliEmcalJet *jet, AliParticleContainer *cont2=0x0) const
TH2F * fhRjetTrvspTj
! distance in R between each jetO and embedded single track (those below fRadius are rejected) ...
TH2F ** fh2PtRawSubFacV2
! raw pT vs 0.5(rho+rhom)^2*V2
bool Bool_t
Definition: External.C:53
AliEmcalJetShapeProperties * GetShapeProperties() const
Definition: AliEmcalJet.h:361
Bool_t fFromTree
Input embedding from tree.
TLorentzVector * fJet2Vec
jet2(probe) vector
TLorentzVector * fVecP
! vector with particle level jet
Bool_t fCreateTree
create output tree
Double_t M() const
Definition: AliEmcalJet.h:120
Int_t fContainerNoEmb
subtracted jets from Pb-Pb only events
Bool_t fSingleTrackEmb
single track embedding
Background fluctuation studies: dMdpT spectrum for PYTHIA and single track embedding.
Container for jet within the EMCAL jet framework.
Int_t fContainerBase
jets to be analyzed
TH3F ** fh3PtTrueDeltaMRelLeadPt
! true jet pT vs (Msub - Mtrue)/Mtrue vs LeadPt for matched jets
Bool_t reject