AliPhysics  1811c8f (1811c8f)
AliRDHFCutsLctopK0sfromAODtracks.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 Lc->p+K0s
21 //
22 // Modified by Y.S Watanabe - wyosuke@cns.s.u-tokyo.ac.jp
23 //
25 
26 #include <Riostream.h>
27 
28 #include <TDatabasePDG.h>
29 #include <TMath.h>
30 #include <TLorentzVector.h>
31 #include <TVector3.h>
32 
33 #include "AliAnalysisManager.h"
34 #include "AliInputEventHandler.h"
35 #include "AliPIDResponse.h"
37 #include "AliAODRecoCascadeHF.h"
38 #include "AliAODTrack.h"
39 #include "AliESDtrack.h"
40 #include "AliESDVertex.h"
41 #include "AliAODVertex.h"
42 #include "AliAODv0.h"
43 #include "AliAODcascade.h"
44 #include "AliESDv0.h"
45 
46 using std::cout;
47 using std::endl;
48 
52 
53 
54 //--------------------------------------------------------------------------
56 AliRDHFCuts(name),
57  fPIDStrategy(kNSigmaCuts),
58  fCombinedPIDThreshold(0.),
59  fUseOnTheFlyV0(kFALSE),
60  fBzkG(0),
61  fProdTrackTPCNclsPIDMin(0),
62  fProdTrackTPCNclsRatioMin(0.0),
63  fProdUseAODFilterBit(kTRUE),
64  fProdAODFilterBit(4),
65  fProdRejectTrackWithShared(kFALSE),
66  fProdV0MassTolK0s(0.01),
67  fProdV0MassRejLambda(0.00),
68  fProdV0MassRejPhoton(0.00),
69  fProdV0PtMin(0.5),
70  fProdV0CosPointingAngleToPrimVtxMin(0.99),
71  fProdV0DcaDaughtersMax(1.5),
72  fProdV0DaughterEtaRange(0.8),
73  fProdV0DaughterPtMin(0.0),
74  fProdV0DaughterTPCClusterMin(70),
75  fProdV0EtaMin(-9999.),
76  fProdV0EtaMax(9999.),
77  fProdV0RapMin(-9999.),
78  fProdV0RapMax(9999.),
79  fProdRoughMassTol(0.25),
80  fProdRoughPtMin(0.0),
81  fNWeightingProtonBinLimits(0),
82  fWeightingProtonBins(0),
83  fNWeightingK0sBinLimits(0),
84  fWeightingK0sBins(0),
85  fNWeightingBins(0),
86  fWeight_p0(0),
87  fWeight_p1(0),
88  fWeight_p2(0),
89  fWeight_p3(0),
90  fTagV0MassTol(0)
91 {
92  //
93  // Default Constructor
94  //
95  for(Int_t i=0;i<3;i++){
96  fPrimVert[i] = 0.;
97  }
98 
99  const Int_t nvars=9;
100  SetNVars(nvars);
101  TString varNames[nvars]={"Lc inv. mass [GeV/c2]", // 0
102  "Opening angle [rad]",//1
103  "n#sigma_{TPC} max",//2
104  "n#sigma_{TOF} min",//3
105  "Decay Length min [cm]",//4
106  "cos #theta min",//5
107  "cos #theta max",//6
108  "Proton d0 max",//7
109  "V0 d0 max"//8
110  };
111 
112  Bool_t isUpperCut[nvars]={kTRUE, // 0
113  kFALSE, //1: opening angle
114  kTRUE, //2: nsigma_tpc max
115  kFALSE, //3: nsigma tof min
116  kFALSE, //4: decay length min
117  kFALSE, //5: cos the min
118  kTRUE, //6: cos the max
119  kTRUE, //7:
120  kTRUE //8:
121  };
122  SetVarNames(nvars,varNames,isUpperCut);
123  Bool_t forOpt[nvars]={kFALSE, // 0
124  kFALSE, //1
125  kTRUE, //2
126  kTRUE, //3
127  kTRUE, //4
128  kTRUE, //5
129  kTRUE, //6
130  kTRUE, //7
131  kTRUE //8
132  };
133  SetVarsForOpt(nvars,forOpt);
134 
135  Float_t limits[2]={0,999999999.};
136  SetPtBins(2,limits);
137 }
138 //--------------------------------------------------------------------------
140  AliRDHFCuts(source),
141  fPIDStrategy(source.fPIDStrategy),
144  fBzkG(source.fBzkG),
153  fProdV0PtMin(source.fProdV0PtMin),
166  fWeightingProtonBins(NULL),
168  fWeightingK0sBins(NULL),
170  fWeight_p0(NULL),
171  fWeight_p1(NULL),
172  fWeight_p2(NULL),
173  fWeight_p3(NULL),
175 {
176  //
177  // Copy constructor
178  //
179  for(Int_t i=0;i<3;i++){
180  fPrimVert[i] = source.fPrimVert[i];
181  }
188  for(Int_t i=0;i<fNWeightingProtonBinLimits;i++){
190  }
191  for(Int_t i=0;i<fNWeightingK0sBinLimits;i++){
192  fWeightingK0sBins[i] = source.fWeightingK0sBins[i];
193  }
194  for(Int_t i=0;i<fNWeightingBins;i++){
195  fWeight_p0[i] = source.fWeight_p0[i];
196  fWeight_p1[i] = source.fWeight_p1[i];
197  fWeight_p2[i] = source.fWeight_p2[i];
198  fWeight_p3[i] = source.fWeight_p3[i];
199  }
200 }
201 //--------------------------------------------------------------------------
203 {
204  //
205  // assignment operator
206  //
207 
208  if (this != &source) {
209  AliRDHFCuts::operator=(source);
210  }
211 
212  fPIDStrategy = source.fPIDStrategy;
215  fBzkG = source.fBzkG;
224  fProdV0PtMin = source.fProdV0PtMin;
230  fProdV0EtaMin = source.fProdV0EtaMin;
231  fProdV0EtaMax = source.fProdV0EtaMax;
232  fProdV0RapMin = source.fProdV0RapMin;
233  fProdV0RapMax = source.fProdV0RapMax;
239  fTagV0MassTol = source.fTagV0MassTol;
240 
241  for(Int_t i=0;i<3;i++){
242  fPrimVert[i] = source.fPrimVert[i];
243  }
244 
251  for(Int_t i=0;i<fNWeightingProtonBinLimits;i++){
253  }
254  for(Int_t i=0;i<fNWeightingK0sBinLimits;i++){
255  fWeightingK0sBins[i] = source.fWeightingK0sBins[i];
256  }
257  for(Int_t i=0;i<fNWeightingBins;i++){
258  fWeight_p0[i] = source.fWeight_p0[i];
259  fWeight_p1[i] = source.fWeight_p1[i];
260  fWeight_p2[i] = source.fWeight_p2[i];
261  fWeight_p3[i] = source.fWeight_p3[i];
262  }
263 
264 
265  return *this;
266 }
267 
268 //---------------------------------------------------------------------------
270  //
271  // Default Destructor
272  //
273 
274  delete [] fWeightingProtonBins;
275  delete [] fWeightingK0sBins;
276  delete [] fWeight_p0;
277  delete [] fWeight_p1;
278  delete [] fWeight_p2;
279  delete [] fWeight_p3;
280 
281 }
282 
283 //---------------------------------------------------------------------------
285  //
286  // Fills in vars the values of the variables
287  //
288 
289  if (pdgdaughters[0]==-9999) return; // dummy
290 
292  if(!dd){
293  AliError("No AliAODRecoCascadeHF object found\n");
294  return;
295  }
296 
297  if (nvars!=fnVarsForOpt) {
298  AliError("Cut object seems to have the wrong number of variables\n");
299  return;
300  }
301 
302  //Double_t ptD=d->Pt();
303  //Int_t ptbin=PtBin(ptD);
304  Int_t iter=-1;
305 
306  if(fVarsForOpt[0]){
307  iter++;
308  Double_t mlcPDG = TDatabasePDG::Instance()->GetParticle(4122)->Mass();
309  vars[iter]= TMath::Abs(dd->InvMassLctoK0sP()-mlcPDG) ;
310  }
311  if(fVarsForOpt[1]){
312  iter++;
313  vars[iter]= dd->Pt();
314  }
315 
316  return;
317 }
318 
319 //---------------------------------------------------------------------------
321  //
322  // Apply selection
323  //
324 
325  if (!fCutsRD) {
326  AliFatal("Cut matrix not inizialized. Exit...");
327  return 0;
328  }
329 
331  if(!d){
332  AliDebug(2,"AliAODRecoCascadeHF null");
333  return 0;
334  }
335 
336  Double_t ptD=d->Pt();
337  if(ptD<fMinPtCand) return 0;
338  if(ptD>fMaxPtCand) return 0;
339 
340  Double_t pt=d->Pt();
341  Int_t ptbin=PtBin(pt);
342  if (ptbin==-1) {
343  return 0;
344  }
345 
346  if (selectionLevel==AliRDHFCuts::kAll ||
347  selectionLevel==AliRDHFCuts::kTracks) {
348  //Performed in production stage
349  }
350 
351  Int_t returnvalueCuts=1;
352  // selection on candidate
353  if (selectionLevel==AliRDHFCuts::kAll ||
354  selectionLevel==AliRDHFCuts::kCandidate) {
355 
356  Bool_t okcand=kTRUE;
357 
358  Double_t mlcPDG = TDatabasePDG::Instance()->GetParticle(4122)->Mass();
359  Double_t mprPDG = TDatabasePDG::Instance()->GetParticle(2212)->Mass();
360  Double_t mk0PDG = TDatabasePDG::Instance()->GetParticle(310)->Mass();
361  Double_t v0px = d->PxProng(1);
362  Double_t v0py = d->PyProng(1);
363  Double_t v0pz = d->PzProng(1);
364  Double_t epx = d->PxProng(0);
365  Double_t epy = d->PyProng(0);
366  Double_t epz = d->PzProng(0);
367  Double_t cosoa = (v0px*epx+v0py*epy+v0pz*epz)/sqrt(v0px*v0px+v0py*v0py+v0pz*v0pz)/sqrt(epx*epx+epy*epy+epz*epz);
368 
369  TLorentzVector vpr, vk0s,vlc;
370  vpr.SetXYZM(epx,epy,epz,mprPDG);
371  vk0s.SetXYZM(v0px,v0py,v0pz,mk0PDG);
372  vlc = vpr + vk0s;
373  TVector3 vboost = vlc.BoostVector();
374  vpr.Boost(-vboost);
375  Double_t bachcosthe = cos(vpr.Angle(vlc.Vect()));
376 
377  if(TMath::Abs(d->InvMassLctoK0sP()-mlcPDG) > fCutsRD[GetGlobalIndex(0,ptbin)])
378  {
379  okcand = kFALSE;
380  }
381  if(cosoa < fCutsRD[GetGlobalIndex(1,ptbin)])
382  {
383  okcand = kFALSE;
384  }
386  {
387  okcand = kFALSE;
388  }
389  if(bachcosthe < fCutsRD[GetGlobalIndex(5,ptbin)])
390  {
391  okcand = kFALSE;
392  }
393  if(bachcosthe > fCutsRD[GetGlobalIndex(6,ptbin)])
394  {
395  okcand = kFALSE;
396  }
397  if(fabs(d->Getd0Prong(0)) > fCutsRD[GetGlobalIndex(7,ptbin)])
398  {
399  okcand = kFALSE;
400  }
401  if(fabs(d->Getd0Prong(1)) > fCutsRD[GetGlobalIndex(8,ptbin)])
402  {
403  okcand = kFALSE;
404  }
405 
406  if(!okcand) return 0;
407  returnvalueCuts = 1;
408  }
409 
410  Int_t returnvaluePID=1;
411  if(selectionLevel==AliRDHFCuts::kAll ||
412  selectionLevel==AliRDHFCuts::kCandidate||
413  selectionLevel==AliRDHFCuts::kPID) {
414 
415  AliAODTrack *part = (AliAODTrack*)d->GetSecondaryVtx()->GetDaughter(0);
416 
417  Double_t nSigmaTPCpr = fPidHF->GetPidResponse()->NumberOfSigmasTPC(part,AliPID::kProton);
418  if(nSigmaTPCpr>fCutsRD[GetGlobalIndex(2,ptbin)]){
419  returnvaluePID = -1;
420  }
421 
422  Double_t nSigmaTOFpr = fPidHF->GetPidResponse()->NumberOfSigmasTOF(part,AliPID::kProton);
423  if(nSigmaTOFpr<fCutsRD[GetGlobalIndex(3,ptbin)]){
424  returnvaluePID = -1;
425  }
426 
427  }
428 
429  Int_t returnvalue = 0;
430  if(returnvalueCuts==1 && returnvaluePID==1) returnvalue=1;
431 
432  return returnvalue;
433 }
434 
435 //---------------------------------------------------------------------------
436 Int_t AliRDHFCutsLctopK0sfromAODtracks::IsSelected(TLorentzVector* vtrk, TLorentzVector *vv0, Double_t *cutvars, Int_t selectionLevel) {
437  //
438  // Apply selection on mixed event tracks
439  //
440 
441  if (!fCutsRD) {
442  AliFatal("Cut matrix not inizialized. Exit...");
443  return 0;
444  }
445 
446  Double_t ptD=cutvars[1];
447  if(ptD<fMinPtCand) return 0;
448  if(ptD>fMaxPtCand) return 0;
449 
450  Double_t pt=cutvars[1];
451  Int_t ptbin=PtBin(pt);
452  if (ptbin==-1) {
453  return 0;
454  }
455 
456  if (selectionLevel==AliRDHFCuts::kAll ||
457  selectionLevel==AliRDHFCuts::kTracks) {
458  //Performed in production stage
459  }
460 
461  Int_t returnvalueCuts=1;
462  // selection on candidate
463  if (selectionLevel==AliRDHFCuts::kAll ||
464  selectionLevel==AliRDHFCuts::kCandidate) {
465 
466  Bool_t okcand=kTRUE;
467 
468  Double_t mlcPDG = TDatabasePDG::Instance()->GetParticle(4122)->Mass();
469  Double_t mprPDG = TDatabasePDG::Instance()->GetParticle(2212)->Mass();
470  Double_t mk0PDG = TDatabasePDG::Instance()->GetParticle(310)->Mass();
471  Double_t v0px = vv0->Px();
472  Double_t v0py = vv0->Py();
473  Double_t v0pz = vv0->Pz();
474  Double_t epx = vtrk->Px();
475  Double_t epy = vtrk->Py();
476  Double_t epz = vtrk->Pz();
477  Double_t cosoa = (v0px*epx+v0py*epy+v0pz*epz)/sqrt(v0px*v0px+v0py*v0py+v0pz*v0pz)/sqrt(epx*epx+epy*epy+epz*epz);
478 
479  TLorentzVector vpr, vk0s,vlc;
480  vpr.SetXYZM(epx,epy,epz,mprPDG);
481  vk0s.SetXYZM(v0px,v0py,v0pz,mk0PDG);
482  vlc = vpr + vk0s;
483  TVector3 vboost = vlc.BoostVector();
484  vpr.Boost(-vboost);
485  Double_t bachcosthe = cos(vpr.Angle(vlc.Vect()));
486 
487  if(TMath::Abs(cutvars[0]-mlcPDG) > fCutsRD[GetGlobalIndex(0,ptbin)])
488  {
489  okcand = kFALSE;
490  }
491  if(cosoa < fCutsRD[GetGlobalIndex(1,ptbin)])
492  {
493  okcand = kFALSE;
494  }
495  if(cutvars[4] < fCutsRD[GetGlobalIndex(4,ptbin)])
496  {
497  okcand = kFALSE;
498  }
499  if(bachcosthe < fCutsRD[GetGlobalIndex(5,ptbin)])
500  {
501  okcand = kFALSE;
502  }
503  if(bachcosthe > fCutsRD[GetGlobalIndex(6,ptbin)])
504  {
505  okcand = kFALSE;
506  }
507  if(cutvars[5] > fCutsRD[GetGlobalIndex(7,ptbin)])
508  {
509  okcand = kFALSE;
510  }
511  if(cutvars[6] > fCutsRD[GetGlobalIndex(8,ptbin)])
512  {
513  okcand = kFALSE;
514  }
515 
516  if(!okcand) return 0;
517  returnvalueCuts = 1;
518  }
519 
520  Int_t returnvaluePID=1;
521  if(selectionLevel==AliRDHFCuts::kAll ||
522  selectionLevel==AliRDHFCuts::kCandidate||
523  selectionLevel==AliRDHFCuts::kPID) {
524 
525  Double_t nSigmaTPCpr = cutvars[2];
526  if(fabs(nSigmaTPCpr)>fCutsRD[GetGlobalIndex(2,ptbin)]){
527  returnvaluePID = -1;
528  }
529 
530  Double_t nSigmaTOFpr = cutvars[3];
531  if(fabs(nSigmaTOFpr)<fCutsRD[GetGlobalIndex(3,ptbin)]){
532  returnvaluePID = -1;
533  }
534 
535  }
536 
537  Int_t returnvalue = 0;
538  if(returnvalueCuts==1 && returnvaluePID==1) returnvalue=1;
539 
540  return returnvalue;
541 }
542 
543 //---------------------------------------------------------------------------
545 {
546  //
547  // IsSelectedPID ( not used)
548  //
549 
550  if(!fUsePID || !obj) return 1;
551 
553  AliAODTrack *part = dd->GetBachelor();
554 
555  Int_t returnvalue=1;
556 
557  if(fPidHF->GetPidResponse()==0x0){
558  AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager();
559  AliInputEventHandler *inputHandler=(AliInputEventHandler*)mgr->GetInputEventHandler();
560  AliPIDResponse *pidResp=inputHandler->GetPIDResponse();
561  fPidHF->SetPidResponse(pidResp);
562  }
563 
564  Int_t isProton=fPidHF->MakeRawPid(part,4);
565  if(isProton<1) returnvalue = 0;
566 
567  return returnvalue;
568 }
569 
570 //---------------------------------------------------------------------------
572 {
573  //
574  // IsSelectedProtonID
575  //
576 
577  if(fPidHF->GetPidResponse()==0x0){
578  AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager();
579  AliInputEventHandler *inputHandler=(AliInputEventHandler*)mgr->GetInputEventHandler();
580  AliPIDResponse *pidResp=inputHandler->GetPIDResponse();
581  fPidHF->SetPidResponse(pidResp);
582  }
583 
584  //Int_t isProton=fPidHF->MakeRawPid(part,4);
585  //if(isProton<1) return kFALSE;
586  Double_t nsigmatpc_proton = fPidHF->GetSigma(0);
587  Double_t nsigmatof_proton = fPidHF->GetSigma(3);
588  Double_t nSigmaTPCpr = fPidHF->GetPidResponse()->NumberOfSigmasTPC(part,AliPID::kProton);
589  Double_t nSigmaTOFpr = fPidHF->GetPidResponse()->NumberOfSigmasTOF(part,AliPID::kProton);
590 
591  if(fabs(nSigmaTPCpr)<nsigmatpc_proton && fabs(nSigmaTOFpr)<nsigmatof_proton){
592  return kTRUE;
593  }
594 
595  return kFALSE;
596 }
597 //---------------------------------------------------------------------------
599 {
600  //
601  // IsSelectedKaonID
602  //
603 
604  if(fPidHF->GetPidResponse()==0x0){
605  AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager();
606  AliInputEventHandler *inputHandler=(AliInputEventHandler*)mgr->GetInputEventHandler();
607  AliPIDResponse *pidResp=inputHandler->GetPIDResponse();
608  fPidHF->SetPidResponse(pidResp);
609  }
610 
611  //Int_t isKaon=fPidHF->MakeRawPid(part,3);
612  //if(isKaon<1) return kFALSE;
613  Double_t nsigmatpc_kaon = fPidHF->GetSigma(0);
614  Double_t nsigmatof_kaon = fPidHF->GetSigma(3);
615  Double_t nSigmaTPCka = fPidHF->GetPidResponse()->NumberOfSigmasTPC(part,AliPID::kKaon);
616  Double_t nSigmaTOFka = fPidHF->GetPidResponse()->NumberOfSigmasTOF(part,AliPID::kKaon);
617 
618  if(fabs(nSigmaTPCka)<nsigmatpc_kaon && fabs(nSigmaTOFka)<nsigmatof_kaon){
619  return kTRUE;
620  }
621 
622  return kFALSE;
623 }
624 
625 //---------------------------------------------------------------------------
627  //
628  // IsSelectedCombinedPID
629  //
630 
631  if(!fUsePID || !obj) {return 1;}
632 
634  AliAODTrack *part = dd->GetBachelor();
635  if(!part) return 0;
636 
637  Int_t returnvalue=1;
638  Double_t probProton = GetProtonProbabilityTPCTOF(part);
639  if(probProton<fCombinedPIDThreshold) returnvalue = 0;
640 
641  return returnvalue;
642 }
643 
644 //________________________________________________________________________
646 {
647  //
648  // Get Proton probability
649  //
650  if(!fPidHF->GetUseCombined()) return -9999.;
651  fPidHF->GetPidCombined()->SetDetectorMask(AliPIDResponse::kDetTPC+AliPIDResponse::kDetTOF);
652  Double_t prob1[AliPID::kSPECIES];
653  UInt_t detUsed1 = fPidHF->GetPidCombined()->ComputeProbabilities(trk, fPidHF->GetPidResponse(), prob1);
654  if (detUsed1 != (UInt_t)fPidHF->GetPidCombined()->GetDetectorMask() )
655  {
656  fPidHF->GetPidCombined()->SetDetectorMask(AliPIDResponse::kDetTPC);
657  detUsed1 = fPidHF->GetPidCombined()->ComputeProbabilities(trk, fPidHF->GetPidResponse(), prob1);
658  }
659  return prob1[AliPID::kProton];
660 }
661 
662 //________________________________________________________________________
663 Bool_t AliRDHFCutsLctopK0sfromAODtracks::SingleTrkCuts(AliAODTrack *trk, AliAODTrack *trkpid, AliAODVertex *primVert)
664 {
665  //
666  // Single Track Cut to be applied before object creation
667  //
668 
669  //if(trk->GetStatus()&AliESDtrack::kITSpureSA) return kFALSE;
670  //if(!(trk->GetStatus()&AliESDtrack::kITSin)) return kFALSE;
671  //if(fProdUseAODFilterBit && !trk->TestFilterMask(BIT(4))) return kFALSE;
672  if(fTrackCuts){
673  if(fProdAODFilterBit==7){
675  fTrackCuts->GetPtRange(ptmin,ptmax);
676  fTrackCuts->GetEtaRange(etamin,etamax);
677  if(trk->Pt()<ptmin || trk->Pt()>ptmax) return kFALSE;
678  if(trk->Eta()<etamin || trk->Eta()>etamax) return kFALSE;
679  }else{
680  Double_t pos[3]; primVert->GetXYZ(pos);
681  Double_t cov[6]; primVert->GetCovarianceMatrix(cov);
682  const AliESDVertex vESD(pos,cov,100.,100);
683  if(!IsDaughterSelected(trk,&vESD,fTrackCuts)) return kFALSE;
684  }
685  }
686 
687  if(trkpid->GetTPCsignalN()<fProdTrackTPCNclsPIDMin) return kFALSE;
688  if(trk->GetTPCNclsF()>0){
689  Float_t tpcratio = (Float_t)trk->GetTPCncls()/(Float_t)trk->GetTPCNclsF();
690  if(tpcratio<fProdTrackTPCNclsRatioMin) return kFALSE;
691  }
692 
693  if(fUsePID)
694  {
695  if(fPidHF->GetPidResponse()==0x0){
696  AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager();
697  AliInputEventHandler *inputHandler=(AliInputEventHandler*)mgr->GetInputEventHandler();
698  AliPIDResponse *pidResp=inputHandler->GetPIDResponse();
699  fPidHF->SetPidResponse(pidResp);
700  }
701 
702  switch(fPIDStrategy){
703  case kNSigmaCuts:
704  return IsSelectedProtonID(trkpid);
705  break;
706  }
707  }
708 
710  const TBits sharedMap = trk->GetTPCSharedMap();
711  if((sharedMap.CountBits()) >= 1){
712  return kFALSE;
713  }
714  }
715 
716  return kTRUE;
717 }
718 //________________________________________________________________________
719 Bool_t AliRDHFCutsLctopK0sfromAODtracks::SingleKaonCuts(AliAODTrack *trk, AliAODVertex *primVert)
720 {
721  //
722  // Single Track Cut to be applied before object creation
723  //
724 
725  if(trk->GetStatus()&AliESDtrack::kITSpureSA) return kFALSE;
726  if(!(trk->GetStatus()&AliESDtrack::kITSin)) return kFALSE;
727  if(fProdUseAODFilterBit && !trk->TestFilterMask(BIT(4))) return kFALSE;
728  Double_t pos[3]; primVert->GetXYZ(pos);
729  Double_t cov[6]; primVert->GetCovarianceMatrix(cov);
730  const AliESDVertex vESD(pos,cov,100.,100);
731  if(fTrackCuts&&!IsDaughterSelected(trk,&vESD,fTrackCuts)) return kFALSE;
732 
733  if(trk->GetTPCsignalN()<fProdTrackTPCNclsPIDMin) return kFALSE;
734  if(trk->GetTPCNclsF()>0){
735  Float_t tpcratio = (Float_t)trk->GetTPCncls()/(Float_t)trk->GetTPCNclsF();
736  if(tpcratio<fProdTrackTPCNclsRatioMin) return kFALSE;
737  }
738 
739  if(fUsePID)
740  {
741  if(fPidHF->GetPidResponse()==0x0){
742  AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager();
743  AliInputEventHandler *inputHandler=(AliInputEventHandler*)mgr->GetInputEventHandler();
744  AliPIDResponse *pidResp=inputHandler->GetPIDResponse();
745  fPidHF->SetPidResponse(pidResp);
746  }
747 
748  switch(fPIDStrategy){
749  case kNSigmaCuts:
750  return IsSelectedKaonID(trk);
751  break;
752  }
753  }
754 
755  return kTRUE;
756 }
757 //________________________________________________________________________
759 {
761  if(!lcobj){
762  AliError("No AliAODRecoCascadeHF object found\n");
763  return -9999.;
764  }
765  Double_t dvertx = lcobj->GetSecondaryVtx()->GetX()-lcobj->GetOwnPrimaryVtx()->GetX();
766  Double_t dverty = lcobj->GetSecondaryVtx()->GetY()-lcobj->GetOwnPrimaryVtx()->GetY();
767  Double_t px = lcobj->Px();
768  Double_t py = lcobj->Py();
769  Double_t inner = px*dvertx + py*dverty;
770  if(inner<0.) return -1.;
771  return 1.;
772 }
773 //________________________________________________________________________
774 Bool_t AliRDHFCutsLctopK0sfromAODtracks::SingleV0Cuts(AliAODv0 *v0, AliAODVertex *primVert)
775 {
776  //
777  // Single V0 Cut to be applied before object creation
778  //
779 
780  Bool_t onFlyV0 = v0->GetOnFlyStatus(); // on-the-flight V0s
781  if ( onFlyV0 && !fUseOnTheFlyV0 ) return kFALSE;
782 
783  AliAODTrack *cptrack = (AliAODTrack*)(v0->GetDaughter(0));
784  AliAODTrack *cntrack = (AliAODTrack*)(v0->GetDaughter(1));
785  if(!cptrack || !cntrack) return kFALSE;
786  if ( cptrack->Charge() == cntrack->Charge() ) return kFALSE;
787  if(!(cptrack->GetStatus() & AliESDtrack::kTPCrefit) ||
788  !(cntrack->GetStatus() & AliESDtrack::kTPCrefit)) return kFALSE;
789  AliAODVertex *maybeKinkPos = (AliAODVertex*)cptrack->GetProdVertex();
790  AliAODVertex *maybeKinkNeg = (AliAODVertex*)cntrack->GetProdVertex();
791  if (maybeKinkPos->GetType()==AliAODVertex::kKink || maybeKinkNeg->GetType()==AliAODVertex::kKink)
792  return kFALSE;
793 
794  if ( ( ( cptrack->GetTPCClusterInfo(2,1) ) < (Float_t)fProdV0DaughterTPCClusterMin ) ||
795  ( ( cntrack->GetTPCClusterInfo(2,1) ) < (Float_t)fProdV0DaughterTPCClusterMin) ) return kFALSE;
796 
797  Double_t massK0S = v0->MassK0Short();
798  Double_t mk0sPDG = TDatabasePDG::Instance()->GetParticle(310)->Mass();
799  if(fabs(massK0S-mk0sPDG)>fProdV0MassTolK0s) return kFALSE;
800 
801  Double_t massLambda = v0->MassLambda();
802  Double_t massAntiLambda = v0->MassAntiLambda();
803  Double_t mlamPDG = TDatabasePDG::Instance()->GetParticle(3122)->Mass();
804  if((fabs(massAntiLambda-mlamPDG)<fProdV0MassRejLambda) || (fabs(massLambda-mlamPDG)<fProdV0MassRejLambda)) return kFALSE;
805 
806  Double_t pxe1 = v0->MomPosX();
807  Double_t pye1 = v0->MomPosY();
808  Double_t pze1 = v0->MomPosZ();
809  Double_t Ee1 = sqrt(pxe1*pxe1+pye1*pye1+pze1*pze1+0.000511*0.000511);
810  Double_t pxe2 = v0->MomNegX();
811  Double_t pye2 = v0->MomNegY();
812  Double_t pze2 = v0->MomNegZ();
813  Double_t Ee2 = sqrt(pxe2*pxe2+pye2*pye2+pze2*pze2+0.000511*0.000511);
814  Double_t mphoton = sqrt(pow(Ee1+Ee2,2)-pow(pxe1+pxe2,2)-pow(pye1+pye2,2)-pow(pze1+pze2,2));
815  if(mphoton<fProdV0MassRejPhoton) return kFALSE;
816 
817 
818  if(TMath::Abs(v0->DcaV0Daughters())>fProdV0DcaDaughtersMax) return kFALSE;
819  Double_t posVtx[3] = {0.,0.,0.};
820  primVert->GetXYZ(posVtx);
821  Double_t cospav0 = v0->CosPointingAngle(posVtx);
822  if(cospav0<fProdV0CosPointingAngleToPrimVtxMin) return kFALSE;
823  if(v0->Pt()<fProdV0PtMin) return kFALSE;
824  if(fabs(cptrack->Eta())>fProdV0DaughterEtaRange) return kFALSE;
825  if(fabs(cntrack->Eta())>fProdV0DaughterEtaRange) return kFALSE;
826  if(cptrack->Pt()<fProdV0DaughterPtMin) return kFALSE;
827  if(cntrack->Pt()<fProdV0DaughterPtMin) return kFALSE;
828 
829  Double_t RapK0s = v0->RapK0Short();
830  if(RapK0s<fProdV0RapMin || RapK0s>fProdV0RapMax) return kFALSE;
831 
832  Double_t EtaK0s = v0->PseudoRapV0();
833  if(EtaK0s<fProdV0EtaMin || EtaK0s>fProdV0EtaMax) return kFALSE;
834 
835 
837  const TBits sharedMap1 = cptrack->GetTPCSharedMap();
838  const TBits sharedMap2 = cntrack->GetTPCSharedMap();
839  if((sharedMap1.CountBits() >= 1) || (sharedMap2.CountBits() >= 1))
840  {
841  return kFALSE;
842  }
843  }
844 
845 
846  return kTRUE;
847 }
848 
849 //________________________________________________________________________
851 {
852  //
853  // Mass and pT Cut to be applied before object creation
854  //
855 
856  Double_t mprPDG = TDatabasePDG::Instance()->GetParticle(2212)->Mass();
857  Double_t mLcPDG = TDatabasePDG::Instance()->GetParticle(4122)->Mass();
858 
859  Double_t pxpr_init = part->Px();
860  Double_t pypr_init = part->Py();
861  Double_t pzpr_init = part->Pz();
862  Double_t Epr_init = sqrt(pxpr_init*pxpr_init+pypr_init*pypr_init+pzpr_init*pzpr_init+mprPDG*mprPDG);
863 
864  Double_t pxv0_init = v0->Px();
865  Double_t pyv0_init = v0->Py();
866  Double_t pzv0_init = v0->Pz();
867  Double_t massv0_init = v0->MassK0Short();
868  Double_t Ev0_init = sqrt(pxv0_init*pxv0_init+pyv0_init*pyv0_init+pzv0_init*pzv0_init+massv0_init*massv0_init);
869 
870  Double_t pxlc_init = pxpr_init+pxv0_init;
871  Double_t pylc_init = pypr_init+pyv0_init;
872  Double_t pzlc_init = pzpr_init+pzv0_init;
873  Double_t Elc_init = Epr_init+Ev0_init;
874  Double_t lcmass_init = sqrt(Elc_init*Elc_init-pxlc_init*pxlc_init-pylc_init*pylc_init-pzlc_init*pzlc_init);
875 
876  if(lcmass_init<mLcPDG-fProdRoughMassTol || lcmass_init>mLcPDG+fProdRoughMassTol) return kFALSE;
877  if(sqrt(pxlc_init*pxlc_init+pylc_init*pylc_init)<fProdRoughPtMin) return kFALSE;
878 
879  return kTRUE;
880 }
881 //________________________________________________________________________
883 {
884  //
885  // Mass and pT Cut to be applied before object creation
886  //
887 
888  Double_t mprPDG = TDatabasePDG::Instance()->GetParticle(2212)->Mass();
889  Double_t mLcPDG = TDatabasePDG::Instance()->GetParticle(4122)->Mass();
890 
891  Double_t pxpr_init = part->Px();
892  Double_t pypr_init = part->Py();
893  Double_t pzpr_init = part->Pz();
894  Double_t Epr_init = sqrt(pxpr_init*pxpr_init+pypr_init*pypr_init+pzpr_init*pzpr_init+mprPDG*mprPDG);
895 
896  Double_t pxv0_init = vka->Px();
897  Double_t pyv0_init = vka->Py();
898  Double_t pzv0_init = vka->Pz();
899  Double_t massv0_init = 0.493677;
900  Double_t Ev0_init = sqrt(pxv0_init*pxv0_init+pyv0_init*pyv0_init+pzv0_init*pzv0_init+massv0_init*massv0_init);
901 
902  Double_t pxlc_init = pxpr_init+pxv0_init;
903  Double_t pylc_init = pypr_init+pyv0_init;
904  Double_t pzlc_init = pzpr_init+pzv0_init;
905  Double_t Elc_init = Epr_init+Ev0_init;
906  Double_t lcmass_init = sqrt(Elc_init*Elc_init-pxlc_init*pxlc_init-pylc_init*pylc_init-pzlc_init*pzlc_init);
907 
908  if(lcmass_init<mLcPDG-fProdRoughMassTol || lcmass_init>mLcPDG+fProdRoughMassTol) return kFALSE;
909  if(sqrt(pxlc_init*pxlc_init+pylc_init*pylc_init)<fProdRoughPtMin) return kFALSE;
910 
911  return kTRUE;
912 }
913 //________________________________________________________________________
915 {
916  //
917  // Mass and pT Cut to be applied before object creation
918  //
919 
920  Double_t mprPDG = TDatabasePDG::Instance()->GetParticle(2212)->Mass();
921  Double_t mLcPDG = TDatabasePDG::Instance()->GetParticle(4122)->Mass();
922 
923  Double_t pxpr_init = part->Px();
924  Double_t pypr_init = part->Py();
925  Double_t pzpr_init = part->Pz();
926  Double_t Epr_init = sqrt(pxpr_init*pxpr_init+pypr_init*pypr_init+pzpr_init*pzpr_init+mprPDG*mprPDG);
927 
928  Double_t pxv0_init = v0->Px();
929  Double_t pyv0_init = v0->Py();
930  Double_t pzv0_init = v0->Pz();
931  Double_t massv0_init = v0->M();
932  Double_t Ev0_init = sqrt(pxv0_init*pxv0_init+pyv0_init*pyv0_init+pzv0_init*pzv0_init+massv0_init*massv0_init);
933 
934  Double_t pxlc_init = pxpr_init+pxv0_init;
935  Double_t pylc_init = pypr_init+pyv0_init;
936  Double_t pzlc_init = pzpr_init+pzv0_init;
937  Double_t Elc_init = Epr_init+Ev0_init;
938  Double_t lcmass_init = sqrt(Elc_init*Elc_init-pxlc_init*pxlc_init-pylc_init*pylc_init-pzlc_init*pzlc_init);
939 
940  if(lcmass_init<mLcPDG-fProdRoughMassTol || lcmass_init>mLcPDG+fProdRoughMassTol) return kFALSE;
941  if(sqrt(pxlc_init*pxlc_init+pylc_init*pylc_init)<fProdRoughPtMin) return kFALSE;
942 
943  return kTRUE;
944 }
945 //________________________________________________________________________
947 {
948  //
949  // Mass and pT Cut to be applied before object creation
950  //
951 
952  Double_t mprPDG = TDatabasePDG::Instance()->GetParticle(2212)->Mass();
953  Double_t mLcPDG = TDatabasePDG::Instance()->GetParticle(4122)->Mass();
954 
955  Double_t pxpr_init = part->Px();
956  Double_t pypr_init = part->Py();
957  Double_t pzpr_init = part->Pz();
958  Double_t Epr_init = sqrt(pxpr_init*pxpr_init+pypr_init*pypr_init+pzpr_init*pzpr_init+mprPDG*mprPDG);
959 
960  Double_t pxv0_init = vka->Px();
961  Double_t pyv0_init = vka->Py();
962  Double_t pzv0_init = vka->Pz();
963  Double_t massv0_init = 0.493677;
964  Double_t Ev0_init = sqrt(pxv0_init*pxv0_init+pyv0_init*pyv0_init+pzv0_init*pzv0_init+massv0_init*massv0_init);
965 
966  Double_t pxlc_init = pxpr_init+pxv0_init;
967  Double_t pylc_init = pypr_init+pyv0_init;
968  Double_t pzlc_init = pzpr_init+pzv0_init;
969  Double_t Elc_init = Epr_init+Ev0_init;
970  Double_t lcmass_init = sqrt(Elc_init*Elc_init-pxlc_init*pxlc_init-pylc_init*pylc_init-pzlc_init*pzlc_init);
971 
972  if(lcmass_init<mLcPDG-fProdRoughMassTol || lcmass_init>mLcPDG+fProdRoughMassTol) return kFALSE;
973  if(sqrt(pxlc_init*pxlc_init+pylc_init*pylc_init)<fProdRoughPtMin) return kFALSE;
974 
975  return kTRUE;
976 }
977 //________________________________________________________________________
978 void AliRDHFCutsLctopK0sfromAODtracks::SetMixingWeights(Int_t nbinpr, Double_t *binspr, Int_t nbink0s, Double_t *binsk0s, Double_t *p0val, Double_t *p1val, Double_t *p2val, Double_t *p3val)
979 {
980  //
981  // Set weighting factor for mixing
982  //
983  fNWeightingProtonBinLimits = nbinpr+1;
984  fNWeightingK0sBinLimits = nbink0s+1;
985  fNWeightingBins = nbinpr*nbink0s;
986 
993 
994  for(Int_t i=0;i<fNWeightingProtonBinLimits;i++){
995  fWeightingProtonBins[i] = binspr[i];
996  }
997  for(Int_t i=0;i<fNWeightingK0sBinLimits;i++){
998  fWeightingK0sBins[i] = binsk0s[i];
999  }
1000  for(Int_t i=0;i<fNWeightingBins;i++){
1001  fWeight_p0[i] = p0val[i];
1002  fWeight_p1[i] = p1val[i];
1003  fWeight_p2[i] = p2val[i];
1004  fWeight_p3[i] = p3val[i];
1005  }
1006  return;
1007 }
1008 //________________________________________________________________________
1010 {
1011  //
1012  // Get weighting factor for mixing
1013  //
1014  if(fNWeightingBins==0) return 1.;
1015  if(dphi>M_PI/2.) return 1.;//does not support away side
1016 
1017  Int_t ibin_pr = -9999;
1018  for(Int_t i=0;i<fNWeightingProtonBinLimits-1;i++){
1019  if(fWeightingProtonBins[i]<pt_pr && fWeightingProtonBins[i+1]>pt_pr){
1020  ibin_pr = i;
1021  break;
1022  }
1023  }
1024  Int_t ibin_k0s = -9999;
1025  for(Int_t i=0;i<fNWeightingK0sBinLimits-1;i++){
1026  if(fWeightingK0sBins[i]<pt_k0s && fWeightingK0sBins[i+1]>pt_k0s){
1027  ibin_k0s = i;
1028  break;
1029  }
1030  }
1031  if(ibin_pr<0 || ibin_pr > fNWeightingProtonBinLimits-1) return 1.;
1032  if(ibin_k0s<0 || ibin_k0s > fNWeightingK0sBinLimits-1) return 1.;
1033 
1034  Int_t ibin_comb = ibin_pr*(fNWeightingK0sBinLimits-1)+ibin_k0s;
1035 
1036  Double_t p0 = fWeight_p0[ibin_comb];
1037  Double_t p1 = fWeight_p1[ibin_comb];
1038  Double_t p2 = fWeight_p2[ibin_comb];
1039  Double_t p3 = fWeight_p3[ibin_comb];
1040  Double_t weight = p0 + p1 *TMath::Gaus(dphi,0.,p2)*TMath::Gaus(deta,0.,p3);
1041 
1042  return weight;
1043 }
1044 //________________________________________________________________________
1046 {
1047  //
1048  // Tag conversion electron tracks
1049  //
1050  if(fTagV0MassTol<0.) return kFALSE;
1051 
1052  Double_t mprPDG = TDatabasePDG::Instance()->GetParticle(2212)->Mass();
1053  Double_t mpiPDG = TDatabasePDG::Instance()->GetParticle(211)->Mass();
1054  Double_t mlamPDG = TDatabasePDG::Instance()->GetParticle(3122)->Mass();
1055 
1056  Bool_t isv0 = kFALSE;
1057  Bool_t islam = kFALSE;
1058  minmass = 9999.;
1059 
1060  Int_t trkid = ptrk->GetID();
1061  Double_t px1 = ptrk->Px();
1062  Double_t py1 = ptrk->Py();
1063  Double_t pz1 = ptrk->Pz();
1064  Double_t Epr1 = sqrt(px1*px1+py1*py1+pz1*pz1+mprPDG*mprPDG);
1065 
1066  for(Int_t it=0;it<ntrk;it++){
1067  AliAODTrack *trk2 = (AliAODTrack*) evt->GetTrack(it);
1068  if(!trk2) continue;
1069  Int_t trkid2 = trk2->GetID();
1070  if(trkid==trkid2) continue;
1071  if(ptrk->Charge()*trk2->Charge()>0) continue;
1072  if(!ptrk->TestFilterMask(BIT(4))) continue;
1073 
1074  Double_t px2 = trk2->Px();
1075  Double_t py2 = trk2->Py();
1076  Double_t pz2 = trk2->Pz();
1077  Double_t E2 = sqrt(px2*px2+py2*py2+pz2*pz2+mpiPDG*mpiPDG);
1078 
1079  Double_t mass_lam = sqrt(pow(Epr1+E2,2)-pow(px1+px2,2)-pow(py1+py2,2)-pow(pz1+pz2,2));
1080  Double_t dlam = mass_lam-mlamPDG;
1081  if(fabs(dlam)<fabs(minmass)){
1082  minmass = dlam;
1083  islam = kTRUE;
1084  }
1085  }
1086 
1087  if(fabs(minmass)<fTagV0MassTol) isv0 = kTRUE;
1088 
1089  if(islam) minmass += mlamPDG;
1090 
1091  return isv0;
1092 }
1093 
1094 //________________________________________________________________________
1096 {
1097  //
1098  // Tag conversion electron tracks
1099  //
1100  if(fTagV0MassTol<0.) return kFALSE;
1101 
1102  Double_t mprPDG = TDatabasePDG::Instance()->GetParticle(2212)->Mass();
1103  Double_t mpiPDG = TDatabasePDG::Instance()->GetParticle(211)->Mass();
1104  Double_t mlamPDG = TDatabasePDG::Instance()->GetParticle(3122)->Mass();
1105 
1106  Bool_t isv0 = kFALSE;
1107  Bool_t islam = kFALSE;
1108  minmass = 9999.;
1109 
1110  Int_t trkid = ptrk->GetID();
1111  Double_t px1 = ptrk->Px();
1112  Double_t py1 = ptrk->Py();
1113  Double_t pz1 = ptrk->Pz();
1114  Double_t Epr1 = sqrt(px1*px1+py1*py1+pz1*pz1+mprPDG*mprPDG);
1115 
1116  for(Int_t it=0;it<ntrk;it++){
1117  AliAODTrack *trk2 = (AliAODTrack*) evt->GetTrack(it);
1118  if(!trk2) continue;
1119  Int_t trkid2 = trk2->GetID();
1120  if(trkid==trkid2) continue;
1121  if(ptrk->Charge()*trk2->Charge()<0) continue;
1122  if(!ptrk->TestFilterMask(BIT(4))) continue;
1123 
1124  Double_t px2 = trk2->Px();
1125  Double_t py2 = trk2->Py();
1126  Double_t pz2 = trk2->Pz();
1127  Double_t E2 = sqrt(px2*px2+py2*py2+pz2*pz2+mpiPDG*mpiPDG);
1128 
1129  Double_t mass_lam = sqrt(pow(Epr1+E2,2)-pow(px1+px2,2)-pow(py1+py2,2)-pow(pz1+pz2,2));
1130  Double_t dlam = mass_lam-mlamPDG;
1131  if(fabs(dlam)<fabs(minmass)){
1132  minmass = dlam;
1133  islam = kTRUE;
1134  }
1135  }
1136 
1137  if(fabs(minmass)<fTagV0MassTol) isv0 = kTRUE;
1138 
1139  if(islam) minmass += mlamPDG;
1140 
1141  return isv0;
1142 }
Double_t * fWeight_p0
Number of bins for mixing weight should be proton x k0s.
Bool_t SingleTrkCuts(AliAODTrack *trk, AliAODTrack *trkpid, AliAODVertex *vtx)
double Double_t
Definition: External.C:58
Double_t fProdV0MassRejLambda
K0s mass selection used before object creation.
Double_t fProdV0EtaMin
V0 daughter Minimum TPC cluster pT used before object creation.
Double_t GetMixingWeight(Double_t dphi, Double_t deta, Double_t pt_pr, Double_t pt_k0s)
Double_t GetSigma(Int_t idet) const
Definition: AliAODPidHF.h:134
Double_t fProdV0DaughterTPCClusterMin
V0 Daughter pT min used before object creation.
Double_t fProdTrackTPCNclsRatioMin
Min. Number of TPC PID cluster.
Bool_t GetUseCombined()
Definition: AliAODPidHF.h:165
Double_t fBzkG
Flag to check if we use on-the-fly v0.
void SetNVars(Int_t nVars)
Definition: AliRDHFCuts.h:392
AliRDHFCutsLctopK0sfromAODtracks & operator=(const AliRDHFCutsLctopK0sfromAODtracks &source)
Double_t fProdRoughPtMin
Mass cut for Lc used before object creation.
Double_t fProdV0RapMax
Minimum rapidity of cascade.
AliRDHFCuts & operator=(const AliRDHFCuts &source)
Double_t * fWeightingK0sBins
Number of bins for k0s.
Bool_t fUsePID
Definition: AliRDHFCuts.h:422
Double_t fProdV0DaughterEtaRange
Max DCA between V0 daughters used before object creation.
TString part
use mixed event to constrain combinatorial background
Definition: InvMassFit.C:52
Double_t fProdV0MassTolK0s
Flag to Reject tracks with shared clusters.
Bool_t SingleV0Cuts(AliAODv0 *v0, AliAODVertex *vert)
Double_t InvMassLctoK0sP() const
Double_t fProdV0CosPointingAngleToPrimVtxMin
Minimum K0s pT used before object creation.
Double_t fProdRoughMassTol
Maximum rapidity of cascade.
const Double_t etamin
Double_t fProdV0PtMin
photon mass rejection used before object creation
int Int_t
Definition: External.C:63
Int_t fnVarsForOpt
Definition: AliRDHFCuts.h:417
unsigned int UInt_t
Definition: External.C:33
AliPIDCombined * GetPidCombined() const
Definition: AliAODPidHF.h:161
float Float_t
Definition: External.C:68
const Double_t ptmax
Double_t fMaxPtCand
minimum pt of the candidate
Definition: AliRDHFCuts.h:446
Double_t CalculateLcCosPAXY(AliAODRecoDecayHF *obj)
AliESDtrackCuts * fTrackCuts
quality cuts on the daughter tracks
Definition: AliRDHFCuts.h:410
virtual Int_t IsSelected(TObject *obj, Int_t selectionLevel)
Bool_t fUseOnTheFlyV0
Threshold used in IsSelectedCombinedPID.
AliAODTrack * GetBachelor() const
AliAODVertex * GetOwnPrimaryVtx() const
Double_t fProdV0DcaDaughtersMax
V0 pointing angle used before object creation.
Double_t fProdV0RapMin
Maximum eta of cascade.
virtual Int_t IsSelectedPID(AliAODRecoDecayHF *obj)
const Double_t ptmin
Int_t MakeRawPid(AliAODTrack *track, Int_t specie)
AliPIDResponse * GetPidResponse() const
Definition: AliAODPidHF.h:160
Bool_t SelectWithRoughCutsWS(AliAODTrack *vka, AliAODTrack *trk1)
Float_t * fCutsRD
fnVars*fnPtBins
Definition: AliRDHFCuts.h:420
Bool_t fProdUseAODFilterBit
Min. Number of TPC PID cluster.
Double_t fProdV0DaughterPtMin
V0Daughter eta range used before object creation.
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:418
Double_t fProdV0EtaMax
Minimum eta of cascade.
Double_t * fWeightingProtonBins
Number of bins for proton.
Bool_t SingleKaonCuts(AliAODTrack *trk, AliAODVertex *vtx)
virtual void GetCutVarsForOpt(AliAODRecoDecayHF *d, Float_t *vars, Int_t nvars, Int_t *pdgdaughters)
AliRDHFCutsLctopK0sfromAODtracks(const char *name="CutsLctopK0s")
Int_t fNWeightingProtonBinLimits
pT cut for Lc used before object creation
Bool_t TagV0(AliAODTrack *etrk, AliAODEvent *evt, Int_t ntrk, Double_t &minmass)
void SetPtBins(Int_t nPtBinLimits, Float_t *ptBinLimits)
const Double_t etamax
void SetMixingWeights(Int_t nbinpr, Double_t *bins_pr, Int_t nbink0s, Double_t *bins_k0s, Double_t *p0val, Double_t *p1val, Double_t *p2val, Double_t *p3val)
Bool_t SelectWithRoughCuts(AliAODv0 *v0, AliAODTrack *trk1)
Bool_t TagV0SameSign(AliAODTrack *etrk, AliAODEvent *evt, Int_t ntrk, Double_t &minmass)
bool Bool_t
Definition: External.C:53
AliAODPidHF * fPidHF
enable AOD049 centrality cleanup
Definition: AliRDHFCuts.h:424
Int_t PtBin(Double_t pt) const
Int_t GetGlobalIndex(Int_t iVar, Int_t iPtBin) const
Bool_t fProdRejectTrackWithShared
AOD filter Bit used before object creation.
Double_t fMinPtCand
outcome of PID selection
Definition: AliRDHFCuts.h:445
Bool_t IsDaughterSelected(AliAODTrack *track, const AliESDVertex *primary, AliESDtrackCuts *cuts, const AliAODEvent *aod=0x0) const
void SetPidResponse(AliPIDResponse *pidResp)
Definition: AliAODPidHF.h:111
Double_t fProdV0MassRejPhoton
lambda mass rejection used before object creation
Int_t fProdAODFilterBit
Flag for AOD filter Bit used before object creation.