[u/mrichter/AliRoot.git] / PWG2 / RESONANCES / AliRsnCutESD2010.cxx

//
// Class AliRsnCutESD2010
//
// General implementation of a single cut strategy, which can be:
// - a value contained in a given interval  [--> IsBetween()   ]
// - a value equal to a given reference     [--> MatchesValue()]
//
// In all cases, the reference value(s) is (are) given as data members
// and each kind of cut requires a given value type (Int, UInt, Double),
// but the cut check procedure is then automatized and chosen thanks to
// an enumeration of the implemented cut types.
// At the end, the user (or any other point which uses this object) has
// to use the method IsSelected() to check if this cut has been passed.
//
// authors: Martin Vala (martin.vala@cern.ch)
//          Alberto Pulvirenti (alberto.pulvirenti@ct.infn.it)
//

#include <Riostream.h>

#include "AliESDpid.h"
#include "AliITSPIDResponse.h"

#include "AliRsnEvent.h"
#include "AliRsnDaughter.h"
#include "AliRsnCutESD2010.h"

ClassImp(AliRsnCutESD2010)

//_________________________________________________________________________________________________
AliRsnCutESD2010::AliRsnCutESD2010
(const char *name, Bool_t isMC) :
   AliRsnCut(name, AliRsnCut::kDaughter, 0.0, 0.0),
   fIsMC(isMC),
   fCheckITS(kTRUE),
   fCheckTPC(kTRUE),
   fCheckTOF(kTRUE),
   fUseITSTPC(kTRUE),
   fUseITSSA(kTRUE),
   fPID(AliPID::kKaon),
   fMaxITSPIDmom(0.0),
   fMaxITSband(3.0),
   fTPCpLimit(0.35),
   fMinTPCband(3.0),
   fMaxTPCband(5.0),
   fESDpid(),
   fESDtrackCutsTPC(),
   fESDtrackCutsITS(),
   fMinTOF(-3.0),
   fMaxTOF(3.0)
{
//
// Main constructor.
//

   SetMC(isMC);
   
   for (Int_t i = 0; i < 5; i++) fTPCpar[i] = 0.0;
}

//_________________________________________________________________________________________________
AliRsnCutESD2010::AliRsnCutESD2010
(const AliRsnCutESD2010& copy) :
   AliRsnCut(copy),
   fIsMC(copy.fIsMC),
   fCheckITS(copy.fCheckITS),
   fCheckTPC(copy.fCheckTPC),
   fCheckTOF(copy.fCheckTOF),
   fUseITSTPC(copy.fUseITSTPC),
   fUseITSSA(copy.fUseITSSA),
   fPID(copy.fPID),
   fMaxITSPIDmom(copy.fMaxITSPIDmom),
   fMaxITSband(copy.fMaxITSband),
   fTPCpLimit(copy.fTPCpLimit),
   fMinTPCband(copy.fMinTPCband),
   fMaxTPCband(copy.fMaxTPCband),
   fESDpid(copy.fESDpid),
   fESDtrackCutsTPC(copy.fESDtrackCutsTPC),
   fESDtrackCutsITS(copy.fESDtrackCutsITS),
   fMinTOF(copy.fMinTOF),
   fMaxTOF(copy.fMaxTOF)
{
//
// Copy constructor.
//

   SetMC(copy.fIsMC);

   Int_t i = 0;
   for (i = 0; i < 5; i++) fTPCpar[i] = copy.fTPCpar[i];
}

