Tuned for monitoring TOF KStar analysis of PbPb 2010 data
Options ("opt" argument):
+- dim1 --> use TH1 only (no p or pt dependence)
+- dim3 --> use TH3 (p dependence) for TOF vs TPC pid histos
- NoTOFSIGMA --> disable the nsigma_TOF vs p histos
- NoTPCSIGMA --> disable the nsigma_TPC vs p_TPC histos
- NoSIGN --> disable splitting for single track charge
void AddMonitorOutput(Bool_t useMCMon = 0, TObjArray *mon=0,TString opt="",AliRsnLoopDaughter *lm=0)
{
+ //Set options
+ Bool_t useTH1 = opt.Contains("dim1");
+ Bool_t useTH3 = opt.Contains("dim3");
+ Bool_t monitorSign = !opt.Contains("NoSIGN");
+ Bool_t monitorTrackQ = !opt.Contains("NoTrackQ");
+ Bool_t monitorTPCpid = !opt.Contains("NoTPCSIGMA");
+ Bool_t monitorTOFpid = !opt.Contains("NoTPCSIGMA");
+
// Multiplicity/centrality
AliRsnValueEvent *multi = new AliRsnValueEvent("multi",AliRsnValueEvent::kMult);
multi->SetBins(0.0, 400.0, 1);
// Momentum
AliRsnValueDaughter *axisMomTPC = new AliRsnValueDaughter("pTPC", AliRsnValueDaughter::kPtpc);
- axisMomTPC->SetBins(0.0, 10.0, 0.01);
+ axisMomTPC->SetBins(0.0, 10.0, 0.02);
AliRsnValueDaughter *axisMomP = new AliRsnValueDaughter("p", AliRsnValueDaughter::kP);
- axisMomP->SetBins(0.0, 10.0, 0.01);
+ axisMomP->SetBins(0.0, 10.0, 0.02);
// Momentum Pt
AliRsnValueDaughter *axisMomPt = new AliRsnValueDaughter("pt", AliRsnValueDaughter::kPt);
- axisMomPt->SetBins(0.0,10.0,0.01);
+ axisMomPt->SetBins(0.0,10.0,0.02);
// Eta
AliRsnValueDaughter *axisMomEta = new AliRsnValueDaughter("eta", AliRsnValueDaughter::kEta);
axisMomEta->SetBins(-1.0, 1.0, 0.1);
//ITS clusters
AliRsnValueDaughter *axisITScls = new AliRsnValueDaughter("ITScls", AliRsnValueDaughter::kNITSclusters);
- axisITScls->SetBins(0.0, 10.0, 1.0);
+ axisITScls->SetBins(0.0, 12.0, 1.0);
//TPC clusters
AliRsnValueDaughter *axisTPCcls = new AliRsnValueDaughter("TPCcls", AliRsnValueDaughter::kNTPCclusters);
- axisTPCcls->SetBins(0.0, 300.0, 1.0);
+ axisTPCcls->SetBins(0.0, 160.0, 1.0);
+ //TPC crossed rows
+ AliRsnValueDaughter *axisTPCcrossedRows = new AliRsnValueDaughter("TPCcrossedRows", AliRsnValueDaughter::kNTPCcrossedRows);
+ axisTPCcrossedRows->SetBins(0.0, 160.0, 1.0);
+ //TPC crossed rows / findable clusters
+ AliRsnValueDaughter *axisTPCcrossedRows2Fcls = new AliRsnValueDaughter("TPCcrossedRows2Fcls", AliRsnValueDaughter::kNTPCcrossedRowsFclusters);
+ axisTPCcrossedRows2Fcls->SetBins(0.0, 1.0, 0.1);
//ITS chi2
AliRsnValueDaughter *axisITSchi2 = new AliRsnValueDaughter("ITSchi2", AliRsnValueDaughter::kITSchi2);
- axisITSchi2->SetBins(0.0, 10.0, 0.1);
+ axisITSchi2->SetBins(0.0, 12.0, 0.1);
//TPC chi2
AliRsnValueDaughter *axisTPCchi2 = new AliRsnValueDaughter("TPCchi2", AliRsnValueDaughter::kTPCchi2);
axisTPCchi2->SetBins(0.0, 10.0, 0.1);
axisDCAxy->SetBins(-2.5, 2.5, 0.001);
//DCA z
AliRsnValueDaughter *axisDCAz = new AliRsnValueDaughter("DCAz", AliRsnValueDaughter::kDCAZ);
- axisDCAz->SetBins(-10.0, 10.0, 0.01);
+ axisDCAz->SetBins(-5.0, 5.0, 0.01);
//Charge
AliRsnValueDaughter *axisCharge = new AliRsnValueDaughter("charge",AliRsnValueDaughter::kCharge);
axisCharge->SetBins(-1.5, 1.5, 1.0);
/* tof signal - time */
AliRsnValueDaughter *axisSigTOF = new AliRsnValueDaughter("sTOF", AliRsnValueDaughter::kTOFsignal);
axisSigTOF->SetBins(10000.0, 50000.0, 250);//in ps
+
+ // kTOFdeltaPi
+ AliRsnValueDaughter *axisTOFdeltaPi = new AliRsnValueDaughter("Dpi", AliRsnValueDaughter::kTOFdeltaPi);
+ axisTOFdeltaPi->SetBins(-3000.,3000., 10.);
+ // kTOFdeltaK
+ AliRsnValueDaughter *axisTOFdeltaK = new AliRsnValueDaughter("DK", AliRsnValueDaughter::kTOFdeltaK);
+ axisTOFdeltaK->SetBins(-3000.,3000., 10.);
+ // kTOFdeltaP
+ AliRsnValueDaughter *axisTOFdeltaP = new AliRsnValueDaughter("Dp", AliRsnValueDaughter::kTOFdeltaP);
+ axisTOFdeltaP->SetBins(-3000.,3000., 10.);
+
// kTOFnsigmaPi
AliRsnValueDaughter *axisTOFnsigmaPi = new AliRsnValueDaughter("pi", AliRsnValueDaughter::kTOFnsigmaPi);
axisTOFnsigmaPi->SetBins(-10.,10., 0.1);
// output: TH1D for momentum
AliRsnListOutput *outMonitorP = new AliRsnListOutput("P", AliRsnListOutput::kHistoDefault);
outMonitorP->AddValue(axisMomP);
- if (!opt.Contains("NoSIGN")) {
- outMonitorP->AddValue(axisCharge);
- }
+ if (monitorSign) outMonitorP->AddValue(axisCharge);
if (mon) mon->Add(outMonitorP);
if (lm) lm->AddOutput(outMonitorP);
// output: TH1D for pt
AliRsnListOutput *outMonitorPt = new AliRsnListOutput("Pt", AliRsnListOutput::kHistoDefault);
outMonitorPt->AddValue(axisMomPt);
- if (!opt.Contains("NoSIGN")) {
- outMonitorPt->AddValue(axisCharge);
- }
+ if (monitorSign) outMonitorPt->AddValue(axisCharge);
if (mon) mon->Add(outMonitorPt);
if (lm) lm->AddOutput(outMonitorPt);
// output: TH1D for pseudorapidity
AliRsnListOutput *outMonitorEta = new AliRsnListOutput("Eta", AliRsnListOutput::kHistoDefault);
outMonitorEta->AddValue(axisMomEta);
- if (!opt.Contains("NoSIGN")) {
- outMonitorEta->AddValue(axisCharge);
- }
+ if (monitorSign) outMonitorEta->AddValue(axisCharge);
if (mon) mon->Add(outMonitorEta);
if (lm) lm->AddOutput(outMonitorEta);
- // output: TH2D for phi at vertex
+ // output: TH1D for phi at vertex
AliRsnListOutput *outMonitorPhi = new AliRsnListOutput("Phi", AliRsnListOutput::kHistoDefault);
- //outMonitorPhi->AddValue(axisMomPt);
outMonitorPhi->AddValue(axisPhi);
- if (!opt.Contains("NoSIGN")) {
- outMonitorPhi->AddValue(axisCharge);
- }
+ if (monitorSign) outMonitorPhi->AddValue(axisCharge);
if (mon) mon->Add(outMonitorPhi);
if (lm) lm->AddOutput(outMonitorPhi);
- // output: TH2D for phiOuterTPC at TPC outer radius
+ // output: TH1D for phiOuterTPC at TPC outer radius
AliRsnListOutput *outMonitorPhiOuterTPC = new AliRsnListOutput("PhiOuterTPC", AliRsnListOutput::kHistoDefault);
- //outMonitorPhiOuterTPC->AddValue(axisMomPt);
outMonitorPhiOuterTPC->AddValue(axisPhiOuterTPC);
- if (!opt.Contains("NoSIGN")) {
- outMonitorPhiOuterTPC->AddValue(axisCharge);
- }
+ if (monitorSign) outMonitorPhiOuterTPC->AddValue(axisCharge);
if (mon) mon->Add(outMonitorPhiOuterTPC);
if (lm) lm->AddOutput(outMonitorPhiOuterTPC);
-
+
// output: TH2D for phi vs pt
AliRsnListOutput *outMonitorPhiVsPt = new AliRsnListOutput("PhiVsPt", AliRsnListOutput::kHistoDefault);
outMonitorPhiVsPt->AddValue(axisMomPt);
outMonitorPhiVsPt->AddValue(axisPhi);
- if (!opt.Contains("NoSIGN")) {
- outMonitorPhiVsPt->AddValue(axisCharge);
- }
+ if (monitorSign) outMonitorPhiVsPt->AddValue(axisCharge);
if (mon) mon->Add(outMonitorPhiVsPt);
if (lm) lm->AddOutput(outMonitorPhiVsPt);
/****************************************************************/
/*************** MONITOR TRACK QUALITY ********************/
/****************************************************************/
- if (!opt.Contains("NoTrackQ")) {
+ if (monitorTrackQ) {
// output: 2D histogram of DCAxy vs pt
AliRsnListOutput *outMonitorDCAxy = new AliRsnListOutput("DCAxyVsPt", AliRsnListOutput::kHistoDefault);
- outMonitorDCAxy->AddValue(axisMomPt);
+ if (!useTH1) outMonitorDCAxy->AddValue(axisMomPt);
outMonitorDCAxy->AddValue(axisDCAxy);
if (mon) mon->Add(outMonitorDCAxy);
if (lm) lm->AddOutput(outMonitorDCAxy);
// output: 2D histogram of DCAz vs P
AliRsnListOutput *outMonitorDCAz = new AliRsnListOutput("DCAzVsP", AliRsnListOutput::kHistoDefault);
- outMonitorDCAz->AddValue(axisMomP);
+ if (!useTH1) outMonitorDCAz->AddValue(axisMomP);
outMonitorDCAz->AddValue(axisDCAz);
if (mon) mon->Add(outMonitorDCAz);
if (lm) lm->AddOutput(outMonitorDCAz);
// output: 2D histogram of ITS cls vs pt
AliRsnListOutput *outMonitorITScls = new AliRsnListOutput("ITSclsVsPt", AliRsnListOutput::kHistoDefault);
- outMonitorITScls->AddValue(axisMomPt);
+ if (!useTH1) outMonitorITScls->AddValue(axisMomPt);
outMonitorITScls->AddValue(axisITScls);
if (mon) mon->Add(outMonitorITScls);
if (lm) lm->AddOutput(outMonitorITScls);
// output: 2D histogram of TPC cls vs. pt
AliRsnListOutput *outMonitorTPCcls = new AliRsnListOutput("TPCclsVsPt", AliRsnListOutput::kHistoDefault);
- outMonitorTPCcls->AddValue(axisMomPt);
+ if (!useTH1) outMonitorTPCcls->AddValue(axisMomPt);
outMonitorTPCcls->AddValue(axisTPCcls);
if (mon) mon->Add(outMonitorTPCcls);
if (lm) lm->AddOutput(outMonitorTPCcls);
// output: 2D histogram of TPC cls vs. TPC momentum
AliRsnListOutput *outMonitorTPCclsVsPtpc = new AliRsnListOutput("TPCclsVsPtpc", AliRsnListOutput::kHistoDefault);
- outMonitorTPCclsVsPtpc->AddValue(axisMomTPC);
+ if (!useTH1) outMonitorTPCclsVsPtpc->AddValue(axisMomTPC);
outMonitorTPCclsVsPtpc->AddValue(axisTPCcls);
if (mon) mon->Add(outMonitorTPCclsVsPtpc);
if (lm) lm->AddOutput(outMonitorTPCclsVsPtpc);
+ // output: 2D histogram of TPC crossed rows vs. TPC momentum
+ AliRsnListOutput *outMonitorTPCcrossedRowsVsPtpc = new AliRsnListOutput("TPCcrossedRowsVsPtpc", AliRsnListOutput::kHistoDefault);
+ if (!useTH1) outMonitorTPCcrossedRowsVsPtpc->AddValue(axisMomTPC);
+ outMonitorTPCcrossedRowsVsPtpc->AddValue(axisTPCcrossedRows);
+ if (mon) mon->Add(outMonitorTPCcrossedRowsVsPtpc);
+ if (lm) lm->AddOutput(outMonitorTPCcrossedRowsVsPtpc);
+
+ // output: 2D histogram of TPC crossed rows/Findable cls vs. TPC momentum
+ AliRsnListOutput *outMonitorTPCcrossedRows2FclsVsPtpc = new AliRsnListOutput("TPCcrossedRows2FclsVsPtpc", AliRsnListOutput::kHistoDefault);
+ if (!useTH1) outMonitorTPCcrossedRows2FclsVsPtpc->AddValue(axisMomTPC);
+ outMonitorTPCcrossedRows2FclsVsPtpc->AddValue(axisTPCcrossedRows2Fcls);
+ if (mon) mon->Add(outMonitorTPCcrossedRows2FclsVsPtpc);
+ if (lm) lm->AddOutput(outMonitorTPCcrossedRows2FclsVsPtpc);
+
// output: 2D histogram of ITS chi2 vs pt
AliRsnListOutput *outMonitorITSchi2 = new AliRsnListOutput("ITSchi2VsPt", AliRsnListOutput::kHistoDefault);
- outMonitorITSchi2->AddValue(axisMomPt);
+ if (!useTH1) outMonitorITSchi2->AddValue(axisMomPt);
outMonitorITSchi2->AddValue(axisITSchi2);
if (mon) mon->Add(outMonitorITSchi2);
if (lm) lm->AddOutput(outMonitorITSchi2);
// output: 2D histogram of TPC chi2 vs. pt
AliRsnListOutput *outMonitorTPCchi2 = new AliRsnListOutput("TPCchi2VsPt", AliRsnListOutput::kHistoDefault);
- outMonitorTPCchi2->AddValue(axisMomPt);
+ if (!useTH1) outMonitorTPCchi2->AddValue(axisMomPt);
outMonitorTPCchi2->AddValue(axisTPCchi2);
if (mon) mon->Add(outMonitorTPCchi2);
if (lm) lm->AddOutput(outMonitorTPCchi2);
// output: 2D histogram of TPC chi2 vs. TPC momentum
AliRsnListOutput *outMonitorTPCchi2VsPtpc = new AliRsnListOutput("TPCchi2VsPtpc", AliRsnListOutput::kHistoDefault);
- outMonitorTPCchi2VsPtpc->AddValue(axisMomTPC);
+ if (!useTH1) outMonitorTPCchi2VsPtpc->AddValue(axisMomTPC);
outMonitorTPCchi2VsPtpc->AddValue(axisTPCchi2);
if (mon) mon->Add(outMonitorTPCchi2VsPtpc);
if (lm) lm->AddOutput(outMonitorTPCchi2VsPtpc);
/****************************************************************/
/*************** MONITOR TPC ********************/
/****************************************************************/
- if (!opt.Contains("NoTPCSIGMA")) {
+ if (monitorTPCpid) {
// output: 2D histogram of TPC signal vs. TPC momentum
AliRsnListOutput *outMonitordEdxTPC = new AliRsnListOutput("dEdx_VsPtpc", AliRsnListOutput::kHistoDefault);
outMonitordEdxTPC->AddValue(axisMomTPC);
AliRsnListOutput *outMonitorTOFvsTPCnsigmaPi = new AliRsnListOutput("TOFnsigmaPi_TPCnsigmaPi", AliRsnListOutput::kHistoDefault);
outMonitorTOFvsTPCnsigmaPi->AddValue(axisTOFnsigmaPi);
outMonitorTOFvsTPCnsigmaPi->AddValue(axisTPCnsigmaPi);
- //outMonitorTOFvsTPCnsigmaPi->AddValue(axisMomP);
+ if (useTH3) outMonitorTOFvsTPCnsigmaPi->AddValue(axisMomP);
if (mon) mon->Add(outMonitorTOFvsTPCnsigmaPi);
if (lm) lm->AddOutput(outMonitorTOFvsTPCnsigmaPi);
+ // output:2D histogram of TOF Nsigma pi vs. TPC Nsigma pi vs momentum
+ AliRsnListOutput *outMonitorTOFvsTPCnsigmaK = new AliRsnListOutput("TOFnsigmaK_TPCnsigmaK", AliRsnListOutput::kHistoDefault);
+ outMonitorTOFvsTPCnsigmaK->AddValue(axisTOFnsigmaK);
+ outMonitorTOFvsTPCnsigmaK->AddValue(axisTPCnsigmaK);
+ if (useTH3) outMonitorTOFvsTPCnsigmaK->AddValue(axisMomP);
+ if (mon) mon->Add(outMonitorTOFvsTPCnsigmaK);
+ if (lm) lm->AddOutput(outMonitorTOFvsTPCnsigmaK);
+
+ AliRsnListOutput *outMonitorTOFvsTPCnsigmaP = new AliRsnListOutput("TOFnsigmaP_TPCnsigmaP", AliRsnListOutput::kHistoDefault);
+ outMonitorTOFvsTPCnsigmaP->AddValue(axisTOFnsigmaP);
+ outMonitorTOFvsTPCnsigmaP->AddValue(axisTPCnsigmaP);
+ if (useTH3) outMonitorTOFvsTPCnsigmaP->AddValue(axisMomP);
+ if (mon) mon->Add(outMonitorTOFvsTPCnsigmaP);
+ if (lm) lm->AddOutput(outMonitorTOFvsTPCnsigmaP);
+
// // output: 2D histogram of TOF signal vs. momentum
// AliRsnListOutput *outMonitorTimeTOF = new AliRsnListOutput("time_VsP", AliRsnListOutput::kHistoDefault);
// outMonitorTimeTOF->AddValue(axisMomP);
// if (mon) mon->Add(outMonitorTimeTOFPt);
// if (lm) lm->AddOutput(outMonitorTimeTOFPt);
- if (!opt.Contains("NoTOFSIGMA")) {
+ if (monitorTOFpid) {
// output: 2D histogram of TOF Nsigma pi vs. TPC momentum
AliRsnListOutput *outMonitorTOFnsigmaPi = new AliRsnListOutput("TOF_nsigmaPi_vsP", AliRsnListOutput::kHistoDefault);
outMonitorTOFnsigmaPi->AddValue(axisMomP);
outMonitorTOFnsigmaP->AddValue(axisTOFnsigmaP);
if (mon) mon->Add(outMonitorTOFnsigmaP);
if (lm) lm->AddOutput(outMonitorTOFnsigmaP);
+
+ // output: 2D histogram of TOF Delta pi vs. TPC momentum
+ AliRsnListOutput *outMonitorTOFdeltaPi = new AliRsnListOutput("TOF_deltaPi_vsP", AliRsnListOutput::kHistoDefault);
+ outMonitorTOFdeltaPi->AddValue(axisMomP);
+ outMonitorTOFdeltaPi->AddValue(axisTOFdeltaPi);
+ if (mon) mon->Add(outMonitorTOFdeltaPi);
+ if (lm) lm->AddOutput(outMonitorTOFdeltaPi);
+
+ // output: 2D histogram of TOF signal vs. TOF momentum
+ AliRsnListOutput *outMonitorTOFdeltaK = new AliRsnListOutput("TOF_deltaK_vsP", AliRsnListOutput::kHistoDefault);
+ outMonitorTOFdeltaK->AddValue(axisMomP);
+ outMonitorTOFdeltaK->AddValue(axisTOFdeltaK);
+ if (mon) mon->Add(outMonitorTOFdeltaK);
+ if (lm) lm->AddOutput(outMonitorTOFdeltaK);
+
+ // output: 2D histogram of TOF signal vs. TOF momentum
+ AliRsnListOutput *outMonitorTOFdeltaP = new AliRsnListOutput("TOF_deltaPro_vsP", AliRsnListOutput::kHistoDefault);
+ outMonitorTOFdeltaP->AddValue(axisMomP);
+ outMonitorTOFdeltaP->AddValue(axisTOFdeltaP);
+ if (mon) mon->Add(outMonitorTOFdeltaP);
+ if (lm) lm->AddOutput(outMonitorTOFdeltaP);
}
/****************************************************************/
/***************************************************************************
- fbellini@cern.ch - last modified on 06/08/2012
+ fbellini@cern.ch - last modified on 28/11/2013
// *** Configuration script for K*, anti-K* analysis with 2010 PbPb runs ***
+// *** Configuration script for K*, anti-K* analysis with 2013 pPb runs ***
//
// A configuration script for RSN package needs to define the followings:
//
// (2) cuts at all levels: single daughters, tracks, events
// (3) output objects: histograms or trees
****************************************************************************/
-
Bool_t ConfigTOFanalysisKStar
(
AliRsnMiniAnalysisTask *task,
const char *suffix,
AliRsnCutSet *cutsPair,
Int_t aodFilterBit = 5,
+ Int_t customQualityCutsID = AliRsnCutSetDaughterParticle::kDisableCustom,
AliRsnCutSetDaughterParticle::ERsnDaughterCutSet cutPiCandidate = AliRsnCutSetDaughterParticle::kTOFpidKstarPbPb2010,
AliRsnCutSetDaughterParticle::ERsnDaughterCutSet cutKaCandidate = AliRsnCutSetDaughterParticle::kTOFpidKstarPbPb2010,
Float_t nsigmaPi = 2.0,
Bool_t useMixLS = 0,
Int_t signedPdg = 313,
TString monitorOpt = "",
- AliRsnMiniValue::EType yaxisVar = AliRsnMiniValue::kPt
+ AliRsnMiniValue::EType yaxisVar = AliRsnMiniValue::kPt
)
{
// manage suffix
AliRsnCutSetDaughterParticle * cutSetQ;
AliRsnCutSetDaughterParticle * cutSetPi;
AliRsnCutSetDaughterParticle * cutSetK;
-
- cutSetQ = new AliRsnCutSetDaughterParticle(Form("cutQ_bit%i",aodFilterBit), AliRsnCutSetDaughterParticle::kQualityStd2010, AliPID::kPion, -1.0, aodFilterBit);
- cutSetPi = new AliRsnCutSetDaughterParticle(Form("cutPi%i_%2.1fsigma",cutPiCandidate, nsigmaPi), cutPiCandidate, AliPID::kPion, nsigmaPi, aodFilterBit);
- cutSetK = new AliRsnCutSetDaughterParticle(Form("cutK%i_%2.1fsigma",cutPiCandidate, nsigmaKa), cutKaCandidate, AliPID::kKaon, nsigmaKa, aodFilterBit);
-
+
+ AliRsnCutTrackQuality * trkQualityCut = new AliRsnCutTrackQuality("myQualityCut");
+ if (SetCustomQualityCut(trkQualityCut, customQualityCutsID, aodFilterBit)) {
+ //Set custom quality cuts for systematic checks
+ cutSetQ = new AliRsnCutSetDaughterParticle(Form("cutQ_bit%i",aodFilterBit), trkQualityCut, AliRsnCutSetDaughterParticle::kQualityStd2011, AliPID::kPion, -1.0);
+ cutSetPi = new AliRsnCutSetDaughterParticle(Form("cutPi%i_%2.1fsigma",cutPiCandidate, nsigmaPi), trkQualityCut, cutPiCandidate, AliPID::kPion, nsigmaPi);
+ cutSetK = new AliRsnCutSetDaughterParticle(Form("cutK%i_%2.1fsigma",cutPiCandidate, nsigmaKa), trkQualityCut, cutKaCandidate, AliPID::kKaon, nsigmaKa);
+ } else {
+ //use defult quality cuts (std 2010 or 2011)
+ cutSetQ = new AliRsnCutSetDaughterParticle(Form("cutQ_bit%i",aodFilterBit), AliRsnCutSetDaughterParticle::kQualityStd2011, AliPID::kPion, -1.0, aodFilterBit);
+ cutSetPi = new AliRsnCutSetDaughterParticle(Form("cutPi%i_%2.1fsigma",cutPiCandidate, nsigmaPi), cutPiCandidate, AliPID::kPion, nsigmaPi, aodFilterBit);
+ cutSetK = new AliRsnCutSetDaughterParticle(Form("cutK%i_%2.1fsigma",cutPiCandidate, nsigmaKa), cutKaCandidate, AliPID::kKaon, nsigmaKa, aodFilterBit);
+ }
+
Int_t iCutQ = task->AddTrackCuts(cutSetQ);
Int_t iCutPi = task->AddTrackCuts(cutSetPi);
Int_t iCutK = task->AddTrackCuts(cutSetK);
/* 2nd daughter pt */ Int_t sdpt = task->CreateValue(AliRsnMiniValue::kSecondDaughterPt, kFALSE);
/* 1st daughter p */ Int_t fdp = task->CreateValue(AliRsnMiniValue::kFirstDaughterP, kFALSE);
/* 2nd daughter p */ Int_t sdp = task->CreateValue(AliRsnMiniValue::kSecondDaughterP, kFALSE);
-
+
// -- Create all needed outputs -----------------------------------------------------------------
// use an array for more compact writing, which are different on mixing and charges
// [0] = unlike
}
return kTRUE;
}
+
+//-------------------------------------------------------
+Bool_t SetCustomQualityCut(AliRsnCutTrackQuality * trkQualityCut, Int_t customQualityCutsID = 0, Int_t customFilterBit = 0)
+{
+ //Sets configuration for track quality object different from std quality cuts.
+ //Returns kTRUE if track quality cut object is successfully defined,
+ //returns kFALSE if an invalid set of cuts (customQualityCutsID) is chosen or if the
+ //object to be configured does not exist.
+
+ /* NOTES FROM PRODUCTION LHC13b pass3 - AOD filtered with v5-03-Rev-20
+ //(http://svnweb.cern.ch/world/wsvn/AliRoot/tags/v5-03-Rev-20/ANALYSIS/macros/AddTaskESDFilter.C)
+
+ //filter bit 0: Cuts on primary tracks
+ // AliESDtrackCuts* esdTrackCutsL = AliESDtrackCuts::GetStandardTPCOnlyTrackCuts();
+
+ //filter bit 4: std but looser dca cut
+ // AliESDtrackCuts* esdTrackCutsH = AliESDtrackCuts::GetStandardITSTPCTrackCuts2011(kFALSE);
+ // esdTrackCutsH->SetMaxDCAToVertexXY(2.4);
+ // esdTrackCutsH->SetMaxDCAToVertexZ(3.2);
+ // esdTrackCutsH->SetDCAToVertex2D(kTRUE);
+
+ //filter bit 5: AliESDtrackCuts::GetStandardITSTPCTrackCuts2011();
+
+ //filter bit 10: standard cuts with tight DCA cut, using cluster cut instead of crossed rows (a la 2010 default)
+ //AliESDtrackCuts* esdTrackCutsH2Cluster = AliESDtrackCuts::GetStandardITSTPCTrackCuts2011(kTRUE, 0);
+ */
+
+ if ((!trkQualityCut) || (customQualityCutsID<=0) || (customQualityCutsID>=AliRsnCutSetDaughterParticle::kNcustomQualityCuts)){
+ Printf("::::: SetCustomQualityCut:: use default quality cuts specified in task configuration.");
+ return kFALSE;
+ }
+ //for pA 2013
+ //trkQualityCut->SetDefaults2011();//with filter bit=10
+ //reset filter bit to very loose cuts
+ trkQualityCut->SetAODTestFilterBit(customFilterBit);
+ //apply all other cuts "by hand"
+ trkQualityCut->SetCheckOnlyFilterBit(kFALSE);
+ trkQualityCut->SetMinNCrossedRowsTPC(70);
+ trkQualityCut->SetMinNCrossedRowsOverFindableClsTPC(0.8);
+ trkQualityCut->SetMaxChi2TPCConstrainedGlobal(36);//used for ESD only - for AOD does not correspond to any cut
+ trkQualityCut->SetTPCmaxChi2(4.0); //already in filter bit 0
+ trkQualityCut->SetRejectKinkDaughters(kTRUE); //already in filter bit 0
+ trkQualityCut->SetSPDminNClusters(AliESDtrackCuts::kAny);
+ trkQualityCut->SetITSmaxChi2(36);
+ trkQualityCut->AddStatusFlag(AliESDtrack::kTPCin , kTRUE);//already in defaults 2011
+ trkQualityCut->AddStatusFlag(AliESDtrack::kTPCrefit, kTRUE);//already in defaults 2011
+ trkQualityCut->AddStatusFlag(AliESDtrack::kITSrefit, kTRUE);//already in defaults 2011
+
+ if (customQualityCutsID==AliRsnCutSetDaughterParticle::kFilterBitCustom) {
+ trkQualityCut->SetCheckOnlyFilterBit(kTRUE);
+ }
+
+ if (customQualityCutsID==AliRsnCutSetDaughterParticle::kStdLooserDCAXY){
+ trkQualityCut->SetDCARmax(2.4);
+ } else {
+ trkQualityCut->SetDCARPtFormula("0.0105+0.0350/pt^1.1");
+ }
+
+ if (customQualityCutsID==AliRsnCutSetDaughterParticle::kStdLooserDCAZ){
+ trkQualityCut->SetDCAZmax(3.2);
+ } else {
+ trkQualityCut->SetDCAZmax(2.0);
+ }
+
+ if (customQualityCutsID==AliRsnCutSetDaughterParticle::kStdCrossedRows60){
+ trkQualityCut->SetMinNCrossedRowsTPC(60);
+ }
+
+ if (customQualityCutsID==AliRsnCutSetDaughterParticle::kStdCrossedRows80){
+ trkQualityCut->SetMinNCrossedRowsTPC(80);
+ }
+
+ if (customQualityCutsID==AliRsnCutSetDaughterParticle::kStdRowsToCls075){
+ trkQualityCut->SetMinNCrossedRowsOverFindableClsTPC(0.75);
+ }
+
+ if (customQualityCutsID==AliRsnCutSetDaughterParticle::kStdRowsToCls085){
+ trkQualityCut->SetMinNCrossedRowsOverFindableClsTPC(0.85);
+ }
+
+ if (customQualityCutsID==AliRsnCutSetDaughterParticle::kStdCls70){
+ trkQualityCut->SetAODTestFilterBit(10);
+ trkQualityCut->SetTPCminNClusters(70);
+ }
+
+ if (customQualityCutsID==AliRsnCutSetDaughterParticle::kStdChi2TPCCls35){
+ trkQualityCut->SetTPCmaxChi2(3.5);
+ }
+
+ trkQualityCut->SetPtRange(0.15, 20.0);
+ trkQualityCut->SetEtaRange(-0.8, 0.8);
+
+ Printf(Form("::::: SetCustomQualityCut:: using custom track quality cuts #%i",customQualityCutsID));
+ trkQualityCut->Print();
+ return kTRUE;
+}
git://git.uio.no / u / mrichter / AliRoot.git / commitdiff