[u/mrichter/AliRoot.git] / PWG3 / vertexingHF / AliRDHFCutsDStartoKpipi.cxx

/**************************************************************************
 * Copyright(c) 1998-2010, ALICE Experiment at CERN, All rights reserved. *
 *                                                                        *
 * Author: The ALICE Off-line Project.                                    *
 * Contributors are mentioned in the code where appropriate.              *
 *                                                                        *
 * Permission to use, copy, modify and distribute this software and its   *
 * documentation strictly for non-commercial purposes is hereby granted   *
 * without fee, provided that the above copyright notice appears in all   *
 * copies and that both the copyright notice and this permission notice   *
 * appear in the supporting documentation. The authors make no claims     *
 * about the suitability of this software for any purpose. It is          *
 * provided "as is" without express or implied warranty.                  *
 **************************************************************************/

/////////////////////////////////////////////////////////////
//
// Class for cuts on AOD reconstructed DStar->Kpipi
//
// Author: A.Grelli, alessandro.grelli@uu.nl
/////////////////////////////////////////////////////////////

#include <TDatabasePDG.h>
#include <Riostream.h>

#include "AliAODRecoDecayHF2Prong.h"
#include "AliAODRecoCascadeHF.h"
#include "AliRDHFCutsD0toKpi.h"
#include "AliRDHFCutsDStartoKpipi.h"
#include "AliAODTrack.h"
#include "AliESDtrack.h"

ClassImp(AliRDHFCutsDStartoKpipi)

//--------------------------------------------------------------------------
AliRDHFCutsDStartoKpipi::AliRDHFCutsDStartoKpipi() : 
AliRDHFCuts()
{
  //
  // Default Constructor
  //
 
  Int_t nvars=14;
  SetNVars(nvars);
  TString varNames[14]={
    "inv. mass [GeV]",   
    "dca [cm]",
    "cosThetaStar", 
    "pTK [GeV/c]",
    "pTPi [GeV/c]",
    "d0K [cm]",
    "d0Pi [cm]",
    "d0d0 [cm^2]",
    "cosThetaPoint",
    "inv. mass half width of D* [GeV]",
    "half width of (M_Kpipi-M_D0) [GeV]",
    "PtMin of pi_s [GeV/c]",
    "PtMax of pi_s [GeV/c]",
    "theta, angle between the pi_s and decay plane of the D0 [rad]"};
  Bool_t isUpperCut[14]={
    kTRUE,
    kTRUE,
    kTRUE,
    kFALSE,
    kFALSE,
    kTRUE,
    kTRUE,
    kTRUE,
    kFALSE,
    kTRUE,
    kTRUE,
    kTRUE,
    kTRUE,
    kFALSE};
  SetVarNames(nvars,varNames,isUpperCut);
  Bool_t forOpt[14]={
    kFALSE,
    kTRUE,
    kTRUE,
    kFALSE,
    kFALSE,
    kFALSE,
    kFALSE,
    kTRUE,
    kTRUE,
    kFALSE,
    kTRUE,
    kFALSE,
    kFALSE,
    kFALSE};
  SetVarsForOpt(5,forOpt);
  Float_t limits[2]={0,999999999.};
  SetPtBins(2,limits);
}
//--------------------------------------------------------------------------
AliRDHFCutsDStartoKpipi::AliRDHFCutsDStartoKpipi(const AliRDHFCutsDStartoKpipi &source) :
  AliRDHFCuts(source)
{
  //
  // Copy constructor
  //

}
//--------------------------------------------------------------------------
AliRDHFCutsDStartoKpipi &AliRDHFCutsDStartoKpipi::operator=(const AliRDHFCutsDStartoKpipi &source)
{
  //
  // assignment operator
  //
  if(&source == this) return *this;

  AliRDHFCuts::operator=(source);

  return *this;
}