//_________________________________________________________________________________________________
AliRsnCutESD2010& AliRsnCutESD2010::operator=(const AliRsnCutESD2010& copy)
{
//
// Assignment operator
//

   AliRsnCut::operator=(copy);

   SetMC(copy.fIsMC);

   fCheckITS = copy.fCheckITS;
   fCheckTPC = copy.fCheckTPC;
   fCheckTOF = copy.fCheckTOF;
   fUseITSTPC = copy.fUseITSTPC;
   fUseITSSA = copy.fUseITSSA;
   fPID = copy.fPID;
   fMaxITSPIDmom = copy.fMaxITSPIDmom;
   fMaxITSband = copy.fMaxITSband;
   fTPCpLimit = copy.fTPCpLimit;
   fMinTPCband = copy.fMinTPCband;
   fMaxTPCband = copy.fMaxTPCband;
   fMinTOF = copy.fMinTOF;
   fMaxTOF = copy.fMaxTOF;
   fESDpid = copy.fESDpid;

   Int_t i = 0;
   for (i = 0; i < 5; i++) fTPCpar[i] = copy.fTPCpar[i];


   fESDtrackCutsTPC = copy.fESDtrackCutsTPC;
   fESDtrackCutsITS = copy.fESDtrackCutsITS;

   return (*this);
}

//_________________________________________________________________________________________________
void AliRsnCutESD2010::SetMC(Bool_t isMC)
{
//
// Sets some aspects of cuts depending on the fact that runs on MC or not
//

   fIsMC = isMC;

   AliITSPIDResponse itsresponse(fIsMC);
   fESDpid.GetITSResponse() = itsresponse;
}

//_________________________________________________________________________________________________
Bool_t AliRsnCutESD2010::IsSelected(TObject *object)
{
//
// Cut checker.
//

   // coherence check: require an ESD track
   if (!TargetOK(object)) return kFALSE;
   AliESDtrack *track = fDaughter->GetRefESDtrack();
   if (!track) return kFALSE;

   // if no reference event, skip
   AliRsnEvent *rsn = fEvent;
   if (!rsn) return kFALSE;
   fESDpid.SetTOFResponse(rsn->GetRefESD(), AliESDpid::kTOF_T0);

   // check quality and track type and reject tracks not passing this step
   if (!OkQuality(track)) {
      AliDebug(AliLog::kDebug + 2, "Failed quality cut");
      return kFALSE;
   }

   // ITS PID can be checked always
   // if PID is not required, the flag is sed as
   // if the cut was alsways passed
   Bool_t okITSpid = OkITSPID(track);
   if (!fCheckITS) okITSpid = kTRUE;

   // TPC PID can be checked only for TPC+ITS tracks
   // if PID is not required, the flag is sed as
   // if the cut was alsways passed
   Bool_t okTPCpid = kFALSE;
   if (IsITSTPC(track)) okTPCpid = OkTPCPID(track);
   if (!fCheckTPC) okTPCpid = kTRUE;

   // TOF PID can be checked only if TOF is matched
   // if PID is not required, the flag is sed as
   // if the cut was alsways passed
   Bool_t okTOFpid = kFALSE;
   if (IsITSTPC(track) && MatchTOF(track)) okTOFpid = OkTOFPID(track);
   if (!fCheckTOF) okTOFpid = kTRUE;

   // now combine all outcomes according to the different possibilities:
   // -- ITS standalone:
   //    --> only ITS PID, always
   // -- ITS + TPC:
   //    --> ITS PID, only for momenta lower than 'fMaxITSPIDmom' and when the ITSpid flag is active
   //    --> TPC PID, always --> MASTER (first to be checked, if fails, track is rejected)
   //    --> TOF PID, only if matched
   if (IsITSSA(track)) {
      if (!okITSpid) {
         AliDebug(AliLog::kDebug + 2, "ITS standalone track --> ITS PID failed");
         return kFALSE;
      }
   } else { // checking IsITSTPC() is redundant due to OkQuality() cut check
      if (!okTPCpid) {
         AliDebug(AliLog::kDebug + 2, "ITS+TPC track --> TPC PID failed");
         return kFALSE;
      } else if (MatchTOF(track) && !okTOFpid) {
         AliDebug(AliLog::kDebug + 2, "ITS+TPC track --> TOF matched but TOF PID failed");
         return kFALSE;
      } else if (track->IsOn(AliESDtrack::kITSpid) && track->P() <= fMaxITSPIDmom && !okITSpid) {
         AliDebug(AliLog::kDebug + 2, Form("ITS+TPC track --> Momentum lower than limit (%.2f) and ITS PID failed", fMaxITSPIDmom));
         return kFALSE;
      }
   }

   // arriving here, the track has survived all checks
   return kTRUE;
}

