[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),
   fCheckOnlyFilterBit(kTRUE),
   fUseCustomQualityCuts(kFALSE)  
{
   //
   // Default constructor
  SetPtRange(0.0, 1E20);
  SetEtaRange(1E20, 1E20);
}

//__________________________________________________________________________________________________
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(nSigmaFast),
   fNsigmaTOF(nSigmaFast),
   fCutQuality(new AliRsnCutTrackQuality("CutQuality")),
   fAODTrkCutFilterBit(AODfilterBit),
   fCheckOnlyFilterBit(kTRUE),
   fUseCustomQualityCuts(kFALSE)
{
   //
   // Constructor
   //
  //set here pt and eta range
  SetPtRange(0.15, 20.0);
  SetEtaRange(-0.8, 0.8);
  
  //if nsigma not specified, sets "no-PID" cuts
  if (nSigmaFast<=0){
    fNsigmaTPC=1e20;
    fNsigmaTOF=1e20;
    AliWarning("Requested fast n-sigma PID with negative value for n. --> Setting n = 1E20");
  }   

  //initialize quality std and PID cuts
  InitStdQualityCuts();
  Init();
}

//__________________________________________________________________________________________________
AliRsnCutSetDaughterParticle::AliRsnCutSetDaughterParticle(const char *name, AliRsnCutTrackQuality *rsnTrackQualityCut, AliRsnCutSetDaughterParticle::ERsnDaughterCutSet cutSetID, AliPID::EParticleType pid, Float_t nSigmaFast = -1.0) :
  AliRsnCutSet(name, AliRsnTarget::kDaughter),
  fPID(pid),
  fAppliedCutSetID(cutSetID),
  fNsigmaTPC(nSigmaFast),
  fNsigmaTOF(nSigmaFast),
  fCutQuality(rsnTrackQualityCut),
  fAODTrkCutFilterBit(0),
  fCheckOnlyFilterBit(kFALSE),
  fUseCustomQualityCuts(kTRUE)
{
  //
  // Constructor: uses externally-defined track-quality cut object
  //
  if (!rsnTrackQualityCut) {
    //if external track quality cut object not defined,
    //sets default track quality to be initialised +
    //sets here pt and eta cuts
    InitStdQualityCuts();
    SetPtRange(0.15, 20.0);
    SetEtaRange(-0.8, 0.8);
  } else {
    //checks validity of passed quality-cut object
    //if Ok, inherits all cuts including Pt and Eta cut
    fCheckOnlyFilterBit=kFALSE;
    fUseCustomQualityCuts = kTRUE;
    SetPtRange(rsnTrackQualityCut->GetPtRange(0), rsnTrackQualityCut->GetPtRange(1));
    SetEtaRange(rsnTrackQualityCut->GetEtaRange(0),rsnTrackQualityCut->GetEtaRange(1));
    AliInfo("Custom quality cuts applied");
    rsnTrackQualityCut->Print();
  } 
  
  //if nsigma not specified, sets "no-PID" cuts
  if (nSigmaFast<=0){
    fNsigmaTPC=1e20;
    fNsigmaTOF=1e20;
    AliWarning("Requested fast n-sigma PID with negative value for n. --> Setting n = 1E20");
  } 
  
  //initialize PID cuts
  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),
  fCheckOnlyFilterBit(copy.fCheckOnlyFilterBit),
  fUseCustomQualityCuts(copy.fUseCustomQualityCuts)
{
  //
  // copy constructor
  SetPtRange(copy.fPtRange[0], copy.fPtRange[1]);
  SetEtaRange(copy.fEtaRange[0], copy.fEtaRange[1]);
}

//__________________________________________________________________________________________________
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;
   fCheckOnlyFilterBit=copy.fCheckOnlyFilterBit;
   fUseCustomQualityCuts=copy.fUseCustomQualityCuts;
   fCutQuality=copy.fCutQuality;
   return (*this);
}

//----------------------------------------------------------------------------
AliRsnCutSetDaughterParticle::~AliRsnCutSetDaughterParticle()
{
   //
   //destructor
   //
   if (fCutQuality)
      delete fCutQuality;
}

