[u/mrichter/AliRoot.git] / PWGLF / RESONANCES / AliRsnCutSetDaughterParticle.cxx

//
// Author: Francesca Bellini (fbellini@cern.ch)
//
//

#include <Riostream.h>

#include "AliPID.h"
#include "AliPIDResponse.h"
#include "AliRsnCutSetDaughterParticle.h"

class AliRsnCutPIDNSigma;
class AliRsnPIDRange;
class AliRsnCutPhi;

ClassImp(AliRsnCutSetDaughterParticle)

//__________________________________________________________________________________________________
AliRsnCutSetDaughterParticle::AliRsnCutSetDaughterParticle() :
   AliRsnCutSet("AliRsnCutSetDaughterParticle", AliRsnTarget::kDaughter),
   fPID(AliPID::kPion),
   fAppliedCutSetID(AliRsnCutSetDaughterParticle::kNDaughterCuts),
   fNsigmaTPC(1E20),
   fNsigmaTOF(1E20),
   fCutQuality(0x0),
   fAODTrkCutFilterBit(0)
{
   //
   // Default constructor
}

//__________________________________________________________________________________________________
AliRsnCutSetDaughterParticle::AliRsnCutSetDaughterParticle(const char *name, AliRsnCutSetDaughterParticle::ERsnDaughterCutSet cutSetID, AliPID::EParticleType pid, Float_t nSigmaFast = -1.0, Int_t AODfilterBit = 0) :
   AliRsnCutSet(name, AliRsnTarget::kDaughter),
   fPID(pid),
   fAppliedCutSetID(cutSetID),
   fNsigmaTPC(1E20),
   fNsigmaTOF(1E20),
   fCutQuality(new AliRsnCutTrackQuality("CutQuality")),
   fAODTrkCutFilterBit(AODfilterBit)
{
   //
   // Constructor
   //
   if ( (nSigmaFast<=0) &&
        ((cutSetID == AliRsnCutSetDaughterParticle::kFastTPCpidNsigma) || (cutSetID == AliRsnCutSetDaughterParticle::kFastTOFpidNsigma) || (cutSetID == AliRsnCutSetDaughterParticle::kTOFMatchTPCpidNsigma)) ) {
      AliError("Requested fast n-sigma PID with invalid value for n. Setting n = 1E20");
   } else {
      if (cutSetID == AliRsnCutSetDaughterParticle::kFastTPCpidNsigma) {
         fNsigmaTPC = nSigmaFast;
      }
      if (cutSetID == AliRsnCutSetDaughterParticle::kTOFMatchTPCpidNsigma) {
	fNsigmaTPC = nSigmaFast;
      }
      if ( (cutSetID == AliRsnCutSetDaughterParticle::kFastTOFpidNsigma) ||
           (cutSetID == AliRsnCutSetDaughterParticle::kTOFpidKstarPbPb2010) ) {
         fNsigmaTOF = nSigmaFast;
      }
   }

   Init();
}

//__________________________________________________________________________________________________
AliRsnCutSetDaughterParticle::AliRsnCutSetDaughterParticle(const AliRsnCutSetDaughterParticle &copy) :
   AliRsnCutSet(copy),
   fPID(copy.fPID),
   fAppliedCutSetID(copy.fAppliedCutSetID),
   fNsigmaTPC(copy.fNsigmaTPC),
   fNsigmaTOF(copy.fNsigmaTOF),
   fCutQuality(copy.fCutQuality),
   fAODTrkCutFilterBit(copy.fAODTrkCutFilterBit)
{
   //
   // copy constructor
}

//__________________________________________________________________________________________________
AliRsnCutSetDaughterParticle &AliRsnCutSetDaughterParticle::operator=(const AliRsnCutSetDaughterParticle &copy)
{
   //
   // operator =
   //
   AliRsnCutSet::operator=(copy);
   if (this == &copy)
      return *this;
   fPID=copy.fPID;
   fAppliedCutSetID=copy.fAppliedCutSetID;
   fNsigmaTPC=copy.fNsigmaTPC;
   fNsigmaTOF=copy.fNsigmaTOF;
   fAODTrkCutFilterBit=copy.fAODTrkCutFilterBit;
   fCutQuality=copy.fCutQuality;
   return (*this);
}

