AliPhysics  4c9ecbb (4c9ecbb)
AliVertexingHFUtils.cxx
Go to the documentation of this file.
1 /**************************************************************************
2  * Copyright(c) 2007-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 #include <TMath.h>
17 #include <TRandom.h>
18 #include <TProfile.h>
19 #include <TClonesArray.h>
20 #include <TH1F.h>
21 #include <TH2F.h>
22 #include <TF1.h>
23 #include <TParticle.h>
24 #include "AliMCEvent.h"
25 #include "AliAODEvent.h"
26 #include "AliAODMCHeader.h"
27 #include "AliGenEventHeader.h"
28 #include "AliAODMCParticle.h"
29 #include "AliAODRecoDecayHF.h"
30 #include "AliVertexingHFUtils.h"
31 
32 /* $Id$ */
33 
35 // //
36 // Class with functions useful for different D2H analyses //
37 // - event plane resolution //
38 // - <pt> calculation with side band subtraction //
39 // - tracklet multiplicity calculation //
40 // Origin: F.Prino, Torino, prino@to.infn.it //
41 // //
43 
45 ClassImp(AliVertexingHFUtils);
47 
48 
49 //______________________________________________________________________
50 AliVertexingHFUtils::AliVertexingHFUtils():TObject(),
51  fK(1),
52  fSubRes(1.),
53  fMinEtaForTracklets(-1.),
54  fMaxEtaForTracklets(1.)
55 {
57 }
58 
59 
60 //______________________________________________________________________
61 AliVertexingHFUtils::AliVertexingHFUtils(Int_t k):
62  TObject(),
63  fK(k),
64  fSubRes(1.),
65  fMinEtaForTracklets(-1.),
66  fMaxEtaForTracklets(1.)
67 {
69 }
70 
71 
72 //______________________________________________________________________
73 void AliVertexingHFUtils::ComputeSignificance(Double_t signal, Double_t errsignal, Double_t background, Double_t errbackground, Double_t &significance,Double_t &errsignificance){
75 
76 
77  Double_t errSigSq=errsignal*errsignal;
78  Double_t errBkgSq=errbackground*errbackground;
79  Double_t sigPlusBkg=signal+background;
80  if(sigPlusBkg>0. && signal>0.){
81  significance = signal/TMath::Sqrt(signal+background);
82  errsignificance = significance*TMath::Sqrt((errSigSq+errBkgSq)/(4.*sigPlusBkg*sigPlusBkg)+(background/sigPlusBkg)*errSigSq/signal/signal);
83  }else{
84  significance=0.;
85  errsignificance=0.;
86  }
87  return;
88 
89 }
90 //______________________________________________________________________
91 Double_t AliVertexingHFUtils::Pol(Double_t x, Int_t k){
93  Double_t c[5];
94  if(k==1){
95  c[0]=0.626657; c[1]=0.; c[2]=-0.09694; c[3]=0.02754; c[4]=-0.002283;
96  }
97  else if(k==2){
98  c[0]=0.; c[1]=0.25; c[2]=-0.011414; c[3]=-0.034726; c[4]=0.006815;
99  }
100  else return -1;
101  return c[0]*x+c[1]*x*x+c[2]*x*x*x+c[3]*x*x*x*x+c[4]*x*x*x*x*x;
102 }
103 
104 //______________________________________________________________________
105 Double_t AliVertexingHFUtils:: ResolK1(Double_t x){
106  return TMath::Sqrt(TMath::Pi()/8)*x*TMath::Exp(-x*x/4)*(TMath::BesselI0(x*x/4)+TMath::BesselI1(x*x/4));
107 }
108 
109 
110 //______________________________________________________________________
111 Double_t AliVertexingHFUtils::FindChi(Double_t res, Int_t k){
113 
114  Double_t x1=0;
115  Double_t x2=15;
116  Double_t y1,y2;
117  if(k==1){
118  y1=ResolK1(x1)-res;
119  y2=ResolK1(x2)-res;
120  }
121  else if(k==2){
122  y1=Pol(x1,2)-res;
123  y2=Pol(x2,2)-res;
124  }
125  else return -1;
126 
127  if(y1*y2>0) return -1;
128  if(y1==0) return y1;
129  if(y2==0) return y2;
130  Double_t xmed,ymed;
131  Int_t jiter=0;
132  while((x2-x1)>0.0001){
133  xmed=0.5*(x1+x2);
134  if(k==1){
135  y1=ResolK1(x1)-res;
136  y2=ResolK1(x2)-res;
137  ymed=ResolK1(xmed)-res;
138  }
139  else if(k==2){
140  y1=Pol(x1,2)-res;
141  y2=Pol(x2,2)-res;
142  ymed=Pol(xmed,2)-res;
143  }
144  else return -1;
145  if((y1*ymed)<0) x2=xmed;
146  if((y2*ymed)<0)x1=xmed;
147  if(ymed==0) return xmed;
148  jiter++;
149  }
150  return 0.5*(x1+x2);
151 }
152 
153 //______________________________________________________________________
154 Double_t AliVertexingHFUtils::GetFullEvResol(Double_t resSub, Int_t k){
156  Double_t chisub=FindChi(resSub,k);
157  Double_t chifull=chisub*TMath::Sqrt(2);
158  if(k==1) return ResolK1(chifull);
159  else if(k==2) return Pol(chifull,2);
160  else{
161  printf("k should be <=2\n");
162  return 1.;
163  }
164 }
165 
166 //______________________________________________________________________
167 Double_t AliVertexingHFUtils::GetFullEvResol(const TH1F* hSubEvCorr, Int_t k){
169  if(!hSubEvCorr) return 1.;
170  Double_t resSub=GetSubEvResol(hSubEvCorr);
171  return GetFullEvResol(resSub,k);
172 }
173 //______________________________________________________________________
174 Double_t AliVertexingHFUtils::GetFullEvResolLowLim(const TH1F* hSubEvCorr, Int_t k){
176  if(!hSubEvCorr) return 1.;
177  Double_t resSub=GetSubEvResolLowLim(hSubEvCorr);
178  printf("%f\n",resSub);
179  return GetFullEvResol(resSub,k);
180 }
181 //______________________________________________________________________
182 Double_t AliVertexingHFUtils::GetFullEvResolHighLim(const TH1F* hSubEvCorr, Int_t k){
184  if(!hSubEvCorr) return 1.;
185  Double_t resSub=GetSubEvResolHighLim(hSubEvCorr);
186  printf("%f\n",resSub);
187  return GetFullEvResol(resSub,k);
188 }
189 //______________________________________________________________________
190 Int_t AliVertexingHFUtils::GetNumberOfTrackletsInEtaRange(AliAODEvent* ev, Double_t mineta, Double_t maxeta){
192  AliAODTracklets* tracklets=ev->GetTracklets();
193  Int_t nTr=tracklets->GetNumberOfTracklets();
194  Int_t count=0;
195  for(Int_t iTr=0; iTr<nTr; iTr++){
196  Double_t theta=tracklets->GetTheta(iTr);
197  Double_t eta=-TMath::Log(TMath::Tan(theta/2.));
198  if(eta>mineta && eta<maxeta) count++;
199  }
200  return count;
201 }
202 //______________________________________________________________________
203 Int_t AliVertexingHFUtils::GetGeneratedMultiplicityInEtaRange(TClonesArray* arrayMC, Double_t mineta, Double_t maxeta){
205 
206  Int_t nChargedMC=0;
207  for(Int_t i=0;i<arrayMC->GetEntriesFast();i++){
208  AliAODMCParticle *part=(AliAODMCParticle*)arrayMC->UncheckedAt(i);
209  Int_t charge = part->Charge();
210  Double_t eta = part->Eta();
211  if(charge!=0 && eta>mineta && eta<maxeta) nChargedMC++;
212  }
213  return nChargedMC;
214 }
215 //______________________________________________________________________
216 Int_t AliVertexingHFUtils::GetGeneratedPrimariesInEtaRange(TClonesArray* arrayMC, Double_t mineta, Double_t maxeta){
218 
219  Int_t nChargedMC=0;
220  for(Int_t i=0;i<arrayMC->GetEntriesFast();i++){
221  AliAODMCParticle *part=(AliAODMCParticle*)arrayMC->UncheckedAt(i);
222  Int_t charge = part->Charge();
223  Double_t eta = part->Eta();
224  if(charge!=0 && eta>mineta && eta<maxeta){
225  if(part->IsPrimary())nChargedMC++;
226  }
227  }
228  return nChargedMC;
229 }
230 //______________________________________________________________________
231 Int_t AliVertexingHFUtils::GetGeneratedPhysicalPrimariesInEtaRange(TClonesArray* arrayMC, Double_t mineta, Double_t maxeta){
233 
234  Int_t nChargedMC=0;
235  for(Int_t i=0;i<arrayMC->GetEntriesFast();i++){
236  AliAODMCParticle *part=(AliAODMCParticle*)arrayMC->UncheckedAt(i);
237  Int_t charge = part->Charge();
238  Double_t eta = part->Eta();
239  if(charge!=0 && eta>mineta && eta<maxeta){
240  if(part->IsPhysicalPrimary())nChargedMC++;
241  }
242  }
243  return nChargedMC;
244 }
245 
246 
247 //______________________________________________________________________
248 Double_t AliVertexingHFUtils::GetVZEROAEqualizedMultiplicity(AliAODEvent* ev){
249  //
252  // http://git.cern.ch/pubweb/AliRoot.git/blob/HEAD:/ANALYSIS/AliCentralitySelectionTask.cxx#l1345
253 
254  Double_t multV0AEq=0;
255  for(Int_t iCh = 32; iCh < 64; ++iCh) {
256  Double_t mult = ev->GetVZEROEqMultiplicity(iCh);
257  multV0AEq += mult;
258  }
259  return multV0AEq;
260 }
261 
262 //______________________________________________________________________
263 Double_t AliVertexingHFUtils::GetVZEROCEqualizedMultiplicity(AliAODEvent* ev){
267 
268  Double_t multV0CEq=0;
269  for(Int_t iCh = 0; iCh < 32; ++iCh) {
270  Double_t mult = ev->GetVZEROEqMultiplicity(iCh);
271  multV0CEq += mult;
272  }
273  return multV0CEq;
274 }
275 
276 //______________________________________________________________________
277 void AliVertexingHFUtils::AveragePt(Float_t& averagePt, Float_t& errorPt,Float_t ptmin,Float_t ptmax, TH2F* hMassD, Float_t massFromFit, Float_t sigmaFromFit, TF1* funcB2, Float_t sigmaRangeForSig,Float_t sigmaRangeForBkg, Float_t minMass, Float_t maxMass, Int_t rebin){
278 
280 
281  //Make 2D histos in the desired pt range
282  Int_t start=hMassD->FindBin(ptmin);
283  Int_t end=hMassD->FindBin(ptmax)-1;
284  const Int_t nx=end-start;
285  TH2F *hMassDpt=new TH2F("hptmass","hptmass",nx,ptmin,ptmax,hMassD->GetNbinsY(),hMassD->GetYaxis()->GetBinLowEdge(1),hMassD->GetYaxis()->GetBinLowEdge(hMassD->GetNbinsY())+hMassD->GetYaxis()->GetBinWidth(hMassD->GetNbinsY()));
286  for(Int_t ix=start;ix<end;ix++){
287  for(Int_t iy=1;iy<=hMassD->GetNbinsY();iy++){
288  hMassDpt->SetBinContent(ix-start+1,iy,hMassD->GetBinContent(ix,iy));
289  hMassDpt->SetBinError(ix-start+1,iy,hMassD->GetBinError(ix,iy));
290  }
291  }
292 
293  Double_t minMassSig=massFromFit-sigmaRangeForSig*sigmaFromFit;
294  Double_t maxMassSig=massFromFit+sigmaRangeForSig*sigmaFromFit;
295  Int_t minBinSig=hMassD->GetYaxis()->FindBin(minMassSig);
296  Int_t maxBinSig=hMassD->GetYaxis()->FindBin(maxMassSig);
297  Double_t minMassSigBin=hMassD->GetYaxis()->GetBinLowEdge(minBinSig);
298  Double_t maxMassSigBin=hMassD->GetYaxis()->GetBinLowEdge(maxBinSig)+hMassD->GetYaxis()->GetBinWidth(maxBinSig);
299  // printf("Signal Fit Limits = %f %f\n",minMassSigBin,maxMassSigBin);
300 
301  Double_t maxMassBkgLow=massFromFit-sigmaRangeForBkg*sigmaFromFit;
302  Int_t minBinBkgLow=TMath::Max(hMassD->GetYaxis()->FindBin(minMass),2);
303  Int_t maxBinBkgLow=hMassD->GetYaxis()->FindBin(maxMassBkgLow);
304  Double_t minMassBkgLowBin=hMassD->GetYaxis()->GetBinLowEdge(minBinBkgLow);
305  Double_t maxMassBkgLowBin=hMassD->GetYaxis()->GetBinLowEdge(maxBinBkgLow)+hMassD->GetYaxis()->GetBinWidth(maxBinBkgLow);
306  Double_t minMassBkgHi=massFromFit+sigmaRangeForBkg*sigmaFromFit;
307  Int_t minBinBkgHi=hMassD->GetYaxis()->FindBin(minMassBkgHi);
308  Int_t maxBinBkgHi=TMath::Min(hMassD->GetYaxis()->FindBin(maxMass),hMassD->GetNbinsY()-1);
309  Double_t minMassBkgHiBin=hMassD->GetYaxis()->GetBinLowEdge(minBinBkgHi);
310  Double_t maxMassBkgHiBin=hMassD->GetYaxis()->GetBinLowEdge(maxBinBkgHi)+hMassD->GetYaxis()->GetBinWidth(maxBinBkgHi);
311  // printf("BKG Fit Limits = %f %f && %f %f\n",minMassBkgLowBin,maxMassBkgLowBin,minMassBkgHiBin,maxMassBkgHiBin);
312 
313  Double_t bkgSig=funcB2->Integral(minMassSigBin,maxMassSigBin);
314  Double_t bkgLow=funcB2->Integral(minMassBkgLowBin,maxMassBkgLowBin);
315  Double_t bkgHi=funcB2->Integral(minMassBkgHiBin,maxMassBkgHiBin);
316  // printf("Background integrals = %f %f %f\n",bkgLow,bkgSig,bkgHi);
317 
318  TH1F* hMptBkgLo=(TH1F*)hMassDpt->ProjectionX("hPtBkgLoBin",minBinBkgLow,maxBinBkgLow);
319  TH1F* hMptBkgHi=(TH1F*)hMassDpt->ProjectionX("hPtBkgHiBin",minBinBkgHi,maxBinBkgHi);
320  TH1F* hMptSigReg=(TH1F*)hMassDpt->ProjectionX("hCPtBkgSigBin",minBinSig,maxBinSig);
321 
322  hMptBkgLo->Rebin(rebin);
323  hMptBkgHi->Rebin(rebin);
324  hMptSigReg->Rebin(rebin);
325 
326  hMptBkgLo->Sumw2();
327  hMptBkgHi->Sumw2();
328  TH1F* hMptBkgLoScal=(TH1F*)hMptBkgLo->Clone("hPtBkgLoScalBin");
329  hMptBkgLoScal->Scale(bkgSig/bkgLow);
330  TH1F* hMptBkgHiScal=(TH1F*)hMptBkgHi->Clone("hPtBkgHiScalBin");
331  hMptBkgHiScal->Scale(bkgSig/bkgHi);
332 
333  TH1F* hMptBkgAver=0x0;
334  hMptBkgAver=(TH1F*)hMptBkgLoScal->Clone("hPtBkgAverBin");
335  hMptBkgAver->Add(hMptBkgHiScal);
336  hMptBkgAver->Scale(0.5);
337  TH1F* hMptSig=(TH1F*)hMptSigReg->Clone("hCPtSigBin");
338  hMptSig->Add(hMptBkgAver,-1.);
339 
340  averagePt = hMptSig->GetMean();
341  errorPt = hMptSig->GetMeanError();
342 
343  delete hMptBkgLo;
344  delete hMptBkgHi;
345  delete hMptSigReg;
346  delete hMptBkgLoScal;
347  delete hMptBkgHiScal;
348  delete hMptBkgAver;
349  delete hMassDpt;
350  delete hMptSig;
351 
352 }
353 //____________________________________________________________________________
354 Bool_t AliVertexingHFUtils::CheckT0TriggerFired(AliAODEvent* aodEv){
356  const Double32_t *mean = aodEv->GetT0TOF();
357  if(mean && mean[0]<9999.) return kTRUE;
358  else return kFALSE;
359 }
360 //____________________________________________________________________________
361 Double_t AliVertexingHFUtils::GetTrueImpactParameterDzero(AliAODMCHeader *mcHeader, TClonesArray* arrayMC, AliAODMCParticle *partD) {
363 
364  if(!partD || !arrayMC || !mcHeader) return 99999.;
365  Int_t code=partD->GetPdgCode();
366  if(TMath::Abs(code)!=421) return 99999.;
367 
368  Double_t vtxTrue[3];
369  mcHeader->GetVertex(vtxTrue);
370  Double_t origD[3];
371  partD->XvYvZv(origD);
372  Short_t charge=partD->Charge();
373  Double_t pXdauTrue[2],pYdauTrue[2],pZdauTrue[2];
374  for(Int_t iDau=0; iDau<2; iDau++){
375  pXdauTrue[iDau]=0.;
376  pYdauTrue[iDau]=0.;
377  pZdauTrue[iDau]=0.;
378  }
379 
380  Int_t nDau=partD->GetNDaughters();
381  Int_t labelFirstDau = partD->GetDaughter(0);
382  if(nDau==2){
383  for(Int_t iDau=0; iDau<2; iDau++){
384  Int_t ind = labelFirstDau+iDau;
385  AliAODMCParticle* part = dynamic_cast<AliAODMCParticle*>(arrayMC->At(ind));
386  if(!part){
387  printf("Daughter particle not found in MC array");
388  return 99999.;
389  }
390  pXdauTrue[iDau]=part->Px();
391  pYdauTrue[iDau]=part->Py();
392  pZdauTrue[iDau]=part->Pz();
393  }
394  }else{
395  return 99999.;
396  }
397 
398  Double_t d0dummy[2]={0.,0.};
399  AliAODRecoDecayHF aodDvsMC(vtxTrue,origD,2,charge,pXdauTrue,pYdauTrue,pZdauTrue,d0dummy);
400  return aodDvsMC.ImpParXY();
401 
402 }
403 //____________________________________________________________________________
404 Double_t AliVertexingHFUtils::GetTrueImpactParameterDplus(AliAODMCHeader *mcHeader, TClonesArray* arrayMC, AliAODMCParticle *partD) {
406 
407  if(!partD || !arrayMC || !mcHeader) return 99999.;
408  Int_t code=partD->GetPdgCode();
409  if(TMath::Abs(code)!=411) return 99999.;
410 
411  Double_t vtxTrue[3];
412  mcHeader->GetVertex(vtxTrue);
413  Double_t origD[3];
414  partD->XvYvZv(origD);
415  Short_t charge=partD->Charge();
416  Double_t pXdauTrue[3],pYdauTrue[3],pZdauTrue[3];
417  for(Int_t iDau=0; iDau<3; iDau++){
418  pXdauTrue[iDau]=0.;
419  pYdauTrue[iDau]=0.;
420  pZdauTrue[iDau]=0.;
421  }
422 
423  Int_t nDau=partD->GetNDaughters();
424  Int_t labelFirstDau = partD->GetDaughter(0);
425  if(nDau==3){
426  for(Int_t iDau=0; iDau<3; iDau++){
427  Int_t ind = labelFirstDau+iDau;
428  AliAODMCParticle* part = dynamic_cast<AliAODMCParticle*>(arrayMC->At(ind));
429  if(!part){
430  printf("Daughter particle not found in MC array");
431  return 99999.;
432  }
433  pXdauTrue[iDau]=part->Px();
434  pYdauTrue[iDau]=part->Py();
435  pZdauTrue[iDau]=part->Pz();
436  }
437  }else if(nDau==2){
438  Int_t theDau=0;
439  for(Int_t iDau=0; iDau<2; iDau++){
440  Int_t ind = labelFirstDau+iDau;
441  AliAODMCParticle* part = dynamic_cast<AliAODMCParticle*>(arrayMC->At(ind));
442  if(!part){
443  printf("Daughter particle not found in MC array");
444  return 99999.;
445  }
446  Int_t pdgCode=TMath::Abs(part->GetPdgCode());
447  if(pdgCode==211 || pdgCode==321){
448  pXdauTrue[theDau]=part->Px();
449  pYdauTrue[theDau]=part->Py();
450  pZdauTrue[theDau]=part->Pz();
451  ++theDau;
452  }else{
453  Int_t nDauRes=part->GetNDaughters();
454  if(nDauRes==2){
455  Int_t labelFirstDauRes = part->GetDaughter(0);
456  for(Int_t iDauRes=0; iDauRes<2; iDauRes++){
457  Int_t indDR = labelFirstDauRes+iDauRes;
458  AliAODMCParticle* partDR = dynamic_cast<AliAODMCParticle*>(arrayMC->At(indDR));
459  if(!partDR){
460  printf("Daughter particle not found in MC array");
461  return 99999.;
462  }
463 
464  Int_t pdgCodeDR=TMath::Abs(partDR->GetPdgCode());
465  if(pdgCodeDR==211 || pdgCodeDR==321){
466  pXdauTrue[theDau]=partDR->Px();
467  pYdauTrue[theDau]=partDR->Py();
468  pZdauTrue[theDau]=partDR->Pz();
469  ++theDau;
470  }
471  }
472  }
473  }
474  }
475  if(theDau!=3){
476  printf("Wrong number of decay prongs");
477  return 99999.;
478  }
479  }
480 
481  Double_t d0dummy[3]={0.,0.,0.};
482  AliAODRecoDecayHF aodDvsMC(vtxTrue,origD,3,charge,pXdauTrue,pYdauTrue,pZdauTrue,d0dummy);
483  return aodDvsMC.ImpParXY();
484 
485 }
486 
487 
488 
489 //____________________________________________________________________________
490 Double_t AliVertexingHFUtils::GetCorrectedNtracklets(TProfile* estimatorAvg, Double_t uncorrectedNacc, Double_t vtxZ, Double_t refMult) {
491  //
492  // Correct the number of accepted tracklets based on a TProfile Hist
493  //
494  //
495 
496  if(TMath::Abs(vtxZ)>10.0){
497  // printf("ERROR: Z vertex out of range for correction of multiplicity\n");
498  return uncorrectedNacc;
499  }
500 
501  if(!estimatorAvg){
502  printf("ERROR: Missing TProfile for correction of multiplicity\n");
503  return uncorrectedNacc;
504  }
505 
506  Double_t localAvg = estimatorAvg->GetBinContent(estimatorAvg->FindBin(vtxZ));
507 
508  Double_t deltaM = uncorrectedNacc*(refMult/localAvg - 1);
509 
510  Double_t correctedNacc = uncorrectedNacc + (deltaM>0 ? 1 : -1) * gRandom->Poisson(TMath::Abs(deltaM));
511 
512  return correctedNacc;
513 }
514 //______________________________________________________________________
515 TString AliVertexingHFUtils::GetGenerator(Int_t label, AliAODMCHeader* header){
517 
518  Int_t nsumpart=0;
519  TList *lh=header->GetCocktailHeaders();
520  Int_t nh=lh->GetEntries();
521  for(Int_t i=0;i<nh;i++){
522  AliGenEventHeader* gh=(AliGenEventHeader*)lh->At(i);
523  TString genname=gh->GetName();
524  Int_t npart=gh->NProduced();
525  if(label>=nsumpart && label<(nsumpart+npart)) return genname;
526  nsumpart+=npart;
527  }
528  TString empty="";
529  return empty;
530 }
531 //_____________________________________________________________________
532 void AliVertexingHFUtils::GetTrackPrimaryGenerator(AliAODTrack *track,AliAODMCHeader *header,TClonesArray *arrayMC,TString &nameGen){
533 
535 
536  Int_t lab=TMath::Abs(track->GetLabel());
537  nameGen=GetGenerator(lab,header);
538 
539  // Int_t countControl=0;
540 
541  while(nameGen.IsWhitespace()){
542  AliAODMCParticle *mcpart= (AliAODMCParticle*)arrayMC->At(lab);
543  if(!mcpart){
544  printf("AliVertexingHFUtils::IsTrackInjected - BREAK: No valid AliAODMCParticle at label %i\n",lab);
545  break;
546  }
547  Int_t mother = mcpart->GetMother();
548  if(mother<0){
549  printf("AliVertexingHFUtils::IsTrackInjected - BREAK: Reached primary particle without valid mother\n");
550  break;
551  }
552  lab=mother;
553  nameGen=GetGenerator(mother,header);
554  // countControl++;
555  // if(countControl>=10){ // 10 = arbitrary number; protection from infinite loops
556  // printf("AliVertexingHFUtils::IsTrackInjected - BREAK: Protection from infinite loop active\n");
557  // break;
558  // }
559  }
560 
561  return;
562 }
563 //----------------------------------------------------------------------
564 Bool_t AliVertexingHFUtils::IsTrackInjected(AliAODTrack *track,AliAODMCHeader *header,TClonesArray *arrayMC){
566  TString nameGen;
567  GetTrackPrimaryGenerator(track,header,arrayMC,nameGen);
568 
569  if(nameGen.IsWhitespace() || nameGen.Contains("ijing")) return kFALSE;
570 
571  return kTRUE;
572 }
573 //____________________________________________________________________________
574 Bool_t AliVertexingHFUtils::IsCandidateInjected(AliAODRecoDecayHF *cand, AliAODMCHeader *header,TClonesArray *arrayMC){
576 
577  Int_t nprongs=cand->GetNProngs();
578  for(Int_t i=0;i<nprongs;i++){
579  AliAODTrack *daugh=(AliAODTrack*)cand->GetDaughter(i);
580  if(IsTrackInjected(daugh,header,arrayMC)) return kTRUE;
581  }
582  return kFALSE;
583 }
584 //____________________________________________________________________________
585 Bool_t AliVertexingHFUtils::HasCascadeCandidateAnyDaughInjected(AliAODRecoCascadeHF *cand, AliAODMCHeader *header,TClonesArray *arrayMC){
587 
588  AliAODTrack* bach = cand->GetBachelor();
589  if(IsTrackInjected(bach, header, arrayMC)) {
590  AliDebug(2, "Bachelor is injected, the whole candidate is then injected");
591  return kTRUE;
592  }
593  AliAODv0* v0 = cand->Getv0();
594  Int_t nprongs = v0->GetNProngs();
595  for(Int_t i = 0; i < nprongs; i++){
596  AliAODTrack *daugh = (AliAODTrack*)v0->GetDaughter(i);
597  if(IsTrackInjected(daugh,header,arrayMC)) {
598  AliDebug(2, Form("V0 daughter number %d is injected, the whole candidate is then injected", i));
599  return kTRUE;
600  }
601  }
602  return kFALSE;
603 }
604 //____________________________________________________________________________
605 Int_t AliVertexingHFUtils::CheckOrigin(AliMCEvent* mcEvent, TParticle *mcPart, Bool_t searchUpToQuark){
607 
608  Int_t pdgGranma = 0;
609  Int_t mother = 0;
610  mother = mcPart->GetFirstMother();
611  Int_t istep = 0;
612  Int_t abspdgGranma =0;
613  Bool_t isFromB=kFALSE;
614  Bool_t isQuarkFound=kFALSE;
615  while (mother >0 ){
616  istep++;
617  TParticle* mcGranma = mcEvent->Particle(mother);
618  if (mcGranma){
619  pdgGranma = mcGranma->GetPdgCode();
620  abspdgGranma = TMath::Abs(pdgGranma);
621  if ((abspdgGranma > 500 && abspdgGranma < 600) || (abspdgGranma > 5000 && abspdgGranma < 6000)){
622  isFromB=kTRUE;
623  }
624  if(abspdgGranma==4 || abspdgGranma==5) isQuarkFound=kTRUE;
625  mother = mcGranma->GetFirstMother();
626  }else{
627  printf("CheckOrigin: Failed casting the mother particle!");
628  break;
629  }
630  }
631  if(searchUpToQuark && !isQuarkFound) return 0;
632  if(isFromB) return 5;
633  else return 4;
634 
635 }
636 //____________________________________________________________________________
637 Int_t AliVertexingHFUtils::CheckOrigin(TClonesArray* arrayMC, AliAODMCParticle *mcPart, Bool_t searchUpToQuark){
639 
640  Int_t pdgGranma = 0;
641  Int_t mother = 0;
642  mother = mcPart->GetMother();
643  Int_t istep = 0;
644  Int_t abspdgGranma =0;
645  Bool_t isFromB=kFALSE;
646  Bool_t isQuarkFound=kFALSE;
647  while (mother >0 ){
648  istep++;
649  AliAODMCParticle* mcGranma = dynamic_cast<AliAODMCParticle*>(arrayMC->At(mother));
650  if (mcGranma){
651  pdgGranma = mcGranma->GetPdgCode();
652  abspdgGranma = TMath::Abs(pdgGranma);
653  if ((abspdgGranma > 500 && abspdgGranma < 600) || (abspdgGranma > 5000 && abspdgGranma < 6000)){
654  isFromB=kTRUE;
655  }
656  if(abspdgGranma==4 || abspdgGranma==5) isQuarkFound=kTRUE;
657  mother = mcGranma->GetMother();
658  }else{
659  printf("AliVertexingHFUtils::CheckOrigin: Failed casting the mother particle!");
660  break;
661  }
662  }
663  if(searchUpToQuark && !isQuarkFound) return 0;
664  if(isFromB) return 5;
665  else return 4;
666 
667 }
668 //____________________________________________________________________________
669 Double_t AliVertexingHFUtils::GetBeautyMotherPt(TClonesArray* arrayMC, AliAODMCParticle *mcPart){
671 
672  Int_t pdgGranma = 0;
673  Int_t mother = 0;
674  mother = mcPart->GetMother();
675  Int_t istep = 0;
676  Int_t abspdgGranma =0;
677  while (mother >0 ){
678  istep++;
679  AliAODMCParticle* mcGranma = dynamic_cast<AliAODMCParticle*>(arrayMC->At(mother));
680  if (mcGranma){
681  pdgGranma = mcGranma->GetPdgCode();
682  abspdgGranma = TMath::Abs(pdgGranma);
683  if ((abspdgGranma > 500 && abspdgGranma < 600) || (abspdgGranma > 5000 && abspdgGranma < 6000)){
684  return mcGranma->Pt();
685  }
686  if(abspdgGranma==4) return -999.;
687  if(abspdgGranma==5) return -1.;
688  mother = mcGranma->GetMother();
689  }else{
690  printf("AliVertexingHFUtils::GetBeautyMotherPt: Failed casting the mother particle!");
691  break;
692  }
693  }
694  return -999.;
695 }
696 //____________________________________________________________________________
697 Int_t AliVertexingHFUtils::CheckD0Decay(AliMCEvent* mcEvent, Int_t label, Int_t* arrayDauLab){
699 
700  if(label<0) return -1;
701  TParticle* mcPart = mcEvent->Particle(label);
702  Int_t pdgD=mcPart->GetPdgCode();
703  if(TMath::Abs(pdgD)!=421) return -1;
704 
705  Int_t nDau=mcPart->GetNDaughters();
706 
707  if(nDau==2){
708  Int_t daughter0 = mcPart->GetDaughter(0);
709  Int_t daughter1 = mcPart->GetDaughter(1);
710  TParticle* mcPartDaughter0 = mcEvent->Particle(daughter0);
711  TParticle* mcPartDaughter1 = mcEvent->Particle(daughter1);
712  if(!mcPartDaughter0 || !mcPartDaughter1) return -1;
713  arrayDauLab[0]=daughter0;
714  arrayDauLab[1]=daughter1;
715  Int_t pdgCode0=mcPartDaughter0->GetPdgCode();
716  Int_t pdgCode1=mcPartDaughter1->GetPdgCode();
717  if(!(TMath::Abs(pdgCode0)==321 && TMath::Abs(pdgCode1)==211) &&
718  !(TMath::Abs(pdgCode0)==211 && TMath::Abs(pdgCode1)==321)){
719  return -1;
720  }
721  if(TMath::Abs(pdgCode0)==321 && (pdgD*pdgCode0)>0) return -1;
722  if(TMath::Abs(pdgCode1)==321 && (pdgD*pdgCode1)>0) return -1;
723  if((pdgCode0*pdgCode1)>0) return -1;
724  Double_t sumPxDau=mcPartDaughter0->Px()+mcPartDaughter1->Px();
725  Double_t sumPyDau=mcPartDaughter0->Py()+mcPartDaughter1->Py();
726  Double_t sumPzDau=mcPartDaughter0->Pz()+mcPartDaughter1->Pz();
727  if(TMath::Abs(mcPart->Px()-sumPxDau)>0.001) return -2;
728  if(TMath::Abs(mcPart->Py()-sumPyDau)>0.001) return -2;
729  if(TMath::Abs(mcPart->Pz()-sumPzDau)>0.001) return -2;
730  return 1;
731  }
732 
733  if(nDau==3 || nDau==4){
734  Int_t nKaons=0;
735  Int_t nPions=0;
736  Double_t sumPxDau=0.;
737  Double_t sumPyDau=0.;
738  Double_t sumPzDau=0.;
739  Int_t nFoundKpi=0;
740  Int_t labelFirstDau = mcPart->GetDaughter(0);
741  for(Int_t iDau=0; iDau<nDau; iDau++){
742  Int_t indDau = labelFirstDau+iDau;
743  if(indDau<0) return -1;
744  TParticle* dau=mcEvent->Particle(indDau);
745  if(!dau) return -1;
746  Int_t pdgdau=dau->GetPdgCode();
747  if(TMath::Abs(pdgdau)==321){
748  if(pdgD>0 && pdgdau>0) return -1;
749  if(pdgD<0 && pdgdau<0) return -1;
750  nKaons++;
751  sumPxDau+=dau->Px();
752  sumPyDau+=dau->Py();
753  sumPzDau+=dau->Pz();
754  arrayDauLab[nFoundKpi++]=indDau;
755  if(nFoundKpi>4) return -1;
756  }else if(TMath::Abs(pdgdau)==211){
757  nPions++;
758  sumPxDau+=dau->Px();
759  sumPyDau+=dau->Py();
760  sumPzDau+=dau->Pz();
761  arrayDauLab[nFoundKpi++]=indDau;
762  if(nFoundKpi>4) return -1;
763  }else if(TMath::Abs(pdgdau)==113 || TMath::Abs(pdgdau)==313){
764  Int_t nResDau=dau->GetNDaughters();
765  if(nResDau!=2) return -1;
766  Int_t indFirstResDau=dau->GetDaughter(0);
767  for(Int_t resDau=0; resDau<2; resDau++){
768  Int_t indResDau=indFirstResDau+resDau;
769  if(indResDau<0) return -1;
770  TParticle* resdau=mcEvent->Particle(indResDau);
771  if(!resdau) return -1;
772  Int_t pdgresdau=resdau->GetPdgCode();
773  if(TMath::Abs(pdgresdau)==321){
774  if(pdgD>0 && pdgresdau>0) return -1;
775  if(pdgD<0 && pdgresdau<0) return -1;
776  nKaons++;
777  sumPxDau+=resdau->Px();
778  sumPyDau+=resdau->Py();
779  sumPzDau+=resdau->Pz();
780  arrayDauLab[nFoundKpi++]=indResDau;
781  if(nFoundKpi>4) return -1;
782  }
783  if(TMath::Abs(pdgresdau)==211){
784  nPions++;
785  sumPxDau+=resdau->Px();
786  sumPyDau+=resdau->Py();
787  sumPzDau+=resdau->Pz();
788  arrayDauLab[nFoundKpi++]=indResDau;
789  if(nFoundKpi>4) return -1;
790  }
791  }
792  }else{
793  return -1;
794  }
795  }
796  if(nPions!=3) return -1;
797  if(nKaons!=1) return -1;
798  if(TMath::Abs(mcPart->Px()-sumPxDau)>0.001) return -1;
799  if(TMath::Abs(mcPart->Py()-sumPyDau)>0.001) return -1;
800  if(TMath::Abs(mcPart->Pz()-sumPzDau)>0.001) return -1;
801  return 2;
802  }
803  return -1;
804 }
805 
806 //____________________________________________________________________________
807 Int_t AliVertexingHFUtils::CheckD0Decay(TClonesArray* arrayMC, AliAODMCParticle *mcPart, Int_t* arrayDauLab){
809 
810  Int_t pdgD=mcPart->GetPdgCode();
811  if(TMath::Abs(pdgD)!=421) return -1;
812 
813  Int_t nDau=mcPart->GetNDaughters();
814 
815  if(nDau==2){
816  Int_t daughter0 = mcPart->GetDaughter(0);
817  Int_t daughter1 = mcPart->GetDaughter(1);
818  AliAODMCParticle* mcPartDaughter0 = dynamic_cast<AliAODMCParticle*>(arrayMC->At(daughter0));
819  AliAODMCParticle* mcPartDaughter1 = dynamic_cast<AliAODMCParticle*>(arrayMC->At(daughter1));
820  if(!mcPartDaughter0 || !mcPartDaughter1) return -1;
821  arrayDauLab[0]=daughter0;
822  arrayDauLab[1]=daughter1;
823  Int_t pdgCode0=mcPartDaughter0->GetPdgCode();
824  Int_t pdgCode1=mcPartDaughter1->GetPdgCode();
825  if(!(TMath::Abs(pdgCode0)==321 && TMath::Abs(pdgCode1)==211) &&
826  !(TMath::Abs(pdgCode0)==211 && TMath::Abs(pdgCode1)==321)){
827  return -1;
828  }
829  if(TMath::Abs(pdgCode0)==321 && (pdgD*pdgCode0)>0) return -1;
830  if(TMath::Abs(pdgCode1)==321 && (pdgD*pdgCode1)>0) return -1;
831  if((pdgCode0*pdgCode1)>0) return -1;
832  Double_t sumPxDau=mcPartDaughter0->Px()+mcPartDaughter1->Px();
833  Double_t sumPyDau=mcPartDaughter0->Py()+mcPartDaughter1->Py();
834  Double_t sumPzDau=mcPartDaughter0->Pz()+mcPartDaughter1->Pz();
835  if(TMath::Abs(mcPart->Px()-sumPxDau)>0.001) return -2;
836  if(TMath::Abs(mcPart->Py()-sumPyDau)>0.001) return -2;
837  if(TMath::Abs(mcPart->Pz()-sumPzDau)>0.001) return -2;
838  return 1;
839  }
840 
841  if(nDau==3 || nDau==4){
842  Int_t nKaons=0;
843  Int_t nPions=0;
844  Double_t sumPxDau=0.;
845  Double_t sumPyDau=0.;
846  Double_t sumPzDau=0.;
847  Int_t nFoundKpi=0;
848  Int_t labelFirstDau = mcPart->GetDaughter(0);
849  for(Int_t iDau=0; iDau<nDau; iDau++){
850  Int_t indDau = labelFirstDau+iDau;
851  if(indDau<0) return -1;
852  AliAODMCParticle* dau=dynamic_cast<AliAODMCParticle*>(arrayMC->At(indDau));
853  if(!dau) return -1;
854  Int_t pdgdau=dau->GetPdgCode();
855  if(TMath::Abs(pdgdau)==321){
856  if(pdgD>0 && pdgdau>0) return -1;
857  if(pdgD<0 && pdgdau<0) return -1;
858  nKaons++;
859  sumPxDau+=dau->Px();
860  sumPyDau+=dau->Py();
861  sumPzDau+=dau->Pz();
862  arrayDauLab[nFoundKpi++]=indDau;
863  if(nFoundKpi>4) return -1;
864  }else if(TMath::Abs(pdgdau)==211){
865  nPions++;
866  sumPxDau+=dau->Px();
867  sumPyDau+=dau->Py();
868  sumPzDau+=dau->Pz();
869  arrayDauLab[nFoundKpi++]=indDau;
870  if(nFoundKpi>4) return -1;
871  }else if(TMath::Abs(pdgdau)==113 || TMath::Abs(pdgdau)==313){
872  Int_t nResDau=dau->GetNDaughters();
873  if(nResDau!=2) return -1;
874  Int_t indFirstResDau=dau->GetDaughter(0);
875  for(Int_t resDau=0; resDau<2; resDau++){
876  Int_t indResDau=indFirstResDau+resDau;
877  if(indResDau<0) return -1;
878  AliAODMCParticle* resdau=dynamic_cast<AliAODMCParticle*>(arrayMC->At(indResDau));
879  if(!resdau) return -1;
880  Int_t pdgresdau=resdau->GetPdgCode();
881  if(TMath::Abs(pdgresdau)==321){
882  if(pdgD>0 && pdgresdau>0) return -1;
883  if(pdgD<0 && pdgresdau<0) return -1;
884  nKaons++;
885  sumPxDau+=resdau->Px();
886  sumPyDau+=resdau->Py();
887  sumPzDau+=resdau->Pz();
888  arrayDauLab[nFoundKpi++]=indResDau;
889  if(nFoundKpi>4) return -1;
890  }
891  if(TMath::Abs(pdgresdau)==211){
892  nPions++;
893  sumPxDau+=resdau->Px();
894  sumPyDau+=resdau->Py();
895  sumPzDau+=resdau->Pz();
896  arrayDauLab[nFoundKpi++]=indResDau;
897  if(nFoundKpi>4) return -1;
898  }
899  }
900  }else{
901  return -1;
902  }
903  }
904  if(nPions!=3) return -1;
905  if(nKaons!=1) return -1;
906  if(TMath::Abs(mcPart->Px()-sumPxDau)>0.001) return -1;
907  if(TMath::Abs(mcPart->Py()-sumPyDau)>0.001) return -1;
908  if(TMath::Abs(mcPart->Pz()-sumPzDau)>0.001) return -1;
909  return 2;
910  }
911  return -1;
912 }
913 //____________________________________________________________________________
914 Int_t AliVertexingHFUtils::CheckDplusDecay(AliMCEvent* mcEvent, Int_t label, Int_t* arrayDauLab){
916 
917  if(label<0) return -1;
918  TParticle* mcPart = mcEvent->Particle(label);
919  Int_t pdgD=mcPart->GetPdgCode();
920  if(TMath::Abs(pdgD)!=411) return -1;
921 
922  Int_t nDau=mcPart->GetNDaughters();
923  Int_t labelFirstDau = mcPart->GetDaughter(0);
924  Int_t nKaons=0;
925  Int_t nPions=0;
926  Double_t sumPxDau=0.;
927  Double_t sumPyDau=0.;
928  Double_t sumPzDau=0.;
929  Int_t nFoundKpi=0;
930 
931  if(nDau==3 || nDau==2){
932  for(Int_t iDau=0; iDau<nDau; iDau++){
933  Int_t indDau = labelFirstDau+iDau;
934  if(indDau<0) return -1;
935  TParticle* dau=mcEvent->Particle(indDau);
936  if(!dau) return -1;
937  Int_t pdgdau=dau->GetPdgCode();
938  if(TMath::Abs(pdgdau)==321){
939  if(pdgD*pdgdau>0) return -1;
940  nKaons++;
941  sumPxDau+=dau->Px();
942  sumPyDau+=dau->Py();
943  sumPzDau+=dau->Pz();
944  arrayDauLab[nFoundKpi++]=indDau;
945  if(nFoundKpi>3) return -1;
946  }else if(TMath::Abs(pdgdau)==211){
947  if(pdgD*pdgdau<0) return -1;
948  nPions++;
949  sumPxDau+=dau->Px();
950  sumPyDau+=dau->Py();
951  sumPzDau+=dau->Pz();
952  arrayDauLab[nFoundKpi++]=indDau;
953  if(nFoundKpi>3) return -1;
954  }else if(TMath::Abs(pdgdau)==313){
955  Int_t nResDau=dau->GetNDaughters();
956  if(nResDau!=2) return -1;
957  Int_t indFirstResDau=dau->GetDaughter(0);
958  for(Int_t resDau=0; resDau<2; resDau++){
959  Int_t indResDau=indFirstResDau+resDau;
960  if(indResDau<0) return -1;
961  TParticle* resdau=mcEvent->Particle(indResDau);
962  if(!resdau) return -1;
963  Int_t pdgresdau=resdau->GetPdgCode();
964  if(TMath::Abs(pdgresdau)==321){
965  if(pdgD*pdgresdau>0) return -1;
966  sumPxDau+=resdau->Px();
967  sumPyDau+=resdau->Py();
968  sumPzDau+=resdau->Pz();
969  nKaons++;
970  arrayDauLab[nFoundKpi++]=indResDau;
971  if(nFoundKpi>3) return -1;
972  }
973  if(TMath::Abs(pdgresdau)==211){
974  if(pdgD*pdgresdau<0) return -1;
975  sumPxDau+=resdau->Px();
976  sumPyDau+=resdau->Py();
977  sumPzDau+=resdau->Pz();
978  nPions++;
979  arrayDauLab[nFoundKpi++]=indResDau;
980  if(nFoundKpi>3) return -1;
981  }
982  }
983  }else{
984  return -1;
985  }
986  }
987  if(nPions!=2) return -1;
988  if(nKaons!=1) return -1;
989  if(TMath::Abs(mcPart->Px()-sumPxDau)>0.001) return -2;
990  if(TMath::Abs(mcPart->Py()-sumPyDau)>0.001) return -2;
991  if(TMath::Abs(mcPart->Pz()-sumPzDau)>0.001) return -2;
992  if(nDau==3) return 1;
993  else if(nDau==2) return 2;
994  }
995 
996  return -1;
997 
998 }
999 
1000 //____________________________________________________________________________
1001 Int_t AliVertexingHFUtils::CheckDplusDecay(TClonesArray* arrayMC, AliAODMCParticle *mcPart, Int_t* arrayDauLab){
1003 
1004  Int_t pdgD=mcPart->GetPdgCode();
1005  if(TMath::Abs(pdgD)!=411) return -1;
1006 
1007  Int_t nDau=mcPart->GetNDaughters();
1008  Int_t labelFirstDau = mcPart->GetDaughter(0);
1009  Int_t nKaons=0;
1010  Int_t nPions=0;
1011  Double_t sumPxDau=0.;
1012  Double_t sumPyDau=0.;
1013  Double_t sumPzDau=0.;
1014  Int_t nFoundKpi=0;
1015 
1016  if(nDau==3 || nDau==2){
1017  for(Int_t iDau=0; iDau<nDau; iDau++){
1018  Int_t indDau = labelFirstDau+iDau;
1019  if(indDau<0) return -1;
1020  AliAODMCParticle* dau=dynamic_cast<AliAODMCParticle*>(arrayMC->At(indDau));
1021  if(!dau) return -1;
1022  Int_t pdgdau=dau->GetPdgCode();
1023  if(TMath::Abs(pdgdau)==321){
1024  if(pdgD*pdgdau>0) return -1;
1025  nKaons++;
1026  sumPxDau+=dau->Px();
1027  sumPyDau+=dau->Py();
1028  sumPzDau+=dau->Pz();
1029  arrayDauLab[nFoundKpi++]=indDau;
1030  if(nFoundKpi>3) return -1;
1031  }else if(TMath::Abs(pdgdau)==211){
1032  if(pdgD*pdgdau<0) return -1;
1033  nPions++;
1034  sumPxDau+=dau->Px();
1035  sumPyDau+=dau->Py();
1036  sumPzDau+=dau->Pz();
1037  arrayDauLab[nFoundKpi++]=indDau;
1038  if(nFoundKpi>3) return -1;
1039  }else if(TMath::Abs(pdgdau)==313){
1040  Int_t nResDau=dau->GetNDaughters();
1041  if(nResDau!=2) return -1;
1042  Int_t indFirstResDau=dau->GetDaughter(0);
1043  for(Int_t resDau=0; resDau<2; resDau++){
1044  Int_t indResDau=indFirstResDau+resDau;
1045  if(indResDau<0) return -1;
1046  AliAODMCParticle* resdau=dynamic_cast<AliAODMCParticle*>(arrayMC->At(indResDau));
1047  if(!resdau) return -1;
1048  Int_t pdgresdau=resdau->GetPdgCode();
1049  if(TMath::Abs(pdgresdau)==321){
1050  if(pdgD*pdgresdau>0) return -1;
1051  sumPxDau+=resdau->Px();
1052  sumPyDau+=resdau->Py();
1053  sumPzDau+=resdau->Pz();
1054  nKaons++;
1055  arrayDauLab[nFoundKpi++]=indResDau;
1056  if(nFoundKpi>3) return -1;
1057  }
1058  if(TMath::Abs(pdgresdau)==211){
1059  if(pdgD*pdgresdau<0) return -1;
1060  sumPxDau+=resdau->Px();
1061  sumPyDau+=resdau->Py();
1062  sumPzDau+=resdau->Pz();
1063  nPions++;
1064  arrayDauLab[nFoundKpi++]=indResDau;
1065  if(nFoundKpi>3) return -1;
1066  }
1067  }
1068  }else{
1069  return -1;
1070  }
1071  }
1072  if(nPions!=2) return -1;
1073  if(nKaons!=1) return -1;
1074  if(TMath::Abs(mcPart->Px()-sumPxDau)>0.001) return -2;
1075  if(TMath::Abs(mcPart->Py()-sumPyDau)>0.001) return -2;
1076  if(TMath::Abs(mcPart->Pz()-sumPzDau)>0.001) return -2;
1077  if(nDau==3) return 1;
1078  else if(nDau==2) return 2;
1079  }
1080 
1081  return -1;
1082 
1083 }
1084 //____________________________________________________________________________
1085 Int_t AliVertexingHFUtils::CheckDplusKKpiDecay(AliMCEvent* mcEvent, Int_t label, Int_t* arrayDauLab){
1087 
1088  if(label<0) return -1;
1089  TParticle* mcPart = mcEvent->Particle(label);
1090  Int_t pdgD=mcPart->GetPdgCode();
1091  if(TMath::Abs(pdgD)!=411) return -1;
1092 
1093  Int_t nDau=mcPart->GetNDaughters();
1094  Int_t labelFirstDau = mcPart->GetDaughter(0);
1095  Int_t nKaons=0;
1096  Int_t nPions=0;
1097  Double_t sumPxDau=0.;
1098  Double_t sumPyDau=0.;
1099  Double_t sumPzDau=0.;
1100  Int_t nFoundKpi=0;
1101  Bool_t isPhi=kFALSE;
1102  Bool_t isk0st=kFALSE;
1103 
1104  if(nDau==3 || nDau==2){
1105  for(Int_t iDau=0; iDau<nDau; iDau++){
1106  Int_t indDau = labelFirstDau+iDau;
1107  if(indDau<0) return -1;
1108  TParticle* dau=mcEvent->Particle(indDau);
1109  if(!dau) return -1;
1110  Int_t pdgdau=dau->GetPdgCode();
1111  if(TMath::Abs(pdgdau)==321){
1112  nKaons++;
1113  sumPxDau+=dau->Px();
1114  sumPyDau+=dau->Py();
1115  sumPzDau+=dau->Pz();
1116  arrayDauLab[nFoundKpi++]=indDau;
1117  if(nFoundKpi>3) return -1;
1118  }else if(TMath::Abs(pdgdau)==211){
1119  nPions++;
1120  sumPxDau+=dau->Px();
1121  sumPyDau+=dau->Py();
1122  sumPzDau+=dau->Pz();
1123  arrayDauLab[nFoundKpi++]=indDau;
1124  if(nFoundKpi>3) return -1;
1125  }else if(TMath::Abs(pdgdau)==313 || TMath::Abs(pdgdau)==333){
1126  if(TMath::Abs(pdgdau)==313) isk0st=kTRUE;
1127  if(TMath::Abs(pdgdau)==333) isPhi=kTRUE;
1128  Int_t nResDau=dau->GetNDaughters();
1129  if(nResDau!=2) return -1;
1130  Int_t indFirstResDau=dau->GetDaughter(0);
1131  for(Int_t resDau=0; resDau<2; resDau++){
1132  Int_t indResDau=indFirstResDau+resDau;
1133  if(indResDau<0) return -1;
1134  TParticle* resdau=mcEvent->Particle(indResDau);
1135  if(!resdau) return -1;
1136  Int_t pdgresdau=resdau->GetPdgCode();
1137  if(TMath::Abs(pdgresdau)==321){
1138  sumPxDau+=resdau->Px();
1139  sumPyDau+=resdau->Py();
1140  sumPzDau+=resdau->Pz();
1141  nKaons++;
1142  arrayDauLab[nFoundKpi++]=indResDau;
1143  if(nFoundKpi>3) return -1;
1144  }
1145  if(TMath::Abs(pdgresdau)==211){
1146  sumPxDau+=resdau->Px();
1147  sumPyDau+=resdau->Py();
1148  sumPzDau+=resdau->Pz();
1149  nPions++;
1150  arrayDauLab[nFoundKpi++]=indResDau;
1151  if(nFoundKpi>3) return -1;
1152  }
1153  }
1154  }else{
1155  return -1;
1156  }
1157  }
1158  if(nPions!=1) return -1;
1159  if(nKaons!=2) return -1;
1160  if(TMath::Abs(mcPart->Px()-sumPxDau)>0.001) return -2;
1161  if(TMath::Abs(mcPart->Py()-sumPyDau)>0.001) return -2;
1162  if(TMath::Abs(mcPart->Pz()-sumPzDau)>0.001) return -2;
1163  if(nDau==3) return 3;
1164  else if(nDau==2){
1165  if(isk0st) return 2;
1166  if(isPhi) return 1;
1167  }
1168  }
1169 
1170  return -1;
1171 
1172 }
1173 //____________________________________________________________________________
1174 Int_t AliVertexingHFUtils::CheckDplusKKpiDecay(TClonesArray* arrayMC, AliAODMCParticle *mcPart, Int_t* arrayDauLab){
1176 
1177  Int_t pdgD=mcPart->GetPdgCode();
1178  if(TMath::Abs(pdgD)!=411) return -1;
1179 
1180  Int_t nDau=mcPart->GetNDaughters();
1181  Int_t labelFirstDau = mcPart->GetDaughter(0);
1182  Int_t nKaons=0;
1183  Int_t nPions=0;
1184  Double_t sumPxDau=0.;
1185  Double_t sumPyDau=0.;
1186  Double_t sumPzDau=0.;
1187  Int_t nFoundKpi=0;
1188  Bool_t isPhi=kFALSE;
1189  Bool_t isk0st=kFALSE;
1190 
1191  if(nDau==3 || nDau==2){
1192  for(Int_t iDau=0; iDau<nDau; iDau++){
1193  Int_t indDau = labelFirstDau+iDau;
1194  if(indDau<0) return -1;
1195  AliAODMCParticle* dau=dynamic_cast<AliAODMCParticle*>(arrayMC->At(indDau));
1196  if(!dau) return -1;
1197  Int_t pdgdau=dau->GetPdgCode();
1198  if(TMath::Abs(pdgdau)==321){
1199  nKaons++;
1200  sumPxDau+=dau->Px();
1201  sumPyDau+=dau->Py();
1202  sumPzDau+=dau->Pz();
1203  arrayDauLab[nFoundKpi++]=indDau;
1204  if(nFoundKpi>3) return -1;
1205  }else if(TMath::Abs(pdgdau)==211){
1206  nPions++;
1207  sumPxDau+=dau->Px();
1208  sumPyDau+=dau->Py();
1209  sumPzDau+=dau->Pz();
1210  arrayDauLab[nFoundKpi++]=indDau;
1211  if(nFoundKpi>3) return -1;
1212  }else if(TMath::Abs(pdgdau)==313 || TMath::Abs(pdgdau)==333){
1213  if(TMath::Abs(pdgdau)==313) isk0st=kTRUE;
1214  if(TMath::Abs(pdgdau)==333) isPhi=kTRUE;
1215  Int_t nResDau=dau->GetNDaughters();
1216  if(nResDau!=2) return -1;
1217  Int_t indFirstResDau=dau->GetDaughter(0);
1218  for(Int_t resDau=0; resDau<2; resDau++){
1219  Int_t indResDau=indFirstResDau+resDau;
1220  if(indResDau<0) return -1;
1221  AliAODMCParticle* resdau=dynamic_cast<AliAODMCParticle*>(arrayMC->At(indResDau));
1222  if(!resdau) return -1;
1223  Int_t pdgresdau=resdau->GetPdgCode();
1224  if(TMath::Abs(pdgresdau)==321){
1225  sumPxDau+=resdau->Px();
1226  sumPyDau+=resdau->Py();
1227  sumPzDau+=resdau->Pz();
1228  nKaons++;
1229  arrayDauLab[nFoundKpi++]=indResDau;
1230  if(nFoundKpi>3) return -1;
1231  }
1232  if(TMath::Abs(pdgresdau)==211){
1233  sumPxDau+=resdau->Px();
1234  sumPyDau+=resdau->Py();
1235  sumPzDau+=resdau->Pz();
1236  nPions++;
1237  arrayDauLab[nFoundKpi++]=indResDau;
1238  if(nFoundKpi>3) return -1;
1239  }
1240  }
1241  }else{
1242  return -1;
1243  }
1244  }
1245  if(nPions!=1) return -1;
1246  if(nKaons!=2) return -1;
1247  if(TMath::Abs(mcPart->Px()-sumPxDau)>0.001) return -2;
1248  if(TMath::Abs(mcPart->Py()-sumPyDau)>0.001) return -2;
1249  if(TMath::Abs(mcPart->Pz()-sumPzDau)>0.001) return -2;
1250  if(nDau==3) return 3;
1251  else if(nDau==2){
1252  if(isk0st) return 2;
1253  if(isPhi) return 1;
1254  }
1255  }
1256 
1257  return -1;
1258 
1259 }
1260 //____________________________________________________________________________
1261 Int_t AliVertexingHFUtils::CheckDplusK0spiDecay(AliMCEvent* mcEvent, Int_t label, Int_t* arrayDauLab){
1263 
1264  if(label<0) return -1;
1265  TParticle* mcPart = mcEvent->Particle(label);
1266  Int_t pdgD=mcPart->GetPdgCode();
1267  if(TMath::Abs(pdgD)!=411) return -1;
1268 
1269  Int_t nDau=mcPart->GetNDaughters();
1270  Int_t labelFirstDau = mcPart->GetDaughter(0);
1271  Int_t nPions=0;
1272  Double_t sumPxDau=0.;
1273  Double_t sumPyDau=0.;
1274  Double_t sumPzDau=0.;
1275  Int_t nFoundpi=0;
1276 
1277  Int_t codeV0=-1;
1278  if(nDau==2){
1279  for(Int_t iDau=0; iDau<nDau; iDau++){
1280  Int_t indDau = labelFirstDau+iDau;
1281  if(indDau<0) return -1;
1282  TParticle* dau=mcEvent->Particle(indDau);
1283  if(!dau) return -1;
1284  Int_t pdgdau=dau->GetPdgCode();
1285  if(TMath::Abs(pdgdau)==211){
1286  nPions++;
1287  sumPxDau+=dau->Px();
1288  sumPyDau+=dau->Py();
1289  sumPzDau+=dau->Pz();
1290  arrayDauLab[nFoundpi++]=indDau;
1291  if(nFoundpi>3) return -1;
1292  }else if(TMath::Abs(pdgdau)==311){
1293  codeV0=TMath::Abs(pdgdau);
1294  TParticle* v0=dau;
1295  if(codeV0==311){
1296  Int_t nK0Dau=dau->GetNDaughters();
1297  if(nK0Dau!=1) return -1;
1298  Int_t indK0s=dau->GetDaughter(0);
1299  if(indK0s<0) return -1;
1300  v0=mcEvent->Particle(indK0s);
1301  if(!v0) return -1;
1302  Int_t pdgK0sl=v0->GetPdgCode();
1303  codeV0=TMath::Abs(pdgK0sl);
1304  }
1305  Int_t nV0Dau=v0->GetNDaughters();
1306  if(nV0Dau!=2) return -1;
1307  Int_t indFirstV0Dau=v0->GetDaughter(0);
1308  for(Int_t v0Dau=0; v0Dau<2; v0Dau++){
1309  Int_t indV0Dau=indFirstV0Dau+v0Dau;
1310  if(indV0Dau<0) return -1;
1311  TParticle* v0dau=mcEvent->Particle(indV0Dau);
1312  if(!v0dau) return -1;
1313  Int_t pdgv0dau=v0dau->GetPdgCode();
1314  if(TMath::Abs(pdgv0dau)==211){
1315  sumPxDau+=v0dau->Px();
1316  sumPyDau+=v0dau->Py();
1317  sumPzDau+=v0dau->Pz();
1318  nPions++;
1319  arrayDauLab[nFoundpi++]=indV0Dau;
1320  if(nFoundpi>3) return -1;
1321  }
1322  }
1323  }else{
1324  return -1;
1325  }
1326  }
1327  if(nPions!=3) return -1;
1328  if(TMath::Abs(mcPart->Px()-sumPxDau)>0.001) return -2;
1329  if(TMath::Abs(mcPart->Py()-sumPyDau)>0.001) return -2;
1330  if(TMath::Abs(mcPart->Pz()-sumPzDau)>0.001) return -2;
1331  if(codeV0==310) return 1;
1332  }
1333  return -1;
1334 
1335 }
1336 
1337 
1338 //____________________________________________________________________________
1339 Int_t AliVertexingHFUtils::CheckDsDecay(AliMCEvent* mcEvent, Int_t label, Int_t* arrayDauLab){
1341 
1342  if(label<0) return -1;
1343  TParticle* mcPart = mcEvent->Particle(label);
1344  Int_t pdgD=mcPart->GetPdgCode();
1345  if(TMath::Abs(pdgD)!=431) return -1;
1346 
1347  Int_t nDau=mcPart->GetNDaughters();
1348  Int_t labelFirstDau = mcPart->GetDaughter(0);
1349  Int_t nKaons=0;
1350  Int_t nPions=0;
1351  Double_t sumPxDau=0.;
1352  Double_t sumPyDau=0.;
1353  Double_t sumPzDau=0.;
1354  Int_t nFoundKpi=0;
1355  Bool_t isPhi=kFALSE;
1356  Bool_t isk0st=kFALSE;
1357 
1358  if(nDau==3 || nDau==2){
1359  for(Int_t iDau=0; iDau<nDau; iDau++){
1360  Int_t indDau = labelFirstDau+iDau;
1361  if(indDau<0) return -1;
1362  TParticle* dau=mcEvent->Particle(indDau);
1363  if(!dau) return -1;
1364  Int_t pdgdau=dau->GetPdgCode();
1365  if(TMath::Abs(pdgdau)==321){
1366  nKaons++;
1367  sumPxDau+=dau->Px();
1368  sumPyDau+=dau->Py();
1369  sumPzDau+=dau->Pz();
1370  arrayDauLab[nFoundKpi++]=indDau;
1371  if(nFoundKpi>3) return -1;
1372  }else if(TMath::Abs(pdgdau)==211){
1373  nPions++;
1374  sumPxDau+=dau->Px();
1375  sumPyDau+=dau->Py();
1376  sumPzDau+=dau->Pz();
1377  arrayDauLab[nFoundKpi++]=indDau;
1378  if(nFoundKpi>3) return -1;
1379  }else if(TMath::Abs(pdgdau)==313 || TMath::Abs(pdgdau)==333){
1380  if(TMath::Abs(pdgdau)==313) isk0st=kTRUE;
1381  if(TMath::Abs(pdgdau)==333) isPhi=kTRUE;
1382  Int_t nResDau=dau->GetNDaughters();
1383  if(nResDau!=2) return -1;
1384  Int_t indFirstResDau=dau->GetDaughter(0);
1385  for(Int_t resDau=0; resDau<2; resDau++){
1386  Int_t indResDau=indFirstResDau+resDau;
1387  if(indResDau<0) return -1;
1388  TParticle* resdau=mcEvent->Particle(indResDau);
1389  if(!resdau) return -1;
1390  Int_t pdgresdau=resdau->GetPdgCode();
1391  if(TMath::Abs(pdgresdau)==321){
1392  sumPxDau+=resdau->Px();
1393  sumPyDau+=resdau->Py();
1394  sumPzDau+=resdau->Pz();
1395  nKaons++;
1396  arrayDauLab[nFoundKpi++]=indResDau;
1397  if(nFoundKpi>3) return -1;
1398  }
1399  if(TMath::Abs(pdgresdau)==211){
1400  sumPxDau+=resdau->Px();
1401  sumPyDau+=resdau->Py();
1402  sumPzDau+=resdau->Pz();
1403  nPions++;
1404  arrayDauLab[nFoundKpi++]=indResDau;
1405  if(nFoundKpi>3) return -1;
1406  }
1407  }
1408  }else{
1409  return -1;
1410  }
1411  }
1412  if(nPions!=1) return -1;
1413  if(nKaons!=2) return -1;
1414  if(TMath::Abs(mcPart->Px()-sumPxDau)>0.001) return -2;
1415  if(TMath::Abs(mcPart->Py()-sumPyDau)>0.001) return -2;
1416  if(TMath::Abs(mcPart->Pz()-sumPzDau)>0.001) return -2;
1417  if(nDau==3) return 3;
1418  else if(nDau==2){
1419  if(isk0st) return 2;
1420  if(isPhi) return 1;
1421  }
1422  }
1423 
1424  return -1;
1425 
1426 }
1427 //____________________________________________________________________________
1428 Int_t AliVertexingHFUtils::CheckDsK0sKDecay(AliMCEvent* mcEvent, Int_t label, Int_t* arrayDauLab){
1430 
1431  if(label<0) return -1;
1432  TParticle* mcPart = mcEvent->Particle(label);
1433  Int_t pdgD=mcPart->GetPdgCode();
1434  if(TMath::Abs(pdgD)!=431) return -1;
1435 
1436  Int_t nDau=mcPart->GetNDaughters();
1437  Int_t labelFirstDau = mcPart->GetDaughter(0);
1438  Int_t nPions=0;
1439  Int_t nKaons=0;
1440  Double_t sumPxDau=0.;
1441  Double_t sumPyDau=0.;
1442  Double_t sumPzDau=0.;
1443  Int_t nFoundKpi=0;
1444 
1445  Int_t codeV0=-1;
1446  if(nDau==2){
1447  for(Int_t iDau=0; iDau<nDau; iDau++){
1448  Int_t indDau = labelFirstDau+iDau;
1449  if(indDau<0) return -1;
1450  TParticle* dau=mcEvent->Particle(indDau);
1451  if(!dau) return -1;
1452  Int_t pdgdau=dau->GetPdgCode();
1453  if(TMath::Abs(pdgdau)==211){
1454  nPions++;
1455  sumPxDau+=dau->Px();
1456  sumPyDau+=dau->Py();
1457  sumPzDau+=dau->Pz();
1458  arrayDauLab[nFoundKpi++]=indDau;
1459  if(nFoundKpi>3) return -1;
1460  }else if(TMath::Abs(pdgdau)==321){
1461  nKaons++;
1462  sumPxDau+=dau->Px();
1463  sumPyDau+=dau->Py();
1464  sumPzDau+=dau->Pz();
1465  arrayDauLab[nFoundKpi++]=indDau;
1466  if(nFoundKpi>3) return -1;
1467  }else if(TMath::Abs(pdgdau)==311){
1468  codeV0=TMath::Abs(pdgdau);
1469  TParticle* v0=dau;
1470  if(codeV0==311){
1471  Int_t nK0Dau=dau->GetNDaughters();
1472  if(nK0Dau!=1) return -1;
1473  Int_t indK0s=dau->GetDaughter(0);
1474  if(indK0s<0) return -1;
1475  v0=mcEvent->Particle(indK0s);
1476  if(!v0) return -1;
1477  Int_t pdgK0sl=v0->GetPdgCode();
1478  codeV0=TMath::Abs(pdgK0sl);
1479  }
1480  Int_t nV0Dau=v0->GetNDaughters();
1481  if(nV0Dau!=2) return -1;
1482  Int_t indFirstV0Dau=v0->GetDaughter(0);
1483  for(Int_t v0Dau=0; v0Dau<2; v0Dau++){
1484  Int_t indV0Dau=indFirstV0Dau+v0Dau;
1485  if(indV0Dau<0) return -1;
1486  TParticle* v0dau=mcEvent->Particle(indV0Dau);
1487  if(!v0dau) return -1;
1488  Int_t pdgv0dau=v0dau->GetPdgCode();
1489  if(TMath::Abs(pdgv0dau)==211){
1490  sumPxDau+=v0dau->Px();
1491  sumPyDau+=v0dau->Py();
1492  sumPzDau+=v0dau->Pz();
1493  nPions++;
1494  arrayDauLab[nFoundKpi++]=indV0Dau;
1495  if(nFoundKpi>3) return -1;
1496  }
1497  }
1498  }else{
1499  return -1;
1500  }
1501  }
1502  if(nPions!=2) return -1;
1503  if(nKaons!=1) return -1;
1504  if(TMath::Abs(mcPart->Px()-sumPxDau)>0.001) return -2;
1505  if(TMath::Abs(mcPart->Py()-sumPyDau)>0.001) return -2;
1506  if(TMath::Abs(mcPart->Pz()-sumPzDau)>0.001) return -2;
1507  if(codeV0==310) return 1;
1508  }
1509  return -1;
1510 
1511 }
1512 
1513 
1514 //____________________________________________________________________________
1515 Int_t AliVertexingHFUtils::CheckDsDecay(TClonesArray* arrayMC, AliAODMCParticle *mcPart, Int_t* arrayDauLab){
1517 
1518  Int_t pdgD=mcPart->GetPdgCode();
1519  if(TMath::Abs(pdgD)!=431) return -1;
1520 
1521  Int_t nDau=mcPart->GetNDaughters();
1522  Int_t labelFirstDau = mcPart->GetDaughter(0);
1523  Int_t nKaons=0;
1524  Int_t nPions=0;
1525  Double_t sumPxDau=0.;
1526  Double_t sumPyDau=0.;
1527  Double_t sumPzDau=0.;
1528  Int_t nFoundKpi=0;
1529  Bool_t isPhi=kFALSE;
1530  Bool_t isk0st=kFALSE;
1531 
1532  if(nDau==3 || nDau==2){
1533  for(Int_t iDau=0; iDau<nDau; iDau++){
1534  Int_t indDau = labelFirstDau+iDau;
1535  if(indDau<0) return -1;
1536  AliAODMCParticle* dau=dynamic_cast<AliAODMCParticle*>(arrayMC->At(indDau));
1537  if(!dau) return -1;
1538  Int_t pdgdau=dau->GetPdgCode();
1539  if(TMath::Abs(pdgdau)==321){
1540  nKaons++;
1541  sumPxDau+=dau->Px();
1542  sumPyDau+=dau->Py();
1543  sumPzDau+=dau->Pz();
1544  arrayDauLab[nFoundKpi++]=indDau;
1545  if(nFoundKpi>3) return -1;
1546  }else if(TMath::Abs(pdgdau)==211){
1547  nPions++;
1548  sumPxDau+=dau->Px();
1549  sumPyDau+=dau->Py();
1550  sumPzDau+=dau->Pz();
1551  arrayDauLab[nFoundKpi++]=indDau;
1552  if(nFoundKpi>3) return -1;
1553  }else if(TMath::Abs(pdgdau)==313 || TMath::Abs(pdgdau)==333){
1554  if(TMath::Abs(pdgdau)==313) isk0st=kTRUE;
1555  if(TMath::Abs(pdgdau)==333) isPhi=kTRUE;
1556  Int_t nResDau=dau->GetNDaughters();
1557  if(nResDau!=2) return -1;
1558  Int_t indFirstResDau=dau->GetDaughter(0);
1559  for(Int_t resDau=0; resDau<2; resDau++){
1560  Int_t indResDau=indFirstResDau+resDau;
1561  if(indResDau<0) return -1;
1562  AliAODMCParticle* resdau=dynamic_cast<AliAODMCParticle*>(arrayMC->At(indResDau));
1563  if(!resdau) return -1;
1564  Int_t pdgresdau=resdau->GetPdgCode();
1565  if(TMath::Abs(pdgresdau)==321){
1566  sumPxDau+=resdau->Px();
1567  sumPyDau+=resdau->Py();
1568  sumPzDau+=resdau->Pz();
1569  nKaons++;
1570  arrayDauLab[nFoundKpi++]=indResDau;
1571  if(nFoundKpi>3) return -1;
1572  }
1573  if(TMath::Abs(pdgresdau)==211){
1574  sumPxDau+=resdau->Px();
1575  sumPyDau+=resdau->Py();
1576  sumPzDau+=resdau->Pz();
1577  nPions++;
1578  arrayDauLab[nFoundKpi++]=indResDau;
1579  if(nFoundKpi>3) return -1;
1580  }
1581  }
1582  }else{
1583  return -1;
1584  }
1585  }
1586  if(nPions!=1) return -1;
1587  if(nKaons!=2) return -1;
1588  if(TMath::Abs(mcPart->Px()-sumPxDau)>0.001) return -2;
1589  if(TMath::Abs(mcPart->Py()-sumPyDau)>0.001) return -2;
1590  if(TMath::Abs(mcPart->Pz()-sumPzDau)>0.001) return -2;
1591  if(nDau==3) return 3;
1592  else if(nDau==2){
1593  if(isk0st) return 2;
1594  if(isPhi) return 1;
1595  }
1596  }
1597 
1598  return -1;
1599 
1600 }
1601 //____________________________________________________________________________
1602 Int_t AliVertexingHFUtils::CheckDstarDecay(AliMCEvent* mcEvent, Int_t label, Int_t* arrayDauLab){
1604 
1605  if(label<0) return -1;
1606  TParticle* mcPart = mcEvent->Particle(label);
1607  Int_t pdgD=mcPart->GetPdgCode();
1608  if(TMath::Abs(pdgD)!=413) return -1;
1609 
1610  Int_t nDau=mcPart->GetNDaughters();
1611  if(nDau!=2) return -1;
1612 
1613  Int_t labelFirstDau = mcPart->GetDaughter(0);
1614  Int_t nKaons=0;
1615  Int_t nPions=0;
1616  Double_t sumPxDau=0.;
1617  Double_t sumPyDau=0.;
1618  Double_t sumPzDau=0.;
1619  Int_t nFoundKpi=0;
1620 
1621  for(Int_t iDau=0; iDau<nDau; iDau++){
1622  Int_t indDau = labelFirstDau+iDau;
1623  if(indDau<0) return -1;
1624  TParticle* dau=mcEvent->Particle(indDau);
1625  if(!dau) return -1;
1626  Int_t pdgdau=dau->GetPdgCode();
1627  if(TMath::Abs(pdgdau)==421){
1628  Int_t nResDau=dau->GetNDaughters();
1629  if(nResDau!=2) return -1;
1630  Int_t indFirstResDau=dau->GetDaughter(0);
1631  for(Int_t resDau=0; resDau<2; resDau++){
1632  Int_t indResDau=indFirstResDau+resDau;
1633  if(indResDau<0) return -1;
1634  TParticle* resdau=mcEvent->Particle(indResDau);
1635  if(!resdau) return -1;
1636  Int_t pdgresdau=resdau->GetPdgCode();
1637  if(TMath::Abs(pdgresdau)==321){
1638  if(pdgD*pdgresdau>0) return -1;
1639  sumPxDau+=resdau->Px();
1640  sumPyDau+=resdau->Py();
1641  sumPzDau+=resdau->Pz();
1642  nKaons++;
1643  arrayDauLab[nFoundKpi++]=indResDau;
1644  if(nFoundKpi>3) return -1;
1645  }
1646  if(TMath::Abs(pdgresdau)==211){
1647  if(pdgD*pdgresdau<0) return -1;
1648  sumPxDau+=resdau->Px();
1649  sumPyDau+=resdau->Py();
1650  sumPzDau+=resdau->Pz();
1651  nPions++;
1652  arrayDauLab[nFoundKpi++]=indResDau;
1653  if(nFoundKpi>3) return -1;
1654  }
1655  }
1656  }else if(TMath::Abs(pdgdau)==211){
1657  if(pdgD*pdgdau<0) return -1;
1658  nPions++;
1659  sumPxDau+=dau->Px();
1660  sumPyDau+=dau->Py();
1661  sumPzDau+=dau->Pz();
1662  arrayDauLab[nFoundKpi++]=indDau;
1663  if(nFoundKpi>3) return -1;
1664  }
1665  }
1666 
1667  if(nPions!=2) return -1;
1668  if(nKaons!=1) return -1;
1669  if(TMath::Abs(mcPart->Px()-sumPxDau)>0.001) return -2;
1670  if(TMath::Abs(mcPart->Py()-sumPyDau)>0.001) return -2;
1671  if(TMath::Abs(mcPart->Pz()-sumPzDau)>0.001) return -2;
1672  return 1;
1673 
1674 }
1675 
1676 //____________________________________________________________________________
1677 Int_t AliVertexingHFUtils::CheckDstarDecay(TClonesArray* arrayMC, AliAODMCParticle *mcPart, Int_t* arrayDauLab){
1679 
1680  Int_t pdgD=mcPart->GetPdgCode();
1681  if(TMath::Abs(pdgD)!=413) return -1;
1682 
1683  Int_t nDau=mcPart->GetNDaughters();
1684  if(nDau!=2) return -1;
1685 
1686  Int_t labelFirstDau = mcPart->GetDaughter(0);
1687  Int_t nKaons=0;
1688  Int_t nPions=0;
1689  Double_t sumPxDau=0.;
1690  Double_t sumPyDau=0.;
1691  Double_t sumPzDau=0.;
1692  Int_t nFoundKpi=0;
1693 
1694  for(Int_t iDau=0; iDau<nDau; iDau++){
1695  Int_t indDau = labelFirstDau+iDau;
1696  if(indDau<0) return -1;
1697  AliAODMCParticle* dau=dynamic_cast<AliAODMCParticle*>(arrayMC->At(indDau));
1698  if(!dau) return -1;
1699  Int_t pdgdau=dau->GetPdgCode();
1700  if(TMath::Abs(pdgdau)==421){
1701  Int_t nResDau=dau->GetNDaughters();
1702  if(nResDau!=2) return -1;
1703  Int_t indFirstResDau=dau->GetDaughter(0);
1704  for(Int_t resDau=0; resDau<2; resDau++){
1705  Int_t indResDau=indFirstResDau+resDau;
1706  if(indResDau<0) return -1;
1707  AliAODMCParticle* resdau=dynamic_cast<AliAODMCParticle*>(arrayMC->At(indResDau));
1708  if(!resdau) return -1;
1709  Int_t pdgresdau=resdau->GetPdgCode();
1710  if(TMath::Abs(pdgresdau)==321){
1711  if(pdgD*pdgresdau>0) return -1;
1712  sumPxDau+=resdau->Px();
1713  sumPyDau+=resdau->Py();
1714  sumPzDau+=resdau->Pz();
1715  nKaons++;
1716  arrayDauLab[nFoundKpi++]=indResDau;
1717  if(nFoundKpi>3) return -1;
1718  }
1719  if(TMath::Abs(pdgresdau)==211){
1720  if(pdgD*pdgresdau<0) return -1;
1721  sumPxDau+=resdau->Px();
1722  sumPyDau+=resdau->Py();
1723  sumPzDau+=resdau->Pz();
1724  nPions++;
1725  arrayDauLab[nFoundKpi++]=indResDau;
1726  if(nFoundKpi>3) return -1;
1727  }
1728  }
1729  }else if(TMath::Abs(pdgdau)==211){
1730  if(pdgD*pdgdau<0) return -1;
1731  nPions++;
1732  sumPxDau+=dau->Px();
1733  sumPyDau+=dau->Py();
1734  sumPzDau+=dau->Pz();
1735  arrayDauLab[nFoundKpi++]=indDau;
1736  if(nFoundKpi>3) return -1;
1737  }
1738  }
1739 
1740  if(nPions!=2) return -1;
1741  if(nKaons!=1) return -1;
1742  if(TMath::Abs(mcPart->Px()-sumPxDau)>0.001) return -2;
1743  if(TMath::Abs(mcPart->Py()-sumPyDau)>0.001) return -2;
1744  if(TMath::Abs(mcPart->Pz()-sumPzDau)>0.001) return -2;
1745  return 1;
1746 
1747 }
1748 
1749 //____________________________________________________________________________
1750 Int_t AliVertexingHFUtils::CheckLcpKpiDecay(AliMCEvent* mcEvent, Int_t label, Int_t* arrayDauLab){
1752 
1753  if(label<0) return -1;
1754  TParticle* mcPart = mcEvent->Particle(label);
1755  Int_t pdgD=mcPart->GetPdgCode();
1756  if(TMath::Abs(pdgD)!=4122) return -1;
1757 
1758  Int_t nDau=mcPart->GetNDaughters();
1759  Int_t labelFirstDau = mcPart->GetDaughter(0);
1760  Int_t nKaons=0;
1761  Int_t nPions=0;
1762  Int_t nProtons=0;
1763  Double_t sumPxDau=0.;
1764  Double_t sumPyDau=0.;
1765  Double_t sumPzDau=0.;
1766  Int_t nFoundpKpi=0;
1767 
1768  Int_t codeRes=-1;
1769  if(nDau==3 || nDau==2){
1770  for(Int_t iDau=0; iDau<nDau; iDau++){
1771  Int_t indDau = labelFirstDau+iDau;
1772  if(indDau<0) return -1;
1773  TParticle* dau=mcEvent->Particle(indDau);
1774  if(!dau) return -1;
1775  Int_t pdgdau=dau->GetPdgCode();
1776  if(TMath::Abs(pdgdau)==321){
1777  nKaons++;
1778  sumPxDau+=dau->Px();
1779  sumPyDau+=dau->Py();
1780  sumPzDau+=dau->Pz();
1781  arrayDauLab[nFoundpKpi++]=indDau;
1782  if(nFoundpKpi>3) return -1;
1783  }else if(TMath::Abs(pdgdau)==211){
1784  nPions++;
1785  sumPxDau+=dau->Px();
1786  sumPyDau+=dau->Py();
1787  sumPzDau+=dau->Pz();
1788  arrayDauLab[nFoundpKpi++]=indDau;
1789  if(nFoundpKpi>3) return -1;
1790  }else if(TMath::Abs(pdgdau)==2212){
1791  nProtons++;
1792  sumPxDau+=dau->Px();
1793  sumPyDau+=dau->Py();
1794  sumPzDau+=dau->Pz();
1795  arrayDauLab[nFoundpKpi++]=indDau;
1796  if(nFoundpKpi>3) return -1;
1797  }else if(TMath::Abs(pdgdau)==313 || TMath::Abs(pdgdau)==3124 ||
1798  TMath::Abs(pdgdau)==2224){
1799  codeRes=TMath::Abs(pdgdau);
1800  Int_t nResDau=dau->GetNDaughters();
1801  if(nResDau!=2) return -1;
1802  Int_t indFirstResDau=dau->GetDaughter(0);
1803  for(Int_t resDau=0; resDau<2; resDau++){
1804  Int_t indResDau=indFirstResDau+resDau;
1805  if(indResDau<0) return -1;
1806  TParticle* resdau=mcEvent->Particle(indResDau);
1807  if(!resdau) return -1;
1808  Int_t pdgresdau=resdau->GetPdgCode();
1809  if(TMath::Abs(pdgresdau)==321){
1810  sumPxDau+=resdau->Px();
1811  sumPyDau+=resdau->Py();
1812  sumPzDau+=resdau->Pz();
1813  nKaons++;
1814  arrayDauLab[nFoundpKpi++]=indResDau;
1815  if(nFoundpKpi>3) return -1;
1816  }else if(TMath::Abs(pdgresdau)==211){
1817  sumPxDau+=resdau->Px();
1818  sumPyDau+=resdau->Py();
1819  sumPzDau+=resdau->Pz();
1820  nPions++;
1821  arrayDauLab[nFoundpKpi++]=indResDau;
1822  if(nFoundpKpi>3) return -1;
1823  }else if(TMath::Abs(pdgresdau)==2212){
1824  sumPxDau+=resdau->Px();
1825  sumPyDau+=resdau->Py();
1826  sumPzDau+=resdau->Pz();
1827  nProtons++;
1828  arrayDauLab[nFoundpKpi++]=indResDau;
1829  if(nFoundpKpi>3) return -1;
1830  }
1831  }
1832  }else{
1833  return -1;
1834  }
1835  }
1836  if(nPions!=1) return -1;
1837  if(nKaons!=1) return -1;
1838  if(nProtons!=1) return -1;
1839  if(TMath::Abs(mcPart->Px()-sumPxDau)>0.001) return -2;
1840  if(TMath::Abs(mcPart->Py()-sumPyDau)>0.001) return -2;
1841  if(TMath::Abs(mcPart->Pz()-sumPzDau)>0.001) return -2;
1842  if(nDau==3) return 1;
1843  else if(nDau==2){
1844  if(codeRes==313) return 2;
1845  else if(codeRes==2224) return 3;
1846  else if(codeRes==3124) return 4;
1847  }
1848  }
1849  return -1;
1850 
1851 }
1852 
1853 //____________________________________________________________________________
1854 Int_t AliVertexingHFUtils::CheckLcpKpiDecay(TClonesArray* arrayMC, AliAODMCParticle *mcPart, Int_t* arrayDauLab){
1856 
1857  Int_t pdgD=mcPart->GetPdgCode();
1858  if(TMath::Abs(pdgD)!=4122) return -1;
1859 
1860  Int_t nDau=mcPart->GetNDaughters();
1861  Int_t labelFirstDau = mcPart->GetDaughter(0);
1862  Int_t nKaons=0;
1863  Int_t nPions=0;
1864  Int_t nProtons=0;
1865  Double_t sumPxDau=0.;
1866  Double_t sumPyDau=0.;
1867  Double_t sumPzDau=0.;
1868  Int_t nFoundpKpi=0;
1869 
1870  Int_t codeRes=-1;
1871  if(nDau==3 || nDau==2){
1872  for(Int_t iDau=0; iDau<nDau; iDau++){
1873  Int_t indDau = labelFirstDau+iDau;
1874  if(indDau<0) return -1;
1875  AliAODMCParticle* dau=dynamic_cast<AliAODMCParticle*>(arrayMC->At(indDau));
1876  if(!dau) return -1;
1877  Int_t pdgdau=dau->GetPdgCode();
1878  if(TMath::Abs(pdgdau)==321){
1879  nKaons++;
1880  sumPxDau+=dau->Px();
1881  sumPyDau+=dau->Py();
1882  sumPzDau+=dau->Pz();
1883  arrayDauLab[nFoundpKpi++]=indDau;
1884  if(nFoundpKpi>3) return -1;
1885  }else if(TMath::Abs(pdgdau)==211){
1886  nPions++;
1887  sumPxDau+=dau->Px();
1888  sumPyDau+=dau->Py();
1889  sumPzDau+=dau->Pz();
1890  arrayDauLab[nFoundpKpi++]=indDau;
1891  if(nFoundpKpi>3) return -1;
1892  }else if(TMath::Abs(pdgdau)==2212){
1893  nProtons++;
1894  sumPxDau+=dau->Px();
1895  sumPyDau+=dau->Py();
1896  sumPzDau+=dau->Pz();
1897  arrayDauLab[nFoundpKpi++]=indDau;
1898  if(nFoundpKpi>3) return -1;
1899  }else if(TMath::Abs(pdgdau)==313 || TMath::Abs(pdgdau)==3124 ||
1900  TMath::Abs(pdgdau)==2224){
1901  codeRes=TMath::Abs(pdgdau);
1902  Int_t nResDau=dau->GetNDaughters();
1903  if(nResDau!=2) return -1;
1904  Int_t indFirstResDau=dau->GetDaughter(0);
1905  for(Int_t resDau=0; resDau<2; resDau++){
1906  Int_t indResDau=indFirstResDau+resDau;
1907  if(indResDau<0) return -1;
1908  AliAODMCParticle* resdau=dynamic_cast<AliAODMCParticle*>(arrayMC->At(indResDau));
1909  if(!resdau) return -1;
1910  Int_t pdgresdau=resdau->GetPdgCode();
1911  if(TMath::Abs(pdgresdau)==321){
1912  sumPxDau+=resdau->Px();
1913  sumPyDau+=resdau->Py();
1914  sumPzDau+=resdau->Pz();
1915  nKaons++;
1916  arrayDauLab[nFoundpKpi++]=indResDau;
1917  if(nFoundpKpi>3) return -1;
1918  }else if(TMath::Abs(pdgresdau)==211){
1919  sumPxDau+=resdau->Px();
1920  sumPyDau+=resdau->Py();
1921  sumPzDau+=resdau->Pz();
1922  nPions++;
1923  arrayDauLab[nFoundpKpi++]=indResDau;
1924  if(nFoundpKpi>3) return -1;
1925  }else if(TMath::Abs(pdgresdau)==2212){
1926  sumPxDau+=resdau->Px();
1927  sumPyDau+=resdau->Py();
1928  sumPzDau+=resdau->Pz();
1929  nProtons++;
1930  arrayDauLab[nFoundpKpi++]=indResDau;
1931  if(nFoundpKpi>3) return -1;
1932  }
1933  }
1934  }else{
1935  return -1;
1936  }
1937  }
1938  if(nPions!=1) return -1;
1939  if(nKaons!=1) return -1;
1940  if(nProtons!=1) return -1;
1941  if(TMath::Abs(mcPart->Px()-sumPxDau)>0.001) return -2;
1942  if(TMath::Abs(mcPart->Py()-sumPyDau)>0.001) return -2;
1943  if(TMath::Abs(mcPart->Pz()-sumPzDau)>0.001) return -2;
1944  if(nDau==3) return 1;
1945  else if(nDau==2){
1946  if(codeRes==313) return 2;
1947  else if(codeRes==2224) return 3;
1948  else if(codeRes==3124) return 4;
1949  }
1950  }
1951  return -1;
1952 
1953 }
1954 //____________________________________________________________________________
1955 Int_t AliVertexingHFUtils::CheckLcV0bachelorDecay(AliMCEvent* mcEvent, Int_t label, Int_t* arrayDauLab){
1957 
1958  if(label<0) return -1;
1959  TParticle* mcPart = mcEvent->Particle(label);
1960  Int_t pdgD=mcPart->GetPdgCode();
1961  if(TMath::Abs(pdgD)!=4122) return -1;
1962 
1963  Int_t nDau=mcPart->GetNDaughters();
1964  Int_t labelFirstDau = mcPart->GetDaughter(0);
1965  Int_t nPions=0;
1966  Int_t nProtons=0;
1967  Double_t sumPxDau=0.;
1968  Double_t sumPyDau=0.;
1969  Double_t sumPzDau=0.;
1970  Int_t nFoundppi=0;
1971 
1972  Int_t codeV0=-1;
1973  if(nDau==2){
1974  for(Int_t iDau=0; iDau<nDau; iDau++){
1975  Int_t indDau = labelFirstDau+iDau;
1976  if(indDau<0) return -1;
1977  TParticle* dau=mcEvent->Particle(indDau);
1978  if(!dau) return -1;
1979  Int_t pdgdau=dau->GetPdgCode();
1980  if(TMath::Abs(pdgdau)==211){
1981  nPions++;
1982  sumPxDau+=dau->Px();
1983  sumPyDau+=dau->Py();
1984  sumPzDau+=dau->Pz();
1985  arrayDauLab[nFoundppi++]=indDau;
1986  if(nFoundppi>3) return -1;
1987  }else if(TMath::Abs(pdgdau)==2212){
1988  nProtons++;
1989  sumPxDau+=dau->Px();
1990  sumPyDau+=dau->Py();
1991  sumPzDau+=dau->Pz();
1992  arrayDauLab[nFoundppi++]=indDau;
1993  if(nFoundppi>3) return -1;
1994  }else if(TMath::Abs(pdgdau)==311 || TMath::Abs(pdgdau)==3122){
1995  codeV0=TMath::Abs(pdgdau);
1996  TParticle* v0=dau;
1997  if(codeV0==311){
1998  Int_t nK0Dau=dau->GetNDaughters();
1999  if(nK0Dau!=1) return -1;
2000  Int_t indK0s=dau->GetDaughter(0);
2001  if(indK0s<0) return -1;
2002  v0=mcEvent->Particle(indK0s);
2003  if(!v0) return -1;
2004  Int_t pdgK0sl=v0->GetPdgCode();
2005  codeV0=TMath::Abs(pdgK0sl);
2006  }
2007  Int_t nV0Dau=v0->GetNDaughters();
2008  if(nV0Dau!=2) return -1;
2009  Int_t indFirstV0Dau=v0->GetDaughter(0);
2010  for(Int_t v0Dau=0; v0Dau<2; v0Dau++){
2011  Int_t indV0Dau=indFirstV0Dau+v0Dau;
2012  if(indV0Dau<0) return -1;
2013  TParticle* v0dau=mcEvent->Particle(indV0Dau);
2014  if(!v0dau) return -1;
2015  Int_t pdgv0dau=v0dau->GetPdgCode();
2016  if(TMath::Abs(pdgv0dau)==211){
2017  sumPxDau+=v0dau->Px();
2018  sumPyDau+=v0dau->Py();
2019  sumPzDau+=v0dau->Pz();
2020  nPions++;
2021  arrayDauLab[nFoundppi++]=indV0Dau;
2022  if(nFoundppi>3) return -1;
2023  }else if(TMath::Abs(pdgv0dau)==2212){
2024  sumPxDau+=v0dau->Px();
2025  sumPyDau+=v0dau->Py();
2026  sumPzDau+=v0dau->Pz();
2027  nProtons++;
2028  arrayDauLab[nFoundppi++]=indV0Dau;
2029  if(nFoundppi>3) return -1;
2030  }
2031  }
2032  }else{
2033  return -1;
2034  }
2035  }
2036  if(nPions!=2) return -1;
2037  if(nProtons!=1) return -1;
2038  if(TMath::Abs(mcPart->Px()-sumPxDau)>0.001) return -2;
2039  if(TMath::Abs(mcPart->Py()-sumPyDau)>0.001) return -2;
2040  if(TMath::Abs(mcPart->Pz()-sumPzDau)>0.001) return -2;
2041  if(codeV0==310) return 1;
2042  else if(codeV0==3122) return 2;
2043  }
2044  return -1;
2045 
2046 }
2047 
2048 
2049 //__________________________________xic______________________________________
2050 Int_t AliVertexingHFUtils::CheckXicXipipiDecay(AliMCEvent* mcEvent, Int_t label, Int_t* arrayDauLab){
2052 
2053  if(label<0) return -1;
2054  TParticle* mcPart = mcEvent->Particle(label);
2055  Int_t pdgD=mcPart->GetPdgCode();
2056  if(TMath::Abs(pdgD)!=4232) return -1;
2057 
2058  Int_t nDau=mcPart->GetNDaughters();
2059  if(nDau!=3) return -1;
2060 
2061  Int_t labelFirstDau = mcPart->GetDaughter(0);
2062  Int_t nXi=0;
2063  Int_t nPions=0;
2064  Double_t sumPxDau=0.;
2065  Double_t sumPyDau=0.;
2066  Double_t sumPzDau=0.;
2067  Int_t nFoundXi=0;
2068 
2069  for(Int_t iDau=0; iDau<nDau; iDau++){
2070  Int_t indDau = labelFirstDau+iDau;
2071  if(indDau<0) return -1;
2072  TParticle* dau=mcEvent->Particle(indDau);
2073  if(!dau) return -1;
2074  Int_t pdgdau=dau->GetPdgCode();
2075  if(TMath::Abs(pdgdau)==3312){
2076  if(pdgD*pdgdau<0) return -1;
2077  sumPxDau+=dau->Px();
2078  sumPyDau+=dau->Py();
2079  sumPzDau+=dau->Pz();
2080  nXi++;
2081  arrayDauLab[nFoundXi++]=indDau;
2082 
2083  }
2084  if(TMath::Abs(pdgdau)==211){
2085  if(pdgD*pdgdau<0) return -1;
2086  nPions++;
2087  sumPxDau+=dau->Px();
2088  sumPyDau+=dau->Py();
2089  sumPzDau+=dau->Pz();
2090  arrayDauLab[nFoundXi++]=indDau;
2091  if(nFoundXi>3) return -1;
2092  }
2093  }
2094 
2095  if(nPions!=2) return -1;
2096  if(nXi!=1) return -1;
2097  if(TMath::Abs(mcPart->Px()-sumPxDau)>0.001) return -2;
2098  if(TMath::Abs(mcPart->Py()-sumPyDau)>0.001) return -2;
2099  if(TMath::Abs(mcPart->Pz()-sumPzDau)>0.001) return -2;
2100  return 1;
2101 
2102 }
2103 //________________________________________________________________________
2104 Double_t AliVertexingHFUtils::GetSphericity(AliAODEvent* aod,
2105  Double_t etaMin, Double_t etaMax,
2106  Double_t ptMin, Double_t ptMax,
2107  Int_t filtbit1, Int_t filtbit2,
2108  Int_t minMult){
2110 
2111  Int_t nTracks=aod->GetNumberOfTracks();
2112  Int_t nSelTracks=0;
2113 
2114  Double_t sumpt=0.;
2115  Double_t s00=0.;
2116  Double_t s01=0.;
2117  Double_t s11=0.;
2118  if(ptMin<0.) ptMin=0.;
2119 
2120  for(Int_t it=0; it<nTracks; it++) {
2121  AliAODTrack *tr=dynamic_cast<AliAODTrack*>(aod->GetTrack(it));
2122  if(!tr) continue;
2123  Float_t eta = tr->Eta();
2124  Float_t pt = tr->Pt();
2125  Float_t phi = tr->Phi();
2126  if(eta<etaMin || eta>etaMax) continue;
2127  if(pt<ptMin || pt>ptMax) continue;
2128  Bool_t fb1 = tr->TestFilterBit(filtbit1);
2129  Bool_t fb2 = tr->TestFilterBit(filtbit2);
2130  Bool_t tpcRefit=tr->GetStatus() & AliAODTrack::kTPCrefit;
2131  if(filtbit1==1 && !tpcRefit) fb1=kFALSE;
2132  if(filtbit2==1 && !tpcRefit) fb2=kFALSE;
2133  if( !(fb1 || fb2) ) continue;
2134  Double_t px=pt*TMath::Cos(phi);
2135  Double_t py=pt*TMath::Sin(phi);
2136  s00 += (px * px)/pt;
2137  s01 += (py * px)/pt;
2138  s11 += (py * py)/pt;
2139  nSelTracks++;
2140  sumpt+=pt;
2141  }
2142 
2143  if(nSelTracks<minMult) return -0.5;
2144 
2145  if(sumpt>0.){
2146  s00/=sumpt;
2147  s01/=sumpt;
2148  s11/=sumpt;
2149  }else return -0.5;
2150 
2151  Double_t sphericity = -10;
2152  Double_t lambda1=((s00+s11)+TMath::Sqrt((s00+s11)*(s00+s11)-4*(s00*s11-s01*s01)))/2.;
2153  Double_t lambda2=((s00+s11)-TMath::Sqrt((s00+s11)*(s00+s11)-4*(s00*s11-s01*s01)))/2.;
2154  if(TMath::Abs(lambda2)<0.00001 && TMath::Abs(lambda1)<0.00001) sphericity=0;
2155  if(TMath::Abs(lambda1+lambda2)>0.000001) sphericity=2*TMath::Min(lambda1,lambda2)/(lambda1+lambda2);
2156  return sphericity;
2157 
2158 }
2159 
2160 //________________________________________________________________________
2161 void AliVertexingHFUtils::GetSpherocity(AliAODEvent* aod,
2162  Double_t &spherocity, Double_t &phiRef,
2163  Double_t etaMin, Double_t etaMax,
2164  Double_t ptMin, Double_t ptMax,
2165  Int_t filtbit1, Int_t filtbit2,
2166  Int_t minMult, Double_t phiStepSizeDeg,
2167  Int_t nTrksToSkip, Int_t* idToSkip
2168  ){
2170 
2171  Int_t nTracks=aod->GetNumberOfTracks();
2172  Int_t nSelTracks=0;
2173 
2174  Double_t* ptArr=new Double_t[nTracks];
2175  Double_t* phiArr=new Double_t[nTracks];
2176  Double_t sumpt=0.;
2177 
2178  for(Int_t it=0; it<nTracks; it++) {
2179  AliAODTrack *tr=dynamic_cast<AliAODTrack*>(aod->GetTrack(it));
2180  if(!tr) continue;
2181  Float_t eta = tr->Eta();
2182  Float_t pt = tr->Pt();
2183  Float_t phi = tr->Phi();
2184  if(eta<etaMin || eta>etaMax) continue;
2185  if(pt<ptMin || pt>ptMax) continue;
2186  if(nTrksToSkip>0 && idToSkip){
2187  Int_t trid = (Int_t)tr->GetID();
2188  Bool_t keep=kTRUE;
2189  for(Int_t jt=0; jt<nTrksToSkip; jt++){
2190  if(trid==idToSkip[jt]) keep=kFALSE;
2191  }
2192  if(!keep) continue;
2193  }
2194  Bool_t fb1 = tr->TestFilterBit(filtbit1);
2195  Bool_t fb2 = tr->TestFilterBit(filtbit2);
2196  Bool_t tpcRefit=tr->GetStatus() & AliAODTrack::kTPCrefit;
2197  if(filtbit1==1 && !tpcRefit) fb1=kFALSE;
2198  if(filtbit2==1 && !tpcRefit) fb2=kFALSE;
2199  if( !(fb1 || fb2) ) continue;
2200  ptArr[nSelTracks]=pt;
2201  phiArr[nSelTracks]=phi;
2202  nSelTracks++;
2203  sumpt+=pt;
2204  }
2205 
2206  if(nSelTracks<minMult){spherocity = -0.5; return;}
2207 
2208  //Getting thrust
2209  spherocity=2.;
2210  for(Int_t i=0; i<360/phiStepSizeDeg; ++i){
2211  Double_t phistep=TMath::Pi()*(Double_t)i*phiStepSizeDeg/180.;
2212  Double_t nx=TMath::Cos(phistep);
2213  Double_t ny=TMath::Sin(phistep);
2214  Double_t numer=0.;
2215  for(Int_t j=0; j<nSelTracks; ++j){
2216  Double_t pxA=ptArr[j]*TMath::Cos(phiArr[j]); // x component of an unitary vector n
2217  Double_t pyA=ptArr[j]*TMath::Sin(phiArr[j]); // y component of an unitary vector n
2218  numer+=TMath::Abs(ny*pxA - nx*pyA);
2219  }
2220  Double_t pFull=numer*numer/(sumpt*sumpt);
2221  if(pFull<spherocity){
2222  spherocity=pFull; // minimization;
2223  phiRef=phistep;
2224  }
2225  }
2226 
2227  delete [] ptArr;
2228  delete [] phiArr;
2229 
2230  spherocity*=(TMath::Pi()*TMath::Pi()/4.);
2231  return;
2232 
2233 }
2234 //________________________________________________________________________
2235 void AliVertexingHFUtils::GetGeneratedSpherocity(TClonesArray *arrayMC,
2236  Double_t &spherocity, Double_t &phiRef,
2237  Double_t etaMin, Double_t etaMax,
2238  Double_t ptMin, Double_t ptMax,
2239  Int_t minMult, Double_t phiStepSizeDeg){
2240 
2242 
2243  Int_t nParticles=arrayMC->GetEntriesFast();
2244  Int_t nSelParticles=0;
2245 
2246  Double_t* ptArr=new Double_t[nParticles];
2247  Double_t* phiArr=new Double_t[nParticles];
2248  Double_t sumpt=0.;
2249 
2250  for(Int_t ip=0; ip<nParticles; ip++) {
2251  AliAODMCParticle *part=(AliAODMCParticle*)arrayMC->UncheckedAt(ip);
2252  if(!part) continue;
2253  Float_t eta = part->Eta();
2254  Float_t pt = part->Pt();
2255  Float_t phi = part->Phi();
2256  Int_t charge = part->Charge();
2257  Bool_t isPhysPrim = part->IsPhysicalPrimary();
2258  if(!isPhysPrim) continue;
2259  if(charge==0) continue;
2260  if(eta<etaMin || eta>etaMax) continue;
2261  if(pt<ptMin || pt>ptMax) continue;
2262 
2263  ptArr[nSelParticles]=pt;
2264  phiArr[nSelParticles]=phi;
2265  nSelParticles++;
2266  sumpt+=pt;
2267  }
2268 
2269  if(nSelParticles<minMult){spherocity = -0.5; return;}
2270 
2271  //Getting thrust
2272  spherocity=2.;
2273  for(Int_t i=0; i<360/phiStepSizeDeg; ++i){
2274  Double_t phistep=TMath::Pi()*(Double_t)i*phiStepSizeDeg/180.;
2275  Double_t nx=TMath::Cos(phistep);
2276  Double_t ny=TMath::Sin(phistep);
2277  Double_t numer=0.;
2278  for(Int_t j=0; j<nSelParticles; ++j){
2279  Double_t pxA=ptArr[j]*TMath::Cos(phiArr[j]); // x component of an unitary vector n
2280  Double_t pyA=ptArr[j]*TMath::Sin(phiArr[j]); // y component of an unitary vector n
2281  numer+=TMath::Abs(ny*pxA - nx*pyA);
2282  }
2283  Double_t pFull=numer*numer/(sumpt*sumpt);
2284  if(pFull<spherocity){
2285  spherocity=pFull; // minimization;
2286  phiRef=phistep;
2287  }
2288  }
2289 
2290  delete [] ptArr;
2291  delete [] phiArr;
2292 
2293  spherocity*=(TMath::Pi()*TMath::Pi()/4.);
2294  return;
2295 
2296 }
2297 
2298 //________________________________________________________________________
2299 TH1D* AliVertexingHFUtils::RebinHisto(TH1* hOrig, Int_t reb, Int_t firstUse){
2305 
2306  Int_t nBinOrig=hOrig->GetNbinsX();
2307  Int_t firstBinOrig=1;
2308  Int_t lastBinOrig=nBinOrig;
2309  Int_t nBinOrigUsed=nBinOrig;
2310  Int_t nBinFinal=nBinOrig/reb;
2311  if(firstUse>=1){
2312  firstBinOrig=firstUse;
2313  nBinFinal=(nBinOrig-firstUse+1)/reb;
2314  nBinOrigUsed=nBinFinal*reb;
2315  lastBinOrig=firstBinOrig+nBinOrigUsed-1;
2316  }else{
2317  Int_t exc=nBinOrigUsed%reb;
2318  if(exc!=0){
2319  nBinOrigUsed-=exc;
2320  lastBinOrig=firstBinOrig+nBinOrigUsed-1;
2321  }
2322  }
2323 
2324  printf("Rebin from %d bins to %d bins -- Used bins=%d in range %d-%d\n",nBinOrig,nBinFinal,nBinOrigUsed,firstBinOrig,lastBinOrig);
2325  Float_t lowLim=hOrig->GetXaxis()->GetBinLowEdge(firstBinOrig);
2326  Float_t hiLim=hOrig->GetXaxis()->GetBinUpEdge(lastBinOrig);
2327  TH1D* hRebin=new TH1D(Form("%s-rebin",hOrig->GetName()),hOrig->GetTitle(),nBinFinal,lowLim,hiLim);
2328  Int_t lastSummed=firstBinOrig-1;
2329  for(Int_t iBin=1;iBin<=nBinFinal; iBin++){
2330  Float_t sum=0.;
2331  Float_t sume2=0.;
2332  for(Int_t iOrigBin=0;iOrigBin<reb;iOrigBin++){
2333  sum+=hOrig->GetBinContent(lastSummed+1);
2334  sume2+=(hOrig->GetBinError(lastSummed+1)*hOrig->GetBinError(lastSummed+1));
2335  lastSummed++;
2336  }
2337  hRebin->SetBinContent(iBin,sum);
2338  hRebin->SetBinError(iBin,TMath::Sqrt(sume2));
2339  }
2340  return hRebin;
2341 }
2342 //________________________________________________________________________
2343 TH1* AliVertexingHFUtils::AdaptTemplateRangeAndBinning(const TH1 *hMC,TH1 *hData, Double_t minFit, Double_t maxFit){
2345 
2346  Int_t binmin=TMath::Max(1,hData->FindBin(hMC->GetXaxis()->GetXmin()));
2347  Bool_t found=kFALSE;
2348  Int_t binminD=-1;
2349  Int_t binminMC=-1;
2350  for(Int_t j=binmin; j<hData->GetNbinsX(); j++){
2351  if(found) break;
2352  for(Int_t k=1; k<hMC->GetNbinsX(); k++){
2353  Double_t delta=TMath::Abs(hMC->GetBinLowEdge(k)-hData->GetBinLowEdge(j));
2354  if(delta<0.0001){
2355  found=kTRUE;
2356  binminMC=k;
2357  binminD=j;
2358  }
2359  if(found) break;
2360  }
2361  }
2362  Int_t binmax=TMath::Min(hData->GetNbinsX(),hData->FindBin(hMC->GetXaxis()->GetXmax()*0.99999));
2363  found=kFALSE;
2364  Int_t binmaxD=-1;
2365  Int_t binmaxMC=-1;
2366  for(Int_t j=binmax; j>1; j--){
2367  if(found) break;
2368  for(Int_t k=hMC->GetNbinsX(); k>400; k--){
2369  Double_t delta=TMath::Abs(hMC->GetBinLowEdge(k+1)-hData->GetBinLowEdge(j+1));
2370  if(delta<0.0001){
2371  found=kTRUE;
2372  binmaxMC=k;
2373  binmaxD=j;
2374  }
2375  if(found) break;
2376  }
2377  }
2378 
2379  Double_t min=hData->GetBinLowEdge(binminD);
2380  Double_t max=hData->GetBinLowEdge(binmaxD)+hData->GetBinWidth(binmaxD);
2381  Double_t minMC=hMC->GetBinLowEdge(binminMC);
2382  Double_t maxMC=hMC->GetBinLowEdge(binmaxMC)+hMC->GetBinWidth(binmaxMC);
2383  Double_t width=hData->GetBinWidth(binminD);
2384  Double_t widthMC=hMC->GetBinWidth(binminMC);
2385 
2386  if(TMath::Abs(minMC-min)>0.0001*min || TMath::Abs(maxMC-max)>0.0001*max){
2387  printf("Cannot adapt range and rebin histo:\n");
2388  printf("Range for data histo: %f-%f GeV/c2 bins %d-%d width=%f\n",min,max,binminD,binmaxD,width);
2389  printf("Range for reflection histo: %f-%f GeV/c2 bins %d-%d width=%f\n",minMC,maxMC,binminMC,binmaxMC,widthMC);
2390  return 0x0;
2391  }
2392 
2393  Double_t rebin=width/widthMC;
2394  if(TMath::Abs(rebin-TMath::Nint(rebin))>0.001){
2395  printf("Cannot adapt histo: rebin %f issue, width MC = %f, width hData=%f (check=%f)\n",rebin,widthMC,width,TMath::Abs(rebin-TMath::Nint(rebin)));
2396  return 0x0;
2397  }
2398 
2399  Int_t nBinsNew=binmaxD-binminD+1;
2400  TH1 *hOut;
2401  TString stype=hMC->ClassName();
2402  if(stype.Contains("TH1F")){
2403  hOut=new TH1F(Form("%s-rebinned",hMC->GetName()),hMC->GetTitle(),nBinsNew,min,max);
2404  }else if(stype.Contains("TH1D")){
2405  hOut=new TH1D(Form("%s-rebinned",hMC->GetName()),hMC->GetTitle(),nBinsNew,min,max);
2406  }else{
2407  printf("Wrong type %s\n",stype.Data());
2408  return 0x0;
2409  }
2410 
2411  for(Int_t j=1; j<=hMC->GetNbinsX(); j++){
2412  Double_t m=hMC->GetBinCenter(j);
2413  Int_t binFin=hOut->FindBin(m);
2414  if(binFin>=1 && binFin<=nBinsNew){
2415  hOut->AddBinContent(binFin,hMC->GetBinContent(j));
2416  }
2417  }
2418  return hOut;
2419 }
charge
Int_t charge
Definition: MuonTrackingEfficiency.C:58
AliVertexingHFUtils::GetSpherocity
static void GetSpherocity(AliAODEvent *aod, Double_t &spherocity, Double_t &phiRef, Double_t etaMin=-0.8, Double_t etaMax=0.8, Double_t ptMin=0.15, Double_t ptMax=10., Int_t filtbit1=256, Int_t filtbit2=512, Int_t minMult=3, Double_t phiStepSizeDeg=0.1, Int_t nTrksToSkip=0, Int_t *idToSkip=0x0)
Functions for event shape variables.
Definition: AliVertexingHFUtils.cxx:2161
AliVertexingHFUtils::CheckD0Decay
static Int_t CheckD0Decay(AliMCEvent *mcEvent, Int_t label, Int_t *arrayDauLab)
Definition: AliVertexingHFUtils.cxx:697
AliVertexingHFUtils::AveragePt
static void AveragePt(Float_t &averagePt, Float_t &errorPt, Float_t ptmin, Float_t ptmax, TH2F *hMassD, Float_t massFromFit, Float_t sigmaFromFit, TF1 *funcB2, Float_t sigmaRangeForSig=2.5, Float_t sigmaRangeForBkg=4.5, Float_t minMass=0., Float_t maxMass=3., Int_t rebin=1)
Functions for computing average pt.
Definition: AliVertexingHFUtils.cxx:277
AliVertexingHFUtils::RebinHisto
static TH1D * RebinHisto(TH1 *hOrig, Int_t reb, Int_t firstUse=-1)
Rebinning of invariant mass histograms.
Definition: AliVertexingHFUtils.cxx:2299
Double_t
double Double_t
Definition: External.C:58
TH2F
Definition: External.C:236
AliVertexingHFUtils::CheckDplusDecay
static Int_t CheckDplusDecay(AliMCEvent *mcEvent, Int_t label, Int_t *arrayDauLab)
Definition: AliVertexingHFUtils.cxx:914
AliVertexingHFUtils::CheckDsDecay
static Int_t CheckDsDecay(AliMCEvent *mcEvent, Int_t label, Int_t *arrayDauLab)
Definition: AliVertexingHFUtils.cxx:1339
AliVertexingHFUtils::CheckLcpKpiDecay
static Int_t CheckLcpKpiDecay(AliMCEvent *mcEvent, Int_t label, Int_t *arrayDauLab)
Definition: AliVertexingHFUtils.cxx:1750
AliAODRecoCascadeHF::Getv0
AliAODv0 * Getv0() const
Definition: AliAODRecoCascadeHF.h:56
AliVertexingHFUtils.h
AliAODRecoDecayHF::ImpParXY
Double_t ImpParXY() const
Definition: AliAODRecoDecayHF.h:83
AliVertexingHFUtils::GetGenerator
static TString GetGenerator(Int_t label, AliAODMCHeader *header)
Definition: AliVertexingHFUtils.cxx:515
c
TCanvas * c
Definition: TestFitELoss.C:172
AliVertexingHFUtils::Pol
Double_t Pol(Double_t x) const
Definition: AliVertexingHFUtils.h:53
AliVertexingHFUtils::GetFullEvResolLowLim
static Double_t GetFullEvResolLowLim(const TH1F *hSubEvCorr, Int_t k=1)
Definition: AliVertexingHFUtils.cxx:174
ptMin
Double_t ptMin
Definition: MuonTrackingEfficiency.C:52
AliVertexingHFUtils::AdaptTemplateRangeAndBinning
static TH1 * AdaptTemplateRangeAndBinning(const TH1 *hRef, TH1 *hData, Double_t minFit, Double_t maxFit)
Definition: AliVertexingHFUtils.cxx:2343
AliVertexingHFUtils::CheckOrigin
static Int_t CheckOrigin(TClonesArray *arrayMC, AliAODMCParticle *mcPart, Bool_t searchUpToQuark=kTRUE)
Functions to check the decay tree.
Definition: AliVertexingHFUtils.cxx:637
gRandom
TRandom * gRandom
part
TString part
use mixed event to constrain combinatorial background
Definition: InvMassFit.C:52
AliVertexingHFUtils::GetTrackPrimaryGenerator
void GetTrackPrimaryGenerator(AliAODTrack *track, AliAODMCHeader *header, TClonesArray *arrayMC, TString &nameGen)
Definition: AliVertexingHFUtils.cxx:532
AliVertexingHFUtils::fMinEtaForTracklets
Double_t fMinEtaForTracklets
sub-event resolution = sqrt(<cos[n(phiA-phiB)] >)
Definition: AliVertexingHFUtils.h:159
AliVertexingHFUtils::fSubRes
Double_t fSubRes
ratio of measured harmonic to event plane harmonic
Definition: AliVertexingHFUtils.h:158
AliVertexingHFUtils::CheckDplusK0spiDecay
static Int_t CheckDplusK0spiDecay(AliMCEvent *mcEvent, Int_t label, Int_t *arrayDauLab)
Definition: AliVertexingHFUtils.cxx:1261
AliVertexingHFUtils::CheckXicXipipiDecay
static Int_t CheckXicXipipiDecay(AliMCEvent *mcEvent, Int_t label, Int_t *arrayDauLab)
Definition: AliVertexingHFUtils.cxx:2050
AliVertexingHFUtils::CheckLcV0bachelorDecay
static Int_t CheckLcV0bachelorDecay(AliMCEvent *mcEvent, Int_t label, Int_t *arrayDauLab)
Definition: AliVertexingHFUtils.cxx:1955
AliVertexingHFUtils::fMaxEtaForTracklets
Double_t fMaxEtaForTracklets
min eta for counting tracklets
Definition: AliVertexingHFUtils.h:160
AliVertexingHFUtils::GetVZEROCEqualizedMultiplicity
static Double_t GetVZEROCEqualizedMultiplicity(AliAODEvent *ev)
Definition: AliVertexingHFUtils.cxx:263
AliVertexingHFUtils::GetFullEvResolHighLim
static Double_t GetFullEvResolHighLim(const TH1F *hSubEvCorr, Int_t k=1)
Definition: AliVertexingHFUtils.cxx:182
AliVertexingHFUtils::GetGeneratedSpherocity
static void GetGeneratedSpherocity(TClonesArray *arrayMC, Double_t &spherocity, Double_t &phiRef, Double_t etaMin=-0.8, Double_t etaMax=0.8, Double_t ptMin=0.15, Double_t ptMax=10., Int_t minMult=3, Double_t phiStepSizeDeg=0.1)
Definition: AliVertexingHFUtils.cxx:2235
AliVertexingHFUtils::ResolK1
static Double_t ResolK1(Double_t x)
Definition: AliVertexingHFUtils.cxx:105
AliVertexingHFUtils::GetNumberOfTrackletsInEtaRange
static Int_t GetNumberOfTrackletsInEtaRange(AliAODEvent *ev, Double_t mineta, Double_t maxeta)
Definition: AliVertexingHFUtils.cxx:190
Int_t
int Int_t
Definition: External.C:63
AliVertexingHFUtils::GetFullEvResol
Double_t GetFullEvResol() const
Definition: AliVertexingHFUtils.h:55
Float_t
float Float_t
Definition: External.C:68
ptmax
const Double_t ptmax
Definition: AddTaskCFDStar.C:39
AliVertexingHFUtils::CheckDplusKKpiDecay
static Int_t CheckDplusKKpiDecay(AliMCEvent *mcEvent, Int_t label, Int_t *arrayDauLab)
Definition: AliVertexingHFUtils.cxx:1085
AliVertexingHFUtils::CheckT0TriggerFired
static Bool_t CheckT0TriggerFired(AliAODEvent *aodEv)
Functions for processing trigger information.
Definition: AliVertexingHFUtils.cxx:354
TH1D
Definition: External.C:212
AliAODRecoCascadeHF::GetBachelor
AliAODTrack * GetBachelor() const
Definition: AliAODRecoCascadeHF.h:53
AliVertexingHFUtils::GetSubEvResolLowLim
static Double_t GetSubEvResolLowLim(const TH1F *hSubEvCorr)
Definition: AliVertexingHFUtils.h:63
ptmin
const Double_t ptmin
Definition: AddTaskCFDStar.C:38
AliVertexingHFUtils::HasCascadeCandidateAnyDaughInjected
Bool_t HasCascadeCandidateAnyDaughInjected(AliAODRecoCascadeHF *cand, AliAODMCHeader *header, TClonesArray *arrayMC)
Definition: AliVertexingHFUtils.cxx:585
AliVertexingHFUtils::IsCandidateInjected
Bool_t IsCandidateInjected(AliAODRecoDecayHF *cand, AliAODMCHeader *header, TClonesArray *arrayMC)
Definition: AliVertexingHFUtils.cxx:574
AliVertexingHFUtils::CheckDstarDecay
static Int_t CheckDstarDecay(AliMCEvent *mcEvent, Int_t label, Int_t *arrayDauLab)
Definition: AliVertexingHFUtils.cxx:1602
Short_t
short Short_t
Definition: External.C:23
AliVertexingHFUtils::GetBeautyMotherPt
static Double_t GetBeautyMotherPt(TClonesArray *arrayMC, AliAODMCParticle *mcPart)
Definition: AliVertexingHFUtils.cxx:669
AliVertexingHFUtils::ComputeSignificance
static void ComputeSignificance(Double_t signal, Double_t errsignal, Double_t background, Double_t errbackground, Double_t &significance, Double_t &errsignificance)
Significance calculator.
Definition: AliVertexingHFUtils.cxx:73
AliVertexingHFUtils::GetCorrectedNtracklets
static Double_t GetCorrectedNtracklets(TProfile *estimatorAvg, Double_t uncorrectedNacc, Double_t vtxZ, Double_t refMult)
Definition: AliVertexingHFUtils.cxx:490
AliVertexingHFUtils::GetSubEvResol
Double_t GetSubEvResol() const
Definition: AliVertexingHFUtils.h:52
AliVertexingHFUtils::IsTrackInjected
Bool_t IsTrackInjected(AliAODTrack *track, AliAODMCHeader *header, TClonesArray *arrayMC)
Definition: AliVertexingHFUtils.cxx:564
minMass
Double_t minMass
Definition: ProjectCombinHFAndFit.C:51
AliAODRecoDecayHF.h
AliVertexingHFUtils::FindChi
Double_t FindChi() const
Definition: AliVertexingHFUtils.h:54
rebin
Int_t rebin
Definition: charmCutsOptimization.C:32
AliVertexingHFUtils::GetGeneratedPhysicalPrimariesInEtaRange
static Int_t GetGeneratedPhysicalPrimariesInEtaRange(TClonesArray *arrayMC, Double_t mineta, Double_t maxeta)
Definition: AliVertexingHFUtils.cxx:231
AliVertexingHFUtils::GetVZEROAEqualizedMultiplicity
static Double_t GetVZEROAEqualizedMultiplicity(AliAODEvent *ev)
Utilities for V0 multiplicity checks.
Definition: AliVertexingHFUtils.cxx:248
AliVertexingHFUtils::GetTrueImpactParameterDzero
static Double_t GetTrueImpactParameterDzero(AliAODMCHeader *mcHeader, TClonesArray *arrayMC, AliAODMCParticle *partDp)
Functions for computing true impact parameter of D meson.
Definition: AliVertexingHFUtils.cxx:361
maxMass
Double_t maxMass
Definition: ProjectCombinHFAndFit.C:52
Bool_t
bool Bool_t
Definition: External.C:53
AliVertexingHFUtils::CheckDsK0sKDecay
static Int_t CheckDsK0sKDecay(AliMCEvent *mcEvent, Int_t label, Int_t *arrayDauLab)
Definition: AliVertexingHFUtils.cxx:1428
ptMax
Double_t ptMax
Definition: MuonTrackingEfficiency.C:53
AliVertexingHFUtils::GetSubEvResolHighLim
static Double_t GetSubEvResolHighLim(const TH1F *hSubEvCorr)
Definition: AliVertexingHFUtils.h:67
AliVertexingHFUtils::GetTrueImpactParameterDplus
static Double_t GetTrueImpactParameterDplus(AliAODMCHeader *mcHeader, TClonesArray *arrayMC, AliAODMCParticle *partDp)
Definition: AliVertexingHFUtils.cxx:404
AliVertexingHFUtils::GetSphericity
static Double_t GetSphericity(AliAODEvent *aod, Double_t etaMin=-0.8, Double_t etaMax=0.8, Double_t ptMin=0.15, Double_t ptMax=10., Int_t filtbit1=256, Int_t filtbit2=512, Int_t minMult=3)
Definition: AliVertexingHFUtils.cxx:2104
TH1
Definition: External.C:196
AliVertexingHFUtils::GetGeneratedMultiplicityInEtaRange
static Int_t GetGeneratedMultiplicityInEtaRange(TClonesArray *arrayMC, Double_t mineta, Double_t maxeta)
Definition: AliVertexingHFUtils.cxx:203
AliVertexingHFUtils::GetGeneratedPrimariesInEtaRange
static Int_t GetGeneratedPrimariesInEtaRange(TClonesArray *arrayMC, Double_t mineta, Double_t maxeta)
Definition: AliVertexingHFUtils.cxx:216
AliVertexingHFUtils
Class with functions useful for different D2H analyses //.
Definition: AliVertexingHFUtils.h:36