//______________________________________________________________________________
Bool_t AliRsnCutESD2010::OkQuality(AliESDtrack *track)
{
//
// Check track quality parameters.
// Rejects all tracks which are not either TPC+ITS nor ITS standalone.
// If tracks of any type are not flagged to be used, they are rejected anyway.
//

   if (IsITSTPC(track)) return (fUseITSTPC && fESDtrackCutsTPC.IsSelected(track));
   if (IsITSSA(track)) return (fUseITSSA  && fESDtrackCutsITS.IsSelected(track));

   return kFALSE;
}

//______________________________________________________________________________
Bool_t AliRsnCutESD2010::OkITSPID(AliESDtrack *track)
{
//
// Check ITS particle identification with 3sigma cut
//

   // count PID layers and reject if they are too few
   Int_t   k, nITSpidLayers = 0;
   UChar_t itsCluMap = track->GetITSClusterMap();
   for (k = 2; k < 6; k++) if (itsCluMap & (1 << k)) ++nITSpidLayers;
   if (nITSpidLayers < 3) {
      AliDebug(AliLog::kDebug + 2, "Rejecting track with too few ITS pid layers");
      return kFALSE;
   }

   // check the track type (ITS+TPC or ITS standalone)
   // and reject it if it is of none of the allowed types
   Bool_t isSA = kFALSE;
   if (IsITSTPC(track)) isSA = kFALSE;
   else if (IsITSSA(track)) isSA = kTRUE;
   else {
      AliWarning("Track is neither ITS+TPC nor ITS standalone");
      return kFALSE;
   }

   // create the PID response object and compute nsigma
   AliITSPIDResponse &itsrsp = fESDpid.GetITSResponse();
   Double_t mom    = track->P();
   Double_t nSigma = itsrsp.GetNumberOfSigmas(mom, track->GetITSsignal(), fPID, nITSpidLayers, isSA);

   // evaluate the cut
   Bool_t ok = (TMath::Abs(nSigma) <= fMaxITSband);

   // debug message
   AliDebug(AliLog::kDebug + 2, Form("ITS nsigma = %f -- max = %f -- cut %s", nSigma, fMaxITSband, (ok ? "passed" : "failed")));

   // outcome
   return ok;
}

//______________________________________________________________________________
Bool_t AliRsnCutESD2010::OkTPCPID(AliESDtrack *track)
{
//
// Check TPC particle identification with {3|5}sigmacut,
// depending on the track total momentum.
//

   // setup TPC PID response
   AliTPCPIDResponse &tpcrsp = fESDpid.GetTPCResponse();
   //tpcrsp.SetBetheBlochParameters(fTPCpar[0],fTPCpar[1],fTPCpar[2],fTPCpar[3],fTPCpar[4]);

   // get momentum and number of sigmas and choose the reference band
   Double_t mom       = track->GetInnerParam()->P();
   Double_t nSigma    = tpcrsp.GetNumberOfSigmas(mom, track->GetTPCsignal(), track->GetTPCsignalN(), fPID);
   Double_t maxNSigma = fMaxTPCband;
   if (mom < fTPCpLimit) maxNSigma = fMinTPCband;

   // evaluate the cut
   Bool_t ok = (TMath::Abs(nSigma) <= maxNSigma);

   // debug message
   AliDebug(AliLog::kDebug + 2, Form("TPC nsigma = %f -- max = %f -- cut %s", nSigma, maxNSigma, (ok ? "passed" : "failed")));

   // outcome
   return ok;
}