//----------------------------------------------------------------------------
AliRsnCutSetDaughterParticle::~AliRsnCutSetDaughterParticle()
{
   //
   //destructor
   //
   if (fCutQuality)
      delete fCutQuality;
}
//----------------------------------------------------------------------------
void AliRsnCutSetDaughterParticle::Init()
{
   //
   // init cut sets by setting variable params
   //
   fCutQuality->SetDefaults2010();
   fCutQuality->SetPtRange(0.15, 20.0);
   fCutQuality->SetEtaRange(-0.8, 0.8);
   fCutQuality->SetDCARPtFormula("0.0182+0.0350/pt^1.01");
   fCutQuality->SetDCAZmax(2.0);
   fCutQuality->SetSPDminNClusters(1);
   fCutQuality->SetITSminNClusters(0);
   fCutQuality->SetITSmaxChi2(36);
   fCutQuality->SetTPCminNClusters(70);
   fCutQuality->SetTPCmaxChi2(4.0);
   fCutQuality->SetRejectKinkDaughters();
   fCutQuality->SetAODTestFilterBit(fAODTrkCutFilterBit);
   //fCutQuality->SetITSmaxChi2(36);
   //fCutQuality->SetMaxChi2TPCConstrainedGlobal(36);

   AliRsnCutTOFMatch  *iCutTOFMatch     = new AliRsnCutTOFMatch("CutTOFMatch");
   AliRsnCutPIDNSigma *iCutTPCNSigma    = new AliRsnCutPIDNSigma("CutTPCNSigma", fPID, AliRsnCutPIDNSigma::kTPC);//, AliRsnCutPIDNSigma::kTPCinnerP );
   AliRsnCutPIDNSigma *iCutTPCTOFNSigma = new AliRsnCutPIDNSigma("CutTPCTOFNSigma", fPID, AliRsnCutPIDNSigma::kTPC);//, AliRsnCutPIDNSigma::kTPCinnerP );
   AliRsnCutPIDNSigma *iCutTOFNSigma    = new AliRsnCutPIDNSigma("CutTOFNSigma", fPID, AliRsnCutPIDNSigma::kTOF);//, AliRsnCutPIDNSigma::kP );
   AliRsnCutPhi  *iCutPhiTRD2010        = new AliRsnCutPhi("CutPhiTRD2010","InTRD");
   AliRsnCutPhi  *iCutPhiNoTRD2010      = new AliRsnCutPhi("CutPhiNoTRD2010","OutTRD");
   
   switch (fAppliedCutSetID)
   {
      case AliRsnCutSetDaughterParticle::kNoCuts :
         AliInfo("No cuts applied to daughter particle");
         break;

      case AliRsnCutSetDaughterParticle::kQualityStd2010 :
         AddCut(fCutQuality);
         SetCutScheme(fCutQuality->GetName());
         break;

      case AliRsnCutSetDaughterParticle::kQualityStd2011:
         //fCutQuality->SetAODTestFilterBit(10);     //1024
         AddCut(fCutQuality);
         SetCutScheme(fCutQuality->GetName());
         break;

      case AliRsnCutSetDaughterParticle::kTOFMatch :
         AddCut(fCutQuality);
         AddCut(iCutTOFMatch);
         SetCutScheme( Form("%s&(%s)",fCutQuality->GetName(), iCutTOFMatch->GetName()) );
         break;

      case    AliRsnCutSetDaughterParticle::kFastTPCpidNsigma :
         if (fNsigmaTPC <= 0.0) {
            AliWarning(Form("Invalid number of sigmas required for %s. Setting default nSigma = 10",iCutTPCNSigma->GetName()));
            SetNsigmaForFastTPCpid(10.0);
         }
         iCutTPCNSigma->SinglePIDRange(fNsigmaTPC);
         AddCut(fCutQuality);
         AddCut(iCutTPCNSigma);
         SetCutScheme( Form("%s&%s",fCutQuality->GetName(), iCutTPCNSigma->GetName()) );
         break;

      case    AliRsnCutSetDaughterParticle::kFastTOFpidNsigma :
         if (fNsigmaTOF <= 0.0) {
            AliWarning(Form("Invalid number of sigmas required for %s. Setting default nSigma = 10",iCutTOFNSigma->GetName()));
            SetNsigmaForFastTOFpid(10.0);
         }
         iCutTOFNSigma->SinglePIDRange(fNsigmaTOF);
         //iCutTOFNSigma->AddPIDRange(3.0, 0.35, 1E20);
         AddCut(fCutQuality);
         AddCut(iCutTOFNSigma);
         SetCutScheme( Form("%s&%s",fCutQuality->GetName(), iCutTOFNSigma->GetName()) );
         break;

      case    AliRsnCutSetDaughterParticle::kTPCTOFpidKstarPP2010 :
         /* Set TPC  PID (if no TOF)*/
         // all   below   350         MeV: 5sigma
         // all   between 350 and 500 MeV: 3sigma
         // pios above   500         MeV: 2sigma
         // kaons between 500 and 700 MeV: 2sigma
         // kaons above   700         MeV: rejected
         iCutTPCNSigma->AddPIDRange(5.0, 0.0, 0.35);
         iCutTPCNSigma->AddPIDRange(3.0, 0.35, 0.5);
         if (fPID==AliPID::kPion)
            iCutTPCNSigma->AddPIDRange(2.0, 0.5, 1E20);
         if (fPID==AliPID::kKaon)
            iCutTPCNSigma->AddPIDRange(2.0, 0.5, 0.7);

         AddCut(fCutQuality);
         AddCut(iCutTOFMatch);
         AddCut(iCutTPCNSigma);

         /* set TPC+TOF PID*/
         iCutTPCTOFNSigma->SinglePIDRange(5.0);
         iCutTOFNSigma->AddPIDRange(3.0, 0.0, 1.5);
         iCutTOFNSigma->AddPIDRange(2.0, 1.5, 1E20);

         AddCut(iCutTPCTOFNSigma);
         AddCut(iCutTOFNSigma);

         // scheme:
         // quality & [ (TOF & TPCTOF) || (!TOFmatch & TPConly) ]
         SetCutScheme( Form("%s&((%s&%s)|((!%s)&%s))",fCutQuality->GetName(), iCutTPCTOFNSigma->GetName(), iCutTOFNSigma->GetName(), iCutTOFMatch->GetName(), iCutTPCNSigma->GetName()) ) ;
         break;

      case AliRsnCutSetDaughterParticle::kTOFpidKstarPbPb2010:
         if (fNsigmaTOF <= 0.0) {
            AliWarning(Form("Invalid number of sigmas required for %s. Setting default nSigma = 10",iCutTOFNSigma->GetName()));
            SetNsigmaForFastTOFpid(10.0);
         }
         iCutTOFNSigma->SinglePIDRange(fNsigmaTOF);
         //iCutTOFNSigma->AddPIDRange(3.0, 0.35, 1E20);
         iCutTPCTOFNSigma->SinglePIDRange(5.0); //5-sigma veto on tpc signal

         AddCut(fCutQuality);
         AddCut(iCutTOFNSigma);
         AddCut(iCutTPCTOFNSigma);
         SetCutScheme( Form("%s&%s&%s",fCutQuality->GetName(), iCutTOFNSigma->GetName(), iCutTPCTOFNSigma->GetName()) );
         break;

      case AliRsnCutSetDaughterParticle::kTOFTPCmismatchKstarPbPb2010:
         iCutTPCTOFNSigma->SinglePIDRange(5.0); //5-sigma veto on tpc signal
         AddCut(fCutQuality);
         AddCut(iCutTOFMatch);
         AddCut(iCutTPCTOFNSigma);
         SetCutScheme( Form("%s&%s&%s",fCutQuality->GetName(), iCutTOFMatch->GetName(), iCutTPCTOFNSigma->GetName()) );
         break;

   case AliRsnCutSetDaughterParticle::kTOFMatchTRD2010 :
         AddCut(fCutQuality);
         AddCut(iCutTOFMatch);
	 AddCut(iCutPhiTRD2010);
	 SetCutScheme( Form("%s&(%s)&(%s)",fCutQuality->GetName(), iCutTOFMatch->GetName(), iCutPhiTRD2010->GetName()) );
         break;
	 
   case AliRsnCutSetDaughterParticle::kTOFMatchNoTRD2010 :
         AddCut(fCutQuality);
         AddCut(iCutTOFMatch);
	 AddCut(iCutPhiNoTRD2010);
	 SetCutScheme( Form("%s&(%s)&(%s)",fCutQuality->GetName(), iCutTOFMatch->GetName(), iCutPhiNoTRD2010->GetName()) );
         break;

      case AliRsnCutSetDaughterParticle::kTOFpidKstarPbPbTRD2010:
         if (fNsigmaTOF <= 0.0) {
            AliWarning(Form("Invalid number of sigmas required for %s. Setting default nSigma = 10",iCutTOFNSigma->GetName()));
            SetNsigmaForFastTOFpid(10.0);
         }
         iCutTOFNSigma->SinglePIDRange(fNsigmaTOF);
         //iCutTOFNSigma->AddPIDRange(3.0, 0.35, 1E20);
         iCutTPCTOFNSigma->SinglePIDRange(5.0); //5-sigma veto on tpc signal

         AddCut(fCutQuality);
         AddCut(iCutTOFNSigma);
         AddCut(iCutTPCTOFNSigma);
	 AddCut(iCutPhiTRD2010);
         SetCutScheme( Form("%s&%s&%s&%s",fCutQuality->GetName(), iCutTOFNSigma->GetName(), iCutTPCTOFNSigma->GetName(),iCutPhiTRD2010->GetName()) );
         break;

 case AliRsnCutSetDaughterParticle::kTOFpidKstarPbPbNoTRD2010:
         if (fNsigmaTOF <= 0.0) {
            AliWarning(Form("Invalid number of sigmas required for %s. Setting default nSigma = 10",iCutTOFNSigma->GetName()));
            SetNsigmaForFastTOFpid(10.0);
         }
         iCutTOFNSigma->SinglePIDRange(fNsigmaTOF);
         //iCutTOFNSigma->AddPIDRange(3.0, 0.35, 1E20);
         iCutTPCTOFNSigma->SinglePIDRange(5.0); //5-sigma veto on tpc signal

         AddCut(fCutQuality);
         AddCut(iCutTOFNSigma);
         AddCut(iCutTPCTOFNSigma);
	 AddCut(iCutPhiNoTRD2010);
         SetCutScheme( Form("%s&%s&%s&%s",fCutQuality->GetName(), iCutTOFNSigma->GetName(), iCutTPCTOFNSigma->GetName(),iCutPhiNoTRD2010->GetName()) );
         break;

   case AliRsnCutSetDaughterParticle::kTOFMatchTPCpidNsigma :
         if (fNsigmaTPC <= 0.0) {
            AliWarning(Form("Invalid number of sigmas required for %s. Setting default nSigma = 10",iCutTPCNSigma->GetName()));
            SetNsigmaForFastTPCpid(10.0);
         }
         iCutTPCNSigma->SinglePIDRange(fNsigmaTPC);
         AddCut(fCutQuality);
         AddCut(iCutTPCNSigma);
	 AddCut(iCutTOFMatch);	
         SetCutScheme( Form("%s&%s&%s",fCutQuality->GetName(), iCutTPCNSigma->GetName(), iCutTOFMatch->GetName()) );
         break;

   case AliRsnCutSetDaughterParticle::kQualityStd2010TRD:
     AddCut(fCutQuality);
     AddCut(iCutPhiTRD2010);
     SetCutScheme( Form("%s&%s",fCutQuality->GetName(),iCutPhiTRD2010->GetName()) );
     break;
     
   case AliRsnCutSetDaughterParticle::kQualityStd2010NoTRD:
     AddCut(fCutQuality);
     AddCut(iCutPhiNoTRD2010);
     SetCutScheme( Form("%s&%s",fCutQuality->GetName(),iCutPhiNoTRD2010->GetName()) );
     break;
   

    default :
         break;
   }

}
Commit	Line	Data
9cdd5474	1	//
	2	// Author: Francesca Bellini (fbellini@cern.ch)
	3	//
	4	//
	5
	6	#include <Riostream.h>
	7
	8	#include "AliPID.h"
	9	#include "AliPIDResponse.h"
	10	#include "AliRsnCutSetDaughterParticle.h"
	11
	12	class AliRsnCutPIDNSigma;
	13	class AliRsnPIDRange;