//----------------------------------------------------------------------------
void AliRsnCutSetDaughterParticle::Init()
{
  
  //define TOF match cut
  AliRsnCutTOFMatch  *iCutTOFMatch     = new AliRsnCutTOFMatch("CutTOFMatch");
  //define PID cuts
  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 );
  //define phi (azimuthal angle) cuts for TRD presence
  AliRsnCutPhi  *iCutPhiTRD2010        = new AliRsnCutPhi("CutPhiTRD2010","InTRD CheckTOF");
  AliRsnCutPhi  *iCutPhiNoTRD2010      = new AliRsnCutPhi("CutPhiNoTRD2010","OutTRD CheckTOF");
  
  //
  //defines cut schemes by combining quality cuts and PID cuts
  //
  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;
   
   case AliRsnCutSetDaughterParticle::kTOFMatchPPB2011: //pA analysis
     AddCut(fCutQuality);
     AddCut(iCutTOFMatch);
     SetCutScheme( Form("%s&(%s)",fCutQuality->GetName(), iCutTOFMatch->GetName()) );
     break;

   case AliRsnCutSetDaughterParticle::kTPCpidKstarPPB2011:
     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::kTOFpidKstarPPB2011:
     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::kTPCTOFpidKstarPPB2011:
     /* 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::kTPCpidTOFvetoKStarPPB2011:
     if (fNsigmaTPC <= 0.0) {
       AliWarning(Form("Invalid number of sigmas required for %s. Setting nSigma = 5.0",iCutTPCNSigma->GetName()));
       SetNsigmaForFastTPCpid(5.0);
     }
     iCutTPCNSigma->SinglePIDRange(fNsigmaTPC);
     
     if(fNsigmaTPC==3.0)
       iCutTOFNSigma->SinglePIDRange(5.0);
     if(fNsigmaTPC==2.0)
       iCutTOFNSigma->SinglePIDRange(3.0);
     
     AddCut(fCutQuality);
     AddCut(iCutTPCNSigma);
     AddCut(iCutTOFNSigma);
     
     // scheme:
     // quality & [ (TPCsigma & TOFsigma-2) ]
     SetCutScheme( Form("%s&%s&%s",fCutQuality->GetName(),iCutTPCNSigma->GetName(),iCutTOFNSigma->GetName()) ) ;
     break;
     
   case AliRsnCutSetDaughterParticle::kTPCpidMatchPPB2011:
     if (fNsigmaTPC <= 0.0) {
       AliWarning(Form("Invalid number of sigmas required for %s. Setting nSigma = 5.0",iCutTPCNSigma->GetName()));
       SetNsigmaForFastTPCpid(5.0);
     }
     iCutTPCNSigma->SinglePIDRange(fNsigmaTPC);
     AddCut(fCutQuality);
     AddCut(iCutTPCNSigma);
     AddCut(iCutTOFMatch);
     SetCutScheme( Form("%s&%s&%s",fCutQuality->GetName(), iCutTPCNSigma->GetName(),iCutTOFMatch->GetName()) );
     break;

   default :
     break;
   }

}


//-----------------------------------------------
void AliRsnCutSetDaughterParticle::PrintTrackQualityCuts()
{
  //Prints track quality cuts
  fCutQuality->Print();
  return;
}

//-----------------------------------------------
void AliRsnCutSetDaughterParticle::InitStdQualityCuts()
{
  // initialize quality std (if not externally defined) and PID cuts
  // init cut sets by setting variable params
  // 
  Bool_t isUse2011stdQualityCuts = ((fAppliedCutSetID==AliRsnCutSetDaughterParticle::kQualityStd2011) ||
				    (fAppliedCutSetID==AliRsnCutSetDaughterParticle::kTOFMatchPPB2011) || //pA analysis
				    (fAppliedCutSetID==AliRsnCutSetDaughterParticle::kTPCpidKstarPPB2011) ||
				    (fAppliedCutSetID==AliRsnCutSetDaughterParticle::kTOFpidKstarPPB2011) ||
				    (fAppliedCutSetID==AliRsnCutSetDaughterParticle::kTPCTOFpidKstarPPB2011) ||
				    (fAppliedCutSetID==AliRsnCutSetDaughterParticle::kTPCpidTOFvetoKStarPPB2011) ||
				    (fAppliedCutSetID==AliRsnCutSetDaughterParticle::kTPCpidMatchPPB2011));
  if (isUse2011stdQualityCuts) {
    fCutQuality->SetDefaults2011();//uses filter bit 10 as default
    fCutQuality->SetAODTestFilterBit(fAODTrkCutFilterBit); //changes default filter bit 10 to the chosen filter bit
  } else {
    fCutQuality->SetDefaults2010();
    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);
  }
  
  //apply pt and eta cuts
  fCutQuality->SetPtRange(fPtRange[0], fPtRange[1]);
  fCutQuality->SetEtaRange(fEtaRange[0], fEtaRange[1]);
  AliInfo("Standard quality cuts applied");
  fCutQuality->Print();
  return;
}
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),
536339fc	26	fAODTrkCutFilterBit(0),
e1fec9d4	27	fCheckOnlyFilterBit(kTRUE),
e1fec9d4	28	fUseCustomQualityCuts(kFALSE)
9cdd5474	29	{
	30	//
	31	// Default constructor
e1fec9d4	32	SetPtRange(0.0, 1E20);
e1fec9d4	33	SetEtaRange(1E20, 1E20);
9cdd5474	34	}
	35
	36	//__________________________________________________________________________________________________
a6430459	37	AliRsnCutSetDaughterParticle::AliRsnCutSetDaughterParticle(const char *name, AliRsnCutSetDaughterParticle::ERsnDaughterCutSet cutSetID, AliPID::EParticleType pid, Float_t nSigmaFast = -1.0, Int_t AODfilterBit = 0) :
e6952ec7	38	AliRsnCutSet(name, AliRsnTarget::kDaughter),
	39	fPID(pid),
	40	fAppliedCutSetID(cutSetID),
9006f1a2	41	fNsigmaTPC(nSigmaFast),
9006f1a2	42	fNsigmaTOF(nSigmaFast),
e6952ec7	43	fCutQuality(new AliRsnCutTrackQuality("CutQuality")),
536339fc	44	fAODTrkCutFilterBit(AODfilterBit),
e1fec9d4	45	fCheckOnlyFilterBit(kTRUE),
e1fec9d4	46	fUseCustomQualityCuts(kFALSE)
9cdd5474	47	{
	48	//
	49	// Constructor
	50	//
e1fec9d4	51	//set here pt and eta range
	52	SetPtRange(0.15, 20.0);
	53	SetEtaRange(-0.8, 0.8);
	54
	55	//if nsigma not specified, sets "no-PID" cuts
9006f1a2	56	if (nSigmaFast<=0){
	57	fNsigmaTPC=1e20;
	58	fNsigmaTOF=1e20;
	59	AliWarning("Requested fast n-sigma PID with negative value for n. --> Setting n = 1E20");
e1fec9d4	60	}
	61
	62	//initialize quality std and PID cuts
	63	InitStdQualityCuts();
9006f1a2	64	Init();
9cdd5474	65	}
9cdd5474	66
e1fec9d4	67	//__________________________________________________________________________________________________
	68	AliRsnCutSetDaughterParticle::AliRsnCutSetDaughterParticle(const char name, AliRsnCutTrackQuality rsnTrackQualityCut, AliRsnCutSetDaughterParticle::ERsnDaughterCutSet cutSetID, AliPID::EParticleType pid, Float_t nSigmaFast = -1.0) :
	69	AliRsnCutSet(name, AliRsnTarget::kDaughter),
	70	fPID(pid),
	71	fAppliedCutSetID(cutSetID),
	72	fNsigmaTPC(nSigmaFast),
	73	fNsigmaTOF(nSigmaFast),
	74	fCutQuality(rsnTrackQualityCut),
	75	fAODTrkCutFilterBit(0),
	76	fCheckOnlyFilterBit(kFALSE),
	77	fUseCustomQualityCuts(kTRUE)
	78	{
	79	//
	80	// Constructor: uses externally-defined track-quality cut object
	81	//
	82	if (!rsnTrackQualityCut) {
	83	//if external track quality cut object not defined,
	84	//sets default track quality to be initialised +
	85	//sets here pt and eta cuts
	86	InitStdQualityCuts();
	87	SetPtRange(0.15, 20.0);
	88	SetEtaRange(-0.8, 0.8);
	89	} else {
	90	//checks validity of passed quality-cut object
	91	//if Ok, inherits all cuts including Pt and Eta cut
	92	fCheckOnlyFilterBit=kFALSE;
	93	fUseCustomQualityCuts = kTRUE;
	94	SetPtRange(rsnTrackQualityCut->GetPtRange(0), rsnTrackQualityCut->GetPtRange(1));
	95	SetEtaRange(rsnTrackQualityCut->GetEtaRange(0),rsnTrackQualityCut->GetEtaRange(1));
	96	AliInfo("Custom quality cuts applied");
	97	rsnTrackQualityCut->Print();
	98	}
	99
	100	//if nsigma not specified, sets "no-PID" cuts
	101	if (nSigmaFast<=0){
	102	fNsigmaTPC=1e20;
	103	fNsigmaTOF=1e20;
	104	AliWarning("Requested fast n-sigma PID with negative value for n. --> Setting n = 1E20");
	105	}
	106
	107	//initialize PID cuts
	108	Init();
	109	}
	110
	111
9cdd5474	112	//__________________________________________________________________________________________________
9cdd5474	113	AliRsnCutSetDaughterParticle::AliRsnCutSetDaughterParticle(const AliRsnCutSetDaughterParticle &copy) :
e1fec9d4	114	AliRsnCutSet(copy),
	115	fPID(copy.fPID),
	116	fAppliedCutSetID(copy.fAppliedCutSetID),
	117	fNsigmaTPC(copy.fNsigmaTPC),
	118	fNsigmaTOF(copy.fNsigmaTOF),
	119	fCutQuality(copy.fCutQuality),
	120	fAODTrkCutFilterBit(copy.fAODTrkCutFilterBit),
	121	fCheckOnlyFilterBit(copy.fCheckOnlyFilterBit),
	122	fUseCustomQualityCuts(copy.fUseCustomQualityCuts)
9cdd5474	123	{
e1fec9d4	124	//
	125	// copy constructor
	126	SetPtRange(copy.fPtRange[0], copy.fPtRange[1]);
	127	SetEtaRange(copy.fEtaRange[0], copy.fEtaRange[1]);
9cdd5474	128	}
	129
	130	//__________________________________________________________________________________________________
	131	AliRsnCutSetDaughterParticle &AliRsnCutSetDaughterParticle::operator=(const AliRsnCutSetDaughterParticle &copy)
e6952ec7	132	{
9cdd5474	133	//
9cdd5474	134	// operator =
e6952ec7	135	//
	136	AliRsnCutSet::operator=(copy);
	137	if (this == &copy)
	138	return *this;
	139	fPID=copy.fPID;
	140	fAppliedCutSetID=copy.fAppliedCutSetID;
	141	fNsigmaTPC=copy.fNsigmaTPC;
	142	fNsigmaTOF=copy.fNsigmaTOF;
	143	fAODTrkCutFilterBit=copy.fAODTrkCutFilterBit;
536339fc	144	fCheckOnlyFilterBit=copy.fCheckOnlyFilterBit;
e1fec9d4	145	fUseCustomQualityCuts=copy.fUseCustomQualityCuts;
e6952ec7	146	fCutQuality=copy.fCutQuality;
e6952ec7	147	return (*this);
9cdd5474	148	}
9cdd5474	149
a6430459	150	//----------------------------------------------------------------------------
	151	AliRsnCutSetDaughterParticle::~AliRsnCutSetDaughterParticle()
	152	{
e6952ec7	153	//
	154	//destructor
	155	//
	156	if (fCutQuality)
	157	delete fCutQuality;
a6430459	158	}
e1fec9d4	159
9cdd5474	160	//----------------------------------------------------------------------------
e6952ec7	161	void AliRsnCutSetDaughterParticle::Init()
e6952ec7	162	{
319ac306	163
e1fec9d4	164	//define TOF match cut
319ac306	165	AliRsnCutTOFMatch *iCutTOFMatch = new AliRsnCutTOFMatch("CutTOFMatch");
e1fec9d4	166	//define PID cuts
	167	AliRsnCutPIDNSigma *iCutTPCNSigma = new AliRsnCutPIDNSigma("CutTPCNSigma", fPID, AliRsnCutPIDNSigma::kTPC);//, AliRsnCutPIDNSigma::kTPCinnerP );
	168	AliRsnCutPIDNSigma *iCutTPCTOFNSigma = new AliRsnCutPIDNSigma("CutTPCTOFNSigma", fPID, AliRsnCutPIDNSigma::kTPC);//, AliRsnCutPIDNSigma::kTPCinnerP );
	169	AliRsnCutPIDNSigma *iCutTOFNSigma = new AliRsnCutPIDNSigma("CutTOFNSigma", fPID, AliRsnCutPIDNSigma::kTOF);//, AliRsnCutPIDNSigma::kP );
	170	//define phi (azimuthal angle) cuts for TRD presence
	171	AliRsnCutPhi *iCutPhiTRD2010 = new AliRsnCutPhi("CutPhiTRD2010","InTRD CheckTOF");
	172	AliRsnCutPhi *iCutPhiNoTRD2010 = new AliRsnCutPhi("CutPhiNoTRD2010","OutTRD CheckTOF");
	173
	174	//
	175	//defines cut schemes by combining quality cuts and PID cuts
	176	//
	177	switch (fAppliedCutSetID)
	178	{
e6952ec7	179	case AliRsnCutSetDaughterParticle::kNoCuts :
	180	AliInfo("No cuts applied to daughter particle");
	181	break;
	182
	183	case AliRsnCutSetDaughterParticle::kQualityStd2010 :
	184	AddCut(fCutQuality);
	185	SetCutScheme(fCutQuality->GetName());
	186	break;
	187
	188	case AliRsnCutSetDaughterParticle::kQualityStd2011:
	189	//fCutQuality->SetAODTestFilterBit(10); //1024
	190	AddCut(fCutQuality);
	191	SetCutScheme(fCutQuality->GetName());
	192	break;
	193
	194	case AliRsnCutSetDaughterParticle::kTOFMatch :
	195	AddCut(fCutQuality);
	196	AddCut(iCutTOFMatch);
	197	SetCutScheme( Form("%s&(%s)",fCutQuality->GetName(), iCutTOFMatch->GetName()) );
	198	break;
	199
	200	case AliRsnCutSetDaughterParticle::kFastTPCpidNsigma :
	201	if (fNsigmaTPC <= 0.0) {
	202	AliWarning(Form("Invalid number of sigmas required for %s. Setting default nSigma = 10",iCutTPCNSigma->GetName()));
	203	SetNsigmaForFastTPCpid(10.0);
	204	}
	205	iCutTPCNSigma->SinglePIDRange(fNsigmaTPC);
	206	AddCut(fCutQuality);
	207	AddCut(iCutTPCNSigma);
	208	SetCutScheme( Form("%s&%s",fCutQuality->GetName(), iCutTPCNSigma->GetName()) );
	209	break;
	210
	211	case AliRsnCutSetDaughterParticle::kFastTOFpidNsigma :
	212	if (fNsigmaTOF <= 0.0) {
	213	AliWarning(Form("Invalid number of sigmas required for %s. Setting default nSigma = 10",iCutTOFNSigma->GetName()));
	214	SetNsigmaForFastTOFpid(10.0);
	215	}
	216	iCutTOFNSigma->SinglePIDRange(fNsigmaTOF);
	217	//iCutTOFNSigma->AddPIDRange(3.0, 0.35, 1E20);
	218	AddCut(fCutQuality);
	219	AddCut(iCutTOFNSigma);
	220	SetCutScheme( Form("%s&%s",fCutQuality->GetName(), iCutTOFNSigma->GetName()) );
	221	break;
	222
	223	case AliRsnCutSetDaughterParticle::kTPCTOFpidKstarPP2010 :
	224	/* Set TPC PID (if no TOF)*/
	225	// all below 350 MeV: 5sigma
	226	// all between 350 and 500 MeV: 3sigma
	227	// pios above 500 MeV: 2sigma
	228	// kaons between 500 and 700 MeV: 2sigma
	229	// kaons above 700 MeV: rejected
	230	iCutTPCNSigma->AddPIDRange(5.0, 0.0, 0.35);
	231	iCutTPCNSigma->AddPIDRange(3.0, 0.35, 0.5);
	232	if (fPID==AliPID::kPion)
	233	iCutTPCNSigma->AddPIDRange(2.0, 0.5, 1E20);
	234	if (fPID==AliPID::kKaon)
	235	iCutTPCNSigma->AddPIDRange(2.0, 0.5, 0.7);
	236
	237	AddCut(fCutQuality);
	238	AddCut(iCutTOFMatch);
	239	AddCut(iCutTPCNSigma);
	240
	241	/* set TPC+TOF PID*/
	242	iCutTPCTOFNSigma->SinglePIDRange(5.0);
