[u/mrichter/AliRoot.git] / PWG3 / vertexingHF / AliRDHFCutsDstoKKpi.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 Ds->KKpi
//
// Author: A.Dainese, andrea.dainese@pd.infn.it
/////////////////////////////////////////////////////////////

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

#include "AliRDHFCutsDstoKKpi.h"
#include "AliAODRecoDecayHF3Prong.h"
#include "AliAODTrack.h"
#include "AliESDtrack.h"

ClassImp(AliRDHFCutsDstoKKpi)

//--------------------------------------------------------------------------
AliRDHFCutsDstoKKpi::AliRDHFCutsDstoKKpi(const char* name) : 
AliRDHFCuts(name)
{
  //
  // Default Constructor
  //
  Int_t nvars=14;
  SetNVars(nvars);
  TString varNames[14]={"inv. mass [GeV]",   
			"pTK [GeV/c]",
			"pTPi [GeV/c]",
			"d0K [cm]",
			"d0Pi [cm]",
			"dist12 [cm]",
			"sigmavert [cm]",
			"decLen [cm]",
			"ptMax [GeV/c]",
			"cosThetaPoint",
			"Sum d0^2 (cm^2)",
			"dca [cm]",
			"inv. mass (Mphi-MKK) [GeV]",
			"inv. mass (MKo*-MKpi) [GeV]"};
  Bool_t isUpperCut[14]={kTRUE,
			 kFALSE,
			 kFALSE,
			 kFALSE,
			 kFALSE,
			 kFALSE,
			 kTRUE,
			 kFALSE,
			 kFALSE,
			 kFALSE,
			 kFALSE,
			 kTRUE,
			 kTRUE,
			 kTRUE};
  SetVarNames(14,varNames,isUpperCut);
  Bool_t forOpt[14]={kFALSE,
		    kFALSE,
		    kFALSE,
		    kFALSE,
		    kFALSE,
		    kFALSE,
		    kTRUE,
		    kTRUE,
		    kTRUE,
		    kTRUE,
		    kTRUE,
		    kFALSE,
		    kTRUE,
		    kTRUE};
  SetVarsForOpt(7,forOpt);
  Float_t limits[2]={0,999999999.};
  SetPtBins(2,limits);
}
//--------------------------------------------------------------------------
AliRDHFCutsDstoKKpi::AliRDHFCutsDstoKKpi(const AliRDHFCutsDstoKKpi &source) :
  AliRDHFCuts(source)
{
  //
  // Copy constructor
  //

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

  AliRDHFCuts::operator=(source);

  return *this;
}