6b5662ca	14	class AliRsnCutPhi;
9cdd5474	15
	16	ClassImp(AliRsnCutSetDaughterParticle)
	17
	18	//__________________________________________________________________________________________________
	19	AliRsnCutSetDaughterParticle::AliRsnCutSetDaughterParticle() :
e6952ec7	20	AliRsnCutSet("AliRsnCutSetDaughterParticle", AliRsnTarget::kDaughter),
	21	fPID(AliPID::kPion),
	22	fAppliedCutSetID(AliRsnCutSetDaughterParticle::kNDaughterCuts),
	23	fNsigmaTPC(1E20),
	24	fNsigmaTOF(1E20),
	25	fCutQuality(0x0),
	26	fAODTrkCutFilterBit(0)
9cdd5474	27	{
	28	//
	29	// Default constructor
	30	}
	31
	32	//__________________________________________________________________________________________________
a6430459	33	AliRsnCutSetDaughterParticle::AliRsnCutSetDaughterParticle(const char *name, AliRsnCutSetDaughterParticle::ERsnDaughterCutSet cutSetID, AliPID::EParticleType pid, Float_t nSigmaFast = -1.0, Int_t AODfilterBit = 0) :
e6952ec7	34	AliRsnCutSet(name, AliRsnTarget::kDaughter),
	35	fPID(pid),
	36	fAppliedCutSetID(cutSetID),
	37	fNsigmaTPC(1E20),
	38	fNsigmaTOF(1E20),
	39	fCutQuality(new AliRsnCutTrackQuality("CutQuality")),
	40	fAODTrkCutFilterBit(AODfilterBit)