243	iCutTOFNSigma->AddPIDRange(3.0, 0.0, 1.5);
244	iCutTOFNSigma->AddPIDRange(2.0, 1.5, 1E20);
245
246	AddCut(iCutTPCTOFNSigma);
247	AddCut(iCutTOFNSigma);
248
249	// scheme:
250	// quality & [ (TOF & TPCTOF) \|\| (!TOFmatch & TPConly) ]
251	SetCutScheme( Form("%s&((%s&%s)\|((!%s)&%s))",fCutQuality->GetName(), iCutTPCTOFNSigma->GetName(), iCutTOFNSigma->GetName(), iCutTOFMatch->GetName(), iCutTPCNSigma->GetName()) ) ;
252	break;
253
254	case AliRsnCutSetDaughterParticle::kTOFpidKstarPbPb2010:
255	if (fNsigmaTOF <= 0.0) {
256	AliWarning(Form("Invalid number of sigmas required for %s. Setting default nSigma = 10",iCutTOFNSigma->GetName()));
257	SetNsigmaForFastTOFpid(10.0);
258	}
259	iCutTOFNSigma->SinglePIDRange(fNsigmaTOF);
260	//iCutTOFNSigma->AddPIDRange(3.0, 0.35, 1E20);
261	iCutTPCTOFNSigma->SinglePIDRange(5.0); //5-sigma veto on tpc signal
262
263	AddCut(fCutQuality);
264	AddCut(iCutTOFNSigma);
265	AddCut(iCutTPCTOFNSigma);
266	SetCutScheme( Form("%s&%s&%s",fCutQuality->GetName(), iCutTOFNSigma->GetName(), iCutTPCTOFNSigma->GetName()) );
267	break;
268
269	case AliRsnCutSetDaughterParticle::kTOFTPCmismatchKstarPbPb2010:
270	iCutTPCTOFNSigma->SinglePIDRange(5.0); //5-sigma veto on tpc signal
271	AddCut(fCutQuality);
272	AddCut(iCutTOFMatch);
273	AddCut(iCutTPCTOFNSigma);
274	SetCutScheme( Form("%s&%s&%s",fCutQuality->GetName(), iCutTOFMatch->GetName(), iCutTPCTOFNSigma->GetName()) );
275	break;
319ac306	276
6b5662ca	277	case AliRsnCutSetDaughterParticle::kTOFMatchTRD2010 :
319ac306	278	AddCut(fCutQuality);
	279	AddCut(iCutTOFMatch);
	280	AddCut(iCutPhiTRD2010);
	281	SetCutScheme( Form("%s&%s&%s",fCutQuality->GetName(), iCutTOFMatch->GetName(), iCutPhiTRD2010->GetName()) );
	282	break;