//---------------------------------------------------------------------------
void AliRDHFCutsDStartoKpipi::GetCutVarsForOpt(AliAODRecoDecayHF *d,Float_t *vars,Int_t nvars,Int_t *pdgdaughters) {
  // 
  // Fills in vars the values of the variables 
  //
  if(nvars!=fnVarsForOpt) {
    printf("AliRDHFCutsDStartoKpipi::GetCutsVarsForOpt: wrong number of variables\n");
    return;
  }
  
 
  AliAODRecoCascadeHF* dstarD0pi = (AliAODRecoCascadeHF*)d;

  AliAODTrack *softPi = (AliAODTrack*)dstarD0pi->GetBachelor();

  AliAODRecoDecayHF2Prong* dd = (AliAODRecoDecayHF2Prong*)dstarD0pi->Get2Prong();
  
   Int_t iter=-1;
  if(fVarsForOpt[0]){
    iter++;
    if(TMath::Abs(pdgdaughters[0])==211) {
      vars[iter]=dd->InvMassD0();
    } else {
      vars[iter]=dd->InvMassD0bar();
    }
  }
  if(fVarsForOpt[1]){
    iter++;
    vars[iter]=dd->GetDCA();
  }
  if(fVarsForOpt[2]){
    iter++;
    if(TMath::Abs(pdgdaughters[0])==211) {
      vars[iter] = dd->CosThetaStarD0();
    } else {
      vars[iter] = dd->CosThetaStarD0bar();
    }
  }
  if(fVarsForOpt[3]){
    iter++;
   if(TMath::Abs(pdgdaughters[0])==321) {
     vars[iter]=dd->PtProng(0);
   }
   else{
     vars[iter]=dd->PtProng(1);
   }
  }
  if(fVarsForOpt[4]){
    iter++;
   if(TMath::Abs(pdgdaughters[0])==211) {
     vars[iter]=dd->PtProng(0);
   }
   else{
     vars[iter]=dd->PtProng(1);
   }
  }
  if(fVarsForOpt[5]){
    iter++;
    if(TMath::Abs(pdgdaughters[0])==321) {
     vars[iter]=dd->Getd0Prong(0);
   }
   else{
     vars[iter]=dd->Getd0Prong(1);
   }
  }
  if(fVarsForOpt[6]){
    iter++;
     if(TMath::Abs(pdgdaughters[0])==211) {
     vars[iter]=dd->Getd0Prong(0);
   }
   else{
     vars[iter]=dd->Getd0Prong(1);
   }
  }
  if(fVarsForOpt[7]){
    iter++;
    vars[iter]= dd->Prodd0d0();
  }
  if(fVarsForOpt[8]){
    iter++;
    vars[iter]=dd->CosPointingAngle();
  }
  if(fVarsForOpt[9]){
    iter++;
    vars[iter]=dstarD0pi->InvMassDstarKpipi();
  }
  if(fVarsForOpt[10]){
    iter++;
    vars[iter]=dstarD0pi->DeltaInvMass();
  }
  if(fVarsForOpt[11]){
    iter++;
    vars[iter] = softPi->Pt();
  }
  if(fVarsForOpt[12]){
    iter++;
    vars[iter] = softPi->Pt();
  }
  if(fVarsForOpt[13]){
    iter++;
    vars[iter] =dstarD0pi->AngleD0dkpPisoft();
  }
 
  return;
}
//---------------------------------------------------------------------------
Int_t AliRDHFCutsDStartoKpipi::IsSelected(TObject* obj,Int_t selectionLevel) {
  //
  // Apply selection for D*.
  //
  if(!fCutsRD){
    cout<<"Cut matrice not inizialized. Exit..."<<endl;
    return 0;
  }
  
  AliAODRecoCascadeHF* d = (AliAODRecoCascadeHF*)obj;
  if(!d){
    cout<<"AliAODRecoCascadeHF null"<<endl;
    return 0;
  }
  
  AliAODRecoDecayHF2Prong* dd = (AliAODRecoDecayHF2Prong*)d->Get2Prong();  
  if(!dd){
    cout<<"AliAODRecoDecayHF2Prong null"<<endl;
    return 0;
  }

  AliAODTrack *b = (AliAODTrack*)d->GetBachelor();

  // selection on daughter tracks 
  if(selectionLevel==AliRDHFCuts::kAll || 
     selectionLevel==AliRDHFCuts::kTracks) {
    if(!AreDaughtersSelected(d)) return 0;
  }
  
  Int_t returnvalue=1;
  
  // selection on candidate
  if(selectionLevel==AliRDHFCuts::kAll || 
     selectionLevel==AliRDHFCuts::kCandidate) {
    
    Double_t pt=d->Pt();
    Int_t ptbin=PtBin(pt);

    // select D0 that passes D* cuts
    returnvalue = IsD0FromDStarSelected(pt,dd,selectionLevel);

    // DStarMass and D0mass
    Double_t mDSPDG = TDatabasePDG::Instance()->GetParticle(413)->Mass();
    Double_t mD0PDG = TDatabasePDG::Instance()->GetParticle(421)->Mass();
    // delta mass PDG
    Double_t deltaPDG = mDSPDG-mD0PDG;
    
    Double_t mD0,mD0bar;
  
    Int_t okDStarP =0;
    Int_t okDStarM =0;
   
    okDStarP=1; okDStarM=1; 

    dd->InvMassD0(mD0,mD0bar);
    // Half width DStar mass
    if(TMath::Abs((d->InvMassDstarKpipi()-mDSPDG))>fCutsRD[GetGlobalIndex(9,ptbin)]) return 0;
    // Half width Delta mass
    
    if(TMath::Abs((d->InvMassDstarKpipi()-mD0)-deltaPDG) > fCutsRD[GetGlobalIndex(10,ptbin)]) okDStarP =0;
    if(TMath::Abs((d->InvMassDstarKpipi()-mD0bar)-deltaPDG) > fCutsRD[GetGlobalIndex(10,ptbin)]) okDStarM =0;
    if(!okDStarP && !okDStarM) return 0;
    
    // cut on soft pion pt
    if(b->Pt() < fCutsRD[GetGlobalIndex(11,ptbin)] || b->Pt() > fCutsRD[GetGlobalIndex(12,ptbin)]) return 0;
    // cut on the angle between D0 decay plane and soft pion
    if(d->AngleD0dkpPisoft() > fCutsRD[GetGlobalIndex(13,ptbin)]) return 0;
  
  }

  return returnvalue;
}
//_________________________________________________________________________________________________
Int_t AliRDHFCutsDStartoKpipi::IsD0FromDStarSelected(Double_t pt, TObject* obj,Int_t selectionLevel) {
  //
  // Apply selection for D0 from D*. The selection in on D0 prongs
  //
  
  if(!fCutsRD){
    cout<<"Cut matrice not inizialized. Exit..."<<endl;
    return 0;
  }
  
  AliAODRecoDecayHF2Prong* dd = (AliAODRecoDecayHF2Prong*)obj;
  
  if(!dd){
    cout<<"AliAODRecoDecayHF2Prong null"<<endl;
    return 0;
  }

  // selection on daughter tracks 
  if(selectionLevel==AliRDHFCuts::kAll || 
     selectionLevel==AliRDHFCuts::kTracks) {
    if(!AreDaughtersSelected(dd)) return 0;
  }
  
  Int_t returnvalue=1;
  
  // selection on candidate
  if(selectionLevel==AliRDHFCuts::kAll || 
     selectionLevel==AliRDHFCuts::kCandidate) {
    
    // D0 mass
    Double_t mD0PDG = TDatabasePDG::Instance()->GetParticle(421)->Mass();
    // delta mass PDG
 
    Int_t ptbin=PtBin(pt);
    
    Double_t mD0,mD0bar,ctsD0,ctsD0bar;
  
    Int_t okD0     =0;
    Int_t okD0bar  =0;
    okD0=1; okD0bar=1;

    if(dd->PtProng(1) < fCutsRD[GetGlobalIndex(3,ptbin)] || dd->PtProng(0) < fCutsRD[GetGlobalIndex(4,ptbin)]) okD0 = 0;
    if(dd->PtProng(0) < fCutsRD[GetGlobalIndex(3,ptbin)] || dd->PtProng(1) < fCutsRD[GetGlobalIndex(4,ptbin)]) okD0bar = 0;
    
    if(!okD0 && !okD0bar) return 0;
    
    if(TMath::Abs(dd->Getd0Prong(1)) > fCutsRD[GetGlobalIndex(5,ptbin)] || 
       TMath::Abs(dd->Getd0Prong(0)) > fCutsRD[GetGlobalIndex(6,ptbin)]) okD0 = 0;
    if(TMath::Abs(dd->Getd0Prong(0)) > fCutsRD[GetGlobalIndex(6,ptbin)] ||
       TMath::Abs(dd->Getd0Prong(1)) > fCutsRD[GetGlobalIndex(5,ptbin)]) okD0bar = 0;
    if(!okD0 && !okD0bar) return 0;
    
    if(dd->GetDCA() > fCutsRD[GetGlobalIndex(1,ptbin)]) return 0;
    
    dd->InvMassD0(mD0,mD0bar);
    if(TMath::Abs(mD0-mD0PDG) > fCutsRD[GetGlobalIndex(0,ptbin)]) okD0 = 0;
    if(TMath::Abs(mD0bar-mD0PDG) > fCutsRD[GetGlobalIndex(0,ptbin)]) okD0bar = 0;
    if(!okD0 && !okD0bar) return 0;
    
    dd->CosThetaStarD0(ctsD0,ctsD0bar);
    if(TMath::Abs(ctsD0) > fCutsRD[GetGlobalIndex(2,ptbin)]) okD0 = 0;
    if(TMath::Abs(ctsD0bar) > fCutsRD[GetGlobalIndex(2,ptbin)]) okD0bar = 0;
    if(!okD0 && !okD0bar) return 0;
    
    if(dd->Prodd0d0() > fCutsRD[GetGlobalIndex(7,ptbin)]) return 0;
    
    if(dd->CosPointingAngle() < fCutsRD[GetGlobalIndex(8,ptbin)]) return 0;

    if (okD0) returnvalue=1; //cuts passed as D0
    if (okD0bar) returnvalue=2; //cuts passed as D0bar
    if (okD0 && okD0bar) returnvalue=3; //both
  }

  return returnvalue;
}
Commit	Line	Data
45bc9115	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	/////////////////////////////////////////////////////////////
	17	//
	18	// Class for cuts on AOD reconstructed DStar->Kpipi
	19	//
	20	// Author: A.Grelli, alessandro.grelli@uu.nl
	21	/////////////////////////////////////////////////////////////
	22
	23	#include <TDatabasePDG.h>
	24	#include <Riostream.h>
	25
	26	#include "AliAODRecoDecayHF2Prong.h"
	27	#include "AliAODRecoCascadeHF.h"
	28	#include "AliRDHFCutsD0toKpi.h"
	29	#include "AliRDHFCutsDStartoKpipi.h"
	30	#include "AliAODTrack.h"
	31	#include "AliESDtrack.h"
	32
	33	ClassImp(AliRDHFCutsDStartoKpipi)
	34
	35	//--------------------------------------------------------------------------
	36	AliRDHFCutsDStartoKpipi::AliRDHFCutsDStartoKpipi() :
	37	AliRDHFCuts()
	38	{
	39	//
	40	// Default Constructor
	41	//
	42
	43	Int_t nvars=14;
	44	SetNVars(nvars);
	45	TString varNames[14]={
	46	"inv. mass [GeV]",
	47	"dca [cm]",
	48	"cosThetaStar",
	49	"pTK [GeV/c]",
	50	"pTPi [GeV/c]",
	51	"d0K [cm]",
	52	"d0Pi [cm]",
	53	"d0d0 [cm^2]",
	54	"cosThetaPoint",
	55	"inv. mass half width of D* [GeV]",
	56	"half width of (M_Kpipi-M_D0) [GeV]",
	57	"PtMin of pi_s [GeV/c]",
	58	"PtMax of pi_s [GeV/c]",
	59	"theta, angle between the pi_s and decay plane of the D0 [rad]"};
	60	Bool_t isUpperCut[14]={
	61	kTRUE,
	62	kTRUE,
	63	kTRUE,
	64	kFALSE,
65	kFALSE,
66	kTRUE,
67	kTRUE,
68	kTRUE,
69	kFALSE,
70	kTRUE,
71	kTRUE,
72	kTRUE,
73	kTRUE,
74	kFALSE};
75	SetVarNames(nvars,varNames,isUpperCut);
76	Bool_t forOpt[14]={
77	kFALSE,
78	kTRUE,
79	kTRUE,
80	kFALSE,
81	kFALSE,
82	kFALSE,
83	kFALSE,
84	kTRUE,
85	kTRUE,
86	kFALSE,
87	kTRUE,
88	kFALSE,
89	kFALSE,
90	kFALSE};
91	SetVarsForOpt(5,forOpt);
92	Float_t limits[2]={0,999999999.};
93	SetPtBins(2,limits);
94	}
95	//--------------------------------------------------------------------------
96	AliRDHFCutsDStartoKpipi::AliRDHFCutsDStartoKpipi(const AliRDHFCutsDStartoKpipi &source) :
97	AliRDHFCuts(source)
98	{
99	//
100	// Copy constructor
101	//
102
103	}
104	//--------------------------------------------------------------------------
105	AliRDHFCutsDStartoKpipi &AliRDHFCutsDStartoKpipi::operator=(const AliRDHFCutsDStartoKpipi &source)
106	{
107	//
108	// assignment operator
109	//
110	if(&source == this) return *this;
111
112	AliRDHFCuts::operator=(source);
113
114	return *this;
115	}
116
117
118	//---------------------------------------------------------------------------
119	void AliRDHFCutsDStartoKpipi::GetCutVarsForOpt(AliAODRecoDecayHF d,Float_t vars,Int_t nvars,Int_t *pdgdaughters) {
120	//
121	// Fills in vars the values of the variables
122	//
123	if(nvars!=fnVarsForOpt) {
124	printf("AliRDHFCutsDStartoKpipi::GetCutsVarsForOpt: wrong number of variables\n");
125	return;
126	}
127
128
129	AliAODRecoCascadeHF* dstarD0pi = (AliAODRecoCascadeHF*)d;
130
131	AliAODTrack softPi = (AliAODTrack)dstarD0pi->GetBachelor();
132
133	AliAODRecoDecayHF2Prong* dd = (AliAODRecoDecayHF2Prong*)dstarD0pi->Get2Prong();
134
135	Int_t iter=-1;
136	if(fVarsForOpt[0]){
137	iter++;
138	if(TMath::Abs(pdgdaughters[0])==211) {
139	vars[iter]=dd->InvMassD0();
140	} else {
141	vars[iter]=dd->InvMassD0bar();
142	}
143	}
144	if(fVarsForOpt[1]){
145	iter++;
146	vars[iter]=dd->GetDCA();
147	}
148	if(fVarsForOpt[2]){
149	iter++;
150	if(TMath::Abs(pdgdaughters[0])==211) {
151	vars[iter] = dd->CosThetaStarD0();
152	} else {
153	vars[iter] = dd->CosThetaStarD0bar();
154	}
155	}
156	if(fVarsForOpt[3]){
157	iter++;
158	if(TMath::Abs(pdgdaughters[0])==321) {
159	vars[iter]=dd->PtProng(0);
160	}
161	else{
162	vars[iter]=dd->PtProng(1);
163	}
164	}
165	if(fVarsForOpt[4]){
166	iter++;
167	if(TMath::Abs(pdgdaughters[0])==211) {
168	vars[iter]=dd->PtProng(0);
169	}
170	else{
171	vars[iter]=dd->PtProng(1);
172	}
173	}
174	if(fVarsForOpt[5]){
175	iter++;
176	if(TMath::Abs(pdgdaughters[0])==321) {
177	vars[iter]=dd->Getd0Prong(0);
178	}
179	else{
180	vars[iter]=dd->Getd0Prong(1);
181	}
182	}
183	if(fVarsForOpt[6]){
184	iter++;
185	if(TMath::Abs(pdgdaughters[0])==211) {
186	vars[iter]=dd->Getd0Prong(0);
187	}
188	else{
189	vars[iter]=dd->Getd0Prong(1);
190	}
191	}
192	if(fVarsForOpt[7]){
193	iter++;
194	vars[iter]= dd->Prodd0d0();
195	}
196	if(fVarsForOpt[8]){
197	iter++;
198	vars[iter]=dd->CosPointingAngle();
199	}
200	if(fVarsForOpt[9]){
201	iter++;
202	vars[iter]=dstarD0pi->InvMassDstarKpipi();
203	}
204	if(fVarsForOpt[10]){
205	iter++;
206	vars[iter]=dstarD0pi->DeltaInvMass();
207	}
208	if(fVarsForOpt[11]){
209	iter++;
210	vars[iter] = softPi->Pt();
211	}
212	if(fVarsForOpt[12]){
213	iter++;
214	vars[iter] = softPi->Pt();
215	}
216	if(fVarsForOpt[13]){
217	iter++;
218	vars[iter] =dstarD0pi->AngleD0dkpPisoft();
219	}
220
221	return;
222	}
223	//---------------------------------------------------------------------------
224	Int_t AliRDHFCutsDStartoKpipi::IsSelected(TObject* obj,Int_t selectionLevel) {
225	//
226	// Apply selection for D*.
227	//
228	if(!fCutsRD){
229	cout<<"Cut matrice not inizialized. Exit..."<<endl;
230	return 0;
231	}
232
233	AliAODRecoCascadeHF* d = (AliAODRecoCascadeHF*)obj;
234	if(!d){
235	cout<<"AliAODRecoCascadeHF null"<<endl;
236	return 0;
237	}
238
239	AliAODRecoDecayHF2Prong* dd = (AliAODRecoDecayHF2Prong*)d->Get2Prong();
240	if(!dd){
241	cout<<"AliAODRecoDecayHF2Prong null"<<endl;
242	return 0;
243	}
244
245	AliAODTrack b = (AliAODTrack)d->GetBachelor();
246
247	// selection on daughter tracks
248	if(selectionLevel==AliRDHFCuts::kAll \|\|
249	selectionLevel==AliRDHFCuts::kTracks) {
250	if(!AreDaughtersSelected(d)) return 0;
251	}
252
253	Int_t returnvalue=1;
254
255	// selection on candidate
256	if(selectionLevel==AliRDHFCuts::kAll \|\|
257	selectionLevel==AliRDHFCuts::kCandidate) {
258
259	Double_t pt=d->Pt();
260	Int_t ptbin=PtBin(pt);
261
262	// select D0 that passes D* cuts
263	returnvalue = IsD0FromDStarSelected(pt,dd,selectionLevel);
264
265	// DStarMass and D0mass
266	Double_t mDSPDG = TDatabasePDG::Instance()->GetParticle(413)->Mass();
267	Double_t mD0PDG = TDatabasePDG::Instance()->GetParticle(421)->Mass();
268	// delta mass PDG
269	Double_t deltaPDG = mDSPDG-mD0PDG;
270
271	Double_t mD0,mD0bar;
272
273	Int_t okDStarP =0;
274	Int_t okDStarM =0;
275
276	okDStarP=1; okDStarM=1;
277
278	dd->InvMassD0(mD0,mD0bar);
279	// Half width DStar mass
280	if(TMath::Abs((d->InvMassDstarKpipi()-mDSPDG))>fCutsRD[GetGlobalIndex(9,ptbin)]) return 0;
281	// Half width Delta mass
282
283	if(TMath::Abs((d->InvMassDstarKpipi()-mD0)-deltaPDG) > fCutsRD[GetGlobalIndex(10,ptbin)]) okDStarP =0;
284	if(TMath::Abs((d->InvMassDstarKpipi()-mD0bar)-deltaPDG) > fCutsRD[GetGlobalIndex(10,ptbin)]) okDStarM =0;
285	if(!okDStarP && !okDStarM) return 0;
286
287	// cut on soft pion pt
288	if(b->Pt() < fCutsRD[GetGlobalIndex(11,ptbin)] \|\| b->Pt() > fCutsRD[GetGlobalIndex(12,ptbin)]) return 0;
289	// cut on the angle between D0 decay plane and soft pion
290	if(d->AngleD0dkpPisoft() > fCutsRD[GetGlobalIndex(13,ptbin)]) return 0;
291
292	}
293
294	return returnvalue;
295	}
296	//_________________________________________________________________________________________________
297	Int_t AliRDHFCutsDStartoKpipi::IsD0FromDStarSelected(Double_t pt, TObject* obj,Int_t selectionLevel) {
298	//
299	// Apply selection for D0 from D*. The selection in on D0 prongs
300	//
301
302	if(!fCutsRD){
303	cout<<"Cut matrice not inizialized. Exit..."<<endl;
304	return 0;
305	}
306
307	AliAODRecoDecayHF2Prong* dd = (AliAODRecoDecayHF2Prong*)obj;
308
309	if(!dd){
310	cout<<"AliAODRecoDecayHF2Prong null"<<endl;
311	return 0;
312	}
313
314	// selection on daughter tracks
315	if(selectionLevel==AliRDHFCuts::kAll \|\|
316	selectionLevel==AliRDHFCuts::kTracks) {
317	if(!AreDaughtersSelected(dd)) return 0;
318	}
319
320	Int_t returnvalue=1;
321
322	// selection on candidate
323	if(selectionLevel==AliRDHFCuts::kAll \|\|
324	selectionLevel==AliRDHFCuts::kCandidate) {
325
326	// D0 mass
327	Double_t mD0PDG = TDatabasePDG::Instance()->GetParticle(421)->Mass();
328	// delta mass PDG
329
330	Int_t ptbin=PtBin(pt);
331
332	Double_t mD0,mD0bar,ctsD0,ctsD0bar;
333
334	Int_t okD0 =0;
335	Int_t okD0bar =0;
336	okD0=1; okD0bar=1;
337
338	if(dd->PtProng(1) < fCutsRD[GetGlobalIndex(3,ptbin)] \|\| dd->PtProng(0) < fCutsRD[GetGlobalIndex(4,ptbin)]) okD0 = 0;
339	if(dd->PtProng(0) < fCutsRD[GetGlobalIndex(3,ptbin)] \|\| dd->PtProng(1) < fCutsRD[GetGlobalIndex(4,ptbin)]) okD0bar = 0;
340
341	if(!okD0 && !okD0bar) return 0;
342
343	if(TMath::Abs(dd->Getd0Prong(1)) > fCutsRD[GetGlobalIndex(5,ptbin)] \|\|
344	TMath::Abs(dd->Getd0Prong(0)) > fCutsRD[GetGlobalIndex(6,ptbin)]) okD0 = 0;
345	if(TMath::Abs(dd->Getd0Prong(0)) > fCutsRD[GetGlobalIndex(6,ptbin)] \|\|
346	TMath::Abs(dd->Getd0Prong(1)) > fCutsRD[GetGlobalIndex(5,ptbin)]) okD0bar = 0;
347	if(!okD0 && !okD0bar) return 0;
348
349	if(dd->GetDCA() > fCutsRD[GetGlobalIndex(1,ptbin)]) return 0;
350
351	dd->InvMassD0(mD0,mD0bar);
352	if(TMath::Abs(mD0-mD0PDG) > fCutsRD[GetGlobalIndex(0,ptbin)]) okD0 = 0;
353	if(TMath::Abs(mD0bar-mD0PDG) > fCutsRD[GetGlobalIndex(0,ptbin)]) okD0bar = 0;
354	if(!okD0 && !okD0bar) return 0;
355
356	dd->CosThetaStarD0(ctsD0,ctsD0bar);
357	if(TMath::Abs(ctsD0) > fCutsRD[GetGlobalIndex(2,ptbin)]) okD0 = 0;
358	if(TMath::Abs(ctsD0bar) > fCutsRD[GetGlobalIndex(2,ptbin)]) okD0bar = 0;
359	if(!okD0 && !okD0bar) return 0;
360
361	if(dd->Prodd0d0() > fCutsRD[GetGlobalIndex(7,ptbin)]) return 0;
362
363	if(dd->CosPointingAngle() < fCutsRD[GetGlobalIndex(8,ptbin)]) return 0;
364
365	if (okD0) returnvalue=1; //cuts passed as D0
366	if (okD0bar) returnvalue=2; //cuts passed as D0bar
367	if (okD0 && okD0bar) returnvalue=3; //both
368	}
369
370	return returnvalue;
371	}
372
373