--- /dev/null
+//
+// Class AliRsnCutAOD2010
+//
+// 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 <TBits.h>
+
+#include "AliESDtrack.h"
+#include "AliAODTrack.h"
+
+#include "AliRsnEvent.h"
+#include "AliRsnDaughter.h"
+#include "AliRsnCutAOD2010.h"
+
+ClassImp(AliRsnCutAOD2010)
+
+//_________________________________________________________________________________________________
+AliRsnCutAOD2010::AliRsnCutAOD2010() :
+ AliRsnCut(AliRsnCut::kDaughter),
+
+ fIsMC(kFALSE),
+ fCheckITS(kTRUE),
+ fCheckTPC(kTRUE),
+ fCheckTOF(kTRUE),
+ fUseGlobal(kTRUE),
+ fUseITSSA(kTRUE),
+
+ fPIDtype(AliPID::kKaon),
+
+ fTPCminNclusters(70),
+ fTPCmaxChi2(4.0),
+ fTPCmaxNSigmaDCA(7.0),
+ fTPClowBand(5.0),
+ fTPChighBand(3.0),
+ fTPClowLimit(0.35),
+
+ fITSminNclusters(4),
+ fITSmaxChi2(2.5),
+ fITSmaxNSigmaDCA(7.0),
+ fITSband(3.0),
+
+ fTOFlowLimit(-2.5),
+ fTOFhighLimit(3.5),
+ fPID()
+{
+//
+// Default constructor.
+//
+
+ Int_t i = 0;
+ for (i = 0; i < 3; i++) fTPCparamDCA[i] = fITSparamDCA[i] = 0.0;
+ for (i = 0; i < 5; i++) fTPCparamBB[i] = 0.0;
+}
+
+//_________________________________________________________________________________________________
+AliRsnCutAOD2010::AliRsnCutAOD2010
+(const char *name) :
+ AliRsnCut(name, AliRsnCut::kDaughter, 0.0, 0.0),
+
+ fIsMC(kFALSE),
+ fCheckITS(kTRUE),
+ fCheckTPC(kTRUE),
+ fCheckTOF(kTRUE),
+ fUseGlobal(kTRUE),
+ fUseITSSA(kTRUE),
+
+ fPIDtype(AliPID::kKaon),
+
+ fTPCminNclusters(70),
+ fTPCmaxChi2(4.0),
+ fTPCmaxNSigmaDCA(7.0),
+ fTPClowBand(5.0),
+ fTPChighBand(3.0),
+ fTPClowLimit(0.35),
+
+ fITSminNclusters(4),
+ fITSmaxChi2(2.5),
+ fITSmaxNSigmaDCA(7.0),
+ fITSband(3.0),
+
+ fTOFlowLimit(-2.5),
+ fTOFhighLimit(3.5),
+ fPID()
+{
+//
+// Main constructor.
+//
+
+ Int_t i = 0;
+ for (i = 0; i < 3; i++) fTPCparamDCA[i] = fITSparamDCA[i] = 0.0;
+ for (i = 0; i < 5; i++) fTPCparamBB[i] = 0.0;
+}
+
+//_________________________________________________________________________________________________
+AliRsnCutAOD2010::AliRsnCutAOD2010
+(const AliRsnCutAOD2010& copy) :
+ AliRsnCut(copy),
+
+ fIsMC(copy.fIsMC),
+ fCheckITS(copy.fCheckITS),
+ fCheckTPC(copy.fCheckTPC),
+ fCheckTOF(copy.fCheckTOF),
+ fUseGlobal(copy.fUseGlobal),
+ fUseITSSA(copy.fUseITSSA),
+
+ fPIDtype(copy.fPIDtype),
+
+ fTPCminNclusters(copy.fTPCminNclusters),
+ fTPCmaxChi2(copy.fTPCmaxChi2),
+ fTPCmaxNSigmaDCA(copy.fTPCmaxNSigmaDCA),
+ fTPClowBand(copy.fTPClowBand),
+ fTPChighBand(copy.fTPChighBand),
+ fTPClowLimit(copy.fTPClowLimit),
+
+ fITSminNclusters(copy.fITSminNclusters),
+ fITSmaxChi2(copy.fITSmaxChi2),
+ fITSmaxNSigmaDCA(copy.fITSmaxNSigmaDCA),
+ fITSband(copy.fITSband),
+
+ fTOFlowLimit(copy.fTOFlowLimit),
+ fTOFhighLimit(copy.fTOFhighLimit),
+ fPID(copy.fPID)
+{
+//
+// Copy constructor
+//
+
+ Int_t i = 0;
+ for (i = 0; i < 3; i++)
+ {
+ fTPCparamDCA[i] = copy.fTPCparamDCA[i];
+ fITSparamDCA[i] = copy.fITSparamDCA[i];
+ }
+ for (i = 0; i < 5; i++) fTPCparamBB[i] = copy.fTPCparamBB[i];
+}
+
+//_________________________________________________________________________________________________
+Bool_t AliRsnCutAOD2010::IsSelected(TObject *obj1, TObject* /*obj2*/)
+{
+//
+// Cut checker.
+//
+
+ // coherence check: require an AOD track
+ AliRsnDaughter *daughter = dynamic_cast<AliRsnDaughter*>(obj1);
+ if (!daughter) return kFALSE;
+ AliAODTrack *track = daughter->GetRefAODtrack();
+ if (!track) return kFALSE;
+
+ // step #0: check presence of an SPD cluster
+ Int_t nITS = 0, nSPD = 0;
+ nSPD = TESTBIT(track->GetITSClusterMap(), 0);
+ nSPD += TESTBIT(track->GetITSClusterMap(), 1);
+ nITS = track->GetITSNcls() - nSPD;
+ if (nSPD <= 0)
+ {
+ AliDebug(AliLog::kDebug + 2, "No SPD clusters in this track. Rejected");
+ return kFALSE;
+ }
+
+ // step #1: check status flags and reject track if it does not match any possibility
+ Bool_t isTPC = track->IsOn(AliESDtrack::kTPCin) && track->IsOn(AliESDtrack::kTPCrefit) && track->IsOn(AliESDtrack::kITSrefit);
+ Bool_t isITSSA = !track->IsOn(AliESDtrack::kTPCin) && track->IsOn(AliESDtrack::kITSrefit) && (!track->IsOn(AliESDtrack::kITSpureSA)) && track->IsOn(AliESDtrack::kITSpid);
+ Bool_t isTOF = track->IsOn(AliESDtrack::kTOFout) && track->IsOn(AliESDtrack::kTIME);
+ if (!isTPC && !isITSSA)
+ {
+ AliDebug(AliLog::kDebug + 2, "Track is not either a TPC track or a ITS standalone. Rejected");
+ return kFALSE;
+ }
+ else if (isTPC && !fUseGlobal)
+ {
+ AliDebug(AliLog::kDebug + 2, "Global tracks not used. Rejected");
+ return kFALSE;
+ }
+ else if (isITSSA && !fUseITSSA)
+ {
+ AliDebug(AliLog::kDebug + 2, "ITS standalone not used. Rejected");
+ return kFALSE;
+ }
+
+ // step #2: check number of clusters
+ Int_t count = 0;
+ if (isTPC)
+ {
+ count = track->GetTPCNcls();
+ if (count < fTPCminNclusters)
+ {
+ AliDebug(AliLog::kDebug + 2, "Too few clusters. Rejected");
+ return kFALSE;
+ }
+ }
+ else // then is ITS-SA
+ {
+ count = track->GetITSNcls();
+ if (count < fITSminNclusters)
+ {
+ AliDebug(AliLog::kDebug + 2, "Too few clusters. Rejected");
+ return kFALSE;
+ }
+ }
+
+ // step #3: check chi square
+ if (isTPC)
+ {
+ if (track->Chi2perNDF() > fTPCmaxChi2)
+ {
+ AliDebug(AliLog::kDebug + 2, "Bad chi2. Rejected");
+ return kFALSE;
+ }
+ }
+ else
+ {
+ if (track->Chi2perNDF() > fITSmaxChi2)
+ {
+ AliDebug(AliLog::kDebug + 2, "Bad chi2. Rejected");
+ return kFALSE;
+ }
+ }
+
+ // step #4: reject kink daughters
+ AliAODVertex *vertex = track->GetProdVertex();
+ if (isTPC && vertex != 0x0)
+ {
+ if (vertex->GetType() == AliAODVertex::kKink && vertex->HasDaughter(track))
+ {
+ AliDebug(AliLog::kDebug + 2, "Kink daughter. Rejected");
+ return kFALSE;
+ }
+ }
+
+ // step #5: DCA cut (transverse)
+ Double_t sigmaDCA = 0.0, nsigma = 0.0;
+ if (isTPC)
+ {
+ sigmaDCA = fTPCparamDCA[0] + fTPCparamDCA[1] / TMath::Power(track->Pt(), fTPCparamDCA[2]);
+ nsigma = fTPCmaxNSigmaDCA;
+ }
+ else
+ {
+ sigmaDCA = fITSparamDCA[0] + fITSparamDCA[1] / TMath::Power(track->Pt(), fITSparamDCA[2]);
+ nsigma = fITSmaxNSigmaDCA;
+ }
+ if (track->DCA() > nsigma * sigmaDCA)
+ {
+ AliDebug(AliLog::kDebug + 2, "Excceeded cut in DCA. Rejected");
+ return kFALSE;
+ }
+
+ // step #6 PID cuts
+ Double_t bandTPC = 0.0;
+ Double_t nsigmaTPC = 0.0;
+ Double_t nsigmaITS = 0.0;
+ Double_t nsigmaTOF = 0.0;
+ if (isTPC) nsigmaTPC = fPID.NumberOfSigmasTPC(track, fPIDtype);
+ if (isITSSA) nsigmaITS = fPID.NumberOfSigmasITS(track, fPIDtype);
+ if (isTOF) nsigmaTOF = fPID.NumberOfSigmasTOF(track, fPIDtype);
+ if (isITSSA && fCheckITS)
+ {
+ if (nITS < 3) return kFALSE;
+ if (TMath::Abs(nsigmaITS) > fITSband)
+ {
+ AliDebug(AliLog::kDebug + 2, "Bad ITS PID. Rejected");
+ return kFALSE;
+ }
+ else
+ {
+ AliDebug(AliLog::kDebug + 2, "Good ITS PID. Accepted");
+ return kFALSE;
+ }
+ }
+ else
+ {
+ if (fCheckTPC)
+ {
+ if (track->P() > fTPClowLimit) bandTPC = fTPChighBand; else bandTPC = fTPClowBand;
+ if (TMath::Abs(nsigmaTPC) > bandTPC)
+ {
+ AliDebug(AliLog::kDebug + 2, "Bad TPC PID. Rejected");
+ return kFALSE;
+ }
+ else
+ {
+ AliDebug(AliLog::kDebug + 2, "Good TPC PID");
+ if (fCheckTOF && isTOF)
+ {
+ if (nsigmaTOF < fTOFlowLimit || nsigmaTOF > fTOFhighLimit)
+ {
+ AliDebug(AliLog::kDebug + 2, "Bad TOF PID. Rejected");
+ return kFALSE;
+ }
+ else
+ {
+ AliDebug(AliLog::kDebug + 2, "Good TOF PID. Accepted");
+ return kFALSE;
+ }
+ }
+ else
+ {
+ AliDebug(AliLog::kDebug + 2, "TOF not checked. Accepted");
+ return kTRUE;
+ }
+ }
+ }
+ else
+ {
+ if (fCheckTOF && isTOF)
+ {
+ if (nsigmaTOF < fTOFlowLimit || nsigmaTOF > fTOFhighLimit)
+ {
+ AliDebug(AliLog::kDebug + 2, "Bad TOF PID. Rejected");
+ return kFALSE;
+ }
+ else
+ {
+ AliDebug(AliLog::kDebug + 2, "Good TOF PID. Accepted");
+ return kFALSE;
+ }
+ }
+ else
+ {
+ AliDebug(AliLog::kDebug + 2, "No PID checked. Accepted");
+ return kTRUE;
+ }
+ }
+ }
+
+ return kTRUE;
+}
--- /dev/null
+//
+// Class AliRsnCutRange
+//
+// General implementation of cuts which check a value inside a range.
+// This range can be defined by two integers or two doubles.
+// A user-friendly enumeration allows to define what is checked.
+//
+// authors: Martin Vala (martin.vala@cern.ch)
+// Alberto Pulvirenti (alberto.pulvirenti@ct.infn.it)
+//
+
+#ifndef ALIRSNCUTAOD2010_H
+#define ALIRSNCUTAOD2010_H
+
+#include "AliPID.h"
+#include "AliAODTrack.h"
+#include "AliAODpidUtil.h"
+
+#include "AliRsnCut.h"
+
+class AliRsnCutAOD2010 : public AliRsnCut
+{
+ public:
+
+ AliRsnCutAOD2010();
+ AliRsnCutAOD2010(const char *name);
+ AliRsnCutAOD2010(const AliRsnCutAOD2010& copy);
+ virtual ~AliRsnCutAOD2010() {;};
+
+ virtual Bool_t IsSelected(TObject *obj1, TObject *obj2 = 0x0);
+
+ void SetMC (Bool_t yn = kTRUE) {fIsMC = yn;}
+ void SetCheckITS (Bool_t yn = kTRUE) {fCheckITS = yn;}
+ void SetCheckTPC (Bool_t yn = kTRUE) {fCheckTPC = yn;}
+ void SetCheckTOF (Bool_t yn = kTRUE) {fCheckTOF = yn;}
+ void SetUseGlobal(Bool_t yn = kTRUE) {fUseGlobal = yn;}
+ void SetUseITSSA (Bool_t yn = kTRUE) {fUseITSSA = yn;}
+ void SetPIDtype (AliPID::EParticleType pid) {fPIDtype = pid;}
+
+ void SetTPCminNclusters(Int_t v) {fTPCminNclusters = v;}
+ void SetTPCmaxChi2(Double_t v) {fTPCmaxChi2 = v;}
+ void SetTPCmaxNSigmaDCA(Double_t v) {fTPCmaxNSigmaDCA = v;}
+ void SetTPCparamDCA(Int_t i, Double_t v) {if (i >= 0 && i < 3) fTPCparamDCA[i] = v;}
+ void SetTPCparamBB(Int_t i, Double_t v) {if (i >= 0 && i < 3) fTPCparamBB[i] = v;}
+ void SetTPClowBand(Double_t v) {fTPClowBand = v;}
+ void SetTPChighBand(Double_t v) {fTPChighBand = v;}
+ void SetTPClowLimit(Double_t v) {fTPClowLimit = v;}
+
+ void SetITSminNclusters(Int_t v) {fITSminNclusters = v;}
+ void SetITSmaxChi2(Double_t v) {fITSmaxChi2 = v;}
+ void SetITSmaxNSigmaDCA(Double_t v) {fITSmaxNSigmaDCA = v;}
+ void SetITSparamDCA(Int_t i, Double_t v) {if (i >= 0 && i < 3) fITSparamDCA[i] = v;}
+ void SetITSparamBB(Int_t i, Double_t v) {if (i >= 0 && i < 3) fITSparamBB[i] = v;}
+ void SetITSband(Double_t v) {fITSband = v;}
+
+ void SetTOFrange(Double_t v1, Double_t v2) {fTOFlowLimit = v1; fTOFhighLimit = v2;}
+
+ protected:
+
+ AliRsnCutAOD2010& operator=(const AliRsnCutAOD2010& /*copy*/) {return (*this);}
+
+ Bool_t fIsMC; // switch for MC analysis
+ Bool_t fCheckITS; // switch for ITS dE/dx check
+ Bool_t fCheckTPC; // switch for TPC dE/dx check
+ Bool_t fCheckTOF; // switch for TOF time check
+ Bool_t fUseGlobal; // switch to use TPC global tracks
+ Bool_t fUseITSSA; // switch to use ITS standalone tracks
+
+ AliPID::EParticleType fPIDtype; // particle type for which PID is checked
+
+ Int_t fTPCminNclusters; // minimum number of clusters in TPC
+ Double_t fTPCmaxChi2; // maximum chi2 / number of clusters in TPC
+ Double_t fTPCmaxNSigmaDCA; // cut in DCA (transv) in numbers of sigma (pt-dependent)
+ Double_t fTPCparamDCA[3]; // parameters to compute sigma for DCA
+ Double_t fTPCparamBB[5]; // parameters for TPC Bethe-Bloch parameterization
+ Double_t fTPClowBand; // large band for low momentum PID
+ Double_t fTPChighBand; // large band for low momentum PID
+ Double_t fTPClowLimit; // limit of low momentum region
+
+ Int_t fITSminNclusters; // minimum number of clusters in TPC
+ Double_t fITSmaxChi2; // maximum chi2 / number of clusters in TPC
+ Double_t fITSmaxNSigmaDCA; // cut in DCA (transv) in numbers of sigma (pt-dependent)
+ Double_t fITSparamDCA[3]; // parameters to compute sigma for DCA
+ Double_t fITSparamBB[5]; // parameters for TPC Bethe-Bloch parameterization
+ Double_t fITSband; // fiducial region for selection of PID
+
+ Double_t fTOFlowLimit; // low limit in asymmetric TOF PID cut
+ Double_t fTOFhighLimit; // low limit in asymmetric TOF PID cut
+
+ AliAODpidUtil fPID; // PID utility
+
+ ClassDef(AliRsnCutAOD2010, 1)
+};
+
+#endif
AliRsnEvent *rsn = dynamic_cast<AliRsnEvent*>(obj1);
if (!rsn) return kFALSE;
AliESDEvent *esd = dynamic_cast<AliESDEvent*>(rsn->GetRef());
- if (!esd)
- {
- AliDebug(AliLog::kDebug+2, "NO ESD");
- return kFALSE;
- }
-
- // get the best primary vertex:
- // first try the one with tracks
- const AliESDVertex *vTrk = esd->GetPrimaryVertexTracks();
- const AliESDVertex *vSPD = esd->GetPrimaryVertexSPD();
- const AliESDVertex *vTPC = esd->GetPrimaryVertexTPC();
- Int_t ncTrk = -1;
- Int_t ncSPD = -1;
- Int_t ncTPC = -1;
- Double_t vzTrk = 2.0 * fMaxD;
- Double_t vzSPD = 2.0 * fMaxD;
- Double_t vzTPC = 2.0 * fMaxD;
- if (vTrk) vzTrk = TMath::Abs(vTrk->GetZv());
- if (vSPD) vzSPD = TMath::Abs(vSPD->GetZv());
- if (vTPC) vzTPC = TMath::Abs(vTPC->GetZv());
- if (vTrk) ncTrk = (Int_t)vTrk->GetNContributors();
- if (vSPD) ncSPD = (Int_t)vSPD->GetNContributors();
- if (vTPC) ncTPC = (Int_t)vTPC->GetNContributors();
- if(vTrk && ncTrk > 0)
- {
- fCutValueI = ncTrk;
- fCutValueD = vzTrk;
- }
- else if (vSPD && ncSPD > 0)
+ AliAODEvent *aod = dynamic_cast<AliAODEvent*>(rsn->GetRef());
+
+ if (esd)
{
- fCutValueI = ncSPD;
- fCutValueD = vzSPD;
+ // get the best primary vertex:
+ // first try the one with tracks
+ const AliESDVertex *vTrk = esd->GetPrimaryVertexTracks();
+ const AliESDVertex *vSPD = esd->GetPrimaryVertexSPD();
+ const AliESDVertex *vTPC = esd->GetPrimaryVertexTPC();
+ Int_t ncTrk = -1;
+ Int_t ncSPD = -1;
+ Int_t ncTPC = -1;
+ Double_t vzTrk = 2.0 * fMaxD;
+ Double_t vzSPD = 2.0 * fMaxD;
+ Double_t vzTPC = 2.0 * fMaxD;
+ if (vTrk) vzTrk = TMath::Abs(vTrk->GetZv());
+ if (vSPD) vzSPD = TMath::Abs(vSPD->GetZv());
+ if (vTPC) vzTPC = TMath::Abs(vTPC->GetZv());
+ if (vTrk) ncTrk = (Int_t)vTrk->GetNContributors();
+ if (vSPD) ncSPD = (Int_t)vSPD->GetNContributors();
+ if (vTPC) ncTPC = (Int_t)vTPC->GetNContributors();
+ if(vTrk && ncTrk > 0)
+ {
+ fCutValueI = ncTrk;
+ fCutValueD = vzTrk;
+ }
+ else if (vSPD && ncSPD > 0)
+ {
+ fCutValueI = ncSPD;
+ fCutValueD = vzSPD;
+ }
+ else if (vTPC && fAcceptTPC && ncTPC > 0)
+ {
+ fCutValueI = ncTPC;
+ fCutValueD = vzTPC;
+ }
+ else
+ {
+ fCutValueI = -1;
+ fCutValueD = 2.0 * fMaxD;
+ }
}
- else if (vTPC && fAcceptTPC && ncTPC > 0)
+ else if (aod)
{
- fCutValueI = ncTPC;
- fCutValueD = vzTPC;
+ AliAODVertex *prim = aod->GetPrimaryVertex();
+ if (!prim || prim->GetNContributors() < 1) prim = aod->GetPrimaryVertexSPD();
+ if (!prim || prim->GetNContributors() < 1) return kFALSE;
+ fCutValueI = prim->GetNContributors();
+ fCutValueD = prim->GetZ();
}
else
- {
- fCutValueI = -1;
- fCutValueD = 2.0 * fMaxD;
- }
-
+ return kFALSE;
+
// output
Bool_t result = ((!OkRangeI()) && OkRangeD());
-
return result;
}
git://git.uio.no / u / mrichter / AliRoot.git / commitdiff