6b5662ca	283
6b5662ca	284	case AliRsnCutSetDaughterParticle::kTOFMatchNoTRD2010 :
319ac306	285	AddCut(fCutQuality);
	286	AddCut(iCutTOFMatch);
	287	AddCut(iCutPhiNoTRD2010);
	288	SetCutScheme( Form("%s&%s&%s",fCutQuality->GetName(), iCutTOFMatch->GetName(), iCutPhiNoTRD2010->GetName()) );
	289	break;
6b5662ca	290
319ac306	291	case AliRsnCutSetDaughterParticle::kTOFpidKstarPbPbTRD2010:
	292	if (fNsigmaTOF <= 0.0) {
	293	AliWarning(Form("Invalid number of sigmas required for %s. Setting default nSigma = 10",iCutTOFNSigma->GetName()));
	294	SetNsigmaForFastTOFpid(10.0);
	295	}
	296	iCutTOFNSigma->SinglePIDRange(fNsigmaTOF);
	297	//iCutTOFNSigma->AddPIDRange(3.0, 0.35, 1E20);
	298	iCutTPCTOFNSigma->SinglePIDRange(5.0); //5-sigma veto on tpc signal
6b5662ca	299
319ac306	300	AddCut(fCutQuality);
	301	AddCut(iCutTOFNSigma);
	302	AddCut(iCutTPCTOFNSigma);
	303	AddCut(iCutPhiTRD2010);
	304	SetCutScheme( Form("%s&%s&%s&%s",fCutQuality->GetName(), iCutTOFNSigma->GetName(), iCutTPCTOFNSigma->GetName(),iCutPhiTRD2010->GetName()) );
	305	break;