//---------------------------------------------------------------------------
void AliRDHFCutsDstoKKpi::GetCutVarsForOpt(AliAODRecoDecayHF *d,Float_t *vars,Int_t nvars,Int_t *pdgdaughters) {
  // 
  // Fills in vars the values of the variables 
  //

  if(nvars!=fnVarsForOpt) {
    printf("AliRDHFCutsDstoKKpi::GetCutsVarsForOpt: wrong number of variables\n");
    return;
  }

  AliAODRecoDecayHF3Prong *dd = (AliAODRecoDecayHF3Prong*)d;
 
  Int_t iter=-1;
  if(fVarsForOpt[0]){
    iter++;
    if(TMath::Abs(pdgdaughters[0]==321)){
      vars[iter]=dd->InvMassDsKKpi();
    }else{
      vars[iter]=dd->InvMassDspiKK();
    }
  }
  if(fVarsForOpt[1]){
    iter++;
    Float_t minPtDau=99999.;
    for(Int_t iprong=0;iprong<3;iprong++){
      if(TMath::Abs(pdgdaughters[iprong])==321 && 
	 dd->PtProng(iprong)<minPtDau) minPtDau=dd->PtProng(iprong);
    }
    vars[iter]=minPtDau;
  }
  if(fVarsForOpt[2]){
    iter++;
    for(Int_t iprong=0;iprong<3;iprong++){
      if(TMath::Abs(pdgdaughters[iprong])==211) {
	vars[iter]=dd->PtProng(iprong);
      }
    }
  }
  if(fVarsForOpt[3]){
    iter++;
    Float_t minImpParDau=99999.;
    for(Int_t iprong=0;iprong<3;iprong++){
      if(TMath::Abs(pdgdaughters[iprong])==321 &&
	 dd->Getd0Prong(iprong)<minImpParDau) minImpParDau=dd->Getd0Prong(iprong);
    }
    vars[iter]=minImpParDau;
  }
  if(fVarsForOpt[4]){
    iter++;
    for(Int_t iprong=0;iprong<3;iprong++){
      if(TMath::Abs(pdgdaughters[iprong])==211) {
	vars[iter]=dd->Getd0Prong(iprong);
      }
    }
  }
  if(fVarsForOpt[5]){
    iter++;
    Float_t minDistPair=TMath::Min(dd->GetDist12toPrim(),dd->GetDist23toPrim());
    vars[iter]=minDistPair;
  }
  if(fVarsForOpt[6]){
    iter++;
    vars[iter]=dd->GetSigmaVert();
  }
  if(fVarsForOpt[7]){
    iter++;
    vars[iter] = dd->DecayLength();
  }
  if(fVarsForOpt[8]){
    iter++;
    Float_t ptmax=0;
    for(Int_t i=0;i<3;i++){
      if(dd->PtProng(i)>ptmax)ptmax=dd->PtProng(i);
    }
    vars[iter]=ptmax;
  }
  if(fVarsForOpt[9]){
    iter++;
    vars[iter]=dd->CosPointingAngle();
  }
  if(fVarsForOpt[10]){
    iter++;
    vars[iter]=dd->Getd0Prong(0)*dd->Getd0Prong(0)+dd->Getd0Prong(1)*dd->Getd0Prong(1)+dd->Getd0Prong(2)*dd->Getd0Prong(2);
  }
  if(fVarsForOpt[11]){
    iter++;
    Float_t maxDCA=0.;
    for(Int_t i=0;i<3;i++){ 
      if(d->GetDCA(i)>maxDCA) maxDCA=d->GetDCA(i);
    }
    vars[iter]=maxDCA;
  }
  if(fVarsForOpt[12]){
    iter++;
    Double_t mPDGPhi = TDatabasePDG::Instance()->GetParticle(333)->Mass();
    if(TMath::Abs(pdgdaughters[0]==321)){
      
      Double_t phimass01=d->InvMass2Prongs(0,1,321,321);
       vars[iter]=TMath::Abs(phimass01-mPDGPhi);
       // vars[iter]=dd->InvMass2Prongs(0,1,321,321);
    }else{
      Double_t phimass12=d->InvMass2Prongs(1,2,321,321);
       vars[iter]=TMath::Abs(phimass12-mPDGPhi);
       // vars[iter]=dd->InvMass2Prongs(1,2,321,321);      
    }
  }
  if(fVarsForOpt[13]){
    iter++;
    Double_t mPDGK0star = TDatabasePDG::Instance()->GetParticle(313)->Mass();
    if(TMath::Abs(pdgdaughters[0]==321)){
      
      Double_t mass12kpi=d->InvMass2Prongs(1,2,321,211);
      vars[iter]=TMath::Abs(mass12kpi-mPDGK0star);
      //	      vars[iter]=dd->InvMass2Prongs(1,2,321,211);
    }else{
      Double_t mass01pik=d->InvMass2Prongs(0,1,211,321);
      vars[iter]=TMath::Abs(mass01pik-mPDGK0star);
      //	vars[iter]=dd->InvMass2Prongs(0,1,211,321);      
    }
  }

  
  return;
}
//---------------------------------------------------------------------------
Int_t AliRDHFCutsDstoKKpi::IsSelected(TObject* obj,Int_t selectionLevel) {
  //
  // Apply selection
  //

  if(!fCutsRD){
    cout<<"Cut matrice not inizialized. Exit..."<<endl;
    return 0;
  }
  //PrintAll();
  AliAODRecoDecayHF3Prong* d=(AliAODRecoDecayHF3Prong*)obj;

  if(!d){
    cout<<"AliAODRecoDecayHF3Prong null"<<endl;
    return 0;
  }


  // 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) {
    

    Int_t okDsKKpi=1;
    Int_t okDspiKK=1;
    Int_t okMassPhi=0;
    Int_t okMassK0star=0;

    Double_t pt=d->Pt();
    Int_t ptbin=PtBin(pt);

    Double_t mDsPDG = TDatabasePDG::Instance()->GetParticle(431)->Mass();
    Double_t mDsKKpi=d->InvMassDsKKpi();
    Double_t mDspiKK=d->InvMassDspiKK();
    if(TMath::Abs(mDsKKpi-mDsPDG)>fCutsRD[GetGlobalIndex(0,ptbin)]) okDsKKpi = 0;
    if(TMath::Abs(mDspiKK-mDsPDG)>fCutsRD[GetGlobalIndex(0,ptbin)]) okDspiKK = 0;
    if(!okDsKKpi && !okDspiKK) return 0;

    //single track
    if(TMath::Abs(d->PtProng(1)) < fCutsRD[GetGlobalIndex(1,ptbin)] || 
       TMath::Abs(d->Getd0Prong(1))<fCutsRD[GetGlobalIndex(3,ptbin)]) return 0;
    if(okDsKKpi){
      if(TMath::Abs(d->PtProng(0)) < fCutsRD[GetGlobalIndex(1,ptbin)] || 
	 TMath::Abs(d->Getd0Prong(0))<fCutsRD[GetGlobalIndex(3,ptbin)]) okDsKKpi=0;
      if(TMath::Abs(d->PtProng(2)) < fCutsRD[GetGlobalIndex(2,ptbin)] || 
	 TMath::Abs(d->Getd0Prong(2))<fCutsRD[GetGlobalIndex(4,ptbin)]) okDsKKpi=0;
    }
    if(okDspiKK){
      if(TMath::Abs(d->PtProng(0)) < fCutsRD[GetGlobalIndex(2,ptbin)] || 
	 TMath::Abs(d->Getd0Prong(0))<fCutsRD[GetGlobalIndex(4,ptbin)]) okDspiKK=0;
      if(TMath::Abs(d->PtProng(2)) < fCutsRD[GetGlobalIndex(1,ptbin)] || 
	 TMath::Abs(d->Getd0Prong(2))<fCutsRD[GetGlobalIndex(3,ptbin)]) okDspiKK=0;
    }
    if(!okDsKKpi && !okDspiKK) return 0;

    // cuts on resonant decays (via Phi or K0*)
    Double_t mPhiPDG = TDatabasePDG::Instance()->GetParticle(333)->Mass();
    Double_t mK0starPDG = TDatabasePDG::Instance()->GetParticle(313)->Mass();
    if(okDsKKpi){
      Double_t mass01phi=d->InvMass2Prongs(0,1,321,321);
      Double_t mass12K0s=d->InvMass2Prongs(1,2,321,211);
      if(TMath::Abs(mass01phi-mPhiPDG)<fCutsRD[GetGlobalIndex(12,ptbin)]) okMassPhi=1;
      if(TMath::Abs(mass12K0s-mK0starPDG)<fCutsRD[GetGlobalIndex(13,ptbin)]) okMassK0star = 1;
      if(!okMassPhi && !okMassK0star) okDsKKpi=0;
    }
    if(okDspiKK){
      Double_t mass01K0s=d->InvMass2Prongs(0,1,211,321);
      Double_t mass12phi=d->InvMass2Prongs(1,2,321,321);
      if(TMath::Abs(mass01K0s-mK0starPDG)<fCutsRD[GetGlobalIndex(13,ptbin)]) okMassK0star = 1;
      if(TMath::Abs(mass12phi-mPhiPDG)<fCutsRD[GetGlobalIndex(12,ptbin)]) okMassPhi=1;
      if(!okMassPhi && !okMassK0star) okDspiKK=0;
    }
    if(!okDsKKpi && !okDspiKK) return 0;

    // Cuts on track pairs
    for(Int_t i=0;i<3;i++) if(d->GetDCA(i)>fCutsRD[GetGlobalIndex(11,ptbin)])  return 0;
    if(d->GetDist12toPrim()<fCutsRD[GetGlobalIndex(5,ptbin)] || 
       d->GetDist23toPrim()<fCutsRD[GetGlobalIndex(5,ptbin)]) return 0;


    // Cuts on candidate triplet
    if(d->GetSigmaVert()>fCutsRD[GetGlobalIndex(6,ptbin)]) return 0;
    if(d->DecayLength()<fCutsRD[GetGlobalIndex(7,ptbin)]) return 0;
    if(TMath::Abs(d->PtProng(0))<fCutsRD[GetGlobalIndex(8,ptbin)] && 
       TMath::Abs(d->PtProng(1))<fCutsRD[GetGlobalIndex(8,ptbin)] && 
       TMath::Abs(d->PtProng(2))<fCutsRD[GetGlobalIndex(8,ptbin)]) return 0;
    if(d->CosPointingAngle()< fCutsRD[GetGlobalIndex(9,ptbin)])return 0;
    Double_t sum2=d->Getd0Prong(0)*d->Getd0Prong(0)+d->Getd0Prong(1)*d->Getd0Prong(1)+d->Getd0Prong(2)*d->Getd0Prong(2);
    if(sum2<fCutsRD[GetGlobalIndex(10,ptbin)])return 0;

    returnvalue=0;
    if(okDsKKpi) returnvalue+=1;
    if(okDspiKK) returnvalue+=2;
    if(okMassPhi) returnvalue+=4;
    if(okMassK0star) returnvalue+=8;

  }
  return returnvalue;

}
//---------------------------------------------------------------------------
Commit	Line	Data
e3d40058	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 Ds->KKpi
	19	//
	20	// Author: A.Dainese, andrea.dainese@pd.infn.it
	21	/////////////////////////////////////////////////////////////
	22
	23	#include <TDatabasePDG.h>
	24	#include <Riostream.h>
	25
	26	#include "AliRDHFCutsDstoKKpi.h"
	27	#include "AliAODRecoDecayHF3Prong.h"
	28	#include "AliAODTrack.h"
	29	#include "AliESDtrack.h"
	30
	31	ClassImp(AliRDHFCutsDstoKKpi)
	32
	33	//--------------------------------------------------------------------------