//______________________________________________________________________________
Bool_t AliRsnCutESD2010::OkTOFPID(AliESDtrack *track)
{
//
// Check TOF particle identification if matched there.
//

   // reject not TOF-matched tracks
   if (!MatchTOF(track)) return kFALSE;

   // setup TOF PID response
   AliTOFPIDResponse &tofrsp = fESDpid.GetTOFResponse();

   // get info for computation
   Double_t momentum = track->P();
   Double_t time     = track->GetTOFsignal();
   Double_t timeint[AliPID::kSPECIES];
   tofrsp.GetStartTime(momentum);
   track->GetIntegratedTimes(timeint);

   // check the cut
   Double_t timeDiff = time - timeint[(Int_t)fPID];
   Double_t sigmaRef = tofrsp.GetExpectedSigma(momentum, timeint[(Int_t)fPID], AliPID::ParticleMass(fPID));
   Double_t nSigma   = timeDiff / sigmaRef;

   // evaluate the cut
   Bool_t ok = (nSigma >= fMinTOF && nSigma <= fMaxTOF);

   // debug message
   AliDebug(AliLog::kDebug + 2, Form("TOF nsigma = %f -- range = %f - %f -- cut %s", nSigma, fMinTOF, fMaxTOF, (ok ? "passed" : "failed")));

   // outcome
   return ok;
}

//_________________________________________________________________________________________________
void AliRsnCutESD2010::Print(const Option_t *) const
{
//
// Print information on this cut
//

   AliInfo(Form("Cut name               : %s", GetName()));
   AliInfo(Form("Using MC settings      : %s", (fIsMC ? "YES" : "NO")));
   AliInfo(Form("Using TPC+ITS tracks   : %s", (fUseITSTPC ? "YES" : "NO")));
   AliInfo(Form("Using ITS SA  tracks   : %s", (fUseITSSA ? "YES" : "NO")));
   AliInfo(Form("Check ITS PID          : %s", (fCheckITS ? "YES" : "NO")));
   AliInfo(Form("Check TPC PID          : %s", (fCheckTPC ? "YES" : "NO")));
   AliInfo(Form("Check TOF PID          : %s", (fCheckTOF ? "YES" : "NO")));
   AliInfo(Form("Reference particle     : %s", AliPID::ParticleName(fPID)));
   AliInfo(Form("ITS PID range  (sigmas): %f", fMaxITSband));
   AliInfo(Form("ITS PID range  (pt)    : %f", fMaxITSPIDmom));
   AliInfo(Form("TPC PID ranges (sigmas): %f %f", fMinTPCband, fMaxTPCband));
   AliInfo(Form("TPC PID limit  (p)     : %f", fTPCpLimit));
   AliInfo(Form("TOF range (sigmas)     : %f - %f", fMinTOF, fMaxTOF));
}
Commit	Line	Data
2dab9030	1	//
	2	// Class AliRsnCutESD2010
	3	//
	4	// General implementation of a single cut strategy, which can be:
	5	// - a value contained in a given interval [--> IsBetween() ]
	6	// - a value equal to a given reference [--> MatchesValue()]
	7	//
	8	// In all cases, the reference value(s) is (are) given as data members
	9	// and each kind of cut requires a given value type (Int, UInt, Double),
	10	// but the cut check procedure is then automatized and chosen thanks to
	11	// an enumeration of the implemented cut types.
	12	// At the end, the user (or any other point which uses this object) has
	13	// to use the method IsSelected() to check if this cut has been passed.
	14	//
	15	// authors: Martin Vala (martin.vala@cern.ch)
	16	// Alberto Pulvirenti (alberto.pulvirenti@ct.infn.it)
	17	//
	18
	19	#include <Riostream.h>
	20
	21	#include "AliESDpid.h"
2dab9030	22	#include "AliITSPIDResponse.h"
	23
	24	#include "AliRsnEvent.h"
	25	#include "AliRsnDaughter.h"
	26	#include "AliRsnCutESD2010.h"
	27
	28	ClassImp(AliRsnCutESD2010)
	29