6b5662ca	306
319ac306	307	case AliRsnCutSetDaughterParticle::kTOFpidKstarPbPbNoTRD2010:
	308	if (fNsigmaTOF <= 0.0) {
	309	AliWarning(Form("Invalid number of sigmas required for %s. Setting default nSigma = 10",iCutTOFNSigma->GetName()));
	310	SetNsigmaForFastTOFpid(10.0);
	311	}
	312	iCutTOFNSigma->SinglePIDRange(fNsigmaTOF);
	313	//iCutTOFNSigma->AddPIDRange(3.0, 0.35, 1E20);
	314	iCutTPCTOFNSigma->SinglePIDRange(5.0); //5-sigma veto on tpc signal
6b5662ca	315
319ac306	316	AddCut(fCutQuality);
	317	AddCut(iCutTOFNSigma);
	318	AddCut(iCutTPCTOFNSigma);
	319	AddCut(iCutPhiNoTRD2010);
	320	SetCutScheme( Form("%s&%s&%s&%s",fCutQuality->GetName(), iCutTOFNSigma->GetName(), iCutTPCTOFNSigma->GetName(),iCutPhiNoTRD2010->GetName()) );
	321	break;
6b5662ca	322
6b5662ca	323	case AliRsnCutSetDaughterParticle::kTOFMatchTPCpidNsigma :
319ac306	324	if (fNsigmaTPC <= 0.0) {
	325	AliWarning(Form("Invalid number of sigmas required for %s. Setting default nSigma = 10",iCutTPCNSigma->GetName()));
	326	SetNsigmaForFastTPCpid(10.0);
	327	}
	328	iCutTPCNSigma->SinglePIDRange(fNsigmaTPC);
	329	AddCut(fCutQuality);
	330	AddCut(iCutTPCNSigma);
	331	AddCut(iCutTOFMatch);
	332	SetCutScheme( Form("%s&%s&%s",fCutQuality->GetName(), iCutTPCNSigma->GetName(), iCutTOFMatch->GetName()) );
	333	break;