9cdd5474	41	{
	42	//
	43	// Constructor
	44	//
e6952ec7	45	if ( (nSigmaFast<=0) &&
6b5662ca	46	((cutSetID == AliRsnCutSetDaughterParticle::kFastTPCpidNsigma) \|\| (cutSetID == AliRsnCutSetDaughterParticle::kFastTOFpidNsigma) \|\| (cutSetID == AliRsnCutSetDaughterParticle::kTOFMatchTPCpidNsigma)) ) {
e6952ec7	47	AliError("Requested fast n-sigma PID with invalid value for n. Setting n = 1E20");
	48	} else {
	49	if (cutSetID == AliRsnCutSetDaughterParticle::kFastTPCpidNsigma) {
	50	fNsigmaTPC = nSigmaFast;
	51	}
6b5662ca	52	if (cutSetID == AliRsnCutSetDaughterParticle::kTOFMatchTPCpidNsigma) {
	53	fNsigmaTPC = nSigmaFast;
	54	}
e6952ec7	55	if ( (cutSetID == AliRsnCutSetDaughterParticle::kFastTOFpidNsigma) \|\|
	56	(cutSetID == AliRsnCutSetDaughterParticle::kTOFpidKstarPbPb2010) ) {
	57	fNsigmaTOF = nSigmaFast;
	58	}
	59	}
	60
	61	Init();
9cdd5474	62	}
	63
	64	//__________________________________________________________________________________________________
	65	AliRsnCutSetDaughterParticle::AliRsnCutSetDaughterParticle(const AliRsnCutSetDaughterParticle &copy) :
	66	AliRsnCutSet(copy),
	67	fPID(copy.fPID),
	68	fAppliedCutSetID(copy.fAppliedCutSetID),
	69	fNsigmaTPC(copy.fNsigmaTPC),