2dab9030	30	//_________________________________________________________________________________________________
2dab9030	31	AliRsnCutESD2010::AliRsnCutESD2010
7ca95a3a	32	(const char *name, Bool_t isMC) :
2a1c7696	33	AliRsnCut(name, AliRsnCut::kDaughter, 0.0, 0.0),
	34	fIsMC(isMC),
	35	fCheckITS(kTRUE),
	36	fCheckTPC(kTRUE),
	37	fCheckTOF(kTRUE),
	38	fUseITSTPC(kTRUE),
	39	fUseITSSA(kTRUE),
	40	fPID(AliPID::kKaon),
	41	fMaxITSPIDmom(0.0),
	42	fMaxITSband(3.0),
	43	fTPCpLimit(0.35),
	44	fMinTPCband(3.0),
	45	fMaxTPCband(5.0),
	46	fESDpid(),
	47	fESDtrackCutsTPC(),
	48	fESDtrackCutsITS(),
	49	fMinTOF(-3.0),
a3dd4b4d	50	fMaxTOF(3.0)
2dab9030	51	{
	52	//
	53	// Main constructor.
	54	//
96e9d35d	55
2a1c7696	56	SetMC(isMC);
245cd328	57
245cd328	58	for (Int_t i = 0; i < 5; i++) fTPCpar[i] = 0.0;
2dab9030	59	}
	60
	61	//_________________________________________________________________________________________________
	62	AliRsnCutESD2010::AliRsnCutESD2010
	63	(const AliRsnCutESD2010& copy) :
2a1c7696	64	AliRsnCut(copy),
	65	fIsMC(copy.fIsMC),
	66	fCheckITS(copy.fCheckITS),
	67	fCheckTPC(copy.fCheckTPC),
	68	fCheckTOF(copy.fCheckTOF),
	69	fUseITSTPC(copy.fUseITSTPC),
	70	fUseITSSA(copy.fUseITSSA),
	71	fPID(copy.fPID),
	72	fMaxITSPIDmom(copy.fMaxITSPIDmom),
	73	fMaxITSband(copy.fMaxITSband),
	74	fTPCpLimit(copy.fTPCpLimit),
	75	fMinTPCband(copy.fMinTPCband),
	76	fMaxTPCband(copy.fMaxTPCband),
	77	fESDpid(copy.fESDpid),
	78	fESDtrackCutsTPC(copy.fESDtrackCutsTPC),
	79	fESDtrackCutsITS(copy.fESDtrackCutsITS),
	80	fMinTOF(copy.fMinTOF),
a3dd4b4d	81	fMaxTOF(copy.fMaxTOF)
2dab9030	82	{
2dab9030	83	//
7ca95a3a	84	// Copy constructor.
2dab9030	85	//
96e9d35d	86
2a1c7696	87	SetMC(copy.fIsMC);
5faf5a07	88
2a1c7696	89	Int_t i = 0;
2a1c7696	90	for (i = 0; i < 5; i++) fTPCpar[i] = copy.fTPCpar[i];
2dab9030	91	}
	92
	93	//_________________________________________________________________________________________________
7ca95a3a	94	AliRsnCutESD2010& AliRsnCutESD2010::operator=(const AliRsnCutESD2010& copy)
2dab9030	95	{
2dab9030	96	//
7ca95a3a	97	// Assignment operator
2dab9030	98	//
c79c04e1	99
2a1c7696	100	AliRsnCut::operator=(copy);
	101
	102	SetMC(copy.fIsMC);
	103
	104	fCheckITS = copy.fCheckITS;
	105	fCheckTPC = copy.fCheckTPC;
	106	fCheckTOF = copy.fCheckTOF;
	107	fUseITSTPC = copy.fUseITSTPC;
	108	fUseITSSA = copy.fUseITSSA;
	109	fPID = copy.fPID;
	110	fMaxITSPIDmom = copy.fMaxITSPIDmom;
	111	fMaxITSband = copy.fMaxITSband;
	112	fTPCpLimit = copy.fTPCpLimit;
	113	fMinTPCband = copy.fMinTPCband;
	114	fMaxTPCband = copy.fMaxTPCband;
	115	fMinTOF = copy.fMinTOF;
	116	fMaxTOF = copy.fMaxTOF;
	117	fESDpid = copy.fESDpid;
a3dd4b4d	118
2a1c7696	119	Int_t i = 0;
	120	for (i = 0; i < 5; i++) fTPCpar[i] = copy.fTPCpar[i];
	121
	122
	123	fESDtrackCutsTPC = copy.fESDtrackCutsTPC;
	124	fESDtrackCutsITS = copy.fESDtrackCutsITS;
	125
	126	return (*this);
7ca95a3a	127	}
0359289f	128
7ca95a3a	129	//_________________________________________________________________________________________________
	130	void AliRsnCutESD2010::SetMC(Bool_t isMC)
	131	{
	132	//
	133	// Sets some aspects of cuts depending on the fact that runs on MC or not
	134	//
0359289f	135
2a1c7696	136	fIsMC = isMC;
	137
	138	AliITSPIDResponse itsresponse(fIsMC);
	139	fESDpid.GetITSResponse() = itsresponse;
2dab9030	140	}
	141
	142	//_________________________________________________________________________________________________