9664d398	334
	335	case AliRsnCutSetDaughterParticle::kQualityStd2010TRD:
	336	AddCut(fCutQuality);
	337	AddCut(iCutPhiTRD2010);
	338	SetCutScheme( Form("%s&%s",fCutQuality->GetName(),iCutPhiTRD2010->GetName()) );
	339	break;
	340
	341	case AliRsnCutSetDaughterParticle::kQualityStd2010NoTRD:
	342	AddCut(fCutQuality);
	343	AddCut(iCutPhiNoTRD2010);
	344	SetCutScheme( Form("%s&%s",fCutQuality->GetName(),iCutPhiNoTRD2010->GetName()) );
	345	break;
	346
b307bb43	347	case AliRsnCutSetDaughterParticle::kTOFMatchPPB2011: //pA analysis
	348	AddCut(fCutQuality);
	349	AddCut(iCutTOFMatch);
	350	SetCutScheme( Form("%s&(%s)",fCutQuality->GetName(), iCutTOFMatch->GetName()) );
	351	break;
	352
	353	case AliRsnCutSetDaughterParticle::kTPCpidKstarPPB2011:
	354	if (fNsigmaTPC <= 0.0) {
	355	AliWarning(Form("Invalid number of sigmas required for %s. Setting default nSigma = 10",iCutTPCNSigma->GetName()));
	356	SetNsigmaForFastTPCpid(10.0);
	357	}
	358	iCutTPCNSigma->SinglePIDRange(fNsigmaTPC);
	359	AddCut(fCutQuality);
	360	AddCut(iCutTPCNSigma);
	361	SetCutScheme( Form("%s&%s",fCutQuality->GetName(), iCutTPCNSigma->GetName()) );
	362	break;
	363
	364	case AliRsnCutSetDaughterParticle::kTOFpidKstarPPB2011:
	365	if (fNsigmaTOF <= 0.0) {
	366	AliWarning(Form("Invalid number of sigmas required for %s. Setting default nSigma = 10",iCutTOFNSigma->GetName()));
	367	SetNsigmaForFastTOFpid(10.0);
	368	}
	369	iCutTOFNSigma->SinglePIDRange(fNsigmaTOF);
	370	//iCutTOFNSigma->AddPIDRange(3.0, 0.35, 1E20);
	371	iCutTPCTOFNSigma->SinglePIDRange(5.0); //5-sigma veto on tpc signal
	372
	373	AddCut(fCutQuality);
	374	AddCut(iCutTOFNSigma);
	375	AddCut(iCutTPCTOFNSigma);
	376	SetCutScheme( Form("%s&%s&%s",fCutQuality->GetName(), iCutTOFNSigma->GetName(), iCutTPCTOFNSigma->GetName()) );
	377	break;
	378
	379	case AliRsnCutSetDaughterParticle::kTPCTOFpidKstarPPB2011:
	380	/* Set TPC PID (if no TOF)*/
	381	// all below 350 MeV: 5sigma
	382	// all between 350 and 500 MeV: 3sigma
	383	// pios above 500 MeV: 2sigma
	384	// kaons between 500 and 700 MeV: 2sigma
	385	// kaons above 700 MeV: rejected
	386	iCutTPCNSigma->AddPIDRange(5.0, 0.0, 0.35);
	387	iCutTPCNSigma->AddPIDRange(3.0, 0.35, 0.5);
	388	if (fPID==AliPID::kPion)
	389	iCutTPCNSigma->AddPIDRange(2.0, 0.5, 1E20);
	390	if (fPID==AliPID::kKaon)
	391	iCutTPCNSigma->AddPIDRange(2.0, 0.5, 0.7);
	392
	393	AddCut(fCutQuality);
	394	AddCut(iCutTOFMatch);
	395	AddCut(iCutTPCNSigma);
	396
	397	/* set TPC+TOF PID*/
	398	iCutTPCTOFNSigma->SinglePIDRange(5.0);
	399	iCutTOFNSigma->AddPIDRange(3.0, 0.0, 1.5);
	400	iCutTOFNSigma->AddPIDRange(2.0, 1.5, 1E20);
	401
	402	AddCut(iCutTPCTOFNSigma);
	403	AddCut(iCutTOFNSigma);
	404
	405	// scheme:
	406	// quality & [ (TOF & TPCTOF) \|\| (!TOFmatch & TPConly) ]
	407	SetCutScheme( Form("%s&((%s&%s)\|((!%s)&%s))",fCutQuality->GetName(), iCutTPCTOFNSigma->GetName(), iCutTOFNSigma->GetName(), iCutTOFMatch->GetName(), iCutTPCNSigma->GetName()) ) ;
	408	break;
