]> git.uio.no Git - u/mrichter/AliRoot.git/blame - PWGHF/vertexingHF/AliRDHFCutsDstoKKpi.cxx
git://git.uio.no / u / mrichter / AliRoot.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
catching warnings for merging of AliTOFHeader and AliESDTrdTrigger; code cleanup...
[u/mrichter/AliRoot.git] / PWGHF / vertexingHF / AliRDHFCutsDstoKKpi.cxx
CommitLineData
42828f21 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
18/////////////////////////////////////////////////////////////
19//
20// Class for cuts on AOD reconstructed Ds->KKpi
21//
22// Author: A.Dainese, andrea.dainese@pd.infn.it
23/////////////////////////////////////////////////////////////
24
25#include <TDatabasePDG.h>
26#include <Riostream.h>
27
28#include "AliRDHFCutsDstoKKpi.h"
29#include "AliAODRecoDecayHF3Prong.h"
30#include "AliAODTrack.h"
31#include "AliESDtrack.h"
32
33ClassImp(AliRDHFCutsDstoKKpi)
34
35//--------------------------------------------------------------------------
36AliRDHFCutsDstoKKpi::AliRDHFCutsDstoKKpi(const char* name) :
37AliRDHFCuts(name),
38fPidOption(0)
39{
40 //
41 // Default Constructor
42 //
43 Int_t nvars=16;
44 SetNVars(nvars);
45 TString varNames[16]={"inv. mass [GeV]",
46 "pTK [GeV/c]",
47 "pTPi [GeV/c]",
48 "d0K [cm]",
49 "d0Pi [cm]",
50 "dist12 [cm]",
51 "sigmavert [cm]",
52 "decLen [cm]",
53 "ptMax [GeV/c]",
54 "cosThetaPoint",
55 "Sum d0^2 (cm^2)",
56 "dca [cm]",
57 "inv. mass (Mphi-MKK) [GeV]",
58 "inv. mass (MKo*-MKpi) [GeV]",
59 "Abs(CosineKpiPhiRFrame)^3",
60 "CosPiDsLabFrame"};
61
62 Bool_t isUpperCut[16]={kTRUE,
63 kFALSE,
64 kFALSE,
65 kFALSE,
66 kFALSE,
67 kFALSE,
68 kTRUE,
69 kFALSE,
70 kFALSE,
71 kFALSE,
72 kFALSE,
73 kTRUE,
74 kTRUE,
75 kTRUE,
76 kFALSE,
77 kTRUE};
78 SetVarNames(16,varNames,isUpperCut);
79 Bool_t forOpt[16]={kFALSE,
80 kFALSE,
81 kFALSE,
82 kFALSE,
83 kFALSE,
84 kFALSE,
85 kTRUE,
86 kTRUE,
87 kTRUE,
88 kTRUE,
89 kTRUE,
90 kFALSE,
91 kTRUE,
92 kTRUE,
93 kFALSE,
94 kFALSE};
95 SetVarsForOpt(7,forOpt);
96 Float_t limits[2]={0,999999999.};
97 SetPtBins(2,limits);
98 if(fPidHF)delete fPidHF;
99 fPidHF=new AliAODPidHF();
100 Double_t plim[2]={0.6,0.8};
101 Double_t nsigma[5]={2.,1.,2.,3.,0.};
102
103 fPidHF->SetPLimit(plim);
104 fPidHF->SetAsym(kTRUE);
105 fPidHF->SetSigma(nsigma);
106 fPidHF->SetMatch(1);
107 fPidHF->SetTPC(1);
108 fPidHF->SetTOF(1);
109 fPidHF->SetITS(0);
110 fPidHF->SetTRD(0);
111 fPidHF->SetCompat(kTRUE);
112
113}
114//--------------------------------------------------------------------------
115AliRDHFCutsDstoKKpi::AliRDHFCutsDstoKKpi(const AliRDHFCutsDstoKKpi &source) :
116 AliRDHFCuts(source),
117 fPidOption(source.fPidOption)
118{
119 //
120 // Copy constructor
121 //
122
123}
124//--------------------------------------------------------------------------
125AliRDHFCutsDstoKKpi &AliRDHFCutsDstoKKpi::operator=(const AliRDHFCutsDstoKKpi &source)
126{
127 //
128 // assignment operator
129 //
130 if(&source == this) return *this;
131
132 AliRDHFCuts::operator=(source);
133
134 fPidOption=source.fPidOption;
135
136 return *this;
137}
138
139
140//---------------------------------------------------------------------------
141void AliRDHFCutsDstoKKpi::GetCutVarsForOpt(AliAODRecoDecayHF *d,Float_t *vars,Int_t nvars,Int_t *pdgdaughters,AliAODEvent *aod) {
142 //
143 // Fills in vars the values of the variables
144 //
145
146 if(nvars!=fnVarsForOpt) {
147 printf("AliRDHFCutsDstoKKpi::GetCutsVarsForOpt: wrong number of variables\n");
148 return;
149 }
150
151 AliAODRecoDecayHF3Prong *dd = (AliAODRecoDecayHF3Prong*)d;
152
153 //recalculate vertex w/o daughters
154 Bool_t cleanvtx=kFALSE;
155 AliAODVertex *origownvtx=0x0;
156 if(fRemoveDaughtersFromPrimary) {
157 if(dd->GetOwnPrimaryVtx()) origownvtx=new AliAODVertex(*dd->GetOwnPrimaryVtx());
158 cleanvtx=kTRUE;
159 if(!RecalcOwnPrimaryVtx(dd,aod)) {
160 CleanOwnPrimaryVtx(dd,aod,origownvtx);
161 cleanvtx=kFALSE;
162 }
163 }
164
165 Int_t iter=-1;
166 if(fVarsForOpt[0]){
167 iter++;
168 if(TMath::Abs(pdgdaughters[0])==321){
169 vars[iter]=dd->InvMassDsKKpi();
170 }else{
171 vars[iter]=dd->InvMassDspiKK();
172 }
173 }
174 if(fVarsForOpt[1]){
175 iter++;
176 Float_t minPtDau=99999.;
177 for(Int_t iprong=0;iprong<3;iprong++){
178 if(TMath::Abs(pdgdaughters[iprong])==321 &&
179 dd->PtProng(iprong)<minPtDau) minPtDau=dd->PtProng(iprong);
180 }
181 vars[iter]=minPtDau;
182 }
183 if(fVarsForOpt[2]){
184 iter++;
185 for(Int_t iprong=0;iprong<3;iprong++){
186 if(TMath::Abs(pdgdaughters[iprong])==211) {
187 vars[iter]=dd->PtProng(iprong);
188 }
189 }
190 }
191 if(fVarsForOpt[3]){
192 iter++;
193 Float_t minImpParDau=99999.;
194 for(Int_t iprong=0;iprong<3;iprong++){
195 if(TMath::Abs(pdgdaughters[iprong])==321 &&
196 dd->Getd0Prong(iprong)<minImpParDau) minImpParDau=dd->Getd0Prong(iprong);
197 }
198 vars[iter]=minImpParDau;
199 }
200 if(fVarsForOpt[4]){
201 iter++;
202 for(Int_t iprong=0;iprong<3;iprong++){
203 if(TMath::Abs(pdgdaughters[iprong])==211) {
204 vars[iter]=dd->Getd0Prong(iprong);
205 }
206 }
207 }
208 if(fVarsForOpt[5]){
209 iter++;
210 Float_t minDistPair=TMath::Min(dd->GetDist12toPrim(),dd->GetDist23toPrim());
211 vars[iter]=minDistPair;
212 }
213 if(fVarsForOpt[6]){
214 iter++;
215 vars[iter]=dd->GetSigmaVert(aod);
216 }
217 if(fVarsForOpt[7]){
218 iter++;
219 vars[iter] = dd->DecayLength();
220 }
221 if(fVarsForOpt[8]){
222 iter++;
223 Float_t ptmax=0;
224 for(Int_t i=0;i<3;i++){
225 if(dd->PtProng(i)>ptmax)ptmax=dd->PtProng(i);
226 }
227 vars[iter]=ptmax;
228 }
229 if(fVarsForOpt[9]){
230 iter++;
231 vars[iter]=dd->CosPointingAngle();
232 }
233 if(fVarsForOpt[10]){
234 iter++;
235 vars[iter]=dd->Getd0Prong(0)*dd->Getd0Prong(0)+dd->Getd0Prong(1)*dd->Getd0Prong(1)+dd->Getd0Prong(2)*dd->Getd0Prong(2);
236 }
237 if(fVarsForOpt[11]){
238 iter++;
239 Float_t maxDCA=0.;
240 for(Int_t i=0;i<3;i++){
241 if(d->GetDCA(i)>maxDCA) maxDCA=d->GetDCA(i);
242 }
243 vars[iter]=maxDCA;
244 }
245 if(fVarsForOpt[12]){
246 iter++;
247 Double_t mPDGPhi = TDatabasePDG::Instance()->GetParticle(333)->Mass();
248 if(TMath::Abs(pdgdaughters[0])==321){
249
250 Double_t phimass01=d->InvMass2Prongs(0,1,321,321);
251 vars[iter]=TMath::Abs(phimass01-mPDGPhi);
252 // vars[iter]=dd->InvMass2Prongs(0,1,321,321);
253 }else{
254 Double_t phimass12=d->InvMass2Prongs(1,2,321,321);
255 vars[iter]=TMath::Abs(phimass12-mPDGPhi);
256 // vars[iter]=dd->InvMass2Prongs(1,2,321,321);
257 }
258 }
259 if(fVarsForOpt[13]){
260 iter++;
261 Double_t mPDGK0star = TDatabasePDG::Instance()->GetParticle(313)->Mass();
262 if(TMath::Abs(pdgdaughters[0])==321){
263
264 Double_t mass12kpi=d->InvMass2Prongs(1,2,321,211);
265 vars[iter]=TMath::Abs(mass12kpi-mPDGK0star);
266 // vars[iter]=dd->InvMass2Prongs(1,2,321,211);
267 }else{
268 Double_t mass01pik=d->InvMass2Prongs(0,1,211,321);
269 vars[iter]=TMath::Abs(mass01pik-mPDGK0star);
270 // vars[iter]=dd->InvMass2Prongs(0,1,211,321);
271 }
272 }
273 if(fVarsForOpt[14]){
274 iter++;
275 if(TMath::Abs(pdgdaughters[0])==321){
276 vars[iter]=dd->CosPiKPhiRFrameKKpi();
277 }else{
278 vars[iter]=dd->CosPiKPhiRFramepiKK();
279 }
280 }
281 if(fVarsForOpt[15]){
282 iter++;
283 if(TMath::Abs(pdgdaughters[0])==321){
284 vars[iter]=dd->CosPiDsLabFrameKKpi();
285 }else{
286 vars[iter]=dd->CosPiDsLabFramepiKK();
287 }
288 }
289
290 if(cleanvtx)CleanOwnPrimaryVtx(dd,aod,origownvtx);
291 return;
292}
293//---------------------------------------------------------------------------
294Bool_t AliRDHFCutsDstoKKpi::IsInFiducialAcceptance(Double_t pt, Double_t y) const
295{
296 //
297 // Checking if Ds is in fiducial acceptance region
298 //
299
300 if(pt > 5.) {
301 // applying cut for pt > 5 GeV
302 AliDebug(2,Form("pt of Ds = %f (> 5), cutting at |y| < 0.8",pt));
303 if (TMath::Abs(y) > 0.8) return kFALSE;
304
305 } else {
306 // appliying smooth cut for pt < 5 GeV
307 Double_t maxFiducialY = -0.2/15*pt*pt+1.9/15*pt+0.5;
308 Double_t minFiducialY = 0.2/15*pt*pt-1.9/15*pt-0.5;
309 AliDebug(2,Form("pt of Ds = %f (< 5), cutting according to the fiducial zone [%f, %f]\n",pt,minFiducialY,maxFiducialY));
310 if (y < minFiducialY || y > maxFiducialY) return kFALSE;
311 }
312
313 return kTRUE;
314}
315
316//---------------------------------------------------------------------------
317Int_t AliRDHFCutsDstoKKpi::IsSelectedPID(AliAODRecoDecayHF *rd) {
318 // PID selection
319 // return values: 0->NOT OK, 1->OK as KKpi, 2->OK as piKK, 3->OK as both
320 Int_t retCode=3;
321 Bool_t okKKpi=kTRUE;
322 Bool_t okpiKK=kTRUE;
323 if(!fUsePID || !rd) return retCode;
324 if(!fPidHF){
325 AliWarning("AliAODPidHF not created!");
326 return retCode;
327 }
328
329 Double_t origCompatTOF=fPidHF->GetPCompatTOF();
330 Double_t origThreshTPC=fPidHF->GetPtThresholdTPC();
331 if(fPidOption==kStrong){
332 fPidHF->SetPCompatTOF(999999.);
333 fPidHF->SetPtThresholdTPC(999999.);
334 }
335
336
337 Int_t nKaons=0;
338 Int_t nNotKaons=0;
339 Int_t sign= rd->GetCharge();
340 for(Int_t iDaught=0; iDaught<3; iDaught++){
341 AliAODTrack *track=(AliAODTrack*)rd->GetDaughter(iDaught);
342
343 Int_t isPion=fPidHF->MakeRawPid(track,AliPID::kPion);
344 Int_t isKaon=fPidHF->MakeRawPid(track,AliPID::kKaon);
345 Int_t isProton=fPidHF->MakeRawPid(track,AliPID::kProton);
346
347 if(isProton>0 && isKaon<0 && isPion<0){
348 fPidHF->SetPCompatTOF(origCompatTOF);
349 fPidHF->SetPtThresholdTPC(origThreshTPC);
350 return 0;
351 }
352 if(sign!=track->Charge()){// must be kaon
353 if(isKaon<0){
354 fPidHF->SetPCompatTOF(origCompatTOF);
355 fPidHF->SetPtThresholdTPC(origThreshTPC);
356 return 0;
357 }
358 if(fPidOption==kStrong && isKaon<=0){
359 fPidHF->SetPCompatTOF(origCompatTOF);
360 fPidHF->SetPtThresholdTPC(origThreshTPC);
361 return 0;
362 }
363 }
364 if(isKaon>0 && isPion<0) nKaons++;
365 if(isKaon<0) nNotKaons++;
366 if(iDaught==0){
367 if(isKaon<0) okKKpi=kFALSE;
368 if(isPion<0) okpiKK=kFALSE;
369 if(fPidOption==kStrong){
370 if(isKaon<=0) okKKpi=kFALSE;
371 if(isPion<=0) okpiKK=kFALSE;
372 }
373 }
374 else if(iDaught==2){
375 if(isKaon<0) okpiKK=kFALSE;
376 if(isPion<0) okKKpi=kFALSE;
377 if(fPidOption==kStrong){
378 if(isKaon<=0) okpiKK=kFALSE;
379 if(isPion<=0) okKKpi=kFALSE;
380 }
381 }
382 }
383
384 fPidHF->SetPCompatTOF(origCompatTOF);
385 fPidHF->SetPtThresholdTPC(origThreshTPC);
386
387 if(nKaons>2)return 0;
388 if(nNotKaons>1) return 0;
389
390 if(!okKKpi) retCode-=1;
391 if(!okpiKK) retCode-=2;
392
393 return retCode;
394}
395
396//---------------------------------------------------------------------------
397Int_t AliRDHFCutsDstoKKpi::IsSelected(TObject* obj,Int_t selectionLevel, AliAODEvent* aod) {
398 //
399 // Apply selection
400 //
401
402 if(!fCutsRD){
403 cout<<"Cut matrix not inizialized. Exit..."<<endl;
404 return 0;
405 }
406 //PrintAll();
407 AliAODRecoDecayHF3Prong* d=(AliAODRecoDecayHF3Prong*)obj;
408
409 if(!d){
410 cout<<"AliAODRecoDecayHF3Prong null"<<endl;
411 return 0;
412 }
413
414 if(fKeepSignalMC) if(IsSignalMC(d,aod,431)) return 3;
415
416 Double_t ptD=d->Pt();
417 if(ptD<fMinPtCand) return 0;
418 if(ptD>fMaxPtCand) return 0;
419
420 if(d->HasBadDaughters()) return 0;
421
422
423 // selection on daughter tracks
424 if(selectionLevel==AliRDHFCuts::kAll ||
425 selectionLevel==AliRDHFCuts::kTracks) {
426 if(!AreDaughtersSelected(d)) return 0;
427 }
428
429
430
431
432 // selection on candidate
433 if(selectionLevel==AliRDHFCuts::kAll ||
434 selectionLevel==AliRDHFCuts::kCandidate) {
435 //recalculate vertex w/o daughters
436 AliAODVertex *origownvtx=0x0;
437 if(fRemoveDaughtersFromPrimary) {
438 if(d->GetOwnPrimaryVtx()) origownvtx=new AliAODVertex(*d->GetOwnPrimaryVtx());
439 if(!RecalcOwnPrimaryVtx(d,aod)) {
440 CleanOwnPrimaryVtx(d,aod,origownvtx);
441 return 0;
442 }
443 }
444
445 Int_t okDsKKpi=1;
446 Int_t okDspiKK=1;
447 Int_t okMassPhiKKpi=0;
448 Int_t okMassPhipiKK=0;
449 Int_t okMassK0starKKpi=0;
450 Int_t okMassK0starpiKK=0;
451 Int_t okDsPhiKKpi=0;
452 Int_t okDsPhipiKK=0;
453 Int_t okDsK0starKKpi=0;
454 Int_t okDsK0starpiKK=0;
455
456 Double_t pt=d->Pt();
457 Int_t ptbin=PtBin(pt);
458 if (ptbin==-1) {
459 CleanOwnPrimaryVtx(d,aod,origownvtx);
460 return 0;
461 }
462
463 Double_t mDsPDG = TDatabasePDG::Instance()->GetParticle(431)->Mass();
464 Double_t mDsKKpi=d->InvMassDsKKpi();
465 Double_t mDspiKK=d->InvMassDspiKK();
466 if(TMath::Abs(mDsKKpi-mDsPDG)>fCutsRD[GetGlobalIndex(0,ptbin)]) okDsKKpi = 0;
467 if(TMath::Abs(mDspiKK-mDsPDG)>fCutsRD[GetGlobalIndex(0,ptbin)]) okDspiKK = 0;
468 if(!okDsKKpi && !okDspiKK){
469 CleanOwnPrimaryVtx(d,aod,origownvtx);
470 return 0;
471 }
472
473
474
475 // cuts on resonant decays (via Phi or K0*)
476 Double_t mPhiPDG = TDatabasePDG::Instance()->GetParticle(333)->Mass();
477 Double_t mK0starPDG = TDatabasePDG::Instance()->GetParticle(313)->Mass();
478 if(okDsKKpi){
479 Double_t mass01phi=d->InvMass2Prongs(0,1,321,321);
480 Double_t mass12K0s=d->InvMass2Prongs(1,2,321,211);
481 if(TMath::Abs(mass01phi-mPhiPDG)<fCutsRD[GetGlobalIndex(12,ptbin)]) okMassPhiKKpi=1;
482 if(TMath::Abs(mass12K0s-mK0starPDG)<fCutsRD[GetGlobalIndex(13,ptbin)]) okMassK0starKKpi = 1;
483 if(!okMassPhiKKpi && !okMassK0starKKpi) okDsKKpi=0;
484 if(okMassPhiKKpi) okDsPhiKKpi=1;
485 if(okMassK0starKKpi) okDsK0starKKpi=1;
486 }
487 if(okDspiKK){
488 Double_t mass01K0s=d->InvMass2Prongs(0,1,211,321);
489 Double_t mass12phi=d->InvMass2Prongs(1,2,321,321);
490 if(TMath::Abs(mass01K0s-mK0starPDG)<fCutsRD[GetGlobalIndex(13,ptbin)]) okMassK0starpiKK = 1;
491 if(TMath::Abs(mass12phi-mPhiPDG)<fCutsRD[GetGlobalIndex(12,ptbin)]) okMassPhipiKK=1;
492 if(!okMassPhipiKK && !okMassK0starpiKK) okDspiKK=0;
493 if(okMassPhipiKK) okDsPhipiKK=1;
494 if(okMassK0starpiKK) okDsK0starpiKK=1;
495 }
496 if(!okDsKKpi && !okDspiKK){
497 CleanOwnPrimaryVtx(d,aod,origownvtx);
498 return 0;
499 }
500
501 // Cuts on track pairs
502 for(Int_t i=0;i<3;i++){
503 if(d->GetDCA(i)>fCutsRD[GetGlobalIndex(11,ptbin)]){
504 CleanOwnPrimaryVtx(d,aod,origownvtx);
505 return 0;
506 }
507 }
508 if(d->GetDist12toPrim()<fCutsRD[GetGlobalIndex(5,ptbin)] ||
509 d->GetDist23toPrim()<fCutsRD[GetGlobalIndex(5,ptbin)]){
510 CleanOwnPrimaryVtx(d,aod,origownvtx);
511 return 0;
512 }
513
514
515
516 //single track
517 if(TMath::Abs(d->Pt2Prong(1)) < fCutsRD[GetGlobalIndex(1,ptbin)]*fCutsRD[GetGlobalIndex(1,ptbin)] ||
518 TMath::Abs(d->Getd0Prong(1))<fCutsRD[GetGlobalIndex(3,ptbin)]){
519 CleanOwnPrimaryVtx(d,aod,origownvtx);
520 return 0;
521 }
522
523 if(okDsKKpi){
524 if(TMath::Abs(d->Pt2Prong(0)) < fCutsRD[GetGlobalIndex(1,ptbin)]*fCutsRD[GetGlobalIndex(1,ptbin)] ||
525 TMath::Abs(d->Getd0Prong(0))<fCutsRD[GetGlobalIndex(3,ptbin)]) okDsKKpi=0;
526 if(TMath::Abs(d->Pt2Prong(2)) < fCutsRD[GetGlobalIndex(2,ptbin)]*fCutsRD[GetGlobalIndex(2,ptbin)] ||
527 TMath::Abs(d->Getd0Prong(2))<fCutsRD[GetGlobalIndex(4,ptbin)]) okDsKKpi=0;
528 }
529 if(okDspiKK){
530 if(TMath::Abs(d->Pt2Prong(0)) < fCutsRD[GetGlobalIndex(2,ptbin)]*fCutsRD[GetGlobalIndex(2,ptbin)] ||
531 TMath::Abs(d->Getd0Prong(0))<fCutsRD[GetGlobalIndex(4,ptbin)]) okDspiKK=0;
532 if(TMath::Abs(d->Pt2Prong(2)) < fCutsRD[GetGlobalIndex(1,ptbin)]*fCutsRD[GetGlobalIndex(1,ptbin)] ||
533 TMath::Abs(d->Getd0Prong(2))<fCutsRD[GetGlobalIndex(3,ptbin)]) okDspiKK=0;
534 }
535 if(!okDsKKpi && !okDspiKK){
536 CleanOwnPrimaryVtx(d,aod,origownvtx);
537 return 0;
538 }
539
540 // Cuts on candidate triplet
541
542
543 if(d->CosPointingAngle()< fCutsRD[GetGlobalIndex(9,ptbin)]){
544 CleanOwnPrimaryVtx(d,aod,origownvtx);
545 return 0;
546 }
547
548 if(d->Pt2Prong(0)<fCutsRD[GetGlobalIndex(8,ptbin)]*fCutsRD[GetGlobalIndex(8,ptbin)] &&
549 d->Pt2Prong(1)<fCutsRD[GetGlobalIndex(8,ptbin)]*fCutsRD[GetGlobalIndex(8,ptbin)] &&
550 d->Pt2Prong(2)<fCutsRD[GetGlobalIndex(8,ptbin)]*fCutsRD[GetGlobalIndex(8,ptbin)]) {
551 CleanOwnPrimaryVtx(d,aod,origownvtx);
552 return 0;
553 }
554
555 if(d->DecayLength2()<fCutsRD[GetGlobalIndex(7,ptbin)]*fCutsRD[GetGlobalIndex(7,ptbin)]){
556 CleanOwnPrimaryVtx(d,aod,origownvtx);
557 return 0;
558 }
559
560
561 Double_t sum2=d->Getd0Prong(0)*d->Getd0Prong(0)+d->Getd0Prong(1)*d->Getd0Prong(1)+d->Getd0Prong(2)*d->Getd0Prong(2);
562 if(sum2<fCutsRD[GetGlobalIndex(10,ptbin)]){
563 CleanOwnPrimaryVtx(d,aod,origownvtx);
564 return 0;
565 }
566
567
568 //sec vert
569 Double_t sigmavert=d->GetSigmaVert(aod);
570 if(sigmavert>fCutsRD[GetGlobalIndex(6,ptbin)]){
571 CleanOwnPrimaryVtx(d,aod,origownvtx);
572 return 0;
573 }
574
575 if(okDsKKpi){
576 Double_t cosPiKPhiRFKKpi=d->CosPiKPhiRFrameKKpi();
577 Double_t kincutPiKPhiKKpi=TMath::Abs(cosPiKPhiRFKKpi*cosPiKPhiRFKKpi*cosPiKPhiRFKKpi);
578 if(kincutPiKPhiKKpi<fCutsRD[GetGlobalIndex(14,ptbin)]) okDsKKpi=0;
579 }
580 if(okDspiKK){
581 Double_t cosPiKPhiRFpiKK=d->CosPiKPhiRFramepiKK();
582 Double_t kincutPiKPhipiKK=TMath::Abs(cosPiKPhiRFpiKK*cosPiKPhiRFpiKK*cosPiKPhiRFpiKK);
583 if(kincutPiKPhipiKK<fCutsRD[GetGlobalIndex(14,ptbin)]) okDspiKK=0;
584 }
585 if(!okDsKKpi && !okDspiKK){
586 CleanOwnPrimaryVtx(d,aod,origownvtx);
587 return 0;
588 }
589
590
591
592 if(okDsKKpi){
593 Double_t cosPiDsLabFrameKKpi=d->CosPiDsLabFrameKKpi();
594 if(cosPiDsLabFrameKKpi>fCutsRD[GetGlobalIndex(15,ptbin)]) okDsKKpi=0;
595 }
596 if(okDspiKK){
597 Double_t cosPiDsLabFramepiKK=d->CosPiDsLabFramepiKK();
598 if(cosPiDsLabFramepiKK>fCutsRD[GetGlobalIndex(15,ptbin)]) okDspiKK=0;
599 }
600 if(!okDsKKpi && !okDspiKK){
601 CleanOwnPrimaryVtx(d,aod,origownvtx);
602 return 0;
603 }
604
605 // unset recalculated primary vertex when not needed any more
606 CleanOwnPrimaryVtx(d,aod,origownvtx);
607
608
609
610 if(!okDsKKpi){
611 okDsPhiKKpi=0;
612 okDsK0starKKpi=0;
613 }
614 if(!okDspiKK){
615 okDsPhipiKK=0;
616 okDsK0starpiKK=0;
617 }
618
619 // PID selection
620 Int_t returnvaluePID=3;
621 if(selectionLevel==AliRDHFCuts::kAll ||
622 selectionLevel==AliRDHFCuts::kCandidate ||
623 selectionLevel==AliRDHFCuts::kPID) {
624 returnvaluePID = IsSelectedPID(d);
625 fIsSelectedPID=returnvaluePID;
626 }
627 if(returnvaluePID==0)return 0;
628
629 Bool_t okPidDsKKpi=returnvaluePID&1;
630 Bool_t okPidDspiKK=returnvaluePID&2;
631 if(!okPidDsKKpi){
632 okDsPhiKKpi=0;
633 okDsK0starKKpi=0;
634 }
635 if(!okPidDspiKK){
636 okDsPhipiKK=0;
637 okDsK0starpiKK=0;
638 }
639
640 if((okPidDsKKpi && okDsKKpi)||(okPidDspiKK && okDspiKK)){
641 Int_t returnvalue=0;
642 if(okDsKKpi) returnvalue+=1;
643 if(okDspiKK) returnvalue+=2;
644 if(okDsPhiKKpi) returnvalue+=4;
645 if(okDsPhipiKK) returnvalue+=8;
646 if(okDsK0starKKpi) returnvalue+=16;
647 if(okDsK0starpiKK) returnvalue+=32;
648 return returnvalue;
649 }else{
650 return 0;
651 }
652 }
653 return 15;
654
655}
656
657//--------------------------------------------------------------------------
658
659UInt_t AliRDHFCutsDstoKKpi::GetPIDTrackTPCTOFBitMap(AliAODTrack *track) const{
660
661 UInt_t bitmap=0;
662
663 Double_t sigmaTPCPionHyp=-999.;
664 Double_t sigmaTPCKaonHyp=-999.;
665 Double_t sigmaTPCProtonHyp=-999.;
666 Double_t sigmaTOFPionHyp=-999.;
667 Double_t sigmaTOFKaonHyp=-999.;
668 Double_t sigmaTOFProtonHyp=-999.;
669
670 Int_t oksigmaTPCPionHyp=fPidHF->GetnSigmaTPC(track,2,sigmaTPCPionHyp);
671 Int_t oksigmaTPCKaonHyp=fPidHF->GetnSigmaTPC(track,3,sigmaTPCKaonHyp);
672 Int_t oksigmaTPCProtonHyp=fPidHF->GetnSigmaTPC(track,4,sigmaTPCProtonHyp);
673 Int_t oksigmaTOFPionHyp=fPidHF->GetnSigmaTOF(track,2,sigmaTOFPionHyp);
674 Int_t oksigmaTOFKaonHyp=fPidHF->GetnSigmaTOF(track,3,sigmaTOFKaonHyp);
675 Int_t oksigmaTOFProtonHyp=fPidHF->GetnSigmaTOF(track,4,sigmaTOFProtonHyp);
676
677 if (oksigmaTPCPionHyp && sigmaTPCPionHyp>0.){
678 if (sigmaTPCPionHyp<1.) bitmap+=1<<kTPCPionLess1;
679 else{
680 if (sigmaTPCPionHyp<2.) bitmap+=1<<kTPCPionMore1Less2;
681 else {
682 if (sigmaTPCPionHyp<3.) bitmap+=1<<kTPCPionMore2Less3;
683 else bitmap+=1<<kTPCPionMore3;
684 }
685 }
686 }
687
688 if (oksigmaTPCKaonHyp && sigmaTPCKaonHyp>0.){
689 if (sigmaTPCKaonHyp<1.) bitmap+=1<<kTPCKaonLess1;
690 else{
691 if (sigmaTPCKaonHyp<2.) bitmap+=1<<kTPCKaonMore1Less2;
692 else {
693 if (sigmaTPCKaonHyp<3.) bitmap+=1<<kTPCKaonMore2Less3;
694 else bitmap+=1<<kTPCKaonMore3;
695 }
696 }
697 }
698
699 if (oksigmaTPCProtonHyp && sigmaTPCProtonHyp>0.){
700 if (sigmaTPCProtonHyp<1.) bitmap+=1<<kTPCProtonLess1;
701 else{
702 if (sigmaTPCProtonHyp<2.) bitmap+=1<<kTPCProtonMore1Less2;
703 else {
704 if (sigmaTPCProtonHyp<3.) bitmap+=1<<kTPCProtonMore2Less3;
705 else bitmap+=1<<kTPCProtonMore3;
706 }
707 }
708 }
709
710 if (oksigmaTOFPionHyp && sigmaTOFPionHyp>0.){
711 if (sigmaTOFPionHyp<1.) bitmap+=1<<kTOFPionLess1;
712 else{
713 if (sigmaTOFPionHyp<2.) bitmap+=1<<kTOFPionMore1Less2;
714 else {
715 if (sigmaTOFPionHyp<3.) bitmap+=1<<kTOFPionMore2Less3;
716 else bitmap+=1<<kTOFPionMore3;
717 }
718 }
719 }
720
721 if (oksigmaTOFKaonHyp && sigmaTOFKaonHyp>0.){
722 if (sigmaTOFKaonHyp<1.) bitmap+=1<<kTOFKaonLess1;
723 else{
724 if (sigmaTOFKaonHyp<2.) bitmap+=1<<kTOFKaonMore1Less2;
725 else {
726 if (sigmaTOFKaonHyp<3.) bitmap+=1<<kTOFKaonMore2Less3;
727 else bitmap+=1<<kTOFKaonMore3;
728 }
729 }
730 }
731
732 if (oksigmaTOFProtonHyp && sigmaTOFProtonHyp>0.){
733 if (sigmaTOFProtonHyp<1.) bitmap+=1<<kTOFProtonLess1;
734 else{
735 if (sigmaTOFProtonHyp<2.) bitmap+=1<<kTOFProtonMore1Less2;
736 else {
737 if (sigmaTOFProtonHyp<3.) bitmap+=1<<kTOFProtonMore2Less3;
738 else bitmap+=1<<kTOFProtonMore3;
739 }
740 }
741 }
742
743
744
745 return bitmap;
746
747}
748
749
750//---------------------------------------------------------------------------
751
752void AliRDHFCutsDstoKKpi::SetStandardCutsPP2010() {
753 //
754 //STANDARD CUTS USED FOR 2010 pp analysis
755 //
756
757 SetName("DstoKKpiCutsStandard");
758 SetTitle("Standard Cuts for D+s analysis");
759
760 // PILE UP REJECTION
761 SetOptPileup(AliRDHFCuts::kRejectPileupEvent);
762
763 // EVENT CUTS
764 SetMinVtxContr(1);
765
766 AliESDtrackCuts* esdTrackCuts=new AliESDtrackCuts();
767 esdTrackCuts->SetRequireSigmaToVertex(kFALSE);
768 //default
769 esdTrackCuts->SetRequireTPCRefit(kTRUE);
770 esdTrackCuts->SetRequireITSRefit(kTRUE);
771 //esdTrackCuts->SetMinNClustersITS(4); // default is 5
772 esdTrackCuts->SetMinNClustersTPC(70);
773 esdTrackCuts->SetClusterRequirementITS(AliESDtrackCuts::kSPD,
774 AliESDtrackCuts::kAny);
775 // default is kBoth, otherwise kAny
776 esdTrackCuts->SetMinDCAToVertexXY(0.);
777 esdTrackCuts->SetPtRange(0.3,1.e10);
778
779 AddTrackCuts(esdTrackCuts);
780
781
782
783 const Int_t nptbins=4;
8195786d 784 Float_t ptbins[nptbins+1];
42828f21 785 ptbins[0]=2.;
786 ptbins[1]=4.;
787 ptbins[2]=6.;
788 ptbins[3]=8.;
789 ptbins[4]=12.;
790
791 const Int_t nvars=16;
792
793 Float_t** anacutsval;
794 anacutsval=new Float_t*[nvars];
795
796 for(Int_t ic=0;ic<nvars;ic++){anacutsval[ic]=new Float_t[nptbins];}
797 for(Int_t ipt=0;ipt<nptbins;ipt++){
798
799 anacutsval[0][ipt]=0.35;
800 anacutsval[1][ipt]=0.3;
801 anacutsval[2][ipt]=0.3;
802 anacutsval[3][ipt]=0.;
803 anacutsval[4][ipt]=0.;
804 anacutsval[5][ipt]=0.005;
805 anacutsval[8][ipt]=0.;
806 anacutsval[10][ipt]=0.;
807 anacutsval[11][ipt]=1000.0;
808 anacutsval[13][ipt]=0.1;
809 }
810
811 //sigmavertex
812
813 anacutsval[6][0]=0.020;
814 anacutsval[6][1]=0.030;
815 anacutsval[6][2]=0.030;
816 anacutsval[6][3]=0.060;
817
818 //Decay length
819
820 anacutsval[7][0]=0.035;
821 anacutsval[7][1]=0.035;
822 anacutsval[7][2]=0.040;
823 anacutsval[7][3]=0.040;
824
825 //cosThetaPoint
826
827 anacutsval[9][0]=0.94;
828 anacutsval[9][1]=0.94;
829 anacutsval[9][2]=0.94;
830 anacutsval[9][3]=0.94;
831
832 //phi DeltaMass
833
834 anacutsval[12][0]=0.0080;
835 anacutsval[12][1]=0.0050;
836 anacutsval[12][2]=0.0045;
837 anacutsval[12][3]=0.0090;
838
839 //Kin1
840
841 anacutsval[14][0]=0.10;
842 anacutsval[14][1]=0.05;
843 anacutsval[14][2]=0.0;
844 anacutsval[14][3]=0.05;
845
846 //Kin2
847
848 anacutsval[15][0]=0.95;
849 anacutsval[15][1]=0.95;
850 anacutsval[15][2]=1.;
851 anacutsval[15][3]=0.95;
852
853
854 SetUsePID(kTRUE);
855 SetPidOption(1);
856 SetGlobalIndex(nvars,nptbins);
857 SetPtBins(nptbins+1,ptbins);
858 SetCuts(nvars,nptbins,anacutsval);
859 SetRemoveDaughtersFromPrim(kTRUE);
860
861 PrintAll();
862
863 for(Int_t iic=0;iic<nvars;iic++){delete [] anacutsval[iic];}
864 delete [] anacutsval;
865 anacutsval=NULL;
866
867 return;
868}
869