32992791	143	Bool_t AliRsnCutESD2010::IsSelected(TObject *object)
2dab9030	144	{
	145	//
	146	// Cut checker.
	147	//
	148
2a1c7696	149	// coherence check: require an ESD track
99261e24	150	if (!TargetOK(object)) return kFALSE;
99261e24	151	AliESDtrack *track = fDaughter->GetRefESDtrack();
2a1c7696	152	if (!track) return kFALSE;
	153
	154	// if no reference event, skip
d7712d44	155	AliRsnEvent *rsn = fEvent;
2a1c7696	156	if (!rsn) return kFALSE;
a3dd4b4d	157	fESDpid.SetTOFResponse(rsn->GetRefESD(), AliESDpid::kTOF_T0);
2a1c7696	158
	159	// check quality and track type and reject tracks not passing this step
	160	if (!OkQuality(track)) {
	161	AliDebug(AliLog::kDebug + 2, "Failed quality cut");
32992791	162	return kFALSE;
2a1c7696	163	}
	164
	165	// ITS PID can be checked always
	166	// if PID is not required, the flag is sed as
	167	// if the cut was alsways passed
	168	Bool_t okITSpid = OkITSPID(track);
	169	if (!fCheckITS) okITSpid = kTRUE;
	170
	171	// TPC PID can be checked only for TPC+ITS tracks
	172	// if PID is not required, the flag is sed as
	173	// if the cut was alsways passed
	174	Bool_t okTPCpid = kFALSE;
	175	if (IsITSTPC(track)) okTPCpid = OkTPCPID(track);
	176	if (!fCheckTPC) okTPCpid = kTRUE;
	177
	178	// TOF PID can be checked only if TOF is matched
	179	// if PID is not required, the flag is sed as
	180	// if the cut was alsways passed
	181	Bool_t okTOFpid = kFALSE;
	182	if (IsITSTPC(track) && MatchTOF(track)) okTOFpid = OkTOFPID(track);
	183	if (!fCheckTOF) okTOFpid = kTRUE;
	184
	185	// now combine all outcomes according to the different possibilities:
	186	// -- ITS standalone:
	187	// --> only ITS PID, always
	188	// -- ITS + TPC:
	189	// --> ITS PID, only for momenta lower than 'fMaxITSPIDmom' and when the ITSpid flag is active
	190	// --> TPC PID, always --> MASTER (first to be checked, if fails, track is rejected)
	191	// --> TOF PID, only if matched
	192	if (IsITSSA(track)) {
	193	if (!okITSpid) {
	194	AliDebug(AliLog::kDebug + 2, "ITS standalone track --> ITS PID failed");
	195	return kFALSE;
	196	}
	197	} else { // checking IsITSTPC() is redundant due to OkQuality() cut check
	198	if (!okTPCpid) {
	199	AliDebug(AliLog::kDebug + 2, "ITS+TPC track --> TPC PID failed");
	200	return kFALSE;
	201	} else if (MatchTOF(track) && !okTOFpid) {
	202	AliDebug(AliLog::kDebug + 2, "ITS+TPC track --> TOF matched but TOF PID failed");
	203	return kFALSE;
	204	} else if (track->IsOn(AliESDtrack::kITSpid) && track->P() <= fMaxITSPIDmom && !okITSpid) {
	205	AliDebug(AliLog::kDebug + 2, Form("ITS+TPC track --> Momentum lower than limit (%.2f) and ITS PID failed", fMaxITSPIDmom));
	206	return kFALSE;
	207	}
	208	}
	209
	210	// arriving here, the track has survived all checks
	211	return kTRUE;
32992791	212	}
	213
	214	//______________________________________________________________________________
	215	Bool_t AliRsnCutESD2010::OkQuality(AliESDtrack *track)
	216	{
	217	//
	218	// Check track quality parameters.
	219	// Rejects all tracks which are not either TPC+ITS nor ITS standalone.
	220	// If tracks of any type are not flagged to be used, they are rejected anyway.
	221	//
	222
2a1c7696	223	if (IsITSTPC(track)) return (fUseITSTPC && fESDtrackCutsTPC.IsSelected(track));
2a1c7696	224	if (IsITSSA(track)) return (fUseITSSA && fESDtrackCutsITS.IsSelected(track));
32992791	225
2a1c7696	226	return kFALSE;
32992791	227	}
0359289f	228
32992791	229	//______________________________________________________________________________
2a1c7696	230	Bool_t AliRsnCutESD2010::OkITSPID(AliESDtrack *track)
32992791	231	{
	232	//
	233	// Check ITS particle identification with 3sigma cut
	234	//
	235
2a1c7696	236	// count PID layers and reject if they are too few
	237	Int_t k, nITSpidLayers = 0;
	238	UChar_t itsCluMap = track->GetITSClusterMap();
	239	for (k = 2; k < 6; k++) if (itsCluMap & (1 << k)) ++nITSpidLayers;
	240	if (nITSpidLayers < 3) {
	241	AliDebug(AliLog::kDebug + 2, "Rejecting track with too few ITS pid layers");
	242	return kFALSE;
	243	}
	244
	245	// check the track type (ITS+TPC or ITS standalone)
	246	// and reject it if it is of none of the allowed types
	247	Bool_t isSA = kFALSE;
	248	if (IsITSTPC(track)) isSA = kFALSE;
	249	else if (IsITSSA(track)) isSA = kTRUE;
	250	else {
	251	AliWarning("Track is neither ITS+TPC nor ITS standalone");
	252	return kFALSE;
	253	}
	254
	255	// create the PID response object and compute nsigma
	256	AliITSPIDResponse &itsrsp = fESDpid.GetITSResponse();
	257	Double_t mom = track->P();
	258	Double_t nSigma = itsrsp.GetNumberOfSigmas(mom, track->GetITSsignal(), fPID, nITSpidLayers, isSA);
	259
	260	// evaluate the cut
	261	Bool_t ok = (TMath::Abs(nSigma) <= fMaxITSband);
	262
	263	// debug message
	264	AliDebug(AliLog::kDebug + 2, Form("ITS nsigma = %f -- max = %f -- cut %s", nSigma, fMaxITSband, (ok ? "passed" : "failed")));
	265
	266	// outcome
	267	return ok;
32992791	268	}
	269
	270	//______________________________________________________________________________
