AliPhysics  vAN-20151012 (2287573)
 All Classes Namespaces Files Functions Variables Enumerations Enumerator Macros
AliRDHFCutsDstoKKpi.cxx
Go to the documentation of this file.
1 /**************************************************************************
2  * Copyright(c) 1998-2010, 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 /* $Id$ */
17 
19 //
20 // Class for cuts on AOD reconstructed Ds->KKpi
21 //
22 // Author: A.Dainese, andrea.dainese@pd.infn.it
24 
25 #include <TDatabasePDG.h>
26 #include <Riostream.h>
27 
28 #include "AliRDHFCutsDstoKKpi.h"
30 #include "AliAODTrack.h"
31 #include "AliESDtrack.h"
32 
33 using std::cout;
34 using std::endl;
35 
39 
40 
41 //--------------------------------------------------------------------------
43 AliRDHFCuts(name),
44  fCutOnResonances(kTRUE),
45  fPidOption(0),
46  fMaxPtStrongPid(0.),
47  fMaxPStrongPidK(0.),
48  fMaxPStrongPidpi(0.),
49  fDistToMaxProb(0.01),
50  fBayesThreshold(0.05),
51  fWeightKKpi(1.),
52  fWeightpiKK(1.)
53 {
54  //
55  // Default Constructor
56  //
57  Int_t nvars=20;
58  SetNVars(nvars);
59  TString varNames[20]={"inv. mass [GeV]",
60  "pTK [GeV/c]",
61  "pTPi [GeV/c]",
62  "d0K [cm]",
63  "d0Pi [cm]",
64  "dist12 [cm]",
65  "sigmavert [cm]",
66  "decLen [cm]",
67  "ptMax [GeV/c]",
68  "cosThetaPoint",
69  "Sum d0^2 (cm^2)",
70  "dca [cm]",
71  "inv. mass (Mphi-MKK) [GeV]",
72  "inv. mass (MKo*-MKpi) [GeV]",
73  "Abs(CosineKpiPhiRFrame)^3",
74  "CosPiDsLabFrame",
75  "decLenXY [cm]"
76  "NormdecLen",
77  "NormdecLenXY [cm]",
78  "cosThetaPointXY"};
79 
80  Bool_t isUpperCut[20]={kTRUE,
81  kFALSE,
82  kFALSE,
83  kFALSE,
84  kFALSE,
85  kFALSE,
86  kTRUE,
87  kFALSE,
88  kFALSE,
89  kFALSE,
90  kFALSE,
91  kTRUE,
92  kTRUE,
93  kTRUE,
94  kFALSE,
95  kTRUE,
96  kFALSE,
97  kFALSE,
98  kFALSE,
99  kFALSE};
100  SetVarNames(20,varNames,isUpperCut);
101  Bool_t forOpt[20]={kFALSE,
102  kFALSE,
103  kFALSE,
104  kFALSE,
105  kFALSE,
106  kFALSE,
107  kTRUE,
108  kTRUE,
109  kTRUE,
110  kTRUE,
111  kTRUE,
112  kFALSE,
113  kTRUE,
114  kTRUE,
115  kFALSE,
116  kFALSE,
117  kTRUE,
118  kTRUE,
119  kTRUE,
120  kTRUE};
121 
122  SetVarsForOpt(11,forOpt);
123  Float_t limits[2]={0,999999999.};
124  SetPtBins(2,limits);
125  if(fPidHF)delete fPidHF;
126  fPidHF=new AliAODPidHF();
127  Double_t plim[2]={0.6,0.8};
128  Double_t nsigma[5]={2.,1.,2.,3.,0.};
129 
130  fPidHF->SetPLimit(plim,2);
131  fPidHF->SetAsym(kTRUE);
132  fPidHF->SetSigma(nsigma);
133  fPidHF->SetMatch(1);
134  fPidHF->SetTPC(1);
135  fPidHF->SetTOF(1);
136  fPidHF->SetITS(0);
137  fPidHF->SetTRD(0);
138  fPidHF->SetCompat(kTRUE);
139 
140 }
141 //--------------------------------------------------------------------------
143  AliRDHFCuts(source),
144  fCutOnResonances(source.fCutOnResonances),
145  fPidOption(source.fPidOption),
146  fMaxPtStrongPid(source.fMaxPtStrongPid),
147  fMaxPStrongPidK(source.fMaxPStrongPidK),
148  fMaxPStrongPidpi(source.fMaxPStrongPidpi),
149  fDistToMaxProb(source.fDistToMaxProb),
150  fBayesThreshold(source.fBayesThreshold),
151  fWeightKKpi(source.fWeightKKpi),
152  fWeightpiKK(source.fWeightpiKK)
153 {
154  //
155  // Copy constructor
156  //
157 
158 }
159 //--------------------------------------------------------------------------
161 {
162  //
163  // assignment operator
164  //
165  if(&source == this) return *this;
166 
167  AliRDHFCuts::operator=(source);
168 
170  fPidOption=source.fPidOption;
176  fWeightKKpi=source.fWeightKKpi;
177  fWeightpiKK=source.fWeightpiKK;
178 
179  return *this;
180 }
181 
182 
183 //---------------------------------------------------------------------------
184 void AliRDHFCutsDstoKKpi::GetCutVarsForOpt(AliAODRecoDecayHF *d,Float_t *vars,Int_t nvars,Int_t *pdgdaughters,AliAODEvent *aod) {
185  //
186  // Fills in vars the values of the variables
187  //
188 
189  if(nvars!=fnVarsForOpt) {
190  printf("AliRDHFCutsDstoKKpi::GetCutsVarsForOpt: wrong number of variables\n");
191  return;
192  }
193 
195 
196  //recalculate vertex w/o daughters
197  Bool_t cleanvtx=kFALSE;
198  AliAODVertex *origownvtx=0x0;
200  if(dd->GetOwnPrimaryVtx()) origownvtx=new AliAODVertex(*dd->GetOwnPrimaryVtx());
201  cleanvtx=kTRUE;
202  if(!RecalcOwnPrimaryVtx(dd,aod)) {
203  CleanOwnPrimaryVtx(dd,aod,origownvtx);
204  cleanvtx=kFALSE;
205  }
206  }
207 
208  Int_t iter=-1;
209  if(fVarsForOpt[0]){
210  iter++;
211  if(TMath::Abs(pdgdaughters[0])==321){
212  vars[iter]=dd->InvMassDsKKpi();
213  }else{
214  vars[iter]=dd->InvMassDspiKK();
215  }
216  }
217  if(fVarsForOpt[1]){
218  iter++;
219  Float_t minPtDau=99999.;
220  for(Int_t iprong=0;iprong<3;iprong++){
221  if(TMath::Abs(pdgdaughters[iprong])==321 &&
222  dd->PtProng(iprong)<minPtDau) minPtDau=dd->PtProng(iprong);
223  }
224  vars[iter]=minPtDau;
225  }
226  if(fVarsForOpt[2]){
227  iter++;
228  for(Int_t iprong=0;iprong<3;iprong++){
229  if(TMath::Abs(pdgdaughters[iprong])==211) {
230  vars[iter]=dd->PtProng(iprong);
231  }
232  }
233  }
234  if(fVarsForOpt[3]){
235  iter++;
236  Float_t minImpParDau=99999.;
237  for(Int_t iprong=0;iprong<3;iprong++){
238  if(TMath::Abs(pdgdaughters[iprong])==321 &&
239  dd->Getd0Prong(iprong)<minImpParDau) minImpParDau=dd->Getd0Prong(iprong);
240  }
241  vars[iter]=minImpParDau;
242  }
243  if(fVarsForOpt[4]){
244  iter++;
245  for(Int_t iprong=0;iprong<3;iprong++){
246  if(TMath::Abs(pdgdaughters[iprong])==211) {
247  vars[iter]=dd->Getd0Prong(iprong);
248  }
249  }
250  }
251  if(fVarsForOpt[5]){
252  iter++;
253  Float_t minDistPair=TMath::Min(dd->GetDist12toPrim(),dd->GetDist23toPrim());
254  vars[iter]=minDistPair;
255  }
256  if(fVarsForOpt[6]){
257  iter++;
258  vars[iter]=dd->GetSigmaVert(aod);
259  }
260  if(fVarsForOpt[7]){
261  iter++;
262  vars[iter] = dd->DecayLength();
263  }
264  if(fVarsForOpt[8]){
265  iter++;
266  Float_t ptmax=0;
267  for(Int_t i=0;i<3;i++){
268  if(dd->PtProng(i)>ptmax)ptmax=dd->PtProng(i);
269  }
270  vars[iter]=ptmax;
271  }
272  if(fVarsForOpt[9]){
273  iter++;
274  vars[iter]=dd->CosPointingAngle();
275  }
276  if(fVarsForOpt[10]){
277  iter++;
278  vars[iter]=dd->Getd0Prong(0)*dd->Getd0Prong(0)+dd->Getd0Prong(1)*dd->Getd0Prong(1)+dd->Getd0Prong(2)*dd->Getd0Prong(2);
279  }
280  if(fVarsForOpt[11]){
281  iter++;
282  Float_t maxDCA=0.;
283  for(Int_t i=0;i<3;i++){
284  if(d->GetDCA(i)>maxDCA) maxDCA=d->GetDCA(i);
285  }
286  vars[iter]=maxDCA;
287  }
288  if(fVarsForOpt[12]){
289  iter++;
290  Double_t mPDGPhi = TDatabasePDG::Instance()->GetParticle(333)->Mass();
291  if(TMath::Abs(pdgdaughters[0])==321){
292 
293  Double_t phimass01=d->InvMass2Prongs(0,1,321,321);
294  vars[iter]=TMath::Abs(phimass01-mPDGPhi);
295  // vars[iter]=dd->InvMass2Prongs(0,1,321,321);
296  }else{
297  Double_t phimass12=d->InvMass2Prongs(1,2,321,321);
298  vars[iter]=TMath::Abs(phimass12-mPDGPhi);
299  // vars[iter]=dd->InvMass2Prongs(1,2,321,321);
300  }
301  }
302  if(fVarsForOpt[13]){
303  iter++;
304  Double_t mPDGK0star = TDatabasePDG::Instance()->GetParticle(313)->Mass();
305  if(TMath::Abs(pdgdaughters[0])==321){
306 
307  Double_t mass12kpi=d->InvMass2Prongs(1,2,321,211);
308  vars[iter]=TMath::Abs(mass12kpi-mPDGK0star);
309  // vars[iter]=dd->InvMass2Prongs(1,2,321,211);
310  }else{
311  Double_t mass01pik=d->InvMass2Prongs(0,1,211,321);
312  vars[iter]=TMath::Abs(mass01pik-mPDGK0star);
313  // vars[iter]=dd->InvMass2Prongs(0,1,211,321);
314  }
315  }
316  if(fVarsForOpt[14]){
317  iter++;
318  if(TMath::Abs(pdgdaughters[0])==321){
319  vars[iter]=dd->CosPiKPhiRFrameKKpi();
320  }else{
321  vars[iter]=dd->CosPiKPhiRFramepiKK();
322  }
323  }
324  if(fVarsForOpt[15]){
325  iter++;
326  if(TMath::Abs(pdgdaughters[0])==321){
327  vars[iter]=dd->CosPiDsLabFrameKKpi();
328  }else{
329  vars[iter]=dd->CosPiDsLabFramepiKK();
330  }
331  }
332 
333  if(fVarsForOpt[16]){
334  iter++;
335  vars[iter]=dd->DecayLengthXY();
336  }
337 
338  if(fVarsForOpt[17]){
339  iter++;
340  vars[iter]=dd->NormalizedDecayLength();
341  }
342 
343  if(fVarsForOpt[18]){
344  iter++;
345  vars[iter]=dd->NormalizedDecayLengthXY();
346  }
347 
348  if(fVarsForOpt[19]){
349  iter++;
350  vars[iter]=dd->CosPointingAngleXY();
351  }
352 
353  if(cleanvtx)CleanOwnPrimaryVtx(dd,aod,origownvtx);
354  return;
355 }
356 //---------------------------------------------------------------------------
357 Bool_t AliRDHFCutsDstoKKpi::IsInFiducialAcceptance(Double_t pt, Double_t y) const
358 {
359  //
360  // Checking if Ds is in fiducial acceptance region
361  //
362 
363  if(fMaxRapidityCand>-998.){
364  if(TMath::Abs(y) > fMaxRapidityCand) return kFALSE;
365  else return kTRUE;
366  }
367 
368  if(pt > 5.) {
369  // applying cut for pt > 5 GeV
370  AliDebug(2,Form("pt of Ds = %f (> 5), cutting at |y| < 0.8",pt));
371  if (TMath::Abs(y) > 0.8) return kFALSE;
372 
373  } else {
374  // appliying smooth cut for pt < 5 GeV
375  Double_t maxFiducialY = -0.2/15*pt*pt+1.9/15*pt+0.5;
376  Double_t minFiducialY = 0.2/15*pt*pt-1.9/15*pt-0.5;
377  AliDebug(2,Form("pt of Ds = %f (< 5), cutting according to the fiducial zone [%f, %f]\n",pt,minFiducialY,maxFiducialY));
378  if (y < minFiducialY || y > maxFiducialY) return kFALSE;
379  }
380 
381  return kTRUE;
382 }
383 
384 //---------------------------------------------------------------------------
386  Int_t retCode=3;
387  Bool_t okKKpi=kTRUE;
388  Bool_t okpiKK=kTRUE;
389  if(!fUsePID || !rd) return retCode;
390  if(!fPidHF){
391  AliWarning("AliAODPidHF not created!");
392  return retCode;
393  }
395  AliWarning("Wrong call to Bayesian PID");
396  return retCode;
397  }
398 
399  AliPIDCombined* copid=fPidHF->GetPidCombined();
400  copid->SetDetectorMask(AliPIDResponse::kDetTPC | AliPIDResponse::kDetTOF);
401  AliPIDResponse* pidres=fPidHF->GetPidResponse();
402  Double_t bayesProb[AliPID::kSPECIES];
403  Int_t nKaons=0;
404  Int_t nNotKaons=0;
405  Int_t sign= rd->GetCharge();
406  fWeightKKpi=1.;
407  fWeightpiKK=1.;
408  for(Int_t iDaught=0; iDaught<3; iDaught++){
409  AliAODTrack *track=(AliAODTrack*)rd->GetDaughter(iDaught);
410 
411  Int_t isPion=0;
412  Int_t isKaon=0;
413  Int_t isProton=0;
414  UInt_t usedDet=copid->ComputeProbabilities(track,pidres,bayesProb);
415  if(usedDet!=0){
417  Double_t maxProb=TMath::MaxElement(AliPID::kSPECIES,bayesProb);
418  if(TMath::Abs(maxProb-bayesProb[AliPID::kPion])<fDistToMaxProb) isPion=1;
419  else isPion=-1;
420  if(TMath::Abs(maxProb-bayesProb[AliPID::kKaon])<fDistToMaxProb) isKaon=1;
421  else isKaon=-1;
422  if(TMath::Abs(maxProb-bayesProb[AliPID::kProton])<fDistToMaxProb) isProton=1;
423  else isProton=-1;
424  }
426  if(bayesProb[AliPID::kPion]>fBayesThreshold) isPion=1;
427  else isPion=-1;
428  if(bayesProb[AliPID::kKaon]>fBayesThreshold) isKaon=1;
429  else isKaon=-1;
430  if(bayesProb[AliPID::kProton]>fBayesThreshold) isProton=1;
431  else isProton=-1;
432  }
433  }
434  if(fPidOption==kBayesianWeights){ // store the probabilities in the case kBayesianWeights
435  if(iDaught==0){
436  fWeightKKpi*=bayesProb[AliPID::kKaon];
437  fWeightpiKK*=bayesProb[AliPID::kPion];
438  }else if(iDaught==1){
439  fWeightKKpi*=bayesProb[AliPID::kKaon];
440  fWeightpiKK*=bayesProb[AliPID::kKaon];
441  }else if(iDaught==2){
442  fWeightKKpi*=bayesProb[AliPID::kPion];
443  fWeightpiKK*=bayesProb[AliPID::kKaon];
444  }
445  }else{ // selection for the other cases
446  if(isProton>0 && isKaon<0 && isPion<0) return 0;
447  if(sign!=track->Charge()){// must be kaon
448  if(isKaon<0) return 0;
449  }
450  if(isKaon>0 && isPion<0) nKaons++;
451  if(isKaon<0) nNotKaons++;
452  if(iDaught==0){
453  if(isKaon<0) okKKpi=kFALSE;
454  if(isPion<0) okpiKK=kFALSE;
455  }else if(iDaught==2){
456  if(isKaon<0) okpiKK=kFALSE;
457  if(isPion<0) okKKpi=kFALSE;
458  }
459  }
460  }
461  if(fPidOption==kBayesianWeights) return retCode;
462 
463  if(nKaons>2)return 0;
464  if(nNotKaons>1) return 0;
465 
466  if(!okKKpi) retCode-=1;
467  if(!okpiKK) retCode-=2;
468 
469  return retCode;
470 }
471 
472 //---------------------------------------------------------------------------
474  // PID selection
475  // return values: 0->NOT OK, 1->OK as KKpi, 2->OK as piKK, 3->OK as both
476  Int_t retCode=3;
477  Bool_t okKKpi=kTRUE;
478  Bool_t okpiKK=kTRUE;
479  if(!fUsePID || !rd) return retCode;
480  if(!fPidHF){
481  AliWarning("AliAODPidHF not created!");
482  return retCode;
483  }
485  // call method for Bayesian probability
486  return IsSelectedPIDBayes(rd);
487  }
488 
489  Double_t origCompatTOF=fPidHF->GetPCompatTOF();
490  Double_t origThreshTPC=fPidHF->GetPtThresholdTPC();
491  if(fPidOption==kStrong){
492  fPidHF->SetPCompatTOF(999999.);
493  fPidHF->SetPtThresholdTPC(999999.);
494  }
495 
496  Int_t nKaons=0;
497  Int_t nNotKaons=0;
498  Int_t sign= rd->GetCharge();
499  for(Int_t iDaught=0; iDaught<3; iDaught++){
500  AliAODTrack *track=(AliAODTrack*)rd->GetDaughter(iDaught);
501 
502  Int_t isPion=fPidHF->MakeRawPid(track,AliPID::kPion);
503  Int_t isKaon=fPidHF->MakeRawPid(track,AliPID::kKaon);
504  Int_t isProton=fPidHF->MakeRawPid(track,AliPID::kProton);
505 
506  if(isProton>0 && isKaon<0 && isPion<0){
507  fPidHF->SetPCompatTOF(origCompatTOF);
508  fPidHF->SetPtThresholdTPC(origThreshTPC);
509  return 0;
510  }
511  if(sign!=track->Charge()){// must be kaon
512  if(isKaon<0){
513  fPidHF->SetPCompatTOF(origCompatTOF);
514  fPidHF->SetPtThresholdTPC(origThreshTPC);
515  return 0;
516  }
517  if(fPidOption==kStrong && rd->Pt()<fMaxPtStrongPid && isKaon<=0){
518  fPidHF->SetPCompatTOF(origCompatTOF);
519  fPidHF->SetPtThresholdTPC(origThreshTPC);
520  return 0;
521  }
522  if(fPidOption==kStrongPDep && rd->Pt()<fMaxPtStrongPid){
523  if(isKaon<=0 && track->P()<fMaxPStrongPidK) return 0;
524  }
525  }
526 
527  if(isKaon>0 && isPion<0) nKaons++;
528  if(isKaon<0) nNotKaons++;
529  if(iDaught==0){
530  if(isKaon<0) okKKpi=kFALSE;
531  if(isPion<0) okpiKK=kFALSE;
532  if(fPidOption==kStrong && rd->Pt()<fMaxPtStrongPid){
533  if(isKaon<=0) okKKpi=kFALSE;
534  if(isPion<=0) okpiKK=kFALSE;
535  }
536  if(fPidOption==kStrongPDep && rd->Pt()<fMaxPtStrongPid){
537  if(isKaon<=0 && track->P()<fMaxPStrongPidK) okKKpi=kFALSE;
538  if(isPion<=0 && track->P()<fMaxPStrongPidpi) okpiKK=kFALSE;
539  }
540  }
541  else if(iDaught==2){
542  if(isKaon<0) okpiKK=kFALSE;
543  if(isPion<0) okKKpi=kFALSE;
544  if(fPidOption==kStrong && rd->Pt()<fMaxPtStrongPid){
545  if(isKaon<=0) okpiKK=kFALSE;
546  if(isPion<=0) okKKpi=kFALSE;
547  }
548  if(fPidOption==kStrongPDep && rd->Pt()<fMaxPtStrongPid){
549  if(isKaon<=0 && track->P()<fMaxPStrongPidK) okpiKK=kFALSE;
550  if(isPion<=0 && track->P()<fMaxPStrongPidpi) okKKpi=kFALSE;
551  }
552  }
553  }
554 
555  fPidHF->SetPCompatTOF(origCompatTOF);
556  fPidHF->SetPtThresholdTPC(origThreshTPC);
557 
558  if(nKaons>2)return 0;
559  if(nNotKaons>1) return 0;
560 
561  if(!okKKpi) retCode-=1;
562  if(!okpiKK) retCode-=2;
563 
564  return retCode;
565 }
566 
567 //---------------------------------------------------------------------------
568 Int_t AliRDHFCutsDstoKKpi::IsSelected(TObject* obj,Int_t selectionLevel, AliAODEvent* aod) {
569  //
570  // Apply selection
571  //
572 
573  if(!fCutsRD){
574  cout<<"Cut matrix not inizialized. Exit..."<<endl;
575  return 0;
576  }
577  //PrintAll();
579 
580  if(!d){
581  cout<<"AliAODRecoDecayHF3Prong null"<<endl;
582  return 0;
583  }
584 
585  if(fKeepSignalMC) if(IsSignalMC(d,aod,431)) return 3;
586 
587  Double_t ptD=d->Pt();
588  if(ptD<fMinPtCand) return 0;
589  if(ptD>fMaxPtCand) return 0;
590 
592 
593 
594  // selection on daughter tracks
595  if(selectionLevel==AliRDHFCuts::kAll ||
596  selectionLevel==AliRDHFCuts::kTracks) {
597  if(!AreDaughtersSelected(d)) return 0;
598  }
599 
600 
601 
602 
603  // selection on candidate
604  if(selectionLevel==AliRDHFCuts::kAll ||
605  selectionLevel==AliRDHFCuts::kCandidate) {
606  //recalculate vertex w/o daughters
607  AliAODVertex *origownvtx=0x0;
609  if(d->GetOwnPrimaryVtx()) origownvtx=new AliAODVertex(*d->GetOwnPrimaryVtx());
610  if(!RecalcOwnPrimaryVtx(d,aod)) {
611  CleanOwnPrimaryVtx(d,aod,origownvtx);
612  return 0;
613  }
614  }
615 
616  Int_t okDsKKpi=1;
617  Int_t okDspiKK=1;
618  Int_t okMassPhiKKpi=0;
619  Int_t okMassPhipiKK=0;
620  Int_t okMassK0starKKpi=0;
621  Int_t okMassK0starpiKK=0;
622  Int_t okDsPhiKKpi=0;
623  Int_t okDsPhipiKK=0;
624  Int_t okDsK0starKKpi=0;
625  Int_t okDsK0starpiKK=0;
626 
627  Double_t pt=d->Pt();
628  Int_t ptbin=PtBin(pt);
629  if (ptbin==-1) {
630  CleanOwnPrimaryVtx(d,aod,origownvtx);
631  return 0;
632  }
633 
634  Double_t mDsPDG = TDatabasePDG::Instance()->GetParticle(431)->Mass();
635  Double_t mDsKKpi=d->InvMassDsKKpi();
636  Double_t mDspiKK=d->InvMassDspiKK();
637  if(TMath::Abs(mDsKKpi-mDsPDG)>fCutsRD[GetGlobalIndex(0,ptbin)]) okDsKKpi = 0;
638  if(TMath::Abs(mDspiKK-mDsPDG)>fCutsRD[GetGlobalIndex(0,ptbin)]) okDspiKK = 0;
639  if(!okDsKKpi && !okDspiKK){
640  CleanOwnPrimaryVtx(d,aod,origownvtx);
641  return 0;
642  }
643 
644 
645 
646  // cuts on resonant decays (via Phi or K0*)
647  if(fCutOnResonances){
648  Double_t mPhiPDG = TDatabasePDG::Instance()->GetParticle(333)->Mass();
649  Double_t mK0starPDG = TDatabasePDG::Instance()->GetParticle(313)->Mass();
650  if(okDsKKpi){
651  Double_t mass01phi=d->InvMass2Prongs(0,1,321,321);
652  Double_t mass12K0s=d->InvMass2Prongs(1,2,321,211);
653  if(TMath::Abs(mass01phi-mPhiPDG)<fCutsRD[GetGlobalIndex(12,ptbin)]) okMassPhiKKpi=1;
654  if(TMath::Abs(mass12K0s-mK0starPDG)<fCutsRD[GetGlobalIndex(13,ptbin)]) okMassK0starKKpi = 1;
655  if(!okMassPhiKKpi && !okMassK0starKKpi) okDsKKpi=0;
656  if(okMassPhiKKpi) okDsPhiKKpi=1;
657  if(okMassK0starKKpi) okDsK0starKKpi=1;
658  }
659  if(okDspiKK){
660  Double_t mass01K0s=d->InvMass2Prongs(0,1,211,321);
661  Double_t mass12phi=d->InvMass2Prongs(1,2,321,321);
662  if(TMath::Abs(mass01K0s-mK0starPDG)<fCutsRD[GetGlobalIndex(13,ptbin)]) okMassK0starpiKK = 1;
663  if(TMath::Abs(mass12phi-mPhiPDG)<fCutsRD[GetGlobalIndex(12,ptbin)]) okMassPhipiKK=1;
664  if(!okMassPhipiKK && !okMassK0starpiKK) okDspiKK=0;
665  if(okMassPhipiKK) okDsPhipiKK=1;
666  if(okMassK0starpiKK) okDsK0starpiKK=1;
667  }
668  if(!okDsKKpi && !okDspiKK){
669  CleanOwnPrimaryVtx(d,aod,origownvtx);
670  return 0;
671  }
672  }
673 
674  // Cuts on track pairs
675  for(Int_t i=0;i<3;i++){
676  if(d->GetDCA(i)>fCutsRD[GetGlobalIndex(11,ptbin)]){
677  CleanOwnPrimaryVtx(d,aod,origownvtx);
678  return 0;
679  }
680  }
681  if(d->GetDist12toPrim()<fCutsRD[GetGlobalIndex(5,ptbin)] ||
682  d->GetDist23toPrim()<fCutsRD[GetGlobalIndex(5,ptbin)]){
683  CleanOwnPrimaryVtx(d,aod,origownvtx);
684  return 0;
685  }
686 
687 
688 
689  //single track
690  if(TMath::Abs(d->Pt2Prong(1)) < fCutsRD[GetGlobalIndex(1,ptbin)]*fCutsRD[GetGlobalIndex(1,ptbin)] ||
691  TMath::Abs(d->Getd0Prong(1))<fCutsRD[GetGlobalIndex(3,ptbin)]){
692  CleanOwnPrimaryVtx(d,aod,origownvtx);
693  return 0;
694  }
695 
696  if(okDsKKpi){
697  if(TMath::Abs(d->Pt2Prong(0)) < fCutsRD[GetGlobalIndex(1,ptbin)]*fCutsRD[GetGlobalIndex(1,ptbin)] ||
698  TMath::Abs(d->Getd0Prong(0))<fCutsRD[GetGlobalIndex(3,ptbin)]) okDsKKpi=0;
699  if(TMath::Abs(d->Pt2Prong(2)) < fCutsRD[GetGlobalIndex(2,ptbin)]*fCutsRD[GetGlobalIndex(2,ptbin)] ||
700  TMath::Abs(d->Getd0Prong(2))<fCutsRD[GetGlobalIndex(4,ptbin)]) okDsKKpi=0;
701  }
702  if(okDspiKK){
703  if(TMath::Abs(d->Pt2Prong(0)) < fCutsRD[GetGlobalIndex(2,ptbin)]*fCutsRD[GetGlobalIndex(2,ptbin)] ||
704  TMath::Abs(d->Getd0Prong(0))<fCutsRD[GetGlobalIndex(4,ptbin)]) okDspiKK=0;
705  if(TMath::Abs(d->Pt2Prong(2)) < fCutsRD[GetGlobalIndex(1,ptbin)]*fCutsRD[GetGlobalIndex(1,ptbin)] ||
706  TMath::Abs(d->Getd0Prong(2))<fCutsRD[GetGlobalIndex(3,ptbin)]) okDspiKK=0;
707  }
708  if(!okDsKKpi && !okDspiKK){
709  CleanOwnPrimaryVtx(d,aod,origownvtx);
710  return 0;
711  }
712 
713  // Cuts on candidate triplet
714 
715 
716  if(d->CosPointingAngle()< fCutsRD[GetGlobalIndex(9,ptbin)]){
717  CleanOwnPrimaryVtx(d,aod,origownvtx);
718  return 0;
719  }
720 
721  if(d->Pt2Prong(0)<fCutsRD[GetGlobalIndex(8,ptbin)]*fCutsRD[GetGlobalIndex(8,ptbin)] &&
722  d->Pt2Prong(1)<fCutsRD[GetGlobalIndex(8,ptbin)]*fCutsRD[GetGlobalIndex(8,ptbin)] &&
723  d->Pt2Prong(2)<fCutsRD[GetGlobalIndex(8,ptbin)]*fCutsRD[GetGlobalIndex(8,ptbin)]) {
724  CleanOwnPrimaryVtx(d,aod,origownvtx);
725  return 0;
726  }
727 
728  if(d->DecayLength2()<fCutsRD[GetGlobalIndex(7,ptbin)]*fCutsRD[GetGlobalIndex(7,ptbin)]){
729  CleanOwnPrimaryVtx(d,aod,origownvtx);
730  return 0;
731  }
732 
733 
734  Double_t sum2=d->Getd0Prong(0)*d->Getd0Prong(0)+d->Getd0Prong(1)*d->Getd0Prong(1)+d->Getd0Prong(2)*d->Getd0Prong(2);
735  if(sum2<fCutsRD[GetGlobalIndex(10,ptbin)]){
736  CleanOwnPrimaryVtx(d,aod,origownvtx);
737  return 0;
738  }
739 
740 
741  //sec vert
742  Double_t sigmavert=d->GetSigmaVert(aod);
743  if(sigmavert>fCutsRD[GetGlobalIndex(6,ptbin)]){
744  CleanOwnPrimaryVtx(d,aod,origownvtx);
745  return 0;
746  }
747 
748  // decay length XY
749  if(d->DecayLengthXY()<fCutsRD[GetGlobalIndex(16,ptbin)]){
750  CleanOwnPrimaryVtx(d,aod,origownvtx);
751  return 0;
752  }
753 
754  //norm decay length
755  if(d->NormalizedDecayLength()<fCutsRD[GetGlobalIndex(17,ptbin)]){
756  CleanOwnPrimaryVtx(d,aod,origownvtx);
757  return 0;
758  }
759 
760  //norm decay length XY
761  if(d->NormalizedDecayLengthXY()<fCutsRD[GetGlobalIndex(18,ptbin)]){
762  CleanOwnPrimaryVtx(d,aod,origownvtx);
763  return 0;
764  }
765 
766  //cos pointing XY
767  if(d->CosPointingAngleXY()<fCutsRD[GetGlobalIndex(19,ptbin)]){
768  CleanOwnPrimaryVtx(d,aod,origownvtx);
769  return 0;
770  }
771 
772 
773  if(okDsKKpi){
774  Double_t cosPiKPhiRFKKpi=d->CosPiKPhiRFrameKKpi();
775  Double_t kincutPiKPhiKKpi=TMath::Abs(cosPiKPhiRFKKpi*cosPiKPhiRFKKpi*cosPiKPhiRFKKpi);
776  if(kincutPiKPhiKKpi<fCutsRD[GetGlobalIndex(14,ptbin)]) okDsKKpi=0;
777  }
778  if(okDspiKK){
779  Double_t cosPiKPhiRFpiKK=d->CosPiKPhiRFramepiKK();
780  Double_t kincutPiKPhipiKK=TMath::Abs(cosPiKPhiRFpiKK*cosPiKPhiRFpiKK*cosPiKPhiRFpiKK);
781  if(kincutPiKPhipiKK<fCutsRD[GetGlobalIndex(14,ptbin)]) okDspiKK=0;
782  }
783  if(!okDsKKpi && !okDspiKK){
784  CleanOwnPrimaryVtx(d,aod,origownvtx);
785  return 0;
786  }
787 
788 
789 
790  if(okDsKKpi){
791  Double_t cosPiDsLabFrameKKpi=d->CosPiDsLabFrameKKpi();
792  if(cosPiDsLabFrameKKpi>fCutsRD[GetGlobalIndex(15,ptbin)]) okDsKKpi=0;
793  }
794  if(okDspiKK){
795  Double_t cosPiDsLabFramepiKK=d->CosPiDsLabFramepiKK();
796  if(cosPiDsLabFramepiKK>fCutsRD[GetGlobalIndex(15,ptbin)]) okDspiKK=0;
797  }
798  if(!okDsKKpi && !okDspiKK){
799  CleanOwnPrimaryVtx(d,aod,origownvtx);
800  return 0;
801  }
802 
803  // unset recalculated primary vertex when not needed any more
804  CleanOwnPrimaryVtx(d,aod,origownvtx);
805 
806 
807 
808  if(!okDsKKpi){
809  okDsPhiKKpi=0;
810  okDsK0starKKpi=0;
811  }
812  if(!okDspiKK){
813  okDsPhipiKK=0;
814  okDsK0starpiKK=0;
815  }
816 
817  // PID selection
818  Int_t returnvaluePID=3;
819  if(selectionLevel==AliRDHFCuts::kAll ||
820  selectionLevel==AliRDHFCuts::kCandidate ||
821  selectionLevel==AliRDHFCuts::kPID) {
822  returnvaluePID = IsSelectedPID(d);
823  fIsSelectedPID=returnvaluePID;
824  }
825  if(returnvaluePID==0)return 0;
826 
827  Bool_t okPidDsKKpi=returnvaluePID&1;
828  Bool_t okPidDspiKK=returnvaluePID&2;
829  if(!okPidDsKKpi){
830  okDsPhiKKpi=0;
831  okDsK0starKKpi=0;
832  }
833  if(!okPidDspiKK){
834  okDsPhipiKK=0;
835  okDsK0starpiKK=0;
836  }
837 
838  if((okPidDsKKpi && okDsKKpi)||(okPidDspiKK && okDspiKK)){
839  Int_t returnvalue=0;
840  if(okDsKKpi) returnvalue+=1;
841  if(okDspiKK) returnvalue+=2;
842  if(okDsPhiKKpi) returnvalue+=4;
843  if(okDsPhipiKK) returnvalue+=8;
844  if(okDsK0starKKpi) returnvalue+=16;
845  if(okDsK0starpiKK) returnvalue+=32;
846  return returnvalue;
847  }else{
848  return 0;
849  }
850  }
851  return 15;
852 
853 }
854 
855 //--------------------------------------------------------------------------
856 
857 UInt_t AliRDHFCutsDstoKKpi::GetPIDTrackTPCTOFBitMap(AliAODTrack *track) const{
858 
859  UInt_t bitmap=0;
860 
861  Double_t sigmaTPCPionHyp=-999.;
862  Double_t sigmaTPCKaonHyp=-999.;
863  Double_t sigmaTPCProtonHyp=-999.;
864  Double_t sigmaTOFPionHyp=-999.;
865  Double_t sigmaTOFKaonHyp=-999.;
866  Double_t sigmaTOFProtonHyp=-999.;
867 
868  Int_t oksigmaTPCPionHyp=fPidHF->GetnSigmaTPC(track,2,sigmaTPCPionHyp);
869  Int_t oksigmaTPCKaonHyp=fPidHF->GetnSigmaTPC(track,3,sigmaTPCKaonHyp);
870  Int_t oksigmaTPCProtonHyp=fPidHF->GetnSigmaTPC(track,4,sigmaTPCProtonHyp);
871  Int_t oksigmaTOFPionHyp=fPidHF->GetnSigmaTOF(track,2,sigmaTOFPionHyp);
872  Int_t oksigmaTOFKaonHyp=fPidHF->GetnSigmaTOF(track,3,sigmaTOFKaonHyp);
873  Int_t oksigmaTOFProtonHyp=fPidHF->GetnSigmaTOF(track,4,sigmaTOFProtonHyp);
874 
875  sigmaTPCPionHyp=TMath::Abs(sigmaTPCPionHyp);
876  sigmaTPCKaonHyp=TMath::Abs(sigmaTPCKaonHyp);
877  sigmaTPCProtonHyp=TMath::Abs(sigmaTPCProtonHyp);
878  sigmaTOFPionHyp=TMath::Abs(sigmaTOFPionHyp);
879  sigmaTOFKaonHyp=TMath::Abs(sigmaTOFKaonHyp);
880  sigmaTOFProtonHyp=TMath::Abs(sigmaTOFProtonHyp);
881 
882  if (oksigmaTPCPionHyp && sigmaTPCPionHyp>0.){
883  if (sigmaTPCPionHyp<1.) bitmap+=1<<kTPCPionLess1;
884  else{
885  if (sigmaTPCPionHyp<2.) bitmap+=1<<kTPCPionMore1Less2;
886  else {
887  if (sigmaTPCPionHyp<3.) bitmap+=1<<kTPCPionMore2Less3;
888  else bitmap+=1<<kTPCPionMore3;
889  }
890  }
891  }
892 
893  if (oksigmaTPCKaonHyp && sigmaTPCKaonHyp>0.){
894  if (sigmaTPCKaonHyp<1.) bitmap+=1<<kTPCKaonLess1;
895  else{
896  if (sigmaTPCKaonHyp<2.) bitmap+=1<<kTPCKaonMore1Less2;
897  else {
898  if (sigmaTPCKaonHyp<3.) bitmap+=1<<kTPCKaonMore2Less3;
899  else bitmap+=1<<kTPCKaonMore3;
900  }
901  }
902  }
903 
904  if (oksigmaTPCProtonHyp && sigmaTPCProtonHyp>0.){
905  if (sigmaTPCProtonHyp<1.) bitmap+=1<<kTPCProtonLess1;
906  else{
907  if (sigmaTPCProtonHyp<2.) bitmap+=1<<kTPCProtonMore1Less2;
908  else {
909  if (sigmaTPCProtonHyp<3.) bitmap+=1<<kTPCProtonMore2Less3;
910  else bitmap+=1<<kTPCProtonMore3;
911  }
912  }
913  }
914 
915  if (oksigmaTOFPionHyp && sigmaTOFPionHyp>0.){
916  if (sigmaTOFPionHyp<1.) bitmap+=1<<kTOFPionLess1;
917  else{
918  if (sigmaTOFPionHyp<2.) bitmap+=1<<kTOFPionMore1Less2;
919  else {
920  if (sigmaTOFPionHyp<3.) bitmap+=1<<kTOFPionMore2Less3;
921  else bitmap+=1<<kTOFPionMore3;
922  }
923  }
924  }
925 
926  if (oksigmaTOFKaonHyp && sigmaTOFKaonHyp>0.){
927  if (sigmaTOFKaonHyp<1.) bitmap+=1<<kTOFKaonLess1;
928  else{
929  if (sigmaTOFKaonHyp<2.) bitmap+=1<<kTOFKaonMore1Less2;
930  else {
931  if (sigmaTOFKaonHyp<3.) bitmap+=1<<kTOFKaonMore2Less3;
932  else bitmap+=1<<kTOFKaonMore3;
933  }
934  }
935  }
936 
937  if (oksigmaTOFProtonHyp && sigmaTOFProtonHyp>0.){
938  if (sigmaTOFProtonHyp<1.) bitmap+=1<<kTOFProtonLess1;
939  else{
940  if (sigmaTOFProtonHyp<2.) bitmap+=1<<kTOFProtonMore1Less2;
941  else {
942  if (sigmaTOFProtonHyp<3.) bitmap+=1<<kTOFProtonMore2Less3;
943  else bitmap+=1<<kTOFProtonMore3;
944  }
945  }
946  }
947 
948 
949 
950  return bitmap;
951 
952 }
953 
954 
955 //---------------------------------------------------------------------------
956 
958  //
959  //STANDARD CUTS USED FOR 2010 pp analysis
960  //
961 
962  SetName("DstoKKpiCutsStandard");
963  SetTitle("Standard Cuts for D+s analysis");
964 
965  // PILE UP REJECTION
967 
968  // EVENT CUTS
969  SetMinVtxContr(1);
970 
971  AliESDtrackCuts* esdTrackCuts=new AliESDtrackCuts();
972  esdTrackCuts->SetRequireSigmaToVertex(kFALSE);
973  //default
974  esdTrackCuts->SetRequireTPCRefit(kTRUE);
975  esdTrackCuts->SetRequireITSRefit(kTRUE);
976  //esdTrackCuts->SetMinNClustersITS(4); // default is 5
977  esdTrackCuts->SetMinNClustersTPC(70);
978  esdTrackCuts->SetClusterRequirementITS(AliESDtrackCuts::kSPD,
979  AliESDtrackCuts::kAny);
980  // default is kBoth, otherwise kAny
981  esdTrackCuts->SetMinDCAToVertexXY(0.);
982  esdTrackCuts->SetPtRange(0.3,1.e10);
983 
984  AddTrackCuts(esdTrackCuts);
985  delete esdTrackCuts;
986  esdTrackCuts=NULL;
987 
988 
989  const Int_t nptbins=4;
990  Float_t ptbins[nptbins+1];
991  ptbins[0]=2.;
992  ptbins[1]=4.;
993  ptbins[2]=6.;
994  ptbins[3]=8.;
995  ptbins[4]=12.;
996 
997  const Int_t nvars=20;
998 
999  Float_t** anacutsval;
1000  anacutsval=new Float_t*[nvars];
1001 
1002  for(Int_t ic=0;ic<nvars;ic++){anacutsval[ic]=new Float_t[nptbins];}
1003  for(Int_t ipt=0;ipt<nptbins;ipt++){
1004 
1005  anacutsval[0][ipt]=0.35;
1006  anacutsval[1][ipt]=0.3;
1007  anacutsval[2][ipt]=0.3;
1008  anacutsval[3][ipt]=0.;
1009  anacutsval[4][ipt]=0.;
1010  anacutsval[5][ipt]=0.005;
1011  anacutsval[8][ipt]=0.;
1012  anacutsval[10][ipt]=0.;
1013  anacutsval[11][ipt]=1000.0;
1014  anacutsval[13][ipt]=0.1;
1015  anacutsval[16][ipt]=0.;
1016  anacutsval[17][ipt]=0.;
1017  anacutsval[18][ipt]=0.;
1018  anacutsval[19][ipt]=-1.;
1019 
1020 
1021  }
1022 
1023  //sigmavertex
1024 
1025  anacutsval[6][0]=0.020;
1026  anacutsval[6][1]=0.030;
1027  anacutsval[6][2]=0.030;
1028  anacutsval[6][3]=0.060;
1029 
1030  //Decay length
1031 
1032  anacutsval[7][0]=0.035;
1033  anacutsval[7][1]=0.035;
1034  anacutsval[7][2]=0.040;
1035  anacutsval[7][3]=0.040;
1036 
1037  //cosThetaPoint
1038 
1039  anacutsval[9][0]=0.94;
1040  anacutsval[9][1]=0.94;
1041  anacutsval[9][2]=0.94;
1042  anacutsval[9][3]=0.94;
1043 
1044  //phi DeltaMass
1045 
1046  anacutsval[12][0]=0.0080;
1047  anacutsval[12][1]=0.0050;
1048  anacutsval[12][2]=0.0045;
1049  anacutsval[12][3]=0.0090;
1050 
1051  //Kin1
1052 
1053  anacutsval[14][0]=0.10;
1054  anacutsval[14][1]=0.05;
1055  anacutsval[14][2]=0.0;
1056  anacutsval[14][3]=0.05;
1057 
1058  //Kin2
1059 
1060  anacutsval[15][0]=0.95;
1061  anacutsval[15][1]=0.95;
1062  anacutsval[15][2]=1.;
1063  anacutsval[15][3]=0.95;
1064 
1065  fPidHF->SetOldPid(kTRUE);
1066  SetUsePID(kTRUE);
1067  SetPidOption(1);
1068  SetMaxPtStrongPid(9999.);
1069  SetGlobalIndex(nvars,nptbins);
1070  SetPtBins(nptbins+1,ptbins);
1071  SetCuts(nvars,nptbins,anacutsval);
1073 
1074  PrintAll();
1075 
1076  for(Int_t iic=0;iic<nvars;iic++){delete [] anacutsval[iic];}
1077  delete [] anacutsval;
1078  anacutsval=NULL;
1079 
1080  return;
1081 }
1082 
Double_t NormalizedDecayLengthXY() const
Double_t NormalizedDecayLength() const
ClassImp(AliAnalysisTaskTriggerRates) AliAnalysisTaskTriggerRates
void SetAsym(Bool_t asym)
Definition: AliAODPidHF.h:88
AliRDHFCutsDstoKKpi(const char *name="CutsDstoKKpi")
Bool_t IsSignalMC(AliAODRecoDecay *d, AliAODEvent *aod, Int_t pdg) const
Double_t GetPCompatTOF() const
Definition: AliAODPidHF.h:154
Int_t GetnSigmaTOF(AliAODTrack *track, Int_t species, Double_t &sigma) const
void SetTRD(Bool_t trd)
Definition: AliAODPidHF.h:97
void SetPidOption(Int_t opt)
Bool_t fRemoveDaughtersFromPrimary
Definition: AliRDHFCuts.h:393
Int_t GetnSigmaTPC(AliAODTrack *track, Int_t species, Double_t &sigma) const
virtual void GetCutVarsForOpt(AliAODRecoDecayHF *d, Float_t *vars, Int_t nvars, Int_t *pdgdaughters)
Double_t CosPiDsLabFrameKKpi() const
virtual Int_t IsSelectedPIDBayes(AliAODRecoDecayHF *rd)
Double_t fWeightKKpi
Threshold for Bayesian PID probability.
void SetPCompatTOF(Double_t pTOF)
Definition: AliAODPidHF.h:106
void SetNVars(Int_t nVars)
Definition: AliRDHFCuts.h:361
Double_t CosPointingAngleXY() const
Double_t fMaxRapidityCand
minimum pt of the candidate
Definition: AliRDHFCuts.h:411
Float_t fMaxPtStrongPid
pid option
void SetGlobalIndex()
Definition: AliRDHFCuts.h:196
AliRDHFCuts & operator=(const AliRDHFCuts &source)
virtual Bool_t IsInFiducialAcceptance(Double_t pt, Double_t y) const
virtual Int_t IsSelectedPID(AliAODRecoDecayHF *rd)
Bool_t fUsePID
Definition: AliRDHFCuts.h:388
Double_t GetPtThresholdTPC()
Definition: AliAODPidHF.h:158
UInt_t GetPIDTrackTPCTOFBitMap(AliAODTrack *track) const
void SetTOF(Bool_t tof)
Definition: AliAODPidHF.h:95
Int_t fPidOption
switch for the cuts on phi and K0* inv. mass
Bool_t HasBadDaughters() const
void SetMinVtxContr(Int_t contr=1)
Definition: AliRDHFCuts.h:58
Bool_t fUseTrackSelectionWithFilterBits
flag to reject kink daughters
Definition: AliRDHFCuts.h:421
void SetCuts(Int_t nVars, Int_t nPtBins, Float_t **cutsRD)
Int_t fnVarsForOpt
Definition: AliRDHFCuts.h:383
AliPIDCombined * GetPidCombined() const
Definition: AliAODPidHF.h:161
void SetMaxPtStrongPid(Float_t spid)
const Double_t ptmax
void SetPtThresholdTPC(Double_t ptThresholdTPC)
Definition: AliAODPidHF.h:109
Double_t fMaxPtCand
minimum pt of the candidate
Definition: AliRDHFCuts.h:410
Double_t CosPiKPhiRFrameKKpi() const
AliAODVertex * GetOwnPrimaryVtx() const
Bool_t fKeepSignalMC
max rapidity of candidate (if !=-999 overrides IsInFiducialAcceptance)
Definition: AliRDHFCuts.h:412
virtual Int_t IsSelected(TObject *obj, Int_t selectionLevel)
Double_t GetSigmaVert(const AliAODEvent *aod=0x0)
Bool_t AreDaughtersSelected(AliAODRecoDecayHF *rd) const
virtual void SetStandardCutsPP2010()
AliRDHFCutsDstoKKpi & operator=(const AliRDHFCutsDstoKKpi &source)
Int_t fIsSelectedPID
outcome of cuts selection
Definition: AliRDHFCuts.h:408
Double_t nsigma
Int_t MakeRawPid(AliAODTrack *track, Int_t specie)
AliPIDResponse * GetPidResponse() const
Definition: AliAODPidHF.h:160
void SetSigma(Double_t *sigma)
Definition: AliAODPidHF.h:39
Float_t * fCutsRD
fnVars*fnPtBins
Definition: AliRDHFCuts.h:386
Double_t DecayLength2() const
kinematics & topology
Float_t fMaxPStrongPidK
Maximum pt of candidate to apply strong Pid p dependent.
Double_t CosPiDsLabFramepiKK() const
void SetVarsForOpt(Int_t nVars, Bool_t *forOpt)
Double_t DecayLengthXY() const
void SetVarNames(Int_t nVars, TString *varNames, Bool_t *isUpperCut)
Bool_t * fVarsForOpt
number of cut vars to be optimized for candidates
Definition: AliRDHFCuts.h:384
Double_t fWeightpiKK
weight for KKpi for kBayesianWeights
Double_t fDistToMaxProb
Maximum P of track to apply strong Pid on pi.
Double_t fBayesThreshold
Difference between max probability.
void SetUsePID(Bool_t flag=kTRUE)
Definition: AliRDHFCuts.h:204
virtual void PrintAll() const
void CleanOwnPrimaryVtx(AliAODRecoDecayHF *d, AliAODEvent *aod, AliAODVertex *origownvtx) const
void SetRemoveDaughtersFromPrim(Bool_t removeDaughtersPrim)
Definition: AliRDHFCuts.h:214
Float_t fMaxPStrongPidpi
Maximum P of track to apply strong Pid on K.
void SetOldPid(Bool_t oldPid)
Definition: AliAODPidHF.h:108
void SetPtBins(Int_t nPtBinLimits, Float_t *ptBinLimits)
void SetITS(Bool_t its)
Definition: AliAODPidHF.h:96
void SetMatch(Int_t match)
Definition: AliAODPidHF.h:98
void AddTrackCuts(const AliESDtrackCuts *cuts)
Definition: AliRDHFCuts.h:202
void SetPLimit(Double_t *plim, Int_t npLim)
void SetTPC(Bool_t tpc)
Definition: AliAODPidHF.h:94
Double_t CosPointingAngle() const
void SetCompat(Bool_t comp)
Definition: AliAODPidHF.h:100
AliAODPidHF * fPidHF
enable AOD049 centrality cleanup
Definition: AliRDHFCuts.h:390
Bool_t RecalcOwnPrimaryVtx(AliAODRecoDecayHF *d, AliAODEvent *aod) const
Int_t PtBin(Double_t pt) const
void SetOptPileup(Int_t opt=0)
Definition: AliRDHFCuts.h:218
Int_t GetGlobalIndex(Int_t iVar, Int_t iPtBin) const
Double_t DecayLength() const
Double_t CosPiKPhiRFramepiKK() const
Int_t nptbins
Double_t fMinPtCand
outcome of PID selection
Definition: AliRDHFCuts.h:409