From 5f75cda77dd18f4483b7ecc04c21faddef977c86 Mon Sep 17 00:00:00 2001 From: Amelia Lindner Date: Mon, 11 Apr 2022 12:42:35 +0300 Subject: [PATCH 01/15] first attempt of the track cuts class --- Detectors/GlobalTracking/CMakeLists.txt | 118 +++---- .../include/GlobalTracking/TrackCuts.h | 293 ++++++++++++++++++ .../include/GlobalTracking/TrackMethods.h | 95 ++++++ 3 files changed, 448 insertions(+), 58 deletions(-) create mode 100644 Detectors/GlobalTracking/include/GlobalTracking/TrackCuts.h create mode 100644 Detectors/GlobalTracking/include/GlobalTracking/TrackMethods.h diff --git a/Detectors/GlobalTracking/CMakeLists.txt b/Detectors/GlobalTracking/CMakeLists.txt index e4609d2d2b059..25698399cdfb8 100644 --- a/Detectors/GlobalTracking/CMakeLists.txt +++ b/Detectors/GlobalTracking/CMakeLists.txt @@ -1,65 +1,67 @@ -# Copyright 2019-2020 CERN and copyright holders of ALICE O2. -# See https://alice-o2.web.cern.ch/copyright for details of the copyright holders. -# All rights not expressly granted are reserved. +#Copyright 2019 - 2020 CERN and copyright holders of ALICE O2. +#See https: // alice-o2.web.cern.ch/copyright for details of the copyright holders. +#All rights not expressly granted are reserved. # -# This software is distributed under the terms of the GNU General Public -# License v3 (GPL Version 3), copied verbatim in the file "COPYING". +#This software is distributed under the terms of the GNU General Public +#License v3(GPL Version 3), copied verbatim in the file "COPYING". # -# In applying this license CERN does not waive the privileges and immunities -# granted to it by virtue of its status as an Intergovernmental Organization +#In applying this license CERN does not waive the privileges and immunities +#granted to it by virtue of its status as an Intergovernmental Organization # or submit itself to any jurisdiction. o2_add_library(GlobalTracking - TARGETVARNAME targetName - SOURCES src/MatchTPCITS.cxx - src/MatchTOF.cxx - src/MatchTPCITSParams.cxx - src/MatchCosmics.cxx - src/MatchCosmicsParams.cxx - src/MatchGlobalFwd.cxx - src/MatchGlobalFwdAssessment.cxx - src/MatchITSTPCQC.cxx - src/ITSTPCMatchingQCParams.cxx - src/MatchGlobalFwdParam.cxx - PUBLIC_LINK_LIBRARIES O2::Framework - O2::DataFormatsTPC - O2::DataFormatsITSMFT - O2::DataFormatsITS - O2::DataFormatsFT0 - O2::DataFormatsTOF - O2::DataFormatsTRD - O2::ITSReconstruction - O2::FT0Reconstruction - O2::TPCFastTransformation - O2::GPUO2Interface - O2::TPCBase - O2::TPCReconstruction - O2::TOFBase - O2::TOFCalibration - O2::TOFWorkflowUtils - O2::SimConfig - O2::DataFormatsFT0 - O2::DataFormatsGlobalTracking - O2::ITStracking - O2::MFTTracking - O2::MCHTracking - O2::MathUtils - O2::ReconstructionDataFormats - O2::Steer) + TARGETVARNAME targetName + SOURCES src / + MatchTPCITS.cxx + src / + MatchTOF.cxx + src / + MatchTPCITSParams.cxx + src / + MatchCosmics.cxx + src / + MatchCosmicsParams.cxx + src / + MatchGlobalFwd.cxx + src / + MatchGlobalFwdAssessment.cxx + src / + MatchITSTPCQC.cxx + src / + ITSTPCMatchingQCParams.cxx + src / + MatchGlobalFwdParam.cxx + PUBLIC_LINK_LIBRARIES O2::Framework + O2::DataFormatsTPC + O2::DataFormatsITSMFT + O2::DataFormatsITS + O2::DataFormatsFT0 + O2::DataFormatsTOF + O2::DataFormatsTRD + O2::ITSReconstruction + O2::FT0Reconstruction + O2::TPCFastTransformation + O2::GPUO2Interface + O2::TPCBase + O2::TPCReconstruction + O2::TOFBase + O2::TOFCalibration + O2::TOFWorkflowUtils + O2::SimConfig + O2::DataFormatsFT0 + O2::DataFormatsGlobalTracking + O2::ITStracking + O2::MFTTracking + O2::MCHTracking + O2::MathUtils + O2::ReconstructionDataFormats + O2::Steer) -o2_target_root_dictionary(GlobalTracking - HEADERS include/GlobalTracking/MatchTPCITSParams.h - include/GlobalTracking/MatchGlobalFwd.h - include/GlobalTracking/MatchGlobalFwdParam.h - include/GlobalTracking/MatchGlobalFwdAssessment.h - include/GlobalTracking/MatchTOF.h - include/GlobalTracking/MatchCosmics.h - include/GlobalTracking/MatchCosmicsParams.h - include/GlobalTracking/MatchITSTPCQC.h - include/GlobalTracking/ITSTPCMatchingQCParams.h) + o2_target_root_dictionary(GlobalTracking + HEADERS include / + GlobalTracking / MatchTPCITSParams.h include / GlobalTracking / MatchGlobalFwd.h include / GlobalTracking / MatchGlobalFwdParam.h include / GlobalTracking / MatchGlobalFwdAssessment.h include / GlobalTracking / MatchTOF.h include / GlobalTracking / MatchCosmics.h include / GlobalTracking / MatchCosmicsParams.h include / GlobalTracking / MatchITSTPCQC.h include / GlobalTracking / ITSTPCMatchingQCParams.h include / GlobalTracking / TrackMethods.h include / GlobalTracking / TrackCuts.h) - -if (OpenMP_CXX_FOUND) - target_compile_definitions(${targetName} PRIVATE WITH_OPENMP) - target_link_libraries(${targetName} PRIVATE OpenMP::OpenMP_CXX) -endif() + if (OpenMP_CXX_FOUND) + target_compile_definitions(${targetName} PRIVATE WITH_OPENMP) + target_link_libraries(${targetName} PRIVATE OpenMP::OpenMP_CXX) + endif() diff --git a/Detectors/GlobalTracking/include/GlobalTracking/TrackCuts.h b/Detectors/GlobalTracking/include/GlobalTracking/TrackCuts.h new file mode 100644 index 0000000000000..a2baca2a7c0b5 --- /dev/null +++ b/Detectors/GlobalTracking/include/GlobalTracking/TrackCuts.h @@ -0,0 +1,293 @@ +// Copyright 2019-2020 CERN and copyright holders of ALICE O2. +// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders. +// All rights not expressly granted are reserved. +// +// This software is distributed under the terms of the GNU General Public +// License v3 (GPL Version 3), copied verbatim in the file "COPYING". +// +// In applying this license CERN does not waive the privileges and immunities +// granted to it by virtue of its status as an Intergovernmental Organization +// or submit itself to any jurisdiction. + +/// \file TrackCuts.h +/// \brief Class to perform track cuts +/// \author amelia.lindner@cern.ch + +#ifndef ALICEO2_TRACKCUTS_H +#define ALICEO2_TRACKCUTS_H + +#include "Framework/Logger.h" +#include "Framework/DataTypes.h" +#include "ReconstructionDataFormats/Track.h" +#include "DataFormatsGlobalTracking/RecoContainer.h" +#include "ReconstructionDataFormats/VtxTrackIndex.h" +#include "ReconstructionDataFormats/MatchInfoTOF.h" +#include "DataFormatsTPC/TrackTPC.h" +#include "GlobalTracking/TrackMethods.h" +#include +#include +#include "Rtypes.h" +namespace o2 +{ +using GID = o2::dataformats::GlobalTrackID; +using GIndex = o2::dataformats::VtxTrackIndex; +class TrackCuts +{ + public: + //////////////////////////////// O2 //////////////////////////////// + bool isSelected(GIndex trackIndex, const o2::globaltracking::RecoContainer& data) + { + o2::track::TrackParCov trk; + auto contributorsGID = data.getSingleDetectorRefs(trackIndex); + auto src = trackIndex.getSource(); //make selections depending on track source + if (src == GID::ITSTPCTRDTOF) { + trk = data.getTrack(data.getITSTPCTRDTOFMatches()[trackIndex].getTrackRef()); // ITSTPCTRDTOF is ITSTPCTRD + TOF cluster + } else if (src == GID::TPCTRDTOF) { + trk = data.getTrack(data.getTPCTRDTOFMatches()[trackIndex].getTrackRef()); // TPCTRDTOF is TPCTRD + TOF cluster + } else if (src == GID::ITSTPCTOF) { + trk = data.getTrack(data.getTOFMatch(trackIndex).getTrackRef()); // ITSTPCTOF is ITSTPC + TOF cluster + } else if (src == GID::TPC) { //TPC tracks selection + const auto& tpcTrk = data.getTPCTrack(contributorsGID[GIndex::TPC]); + uint8_t tpcNClsShared, tpcNClsFound, tpcNClsCrossed, tpcNClsFindable, tpcChi2NCl; + tpcNClsFindable = tpcTrk.getNClusters(); + tpcChi2NCl = tpcTrk.getNClusters() ? tpcTrk.getChi2() / tpcTrk.getNClusters() : 0; + TrackMethods::countTPCClusters(tpcTrk, data.getTPCTracksClusterRefs(), data.clusterShMapTPC, data.getTPCClusters(), tpcNClsShared, tpcNClsFound, tpcNClsCrossed); + double tpcCrossedRowsOverFindableCls = tpcNClsCrossed / tpcNClsFindable; + if (tpcTrk.getPt() >= mMinPt && tpcTrk.getPt() <= mMaxPt && + tpcTrk.getEta() >= mMinEta && tpcTrk.getEta() <= mMaxEta && + tpcNClsFound >= mMinNClustersTPC && + tpcNClsCrossed >= mMinNCrossedRowsTPC && + tpcCrossedRowsOverFindableCls >= mMinNCrossedRowsOverFindableClustersTPC && + tpcChi2NCl <= mMaxChi2PerClusterTPC) { + return true; + } else { + return false; + } + } else if (src == GID::ITS) { //ITS tracks selection + const auto& itsTrk = data.getITSTrack(contributorsGID[GIndex::ITS]); + int ITSnClusters = itsTrk.getNClusters(); + float ITSchi2 = itsTrk.getChi2(); + float itsChi2NCl = ITSnClusters != 0 ? ITSchi2 / (float)ITSnClusters : 0; + uint8_t itsClusterMap = itsTrk.getPattern(); + if (itsTrk.getPt() >= mMinPt && itsTrk.getPt() <= mMaxPt && + itsTrk.getEta() >= mMinEta && itsTrk.getEta() <= mMaxEta && + ITSnClusters >= mMinNClustersITS && + itsChi2NCl <= mMaxChi2PerClusterITS && + TrackMethods::FulfillsITSHitRequirements(itsClusterMap, mRequiredITSHits)) { + return true; + } else { + return false; + } + } else { // for the rest, get the track directly + trk = data.getTrack(trackIndex); + } + if (trk.getPt() >= mMinPt && trk.getPt() <= mMaxPt && + trk.getEta() >= mMinEta && trk.getEta() <= mMaxEta) { + return true; + } else { + return false; + } + } + + //////////////////////////////// O2Physics //////////////////////////////// + + enum class TrackCutsList : int { + kTrackType = 0, + kPtRange, + kEtaRange, + kTPCNCls, + kTPCCrossedRows, + kTPCCrossedRowsOverNCls, + kTPCChi2NDF, + kTPCRefit, + kITSNCls, + kITSChi2NDF, + kITSRefit, + kITSHits, + kGoldenChi2, + kDCAxy, + kDCAz, + kNCuts + }; + + static const std::string mCutNames[static_cast(TrackCutsList::kNCuts)]; + // Temporary function to check if track passes selection criteria. To be replaced by framework filters. + template + bool IsSelected(T const& track) + { + const bool isRun2 = track.trackType() == o2::aod::track::Run2Track || track.trackType() == o2::aod::track::Run2Tracklet; + if (track.trackType() == mTrackType && + track.pt() >= mMinPt && track.pt() <= mMaxPt && + track.eta() >= mMinEta && track.eta() <= mMaxEta && + track.tpcNClsFound() >= mMinNClustersTPC && + track.tpcNClsCrossedRows() >= mMinNCrossedRowsTPC && + track.tpcCrossedRowsOverFindableCls() >= mMinNCrossedRowsOverFindableClustersTPC && + (track.itsNCls() >= mMinNClustersITS) && + (track.itsChi2NCl() <= mMaxChi2PerClusterITS) && + (track.tpcChi2NCl() <= mMaxChi2PerClusterTPC) && + (mRequireITSRefit ? (isRun2 ? (track.flags() & o2::aod::track::ITSrefit) : track.hasITS()) : true) && + (mRequireTPCRefit ? (isRun2 ? (track.flags() & o2::aod::track::TPCrefit) : track.hasTPC()) : true) && + ((isRun2 && mRequireGoldenChi2) ? (track.flags() & o2::aod::track::GoldenChi2) : true) && + TrackMethods::FulfillsITSHitRequirements(track.itsClusterMap(), mRequiredITSHits) && + abs(track.dcaXY()) <= ((mMaxDcaXYPtDep) ? mMaxDcaXYPtDep(track.pt()) : mMaxDcaXY) && + abs(track.dcaZ()) <= mMaxDcaZ) { + return true; + } else { + return false; + } + } + + // Temporary function to check if track passes a given selection criteria. To be replaced by framework filters. + template + bool IsSelected(T const& track, const TrackCutsList& cut) + { + const bool isRun2 = track.trackType() == o2::aod::track::Run2Track || track.trackType() == o2::aod::track::Run2Tracklet; + + switch (cut) { + case TrackCutsList::kTrackType: + return track.trackType() == mTrackType; + + case TrackCutsList::kPtRange: + return track.pt() >= mMinPt && track.pt() <= mMaxPt; + + case TrackCutsList::kEtaRange: + return track.eta() >= mMinEta && track.eta() <= mMaxEta; + + case TrackCutsList::kTPCNCls: + return track.tpcNClsFound() >= mMinNClustersTPC; + + case TrackCutsList::kTPCCrossedRows: + return track.tpcNClsCrossedRows() >= mMinNCrossedRowsTPC; + + case TrackCutsList::kTPCCrossedRowsOverNCls: + return track.tpcCrossedRowsOverFindableCls() >= mMinNCrossedRowsOverFindableClustersTPC; + + case TrackCutsList::kTPCChi2NDF: + return track.tpcChi2NCl() <= mMaxChi2PerClusterTPC; + + case TrackCutsList::kTPCRefit: + return (isRun2 && mRequireTPCRefit) ? (track.flags() & o2::aod::track::TPCrefit) : true; + + case TrackCutsList::kITSNCls: + return track.itsNCls() >= mMinNClustersITS; + + case TrackCutsList::kITSChi2NDF: + return track.itsChi2NCl() <= mMaxChi2PerClusterITS; + + case TrackCutsList::kITSRefit: + return (isRun2 && mRequireITSRefit) ? (track.flags() & o2::aod::track::ITSrefit) : true; + + case TrackCutsList::kITSHits: + return FulfillsITSHitRequirements(track.itsClusterMap()); + + case TrackCutsList::kGoldenChi2: + return (isRun2 && mRequireGoldenChi2) ? (track.flags() & o2::aod::track::GoldenChi2) : true; + + case TrackCutsList::kDCAxy: + return abs(track.dcaXY()) <= ((mMaxDcaXYPtDep) ? mMaxDcaXYPtDep(track.pt()) : mMaxDcaXY); + + case TrackCutsList::kDCAz: + return abs(track.dcaZ()) <= mMaxDcaZ; + + default: + return false; + } + } + + void SetTrackType(o2::aod::track::TrackTypeEnum trackType) { mTrackType = trackType; } + void SetPtRange(float minPt = 0.f, float maxPt = 1e10f) + { + mMinPt = minPt; + mMaxPt = maxPt; + } + void SetEtaRange(float minEta = -1e10f, float maxEta = 1e10f) + { + mMinEta = minEta; + mMaxEta = maxEta; + } + void SetRequireITSRefit(bool requireITSRefit = true) + { + mRequireITSRefit = requireITSRefit; + } + void SetRequireTPCRefit(bool requireTPCRefit = true) + { + mRequireTPCRefit = requireTPCRefit; + } + void SetRequireGoldenChi2(bool requireGoldenChi2 = true) + { + mRequireGoldenChi2 = requireGoldenChi2; + } + void SetMinNClustersTPC(int minNClustersTPC) + { + mMinNClustersTPC = minNClustersTPC; + } + void SetMinNCrossedRowsTPC(int minNCrossedRowsTPC) + { + mMinNCrossedRowsTPC = minNCrossedRowsTPC; + } + void SetMinNCrossedRowsOverFindableClustersTPC(float minNCrossedRowsOverFindableClustersTPC) + { + mMinNCrossedRowsOverFindableClustersTPC = minNCrossedRowsOverFindableClustersTPC; + } + void SetMinNClustersITS(int minNClustersITS) + { + mMinNClustersITS = minNClustersITS; + } + void SetMaxChi2PerClusterTPC(float maxChi2PerClusterTPC) + { + mMaxChi2PerClusterTPC = maxChi2PerClusterTPC; + } + void SetMaxChi2PerClusterITS(float maxChi2PerClusterITS) + { + mMaxChi2PerClusterITS = maxChi2PerClusterITS; + } + void SetMaxDcaXY(float maxDcaXY) { mMaxDcaXY = maxDcaXY; } + void SetMaxDcaZ(float maxDcaZ) { mMaxDcaZ = maxDcaZ; } + + void SetMaxDcaXYPtDep(std::function ptDepCut) + { + mMaxDcaXYPtDep = ptDepCut; + } + void SetRequireHitsInITSLayers(int8_t minNRequiredHits, std::set requiredLayers) + { + // layer 0 corresponds to the the innermost ITS layer + mRequiredITSHits.push_back(std::make_pair(minNRequiredHits, requiredLayers)); + } + void SetRequireNoHitsInITSLayers(std::set excludedLayers) + { + mRequiredITSHits.push_back(std::make_pair(-1, excludedLayers)); + } + void ResetITSRequirements() { mRequiredITSHits.clear(); } + + private: + o2::aod::track::TrackTypeEnum mTrackType{o2::aod::track::TrackTypeEnum::Track}; + + // kinematic cuts + float mMinPt{0.f}, + mMaxPt{1e10f}; // range in pT + float mMinEta{-1e10f}, mMaxEta{1e10f}; // range in eta + + // track quality cuts + int mMinNClustersTPC{0}; // min number of TPC clusters + int mMinNCrossedRowsTPC{0}; // min number of crossed rows in TPC + int mMinNClustersITS{0}; // min number of ITS clusters + float mMaxChi2PerClusterTPC{1e10f}; // max tpc fit chi2 per TPC cluster + float mMaxChi2PerClusterITS{1e10f}; // max its fit chi2 per ITS cluster + float mMinNCrossedRowsOverFindableClustersTPC{0.f}; // min ratio crossed rows / findable clusters + + float mMaxDcaXY{1e10f}; // max dca in xy plane + float mMaxDcaZ{1e10f}; // max dca in z direction + std::function mMaxDcaXYPtDep{}; // max dca in xy plane as function of pT + + bool mRequireITSRefit{false}; // require refit in ITS + bool mRequireTPCRefit{false}; // require refit in TPC + bool mRequireGoldenChi2{false}; // require golden chi2 cut (Run 2 only) + + // vector of ITS requirements (minNRequiredHits in specific requiredLayers) + std::vector>> mRequiredITSHits{}; + + ClassDefNV(TrackCuts, 1); +}; +} // namespace o2 + +#endif \ No newline at end of file diff --git a/Detectors/GlobalTracking/include/GlobalTracking/TrackMethods.h b/Detectors/GlobalTracking/include/GlobalTracking/TrackMethods.h new file mode 100644 index 0000000000000..b5c7280184b4d --- /dev/null +++ b/Detectors/GlobalTracking/include/GlobalTracking/TrackMethods.h @@ -0,0 +1,95 @@ +// Copyright 2019-2020 CERN and copyright holders of ALICE O2. +// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders. +// All rights not expressly granted are reserved. +// +// This software is distributed under the terms of the GNU General Public +// License v3 (GPL Version 3), copied verbatim in the file "COPYING". +// +// In applying this license CERN does not waive the privileges and immunities +// granted to it by virtue of its status as an Intergovernmental Organization +// or submit itself to any jurisdiction. + +/// \file TrackCuts.h +/// \brief Class to store some methods used in TrackCuts +/// \author amelia.lindner@cern.ch + +#ifndef ALICEO2_TRACKMETHODS_H +#define ALICEO2_TRACKMETHODS_H + +#include "DataFormatsTPC/TrackTPC.h" +#include "GPUTPCGMMergedTrackHit.h" +#include "DataFormatsITS/TrackITS.h" +#include +#include + +namespace o2 +{ +class TrackMethods +{ + public: + static void countTPCClusters(const o2::tpc::TrackTPC& track, + const gsl::span& tpcClusRefs, + const gsl::span& tpcClusShMap, + const o2::tpc::ClusterNativeAccess& tpcClusAcc, + uint8_t& shared, uint8_t& found, uint8_t& crossed) + { + constexpr int maxRows = 152; + constexpr int neighbour = 2; + std::array clMap{}, shMap{}; + uint8_t sectorIndex; + uint8_t rowIndex; + uint32_t clusterIndex; + shared = 0; + for (int i = 0; i < track.getNClusterReferences(); i++) { + o2::tpc::TrackTPC::getClusterReference(tpcClusRefs, i, sectorIndex, rowIndex, clusterIndex, track.getClusterRef()); + unsigned int absoluteIndex = tpcClusAcc.clusterOffset[sectorIndex][rowIndex] + clusterIndex; + clMap[rowIndex] = true; + if (tpcClusShMap[absoluteIndex] & GPUCA_NAMESPACE::gpu::GPUTPCGMMergedTrackHit::flagShared) { + if (!shMap[rowIndex]) { + shared++; + } + shMap[rowIndex] = true; + } + } + + crossed = 0; + found = 0; + int last = -1; + for (int i = 0; i < maxRows; i++) { + if (clMap[i]) { + crossed++; + found++; + last = i; + } else if ((i - last) <= neighbour) { + crossed++; + } else { + int lim = std::min(i + 1 + neighbour, maxRows); + for (int j = i + 1; j < lim; j++) { + if (clMap[j]) { + crossed++; + } + } + } + } + } + static bool FulfillsITSHitRequirements(uint8_t itsClusterMap, std::vector>> mRequiredITSHits) + { + constexpr uint8_t bit = 1; + for (auto& itsRequirement : mRequiredITSHits) { + auto hits = std::count_if(itsRequirement.second.begin(), itsRequirement.second.end(), [&](auto&& requiredLayer) { return itsClusterMap & (bit << requiredLayer); }); + if ((itsRequirement.first == -1) && (hits > 0)) { + return false; // no hits were required in specified layers + } else if (hits < itsRequirement.first) { + return false; // not enough hits found in specified layers + } + } + return true; + } + + + + ClassDefNV(TrackMethods, 1); +}; +} // namespace o2 + +#endif \ No newline at end of file From 4712bcad4641f44ec7b646a468b20ffb2fdf9b8e Mon Sep 17 00:00:00 2001 From: Amelia Lindner Date: Mon, 11 Apr 2022 17:34:58 +0300 Subject: [PATCH 02/15] add MatchITSTPCQC.cxx --- Detectors/GlobalTracking/src/MatchITSTPCQC.cxx | 9 ++++++++- 1 file changed, 8 insertions(+), 1 deletion(-) diff --git a/Detectors/GlobalTracking/src/MatchITSTPCQC.cxx b/Detectors/GlobalTracking/src/MatchITSTPCQC.cxx index 1565e3997d89e..6451e2a058685 100644 --- a/Detectors/GlobalTracking/src/MatchITSTPCQC.cxx +++ b/Detectors/GlobalTracking/src/MatchITSTPCQC.cxx @@ -10,10 +10,12 @@ // or submit itself to any jurisdiction. #include "GlobalTracking/MatchITSTPCQC.h" +#include "GlobalTracking/TrackCuts.h" #include "ReconstructionDataFormats/TrackTPCITS.h" #include "DataFormatsTPC/TrackTPC.h" #include "Framework/InputSpec.h" #include "ReconstructionDataFormats/TrackParametrization.h" +#include "DataFormatsGlobalTracking/RecoContainer.h" #include "DetectorsBase/Propagator.h" #include "DetectorsBase/GeometryManager.h" #include "SimulationDataFormat/MCUtils.h" @@ -164,6 +166,7 @@ void MatchITSTPCQC::initDataRequest() void MatchITSTPCQC::run(o2::framework::ProcessingContext& ctx) { static int evCount = 0; + o2::globaltracking::RecoContainer mRecoCont; mRecoCont.collectData(ctx, *mDataRequest.get()); mTPCTracks = mRecoCont.getTPCTracks(); mITSTPCTracks = mRecoCont.getTPCITSTracks(); @@ -175,7 +178,11 @@ void MatchITSTPCQC::run(o2::framework::ProcessingContext& ctx) std::vector isTPCTrackSelectedEntry(mTPCTracks.size(), false); for (auto itrk = 0; itrk < mTPCTracks.size(); ++itrk) { auto const& trkTpc = mTPCTracks[itrk]; - if (selectTrack(trkTpc)) { + // if (selectTrack(trkTpc)) { + // isTPCTrackSelectedEntry[itrk] = true; + // } + o2::dataformats::GlobalTrackID id(itrk,o2::dataformats::GlobalTrackID::TPC); + if (TrackCuts::isSelected(id, mRecoCont)) { isTPCTrackSelectedEntry[itrk] = true; } } From eea1f476da37e195223bf7a001213bb13f0792a2 Mon Sep 17 00:00:00 2001 From: Amelia Lindner Date: Mon, 11 Apr 2022 17:37:24 +0300 Subject: [PATCH 03/15] add header file --- Detectors/GlobalTracking/include/GlobalTracking/MatchITSTPCQC.h | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Detectors/GlobalTracking/include/GlobalTracking/MatchITSTPCQC.h b/Detectors/GlobalTracking/include/GlobalTracking/MatchITSTPCQC.h index df82318596123..1be9e3e7d69f2 100644 --- a/Detectors/GlobalTracking/include/GlobalTracking/MatchITSTPCQC.h +++ b/Detectors/GlobalTracking/include/GlobalTracking/MatchITSTPCQC.h @@ -98,7 +98,7 @@ class MatchITSTPCQC private: std::shared_ptr mDataRequest; - o2::globaltracking::RecoContainer mRecoCont; + // o2::globaltracking::RecoContainer mRecoCont; GID::mask_t mSrc = GID::getSourcesMask("TPC,ITS-TPC"); GID::mask_t mAllowedSources = GID::getSourcesMask("TPC,ITS-TPC"); // TPC From 2d533154f049b230225b7078936e531d14d97922 Mon Sep 17 00:00:00 2001 From: Amelia Lindner Date: Mon, 11 Apr 2022 19:28:02 +0300 Subject: [PATCH 04/15] working example --- .../include/GlobalTracking/MatchITSTPCQC.h | 2 +- .../include/GlobalTracking/TrackCuts.h | 584 +++++++++--------- .../GlobalTracking/src/MatchITSTPCQC.cxx | 10 +- 3 files changed, 297 insertions(+), 299 deletions(-) diff --git a/Detectors/GlobalTracking/include/GlobalTracking/MatchITSTPCQC.h b/Detectors/GlobalTracking/include/GlobalTracking/MatchITSTPCQC.h index 1be9e3e7d69f2..df82318596123 100644 --- a/Detectors/GlobalTracking/include/GlobalTracking/MatchITSTPCQC.h +++ b/Detectors/GlobalTracking/include/GlobalTracking/MatchITSTPCQC.h @@ -98,7 +98,7 @@ class MatchITSTPCQC private: std::shared_ptr mDataRequest; - // o2::globaltracking::RecoContainer mRecoCont; + o2::globaltracking::RecoContainer mRecoCont; GID::mask_t mSrc = GID::getSourcesMask("TPC,ITS-TPC"); GID::mask_t mAllowedSources = GID::getSourcesMask("TPC,ITS-TPC"); // TPC diff --git a/Detectors/GlobalTracking/include/GlobalTracking/TrackCuts.h b/Detectors/GlobalTracking/include/GlobalTracking/TrackCuts.h index a2baca2a7c0b5..e6e0b2e7594b4 100644 --- a/Detectors/GlobalTracking/include/GlobalTracking/TrackCuts.h +++ b/Detectors/GlobalTracking/include/GlobalTracking/TrackCuts.h @@ -1,293 +1,291 @@ -// Copyright 2019-2020 CERN and copyright holders of ALICE O2. -// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders. -// All rights not expressly granted are reserved. -// -// This software is distributed under the terms of the GNU General Public -// License v3 (GPL Version 3), copied verbatim in the file "COPYING". -// -// In applying this license CERN does not waive the privileges and immunities -// granted to it by virtue of its status as an Intergovernmental Organization -// or submit itself to any jurisdiction. - -/// \file TrackCuts.h -/// \brief Class to perform track cuts -/// \author amelia.lindner@cern.ch - -#ifndef ALICEO2_TRACKCUTS_H -#define ALICEO2_TRACKCUTS_H - -#include "Framework/Logger.h" -#include "Framework/DataTypes.h" -#include "ReconstructionDataFormats/Track.h" -#include "DataFormatsGlobalTracking/RecoContainer.h" -#include "ReconstructionDataFormats/VtxTrackIndex.h" -#include "ReconstructionDataFormats/MatchInfoTOF.h" -#include "DataFormatsTPC/TrackTPC.h" -#include "GlobalTracking/TrackMethods.h" -#include -#include -#include "Rtypes.h" -namespace o2 -{ -using GID = o2::dataformats::GlobalTrackID; -using GIndex = o2::dataformats::VtxTrackIndex; -class TrackCuts -{ - public: - //////////////////////////////// O2 //////////////////////////////// - bool isSelected(GIndex trackIndex, const o2::globaltracking::RecoContainer& data) - { - o2::track::TrackParCov trk; - auto contributorsGID = data.getSingleDetectorRefs(trackIndex); - auto src = trackIndex.getSource(); //make selections depending on track source - if (src == GID::ITSTPCTRDTOF) { - trk = data.getTrack(data.getITSTPCTRDTOFMatches()[trackIndex].getTrackRef()); // ITSTPCTRDTOF is ITSTPCTRD + TOF cluster - } else if (src == GID::TPCTRDTOF) { - trk = data.getTrack(data.getTPCTRDTOFMatches()[trackIndex].getTrackRef()); // TPCTRDTOF is TPCTRD + TOF cluster - } else if (src == GID::ITSTPCTOF) { - trk = data.getTrack(data.getTOFMatch(trackIndex).getTrackRef()); // ITSTPCTOF is ITSTPC + TOF cluster - } else if (src == GID::TPC) { //TPC tracks selection - const auto& tpcTrk = data.getTPCTrack(contributorsGID[GIndex::TPC]); - uint8_t tpcNClsShared, tpcNClsFound, tpcNClsCrossed, tpcNClsFindable, tpcChi2NCl; - tpcNClsFindable = tpcTrk.getNClusters(); - tpcChi2NCl = tpcTrk.getNClusters() ? tpcTrk.getChi2() / tpcTrk.getNClusters() : 0; - TrackMethods::countTPCClusters(tpcTrk, data.getTPCTracksClusterRefs(), data.clusterShMapTPC, data.getTPCClusters(), tpcNClsShared, tpcNClsFound, tpcNClsCrossed); - double tpcCrossedRowsOverFindableCls = tpcNClsCrossed / tpcNClsFindable; - if (tpcTrk.getPt() >= mMinPt && tpcTrk.getPt() <= mMaxPt && - tpcTrk.getEta() >= mMinEta && tpcTrk.getEta() <= mMaxEta && - tpcNClsFound >= mMinNClustersTPC && - tpcNClsCrossed >= mMinNCrossedRowsTPC && - tpcCrossedRowsOverFindableCls >= mMinNCrossedRowsOverFindableClustersTPC && - tpcChi2NCl <= mMaxChi2PerClusterTPC) { - return true; - } else { - return false; - } - } else if (src == GID::ITS) { //ITS tracks selection - const auto& itsTrk = data.getITSTrack(contributorsGID[GIndex::ITS]); - int ITSnClusters = itsTrk.getNClusters(); - float ITSchi2 = itsTrk.getChi2(); - float itsChi2NCl = ITSnClusters != 0 ? ITSchi2 / (float)ITSnClusters : 0; - uint8_t itsClusterMap = itsTrk.getPattern(); - if (itsTrk.getPt() >= mMinPt && itsTrk.getPt() <= mMaxPt && - itsTrk.getEta() >= mMinEta && itsTrk.getEta() <= mMaxEta && - ITSnClusters >= mMinNClustersITS && - itsChi2NCl <= mMaxChi2PerClusterITS && - TrackMethods::FulfillsITSHitRequirements(itsClusterMap, mRequiredITSHits)) { - return true; - } else { - return false; - } - } else { // for the rest, get the track directly - trk = data.getTrack(trackIndex); - } - if (trk.getPt() >= mMinPt && trk.getPt() <= mMaxPt && - trk.getEta() >= mMinEta && trk.getEta() <= mMaxEta) { - return true; - } else { - return false; - } - } - - //////////////////////////////// O2Physics //////////////////////////////// - - enum class TrackCutsList : int { - kTrackType = 0, - kPtRange, - kEtaRange, - kTPCNCls, - kTPCCrossedRows, - kTPCCrossedRowsOverNCls, - kTPCChi2NDF, - kTPCRefit, - kITSNCls, - kITSChi2NDF, - kITSRefit, - kITSHits, - kGoldenChi2, - kDCAxy, - kDCAz, - kNCuts - }; - - static const std::string mCutNames[static_cast(TrackCutsList::kNCuts)]; - // Temporary function to check if track passes selection criteria. To be replaced by framework filters. - template - bool IsSelected(T const& track) - { - const bool isRun2 = track.trackType() == o2::aod::track::Run2Track || track.trackType() == o2::aod::track::Run2Tracklet; - if (track.trackType() == mTrackType && - track.pt() >= mMinPt && track.pt() <= mMaxPt && - track.eta() >= mMinEta && track.eta() <= mMaxEta && - track.tpcNClsFound() >= mMinNClustersTPC && - track.tpcNClsCrossedRows() >= mMinNCrossedRowsTPC && - track.tpcCrossedRowsOverFindableCls() >= mMinNCrossedRowsOverFindableClustersTPC && - (track.itsNCls() >= mMinNClustersITS) && - (track.itsChi2NCl() <= mMaxChi2PerClusterITS) && - (track.tpcChi2NCl() <= mMaxChi2PerClusterTPC) && - (mRequireITSRefit ? (isRun2 ? (track.flags() & o2::aod::track::ITSrefit) : track.hasITS()) : true) && - (mRequireTPCRefit ? (isRun2 ? (track.flags() & o2::aod::track::TPCrefit) : track.hasTPC()) : true) && - ((isRun2 && mRequireGoldenChi2) ? (track.flags() & o2::aod::track::GoldenChi2) : true) && - TrackMethods::FulfillsITSHitRequirements(track.itsClusterMap(), mRequiredITSHits) && - abs(track.dcaXY()) <= ((mMaxDcaXYPtDep) ? mMaxDcaXYPtDep(track.pt()) : mMaxDcaXY) && - abs(track.dcaZ()) <= mMaxDcaZ) { - return true; - } else { - return false; - } - } - - // Temporary function to check if track passes a given selection criteria. To be replaced by framework filters. - template - bool IsSelected(T const& track, const TrackCutsList& cut) - { - const bool isRun2 = track.trackType() == o2::aod::track::Run2Track || track.trackType() == o2::aod::track::Run2Tracklet; - - switch (cut) { - case TrackCutsList::kTrackType: - return track.trackType() == mTrackType; - - case TrackCutsList::kPtRange: - return track.pt() >= mMinPt && track.pt() <= mMaxPt; - - case TrackCutsList::kEtaRange: - return track.eta() >= mMinEta && track.eta() <= mMaxEta; - - case TrackCutsList::kTPCNCls: - return track.tpcNClsFound() >= mMinNClustersTPC; - - case TrackCutsList::kTPCCrossedRows: - return track.tpcNClsCrossedRows() >= mMinNCrossedRowsTPC; - - case TrackCutsList::kTPCCrossedRowsOverNCls: - return track.tpcCrossedRowsOverFindableCls() >= mMinNCrossedRowsOverFindableClustersTPC; - - case TrackCutsList::kTPCChi2NDF: - return track.tpcChi2NCl() <= mMaxChi2PerClusterTPC; - - case TrackCutsList::kTPCRefit: - return (isRun2 && mRequireTPCRefit) ? (track.flags() & o2::aod::track::TPCrefit) : true; - - case TrackCutsList::kITSNCls: - return track.itsNCls() >= mMinNClustersITS; - - case TrackCutsList::kITSChi2NDF: - return track.itsChi2NCl() <= mMaxChi2PerClusterITS; - - case TrackCutsList::kITSRefit: - return (isRun2 && mRequireITSRefit) ? (track.flags() & o2::aod::track::ITSrefit) : true; - - case TrackCutsList::kITSHits: - return FulfillsITSHitRequirements(track.itsClusterMap()); - - case TrackCutsList::kGoldenChi2: - return (isRun2 && mRequireGoldenChi2) ? (track.flags() & o2::aod::track::GoldenChi2) : true; - - case TrackCutsList::kDCAxy: - return abs(track.dcaXY()) <= ((mMaxDcaXYPtDep) ? mMaxDcaXYPtDep(track.pt()) : mMaxDcaXY); - - case TrackCutsList::kDCAz: - return abs(track.dcaZ()) <= mMaxDcaZ; - - default: - return false; - } - } - - void SetTrackType(o2::aod::track::TrackTypeEnum trackType) { mTrackType = trackType; } - void SetPtRange(float minPt = 0.f, float maxPt = 1e10f) - { - mMinPt = minPt; - mMaxPt = maxPt; - } - void SetEtaRange(float minEta = -1e10f, float maxEta = 1e10f) - { - mMinEta = minEta; - mMaxEta = maxEta; - } - void SetRequireITSRefit(bool requireITSRefit = true) - { - mRequireITSRefit = requireITSRefit; - } - void SetRequireTPCRefit(bool requireTPCRefit = true) - { - mRequireTPCRefit = requireTPCRefit; - } - void SetRequireGoldenChi2(bool requireGoldenChi2 = true) - { - mRequireGoldenChi2 = requireGoldenChi2; - } - void SetMinNClustersTPC(int minNClustersTPC) - { - mMinNClustersTPC = minNClustersTPC; - } - void SetMinNCrossedRowsTPC(int minNCrossedRowsTPC) - { - mMinNCrossedRowsTPC = minNCrossedRowsTPC; - } - void SetMinNCrossedRowsOverFindableClustersTPC(float minNCrossedRowsOverFindableClustersTPC) - { - mMinNCrossedRowsOverFindableClustersTPC = minNCrossedRowsOverFindableClustersTPC; - } - void SetMinNClustersITS(int minNClustersITS) - { - mMinNClustersITS = minNClustersITS; - } - void SetMaxChi2PerClusterTPC(float maxChi2PerClusterTPC) - { - mMaxChi2PerClusterTPC = maxChi2PerClusterTPC; - } - void SetMaxChi2PerClusterITS(float maxChi2PerClusterITS) - { - mMaxChi2PerClusterITS = maxChi2PerClusterITS; - } - void SetMaxDcaXY(float maxDcaXY) { mMaxDcaXY = maxDcaXY; } - void SetMaxDcaZ(float maxDcaZ) { mMaxDcaZ = maxDcaZ; } - - void SetMaxDcaXYPtDep(std::function ptDepCut) - { - mMaxDcaXYPtDep = ptDepCut; - } - void SetRequireHitsInITSLayers(int8_t minNRequiredHits, std::set requiredLayers) - { - // layer 0 corresponds to the the innermost ITS layer - mRequiredITSHits.push_back(std::make_pair(minNRequiredHits, requiredLayers)); - } - void SetRequireNoHitsInITSLayers(std::set excludedLayers) - { - mRequiredITSHits.push_back(std::make_pair(-1, excludedLayers)); - } - void ResetITSRequirements() { mRequiredITSHits.clear(); } - - private: - o2::aod::track::TrackTypeEnum mTrackType{o2::aod::track::TrackTypeEnum::Track}; - - // kinematic cuts - float mMinPt{0.f}, - mMaxPt{1e10f}; // range in pT - float mMinEta{-1e10f}, mMaxEta{1e10f}; // range in eta - - // track quality cuts - int mMinNClustersTPC{0}; // min number of TPC clusters - int mMinNCrossedRowsTPC{0}; // min number of crossed rows in TPC - int mMinNClustersITS{0}; // min number of ITS clusters - float mMaxChi2PerClusterTPC{1e10f}; // max tpc fit chi2 per TPC cluster - float mMaxChi2PerClusterITS{1e10f}; // max its fit chi2 per ITS cluster - float mMinNCrossedRowsOverFindableClustersTPC{0.f}; // min ratio crossed rows / findable clusters - - float mMaxDcaXY{1e10f}; // max dca in xy plane - float mMaxDcaZ{1e10f}; // max dca in z direction - std::function mMaxDcaXYPtDep{}; // max dca in xy plane as function of pT - - bool mRequireITSRefit{false}; // require refit in ITS - bool mRequireTPCRefit{false}; // require refit in TPC - bool mRequireGoldenChi2{false}; // require golden chi2 cut (Run 2 only) - - // vector of ITS requirements (minNRequiredHits in specific requiredLayers) - std::vector>> mRequiredITSHits{}; - - ClassDefNV(TrackCuts, 1); -}; -} // namespace o2 - -#endif \ No newline at end of file +// Copyright 2019-2020 CERN and copyright holders of ALICE O2. +// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders. +// All rights not expressly granted are reserved. +// +// This software is distributed under the terms of the GNU General Public +// License v3 (GPL Version 3), copied verbatim in the file "COPYING". +// +// In applying this license CERN does not waive the privileges and immunities +// granted to it by virtue of its status as an Intergovernmental Organization +// or submit itself to any jurisdiction. + +/// \file TrackCuts.h +/// \brief Class to perform track cuts +/// \author amelia.lindner@cern.ch + +#ifndef ALICEO2_TRACKCUTS_H +#define ALICEO2_TRACKCUTS_H + +#include "Framework/Logger.h" +#include "Framework/DataTypes.h" +#include "ReconstructionDataFormats/Track.h" +#include "DataFormatsGlobalTracking/RecoContainer.h" +#include "ReconstructionDataFormats/MatchInfoTOF.h" +#include "DataFormatsTPC/TrackTPC.h" +#include "GlobalTracking/TrackMethods.h" +#include +#include +#include "Rtypes.h" +namespace o2 +{ +using GID = o2::dataformats::GlobalTrackID; +class TrackCuts +{ + public: + //////////////////////////////// O2 //////////////////////////////// + bool isSelected(GID trackIndex, o2::globaltracking::RecoContainer& data) + { + o2::track::TrackParCov trk; + auto contributorsGID = data.getSingleDetectorRefs(trackIndex); + auto src = trackIndex.getSource(); //make selections depending on track source + if (src == GID::ITSTPCTRDTOF) { + trk = data.getTrack(data.getITSTPCTRDTOFMatches()[trackIndex].getTrackRef()); // ITSTPCTRDTOF is ITSTPCTRD + TOF cluster + } else if (src == GID::TPCTRDTOF) { + trk = data.getTrack(data.getTPCTRDTOFMatches()[trackIndex].getTrackRef()); // TPCTRDTOF is TPCTRD + TOF cluster + } else if (src == GID::ITSTPCTOF) { + trk = data.getTrack(data.getTOFMatch(trackIndex).getTrackRef()); // ITSTPCTOF is ITSTPC + TOF cluster + } else if (src == GID::TPC) { //TPC tracks selection + const auto& tpcTrk = data.getTPCTrack(src); + uint8_t tpcNClsShared, tpcNClsFound, tpcNClsCrossed, tpcNClsFindable, tpcChi2NCl; + tpcNClsFindable = tpcTrk.getNClusters(); + tpcChi2NCl = tpcTrk.getNClusters() ? tpcTrk.getChi2() / tpcTrk.getNClusters() : 0; + TrackMethods::countTPCClusters(tpcTrk, data.getTPCTracksClusterRefs(), data.clusterShMapTPC, data.getTPCClusters(), tpcNClsShared, tpcNClsFound, tpcNClsCrossed); + double tpcCrossedRowsOverFindableCls = tpcNClsCrossed / tpcNClsFindable; + if (tpcTrk.getPt() >= mMinPt && tpcTrk.getPt() <= mMaxPt && + tpcTrk.getEta() >= mMinEta && tpcTrk.getEta() <= mMaxEta && + tpcNClsFound >= mMinNClustersTPC && + tpcNClsCrossed >= mMinNCrossedRowsTPC && + tpcCrossedRowsOverFindableCls >= mMinNCrossedRowsOverFindableClustersTPC && + tpcChi2NCl <= mMaxChi2PerClusterTPC) { + return true; + } else { + return false; + } + } else if (src == GID::ITS) { //ITS tracks selection + const auto& itsTrk = data.getITSTrack(contributorsGID[src]); + int ITSnClusters = itsTrk.getNClusters(); + float ITSchi2 = itsTrk.getChi2(); + float itsChi2NCl = ITSnClusters != 0 ? ITSchi2 / (float)ITSnClusters : 0; + uint8_t itsClusterMap = itsTrk.getPattern(); + if (itsTrk.getPt() >= mMinPt && itsTrk.getPt() <= mMaxPt && + itsTrk.getEta() >= mMinEta && itsTrk.getEta() <= mMaxEta && + ITSnClusters >= mMinNClustersITS && + itsChi2NCl <= mMaxChi2PerClusterITS && + TrackMethods::FulfillsITSHitRequirements(itsClusterMap, mRequiredITSHits)) { + return true; + } else { + return false; + } + } else { // for the rest, get the track directly + trk = data.getTrack(trackIndex); + } + if (trk.getPt() >= mMinPt && trk.getPt() <= mMaxPt && + trk.getEta() >= mMinEta && trk.getEta() <= mMaxEta) { + return true; + } else { + return false; + } + } + + //////////////////////////////// O2Physics //////////////////////////////// + + enum class TrackCutsList : int { + kTrackType = 0, + kPtRange, + kEtaRange, + kTPCNCls, + kTPCCrossedRows, + kTPCCrossedRowsOverNCls, + kTPCChi2NDF, + kTPCRefit, + kITSNCls, + kITSChi2NDF, + kITSRefit, + kITSHits, + kGoldenChi2, + kDCAxy, + kDCAz, + kNCuts + }; + + static const std::string mCutNames[static_cast(TrackCutsList::kNCuts)]; + // Temporary function to check if track passes selection criteria. To be replaced by framework filters. + template + bool IsSelected(T const& track) + { + const bool isRun2 = track.trackType() == o2::aod::track::Run2Track || track.trackType() == o2::aod::track::Run2Tracklet; + if (track.trackType() == mTrackType && + track.pt() >= mMinPt && track.pt() <= mMaxPt && + track.eta() >= mMinEta && track.eta() <= mMaxEta && + track.tpcNClsFound() >= mMinNClustersTPC && + track.tpcNClsCrossedRows() >= mMinNCrossedRowsTPC && + track.tpcCrossedRowsOverFindableCls() >= mMinNCrossedRowsOverFindableClustersTPC && + (track.itsNCls() >= mMinNClustersITS) && + (track.itsChi2NCl() <= mMaxChi2PerClusterITS) && + (track.tpcChi2NCl() <= mMaxChi2PerClusterTPC) && + (mRequireITSRefit ? (isRun2 ? (track.flags() & o2::aod::track::ITSrefit) : track.hasITS()) : true) && + (mRequireTPCRefit ? (isRun2 ? (track.flags() & o2::aod::track::TPCrefit) : track.hasTPC()) : true) && + ((isRun2 && mRequireGoldenChi2) ? (track.flags() & o2::aod::track::GoldenChi2) : true) && + TrackMethods::FulfillsITSHitRequirements(track.itsClusterMap(), mRequiredITSHits) && + abs(track.dcaXY()) <= ((mMaxDcaXYPtDep) ? mMaxDcaXYPtDep(track.pt()) : mMaxDcaXY) && + abs(track.dcaZ()) <= mMaxDcaZ) { + return true; + } else { + return false; + } + } + + // Temporary function to check if track passes a given selection criteria. To be replaced by framework filters. + template + bool IsSelected(T const& track, const TrackCutsList& cut) + { + const bool isRun2 = track.trackType() == o2::aod::track::Run2Track || track.trackType() == o2::aod::track::Run2Tracklet; + + switch (cut) { + case TrackCutsList::kTrackType: + return track.trackType() == mTrackType; + + case TrackCutsList::kPtRange: + return track.pt() >= mMinPt && track.pt() <= mMaxPt; + + case TrackCutsList::kEtaRange: + return track.eta() >= mMinEta && track.eta() <= mMaxEta; + + case TrackCutsList::kTPCNCls: + return track.tpcNClsFound() >= mMinNClustersTPC; + + case TrackCutsList::kTPCCrossedRows: + return track.tpcNClsCrossedRows() >= mMinNCrossedRowsTPC; + + case TrackCutsList::kTPCCrossedRowsOverNCls: + return track.tpcCrossedRowsOverFindableCls() >= mMinNCrossedRowsOverFindableClustersTPC; + + case TrackCutsList::kTPCChi2NDF: + return track.tpcChi2NCl() <= mMaxChi2PerClusterTPC; + + case TrackCutsList::kTPCRefit: + return (isRun2 && mRequireTPCRefit) ? (track.flags() & o2::aod::track::TPCrefit) : true; + + case TrackCutsList::kITSNCls: + return track.itsNCls() >= mMinNClustersITS; + + case TrackCutsList::kITSChi2NDF: + return track.itsChi2NCl() <= mMaxChi2PerClusterITS; + + case TrackCutsList::kITSRefit: + return (isRun2 && mRequireITSRefit) ? (track.flags() & o2::aod::track::ITSrefit) : true; + + case TrackCutsList::kITSHits: + return FulfillsITSHitRequirements(track.itsClusterMap()); + + case TrackCutsList::kGoldenChi2: + return (isRun2 && mRequireGoldenChi2) ? (track.flags() & o2::aod::track::GoldenChi2) : true; + + case TrackCutsList::kDCAxy: + return abs(track.dcaXY()) <= ((mMaxDcaXYPtDep) ? mMaxDcaXYPtDep(track.pt()) : mMaxDcaXY); + + case TrackCutsList::kDCAz: + return abs(track.dcaZ()) <= mMaxDcaZ; + + default: + return false; + } + } + + void SetTrackType(o2::aod::track::TrackTypeEnum trackType) { mTrackType = trackType; } + void SetPtRange(float minPt = 0.f, float maxPt = 1e10f) + { + mMinPt = minPt; + mMaxPt = maxPt; + } + void SetEtaRange(float minEta = -1e10f, float maxEta = 1e10f) + { + mMinEta = minEta; + mMaxEta = maxEta; + } + void SetRequireITSRefit(bool requireITSRefit = true) + { + mRequireITSRefit = requireITSRefit; + } + void SetRequireTPCRefit(bool requireTPCRefit = true) + { + mRequireTPCRefit = requireTPCRefit; + } + void SetRequireGoldenChi2(bool requireGoldenChi2 = true) + { + mRequireGoldenChi2 = requireGoldenChi2; + } + void SetMinNClustersTPC(int minNClustersTPC) + { + mMinNClustersTPC = minNClustersTPC; + } + void SetMinNCrossedRowsTPC(int minNCrossedRowsTPC) + { + mMinNCrossedRowsTPC = minNCrossedRowsTPC; + } + void SetMinNCrossedRowsOverFindableClustersTPC(float minNCrossedRowsOverFindableClustersTPC) + { + mMinNCrossedRowsOverFindableClustersTPC = minNCrossedRowsOverFindableClustersTPC; + } + void SetMinNClustersITS(int minNClustersITS) + { + mMinNClustersITS = minNClustersITS; + } + void SetMaxChi2PerClusterTPC(float maxChi2PerClusterTPC) + { + mMaxChi2PerClusterTPC = maxChi2PerClusterTPC; + } + void SetMaxChi2PerClusterITS(float maxChi2PerClusterITS) + { + mMaxChi2PerClusterITS = maxChi2PerClusterITS; + } + void SetMaxDcaXY(float maxDcaXY) { mMaxDcaXY = maxDcaXY; } + void SetMaxDcaZ(float maxDcaZ) { mMaxDcaZ = maxDcaZ; } + + void SetMaxDcaXYPtDep(std::function ptDepCut) + { + mMaxDcaXYPtDep = ptDepCut; + } + void SetRequireHitsInITSLayers(int8_t minNRequiredHits, std::set requiredLayers) + { + // layer 0 corresponds to the the innermost ITS layer + mRequiredITSHits.push_back(std::make_pair(minNRequiredHits, requiredLayers)); + } + void SetRequireNoHitsInITSLayers(std::set excludedLayers) + { + mRequiredITSHits.push_back(std::make_pair(-1, excludedLayers)); + } + void ResetITSRequirements() { mRequiredITSHits.clear(); } + + private: + o2::aod::track::TrackTypeEnum mTrackType{o2::aod::track::TrackTypeEnum::Track}; + + // kinematic cuts + float mMinPt{5}, + mMaxPt{6}; // range in pT + float mMinEta{-1e10f}, mMaxEta{1e10f}; // range in eta + + // track quality cuts + int mMinNClustersTPC{0}; // min number of TPC clusters + int mMinNCrossedRowsTPC{0}; // min number of crossed rows in TPC + int mMinNClustersITS{0}; // min number of ITS clusters + float mMaxChi2PerClusterTPC{1e10f}; // max tpc fit chi2 per TPC cluster + float mMaxChi2PerClusterITS{1e10f}; // max its fit chi2 per ITS cluster + float mMinNCrossedRowsOverFindableClustersTPC{0.f}; // min ratio crossed rows / findable clusters + + float mMaxDcaXY{1e10f}; // max dca in xy plane + float mMaxDcaZ{1e10f}; // max dca in z direction + std::function mMaxDcaXYPtDep{}; // max dca in xy plane as function of pT + + bool mRequireITSRefit{false}; // require refit in ITS + bool mRequireTPCRefit{false}; // require refit in TPC + bool mRequireGoldenChi2{false}; // require golden chi2 cut (Run 2 only) + + // vector of ITS requirements (minNRequiredHits in specific requiredLayers) + std::vector>> mRequiredITSHits{}; + + ClassDefNV(TrackCuts, 1); +}; +} // namespace o2 + +#endif diff --git a/Detectors/GlobalTracking/src/MatchITSTPCQC.cxx b/Detectors/GlobalTracking/src/MatchITSTPCQC.cxx index 6451e2a058685..236130665f522 100644 --- a/Detectors/GlobalTracking/src/MatchITSTPCQC.cxx +++ b/Detectors/GlobalTracking/src/MatchITSTPCQC.cxx @@ -15,7 +15,6 @@ #include "DataFormatsTPC/TrackTPC.h" #include "Framework/InputSpec.h" #include "ReconstructionDataFormats/TrackParametrization.h" -#include "DataFormatsGlobalTracking/RecoContainer.h" #include "DetectorsBase/Propagator.h" #include "DetectorsBase/GeometryManager.h" #include "SimulationDataFormat/MCUtils.h" @@ -26,6 +25,7 @@ using namespace o2::globaltracking; using namespace o2::mcutils; using MCTrack = o2::MCTrackT; + MatchITSTPCQC::~MatchITSTPCQC() { @@ -166,7 +166,6 @@ void MatchITSTPCQC::initDataRequest() void MatchITSTPCQC::run(o2::framework::ProcessingContext& ctx) { static int evCount = 0; - o2::globaltracking::RecoContainer mRecoCont; mRecoCont.collectData(ctx, *mDataRequest.get()); mTPCTracks = mRecoCont.getTPCTracks(); mITSTPCTracks = mRecoCont.getTPCITSTracks(); @@ -176,13 +175,14 @@ void MatchITSTPCQC::run(o2::framework::ProcessingContext& ctx) // cache selection for TPC tracks std::vector isTPCTrackSelectedEntry(mTPCTracks.size(), false); + TrackCuts cuts; for (auto itrk = 0; itrk < mTPCTracks.size(); ++itrk) { - auto const& trkTpc = mTPCTracks[itrk]; + // auto const& trkTpc = mTPCTracks[itrk]; // if (selectTrack(trkTpc)) { // isTPCTrackSelectedEntry[itrk] = true; // } - o2::dataformats::GlobalTrackID id(itrk,o2::dataformats::GlobalTrackID::TPC); - if (TrackCuts::isSelected(id, mRecoCont)) { + o2::dataformats::GlobalTrackID id(itrk,GID::TPC); + if (cuts.isSelected(id, mRecoCont)) { isTPCTrackSelectedEntry[itrk] = true; } } From f7d89995021a65c50d518228c887eb581fb42630 Mon Sep 17 00:00:00 2001 From: Amelia Lindner Date: Tue, 12 Apr 2022 13:14:01 +0300 Subject: [PATCH 05/15] track cuts class debugging --- .../include/GlobalTracking/TrackCuts.h | 39 ++++++++++--------- 1 file changed, 21 insertions(+), 18 deletions(-) diff --git a/Detectors/GlobalTracking/include/GlobalTracking/TrackCuts.h b/Detectors/GlobalTracking/include/GlobalTracking/TrackCuts.h index e6e0b2e7594b4..d36b0d2a39edc 100644 --- a/Detectors/GlobalTracking/include/GlobalTracking/TrackCuts.h +++ b/Detectors/GlobalTracking/include/GlobalTracking/TrackCuts.h @@ -26,6 +26,7 @@ #include #include #include "Rtypes.h" +#include namespace o2 { using GID = o2::dataformats::GlobalTrackID; @@ -37,32 +38,34 @@ class TrackCuts { o2::track::TrackParCov trk; auto contributorsGID = data.getSingleDetectorRefs(trackIndex); - auto src = trackIndex.getSource(); //make selections depending on track source + auto src = trackIndex.getSource(); // make selections depending on track source if (src == GID::ITSTPCTRDTOF) { trk = data.getTrack(data.getITSTPCTRDTOFMatches()[trackIndex].getTrackRef()); // ITSTPCTRDTOF is ITSTPCTRD + TOF cluster } else if (src == GID::TPCTRDTOF) { trk = data.getTrack(data.getTPCTRDTOFMatches()[trackIndex].getTrackRef()); // TPCTRDTOF is TPCTRD + TOF cluster } else if (src == GID::ITSTPCTOF) { trk = data.getTrack(data.getTOFMatch(trackIndex).getTrackRef()); // ITSTPCTOF is ITSTPC + TOF cluster - } else if (src == GID::TPC) { //TPC tracks selection - const auto& tpcTrk = data.getTPCTrack(src); + } else if (src == GID::TPC) { // TPC tracks selection + const auto& tpcTrk = data.getTPCTrack(contributorsGID[GID::TPC]); uint8_t tpcNClsShared, tpcNClsFound, tpcNClsCrossed, tpcNClsFindable, tpcChi2NCl; tpcNClsFindable = tpcTrk.getNClusters(); tpcChi2NCl = tpcTrk.getNClusters() ? tpcTrk.getChi2() / tpcTrk.getNClusters() : 0; - TrackMethods::countTPCClusters(tpcTrk, data.getTPCTracksClusterRefs(), data.clusterShMapTPC, data.getTPCClusters(), tpcNClsShared, tpcNClsFound, tpcNClsCrossed); - double tpcCrossedRowsOverFindableCls = tpcNClsCrossed / tpcNClsFindable; - if (tpcTrk.getPt() >= mMinPt && tpcTrk.getPt() <= mMaxPt && - tpcTrk.getEta() >= mMinEta && tpcTrk.getEta() <= mMaxEta && - tpcNClsFound >= mMinNClustersTPC && - tpcNClsCrossed >= mMinNCrossedRowsTPC && - tpcCrossedRowsOverFindableCls >= mMinNCrossedRowsOverFindableClustersTPC && - tpcChi2NCl <= mMaxChi2PerClusterTPC) { - return true; - } else { - return false; - } - } else if (src == GID::ITS) { //ITS tracks selection - const auto& itsTrk = data.getITSTrack(contributorsGID[src]); + o2::TrackMethods::countTPCClusters(tpcTrk, data.getTPCTracksClusterRefs(), data.clusterShMapTPC, data.getTPCClusters(), tpcNClsShared, tpcNClsFound, tpcNClsCrossed); + // double tpcCrossedRowsOverFindableCls = tpcNClsCrossed / tpcNClsFindable; + // if (tpcTrk.getPt() >= mMinPt && tpcTrk.getPt() <= mMaxPt && + // tpcTrk.getEta() >= mMinEta && tpcTrk.getEta() <= mMaxEta && + // tpcNClsFound >= mMinNClustersTPC && + // tpcNClsCrossed >= mMinNCrossedRowsTPC && + // tpcCrossedRowsOverFindableCls >= mMinNCrossedRowsOverFindableClustersTPC && + // tpcChi2NCl <= mMaxChi2PerClusterTPC) { + // return true; + // } else { + // return false; + std::cout << "is selected method" << std::endl; + return true; + // } + } else if (src == GID::ITS) { // ITS tracks selection + const auto& itsTrk = data.getITSTrack(contributorsGID[GID::ITS]); int ITSnClusters = itsTrk.getNClusters(); float ITSchi2 = itsTrk.getChi2(); float itsChi2NCl = ITSnClusters != 0 ? ITSchi2 / (float)ITSnClusters : 0; @@ -262,7 +265,7 @@ class TrackCuts // kinematic cuts float mMinPt{5}, - mMaxPt{6}; // range in pT + mMaxPt{6}; // range in pT float mMinEta{-1e10f}, mMaxEta{1e10f}; // range in eta // track quality cuts From f25978f8e3333f65e633164634adeb4a40e220d0 Mon Sep 17 00:00:00 2001 From: Amelia Lindner Date: Fri, 15 Apr 2022 11:55:34 +0300 Subject: [PATCH 06/15] TPC track selection reproduced --- .../include/GlobalTracking/TrackCuts.h | 230 ++---------------- 1 file changed, 26 insertions(+), 204 deletions(-) diff --git a/Detectors/GlobalTracking/include/GlobalTracking/TrackCuts.h b/Detectors/GlobalTracking/include/GlobalTracking/TrackCuts.h index d36b0d2a39edc..b7efdddfa7ab3 100644 --- a/Detectors/GlobalTracking/include/GlobalTracking/TrackCuts.h +++ b/Detectors/GlobalTracking/include/GlobalTracking/TrackCuts.h @@ -23,6 +23,7 @@ #include "ReconstructionDataFormats/MatchInfoTOF.h" #include "DataFormatsTPC/TrackTPC.h" #include "GlobalTracking/TrackMethods.h" +#include "DetectorsBase/Propagator.h" #include #include #include "Rtypes.h" @@ -48,22 +49,21 @@ class TrackCuts } else if (src == GID::TPC) { // TPC tracks selection const auto& tpcTrk = data.getTPCTrack(contributorsGID[GID::TPC]); uint8_t tpcNClsShared, tpcNClsFound, tpcNClsCrossed, tpcNClsFindable, tpcChi2NCl; - tpcNClsFindable = tpcTrk.getNClusters(); - tpcChi2NCl = tpcTrk.getNClusters() ? tpcTrk.getChi2() / tpcTrk.getNClusters() : 0; - o2::TrackMethods::countTPCClusters(tpcTrk, data.getTPCTracksClusterRefs(), data.clusterShMapTPC, data.getTPCClusters(), tpcNClsShared, tpcNClsFound, tpcNClsCrossed); + // tpcNClsFindable = tpcTrk.getNClusters(); + // tpcChi2NCl = tpcTrk.getNClusters() ? tpcTrk.getChi2() / tpcTrk.getNClusters() : 0; + // o2::TrackMethods::countTPCClusters(tpcTrk, data.getTPCTracksClusterRefs(), data.clusterShMapTPC, data.getTPCClusters(), tpcNClsShared, tpcNClsFound, tpcNClsCrossed); // double tpcCrossedRowsOverFindableCls = tpcNClsCrossed / tpcNClsFindable; - // if (tpcTrk.getPt() >= mMinPt && tpcTrk.getPt() <= mMaxPt && - // tpcTrk.getEta() >= mMinEta && tpcTrk.getEta() <= mMaxEta && - // tpcNClsFound >= mMinNClustersTPC && - // tpcNClsCrossed >= mMinNCrossedRowsTPC && - // tpcCrossedRowsOverFindableCls >= mMinNCrossedRowsOverFindableClustersTPC && - // tpcChi2NCl <= mMaxChi2PerClusterTPC) { - // return true; - // } else { - // return false; - std::cout << "is selected method" << std::endl; - return true; - // } + math_utils::Point3D v{}; + std::array dca; + if (tpcTrk.getPt() < mPtTPCCut || + std::abs(tpcTrk.getEta()) > mEtaTPCCut || + tpcTrk.getNClusters() < mNTPCClustersCut || + (!(const_cast(tpcTrk).propagateParamToDCA(v, mBz, &dca, mDCACut)) || + std::abs(dca[0]) > mDCACutY)) { + return false; + } else { + return true; + } } else if (src == GID::ITS) { // ITS tracks selection const auto& itsTrk = data.getITSTrack(contributorsGID[GID::ITS]); int ITSnClusters = itsTrk.getNClusters(); @@ -90,199 +90,21 @@ class TrackCuts } } - //////////////////////////////// O2Physics //////////////////////////////// - - enum class TrackCutsList : int { - kTrackType = 0, - kPtRange, - kEtaRange, - kTPCNCls, - kTPCCrossedRows, - kTPCCrossedRowsOverNCls, - kTPCChi2NDF, - kTPCRefit, - kITSNCls, - kITSChi2NDF, - kITSRefit, - kITSHits, - kGoldenChi2, - kDCAxy, - kDCAz, - kNCuts - }; - - static const std::string mCutNames[static_cast(TrackCutsList::kNCuts)]; - // Temporary function to check if track passes selection criteria. To be replaced by framework filters. - template - bool IsSelected(T const& track) - { - const bool isRun2 = track.trackType() == o2::aod::track::Run2Track || track.trackType() == o2::aod::track::Run2Tracklet; - if (track.trackType() == mTrackType && - track.pt() >= mMinPt && track.pt() <= mMaxPt && - track.eta() >= mMinEta && track.eta() <= mMaxEta && - track.tpcNClsFound() >= mMinNClustersTPC && - track.tpcNClsCrossedRows() >= mMinNCrossedRowsTPC && - track.tpcCrossedRowsOverFindableCls() >= mMinNCrossedRowsOverFindableClustersTPC && - (track.itsNCls() >= mMinNClustersITS) && - (track.itsChi2NCl() <= mMaxChi2PerClusterITS) && - (track.tpcChi2NCl() <= mMaxChi2PerClusterTPC) && - (mRequireITSRefit ? (isRun2 ? (track.flags() & o2::aod::track::ITSrefit) : track.hasITS()) : true) && - (mRequireTPCRefit ? (isRun2 ? (track.flags() & o2::aod::track::TPCrefit) : track.hasTPC()) : true) && - ((isRun2 && mRequireGoldenChi2) ? (track.flags() & o2::aod::track::GoldenChi2) : true) && - TrackMethods::FulfillsITSHitRequirements(track.itsClusterMap(), mRequiredITSHits) && - abs(track.dcaXY()) <= ((mMaxDcaXYPtDep) ? mMaxDcaXYPtDep(track.pt()) : mMaxDcaXY) && - abs(track.dcaZ()) <= mMaxDcaZ) { - return true; - } else { - return false; - } - } - - // Temporary function to check if track passes a given selection criteria. To be replaced by framework filters. - template - bool IsSelected(T const& track, const TrackCutsList& cut) - { - const bool isRun2 = track.trackType() == o2::aod::track::Run2Track || track.trackType() == o2::aod::track::Run2Tracklet; - - switch (cut) { - case TrackCutsList::kTrackType: - return track.trackType() == mTrackType; - - case TrackCutsList::kPtRange: - return track.pt() >= mMinPt && track.pt() <= mMaxPt; - - case TrackCutsList::kEtaRange: - return track.eta() >= mMinEta && track.eta() <= mMaxEta; - - case TrackCutsList::kTPCNCls: - return track.tpcNClsFound() >= mMinNClustersTPC; - - case TrackCutsList::kTPCCrossedRows: - return track.tpcNClsCrossedRows() >= mMinNCrossedRowsTPC; - - case TrackCutsList::kTPCCrossedRowsOverNCls: - return track.tpcCrossedRowsOverFindableCls() >= mMinNCrossedRowsOverFindableClustersTPC; - - case TrackCutsList::kTPCChi2NDF: - return track.tpcChi2NCl() <= mMaxChi2PerClusterTPC; - - case TrackCutsList::kTPCRefit: - return (isRun2 && mRequireTPCRefit) ? (track.flags() & o2::aod::track::TPCrefit) : true; - - case TrackCutsList::kITSNCls: - return track.itsNCls() >= mMinNClustersITS; - - case TrackCutsList::kITSChi2NDF: - return track.itsChi2NCl() <= mMaxChi2PerClusterITS; - - case TrackCutsList::kITSRefit: - return (isRun2 && mRequireITSRefit) ? (track.flags() & o2::aod::track::ITSrefit) : true; - - case TrackCutsList::kITSHits: - return FulfillsITSHitRequirements(track.itsClusterMap()); - - case TrackCutsList::kGoldenChi2: - return (isRun2 && mRequireGoldenChi2) ? (track.flags() & o2::aod::track::GoldenChi2) : true; - - case TrackCutsList::kDCAxy: - return abs(track.dcaXY()) <= ((mMaxDcaXYPtDep) ? mMaxDcaXYPtDep(track.pt()) : mMaxDcaXY); - - case TrackCutsList::kDCAz: - return abs(track.dcaZ()) <= mMaxDcaZ; - - default: - return false; - } - } - - void SetTrackType(o2::aod::track::TrackTypeEnum trackType) { mTrackType = trackType; } - void SetPtRange(float minPt = 0.f, float maxPt = 1e10f) - { - mMinPt = minPt; - mMaxPt = maxPt; - } - void SetEtaRange(float minEta = -1e10f, float maxEta = 1e10f) - { - mMinEta = minEta; - mMaxEta = maxEta; - } - void SetRequireITSRefit(bool requireITSRefit = true) - { - mRequireITSRefit = requireITSRefit; - } - void SetRequireTPCRefit(bool requireTPCRefit = true) - { - mRequireTPCRefit = requireTPCRefit; - } - void SetRequireGoldenChi2(bool requireGoldenChi2 = true) - { - mRequireGoldenChi2 = requireGoldenChi2; - } - void SetMinNClustersTPC(int minNClustersTPC) - { - mMinNClustersTPC = minNClustersTPC; - } - void SetMinNCrossedRowsTPC(int minNCrossedRowsTPC) - { - mMinNCrossedRowsTPC = minNCrossedRowsTPC; - } - void SetMinNCrossedRowsOverFindableClustersTPC(float minNCrossedRowsOverFindableClustersTPC) - { - mMinNCrossedRowsOverFindableClustersTPC = minNCrossedRowsOverFindableClustersTPC; - } - void SetMinNClustersITS(int minNClustersITS) - { - mMinNClustersITS = minNClustersITS; - } - void SetMaxChi2PerClusterTPC(float maxChi2PerClusterTPC) - { - mMaxChi2PerClusterTPC = maxChi2PerClusterTPC; - } - void SetMaxChi2PerClusterITS(float maxChi2PerClusterITS) - { - mMaxChi2PerClusterITS = maxChi2PerClusterITS; - } - void SetMaxDcaXY(float maxDcaXY) { mMaxDcaXY = maxDcaXY; } - void SetMaxDcaZ(float maxDcaZ) { mMaxDcaZ = maxDcaZ; } - - void SetMaxDcaXYPtDep(std::function ptDepCut) - { - mMaxDcaXYPtDep = ptDepCut; - } - void SetRequireHitsInITSLayers(int8_t minNRequiredHits, std::set requiredLayers) - { - // layer 0 corresponds to the the innermost ITS layer - mRequiredITSHits.push_back(std::make_pair(minNRequiredHits, requiredLayers)); - } - void SetRequireNoHitsInITSLayers(std::set excludedLayers) - { - mRequiredITSHits.push_back(std::make_pair(-1, excludedLayers)); - } - void ResetITSRequirements() { mRequiredITSHits.clear(); } - private: - o2::aod::track::TrackTypeEnum mTrackType{o2::aod::track::TrackTypeEnum::Track}; - + // cut values + float mPtTPCCut = 0.1f; + float mEtaTPCCut = 1.4f; + int32_t mNTPCClustersCut = 60; + float mDCACut = 100.f; + float mDCACutY = 10.f; // kinematic cuts - float mMinPt{5}, - mMaxPt{6}; // range in pT + float mMinPt{0.f}, + mMaxPt{1e10f}; // range in pT float mMinEta{-1e10f}, mMaxEta{1e10f}; // range in eta + float mBz = o2::base::Propagator::Instance()->getNominalBz(); - // track quality cuts - int mMinNClustersTPC{0}; // min number of TPC clusters - int mMinNCrossedRowsTPC{0}; // min number of crossed rows in TPC - int mMinNClustersITS{0}; // min number of ITS clusters - float mMaxChi2PerClusterTPC{1e10f}; // max tpc fit chi2 per TPC cluster - float mMaxChi2PerClusterITS{1e10f}; // max its fit chi2 per ITS cluster - float mMinNCrossedRowsOverFindableClustersTPC{0.f}; // min ratio crossed rows / findable clusters - - float mMaxDcaXY{1e10f}; // max dca in xy plane - float mMaxDcaZ{1e10f}; // max dca in z direction - std::function mMaxDcaXYPtDep{}; // max dca in xy plane as function of pT - - bool mRequireITSRefit{false}; // require refit in ITS - bool mRequireTPCRefit{false}; // require refit in TPC - bool mRequireGoldenChi2{false}; // require golden chi2 cut (Run 2 only) + float mMaxChi2PerClusterITS{1e10f}; // max its fit chi2 per ITS cluster + int mMinNClustersITS{0}; // min number of ITS clusters // vector of ITS requirements (minNRequiredHits in specific requiredLayers) std::vector>> mRequiredITSHits{}; From 3991004c158e929ce7c5ac1e307dde3c56a4267e Mon Sep 17 00:00:00 2001 From: Amelia Lindner Date: Fri, 15 Apr 2022 12:35:59 +0300 Subject: [PATCH 07/15] clang format --- .../GlobalTracking/include/GlobalTracking/TrackCuts.h | 8 ++++---- .../GlobalTracking/include/GlobalTracking/TrackMethods.h | 5 +++-- Detectors/GlobalTracking/src/MatchITSTPCQC.cxx | 3 +-- 3 files changed, 8 insertions(+), 8 deletions(-) diff --git a/Detectors/GlobalTracking/include/GlobalTracking/TrackCuts.h b/Detectors/GlobalTracking/include/GlobalTracking/TrackCuts.h index b7efdddfa7ab3..d801f46ad8832 100644 --- a/Detectors/GlobalTracking/include/GlobalTracking/TrackCuts.h +++ b/Detectors/GlobalTracking/include/GlobalTracking/TrackCuts.h @@ -56,10 +56,10 @@ class TrackCuts math_utils::Point3D v{}; std::array dca; if (tpcTrk.getPt() < mPtTPCCut || - std::abs(tpcTrk.getEta()) > mEtaTPCCut || - tpcTrk.getNClusters() < mNTPCClustersCut || - (!(const_cast(tpcTrk).propagateParamToDCA(v, mBz, &dca, mDCACut)) || - std::abs(dca[0]) > mDCACutY)) { + std::abs(tpcTrk.getEta()) > mEtaTPCCut || + tpcTrk.getNClusters() < mNTPCClustersCut || + (!(const_cast(tpcTrk).propagateParamToDCA(v, mBz, &dca, mDCACut)) || + std::abs(dca[0]) > mDCACutY)) { return false; } else { return true; diff --git a/Detectors/GlobalTracking/include/GlobalTracking/TrackMethods.h b/Detectors/GlobalTracking/include/GlobalTracking/TrackMethods.h index b5c7280184b4d..2d67a9595008e 100644 --- a/Detectors/GlobalTracking/include/GlobalTracking/TrackMethods.h +++ b/Detectors/GlobalTracking/include/GlobalTracking/TrackMethods.h @@ -33,6 +33,9 @@ class TrackMethods const o2::tpc::ClusterNativeAccess& tpcClusAcc, uint8_t& shared, uint8_t& found, uint8_t& crossed) { + LOGP(info, "tpcClusRefs {}/{}", (void*)tpcClusRefs.data(), tpcClusRefs.size()); + LOGP(info, "tpcClusShMap {}/{}", (void*)tpcClusShMap.data(), tpcClusShMap.size()); + LOGP(info, " tpcClusAcc{}/{}", (void*)tpcClusAcc.clustersLinear, tpcClusAcc.nClustersTotal); constexpr int maxRows = 152; constexpr int neighbour = 2; std::array clMap{}, shMap{}; @@ -86,8 +89,6 @@ class TrackMethods return true; } - - ClassDefNV(TrackMethods, 1); }; } // namespace o2 diff --git a/Detectors/GlobalTracking/src/MatchITSTPCQC.cxx b/Detectors/GlobalTracking/src/MatchITSTPCQC.cxx index 236130665f522..7464760d7bd68 100644 --- a/Detectors/GlobalTracking/src/MatchITSTPCQC.cxx +++ b/Detectors/GlobalTracking/src/MatchITSTPCQC.cxx @@ -25,7 +25,6 @@ using namespace o2::globaltracking; using namespace o2::mcutils; using MCTrack = o2::MCTrackT; - MatchITSTPCQC::~MatchITSTPCQC() { @@ -181,7 +180,7 @@ void MatchITSTPCQC::run(o2::framework::ProcessingContext& ctx) // if (selectTrack(trkTpc)) { // isTPCTrackSelectedEntry[itrk] = true; // } - o2::dataformats::GlobalTrackID id(itrk,GID::TPC); + o2::dataformats::GlobalTrackID id(itrk, GID::TPC); if (cuts.isSelected(id, mRecoCont)) { isTPCTrackSelectedEntry[itrk] = true; } From 99a14a48568a3645d9e9c756cb34752e7b4ac47c Mon Sep 17 00:00:00 2001 From: Amelia Lindner Date: Fri, 15 Apr 2022 13:00:23 +0300 Subject: [PATCH 08/15] leave MatchITSTPCQC.cxx as it was for now --- Detectors/GlobalTracking/src/MatchITSTPCQC.cxx | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) diff --git a/Detectors/GlobalTracking/src/MatchITSTPCQC.cxx b/Detectors/GlobalTracking/src/MatchITSTPCQC.cxx index 7464760d7bd68..709e9204954c1 100644 --- a/Detectors/GlobalTracking/src/MatchITSTPCQC.cxx +++ b/Detectors/GlobalTracking/src/MatchITSTPCQC.cxx @@ -176,14 +176,14 @@ void MatchITSTPCQC::run(o2::framework::ProcessingContext& ctx) std::vector isTPCTrackSelectedEntry(mTPCTracks.size(), false); TrackCuts cuts; for (auto itrk = 0; itrk < mTPCTracks.size(); ++itrk) { - // auto const& trkTpc = mTPCTracks[itrk]; - // if (selectTrack(trkTpc)) { - // isTPCTrackSelectedEntry[itrk] = true; - // } - o2::dataformats::GlobalTrackID id(itrk, GID::TPC); - if (cuts.isSelected(id, mRecoCont)) { + auto const& trkTpc = mTPCTracks[itrk]; + if (selectTrack(trkTpc)) { isTPCTrackSelectedEntry[itrk] = true; } + // o2::dataformats::GlobalTrackID id(itrk, GID::TPC); + // if (cuts.isSelected(id, mRecoCont)) { + // isTPCTrackSelectedEntry[itrk] = true; + // } } // numerator + eta, chi2... From b9cca7740c8ff426e46f134536b509bed7c2f833 Mon Sep 17 00:00:00 2001 From: Amelia Lindner Date: Mon, 18 Apr 2022 14:51:20 +0300 Subject: [PATCH 09/15] requested changes --- Detectors/GlobalTracking/CMakeLists.txt | 120 +++++++++--------- .../include/GlobalTracking/TrackCuts.h | 55 ++++---- 2 files changed, 91 insertions(+), 84 deletions(-) diff --git a/Detectors/GlobalTracking/CMakeLists.txt b/Detectors/GlobalTracking/CMakeLists.txt index 25698399cdfb8..3579f302b4119 100644 --- a/Detectors/GlobalTracking/CMakeLists.txt +++ b/Detectors/GlobalTracking/CMakeLists.txt @@ -1,67 +1,67 @@ -#Copyright 2019 - 2020 CERN and copyright holders of ALICE O2. -#See https: // alice-o2.web.cern.ch/copyright for details of the copyright holders. -#All rights not expressly granted are reserved. +# Copyright 2019-2020 CERN and copyright holders of ALICE O2. +# See https://alice-o2.web.cern.ch/copyright for details of the copyright holders. +# All rights not expressly granted are reserved. # -#This software is distributed under the terms of the GNU General Public -#License v3(GPL Version 3), copied verbatim in the file "COPYING". +# This software is distributed under the terms of the GNU General Public +# License v3 (GPL Version 3), copied verbatim in the file "COPYING". # -#In applying this license CERN does not waive the privileges and immunities -#granted to it by virtue of its status as an Intergovernmental Organization +# In applying this license CERN does not waive the privileges and immunities +# granted to it by virtue of its status as an Intergovernmental Organization # or submit itself to any jurisdiction. o2_add_library(GlobalTracking - TARGETVARNAME targetName - SOURCES src / - MatchTPCITS.cxx - src / - MatchTOF.cxx - src / - MatchTPCITSParams.cxx - src / - MatchCosmics.cxx - src / - MatchCosmicsParams.cxx - src / - MatchGlobalFwd.cxx - src / - MatchGlobalFwdAssessment.cxx - src / - MatchITSTPCQC.cxx - src / - ITSTPCMatchingQCParams.cxx - src / - MatchGlobalFwdParam.cxx - PUBLIC_LINK_LIBRARIES O2::Framework - O2::DataFormatsTPC - O2::DataFormatsITSMFT - O2::DataFormatsITS - O2::DataFormatsFT0 - O2::DataFormatsTOF - O2::DataFormatsTRD - O2::ITSReconstruction - O2::FT0Reconstruction - O2::TPCFastTransformation - O2::GPUO2Interface - O2::TPCBase - O2::TPCReconstruction - O2::TOFBase - O2::TOFCalibration - O2::TOFWorkflowUtils - O2::SimConfig - O2::DataFormatsFT0 - O2::DataFormatsGlobalTracking - O2::ITStracking - O2::MFTTracking - O2::MCHTracking - O2::MathUtils - O2::ReconstructionDataFormats - O2::Steer) + TARGETVARNAME targetName + SOURCES src/MatchTPCITS.cxx + src/MatchTOF.cxx + src/MatchTPCITSParams.cxx + src/MatchCosmics.cxx + src/MatchCosmicsParams.cxx + src/MatchGlobalFwd.cxx + src/MatchGlobalFwdAssessment.cxx + src/MatchITSTPCQC.cxx + src/ITSTPCMatchingQCParams.cxx + src/MatchGlobalFwdParam.cxx + PUBLIC_LINK_LIBRARIES O2::Framework + O2::DataFormatsTPC + O2::DataFormatsITSMFT + O2::DataFormatsITS + O2::DataFormatsFT0 + O2::DataFormatsTOF + O2::DataFormatsTRD + O2::ITSReconstruction + O2::FT0Reconstruction + O2::TPCFastTransformation + O2::GPUO2Interface + O2::TPCBase + O2::TPCReconstruction + O2::TOFBase + O2::TOFCalibration + O2::TOFWorkflowUtils + O2::SimConfig + O2::DataFormatsFT0 + O2::DataFormatsGlobalTracking + O2::ITStracking + O2::MFTTracking + O2::MCHTracking + O2::MathUtils + O2::ReconstructionDataFormats + O2::Steer) - o2_target_root_dictionary(GlobalTracking - HEADERS include / - GlobalTracking / MatchTPCITSParams.h include / GlobalTracking / MatchGlobalFwd.h include / GlobalTracking / MatchGlobalFwdParam.h include / GlobalTracking / MatchGlobalFwdAssessment.h include / GlobalTracking / MatchTOF.h include / GlobalTracking / MatchCosmics.h include / GlobalTracking / MatchCosmicsParams.h include / GlobalTracking / MatchITSTPCQC.h include / GlobalTracking / ITSTPCMatchingQCParams.h include / GlobalTracking / TrackMethods.h include / GlobalTracking / TrackCuts.h) +o2_target_root_dictionary(GlobalTracking + HEADERS include/GlobalTracking/MatchTPCITSParams.h + include/GlobalTracking/MatchGlobalFwd.h + include/GlobalTracking/MatchGlobalFwdParam.h + include/GlobalTracking/MatchGlobalFwdAssessment.h + include/GlobalTracking/MatchTOF.h + include/GlobalTracking/MatchCosmics.h + include/GlobalTracking/MatchCosmicsParams.h + include/GlobalTracking/MatchITSTPCQC.h + include/GlobalTracking/ITSTPCMatchingQCParams.h + include/GlobalTracking/TrackMethods.h + include/GlobalTracking/TrackCuts.h) - if (OpenMP_CXX_FOUND) - target_compile_definitions(${targetName} PRIVATE WITH_OPENMP) - target_link_libraries(${targetName} PRIVATE OpenMP::OpenMP_CXX) - endif() + +if (OpenMP_CXX_FOUND) + target_compile_definitions(${targetName} PRIVATE WITH_OPENMP) + target_link_libraries(${targetName} PRIVATE OpenMP::OpenMP_CXX) +endif() \ No newline at end of file diff --git a/Detectors/GlobalTracking/include/GlobalTracking/TrackCuts.h b/Detectors/GlobalTracking/include/GlobalTracking/TrackCuts.h index d801f46ad8832..1b2a58d4e2875 100644 --- a/Detectors/GlobalTracking/include/GlobalTracking/TrackCuts.h +++ b/Detectors/GlobalTracking/include/GlobalTracking/TrackCuts.h @@ -22,8 +22,10 @@ #include "DataFormatsGlobalTracking/RecoContainer.h" #include "ReconstructionDataFormats/MatchInfoTOF.h" #include "DataFormatsTPC/TrackTPC.h" +#include "DataFormatsTRD/TrackTRD.h" #include "GlobalTracking/TrackMethods.h" #include "DetectorsBase/Propagator.h" +#include "ReconstructionDataFormats/VtxTrackIndex.h" #include #include #include "Rtypes.h" @@ -31,6 +33,7 @@ namespace o2 { using GID = o2::dataformats::GlobalTrackID; +using GIndex = o2::dataformats::VtxTrackIndex; class TrackCuts { public: @@ -39,14 +42,23 @@ class TrackCuts { o2::track::TrackParCov trk; auto contributorsGID = data.getSingleDetectorRefs(trackIndex); - auto src = trackIndex.getSource(); // make selections depending on track source - if (src == GID::ITSTPCTRDTOF) { - trk = data.getTrack(data.getITSTPCTRDTOFMatches()[trackIndex].getTrackRef()); // ITSTPCTRDTOF is ITSTPCTRD + TOF cluster - } else if (src == GID::TPCTRDTOF) { - trk = data.getTrack(data.getTPCTRDTOFMatches()[trackIndex].getTrackRef()); // TPCTRDTOF is TPCTRD + TOF cluster - } else if (src == GID::ITSTPCTOF) { - trk = data.getTrack(data.getTOFMatch(trackIndex).getTrackRef()); // ITSTPCTOF is ITSTPC + TOF cluster - } else if (src == GID::TPC) { // TPC tracks selection + auto src = trackIndex.getSource(); // make selections depending on track source + if (contributorsGID[GIndex::Source::ITS].isIndexSet()) { // ITS tracks selection + const auto& itsTrk = data.getITSTrack(contributorsGID[GID::ITS]); + int ITSnClusters = itsTrk.getNClusters(); + float ITSchi2 = itsTrk.getChi2(); + float itsChi2NCl = ITSnClusters != 0 ? ITSchi2 / (float)ITSnClusters : 0; + uint8_t itsClusterMap = itsTrk.getPattern(); + if (itsTrk.getPt() >= mMinPt && itsTrk.getPt() <= mMaxPt && + itsTrk.getEta() >= mMinEta && itsTrk.getEta() <= mMaxEta && + ITSnClusters >= mMinNClustersITS && + itsChi2NCl <= mMaxChi2PerClusterITS && + TrackMethods::FulfillsITSHitRequirements(itsClusterMap, mRequiredITSHits)) { + return true; + } else { + return false; + } + } else if (contributorsGID[GIndex::Source::TPC].isIndexSet()) { const auto& tpcTrk = data.getTPCTrack(contributorsGID[GID::TPC]); uint8_t tpcNClsShared, tpcNClsFound, tpcNClsCrossed, tpcNClsFindable, tpcChi2NCl; // tpcNClsFindable = tpcTrk.getNClusters(); @@ -64,22 +76,17 @@ class TrackCuts } else { return true; } - } else if (src == GID::ITS) { // ITS tracks selection - const auto& itsTrk = data.getITSTrack(contributorsGID[GID::ITS]); - int ITSnClusters = itsTrk.getNClusters(); - float ITSchi2 = itsTrk.getChi2(); - float itsChi2NCl = ITSnClusters != 0 ? ITSchi2 / (float)ITSnClusters : 0; - uint8_t itsClusterMap = itsTrk.getPattern(); - if (itsTrk.getPt() >= mMinPt && itsTrk.getPt() <= mMaxPt && - itsTrk.getEta() >= mMinEta && itsTrk.getEta() <= mMaxEta && - ITSnClusters >= mMinNClustersITS && - itsChi2NCl <= mMaxChi2PerClusterITS && - TrackMethods::FulfillsITSHitRequirements(itsClusterMap, mRequiredITSHits)) { - return true; - } else { - return false; - } - } else { // for the rest, get the track directly + } else if (contributorsGID[GIndex::Source::TRD].isIndexSet()) { + const auto& trdTrk = data.getTrack(contributorsGID[GID::TRD]); + } else if (contributorsGID[GIndex::Source::TOF].isIndexSet()) { + const auto& tofMatch = data.getTOFMatch(trackIndex); + } else if (contributorsGID[GIndex::Source::TPCTRDTOF].isIndexSet()) { + trk = data.getTrack(data.getTPCTRDTOFMatches()[trackIndex].getTrackRef()); + } else if (contributorsGID[GIndex::Source::ITSTPCTRDTOF].isIndexSet()) { + trk = data.getTrack(data.getITSTPCTRDTOFMatches()[trackIndex].getTrackRef()); // ITSTPCTRDTOF is ITSTPCTRD + TOF cluster + } else if (contributorsGID[GIndex::Source::ITSTPCTOF].isIndexSet()) { + trk = data.getTrack(data.getTOFMatch(trackIndex).getTrackRef()); // ITSTPCTOF is ITSTPC + TOF cluster + } else { // for the rest, get the track directly trk = data.getTrack(trackIndex); } if (trk.getPt() >= mMinPt && trk.getPt() <= mMaxPt && From 03fcbe1bbfdff16f9ce5f58a9dde198f74fc21f1 Mon Sep 17 00:00:00 2001 From: Amelia Lindner Date: Thu, 28 Apr 2022 14:14:20 +0300 Subject: [PATCH 10/15] fix ITS check, add flag for barrel tracks, remove pt and eta cuts for its tracks --- .../include/GlobalTracking/TrackCuts.h | 19 ++++++++++--------- 1 file changed, 10 insertions(+), 9 deletions(-) diff --git a/Detectors/GlobalTracking/include/GlobalTracking/TrackCuts.h b/Detectors/GlobalTracking/include/GlobalTracking/TrackCuts.h index 1b2a58d4e2875..3501d249bed5c 100644 --- a/Detectors/GlobalTracking/include/GlobalTracking/TrackCuts.h +++ b/Detectors/GlobalTracking/include/GlobalTracking/TrackCuts.h @@ -44,30 +44,30 @@ class TrackCuts auto contributorsGID = data.getSingleDetectorRefs(trackIndex); auto src = trackIndex.getSource(); // make selections depending on track source if (contributorsGID[GIndex::Source::ITS].isIndexSet()) { // ITS tracks selection + isBarrelTrack = true; const auto& itsTrk = data.getITSTrack(contributorsGID[GID::ITS]); int ITSnClusters = itsTrk.getNClusters(); float ITSchi2 = itsTrk.getChi2(); float itsChi2NCl = ITSnClusters != 0 ? ITSchi2 / (float)ITSnClusters : 0; uint8_t itsClusterMap = itsTrk.getPattern(); - if (itsTrk.getPt() >= mMinPt && itsTrk.getPt() <= mMaxPt && - itsTrk.getEta() >= mMinEta && itsTrk.getEta() <= mMaxEta && - ITSnClusters >= mMinNClustersITS && - itsChi2NCl <= mMaxChi2PerClusterITS && - TrackMethods::FulfillsITSHitRequirements(itsClusterMap, mRequiredITSHits)) { - return true; - } else { + if (isBarrelTrack == false || + ITSnClusters <= mMinNClustersITS || + itsChi2NCl >= mMaxChi2PerClusterITS || + TrackMethods::FulfillsITSHitRequirements(itsClusterMap, mRequiredITSHits) == false) { return false; } } else if (contributorsGID[GIndex::Source::TPC].isIndexSet()) { + isBarrelTrack = true; const auto& tpcTrk = data.getTPCTrack(contributorsGID[GID::TPC]); - uint8_t tpcNClsShared, tpcNClsFound, tpcNClsCrossed, tpcNClsFindable, tpcChi2NCl; + // uint8_t tpcNClsShared, tpcNClsFound, tpcNClsCrossed, tpcNClsFindable, tpcChi2NCl; // tpcNClsFindable = tpcTrk.getNClusters(); // tpcChi2NCl = tpcTrk.getNClusters() ? tpcTrk.getChi2() / tpcTrk.getNClusters() : 0; // o2::TrackMethods::countTPCClusters(tpcTrk, data.getTPCTracksClusterRefs(), data.clusterShMapTPC, data.getTPCClusters(), tpcNClsShared, tpcNClsFound, tpcNClsCrossed); // double tpcCrossedRowsOverFindableCls = tpcNClsCrossed / tpcNClsFindable; math_utils::Point3D v{}; std::array dca; - if (tpcTrk.getPt() < mPtTPCCut || + if (isBarrelTrack == false || + tpcTrk.getPt() < mPtTPCCut || std::abs(tpcTrk.getEta()) > mEtaTPCCut || tpcTrk.getNClusters() < mNTPCClustersCut || (!(const_cast(tpcTrk).propagateParamToDCA(v, mBz, &dca, mDCACut)) || @@ -98,6 +98,7 @@ class TrackCuts } private: + bool isBarrelTrack = false; // all barrel tracks must have either ITS or TPC contribution // cut values float mPtTPCCut = 0.1f; float mEtaTPCCut = 1.4f; From 8f49cbb13d09ad9f482069c9a8075f47da80299b Mon Sep 17 00:00:00 2001 From: Amelia Lindner Date: Thu, 28 Apr 2022 14:22:24 +0300 Subject: [PATCH 11/15] fix TPC check --- Detectors/GlobalTracking/include/GlobalTracking/TrackCuts.h | 2 -- 1 file changed, 2 deletions(-) diff --git a/Detectors/GlobalTracking/include/GlobalTracking/TrackCuts.h b/Detectors/GlobalTracking/include/GlobalTracking/TrackCuts.h index 3501d249bed5c..8b4802bafd225 100644 --- a/Detectors/GlobalTracking/include/GlobalTracking/TrackCuts.h +++ b/Detectors/GlobalTracking/include/GlobalTracking/TrackCuts.h @@ -73,8 +73,6 @@ class TrackCuts (!(const_cast(tpcTrk).propagateParamToDCA(v, mBz, &dca, mDCACut)) || std::abs(dca[0]) > mDCACutY)) { return false; - } else { - return true; } } else if (contributorsGID[GIndex::Source::TRD].isIndexSet()) { const auto& trdTrk = data.getTrack(contributorsGID[GID::TRD]); From 7b9ba9423d74641e7e2a404822895aeabe337986 Mon Sep 17 00:00:00 2001 From: Amelia Lindner Date: Thu, 28 Apr 2022 14:34:32 +0300 Subject: [PATCH 12/15] fix TPC check and add cuts for barrel tracks --- .../include/GlobalTracking/TrackCuts.h | 42 +++++++++---------- 1 file changed, 21 insertions(+), 21 deletions(-) diff --git a/Detectors/GlobalTracking/include/GlobalTracking/TrackCuts.h b/Detectors/GlobalTracking/include/GlobalTracking/TrackCuts.h index 8b4802bafd225..0aa6a97ced4b6 100644 --- a/Detectors/GlobalTracking/include/GlobalTracking/TrackCuts.h +++ b/Detectors/GlobalTracking/include/GlobalTracking/TrackCuts.h @@ -50,8 +50,7 @@ class TrackCuts float ITSchi2 = itsTrk.getChi2(); float itsChi2NCl = ITSnClusters != 0 ? ITSchi2 / (float)ITSnClusters : 0; uint8_t itsClusterMap = itsTrk.getPattern(); - if (isBarrelTrack == false || - ITSnClusters <= mMinNClustersITS || + if (ITSnClusters <= mMinNClustersITS || itsChi2NCl >= mMaxChi2PerClusterITS || TrackMethods::FulfillsITSHitRequirements(itsClusterMap, mRequiredITSHits) == false) { return false; @@ -66,32 +65,33 @@ class TrackCuts // double tpcCrossedRowsOverFindableCls = tpcNClsCrossed / tpcNClsFindable; math_utils::Point3D v{}; std::array dca; - if (isBarrelTrack == false || - tpcTrk.getPt() < mPtTPCCut || + if (tpcTrk.getPt() < mPtTPCCut || std::abs(tpcTrk.getEta()) > mEtaTPCCut || tpcTrk.getNClusters() < mNTPCClustersCut || (!(const_cast(tpcTrk).propagateParamToDCA(v, mBz, &dca, mDCACut)) || std::abs(dca[0]) > mDCACutY)) { return false; } - } else if (contributorsGID[GIndex::Source::TRD].isIndexSet()) { - const auto& trdTrk = data.getTrack(contributorsGID[GID::TRD]); - } else if (contributorsGID[GIndex::Source::TOF].isIndexSet()) { - const auto& tofMatch = data.getTOFMatch(trackIndex); - } else if (contributorsGID[GIndex::Source::TPCTRDTOF].isIndexSet()) { - trk = data.getTrack(data.getTPCTRDTOFMatches()[trackIndex].getTrackRef()); - } else if (contributorsGID[GIndex::Source::ITSTPCTRDTOF].isIndexSet()) { - trk = data.getTrack(data.getITSTPCTRDTOFMatches()[trackIndex].getTrackRef()); // ITSTPCTRDTOF is ITSTPCTRD + TOF cluster - } else if (contributorsGID[GIndex::Source::ITSTPCTOF].isIndexSet()) { - trk = data.getTrack(data.getTOFMatch(trackIndex).getTrackRef()); // ITSTPCTOF is ITSTPC + TOF cluster - } else { // for the rest, get the track directly - trk = data.getTrack(trackIndex); } - if (trk.getPt() >= mMinPt && trk.getPt() <= mMaxPt && - trk.getEta() >= mMinEta && trk.getEta() <= mMaxEta) { - return true; - } else { - return false; + // else if (contributorsGID[GIndex::Source::TRD].isIndexSet()) { + // const auto& trdTrk = data.getTrack(contributorsGID[GID::TRD]); + // } else if (contributorsGID[GIndex::Source::TOF].isIndexSet()) { + // const auto& tofMatch = data.getTOFMatch(trackIndex); + // } else if (contributorsGID[GIndex::Source::TPCTRDTOF].isIndexSet()) { + // trk = data.getTrack(data.getTPCTRDTOFMatches()[trackIndex].getTrackRef()); + // } else if (contributorsGID[GIndex::Source::ITSTPCTRDTOF].isIndexSet()) { + // trk = data.getTrack(data.getITSTPCTRDTOFMatches()[trackIndex].getTrackRef()); // ITSTPCTRDTOF is ITSTPCTRD + TOF cluster + // } else if (contributorsGID[GIndex::Source::ITSTPCTOF].isIndexSet()) { + // trk = data.getTrack(data.getTOFMatch(trackIndex).getTrackRef()); // ITSTPCTOF is ITSTPC + TOF cluster + // } + + if (isBarrelTrack) { + trk = data.getTrackParam(trackIndex); + if (trk.getPt() >= mMinPt && trk.getPt() <= mMaxPt && trk.getEta() >= mMinEta && trk.getEta() <= mMaxEta) { + return true; + } else { + return false; + } } } From fd136f6dd2c28fe1d482243ebc50b84ccf7d3aac Mon Sep 17 00:00:00 2001 From: Amelia Lindner Date: Wed, 4 May 2022 15:15:35 +0300 Subject: [PATCH 13/15] fix conditions --- .../include/GlobalTracking/TrackCuts.h | 26 ++++++++++++------- 1 file changed, 16 insertions(+), 10 deletions(-) diff --git a/Detectors/GlobalTracking/include/GlobalTracking/TrackCuts.h b/Detectors/GlobalTracking/include/GlobalTracking/TrackCuts.h index 0aa6a97ced4b6..d885974af3c53 100644 --- a/Detectors/GlobalTracking/include/GlobalTracking/TrackCuts.h +++ b/Detectors/GlobalTracking/include/GlobalTracking/TrackCuts.h @@ -42,7 +42,8 @@ class TrackCuts { o2::track::TrackParCov trk; auto contributorsGID = data.getSingleDetectorRefs(trackIndex); - auto src = trackIndex.getSource(); // make selections depending on track source + auto src = trackIndex.getSource(); // make selections depending on track source + // ITS tracks if (contributorsGID[GIndex::Source::ITS].isIndexSet()) { // ITS tracks selection isBarrelTrack = true; const auto& itsTrk = data.getITSTrack(contributorsGID[GID::ITS]); @@ -55,7 +56,9 @@ class TrackCuts TrackMethods::FulfillsITSHitRequirements(itsClusterMap, mRequiredITSHits) == false) { return false; } - } else if (contributorsGID[GIndex::Source::TPC].isIndexSet()) { + } + // TPC tracks + if (contributorsGID[GIndex::Source::TPC].isIndexSet()) { isBarrelTrack = true; const auto& tpcTrk = data.getTPCTrack(contributorsGID[GID::TPC]); // uint8_t tpcNClsShared, tpcNClsFound, tpcNClsCrossed, tpcNClsFindable, tpcChi2NCl; @@ -73,19 +76,22 @@ class TrackCuts return false; } } - // else if (contributorsGID[GIndex::Source::TRD].isIndexSet()) { + // if (contributorsGID[GIndex::Source::TRD].isIndexSet()) { // const auto& trdTrk = data.getTrack(contributorsGID[GID::TRD]); - // } else if (contributorsGID[GIndex::Source::TOF].isIndexSet()) { + // } + // if (contributorsGID[GIndex::Source::TOF].isIndexSet()) { // const auto& tofMatch = data.getTOFMatch(trackIndex); - // } else if (contributorsGID[GIndex::Source::TPCTRDTOF].isIndexSet()) { + // } + // if (contributorsGID[GIndex::Source::TPCTRDTOF].isIndexSet()) { // trk = data.getTrack(data.getTPCTRDTOFMatches()[trackIndex].getTrackRef()); - // } else if (contributorsGID[GIndex::Source::ITSTPCTRDTOF].isIndexSet()) { + // } + // if (contributorsGID[GIndex::Source::ITSTPCTRDTOF].isIndexSet()) { // trk = data.getTrack(data.getITSTPCTRDTOFMatches()[trackIndex].getTrackRef()); // ITSTPCTRDTOF is ITSTPCTRD + TOF cluster - // } else if (contributorsGID[GIndex::Source::ITSTPCTOF].isIndexSet()) { + // } + // if (contributorsGID[GIndex::Source::ITSTPCTOF].isIndexSet()) { // trk = data.getTrack(data.getTOFMatch(trackIndex).getTrackRef()); // ITSTPCTOF is ITSTPC + TOF cluster // } - - if (isBarrelTrack) { + if (isBarrelTrack) { // track selection for barrel tracks trk = data.getTrackParam(trackIndex); if (trk.getPt() >= mMinPt && trk.getPt() <= mMaxPt && trk.getEta() >= mMinEta && trk.getEta() <= mMaxEta) { return true; @@ -96,7 +102,7 @@ class TrackCuts } private: - bool isBarrelTrack = false; // all barrel tracks must have either ITS or TPC contribution + bool isBarrelTrack = false; // all barrel tracks must have either ITS or TPC contribution -> true if ITS || TPC track source condition is passed // cut values float mPtTPCCut = 0.1f; float mEtaTPCCut = 1.4f; From cfe0f241bd427d4a9b6e3ffd628ba3e608756b2c Mon Sep 17 00:00:00 2001 From: Amelia Lindner Date: Thu, 12 May 2022 10:50:45 +0300 Subject: [PATCH 14/15] fix return --- .../include/GlobalTracking/TrackCuts.h | 25 ++----------------- .../GlobalTracking/src/MatchITSTPCQC.cxx | 14 +++++------ 2 files changed, 9 insertions(+), 30 deletions(-) diff --git a/Detectors/GlobalTracking/include/GlobalTracking/TrackCuts.h b/Detectors/GlobalTracking/include/GlobalTracking/TrackCuts.h index d885974af3c53..52f9b58710a36 100644 --- a/Detectors/GlobalTracking/include/GlobalTracking/TrackCuts.h +++ b/Detectors/GlobalTracking/include/GlobalTracking/TrackCuts.h @@ -61,11 +61,6 @@ class TrackCuts if (contributorsGID[GIndex::Source::TPC].isIndexSet()) { isBarrelTrack = true; const auto& tpcTrk = data.getTPCTrack(contributorsGID[GID::TPC]); - // uint8_t tpcNClsShared, tpcNClsFound, tpcNClsCrossed, tpcNClsFindable, tpcChi2NCl; - // tpcNClsFindable = tpcTrk.getNClusters(); - // tpcChi2NCl = tpcTrk.getNClusters() ? tpcTrk.getChi2() / tpcTrk.getNClusters() : 0; - // o2::TrackMethods::countTPCClusters(tpcTrk, data.getTPCTracksClusterRefs(), data.clusterShMapTPC, data.getTPCClusters(), tpcNClsShared, tpcNClsFound, tpcNClsCrossed); - // double tpcCrossedRowsOverFindableCls = tpcNClsCrossed / tpcNClsFindable; math_utils::Point3D v{}; std::array dca; if (tpcTrk.getPt() < mPtTPCCut || @@ -76,29 +71,13 @@ class TrackCuts return false; } } - // if (contributorsGID[GIndex::Source::TRD].isIndexSet()) { - // const auto& trdTrk = data.getTrack(contributorsGID[GID::TRD]); - // } - // if (contributorsGID[GIndex::Source::TOF].isIndexSet()) { - // const auto& tofMatch = data.getTOFMatch(trackIndex); - // } - // if (contributorsGID[GIndex::Source::TPCTRDTOF].isIndexSet()) { - // trk = data.getTrack(data.getTPCTRDTOFMatches()[trackIndex].getTrackRef()); - // } - // if (contributorsGID[GIndex::Source::ITSTPCTRDTOF].isIndexSet()) { - // trk = data.getTrack(data.getITSTPCTRDTOFMatches()[trackIndex].getTrackRef()); // ITSTPCTRDTOF is ITSTPCTRD + TOF cluster - // } - // if (contributorsGID[GIndex::Source::ITSTPCTOF].isIndexSet()) { - // trk = data.getTrack(data.getTOFMatch(trackIndex).getTrackRef()); // ITSTPCTOF is ITSTPC + TOF cluster - // } if (isBarrelTrack) { // track selection for barrel tracks trk = data.getTrackParam(trackIndex); - if (trk.getPt() >= mMinPt && trk.getPt() <= mMaxPt && trk.getEta() >= mMinEta && trk.getEta() <= mMaxEta) { - return true; - } else { + if (trk.getPt() < mMinPt && trk.getPt() > mMaxPt && trk.getEta() < mMinEta && trk.getEta() > mMaxEta) { return false; } } + return true; } private: diff --git a/Detectors/GlobalTracking/src/MatchITSTPCQC.cxx b/Detectors/GlobalTracking/src/MatchITSTPCQC.cxx index 709e9204954c1..a9e34748a5a81 100644 --- a/Detectors/GlobalTracking/src/MatchITSTPCQC.cxx +++ b/Detectors/GlobalTracking/src/MatchITSTPCQC.cxx @@ -10,7 +10,6 @@ // or submit itself to any jurisdiction. #include "GlobalTracking/MatchITSTPCQC.h" -#include "GlobalTracking/TrackCuts.h" #include "ReconstructionDataFormats/TrackTPCITS.h" #include "DataFormatsTPC/TrackTPC.h" #include "Framework/InputSpec.h" @@ -20,6 +19,7 @@ #include "SimulationDataFormat/MCUtils.h" #include #include "TGraphAsymmErrors.h" +#include "GlobalTracking/TrackCuts.h" using namespace o2::globaltracking; using namespace o2::mcutils; @@ -177,13 +177,13 @@ void MatchITSTPCQC::run(o2::framework::ProcessingContext& ctx) TrackCuts cuts; for (auto itrk = 0; itrk < mTPCTracks.size(); ++itrk) { auto const& trkTpc = mTPCTracks[itrk]; - if (selectTrack(trkTpc)) { - isTPCTrackSelectedEntry[itrk] = true; - } - // o2::dataformats::GlobalTrackID id(itrk, GID::TPC); - // if (cuts.isSelected(id, mRecoCont)) { + // if (selectTrack(trkTpc)) { // isTPCTrackSelectedEntry[itrk] = true; // } + o2::dataformats::GlobalTrackID id(itrk, GID::TPC); + if (cuts.isSelected(id, mRecoCont)) { + isTPCTrackSelectedEntry[itrk] = true; + } } // numerator + eta, chi2... @@ -417,4 +417,4 @@ void MatchITSTPCQC::getHistos(TObjArray& objar) objar.Add(mChi2Matching); objar.Add(mChi2Refit); objar.Add(mTimeResVsPt); -} +} \ No newline at end of file From 058f32fa3909155d168ec5f9f3882a5c9543acea Mon Sep 17 00:00:00 2001 From: Amelia Lindner Date: Wed, 25 May 2022 11:07:25 +0300 Subject: [PATCH 15/15] a more complex description added for further development --- .../include/GlobalTracking/TrackCuts.h | 15 +++++++++++++++ 1 file changed, 15 insertions(+) diff --git a/Detectors/GlobalTracking/include/GlobalTracking/TrackCuts.h b/Detectors/GlobalTracking/include/GlobalTracking/TrackCuts.h index 52f9b58710a36..1c277b24ecdca 100644 --- a/Detectors/GlobalTracking/include/GlobalTracking/TrackCuts.h +++ b/Detectors/GlobalTracking/include/GlobalTracking/TrackCuts.h @@ -13,6 +13,21 @@ /// \brief Class to perform track cuts /// \author amelia.lindner@cern.ch +// This class is developed in order to be used for extensive track selections. The selections are done detector wise +//(or for detector combinations). +// sources: https://github.com/AliceO2Group/AliceO2/blob/e988b0c43346ccb24f3515d1a24f058313f14a0f/DataFormats/Reconstruction/include/ReconstructionDataFormats/GlobalTrackID.h#L40 +// +// !!! For further development: +// The main method is isSelected(o2::dataformats::GlobalTrackID, o2::globaltracking::RecoContainer&), which is a boolean +// that returns true only if all the checks are passed. First, based on the global track id, the track detector source is +// inquired(e.g. below for ITS and TPC tracks). The source-specific tracks is initialized in order to access the +// source-specific parameters than one wants to perform selections on. +// For each detector source, the inquiry should be done in such way that “false” should be returned if the checks are not passed, +// moving to the next detector source otherwise. +// (e.g below for TPC tracks, where the track selections used here: https://github.com/AliceO2Group/AliceO2/blob/dev/Detectors/GlobalTracking/src/MatchITSTPCQC.cxx#L318 +// are reproduced; +// Moreover, an example of how this class should be used can be found here: https://github.com/AliceO2Group/AliceO2/blob/dev/Detectors/GlobalTracking/src/MatchITSTPCQC.cxx#L184). + #ifndef ALICEO2_TRACKCUTS_H #define ALICEO2_TRACKCUTS_H