2a1c7696	271	Bool_t AliRsnCutESD2010::OkTPCPID(AliESDtrack *track)
32992791	272	{
	273	//
	274	// Check TPC particle identification with {3\|5}sigmacut,
	275	// depending on the track total momentum.
	276	//
	277
2a1c7696	278	// setup TPC PID response
	279	AliTPCPIDResponse &tpcrsp = fESDpid.GetTPCResponse();
	280	//tpcrsp.SetBetheBlochParameters(fTPCpar[0],fTPCpar[1],fTPCpar[2],fTPCpar[3],fTPCpar[4]);
	281
	282	// get momentum and number of sigmas and choose the reference band
	283	Double_t mom = track->GetInnerParam()->P();
	284	Double_t nSigma = tpcrsp.GetNumberOfSigmas(mom, track->GetTPCsignal(), track->GetTPCsignalN(), fPID);
	285	Double_t maxNSigma = fMaxTPCband;
	286	if (mom < fTPCpLimit) maxNSigma = fMinTPCband;
	287
	288	// evaluate the cut
	289	Bool_t ok = (TMath::Abs(nSigma) <= maxNSigma);
	290
	291	// debug message
	292	AliDebug(AliLog::kDebug + 2, Form("TPC nsigma = %f -- max = %f -- cut %s", nSigma, maxNSigma, (ok ? "passed" : "failed")));
	293
	294	// outcome
	295	return ok;
32992791	296	}
	297
	298	//______________________________________________________________________________