a9b75906	34	AliRDHFCutsDstoKKpi::AliRDHFCutsDstoKKpi(const char* name) :
a9b75906	35	AliRDHFCuts(name)
e3d40058	36	{
	37	//
	38	// Default Constructor
	39	//
a9b75906	40	Int_t nvars=14;
e3d40058	41	SetNVars(nvars);
a9b75906	42	TString varNames[14]={"inv. mass [GeV]",
4755453e	43	"pTK [GeV/c]",
	44	"pTPi [GeV/c]",
	45	"d0K [cm]",
	46	"d0Pi [cm]",
	47	"dist12 [cm]",
	48	"sigmavert [cm]",
	49	"decLen [cm]",
	50	"ptMax [GeV/c]",
	51	"cosThetaPoint",
	52	"Sum d0^2 (cm^2)",
	53	"dca [cm]",
	54	"inv. mass (Mphi-MKK) [GeV]",
a9b75906	55	"inv. mass (MKo*-MKpi) [GeV]"};
a9b75906	56	Bool_t isUpperCut[14]={kTRUE,
4755453e	57	kFALSE,
	58	kFALSE,
	59	kFALSE,
	60	kFALSE,
	61	kFALSE,
	62	kTRUE,
	63	kFALSE,
	64	kFALSE,
	65	kFALSE,
	66	kFALSE,
	67	kTRUE,
	68	kTRUE,
	69	kTRUE};
a9b75906	70	SetVarNames(14,varNames,isUpperCut);
a9b75906	71	Bool_t forOpt[14]={kFALSE,
4755453e	72	kFALSE,
e3d40058	73	kFALSE,
	74	kFALSE,
	75	kFALSE,
	76	kFALSE,
	77	kTRUE,
4755453e	78	kTRUE,
	79	kTRUE,
	80	kTRUE,
	81	kTRUE,
	82	kFALSE,
	83	kTRUE,
e3d40058	84	kTRUE};
4755453e	85	SetVarsForOpt(7,forOpt);
e3d40058	86	Float_t limits[2]={0,999999999.};
	87	SetPtBins(2,limits);
	88	}
	89	//--------------------------------------------------------------------------
	90	AliRDHFCutsDstoKKpi::AliRDHFCutsDstoKKpi(const AliRDHFCutsDstoKKpi &source) :
	91	AliRDHFCuts(source)
	92	{
	93	//
	94	// Copy constructor
	95	//
	96
	97	}
	98	//--------------------------------------------------------------------------
	99	AliRDHFCutsDstoKKpi &AliRDHFCutsDstoKKpi::operator=(const AliRDHFCutsDstoKKpi &source)
	100	{
	101	//
	102	// assignment operator
	103	//
	104	if(&source == this) return *this;
	105
	106	AliRDHFCuts::operator=(source);
	107
	108	return *this;
	109	}
	110
	111
	112	//---------------------------------------------------------------------------
	113	void AliRDHFCutsDstoKKpi::GetCutVarsForOpt(AliAODRecoDecayHF d,Float_t vars,Int_t nvars,Int_t *pdgdaughters) {
	114	//
	115	// Fills in vars the values of the variables
	116	//
	117
	118	if(nvars!=fnVarsForOpt) {
	119	printf("AliRDHFCutsDstoKKpi::GetCutsVarsForOpt: wrong number of variables\n");
	120	return;
	121	}
	122
	123	AliAODRecoDecayHF3Prong dd = (AliAODRecoDecayHF3Prong)d;
	124
4755453e	125	Int_t iter=-1;
	126	if(fVarsForOpt[0]){
	127	iter++;
	128	if(TMath::Abs(pdgdaughters[0]==321)){
	129	vars[iter]=dd->InvMassDsKKpi();
	130	}else{
	131	vars[iter]=dd->InvMassDspiKK();
	132	}
	133	}
	134	if(fVarsForOpt[1]){
	135	iter++;
	136	Float_t minPtDau=99999.;
	137	for(Int_t iprong=0;iprong<3;iprong++){
	138	if(TMath::Abs(pdgdaughters[iprong])==321 &&
	139	dd->PtProng(iprong)<minPtDau) minPtDau=dd->PtProng(iprong);
	140	}
	141	vars[iter]=minPtDau;
	142	}
	143	if(fVarsForOpt[2]){
	144	iter++;
	145	for(Int_t iprong=0;iprong<3;iprong++){
	146	if(TMath::Abs(pdgdaughters[iprong])==211) {
	147	vars[iter]=dd->PtProng(iprong);
	148	}
	149	}
	150	}
	151	if(fVarsForOpt[3]){
	152	iter++;
	153	Float_t minImpParDau=99999.;
	154	for(Int_t iprong=0;iprong<3;iprong++){
	155	if(TMath::Abs(pdgdaughters[iprong])==321 &&
	156	dd->Getd0Prong(iprong)<minImpParDau) minImpParDau=dd->Getd0Prong(iprong);
	157	}
	158	vars[iter]=minImpParDau;
	159	}
	160	if(fVarsForOpt[4]){
	161	iter++;
	162	for(Int_t iprong=0;iprong<3;iprong++){
	163	if(TMath::Abs(pdgdaughters[iprong])==211) {
	164	vars[iter]=dd->Getd0Prong(iprong);
	165	}
	166	}
	167	}
	168	if(fVarsForOpt[5]){
	169	iter++;
	170	Float_t minDistPair=TMath::Min(dd->GetDist12toPrim(),dd->GetDist23toPrim());
	171	vars[iter]=minDistPair;
	172	}
	173	if(fVarsForOpt[6]){
	174	iter++;
	175	vars[iter]=dd->GetSigmaVert();
	176	}
	177	if(fVarsForOpt[7]){
	178	iter++;
	179	vars[iter] = dd->DecayLength();
	180	}
	181	if(fVarsForOpt[8]){
	182	iter++;
	183	Float_t ptmax=0;
	184	for(Int_t i=0;i<3;i++){
	185	if(dd->PtProng(i)>ptmax)ptmax=dd->PtProng(i);
	186	}
	187	vars[iter]=ptmax;
	188	}
189	if(fVarsForOpt[9]){
190	iter++;
191	vars[iter]=dd->CosPointingAngle();
192	}
193	if(fVarsForOpt[10]){
194	iter++;
195	vars[iter]=dd->Getd0Prong(0)dd->Getd0Prong(0)+dd->Getd0Prong(1)dd->Getd0Prong(1)+dd->Getd0Prong(2)*dd->Getd0Prong(2);
196	}
197	if(fVarsForOpt[11]){
198	iter++;
199	Float_t maxDCA=0.;
200	for(Int_t i=0;i<3;i++){
201	if(d->GetDCA(i)>maxDCA) maxDCA=d->GetDCA(i);
202	}
203	vars[iter]=maxDCA;
204	}
205	if(fVarsForOpt[12]){
206	iter++;
2c3decce	207	Double_t mPDGPhi = TDatabasePDG::Instance()->GetParticle(333)->Mass();
4755453e	208	if(TMath::Abs(pdgdaughters[0]==321)){
2c3decce	209
	210	Double_t phimass01=d->InvMass2Prongs(0,1,321,321);
	211	vars[iter]=TMath::Abs(phimass01-mPDGPhi);
	212	// vars[iter]=dd->InvMass2Prongs(0,1,321,321);
4755453e	213	}else{
2c3decce	214	Double_t phimass12=d->InvMass2Prongs(1,2,321,321);
	215	vars[iter]=TMath::Abs(phimass12-mPDGPhi);
	216	// vars[iter]=dd->InvMass2Prongs(1,2,321,321);
4755453e	217	}
	218	}
	219	if(fVarsForOpt[13]){
	220	iter++;
2c3decce	221	Double_t mPDGK0star = TDatabasePDG::Instance()->GetParticle(313)->Mass();
4755453e	222	if(TMath::Abs(pdgdaughters[0]==321)){
2c3decce	223
	224	Double_t mass12kpi=d->InvMass2Prongs(1,2,321,211);
	225	vars[iter]=TMath::Abs(mass12kpi-mPDGK0star);
	226	// vars[iter]=dd->InvMass2Prongs(1,2,321,211);
4755453e	227	}else{
2c3decce	228	Double_t mass01pik=d->InvMass2Prongs(0,1,211,321);
	229	vars[iter]=TMath::Abs(mass01pik-mPDGK0star);
	230	// vars[iter]=dd->InvMass2Prongs(0,1,211,321);
4755453e	231	}
	232	}
	233
e3d40058	234
	235	return;
	236	}
	237	//---------------------------------------------------------------------------
	238	Int_t AliRDHFCutsDstoKKpi::IsSelected(TObject* obj,Int_t selectionLevel) {
	239	//
	240	// Apply selection
	241	//
	242
	243	if(!fCutsRD){
	244	cout<<"Cut matrice not inizialized. Exit..."<<endl;
	245	return 0;
	246	}
	247	//PrintAll();
	248	AliAODRecoDecayHF3Prong* d=(AliAODRecoDecayHF3Prong*)obj;
	249
	250	if(!d){
	251	cout<<"AliAODRecoDecayHF3Prong null"<<endl;
	252	return 0;
	253	}
	254
	255
	256	// selection on daughter tracks
	257	if(selectionLevel==AliRDHFCuts::kAll \|\|
	258	selectionLevel==AliRDHFCuts::kTracks) {
	259	if(!AreDaughtersSelected(d)) return 0;
	260	}
	261
	262
e3d40058	263
4755453e	264	Int_t returnvalue=1;
e3d40058	265	// selection on candidate
	266	if(selectionLevel==AliRDHFCuts::kAll \|\|
	267	selectionLevel==AliRDHFCuts::kCandidate) {
	268
e3d40058	269
4755453e	270	Int_t okDsKKpi=1;
	271	Int_t okDspiKK=1;
	272	Int_t okMassPhi=0;
	273	Int_t okMassK0star=0;
e3d40058	274
4755453e	275	Double_t pt=d->Pt();
	276	Int_t ptbin=PtBin(pt);
	277
	278	Double_t mDsPDG = TDatabasePDG::Instance()->GetParticle(431)->Mass();
	279	Double_t mDsKKpi=d->InvMassDsKKpi();
	280	Double_t mDspiKK=d->InvMassDspiKK();
	281	if(TMath::Abs(mDsKKpi-mDsPDG)>fCutsRD[GetGlobalIndex(0,ptbin)]) okDsKKpi = 0;
	282	if(TMath::Abs(mDspiKK-mDsPDG)>fCutsRD[GetGlobalIndex(0,ptbin)]) okDspiKK = 0;
	283	if(!okDsKKpi && !okDspiKK) return 0;
	284
	285	//single track
	286	if(TMath::Abs(d->PtProng(1)) < fCutsRD[GetGlobalIndex(1,ptbin)] \|\|
	287	TMath::Abs(d->Getd0Prong(1))<fCutsRD[GetGlobalIndex(3,ptbin)]) return 0;
	288	if(okDsKKpi){
	289	if(TMath::Abs(d->PtProng(0)) < fCutsRD[GetGlobalIndex(1,ptbin)] \|\|
	290	TMath::Abs(d->Getd0Prong(0))<fCutsRD[GetGlobalIndex(3,ptbin)]) okDsKKpi=0;
	291	if(TMath::Abs(d->PtProng(2)) < fCutsRD[GetGlobalIndex(2,ptbin)] \|\|
	292	TMath::Abs(d->Getd0Prong(2))<fCutsRD[GetGlobalIndex(4,ptbin)]) okDsKKpi=0;
	293	}
	294	if(okDspiKK){
	295	if(TMath::Abs(d->PtProng(0)) < fCutsRD[GetGlobalIndex(2,ptbin)] \|\|
	296	TMath::Abs(d->Getd0Prong(0))<fCutsRD[GetGlobalIndex(4,ptbin)]) okDspiKK=0;
	297	if(TMath::Abs(d->PtProng(2)) < fCutsRD[GetGlobalIndex(1,ptbin)] \|\|
	298	TMath::Abs(d->Getd0Prong(2))<fCutsRD[GetGlobalIndex(3,ptbin)]) okDspiKK=0;
	299	}
	300	if(!okDsKKpi && !okDspiKK) return 0;
	301
	302	// cuts on resonant decays (via Phi or K0*)
	303	Double_t mPhiPDG = TDatabasePDG::Instance()->GetParticle(333)->Mass();
	304	Double_t mK0starPDG = TDatabasePDG::Instance()->GetParticle(313)->Mass();
	305	if(okDsKKpi){
	306	Double_t mass01phi=d->InvMass2Prongs(0,1,321,321);
	307	Double_t mass12K0s=d->InvMass2Prongs(1,2,321,211);
	308	if(TMath::Abs(mass01phi-mPhiPDG)<fCutsRD[GetGlobalIndex(12,ptbin)]) okMassPhi=1;
	309	if(TMath::Abs(mass12K0s-mK0starPDG)<fCutsRD[GetGlobalIndex(13,ptbin)]) okMassK0star = 1;
	310	if(!okMassPhi && !okMassK0star) okDsKKpi=0;
	311	}
	312	if(okDspiKK){
	313	Double_t mass01K0s=d->InvMass2Prongs(0,1,211,321);
	314	Double_t mass12phi=d->InvMass2Prongs(1,2,321,321);
	315	if(TMath::Abs(mass01K0s-mK0starPDG)<fCutsRD[GetGlobalIndex(13,ptbin)]) okMassK0star = 1;
	316	if(TMath::Abs(mass12phi-mPhiPDG)<fCutsRD[GetGlobalIndex(12,ptbin)]) okMassPhi=1;
	317	if(!okMassPhi && !okMassK0star) okDspiKK=0;
	318	}
	319	if(!okDsKKpi && !okDspiKK) return 0;
	320
	321	// Cuts on track pairs
	322	for(Int_t i=0;i<3;i++) if(d->GetDCA(i)>fCutsRD[GetGlobalIndex(11,ptbin)]) return 0;
	323	if(d->GetDist12toPrim()<fCutsRD[GetGlobalIndex(5,ptbin)] \|\|
	324	d->GetDist23toPrim()<fCutsRD[GetGlobalIndex(5,ptbin)]) return 0;
	325
	326
	327	// Cuts on candidate triplet
	328	if(d->GetSigmaVert()>fCutsRD[GetGlobalIndex(6,ptbin)]) return 0;
	329	if(d->DecayLength()<fCutsRD[GetGlobalIndex(7,ptbin)]) return 0;
	330	if(TMath::Abs(d->PtProng(0))<fCutsRD[GetGlobalIndex(8,ptbin)] &&
	331	TMath::Abs(d->PtProng(1))<fCutsRD[GetGlobalIndex(8,ptbin)] &&
	332	TMath::Abs(d->PtProng(2))<fCutsRD[GetGlobalIndex(8,ptbin)]) return 0;
	333	if(d->CosPointingAngle()< fCutsRD[GetGlobalIndex(9,ptbin)])return 0;
	334	Double_t sum2=d->Getd0Prong(0)d->Getd0Prong(0)+d->Getd0Prong(1)d->Getd0Prong(1)+d->Getd0Prong(2)*d->Getd0Prong(2);
	335	if(sum2<fCutsRD[GetGlobalIndex(10,ptbin)])return 0;
	336
	337	returnvalue=0;
	338	if(okDsKKpi) returnvalue+=1;
339	if(okDspiKK) returnvalue+=2;
340	if(okMassPhi) returnvalue+=4;
341	if(okMassK0star) returnvalue+=8;
342
343	}
e3d40058	344	return returnvalue;
	345
	346	}
	347	//---------------------------------------------------------------------------