319ac306	409
	410
	411	case AliRsnCutSetDaughterParticle::kTPCpidTOFvetoKStarPPB2011:
	412	if (fNsigmaTPC <= 0.0) {
	413	AliWarning(Form("Invalid number of sigmas required for %s. Setting nSigma = 5.0",iCutTPCNSigma->GetName()));
	414	SetNsigmaForFastTPCpid(5.0);
	415	}
	416	iCutTPCNSigma->SinglePIDRange(fNsigmaTPC);
	417
	418	if(fNsigmaTPC==3.0)
	419	iCutTOFNSigma->SinglePIDRange(5.0);
	420	if(fNsigmaTPC==2.0)
	421	iCutTOFNSigma->SinglePIDRange(3.0);
	422
	423	AddCut(fCutQuality);
	424	AddCut(iCutTPCNSigma);
	425	AddCut(iCutTOFNSigma);
	426
	427	// scheme:
	428	// quality & [ (TPCsigma & TOFsigma-2) ]
	429	SetCutScheme( Form("%s&%s&%s",fCutQuality->GetName(),iCutTPCNSigma->GetName(),iCutTOFNSigma->GetName()) ) ;
	430	break;
	431
	432	case AliRsnCutSetDaughterParticle::kTPCpidMatchPPB2011:
	433	if (fNsigmaTPC <= 0.0) {
	434	AliWarning(Form("Invalid number of sigmas required for %s. Setting nSigma = 5.0",iCutTPCNSigma->GetName()));
	435	SetNsigmaForFastTPCpid(5.0);
	436	}
	437	iCutTPCNSigma->SinglePIDRange(fNsigmaTPC);
	438	AddCut(fCutQuality);
	439	AddCut(iCutTPCNSigma);
	440	AddCut(iCutTOFMatch);
	441	SetCutScheme( Form("%s&%s&%s",fCutQuality->GetName(), iCutTPCNSigma->GetName(),iCutTOFMatch->GetName()) );
	442	break;