a6430459	70	fNsigmaTOF(copy.fNsigmaTOF),
	71	fCutQuality(copy.fCutQuality),
	72	fAODTrkCutFilterBit(copy.fAODTrkCutFilterBit)
9cdd5474	73	{
	74	//
	75	// copy constructor
	76	}
	77
	78	//__________________________________________________________________________________________________
	79	AliRsnCutSetDaughterParticle &AliRsnCutSetDaughterParticle::operator=(const AliRsnCutSetDaughterParticle &copy)
e6952ec7	80	{
9cdd5474	81	//
9cdd5474	82	// operator =
e6952ec7	83	//
	84	AliRsnCutSet::operator=(copy);
	85	if (this == &copy)
	86	return *this;
	87	fPID=copy.fPID;
	88	fAppliedCutSetID=copy.fAppliedCutSetID;
	89	fNsigmaTPC=copy.fNsigmaTPC;
	90	fNsigmaTOF=copy.fNsigmaTOF;
	91	fAODTrkCutFilterBit=copy.fAODTrkCutFilterBit;
	92	fCutQuality=copy.fCutQuality;
	93	return (*this);
9cdd5474	94	}
9cdd5474	95
a6430459	96	//----------------------------------------------------------------------------
	97	AliRsnCutSetDaughterParticle::~AliRsnCutSetDaughterParticle()
	98	{
e6952ec7	99	//
	100	//destructor
	101	//
	102	if (fCutQuality)
	103	delete fCutQuality;
a6430459	104	}
9cdd5474	105	//----------------------------------------------------------------------------
e6952ec7	106	void AliRsnCutSetDaughterParticle::Init()
	107	{
	108	//
	109	// init cut sets by setting variable params
	110	//
	111	fCutQuality->SetDefaults2010();
	112	fCutQuality->SetPtRange(0.15, 20.0);
	113	fCutQuality->SetEtaRange(-0.8, 0.8);
	114	fCutQuality->SetDCARPtFormula("0.0182+0.0350/pt^1.01");
	115	fCutQuality->SetDCAZmax(2.0);
	116	fCutQuality->SetSPDminNClusters(1);
	117	fCutQuality->SetITSminNClusters(0);
	118	fCutQuality->SetITSmaxChi2(36);
	119	fCutQuality->SetTPCminNClusters(70);
	120	fCutQuality->SetTPCmaxChi2(4.0);
	121	fCutQuality->SetRejectKinkDaughters();
	122	fCutQuality->SetAODTestFilterBit(fAODTrkCutFilterBit);
	123	//fCutQuality->SetITSmaxChi2(36);
	124	//fCutQuality->SetMaxChi2TPCConstrainedGlobal(36);
	125
	126	AliRsnCutTOFMatch *iCutTOFMatch = new AliRsnCutTOFMatch("CutTOFMatch");
	127	AliRsnCutPIDNSigma *iCutTPCNSigma = new AliRsnCutPIDNSigma("CutTPCNSigma", fPID, AliRsnCutPIDNSigma::kTPC);//, AliRsnCutPIDNSigma::kTPCinnerP );
	128	AliRsnCutPIDNSigma *iCutTPCTOFNSigma = new AliRsnCutPIDNSigma("CutTPCTOFNSigma", fPID, AliRsnCutPIDNSigma::kTPC);//, AliRsnCutPIDNSigma::kTPCinnerP );
	129	AliRsnCutPIDNSigma *iCutTOFNSigma = new AliRsnCutPIDNSigma("CutTOFNSigma", fPID, AliRsnCutPIDNSigma::kTOF);//, AliRsnCutPIDNSigma::kP );
6b5662ca	130	AliRsnCutPhi *iCutPhiTRD2010 = new AliRsnCutPhi("CutPhiTRD2010","InTRD");
	131	AliRsnCutPhi *iCutPhiNoTRD2010 = new AliRsnCutPhi("CutPhiNoTRD2010","OutTRD");
	132
e6952ec7	133	switch (fAppliedCutSetID)
	134	{
	135	case AliRsnCutSetDaughterParticle::kNoCuts :
	136	AliInfo("No cuts applied to daughter particle");
	137	break;
	138
	139	case AliRsnCutSetDaughterParticle::kQualityStd2010 :
	140	AddCut(fCutQuality);
	141	SetCutScheme(fCutQuality->GetName());
	142	break;
	143
	144	case AliRsnCutSetDaughterParticle::kQualityStd2011:
	145	//fCutQuality->SetAODTestFilterBit(10); //1024
	146	AddCut(fCutQuality);
	147	SetCutScheme(fCutQuality->GetName());
	148	break;
	149
	150	case AliRsnCutSetDaughterParticle::kTOFMatch :
	151	AddCut(fCutQuality);
	152	AddCut(iCutTOFMatch);
	153	SetCutScheme( Form("%s&(%s)",fCutQuality->GetName(), iCutTOFMatch->GetName()) );
	154	break;
	155
	156	case AliRsnCutSetDaughterParticle::kFastTPCpidNsigma :
	157	if (fNsigmaTPC <= 0.0) {
	158	AliWarning(Form("Invalid number of sigmas required for %s. Setting default nSigma = 10",iCutTPCNSigma->GetName()));
	159	SetNsigmaForFastTPCpid(10.0);
	160	}
	161	iCutTPCNSigma->SinglePIDRange(fNsigmaTPC);
	162	AddCut(fCutQuality);
	163	AddCut(iCutTPCNSigma);
	164	SetCutScheme( Form("%s&%s",fCutQuality->GetName(), iCutTPCNSigma->GetName()) );
	165	break;
	166
	167	case AliRsnCutSetDaughterParticle::kFastTOFpidNsigma :
	168	if (fNsigmaTOF <= 0.0) {
	169	AliWarning(Form("Invalid number of sigmas required for %s. Setting default nSigma = 10",iCutTOFNSigma->GetName()));
	170	SetNsigmaForFastTOFpid(10.0);
	171	}
	172	iCutTOFNSigma->SinglePIDRange(fNsigmaTOF);
	173	//iCutTOFNSigma->AddPIDRange(3.0, 0.35, 1E20);
	174	AddCut(fCutQuality);
	175	AddCut(iCutTOFNSigma);
	176	SetCutScheme( Form("%s&%s",fCutQuality->GetName(), iCutTOFNSigma->GetName()) );
	177	break;
	178
	179	case AliRsnCutSetDaughterParticle::kTPCTOFpidKstarPP2010 :
	180	/* Set TPC PID (if no TOF)*/
	181	// all below 350 MeV: 5sigma
	182	// all between 350 and 500 MeV: 3sigma
	183	// pios above 500 MeV: 2sigma
	184	// kaons between 500 and 700 MeV: 2sigma
	185	// kaons above 700 MeV: rejected
	186	iCutTPCNSigma->AddPIDRange(5.0, 0.0, 0.35);
	187	iCutTPCNSigma->AddPIDRange(3.0, 0.35, 0.5);
	188	if (fPID==AliPID::kPion)
	189	iCutTPCNSigma->AddPIDRange(2.0, 0.5, 1E20);
	190	if (fPID==AliPID::kKaon)
	191	iCutTPCNSigma->AddPIDRange(2.0, 0.5, 0.7);
	192
	193	AddCut(fCutQuality);
	194	AddCut(iCutTOFMatch);
	195	AddCut(iCutTPCNSigma);
	196
197	/* set TPC+TOF PID*/
198	iCutTPCTOFNSigma->SinglePIDRange(5.0);
199	iCutTOFNSigma->AddPIDRange(3.0, 0.0, 1.5);
200	iCutTOFNSigma->AddPIDRange(2.0, 1.5, 1E20);
201
202	AddCut(iCutTPCTOFNSigma);
203	AddCut(iCutTOFNSigma);
204
205	// scheme:
206	// quality & [ (TOF & TPCTOF) \|\| (!TOFmatch & TPConly) ]
207	SetCutScheme( Form("%s&((%s&%s)\|((!%s)&%s))",fCutQuality->GetName(), iCutTPCTOFNSigma->GetName(), iCutTOFNSigma->GetName(), iCutTOFMatch->GetName(), iCutTPCNSigma->GetName()) ) ;
208	break;
209
210	case AliRsnCutSetDaughterParticle::kTOFpidKstarPbPb2010:
211	if (fNsigmaTOF <= 0.0) {
212	AliWarning(Form("Invalid number of sigmas required for %s. Setting default nSigma = 10",iCutTOFNSigma->GetName()));
213	SetNsigmaForFastTOFpid(10.0);
214	}
215	iCutTOFNSigma->SinglePIDRange(fNsigmaTOF);
216	//iCutTOFNSigma->AddPIDRange(3.0, 0.35, 1E20);
217	iCutTPCTOFNSigma->SinglePIDRange(5.0); //5-sigma veto on tpc signal
218
219	AddCut(fCutQuality);
220	AddCut(iCutTOFNSigma);
221	AddCut(iCutTPCTOFNSigma);
222	SetCutScheme( Form("%s&%s&%s",fCutQuality->GetName(), iCutTOFNSigma->GetName(), iCutTPCTOFNSigma->GetName()) );
223	break;
224
225	case AliRsnCutSetDaughterParticle::kTOFTPCmismatchKstarPbPb2010:
226	iCutTPCTOFNSigma->SinglePIDRange(5.0); //5-sigma veto on tpc signal
227	AddCut(fCutQuality);
228	AddCut(iCutTOFMatch);
229	AddCut(iCutTPCTOFNSigma);
230	SetCutScheme( Form("%s&%s&%s",fCutQuality->GetName(), iCutTOFMatch->GetName(), iCutTPCTOFNSigma->GetName()) );
231	break;
232
6b5662ca	233	case AliRsnCutSetDaughterParticle::kTOFMatchTRD2010 :
	234	AddCut(fCutQuality);
	235	AddCut(iCutTOFMatch);
	236	AddCut(iCutPhiTRD2010);
	237	SetCutScheme( Form("%s&(%s)&(%s)",fCutQuality->GetName(), iCutTOFMatch->GetName(), iCutPhiTRD2010->GetName()) );
	238	break;
	239
	240	case AliRsnCutSetDaughterParticle::kTOFMatchNoTRD2010 :
	241	AddCut(fCutQuality);
	242	AddCut(iCutTOFMatch);
	243	AddCut(iCutPhiNoTRD2010);
	244	SetCutScheme( Form("%s&(%s)&(%s)",fCutQuality->GetName(), iCutTOFMatch->GetName(), iCutPhiNoTRD2010->GetName()) );
	245	break;
	246
	247	case AliRsnCutSetDaughterParticle::kTOFpidKstarPbPbTRD2010:
	248	if (fNsigmaTOF <= 0.0) {
	249	AliWarning(Form("Invalid number of sigmas required for %s. Setting default nSigma = 10",iCutTOFNSigma->GetName()));
	250	SetNsigmaForFastTOFpid(10.0);
	251	}
	252	iCutTOFNSigma->SinglePIDRange(fNsigmaTOF);
	253	//iCutTOFNSigma->AddPIDRange(3.0, 0.35, 1E20);
	254	iCutTPCTOFNSigma->SinglePIDRange(5.0); //5-sigma veto on tpc signal
	255
	256	AddCut(fCutQuality);
	257	AddCut(iCutTOFNSigma);
	258	AddCut(iCutTPCTOFNSigma);
	259	AddCut(iCutPhiTRD2010);
63800d55	260	SetCutScheme( Form("%s&%s&%s&%s",fCutQuality->GetName(), iCutTOFNSigma->GetName(), iCutTPCTOFNSigma->GetName(),iCutPhiTRD2010->GetName()) );
6b5662ca	261	break;
	262
	263	case AliRsnCutSetDaughterParticle::kTOFpidKstarPbPbNoTRD2010:
	264	if (fNsigmaTOF <= 0.0) {
	265	AliWarning(Form("Invalid number of sigmas required for %s. Setting default nSigma = 10",iCutTOFNSigma->GetName()));
	266	SetNsigmaForFastTOFpid(10.0);
	267	}
	268	iCutTOFNSigma->SinglePIDRange(fNsigmaTOF);
	269	//iCutTOFNSigma->AddPIDRange(3.0, 0.35, 1E20);
	270	iCutTPCTOFNSigma->SinglePIDRange(5.0); //5-sigma veto on tpc signal
	271
	272	AddCut(fCutQuality);
	273	AddCut(iCutTOFNSigma);
	274	AddCut(iCutTPCTOFNSigma);
	275	AddCut(iCutPhiNoTRD2010);
63800d55	276	SetCutScheme( Form("%s&%s&%s&%s",fCutQuality->GetName(), iCutTOFNSigma->GetName(), iCutTPCTOFNSigma->GetName(),iCutPhiNoTRD2010->GetName()) );
6b5662ca	277	break;
	278
	279	case AliRsnCutSetDaughterParticle::kTOFMatchTPCpidNsigma :
	280	if (fNsigmaTPC <= 0.0) {
	281	AliWarning(Form("Invalid number of sigmas required for %s. Setting default nSigma = 10",iCutTPCNSigma->GetName()));
	282	SetNsigmaForFastTPCpid(10.0);
	283	}
	284	iCutTPCNSigma->SinglePIDRange(fNsigmaTPC);
	285	AddCut(fCutQuality);
	286	AddCut(iCutTPCNSigma);
	287	AddCut(iCutTOFMatch);
	288	SetCutScheme( Form("%s&%s&%s",fCutQuality->GetName(), iCutTPCNSigma->GetName(), iCutTOFMatch->GetName()) );
	289	break;
9664d398	290
	291	case AliRsnCutSetDaughterParticle::kQualityStd2010TRD:
	292	AddCut(fCutQuality);
	293	AddCut(iCutPhiTRD2010);
	294	SetCutScheme( Form("%s&%s",fCutQuality->GetName(),iCutPhiTRD2010->GetName()) );
	295	break;
	296
	297	case AliRsnCutSetDaughterParticle::kQualityStd2010NoTRD:
	298	AddCut(fCutQuality);
	299	AddCut(iCutPhiNoTRD2010);
	300	SetCutScheme( Form("%s&%s",fCutQuality->GetName(),iCutPhiNoTRD2010->GetName()) );
	301	break;
	302
	303
6b5662ca	304	default :
e6952ec7	305	break;
	306	}
	307
9cdd5474	308	}
	309
	310
	311