2a1c7696	299	Bool_t AliRsnCutESD2010::OkTOFPID(AliESDtrack *track)
32992791	300	{
	301	//
	302	// Check TOF particle identification if matched there.
	303	//
	304
2a1c7696	305	// reject not TOF-matched tracks
	306	if (!MatchTOF(track)) return kFALSE;
	307
	308	// setup TOF PID response
	309	AliTOFPIDResponse &tofrsp = fESDpid.GetTOFResponse();
	310
	311	// get info for computation
	312	Double_t momentum = track->P();
	313	Double_t time = track->GetTOFsignal();
	314	Double_t timeint[AliPID::kSPECIES];
	315	tofrsp.GetStartTime(momentum);
	316	track->GetIntegratedTimes(timeint);
	317
	318	// check the cut
	319	Double_t timeDiff = time - timeint[(Int_t)fPID];
	320	Double_t sigmaRef = tofrsp.GetExpectedSigma(momentum, timeint[(Int_t)fPID], AliPID::ParticleMass(fPID));
	321	Double_t nSigma = timeDiff / sigmaRef;
	322
	323	// evaluate the cut
	324	Bool_t ok = (nSigma >= fMinTOF && nSigma <= fMaxTOF);
	325
	326	// debug message
	327	AliDebug(AliLog::kDebug + 2, Form("TOF nsigma = %f -- range = %f - %f -- cut %s", nSigma, fMinTOF, fMaxTOF, (ok ? "passed" : "failed")));
	328
	329	// outcome
	330	return ok;
2dab9030	331	}
aa24e021	332
	333	//_________________________________________________________________________________________________
	334	void AliRsnCutESD2010::Print(const Option_t *) const
	335	{
	336	//
	337	// Print information on this cut
	338	//
	339
2a1c7696	340	AliInfo(Form("Cut name : %s", GetName()));
	341	AliInfo(Form("Using MC settings : %s", (fIsMC ? "YES" : "NO")));
	342	AliInfo(Form("Using TPC+ITS tracks : %s", (fUseITSTPC ? "YES" : "NO")));
	343	AliInfo(Form("Using ITS SA tracks : %s", (fUseITSSA ? "YES" : "NO")));
	344	AliInfo(Form("Check ITS PID : %s", (fCheckITS ? "YES" : "NO")));
	345	AliInfo(Form("Check TPC PID : %s", (fCheckTPC ? "YES" : "NO")));
	346	AliInfo(Form("Check TOF PID : %s", (fCheckTOF ? "YES" : "NO")));
	347	AliInfo(Form("Reference particle : %s", AliPID::ParticleName(fPID)));
	348	AliInfo(Form("ITS PID range (sigmas): %f", fMaxITSband));
	349	AliInfo(Form("ITS PID range (pt) : %f", fMaxITSPIDmom));
	350	AliInfo(Form("TPC PID ranges (sigmas): %f %f", fMinTPCband, fMaxTPCband));
	351	AliInfo(Form("TPC PID limit (p) : %f", fTPCpLimit));
2a1c7696	352	AliInfo(Form("TOF range (sigmas) : %f - %f", fMinTOF, fMaxTOF));
aa24e021	353	}