9664d398	443
319ac306	444	default :
319ac306	445	break;
e6952ec7	446	}
e6952ec7	447
9cdd5474	448	}
	449
	450
e1fec9d4	451	//-----------------------------------------------
	452	void AliRsnCutSetDaughterParticle::PrintTrackQualityCuts()
	453	{
	454	//Prints track quality cuts
	455	fCutQuality->Print();
	456	return;
	457	}
9cdd5474	458
e1fec9d4	459	//-----------------------------------------------
	460	void AliRsnCutSetDaughterParticle::InitStdQualityCuts()
	461	{
	462	// initialize quality std (if not externally defined) and PID cuts
	463	// init cut sets by setting variable params
	464	//
	465	Bool_t isUse2011stdQualityCuts = ((fAppliedCutSetID==AliRsnCutSetDaughterParticle::kQualityStd2011) \|\|
	466	(fAppliedCutSetID==AliRsnCutSetDaughterParticle::kTOFMatchPPB2011) \|\| //pA analysis
	467	(fAppliedCutSetID==AliRsnCutSetDaughterParticle::kTPCpidKstarPPB2011) \|\|
	468	(fAppliedCutSetID==AliRsnCutSetDaughterParticle::kTOFpidKstarPPB2011) \|\|
	469	(fAppliedCutSetID==AliRsnCutSetDaughterParticle::kTPCTOFpidKstarPPB2011) \|\|
	470	(fAppliedCutSetID==AliRsnCutSetDaughterParticle::kTPCpidTOFvetoKStarPPB2011) \|\|
	471	(fAppliedCutSetID==AliRsnCutSetDaughterParticle::kTPCpidMatchPPB2011));
	472	if (isUse2011stdQualityCuts) {
	473	fCutQuality->SetDefaults2011();//uses filter bit 10 as default
	474	fCutQuality->SetAODTestFilterBit(fAODTrkCutFilterBit); //changes default filter bit 10 to the chosen filter bit
	475	} else {
	476	fCutQuality->SetDefaults2010();
	477	fCutQuality->SetDCARPtFormula("0.0182+0.0350/pt^1.01");
	478	fCutQuality->SetDCAZmax(2.0);
	479	fCutQuality->SetSPDminNClusters(1);
	480	fCutQuality->SetITSminNClusters(0);
	481	fCutQuality->SetITSmaxChi2(36);
	482	fCutQuality->SetTPCminNClusters(70);
	483	fCutQuality->SetTPCmaxChi2(4.0);
	484	fCutQuality->SetRejectKinkDaughters();
	485	fCutQuality->SetAODTestFilterBit(fAODTrkCutFilterBit);
	486	//fCutQuality->SetITSmaxChi2(36);
	487	//fCutQuality->SetMaxChi2TPCConstrainedGlobal(36);
	488	}
	489
	490	//apply pt and eta cuts
	491	fCutQuality->SetPtRange(fPtRange[0], fPtRange[1]);
	492	fCutQuality->SetEtaRange(fEtaRange[0], fEtaRange[1]);
	493	AliInfo("Standard quality cuts applied");
	494	fCutQuality->Print();
	495	return;
	496	}