From fd00eb29f71ae9d94759a5bb2305cd63ff3f415a Mon Sep 17 00:00:00 2001 From: Andrew Hart Date: Mon, 30 Jan 2023 16:15:00 -0500 Subject: [PATCH 01/23] Added a new EXO regional tracking iteration. --- .../python/displacedRegionalTracking_cff.py | 5 + .../trackingMkFitDisplacedRegionalStep_cff.py | 4 + .../python/EDModules2monitor_cfi.py | 16 +- .../IterTrackingModules4seedMonitoring_cfi.py | 12 + DataFormats/TrackReco/interface/TrackBase.h | 2 +- DataFormats/TrackReco/src/TrackBase.cc | 2 +- .../DisplacedRegionalTracking/BuildFile.xml | 11 + .../interface/DisplacedVertexCluster.h | 66 +++ .../plugins/BuildFile.xml | 11 + .../DisplacedRegionSeedingVertexProducer.cc | 254 ++++++++++++ .../src/DisplacedVertexCluster.cc | 25 ++ .../displacedRegionalStepInputTracks_cfi.py | 17 + .../preDuplicateMergingGeneralTracks_cfi.py | 7 + .../src/trackAlgoPriorityOrder.h | 2 +- .../python/DisplacedRegionalStep_cff.py | 384 ++++++++++++++++++ .../python/dnnQualityCuts.py | 2 + .../python/iterativeTkConfig.py | 21 +- .../python/iterativeTk_cff.py | 5 + ...GlobalTrackingRegionWithVerticesProducer.h | 5 +- .../python/generalV0Candidates_cfi.py | 18 +- RecoVertex/V0Producer/src/V0Fitter.cc | 55 ++- RecoVertex/V0Producer/src/V0Fitter.h | 8 +- .../RecoTrack/python/TrackValidation_cff.py | 2 + Validation/RecoTrack/python/plotting/html.py | 1 + .../RecoTrack/python/plotting/ntupleEnum.py | 2 +- .../python/plotting/trackingPlots.py | 18 + .../test/trackingPerformanceValidation.py | 2 +- 27 files changed, 927 insertions(+), 30 deletions(-) create mode 100644 Configuration/ProcessModifiers/python/displacedRegionalTracking_cff.py create mode 100644 Configuration/ProcessModifiers/python/trackingMkFitDisplacedRegionalStep_cff.py create mode 100644 RecoTracker/DisplacedRegionalTracking/BuildFile.xml create mode 100644 RecoTracker/DisplacedRegionalTracking/interface/DisplacedVertexCluster.h create mode 100644 RecoTracker/DisplacedRegionalTracking/plugins/BuildFile.xml create mode 100644 RecoTracker/DisplacedRegionalTracking/plugins/DisplacedRegionSeedingVertexProducer.cc create mode 100644 RecoTracker/DisplacedRegionalTracking/src/DisplacedVertexCluster.cc create mode 100644 RecoTracker/FinalTrackSelectors/python/displacedRegionalStepInputTracks_cfi.py create mode 100644 RecoTracker/IterativeTracking/python/DisplacedRegionalStep_cff.py diff --git a/Configuration/ProcessModifiers/python/displacedRegionalTracking_cff.py b/Configuration/ProcessModifiers/python/displacedRegionalTracking_cff.py new file mode 100644 index 0000000000000..070c349a0aae9 --- /dev/null +++ b/Configuration/ProcessModifiers/python/displacedRegionalTracking_cff.py @@ -0,0 +1,5 @@ +import FWCore.ParameterSet.Config as cms + +# This modifier is for activating displacedRegionalStep step for phase1 tracking + +displacedRegionalTracking = cms.Modifier() diff --git a/Configuration/ProcessModifiers/python/trackingMkFitDisplacedRegionalStep_cff.py b/Configuration/ProcessModifiers/python/trackingMkFitDisplacedRegionalStep_cff.py new file mode 100644 index 0000000000000..ae5cccc872cf1 --- /dev/null +++ b/Configuration/ProcessModifiers/python/trackingMkFitDisplacedRegionalStep_cff.py @@ -0,0 +1,4 @@ +import FWCore.ParameterSet.Config as cms + +# This modifier sets replaces the default pattern recognition with mkFit for displacedRegionalStep +trackingMkFitDisplacedRegionalStep = cms.Modifier() diff --git a/DQM/TrackingMonitorSource/python/EDModules2monitor_cfi.py b/DQM/TrackingMonitorSource/python/EDModules2monitor_cfi.py index 532e686b1aa7f..d2fcf9cfa5683 100644 --- a/DQM/TrackingMonitorSource/python/EDModules2monitor_cfi.py +++ b/DQM/TrackingMonitorSource/python/EDModules2monitor_cfi.py @@ -16,23 +16,23 @@ # apparentely there are not LogError in RecoLocalTracker/SubCollectionProducers/src/TrackClusterRemover.cc pluginsMonName['Clusterizer'] = cms.string ( 'TrackClusterRemover' ) -modulesLabel ['Clusterizer'] = cms.vstring( 'lowPtTripletStepClusters', 'pixelPairStepClusters', 'detachedTripletStepClusters', 'mixedTripletStepClusters', 'pixelLessStepClusters', 'tobTecStepClusters', 'displacedGeneralStepClusters' ) # TrackClusterRemover +modulesLabel ['Clusterizer'] = cms.vstring( 'lowPtTripletStepClusters', 'pixelPairStepClusters', 'detachedTripletStepClusters', 'mixedTripletStepClusters', 'pixelLessStepClusters', 'tobTecStepClusters', 'displacedGeneralStepClusters', 'displacedRegionalStepClusters' ) # TrackClusterRemover categories ['Clusterizer'] = cms.vstring( ) # initialStepSeeds,lowPtTripletStepSeeds, pixelPairStepSeeds, detachedTripletStepSeeds, : TooManyClusters (SeedGeneratorFromRegionHitsEDProducer), # photonConvTrajSeedFromSingleLeg : (PhotonConversionTrajectorySeedProducerFromSingleLeg) pluginsMonName['Seeding'] = cms.string ( 'Seeding' ) -modulesLabel ['Seeding'] = cms.vstring( 'initialStepSeeds', 'lowPtTripletStepSeeds', 'pixelPairStepSeeds', 'detachedTripletStepSeeds', 'mixedTripletStepSeedsA', 'mixedTripletStepSeedsB', 'mixedTripletStepSeeds', 'pixelLessStepSeeds', 'tobTecStepSeeds', 'displacedGeneralStepSeeds','photonConvTrajSeedFromSingleLeg') +modulesLabel ['Seeding'] = cms.vstring( 'initialStepSeeds', 'lowPtTripletStepSeeds', 'pixelPairStepSeeds', 'detachedTripletStepSeeds', 'mixedTripletStepSeedsA', 'mixedTripletStepSeedsB', 'mixedTripletStepSeeds', 'pixelLessStepSeeds', 'tobTecStepSeeds', 'displacedGeneralStepSeeds', 'displacedRegionalStepSeeds' ,'photonConvTrajSeedFromSingleLeg') categories ['Seeding'] = cms.vstring( 'TooManyClusters', 'TooManyPairs', 'TooManyTriplets', 'TooManySeeds' ) # RecoTracker/CkfPattern/src/CkfTrackCandidateMakerBase.cc pluginsMonName['TrackCandidate'] = cms.string ( 'TrackCandidate' ) -modulesLabel ['TrackCandidate'] = cms.vstring( 'initialStepTrackCandidates', 'lowPtTripletStepTrackCandidates', 'pixelPairStepTrackCandidates', 'detachedTripletStepTrackCandidates', 'mixedTripletStepTrackCandidates', 'pixelLessStepTrackCandidates', 'tobTecStepTrackCandidates', 'displacedGeneralStepTrackCandidates', 'convTrackCandidates' ) +modulesLabel ['TrackCandidate'] = cms.vstring( 'initialStepTrackCandidates', 'lowPtTripletStepTrackCandidates', 'pixelPairStepTrackCandidates', 'detachedTripletStepTrackCandidates', 'mixedTripletStepTrackCandidates', 'pixelLessStepTrackCandidates', 'tobTecStepTrackCandidates', 'displacedGeneralStepTrackCandidates', 'displacedRegionalStepTrackCandidates', 'convTrackCandidates' ) categories ['TrackCandidate'] = cms.vstring( 'TooManySeeds', 'CkfPattern', 'BaseCkfTrajectoryBuilder_InfiniteLoop' ) # TrackProducer:FailedPropagation pluginsMonName['TrackFinder'] = cms.string ( 'TrackFinder' ) -modulesLabel ['TrackFinder'] = cms.vstring( 'pixelTracks', 'initialStepTracks', 'lowPtTripletStepTracks', 'pixelPairStepTracks', 'detachedTripletStepTracks', 'mixedTripletStepTracks', 'pixelLessStepTracks', 'tobTecStepTracks', 'displacedGeneralStepTracks', 'generalTracks' ) +modulesLabel ['TrackFinder'] = cms.vstring( 'pixelTracks', 'initialStepTracks', 'lowPtTripletStepTracks', 'pixelPairStepTracks', 'detachedTripletStepTracks', 'mixedTripletStepTracks', 'pixelLessStepTracks', 'tobTecStepTracks', 'displacedGeneralStepTracks', 'displacedRegionalStepTracks', 'generalTracks' ) categories ['TrackFinder'] = cms.vstring( 'FailedPropagation' ) @@ -63,6 +63,9 @@ 'displacedGeneralStepSeeds_iter7', 'displacedGeneralStepTrackCandidates_iter7', 'displacedGeneralStepTracks_iter7', + 'displacedRegionalStepSeeds_iter8', + 'displacedRegionalStepTrackCandidates_iter8', + 'displacedRegionalStepTracks_iter8', 'photonConvTrajSeedFromSingleLeg', 'convTrackCandidates', 'convStepTracks', @@ -101,7 +104,10 @@ 'tobTecStepTracks_iter6', 'displacedGeneralStepSeeds_iter7', 'displacedGeneralStepTrackCandidates_iter7', - 'displacedGeneralStepTracks_iter7' + 'displacedGeneralStepTracks_iter7', + 'displacedRegionalStepSeeds_iter8', + 'displacedRegionalStepTrackCandidates_iter8', + 'displacedRegionalStepTracks_iter8' ) categories['IterTracking'] = cms.vstring( 'TooManyClusters', diff --git a/DQM/TrackingMonitorSource/python/IterTrackingModules4seedMonitoring_cfi.py b/DQM/TrackingMonitorSource/python/IterTrackingModules4seedMonitoring_cfi.py index d190825a528e6..83a5e94955183 100644 --- a/DQM/TrackingMonitorSource/python/IterTrackingModules4seedMonitoring_cfi.py +++ b/DQM/TrackingMonitorSource/python/IterTrackingModules4seedMonitoring_cfi.py @@ -160,6 +160,18 @@ clusterMax = cms.double(100000), ) +seedMonitoring['displacedRegionalStep'] = cms.PSet( + seedInputTag = cms.InputTag("displacedRegionalStepSeeds"), + trackCandInputTag= cms.InputTag("displacedRegionalStepTrackCandidates"), + trackSeedSizeBin = cms.int32(400), + trackSeedSizeMin = cms.double(0), + trackSeedSizeMax = cms.double(100000), + TCSizeMax = cms.double(199.5), + clusterLabel = cms.vstring('Strip'), + clusterBin = cms.int32(100), + clusterMax = cms.double(100000), +) + seedMonitoring['muonSeededStepOutInDisplaced'] = cms.PSet( seedInputTag = cms.InputTag("muonSeededSeedsOutInDisplaced"), trackCandInputTag = cms.InputTag("muonSeededTrackCandidatesOutInDisplacedg"), diff --git a/DataFormats/TrackReco/interface/TrackBase.h b/DataFormats/TrackReco/interface/TrackBase.h index ae2b52ec6de64..03a548cf410f7 100644 --- a/DataFormats/TrackReco/interface/TrackBase.h +++ b/DataFormats/TrackReco/interface/TrackBase.h @@ -114,7 +114,7 @@ namespace reco { lowPtQuadStep = 23, detachedQuadStep = 24, displacedGeneralStep = 25, - reservedForUpgrades2 = 26, + displacedRegionalStep = 26, bTagGhostTracks = 27, beamhalo = 28, gsf = 29, diff --git a/DataFormats/TrackReco/src/TrackBase.cc b/DataFormats/TrackReco/src/TrackBase.cc index e2145dd54182c..0d902cd8fbcda 100644 --- a/DataFormats/TrackReco/src/TrackBase.cc +++ b/DataFormats/TrackReco/src/TrackBase.cc @@ -32,7 +32,7 @@ std::string const TrackBase::algoNames[] = {"undefAlgorithm", "lowPtQuadStep", "detachedQuadStep", "displacedGeneralStep", - "reservedForUpgrades2", + "displacedRegionalStep", "bTagGhostTracks", "beamhalo", "gsf", diff --git a/RecoTracker/DisplacedRegionalTracking/BuildFile.xml b/RecoTracker/DisplacedRegionalTracking/BuildFile.xml new file mode 100644 index 0000000000000..332974b5ad00a --- /dev/null +++ b/RecoTracker/DisplacedRegionalTracking/BuildFile.xml @@ -0,0 +1,11 @@ + + + + + + + + + + + diff --git a/RecoTracker/DisplacedRegionalTracking/interface/DisplacedVertexCluster.h b/RecoTracker/DisplacedRegionalTracking/interface/DisplacedVertexCluster.h new file mode 100644 index 0000000000000..14f4dd52c7ab3 --- /dev/null +++ b/RecoTracker/DisplacedRegionalTracking/interface/DisplacedVertexCluster.h @@ -0,0 +1,66 @@ +#ifndef RecoTracker_DisplacedRegionalTracking_DisplacedVertexCluster_h +#define RecoTracker_DisplacedRegionalTracking_DisplacedVertexCluster_h + +#include +#include +#include +#include + +#include "DataFormats/Common/interface/View.h" +#include "DataFormats/Candidate/interface/VertexCompositeCandidate.h" +#include "DataFormats/Math/interface/Vector3D.h" + +class DisplacedVertexCluster; +typedef std::list::iterator DisplacedVertexClusterItr; + +class DisplacedVertexCluster { +public: + static constexpr double kInvalidDouble = std::numeric_limits::quiet_NaN(); + + DisplacedVertexCluster() + : valid_(false), rParam2_(kInvalidDouble), sumOfCenters_(0.0, 0.0, 0.0), centerOfMass_(0.0, 0.0, 0.0) {} + + DisplacedVertexCluster(const edm::View &, const unsigned, const double); + + ~DisplacedVertexCluster() { constituents_.clear(); } + + bool valid() const { return valid_; } + double rParam2() const { return rParam2_; } + double rParam() const { return sqrt(rParam2()); } + const std::vector &constituents() const { return constituents_; } + const reco::VertexCompositeCandidate *constituent(const unsigned i) const { return constituents_.at(i); } + unsigned nConstituents() const { return constituents_.size(); } + const math::XYZVector &sumOfCenters() const { return sumOfCenters_; } + const math::XYZVector ¢erOfMass() const { return centerOfMass_; } + + double vx() const { return centerOfMass().x(); } + double vy() const { return centerOfMass().y(); } + double vz() const { return centerOfMass().z(); } + + void merge(const DisplacedVertexCluster &other); + void setInvalid() { valid_ = false; } + + // struct representing the distance between two DisplacedVertexCluster objects + struct Distance { + public: + Distance(DisplacedVertexClusterItr entity0, DisplacedVertexClusterItr entity1) : entities_(entity0, entity1) {} + double distance2() const; + double distance() const { return sqrt(distance2()); } + std::pair &entities() { return entities_; } + const std::pair &entities() const { return entities_; } + + private: + std::pair entities_; + }; + + typedef std::list::iterator DistanceItr; + +private: + bool valid_; + double rParam2_; + std::vector constituents_; + math::XYZVector sumOfCenters_; + math::XYZVector centerOfMass_; +}; + +#endif diff --git a/RecoTracker/DisplacedRegionalTracking/plugins/BuildFile.xml b/RecoTracker/DisplacedRegionalTracking/plugins/BuildFile.xml new file mode 100644 index 0000000000000..7a40b9636ce99 --- /dev/null +++ b/RecoTracker/DisplacedRegionalTracking/plugins/BuildFile.xml @@ -0,0 +1,11 @@ + + + + + + + + + + + diff --git a/RecoTracker/DisplacedRegionalTracking/plugins/DisplacedRegionSeedingVertexProducer.cc b/RecoTracker/DisplacedRegionalTracking/plugins/DisplacedRegionSeedingVertexProducer.cc new file mode 100644 index 0000000000000..0dd5666595591 --- /dev/null +++ b/RecoTracker/DisplacedRegionalTracking/plugins/DisplacedRegionSeedingVertexProducer.cc @@ -0,0 +1,254 @@ +#include +#include +#include +#include +#include + +#include "FWCore/Framework/interface/Event.h" +#include "FWCore/Framework/interface/EventSetup.h" +#include "FWCore/Framework/interface/MakerMacros.h" +#include "FWCore/Framework/interface/global/EDProducer.h" +#include "FWCore/ParameterSet/interface/FileInPath.h" +#include "FWCore/Utilities/interface/InputTag.h" +#include "FWCore/ParameterSet/interface/ParameterSet.h" +#include "FWCore/Utilities/interface/EDGetToken.h" +#include "FWCore/Utilities/interface/Exception.h" +#include "FWCore/Utilities/interface/InputTag.h" + +#include "DataFormats/BeamSpot/interface/BeamSpot.h" +#include "DataFormats/Candidate/interface/VertexCompositeCandidate.h" +#include "DataFormats/Common/interface/Handle.h" +#include "DataFormats/Common/interface/View.h" +#include "DataFormats/Math/interface/Vector3D.h" +#include "DataFormats/VertexReco/interface/Vertex.h" + +#include "PhysicsTools/TensorFlow/interface/TensorFlow.h" + +#include "RecoTracker/DisplacedRegionalTracking/interface/DisplacedVertexCluster.h" + +using namespace std; +typedef DisplacedVertexCluster::Distance Distance; +typedef DisplacedVertexCluster::DistanceItr DistanceItr; + +class DisplacedRegionSeedingVertexProducer : public edm::global::EDProducer<> { +public: + DisplacedRegionSeedingVertexProducer(const edm::ParameterSet &); + ~DisplacedRegionSeedingVertexProducer() override; + void produce(edm::StreamID, edm::Event &, const edm::EventSetup &) const override; + static void fillDescriptions(edm::ConfigurationDescriptions &); + +private: + // clustering parameters + double rParam_; + + // selection parameters + double minRadius_; + double discriminatorCut_; + vector input_names_; + vector output_names_; + + edm::EDGetTokenT beamSpotToken_; + edm::EDGetTokenT > trackClustersToken_; + + tensorflow::Session *session_; + + double getDiscriminatorValue(const DisplacedVertexCluster &, const reco::BeamSpot &) const; +}; + +DisplacedRegionSeedingVertexProducer::DisplacedRegionSeedingVertexProducer(const edm::ParameterSet &cfg) + : rParam_(cfg.getParameter("rParam")), + minRadius_(cfg.getParameter("minRadius")), + discriminatorCut_(cfg.getParameter("discriminatorCut")), + input_names_(cfg.getParameter >("input_names")), + output_names_(cfg.getParameter >("output_names")), + beamSpotToken_(consumes(cfg.getParameter("beamSpot"))), + trackClustersToken_( + consumes >(cfg.getParameter("trackClusters"))) { + unsigned nThreads = cfg.getParameter("nThreads"); + string singleThreadPool = cfg.getParameter("singleThreadPool"); + tensorflow::SessionOptions sessionOptions; + tensorflow::setThreading(sessionOptions, nThreads, singleThreadPool); + string pbFile = cfg.getParameter("graph_path").fullPath(); + auto graphDef = tensorflow::loadGraphDef(pbFile); + session_ = tensorflow::createSession(graphDef, sessionOptions); + + produces >(); +} + +DisplacedRegionSeedingVertexProducer::~DisplacedRegionSeedingVertexProducer() { + if (session_ != nullptr) + tensorflow::closeSession(session_); +} + +void DisplacedRegionSeedingVertexProducer::produce(edm::StreamID streamID, + edm::Event &event, + const edm::EventSetup &setup) const { + const auto &beamSpot = event.get(beamSpotToken_); + const math::XYZVector bs(beamSpot.position()); + + const auto &trackClusters = event.get(trackClustersToken_); + + // Initialize distances. + list pseudoROIs; + list distances; + const double minTrackClusterRadius = minRadius_ - rParam_; + for (unsigned i = 0; i < trackClusters.size(); i++) { + const reco::VertexCompositeCandidate &trackCluster = trackClusters[i]; + const math::XYZVector x(trackCluster.vertex()); + if (minRadius_ < 0.0 || minTrackClusterRadius < 0.0 || (x - bs).rho() > minTrackClusterRadius) + pseudoROIs.emplace_back(trackClusters, i, rParam_); + } + if (pseudoROIs.size() > 1) { + DisplacedVertexClusterItr secondToLast = pseudoROIs.end(); + secondToLast--; + for (DisplacedVertexClusterItr i = pseudoROIs.begin(); i != secondToLast; i++) { + DisplacedVertexClusterItr j = i; + j++; + for (; j != pseudoROIs.end(); j++) { + distances.emplace_back(i, j); + + // Track clusters farther apart than 4 times rParam_ (i.e., 16 times + // rParam_^2) cannot wind up in the same ROI, so remove these pairs. + if (distances.back().distance2() > 16.0 * rParam_ * rParam_) + distances.pop_back(); + } + } + } + + // Do clustering. + while (!distances.empty()) { + const auto comp = [](const Distance &a, const Distance &b) { return a.distance2() <= b.distance2(); }; + distances.sort(comp); + DistanceItr dBest = distances.begin(); + if (dBest->distance2() > rParam_ * rParam_) + break; + + dBest->entities().first->merge(*dBest->entities().second); + dBest->entities().second->setInvalid(); + + const auto distancePred = [](const Distance &a) { + return (!a.entities().first->valid() || !a.entities().second->valid()); + }; + const auto pseudoROIPred = [](const DisplacedVertexCluster &a) { return !a.valid(); }; + distances.remove_if(distancePred); + pseudoROIs.remove_if(pseudoROIPred); + } + + // Remove invalid ROIs. + const auto roiPred = [&](const DisplacedVertexCluster &roi) { + if (!roi.valid()) + return true; + const math::XYZVector &x(roi.centerOfMass()); + if ((x - bs).rho() < minRadius_) + return true; + const double discriminatorValue = ((discriminatorCut_ > 0.0) ? getDiscriminatorValue(roi, beamSpot) : 1.0); + if (discriminatorValue < discriminatorCut_) + return true; + return false; + }; + pseudoROIs.remove_if(roiPred); + + auto regionsOfInterest = make_unique >(); + + constexpr std::array errorA{{1.0, 0.0, 1.0, 0.0, 0.0, 1.0}}; + static const reco::Vertex::Error errorRegion(errorA.begin(), errorA.end(), true, true); + + for (const auto &roi : pseudoROIs) + regionsOfInterest->emplace_back(reco::Vertex::Point(roi.centerOfMass()), errorRegion); + + event.put(move(regionsOfInterest)); +} + +void DisplacedRegionSeedingVertexProducer::fillDescriptions(edm::ConfigurationDescriptions &descriptions) { + edm::ParameterSetDescription desc; + + desc.add("rParam", 1.0); + desc.add("minRadius", -1.0); + desc.add("discriminatorCut", -1.0); + desc.add >("input_names", {"phi_0", "phi_1"}); + desc.add >("output_names", {"model_5/activation_10/Softmax"}); + desc.add("nThreads", 1); + desc.add("singleThreadPool", "no_threads"); + desc.add( + "graph_path", + edm::FileInPath( + "RecoTracker/DisplacedRegionalTracking/data/FullData_Phi-64-128-256_16-32-64_F-128-64-32_Model.pb")); + desc.add("beamSpot", edm::InputTag("offlineBeamSpot")); + desc.add("trackClusters", edm::InputTag("generalV0Candidates", "Kshort")); + + descriptions.add("displacedRegionProducer", desc); +} + +double DisplacedRegionSeedingVertexProducer::getDiscriminatorValue(const DisplacedVertexCluster &roi, + const reco::BeamSpot &bs) const { + // The network takes in two maps of data features, one with information + // related to the pairwise track vertices and one with information related to + // the tracks in an isolation annulus. + + constexpr int maxNVertices = 40; // maximum number of pairwise track vertices per ROI + constexpr int nVertexFeatures = 23; // number of features per pairwise track vertex + constexpr int nDimVertices = 3; // number of tensor dimensions for the map of pairwise track vertices + + constexpr int maxNAnnulusTracks = 10; // maximum number of annulus tracks per ROI + constexpr int nAnnulusTrackFeatures = 8; // number of features per annulus track + constexpr int nDimAnnulusTracks = 3; // number of tensor dimensions for the map of annulus tracks + + tensorflow::Tensor vertexTensor(tensorflow::DT_FLOAT, tensorflow::TensorShape({1, maxNVertices, nVertexFeatures})); + auto vertex_map = vertexTensor.tensor(); + tensorflow::Tensor annulusTensor(tensorflow::DT_FLOAT, + tensorflow::TensorShape({1, maxNAnnulusTracks, nAnnulusTrackFeatures})); + auto annulus_map = annulusTensor.tensor(); + + for (int i = 0, map_i = 0; map_i < maxNVertices; i++, map_i++) { + if (i >= static_cast(roi.nConstituents())) + for (unsigned j = 0; j < nVertexFeatures; j++) + vertex_map(0, map_i, j) = 0.0; + else { + const auto &trackCluster = *roi.constituent(i); + const auto &track0 = *trackCluster.daughter(0)->bestTrack(); + const auto &track1 = *trackCluster.daughter(1)->bestTrack(); + + vertex_map(0, map_i, 0) = trackCluster.vx() - bs.x0(); + vertex_map(0, map_i, 1) = trackCluster.vy() - bs.y0(); + vertex_map(0, map_i, 2) = trackCluster.vz() - bs.z0(); + + vertex_map(0, map_i, 3) = trackCluster.vertexCovariance()(0, 0); + vertex_map(0, map_i, 4) = trackCluster.vertexCovariance()(0, 1); + vertex_map(0, map_i, 5) = trackCluster.vertexCovariance()(0, 2); + vertex_map(0, map_i, 6) = trackCluster.vertexCovariance()(1, 1); + vertex_map(0, map_i, 7) = trackCluster.vertexCovariance()(1, 2); + vertex_map(0, map_i, 8) = trackCluster.vertexCovariance()(2, 2); + + vertex_map(0, map_i, 9) = track0.charge() * track0.pt(); + vertex_map(0, map_i, 10) = track0.eta(); + vertex_map(0, map_i, 11) = track0.phi(); + vertex_map(0, map_i, 12) = track0.dxy(bs); + vertex_map(0, map_i, 13) = track0.dz(bs.position()); + vertex_map(0, map_i, 14) = track0.normalizedChi2(); + vertex_map(0, map_i, 15) = track0.quality(reco::Track::highPurity) ? 1 : 0; + + vertex_map(0, map_i, 16) = track1.charge() * track1.pt(); + vertex_map(0, map_i, 17) = track1.eta(); + vertex_map(0, map_i, 18) = track1.phi(); + vertex_map(0, map_i, 19) = track1.dxy(bs); + vertex_map(0, map_i, 20) = track1.dz(bs.position()); + vertex_map(0, map_i, 21) = track1.normalizedChi2(); + vertex_map(0, map_i, 22) = track1.quality(reco::Track::highPurity) ? 1 : 0; + } + } + + for (int i = 0; i < maxNAnnulusTracks; i++) + for (unsigned j = 0; j < nAnnulusTrackFeatures; j++) + annulus_map(0, i, j) = 0.0; + + tensorflow::NamedTensorList input_tensors; + input_tensors.resize(2); + input_tensors[0] = tensorflow::NamedTensor(input_names_.at(0), vertexTensor); + input_tensors[1] = tensorflow::NamedTensor(input_names_.at(1), annulusTensor); + vector outputs; + tensorflow::run(session_, input_tensors, output_names_, &outputs); + + return (outputs.at(0).flat()(1)); +} + +DEFINE_FWK_MODULE(DisplacedRegionSeedingVertexProducer); diff --git a/RecoTracker/DisplacedRegionalTracking/src/DisplacedVertexCluster.cc b/RecoTracker/DisplacedRegionalTracking/src/DisplacedVertexCluster.cc new file mode 100644 index 0000000000000..c30720401946e --- /dev/null +++ b/RecoTracker/DisplacedRegionalTracking/src/DisplacedVertexCluster.cc @@ -0,0 +1,25 @@ +#include "RecoTracker/DisplacedRegionalTracking/interface/DisplacedVertexCluster.h" + +DisplacedVertexCluster::DisplacedVertexCluster(const edm::View &trackClusters, + const unsigned index, + const double rParam) + : valid_(true), + rParam2_(rParam * rParam), + sumOfCenters_(trackClusters.at(index).vertex()), + centerOfMass_(trackClusters.at(index).vertex()) { + const auto trackClusterPtr = &trackClusters.at(index); + constituents_.push_back(trackClusterPtr); +} + +void DisplacedVertexCluster::merge(const DisplacedVertexCluster &other) { + for (const auto &trackCluster : other.constituents()) + constituents_.push_back(trackCluster); + sumOfCenters_ += other.sumOfCenters(); + centerOfMass_ = sumOfCenters_ * (1.0 / constituents_.size()); +} + +double DisplacedVertexCluster::Distance::distance2() const { + if (entities_.first->valid() && entities_.second->valid()) + return (entities_.first->centerOfMass() - entities_.second->centerOfMass()).mag2(); + return std::numeric_limits::max(); +} diff --git a/RecoTracker/FinalTrackSelectors/python/displacedRegionalStepInputTracks_cfi.py b/RecoTracker/FinalTrackSelectors/python/displacedRegionalStepInputTracks_cfi.py new file mode 100644 index 0000000000000..cb0d1dc22b5e0 --- /dev/null +++ b/RecoTracker/FinalTrackSelectors/python/displacedRegionalStepInputTracks_cfi.py @@ -0,0 +1,17 @@ +import FWCore.ParameterSet.Config as cms +from RecoTracker.FinalTrackSelectors.TrackCollectionMerger_cfi import * +from RecoTracker.FinalTrackSelectors.trackAlgoPriorityOrder_cfi import trackAlgoPriorityOrder + +import RecoTracker.FinalTrackSelectors.trackListMerger_cfi +displacedRegionalStepInputTracks = TrackCollectionMerger.clone( + trackProducers = [ + 'earlyGeneralTracks', + 'muonSeededTracksInOut', + 'muonSeededTracksOutIn' + ], + inputClassifiers =[ + "earlyGeneralTracks", + "muonSeededTracksInOutClassifier", + "muonSeededTracksOutInClassifier" + ] +) diff --git a/RecoTracker/FinalTrackSelectors/python/preDuplicateMergingGeneralTracks_cfi.py b/RecoTracker/FinalTrackSelectors/python/preDuplicateMergingGeneralTracks_cfi.py index 78bf165ec907a..f887aa5fd6c51 100644 --- a/RecoTracker/FinalTrackSelectors/python/preDuplicateMergingGeneralTracks_cfi.py +++ b/RecoTracker/FinalTrackSelectors/python/preDuplicateMergingGeneralTracks_cfi.py @@ -13,6 +13,13 @@ lostHitPenalty = 1.0 ) +from Configuration.Eras.Modifier_trackingPhase1_cff import trackingPhase1 +from Configuration.ProcessModifiers.displacedRegionalTracking_cff import displacedRegionalTracking +def _extend_displacedRegional(x): + x.trackProducers += ['displacedRegionalStepTracks'] + x.inputClassifiers += ['displacedRegionalStep'] +(trackingPhase1 & displacedRegionalTracking).toModify(preDuplicateMergingGeneralTracks, _extend_displacedRegional) + # For Phase2PU140 from Configuration.Eras.Modifier_trackingPhase2PU140_cff import trackingPhase2PU140 from RecoTracker.FinalTrackSelectors.trackListMerger_cfi import trackListMerger as _trackListMerger diff --git a/RecoTracker/FinalTrackSelectors/src/trackAlgoPriorityOrder.h b/RecoTracker/FinalTrackSelectors/src/trackAlgoPriorityOrder.h index 44d7836e37838..4d2d58ab82538 100644 --- a/RecoTracker/FinalTrackSelectors/src/trackAlgoPriorityOrder.h +++ b/RecoTracker/FinalTrackSelectors/src/trackAlgoPriorityOrder.h @@ -44,6 +44,7 @@ namespace impl { reco::TrackBase::conversionStep, reco::TrackBase::muonSeededStepInOut, reco::TrackBase::muonSeededStepOutIn, + reco::TrackBase::displacedRegionalStep, reco::TrackBase::outInEcalSeededConv, reco::TrackBase::inOutEcalSeededConv, reco::TrackBase::nuclInter, @@ -51,7 +52,6 @@ namespace impl { reco::TrackBase::globalMuon, reco::TrackBase::cosmicStandAloneMuon, reco::TrackBase::cosmicGlobalMuon, - reco::TrackBase::reservedForUpgrades2, reco::TrackBase::bTagGhostTracks, reco::TrackBase::beamhalo, reco::TrackBase::gsf, diff --git a/RecoTracker/IterativeTracking/python/DisplacedRegionalStep_cff.py b/RecoTracker/IterativeTracking/python/DisplacedRegionalStep_cff.py new file mode 100644 index 0000000000000..1b139ecdd240c --- /dev/null +++ b/RecoTracker/IterativeTracking/python/DisplacedRegionalStep_cff.py @@ -0,0 +1,384 @@ +import FWCore.ParameterSet.Config as cms +import RecoTracker.IterativeTracking.iterativeTkConfig as _cfg + +#for dnn classifier +from Configuration.ProcessModifiers.trackdnn_cff import trackdnn +from RecoTracker.IterativeTracking.dnnQualityCuts import qualityCutDictionary + +# for no-loopers +from Configuration.ProcessModifiers.trackingNoLoopers_cff import trackingNoLoopers + +############################################################################# +# Tracking seeded by regions of interest targeting exotic physics scenarios # +############################################################################# + +displacedRegionalStepClusters = _cfg.clusterRemoverForIter("DisplacedRegionalStep") +for _eraName, _postfix, _era in _cfg.nonDefaultEras(): + _era.toReplaceWith(displacedRegionalStepClusters, _cfg.clusterRemoverForIter("DisplacedRegionalStep", _eraName, _postfix)) + +# TRIPLET SEEDING LAYERS +from RecoLocalTracker.SiStripClusterizer.SiStripClusterChargeCut_cfi import * +import RecoTracker.TkSeedingLayers.seedingLayersEDProducer_cfi as _mod + +displacedRegionalStepSeedLayersTripl = _mod.seedingLayersEDProducer.clone( + layerList = [ + #TOB + 'TOB1+TOB2+MTOB3','TOB1+TOB2+MTOB4', + #TOB+MTEC + 'TOB1+TOB2+MTEC1_pos','TOB1+TOB2+MTEC1_neg', + ], + TOB = dict( + TTRHBuilder = cms.string('WithTrackAngle'), + clusterChargeCut = cms.PSet(refToPSet_ = cms.string('SiStripClusterChargeCutTight')), + matchedRecHits = cms.InputTag('siStripMatchedRecHits','matchedRecHit'), + skipClusters = cms.InputTag('displacedRegionalStepClusters') + ), + MTOB = dict( + TTRHBuilder = cms.string('WithTrackAngle'), + clusterChargeCut = cms.PSet(refToPSet_ = cms.string('SiStripClusterChargeCutTight')), + skipClusters = cms.InputTag('displacedRegionalStepClusters'), + rphiRecHits = cms.InputTag('siStripMatchedRecHits','rphiRecHit') + ), + MTEC = dict( + rphiRecHits = cms.InputTag('siStripMatchedRecHits','rphiRecHit'), + skipClusters = cms.InputTag('displacedRegionalStepClusters'), + useRingSlector = cms.bool(True), + TTRHBuilder = cms.string('WithTrackAngle'), + clusterChargeCut = cms.PSet(refToPSet_ = cms.string('SiStripClusterChargeCutTight')), + minRing = cms.int32(6), + maxRing = cms.int32(7) + ) +) + +# Triplet TrackingRegion +from RecoTracker.FinalTrackSelectors.displacedRegionalStepInputTracks_cfi import displacedRegionalStepInputTracks +from RecoVertex.V0Producer.generalV0Candidates_cfi import generalV0Candidates as _generalV0Candidates +from RecoTracker.DisplacedRegionalTracking.displacedRegionProducer_cfi import displacedRegionProducer as _displacedRegionProducer +displacedRegionalStepSeedingV0Candidates = _generalV0Candidates.clone( + trackRecoAlgorithm = "displacedRegionalStepInputTracks", + doLambdas = False, + doFit = False, + useRefTracks = False, + vtxDecayXYCut = 1., + ssVtxDecayXYCut = 5., + allowSS = True, + innerTkDCACut = 0.2, + allowWideAngleVtx = True, + mPiPiCut = 13000., + cosThetaXYCut = 0., + kShortMassCut = 13000., +) +displacedRegionalStepSeedingVertices = _displacedRegionProducer.clone( + minRadius = 2.0, + discriminatorCut = 0.5, + trackClusters = ["displacedRegionalStepSeedingV0Candidates", "Kshort"], +) + +from RecoTracker.TkTrackingRegions.globalTrackingRegionWithVertices_cfi import globalTrackingRegionWithVertices as _globalTrackingRegionWithVertices +displacedRegionalStepTrackingRegionsTripl = _globalTrackingRegionWithVertices.clone(RegionPSet = dict( + originRadius = 1.0, + fixedError = 1.0, + VertexCollection = "displacedRegionalStepSeedingVertices", + useFakeVertices = True, + ptMin = 0.55, + allowEmpty = True +)) + +# Triplet seeding +from RecoPixelVertexing.PixelLowPtUtilities.ClusterShapeHitFilterESProducer_cfi import ClusterShapeHitFilterESProducer as _ClusterShapeHitFilterESProducer +displacedRegionalStepClusterShapeHitFilter = _ClusterShapeHitFilterESProducer.clone( + ComponentName = 'displacedRegionalStepClusterShapeHitFilter', + doStripShapeCut = cms.bool(False), + clusterChargeCut = dict(refToPSet_ = 'SiStripClusterChargeCutTight') +) + +from RecoTracker.TkHitPairs.hitPairEDProducer_cfi import hitPairEDProducer as _hitPairEDProducer +displacedRegionalStepHitDoubletsTripl = _hitPairEDProducer.clone( + seedingLayers = "displacedRegionalStepSeedLayersTripl", + trackingRegions = "displacedRegionalStepTrackingRegionsTripl", + maxElement = 50000000, + produceIntermediateHitDoublets = True, +) +from RecoTracker.TkSeedGenerator.multiHitFromChi2EDProducer_cfi import multiHitFromChi2EDProducer as _multiHitFromChi2EDProducer +displacedRegionalStepHitTripletsTripl = _multiHitFromChi2EDProducer.clone( + doublets = "displacedRegionalStepHitDoubletsTripl", + extraPhiKDBox = 0.01, +) +from RecoTracker.TkSeedGenerator.seedCreatorFromRegionConsecutiveHitsEDProducer_cff import seedCreatorFromRegionConsecutiveHitsEDProducer as _seedCreatorFromRegionConsecutiveHitsTripletOnlyEDProducer +_displacedRegionalStepSeedComparitorPSet = dict( + ComponentName = 'CombinedSeedComparitor', + mode = cms.string("and"), + comparitors = cms.VPSet( + cms.PSet(# FIXME: is this defined in any cfi that could be imported instead of copy-paste? + ComponentName = cms.string('PixelClusterShapeSeedComparitor'), + FilterAtHelixStage = cms.bool(True), + FilterPixelHits = cms.bool(False), + FilterStripHits = cms.bool(True), + ClusterShapeHitFilterName = cms.string('displacedRegionalStepClusterShapeHitFilter'), + ClusterShapeCacheSrc = cms.InputTag("siPixelClusterShapeCache") # not really needed here since FilterPixelHits=False + ) + ) +) + +displacedRegionalStepSeedsTripl = _seedCreatorFromRegionConsecutiveHitsTripletOnlyEDProducer.clone(#empirically better than 'SeedFromConsecutiveHitsTripletOnlyCreator' + seedingHitSets = "displacedRegionalStepHitTripletsTripl", + SeedComparitorPSet = _displacedRegionalStepSeedComparitorPSet, +) + +from RecoPixelVertexing.PixelLowPtUtilities.StripSubClusterShapeSeedFilter_cfi import StripSubClusterShapeSeedFilter as _StripSubClusterShapeSeedFilter +from Configuration.ProcessModifiers.approxSiStripClusters_cff import approxSiStripClusters +(~approxSiStripClusters).toModify(displacedRegionalStepSeedsTripl.SeedComparitorPSet.comparitors, func = lambda list: list.append(_StripSubClusterShapeSeedFilter.clone()) ) + +# PAIR SEEDING LAYERS +displacedRegionalStepSeedLayersPair = _mod.seedingLayersEDProducer.clone( + layerList = ['TOB1+TEC1_pos','TOB1+TEC1_neg', + 'TEC1_pos+TEC2_pos','TEC1_neg+TEC2_neg', + 'TEC2_pos+TEC3_pos','TEC2_neg+TEC3_neg', + 'TEC3_pos+TEC4_pos','TEC3_neg+TEC4_neg', + 'TEC4_pos+TEC5_pos','TEC4_neg+TEC5_neg', + 'TEC5_pos+TEC6_pos','TEC5_neg+TEC6_neg', + 'TEC6_pos+TEC7_pos','TEC6_neg+TEC7_neg'], + TOB = dict( + TTRHBuilder = cms.string('WithTrackAngle'), + clusterChargeCut = cms.PSet(refToPSet_ = cms.string('SiStripClusterChargeCutTight')), + matchedRecHits = cms.InputTag('siStripMatchedRecHits','matchedRecHit'), + skipClusters = cms.InputTag('displacedRegionalStepClusters') + ), + TEC = dict( + matchedRecHits = cms.InputTag('siStripMatchedRecHits','matchedRecHit'), + skipClusters = cms.InputTag('displacedRegionalStepClusters'), + useRingSlector = cms.bool(True), + TTRHBuilder = cms.string('WithTrackAngle'), + clusterChargeCut = cms.PSet(refToPSet_ = cms.string('SiStripClusterChargeCutTight')), + minRing = cms.int32(5), + maxRing = cms.int32(5) + ) +) +# Pair TrackingRegion +displacedRegionalStepTrackingRegionsPair = _globalTrackingRegionWithVertices.clone(RegionPSet = dict( + originRadius = 1.0, + fixedError = 1.0, + VertexCollection = "displacedRegionalStepSeedingVertices", + useFakeVertices = True, + ptMin = 0.6, + allowEmpty = True +)) + +# Pair seeds +displacedRegionalStepHitDoubletsPair = _hitPairEDProducer.clone( + seedingLayers = "displacedRegionalStepSeedLayersPair", + trackingRegions = "displacedRegionalStepTrackingRegionsPair", + produceSeedingHitSets = True, + maxElementTotal = 12000000, +) +from RecoTracker.TkSeedGenerator.seedCreatorFromRegionConsecutiveHitsEDProducer_cff import seedCreatorFromRegionConsecutiveHitsEDProducer as _seedCreatorFromRegionConsecutiveHitsEDProducer +displacedRegionalStepSeedsPair = _seedCreatorFromRegionConsecutiveHitsEDProducer.clone( + seedingHitSets = "displacedRegionalStepHitDoubletsPair", + SeedComparitorPSet = _displacedRegionalStepSeedComparitorPSet, +) + +# Combined seeds +import RecoTracker.TkSeedGenerator.GlobalCombinedSeeds_cfi +displacedRegionalStepSeeds = RecoTracker.TkSeedGenerator.GlobalCombinedSeeds_cfi.globalCombinedSeeds.clone( + seedCollections = ['displacedRegionalStepSeedsTripl', 'displacedRegionalStepSeedsPair'] +) + +# QUALITY CUTS DURING TRACK BUILDING (for inwardss and outwards track building steps) +import TrackingTools.TrajectoryFiltering.TrajectoryFilter_cff +_displacedRegionalStepTrajectoryFilterBase = TrackingTools.TrajectoryFiltering.TrajectoryFilter_cff.CkfBaseTrajectoryFilter_block.clone( + maxLostHits = 0, + minimumNumberOfHits = 5, + minPt = 0.1, + minHitsMinPt = 3 + ) +displacedRegionalStepTrajectoryFilter = _displacedRegionalStepTrajectoryFilterBase.clone( + seedPairPenalty = 1, +) + +displacedRegionalStepInOutTrajectoryFilter = displacedRegionalStepTrajectoryFilter.clone( + minimumNumberOfHits = 4, +) + +import RecoTracker.MeasurementDet.Chi2ChargeMeasurementEstimator_cfi +displacedRegionalStepChi2Est = RecoTracker.MeasurementDet.Chi2ChargeMeasurementEstimator_cfi.Chi2ChargeMeasurementEstimator.clone( + ComponentName = 'displacedRegionalStepChi2Est', + nSigma = 3.0, + MaxChi2 = 16.0, + clusterChargeCut = cms.PSet(refToPSet_ = cms.string('SiStripClusterChargeCutTight')) +) + +# TRACK BUILDING +import RecoTracker.CkfPattern.GroupedCkfTrajectoryBuilder_cfi +displacedRegionalStepTrajectoryBuilder = RecoTracker.CkfPattern.GroupedCkfTrajectoryBuilder_cfi.GroupedCkfTrajectoryBuilder.clone( + trajectoryFilter = dict(refToPSet_ = 'displacedRegionalStepTrajectoryFilter'), + inOutTrajectoryFilter = dict(refToPSet_ = 'displacedRegionalStepInOutTrajectoryFilter'), + useSameTrajFilter = False, + minNrOfHitsForRebuild = 4, + alwaysUseInvalidHits = False, + maxCand = 2, + estimator = 'displacedRegionalStepChi2Est', + #startSeedHitsInRebuild = True, + maxDPhiForLooperReconstruction = 2.0, + maxPtForLooperReconstruction = 0.7, +) +trackingNoLoopers.toModify(displacedRegionalStepTrajectoryBuilder, + maxPtForLooperReconstruction = 0.0) + +# MAKING OF TRACK CANDIDATES +import RecoTracker.CkfPattern.CkfTrackCandidates_cfi +# Give handle for CKF for HI +_displacedRegionalStepTrackCandidatesCkf = RecoTracker.CkfPattern.CkfTrackCandidates_cfi.ckfTrackCandidates.clone( + src = 'displacedRegionalStepSeeds', + clustersToSkip = 'displacedRegionalStepClusters', + ### these two parameters are relevant only for the CachingSeedCleanerBySharedInput + numHitsForSeedCleaner = 50, + onlyPixelHitsForSeedCleaner = False, + TrajectoryBuilderPSet = dict(refToPSet_ = 'displacedRegionalStepTrajectoryBuilder'), + doSeedingRegionRebuilding = True, + useHitsSplitting = True, + cleanTrajectoryAfterInOut = True, + TrajectoryCleaner = 'displacedRegionalStepTrajectoryCleanerBySharedHits', +) +displacedRegionalStepTrackCandidates = _displacedRegionalStepTrackCandidatesCkf.clone() + +from Configuration.ProcessModifiers.trackingMkFitDisplacedRegionalStep_cff import trackingMkFitDisplacedRegionalStep +import RecoTracker.MkFit.mkFitSeedConverter_cfi as mkFitSeedConverter_cfi +import RecoTracker.MkFit.mkFitIterationConfigESProducer_cfi as mkFitIterationConfigESProducer_cfi +import RecoTracker.MkFit.mkFitProducer_cfi as mkFitProducer_cfi +import RecoTracker.MkFit.mkFitOutputConverter_cfi as mkFitOutputConverter_cfi +displacedRegionalStepTrackCandidatesMkFitSeeds = mkFitSeedConverter_cfi.mkFitSeedConverter.clone( + seeds = 'displacedRegionalStepSeeds', +) +displacedRegionalStepTrackCandidatesMkFitConfig = mkFitIterationConfigESProducer_cfi.mkFitIterationConfigESProducer.clone( + ComponentName = 'displacedRegionalStepTrackCandidatesMkFitConfig', + config = 'RecoTracker/MkFit/data/mkfit-phase1-tobTecStep.json', +) +displacedRegionalStepTrackCandidatesMkFit = mkFitProducer_cfi.mkFitProducer.clone( + seeds = 'displacedRegionalStepTrackCandidatesMkFitSeeds', + config = ('', 'displacedRegionalStepTrackCandidatesMkFitConfig'), + clustersToSkip = 'displacedRegionalStepClusters', +) +trackingMkFitDisplacedRegionalStep.toReplaceWith(displacedRegionalStepTrackCandidates, mkFitOutputConverter_cfi.mkFitOutputConverter.clone( + seeds = 'displacedRegionalStepSeeds', + mkFitSeeds = 'displacedRegionalStepTrackCandidatesMkFitSeeds', + tracks = 'displacedRegionalStepTrackCandidatesMkFit', +)) + +from TrackingTools.TrajectoryCleaning.TrajectoryCleanerBySharedHits_cfi import trajectoryCleanerBySharedHits +displacedRegionalStepTrajectoryCleanerBySharedHits = trajectoryCleanerBySharedHits.clone( + ComponentName = 'displacedRegionalStepTrajectoryCleanerBySharedHits', + fractionShared = 0.09, + allowSharedFirstHit = True + ) + +# TRACK FITTING AND SMOOTHING OPTIONS +import TrackingTools.TrackFitters.RungeKuttaFitters_cff +displacedRegionalStepFitterSmoother = TrackingTools.TrackFitters.RungeKuttaFitters_cff.KFFittingSmootherWithOutliersRejectionAndRK.clone( + ComponentName = 'displacedRegionalStepFitterSmoother', + EstimateCut = 30, + MinNumberOfHits = 7, + Fitter = 'displacedRegionalStepRKFitter', + Smoother = 'displacedRegionalStepRKSmoother' + ) + +displacedRegionalStepFitterSmootherForLoopers = displacedRegionalStepFitterSmoother.clone( + ComponentName = 'displacedRegionalStepFitterSmootherForLoopers', + Fitter = 'displacedRegionalStepRKFitterForLoopers', + Smoother = 'displacedRegionalStepRKSmootherForLoopers' +) + +# Also necessary to specify minimum number of hits after final track fit +displacedRegionalStepRKTrajectoryFitter = TrackingTools.TrackFitters.RungeKuttaFitters_cff.RKTrajectoryFitter.clone( + ComponentName = 'displacedRegionalStepRKFitter', + minHits = 7 +) + +displacedRegionalStepRKTrajectoryFitterForLoopers = displacedRegionalStepRKTrajectoryFitter.clone( + ComponentName = 'displacedRegionalStepRKFitterForLoopers', + Propagator = 'PropagatorWithMaterialForLoopers', +) + +displacedRegionalStepRKTrajectorySmoother = TrackingTools.TrackFitters.RungeKuttaFitters_cff.RKTrajectorySmoother.clone( + ComponentName = 'displacedRegionalStepRKSmoother', + errorRescaling = 10.0, + minHits = 7 +) + +displacedRegionalStepRKTrajectorySmootherForLoopers = displacedRegionalStepRKTrajectorySmoother.clone( + ComponentName = 'displacedRegionalStepRKSmootherForLoopers', + Propagator = 'PropagatorWithMaterialForLoopers', +) + +import TrackingTools.TrackFitters.FlexibleKFFittingSmoother_cfi +displacedRegionalFlexibleKFFittingSmoother = TrackingTools.TrackFitters.FlexibleKFFittingSmoother_cfi.FlexibleKFFittingSmoother.clone( + ComponentName = 'displacedRegionalFlexibleKFFittingSmoother', + standardFitter = 'displacedRegionalStepFitterSmoother', + looperFitter = 'displacedRegionalStepFitterSmootherForLoopers', +) + +# TRACK FITTING +import RecoTracker.TrackProducer.TrackProducerIterativeDefault_cfi +displacedRegionalStepTracks = RecoTracker.TrackProducer.TrackProducerIterativeDefault_cfi.TrackProducer.clone( + src = 'displacedRegionalStepTrackCandidates', + AlgorithmName = 'displacedRegionalStep', + #Fitter = 'displacedRegionalStepFitterSmoother', + Fitter = 'displacedRegionalFlexibleKFFittingSmoother', +) + +# TRACK SELECTION AND QUALITY FLAG SETTING. +from RecoTracker.FinalTrackSelectors.TrackMVAClassifierPrompt_cfi import * +from RecoTracker.FinalTrackSelectors.TrackMVAClassifierDetached_cfi import * +displacedRegionalStepClassifier1 = TrackMVAClassifierDetached.clone( + src = 'displacedRegionalStepTracks', + mva = dict(GBRForestLabel = 'MVASelectorIter6_13TeV'), + qualityCuts = [-0.6,-0.45,-0.3] +) + +displacedRegionalStepClassifier2 = TrackMVAClassifierPrompt.clone( + src = 'displacedRegionalStepTracks', + mva = dict(GBRForestLabel = 'MVASelectorIter0_13TeV'), + qualityCuts = [0.0,0.0,0.0] +) + +from RecoTracker.FinalTrackSelectors.ClassifierMerger_cfi import * +displacedRegionalStep = ClassifierMerger.clone( + inputClassifiers=['displacedRegionalStepClassifier1','displacedRegionalStepClassifier2'] +) + +from Configuration.Eras.Modifier_trackingPhase1_cff import trackingPhase1 +trackingPhase1.toReplaceWith(displacedRegionalStep, displacedRegionalStepClassifier1.clone( + mva = dict(GBRForestLabel = 'MVASelectorTobTecStep_Phase1'), + qualityCuts = [-0.6,-0.45,-0.3] +)) + +from RecoTracker.FinalTrackSelectors.trackTfClassifier_cfi import * +from RecoTracker.FinalTrackSelectors.trackSelectionTf_cfi import * +from RecoTracker.FinalTrackSelectors.trackSelectionTf_CKF_cfi import * +trackdnn.toReplaceWith(displacedRegionalStep, trackTfClassifier.clone( + src = 'displacedRegionalStepTracks', + qualityCuts = qualityCutDictionary.DisplacedRegionalStep.value() +)) + +DisplacedRegionalStepTask = cms.Task(displacedRegionalStepClusters, + displacedRegionalStepSeedLayersTripl, + displacedRegionalStepInputTracks, + displacedRegionalStepSeedingV0Candidates, + displacedRegionalStepSeedingVertices, + displacedRegionalStepTrackingRegionsTripl, + displacedRegionalStepHitDoubletsTripl, + displacedRegionalStepHitTripletsTripl, + displacedRegionalStepSeedsTripl, + displacedRegionalStepSeedLayersPair, + displacedRegionalStepTrackingRegionsPair, + displacedRegionalStepHitDoubletsPair, + displacedRegionalStepSeedsPair, + displacedRegionalStepSeeds, + displacedRegionalStepTrackCandidates, + displacedRegionalStepTracks, + displacedRegionalStepClassifier1,displacedRegionalStepClassifier2, + displacedRegionalStep) +DisplacedRegionalStep = cms.Sequence(DisplacedRegionalStepTask) + +_DisplacedRegionalStepTask_trackingMkFit = DisplacedRegionalStepTask.copy() +_DisplacedRegionalStepTask_trackingMkFit.add(displacedRegionalStepTrackCandidatesMkFitSeeds, displacedRegionalStepTrackCandidatesMkFit, displacedRegionalStepTrackCandidatesMkFitConfig) +trackingMkFitDisplacedRegionalStep.toReplaceWith(DisplacedRegionalStepTask, _DisplacedRegionalStepTask_trackingMkFit) diff --git a/RecoTracker/IterativeTracking/python/dnnQualityCuts.py b/RecoTracker/IterativeTracking/python/dnnQualityCuts.py index 9758588f44eef..00793f59ea9c7 100644 --- a/RecoTracker/IterativeTracking/python/dnnQualityCuts.py +++ b/RecoTracker/IterativeTracking/python/dnnQualityCuts.py @@ -11,6 +11,7 @@ MixedTripletStep = cms.vdouble(-0.86, -0.68, -0.43), PixelLessStep = cms.vdouble(-0.80, -0.69, -0.40), TobTecStep = cms.vdouble(-0.76, -0.65, -0.55), + DisplacedRegionalStep = cms.vdouble(-0.76, -0.65, -0.55), JetCoreRegionalStep = cms.vdouble(-0.62, -0.49, 0.02) ) @@ -27,5 +28,6 @@ MixedTripletStep = [-0.87, -0.61, -0.17], PixelLessStep = [-0.82, -0.61, -0.16], TobTecStep = [-0.75, -0.65, -0.53], + DisplacedRegionalStep = [-0.75, -0.65, -0.53], JetCoreRegionalStep = [-0.14, -0.12, 0.63], ) diff --git a/RecoTracker/IterativeTracking/python/iterativeTkConfig.py b/RecoTracker/IterativeTracking/python/iterativeTkConfig.py index 9790ee16d265d..cb946b1aa6c84 100644 --- a/RecoTracker/IterativeTracking/python/iterativeTkConfig.py +++ b/RecoTracker/IterativeTracking/python/iterativeTkConfig.py @@ -67,6 +67,10 @@ "MuonSeededStepInOut", "MuonSeededStepOutIn", ] +_iterations_muonSeeded_trackingPhase1 = [ + "MuonSeededStepInOut", + "MuonSeededStepOutIn", +] #Phase2 _iterations_muonSeeded_trackingPhase2PU140 = [ "MuonSeededStepInOut", @@ -99,6 +103,10 @@ "TobTecStep", ]) +from Configuration.ProcessModifiers.displacedRegionalTracking_cff import displacedRegionalTracking +displacedRegionalTracking.toModify(_iterations_muonSeeded_trackingPhase1, func=lambda x: x.append('DisplacedRegionalStep')) +displacedRegionalTracking.toModify(_multipleSeedProducers_trackingPhase1, func=lambda x: x.update({'DisplacedRegionalStep': ['Pair', 'Tripl']})) + from RecoLocalTracker.SubCollectionProducers.trackClusterRemover_cfi import trackClusterRemover as _trackClusterRemover _trackClusterRemoverBase = _trackClusterRemover.clone( maxChi2 = 9.0, @@ -176,7 +184,10 @@ def _seedOrTrackProducers(postfix, typ): ret.append(seeder) for i in globals().get("_iterations_muonSeeded"+postfix, _iterations_muonSeeded): - ret.append(_modulePrefix(i).replace("Step", typ)) + if _modulePrefix(i).endswith("Step"): + ret.append(_modulePrefix(i)+typ) + else: + ret.append(_modulePrefix(i).replace("Step", typ)) return ret @@ -194,7 +205,9 @@ def clusterRemoverForIter(iteration, eraName="", postfix="", module=None): iters = globals()["_iterations"+postfix] try: - ind = iters.index(iteration) + # DisplacedRegionalStep is a special case because it comes after the + # usual muon-seeded steps + ind = iters.index(iteration) if iteration != "DisplacedRegionalStep" else len(iters) except ValueError: # if the iteration is not active in era, just return the same return module @@ -202,6 +215,10 @@ def clusterRemoverForIter(iteration, eraName="", postfix="", module=None): if ind == 0: raise Exception("Iteration %s is the first iteration in era %s, asking cluster remover configuration does not make sense" % (iteration, eraName)) prevIter = iters[ind-1] + # JetCoreRegionalStep uses all clusters, so if that is the previous + # iteration, use the one before that for cluster removal + if prevIter == "JetCoreRegionalStep": + prevIter = iters[ind-2] customize = dict( trajectories = _tracks(prevIter), diff --git a/RecoTracker/IterativeTracking/python/iterativeTk_cff.py b/RecoTracker/IterativeTracking/python/iterativeTk_cff.py index 612bd5752084f..040d023a8c58f 100644 --- a/RecoTracker/IterativeTracking/python/iterativeTk_cff.py +++ b/RecoTracker/IterativeTracking/python/iterativeTk_cff.py @@ -10,6 +10,7 @@ from RecoTracker.IterativeTracking.PixelLessStep_cff import * from RecoTracker.IterativeTracking.TobTecStep_cff import * from RecoTracker.IterativeTracking.DisplacedGeneralStep_cff import * +from RecoTracker.IterativeTracking.DisplacedRegionalStep_cff import * from RecoTracker.IterativeTracking.JetCoreRegionalStep_cff import * # Phase1 specific iterations @@ -43,6 +44,10 @@ conversionStepTracks ) +from Configuration.Eras.Modifier_trackingPhase1_cff import trackingPhase1 +from Configuration.ProcessModifiers.displacedRegionalTracking_cff import displacedRegionalTracking +(trackingPhase1 & displacedRegionalTracking).toModify(iterTrackingTask, lambda x: x.add(DisplacedRegionalStepTask)) + _iterTrackingTask_trackdnn = iterTrackingTask.copy() _iterTrackingTask_trackdnn.add(trackdnn_source) trackdnn.toReplaceWith(iterTrackingTask, _iterTrackingTask_trackdnn) diff --git a/RecoTracker/TkTrackingRegions/plugins/GlobalTrackingRegionWithVerticesProducer.h b/RecoTracker/TkTrackingRegions/plugins/GlobalTrackingRegionWithVerticesProducer.h index 3cad10eac9ec1..4c111d1f578c4 100644 --- a/RecoTracker/TkTrackingRegions/plugins/GlobalTrackingRegionWithVerticesProducer.h +++ b/RecoTracker/TkTrackingRegions/plugins/GlobalTrackingRegionWithVerticesProducer.h @@ -41,6 +41,7 @@ class GlobalTrackingRegionWithVerticesProducer : public TrackingRegionProducer { theOriginRScaling = regionPSet.getParameter("originRScaling4BigEvts"); thePtMinScaling = regionPSet.getParameter("ptMinScaling4BigEvts"); theHalfLengthScaling = regionPSet.getParameter("halfLengthScaling4BigEvts"); + theAllowEmpty = regionPSet.getParameter("allowEmpty"); theMinOriginR = regionPSet.getParameter("minOriginR"); theMaxPtMin = regionPSet.getParameter("maxPtMin"); theMinHalfLength = regionPSet.getParameter("minHalfLength"); @@ -77,6 +78,7 @@ class GlobalTrackingRegionWithVerticesProducer : public TrackingRegionProducer { desc.add("originRScaling4BigEvts", false); desc.add("ptMinScaling4BigEvts", false); desc.add("halfLengthScaling4BigEvts", false); + desc.add("allowEmpty", false); desc.add("minOriginR", 0); desc.add("maxPtMin", 1000); desc.add("minHalfLength", 0); @@ -175,7 +177,7 @@ class GlobalTrackingRegionWithVerticesProducer : public TrackingRegionProducer { } } - if (result.empty() && !(theOriginRScaling || thePtMinScaling || theHalfLengthScaling)) { + if (result.empty() && !(theOriginRScaling || thePtMinScaling || theHalfLengthScaling || theAllowEmpty)) { result.push_back(std::make_unique( thePtMin, theOrigin, theOriginRadius, bsSigmaZ, thePrecise, theUseMS, msmaker)); } @@ -210,6 +212,7 @@ class GlobalTrackingRegionWithVerticesProducer : public TrackingRegionProducer { bool theOriginRScaling; bool thePtMinScaling; bool theHalfLengthScaling; + bool theAllowEmpty; double theMinOriginR; double theMaxPtMin; double theMinHalfLength; diff --git a/RecoVertex/V0Producer/python/generalV0Candidates_cfi.py b/RecoVertex/V0Producer/python/generalV0Candidates_cfi.py index 98372d5a88528..ded8dd7a0fe20 100644 --- a/RecoVertex/V0Producer/python/generalV0Candidates_cfi.py +++ b/RecoVertex/V0Producer/python/generalV0Candidates_cfi.py @@ -17,6 +17,10 @@ doKShorts = cms.bool(True), doLambdas = cms.bool(True), + # perform vertex fit (if false, the POCA is used in lieu of the point + # resulting from a fit) + doFit = cms.bool(True), + # which vertex fitting algorithm to use # True -> KalmanVertexFitter (recommended) # False -> AdaptiveVertexFitter (not recommended) @@ -42,12 +46,22 @@ vtxChi2Cut = cms.double(6.63), # XY decay distance significance > vtxDecaySigXYCut = cms.double(15.), + # XY decay distance > + vtxDecayXYCut = cms.double(-1.), + # XY decay distance for same-sign vertices > + ssVtxDecayXYCut = cms.double(-1.), # XYZ decay distance significance > vtxDecaySigXYZCut = cms.double(-1.), # -- miscellaneous cuts -- - # POCA distance between tracks < - tkDCACut = cms.double(1.), + # allow same-sign pairs of tracks + allowSS = cms.bool(False), + # POCA distance between tracks when POCA is less than 5 cm from the z-axis < + innerTkDCACut = cms.double(1.), + # POCA distance between tracks when POCA is more than 5 cm from the z-axis < + outerTkDCACut = cms.double(1.), + # allow vertices where the angle between the tracks is more than 90 degrees + allowWideAngleVtx = cms.bool(False), # invariant mass of track pair - assuming both tracks are charged pions < mPiPiCut = cms.double(0.6), # check if either track has a hit radially inside the vertex position minus this number times the sigma of the vertex fit diff --git a/RecoVertex/V0Producer/src/V0Fitter.cc b/RecoVertex/V0Producer/src/V0Fitter.cc index ad73994570dbf..33ca4f453f991 100644 --- a/RecoVertex/V0Producer/src/V0Fitter.cc +++ b/RecoVertex/V0Producer/src/V0Fitter.cc @@ -49,9 +49,11 @@ typedef ROOT::Math::SVector SVector3; V0Fitter::V0Fitter(const edm::ParameterSet& theParameters, edm::ConsumesCollector&& iC) : esTokenMF_(iC.esConsumes()) { token_beamSpot = iC.consumes(theParameters.getParameter("beamSpot")); useVertex_ = theParameters.getParameter("useVertex"); - token_vertices = iC.consumes>(theParameters.getParameter("vertices")); + if (useVertex_) + token_vertices = iC.consumes>(theParameters.getParameter("vertices")); token_tracks = iC.consumes(theParameters.getParameter("trackRecoAlgorithm")); + doFit_ = theParameters.getParameter("doFit"); vertexFitter_ = theParameters.getParameter("vertexFitter"); useRefTracks_ = theParameters.getParameter("useRefTracks"); @@ -71,8 +73,13 @@ V0Fitter::V0Fitter(const edm::ParameterSet& theParameters, edm::ConsumesCollecto vtxChi2Cut_ = theParameters.getParameter("vtxChi2Cut"); vtxDecaySigXYZCut_ = theParameters.getParameter("vtxDecaySigXYZCut"); vtxDecaySigXYCut_ = theParameters.getParameter("vtxDecaySigXYCut"); + vtxDecayXYCut_ = theParameters.getParameter("vtxDecayXYCut"); + ssVtxDecayXYCut_ = theParameters.getParameter("ssVtxDecayXYCut"); // miscellaneous cuts - tkDCACut_ = theParameters.getParameter("tkDCACut"); + allowSS_ = theParameters.getParameter("allowSS"); + innerTkDCACut_ = theParameters.getParameter("innerTkDCACut"); + outerTkDCACut_ = theParameters.getParameter("outerTkDCACut"); + allowWideAngleVtx_ = theParameters.getParameter("allowWideAngleVtx"); mPiPiCut_ = theParameters.getParameter("mPiPiCut"); innerHitPosCut_ = theParameters.getParameter("innerHitPosCut"); cosThetaXYCut_ = theParameters.getParameter("cosThetaXYCut"); @@ -150,7 +157,14 @@ void V0Fitter::fitAll(const edm::Event& iEvent, negTransTkPtr = &theTransTracks[trdx2]; posTransTkPtr = &theTransTracks[trdx1]; } else { - continue; + if (!allowSS_) + continue; + + // if same-sign pairs are allowed, assign the negative and positive tracks arbitrarily + negativeTrackRef = theTrackRefs[trdx1]; + positiveTrackRef = theTrackRefs[trdx2]; + negTransTkPtr = &theTransTracks[trdx1]; + posTransTkPtr = &theTransTracks[trdx2]; } // measure distance between tracks at their closest approach @@ -168,20 +182,26 @@ void V0Fitter::fitAll(const edm::Event& iEvent, if (!cApp.status()) continue; float dca = std::abs(cApp.distance()); - if (dca > tkDCACut_) - continue; // the POCA should at least be in the sensitive volume GlobalPoint cxPt = cApp.crossingPoint(); if ((cxPt.x() * cxPt.x() + cxPt.y() * cxPt.y()) > 120. * 120. || std::abs(cxPt.z()) > 300.) continue; + if (cxPt.x() * cxPt.x() + cxPt.y() * cxPt.y() < 25.0) { + if (dca > innerTkDCACut_) + continue; + } else { + if (dca > outerTkDCACut_) + continue; + } + // the tracks should at least point in the same quadrant TrajectoryStateClosestToPoint const& posTSCP = posTransTkPtr->trajectoryStateClosestToPoint(cxPt); TrajectoryStateClosestToPoint const& negTSCP = negTransTkPtr->trajectoryStateClosestToPoint(cxPt); if (!posTSCP.isValid() || !negTSCP.isValid()) continue; - if (posTSCP.momentum().dot(negTSCP.momentum()) < 0) + if (!allowWideAngleVtx_ && posTSCP.momentum().dot(negTSCP.momentum()) < 0) continue; // calculate mPiPi @@ -199,14 +219,17 @@ void V0Fitter::fitAll(const edm::Event& iEvent, transTracks.push_back(*negTransTkPtr); // create the vertex fitter object and vertex the tracks - TransientVertex theRecoVertex; - if (vertexFitter_) { - KalmanVertexFitter theKalmanFitter(useRefTracks_ == 0 ? false : true); - theRecoVertex = theKalmanFitter.vertex(transTracks); - } else if (!vertexFitter_) { - useRefTracks_ = false; - AdaptiveVertexFitter theAdaptiveFitter; - theRecoVertex = theAdaptiveFitter.vertex(transTracks); + const GlobalError dummyError(1.0e-3, 0.0, 1.0e-3, 0.0, 0.0, 1.0e-3); + TransientVertex theRecoVertex(cxPt, dummyError, transTracks, 1.0e-3); + if (doFit_) { + if (vertexFitter_) { + KalmanVertexFitter theKalmanFitter(useRefTracks_ == 0 ? false : true); + theRecoVertex = theKalmanFitter.vertex(transTracks); + } else if (!vertexFitter_) { + useRefTracks_ = false; + AdaptiveVertexFitter theAdaptiveFitter; + theRecoVertex = theAdaptiveFitter.vertex(transTracks); + } } if (!theRecoVertex.isValid()) continue; @@ -225,6 +248,10 @@ void V0Fitter::fitAll(const edm::Event& iEvent, double sigmaDistMagXY = sqrt(ROOT::Math::Similarity(totalCov, distVecXY)) / distMagXY; if (distMagXY / sigmaDistMagXY < vtxDecaySigXYCut_) continue; + if (distMagXY < vtxDecayXYCut_) + continue; + if (posTransTkPtr->charge() * negTransTkPtr->charge() > 0 && distMagXY < ssVtxDecayXYCut_) + continue; // 3D decay significance if (vtxDecaySigXYZCut_ > 0.) { diff --git a/RecoVertex/V0Producer/src/V0Fitter.h b/RecoVertex/V0Producer/src/V0Fitter.h index 5b399f64f6053..9386081245c20 100644 --- a/RecoVertex/V0Producer/src/V0Fitter.h +++ b/RecoVertex/V0Producer/src/V0Fitter.h @@ -48,6 +48,7 @@ class dso_hidden V0Fitter { private: const edm::ESGetToken esTokenMF_; + bool doFit_; bool vertexFitter_; bool useRefTracks_; bool doKShorts_; @@ -63,8 +64,13 @@ class dso_hidden V0Fitter { double vtxChi2Cut_; double vtxDecaySigXYCut_; double vtxDecaySigXYZCut_; + double vtxDecayXYCut_; + double ssVtxDecayXYCut_; // miscellaneous cuts - double tkDCACut_; + bool allowSS_; + double innerTkDCACut_; + double outerTkDCACut_; + bool allowWideAngleVtx_; double mPiPiCut_; double innerHitPosCut_; double cosThetaXYCut_; diff --git a/Validation/RecoTrack/python/TrackValidation_cff.py b/Validation/RecoTrack/python/TrackValidation_cff.py index d77e589dbee89..4976cd18e321d 100644 --- a/Validation/RecoTrack/python/TrackValidation_cff.py +++ b/Validation/RecoTrack/python/TrackValidation_cff.py @@ -45,6 +45,7 @@ _removeForFastSimSeedProducers =["initialStepSeedsPreSplitting", "jetCoreRegionalStepSeeds", "jetCoreRegionalStepSeedsBarrel","jetCoreRegionalStepSeedsEndcap", + "displacedRegionalStepSeeds", "muonSeededSeedsInOut", "muonSeededSeedsOutIn"] @@ -52,6 +53,7 @@ _removeForFastTrackProducers = ["initialStepTracksPreSplitting", "jetCoreRegionalStepTracks", + "displacedRegionalStepTracks", "muonSeededTracksInOut", "muonSeededTracksOutIn"] _trackProducers_fastSim = [ x for x in _trackProducers if x not in _removeForFastTrackProducers] diff --git a/Validation/RecoTrack/python/plotting/html.py b/Validation/RecoTrack/python/plotting/html.py index 1bd245bb73b89..58cc723ea93aa 100644 --- a/Validation/RecoTrack/python/plotting/html.py +++ b/Validation/RecoTrack/python/plotting/html.py @@ -168,6 +168,7 @@ def _toPixel(s): 'jetCoreRegionalStep', 'muonSeededStepInOut', 'muonSeededStepOutIn', + 'displacedRegionalStep', 'duplicateMerge', 'convStep', 'conversionStep', diff --git a/Validation/RecoTrack/python/plotting/ntupleEnum.py b/Validation/RecoTrack/python/plotting/ntupleEnum.py index 167e5cdc91130..3be7d79bc463a 100644 --- a/Validation/RecoTrack/python/plotting/ntupleEnum.py +++ b/Validation/RecoTrack/python/plotting/ntupleEnum.py @@ -42,7 +42,7 @@ def toString(self, val): # Phase1 highPtTripletStep = 22, lowPtQuadStep = 23, detachedQuadStep = 24, displacedGeneralStep = 25, - reservedForUpgrades2 = 26, + displacedRegionalStep = 26, bTagGhostTracks = 27, beamhalo = 28, gsf = 29, diff --git a/Validation/RecoTrack/python/plotting/trackingPlots.py b/Validation/RecoTrack/python/plotting/trackingPlots.py index 8505a03e7af24..b5b34804d1ec5 100644 --- a/Validation/RecoTrack/python/plotting/trackingPlots.py +++ b/Validation/RecoTrack/python/plotting/trackingPlots.py @@ -529,6 +529,9 @@ def _makeMVAPlots(num, hp=False): 'jetCoreRegionalStep', 'muonSeededStepInOut', 'muonSeededStepOutIn', + 'displacedRegionalStepPair', # seeds + 'displacedRegionalStepTripl', # seeds + 'displacedRegionalStep', 'duplicateMerge', ] + _possibleTrackingNonIterationColls _possibleTrackingCollsOld = { @@ -1594,6 +1597,21 @@ def modules(self): "muonSeededTracksOutIntSelector"], # other=["earlyMuons"] ), + Iteration("displacedRegionalStep", + seeding=["displacedRegionalStepSeedLayersTripl", + "displacedRegionalStepSeedLayersPair", + "displacedRegionalStepTrackingRegionsTripl", + "displacedRegionalStepTrackingRegionsPair", + "displacedRegionalStepHitDoubletsTripl", + "displacedRegionalStepHitDoubletsPair", + "displacedRegionalStepHitTripletsTripl", + "displacedRegionalStepSeedsTripl", + "displacedRegionalStepSeedsPair", + "displacedRegionalStepSeeds"], + selection=["displacedRegionalStepClassifier1", + "displacedRegionalStepClassifier2", + "displacedRegionalStep", + "displacedRegionalStepSelector"]), Iteration("duplicateMerge", clusterMasking=[], seeding=[], building=["duplicateTrackCandidates"], diff --git a/Validation/RecoTrack/test/trackingPerformanceValidation.py b/Validation/RecoTrack/test/trackingPerformanceValidation.py index 5741b5674f691..8c89201adeeb2 100755 --- a/Validation/RecoTrack/test/trackingPerformanceValidation.py +++ b/Validation/RecoTrack/test/trackingPerformanceValidation.py @@ -183,7 +183,7 @@ def _isPhase1(release): doPhase2PU = True ### Track algorithm name and quality. Can be a list. -Algos= ['ootb', 'initialStep', 'lowPtTripletStep','pixelPairStep','detachedTripletStep','mixedTripletStep','pixelLessStep','tobTecStep','displacedGeneralStep','jetCoreRegionalStep','muonSeededStepInOut','muonSeededStepOutIn', +Algos= ['ootb', 'initialStep', 'lowPtTripletStep','pixelPairStep','detachedTripletStep','mixedTripletStep','pixelLessStep','tobTecStep','displacedGeneralStep','jetCoreRegionalStep','muonSeededStepInOut','muonSeededStepOutIn','displacedRegionalStep', 'ak4PFJets','btvLike' ] #Algos= ['ootb'] From d4512b0fb94edbd7a4c403817fc4d65e1fb050a8 Mon Sep 17 00:00:00 2001 From: Andrew Hart Date: Tue, 31 Jan 2023 18:39:36 -0500 Subject: [PATCH 02/23] Added DisplacedRegionalStep for testing. --- .../ProcessModifiers/python/trackingMkFitDevel_cff.py | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/Configuration/ProcessModifiers/python/trackingMkFitDevel_cff.py b/Configuration/ProcessModifiers/python/trackingMkFitDevel_cff.py index 6a71b93894d0f..2d684c88435ab 100644 --- a/Configuration/ProcessModifiers/python/trackingMkFitDevel_cff.py +++ b/Configuration/ProcessModifiers/python/trackingMkFitDevel_cff.py @@ -12,6 +12,7 @@ from Configuration.ProcessModifiers.trackingMkFitMixedTripletStep_cff import * from Configuration.ProcessModifiers.trackingMkFitPixelLessStep_cff import * from Configuration.ProcessModifiers.trackingMkFitTobTecStep_cff import * +from Configuration.ProcessModifiers.trackingMkFitDisplacedRegionalStep_cff import * # Use mkFit in selected iterations trackingMkFitDevel = cms.ModifierChain( @@ -26,5 +27,6 @@ trackingMkFitPixelPairStep, trackingMkFitMixedTripletStep, trackingMkFitPixelLessStep, - trackingMkFitTobTecStep + trackingMkFitTobTecStep, + trackingMkFitDisplacedRegionalStep ) From faf4bc80930a9543c22ffaab66cfa5650b903869 Mon Sep 17 00:00:00 2001 From: Andrew Hart Date: Tue, 31 Jan 2023 18:40:05 -0500 Subject: [PATCH 03/23] Added a workflow for displacedRegional. --- Configuration/PyReleaseValidation/README.md | 1 + .../python/upgradeWorkflowComponents.py | 21 +++++++++++++++++++ 2 files changed, 22 insertions(+) diff --git a/Configuration/PyReleaseValidation/README.md b/Configuration/PyReleaseValidation/README.md index 756cdffc750cc..b67b67479a68c 100644 --- a/Configuration/PyReleaseValidation/README.md +++ b/Configuration/PyReleaseValidation/README.md @@ -51,6 +51,7 @@ The offsets currently in use are: * 0.6: HE Collapse (old depth segmentation for 2018) * 0.601: HLT as separate step * 0.7: trackingMkFit modifier +* 0.71: DisplacedRegionalStep tracking iteration for Run-3 * 0.8: BPH Parking (Run-2) * 0.81: Running also HeavyFlavor DQM * 0.9: Vector hits diff --git a/Configuration/PyReleaseValidation/python/upgradeWorkflowComponents.py b/Configuration/PyReleaseValidation/python/upgradeWorkflowComponents.py index 0cafb088d0b80..e767227c2090b 100644 --- a/Configuration/PyReleaseValidation/python/upgradeWorkflowComponents.py +++ b/Configuration/PyReleaseValidation/python/upgradeWorkflowComponents.py @@ -438,6 +438,27 @@ def condition(self, fragment, stepList, key, hasHarvest): offset = 0.17, ) +#Workflow to enable displacedRegionalStep tracking iteration +class UpgradeWorkflow_displacedRegional(UpgradeWorkflowTracking): + def setup__(self, step, stepName, stepDict, k, properties): + if 'Reco' in step: stepDict[stepName][k] = merge([self.step3, stepDict[step][k]]) + def condition_(self, fragment, stepList, key, hasHarvest): + return '2021' in key +upgradeWFs['displacedRegional'] = UpgradeWorkflow_displacedRegional( + steps = [ + 'Reco', + 'RecoFakeHLT', + 'RecoGlobal', + 'RecoNano', + ], + PU = [], + suffix = '_displacedRegional', + offset = 0.71, +) +upgradeWFs['displacedRegional'].step3 = { + '--procModifiers': 'displacedRegionalStep' +} + # Vector Hits workflows class UpgradeWorkflow_vectorHits(UpgradeWorkflow): def setup_(self, step, stepName, stepDict, k, properties): From d7aaa18e6f7c7789aa180d0a53fc224952ee4bfb Mon Sep 17 00:00:00 2001 From: Andrew Hart Date: Tue, 31 Jan 2023 18:41:07 -0500 Subject: [PATCH 04/23] Pass the trackCluster pointer directly. --- .../interface/DisplacedVertexCluster.h | 2 +- .../plugins/DisplacedRegionSeedingVertexProducer.cc | 2 +- .../src/DisplacedVertexCluster.cc | 8 +++----- 3 files changed, 5 insertions(+), 7 deletions(-) diff --git a/RecoTracker/DisplacedRegionalTracking/interface/DisplacedVertexCluster.h b/RecoTracker/DisplacedRegionalTracking/interface/DisplacedVertexCluster.h index 14f4dd52c7ab3..7c2ab043a7164 100644 --- a/RecoTracker/DisplacedRegionalTracking/interface/DisplacedVertexCluster.h +++ b/RecoTracker/DisplacedRegionalTracking/interface/DisplacedVertexCluster.h @@ -20,7 +20,7 @@ class DisplacedVertexCluster { DisplacedVertexCluster() : valid_(false), rParam2_(kInvalidDouble), sumOfCenters_(0.0, 0.0, 0.0), centerOfMass_(0.0, 0.0, 0.0) {} - DisplacedVertexCluster(const edm::View &, const unsigned, const double); + DisplacedVertexCluster(const reco::VertexCompositeCandidate * const, const double); ~DisplacedVertexCluster() { constituents_.clear(); } diff --git a/RecoTracker/DisplacedRegionalTracking/plugins/DisplacedRegionSeedingVertexProducer.cc b/RecoTracker/DisplacedRegionalTracking/plugins/DisplacedRegionSeedingVertexProducer.cc index 0dd5666595591..9f1ab660fa765 100644 --- a/RecoTracker/DisplacedRegionalTracking/plugins/DisplacedRegionSeedingVertexProducer.cc +++ b/RecoTracker/DisplacedRegionalTracking/plugins/DisplacedRegionSeedingVertexProducer.cc @@ -96,7 +96,7 @@ void DisplacedRegionSeedingVertexProducer::produce(edm::StreamID streamID, const reco::VertexCompositeCandidate &trackCluster = trackClusters[i]; const math::XYZVector x(trackCluster.vertex()); if (minRadius_ < 0.0 || minTrackClusterRadius < 0.0 || (x - bs).rho() > minTrackClusterRadius) - pseudoROIs.emplace_back(trackClusters, i, rParam_); + pseudoROIs.emplace_back(&trackClusters.at(i), rParam_); } if (pseudoROIs.size() > 1) { DisplacedVertexClusterItr secondToLast = pseudoROIs.end(); diff --git a/RecoTracker/DisplacedRegionalTracking/src/DisplacedVertexCluster.cc b/RecoTracker/DisplacedRegionalTracking/src/DisplacedVertexCluster.cc index c30720401946e..9411281407aff 100644 --- a/RecoTracker/DisplacedRegionalTracking/src/DisplacedVertexCluster.cc +++ b/RecoTracker/DisplacedRegionalTracking/src/DisplacedVertexCluster.cc @@ -1,13 +1,11 @@ #include "RecoTracker/DisplacedRegionalTracking/interface/DisplacedVertexCluster.h" -DisplacedVertexCluster::DisplacedVertexCluster(const edm::View &trackClusters, - const unsigned index, +DisplacedVertexCluster::DisplacedVertexCluster(const reco::VertexCompositeCandidate * const trackClusterPtr, const double rParam) : valid_(true), rParam2_(rParam * rParam), - sumOfCenters_(trackClusters.at(index).vertex()), - centerOfMass_(trackClusters.at(index).vertex()) { - const auto trackClusterPtr = &trackClusters.at(index); + sumOfCenters_(trackClusterPtr->vertex()), + centerOfMass_(trackClusterPtr->vertex()) { constituents_.push_back(trackClusterPtr); } From 16e8a80b5a40528363d92e1fa4e9e254f7c586f2 Mon Sep 17 00:00:00 2001 From: Andrew Hart Date: Tue, 31 Jan 2023 18:41:24 -0500 Subject: [PATCH 05/23] Made private members const. --- .../DisplacedRegionSeedingVertexProducer.cc | 14 +++++++------- 1 file changed, 7 insertions(+), 7 deletions(-) diff --git a/RecoTracker/DisplacedRegionalTracking/plugins/DisplacedRegionSeedingVertexProducer.cc b/RecoTracker/DisplacedRegionalTracking/plugins/DisplacedRegionSeedingVertexProducer.cc index 9f1ab660fa765..df2155ced8ffc 100644 --- a/RecoTracker/DisplacedRegionalTracking/plugins/DisplacedRegionSeedingVertexProducer.cc +++ b/RecoTracker/DisplacedRegionalTracking/plugins/DisplacedRegionSeedingVertexProducer.cc @@ -39,16 +39,16 @@ class DisplacedRegionSeedingVertexProducer : public edm::global::EDProducer<> { private: // clustering parameters - double rParam_; + const double rParam_; // selection parameters - double minRadius_; - double discriminatorCut_; - vector input_names_; - vector output_names_; + const double minRadius_; + const double discriminatorCut_; + const vector input_names_; + const vector output_names_; - edm::EDGetTokenT beamSpotToken_; - edm::EDGetTokenT > trackClustersToken_; + const edm::EDGetTokenT beamSpotToken_; + const edm::EDGetTokenT > trackClustersToken_; tensorflow::Session *session_; From a82f39b3c83c05c320d1085758d77d501ebf8e6b Mon Sep 17 00:00:00 2001 From: Andrew Hart Date: Tue, 31 Jan 2023 18:42:44 -0500 Subject: [PATCH 06/23] Added parameter for defining inner and outer tracks. --- RecoVertex/V0Producer/python/generalV0Candidates_cfi.py | 8 ++++++-- RecoVertex/V0Producer/src/V0Fitter.cc | 3 ++- RecoVertex/V0Producer/src/V0Fitter.h | 1 + 3 files changed, 9 insertions(+), 3 deletions(-) diff --git a/RecoVertex/V0Producer/python/generalV0Candidates_cfi.py b/RecoVertex/V0Producer/python/generalV0Candidates_cfi.py index ded8dd7a0fe20..6bc8883c5b1a0 100644 --- a/RecoVertex/V0Producer/python/generalV0Candidates_cfi.py +++ b/RecoVertex/V0Producer/python/generalV0Candidates_cfi.py @@ -56,9 +56,13 @@ # -- miscellaneous cuts -- # allow same-sign pairs of tracks allowSS = cms.bool(False), - # POCA distance between tracks when POCA is less than 5 cm from the z-axis < + # Threshold for inner/outer DCA cuts: + # inner tracks = distance between POCA and z-axis < + # outer tracks = distance between POCA and z-axis >= + innerOuterTkDCAThreshold = cms.double(5.), + # POCA distance between inner tracks < innerTkDCACut = cms.double(1.), - # POCA distance between tracks when POCA is more than 5 cm from the z-axis < + # POCA distance between outer tracks < outerTkDCACut = cms.double(1.), # allow vertices where the angle between the tracks is more than 90 degrees allowWideAngleVtx = cms.bool(False), diff --git a/RecoVertex/V0Producer/src/V0Fitter.cc b/RecoVertex/V0Producer/src/V0Fitter.cc index 33ca4f453f991..f8459978d0f06 100644 --- a/RecoVertex/V0Producer/src/V0Fitter.cc +++ b/RecoVertex/V0Producer/src/V0Fitter.cc @@ -77,6 +77,7 @@ V0Fitter::V0Fitter(const edm::ParameterSet& theParameters, edm::ConsumesCollecto ssVtxDecayXYCut_ = theParameters.getParameter("ssVtxDecayXYCut"); // miscellaneous cuts allowSS_ = theParameters.getParameter("allowSS"); + innerOuterTkDCAThreshold_ = theParameters.getParameter("innerOuterTkDCAThreshold"); innerTkDCACut_ = theParameters.getParameter("innerTkDCACut"); outerTkDCACut_ = theParameters.getParameter("outerTkDCACut"); allowWideAngleVtx_ = theParameters.getParameter("allowWideAngleVtx"); @@ -188,7 +189,7 @@ void V0Fitter::fitAll(const edm::Event& iEvent, if ((cxPt.x() * cxPt.x() + cxPt.y() * cxPt.y()) > 120. * 120. || std::abs(cxPt.z()) > 300.) continue; - if (cxPt.x() * cxPt.x() + cxPt.y() * cxPt.y() < 25.0) { + if (cxPt.x() * cxPt.x() + cxPt.y() * cxPt.y() < innerOuterTkDCAThreshold_) { if (dca > innerTkDCACut_) continue; } else { diff --git a/RecoVertex/V0Producer/src/V0Fitter.h b/RecoVertex/V0Producer/src/V0Fitter.h index 9386081245c20..9864a036547aa 100644 --- a/RecoVertex/V0Producer/src/V0Fitter.h +++ b/RecoVertex/V0Producer/src/V0Fitter.h @@ -68,6 +68,7 @@ class dso_hidden V0Fitter { double ssVtxDecayXYCut_; // miscellaneous cuts bool allowSS_; + double innerOuterTkDCAThreshold_; double innerTkDCACut_; double outerTkDCACut_; bool allowWideAngleVtx_; From 8382c9270f33f1e8d97989efc2555f92cedb3ee1 Mon Sep 17 00:00:00 2001 From: Andrew Hart Date: Tue, 31 Jan 2023 19:19:04 -0500 Subject: [PATCH 07/23] Code format. --- .../interface/DisplacedVertexCluster.h | 2 +- .../DisplacedRegionalTracking/src/DisplacedVertexCluster.cc | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/RecoTracker/DisplacedRegionalTracking/interface/DisplacedVertexCluster.h b/RecoTracker/DisplacedRegionalTracking/interface/DisplacedVertexCluster.h index 7c2ab043a7164..35629a52e2158 100644 --- a/RecoTracker/DisplacedRegionalTracking/interface/DisplacedVertexCluster.h +++ b/RecoTracker/DisplacedRegionalTracking/interface/DisplacedVertexCluster.h @@ -20,7 +20,7 @@ class DisplacedVertexCluster { DisplacedVertexCluster() : valid_(false), rParam2_(kInvalidDouble), sumOfCenters_(0.0, 0.0, 0.0), centerOfMass_(0.0, 0.0, 0.0) {} - DisplacedVertexCluster(const reco::VertexCompositeCandidate * const, const double); + DisplacedVertexCluster(const reco::VertexCompositeCandidate *const, const double); ~DisplacedVertexCluster() { constituents_.clear(); } diff --git a/RecoTracker/DisplacedRegionalTracking/src/DisplacedVertexCluster.cc b/RecoTracker/DisplacedRegionalTracking/src/DisplacedVertexCluster.cc index 9411281407aff..3b22f6600c632 100644 --- a/RecoTracker/DisplacedRegionalTracking/src/DisplacedVertexCluster.cc +++ b/RecoTracker/DisplacedRegionalTracking/src/DisplacedVertexCluster.cc @@ -1,6 +1,6 @@ #include "RecoTracker/DisplacedRegionalTracking/interface/DisplacedVertexCluster.h" -DisplacedVertexCluster::DisplacedVertexCluster(const reco::VertexCompositeCandidate * const trackClusterPtr, +DisplacedVertexCluster::DisplacedVertexCluster(const reco::VertexCompositeCandidate *const trackClusterPtr, const double rParam) : valid_(true), rParam2_(rParam * rParam), From 2d270ae305aa32bfd419e6a073faf3288408cf24 Mon Sep 17 00:00:00 2001 From: Andrew Hart Date: Wed, 1 Feb 2023 10:29:34 -0500 Subject: [PATCH 08/23] Just use default destructor. Co-authored-by: Matti Kortelainen --- .../interface/DisplacedVertexCluster.h | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/RecoTracker/DisplacedRegionalTracking/interface/DisplacedVertexCluster.h b/RecoTracker/DisplacedRegionalTracking/interface/DisplacedVertexCluster.h index 35629a52e2158..c66a0c44d00ae 100644 --- a/RecoTracker/DisplacedRegionalTracking/interface/DisplacedVertexCluster.h +++ b/RecoTracker/DisplacedRegionalTracking/interface/DisplacedVertexCluster.h @@ -22,7 +22,7 @@ class DisplacedVertexCluster { DisplacedVertexCluster(const reco::VertexCompositeCandidate *const, const double); - ~DisplacedVertexCluster() { constituents_.clear(); } + ~DisplacedVertexCluster() = default; bool valid() const { return valid_; } double rParam2() const { return rParam2_; } From dfd2135184d6fd499d4f0739e284a5ba51cd3c63 Mon Sep 17 00:00:00 2001 From: Andrew Hart Date: Wed, 1 Feb 2023 10:30:41 -0500 Subject: [PATCH 09/23] Use Python boolean directly. Co-authored-by: Andrea Perrotta --- .../IterativeTracking/python/DisplacedRegionalStep_cff.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/RecoTracker/IterativeTracking/python/DisplacedRegionalStep_cff.py b/RecoTracker/IterativeTracking/python/DisplacedRegionalStep_cff.py index 1b139ecdd240c..83f75e9107c61 100644 --- a/RecoTracker/IterativeTracking/python/DisplacedRegionalStep_cff.py +++ b/RecoTracker/IterativeTracking/python/DisplacedRegionalStep_cff.py @@ -88,7 +88,7 @@ from RecoPixelVertexing.PixelLowPtUtilities.ClusterShapeHitFilterESProducer_cfi import ClusterShapeHitFilterESProducer as _ClusterShapeHitFilterESProducer displacedRegionalStepClusterShapeHitFilter = _ClusterShapeHitFilterESProducer.clone( ComponentName = 'displacedRegionalStepClusterShapeHitFilter', - doStripShapeCut = cms.bool(False), + doStripShapeCut = False, clusterChargeCut = dict(refToPSet_ = 'SiStripClusterChargeCutTight') ) From 3a5763c2df55f7a19de53890e820ebbca927433e Mon Sep 17 00:00:00 2001 From: Andrew Hart Date: Wed, 1 Feb 2023 10:35:54 -0500 Subject: [PATCH 10/23] No need for extra if statement. Co-authored-by: Andrea Perrotta --- RecoVertex/V0Producer/src/V0Fitter.cc | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/RecoVertex/V0Producer/src/V0Fitter.cc b/RecoVertex/V0Producer/src/V0Fitter.cc index f8459978d0f06..fcdfe54616046 100644 --- a/RecoVertex/V0Producer/src/V0Fitter.cc +++ b/RecoVertex/V0Producer/src/V0Fitter.cc @@ -226,7 +226,7 @@ void V0Fitter::fitAll(const edm::Event& iEvent, if (vertexFitter_) { KalmanVertexFitter theKalmanFitter(useRefTracks_ == 0 ? false : true); theRecoVertex = theKalmanFitter.vertex(transTracks); - } else if (!vertexFitter_) { + } else { useRefTracks_ = false; AdaptiveVertexFitter theAdaptiveFitter; theRecoVertex = theAdaptiveFitter.vertex(transTracks); From 147eb78da699a8015da6ab07090bfe7ce84ba70b Mon Sep 17 00:00:00 2001 From: Andrew Hart Date: Wed, 1 Feb 2023 10:37:29 -0500 Subject: [PATCH 11/23] Calculate sigmaDistMagXY only if needed. Co-authored-by: Andrea Perrotta --- RecoVertex/V0Producer/src/V0Fitter.cc | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/RecoVertex/V0Producer/src/V0Fitter.cc b/RecoVertex/V0Producer/src/V0Fitter.cc index fcdfe54616046..054e8abc97935 100644 --- a/RecoVertex/V0Producer/src/V0Fitter.cc +++ b/RecoVertex/V0Producer/src/V0Fitter.cc @@ -246,13 +246,13 @@ void V0Fitter::fitAll(const edm::Event& iEvent, totalCov = referenceVtx.covariance() + theVtx.covariance(); SVector3 distVecXY(vtxPos.x() - referencePos.x(), vtxPos.y() - referencePos.y(), 0.); double distMagXY = ROOT::Math::Mag(distVecXY); - double sigmaDistMagXY = sqrt(ROOT::Math::Similarity(totalCov, distVecXY)) / distMagXY; - if (distMagXY / sigmaDistMagXY < vtxDecaySigXYCut_) - continue; if (distMagXY < vtxDecayXYCut_) continue; if (posTransTkPtr->charge() * negTransTkPtr->charge() > 0 && distMagXY < ssVtxDecayXYCut_) continue; + double sigmaDistMagXY = sqrt(ROOT::Math::Similarity(totalCov, distVecXY)) / distMagXY; + if (distMagXY < vtxDecaySigXYCut_ * sigmaDistMagXY) + continue; // 3D decay significance if (vtxDecaySigXYZCut_ > 0.) { From 98a11b8e3ffbcd3b5ec8f53c99ef62fea8769464 Mon Sep 17 00:00:00 2001 From: Andrew Hart Date: Wed, 1 Feb 2023 10:28:59 -0500 Subject: [PATCH 12/23] Updated offset to 0.701. --- Configuration/PyReleaseValidation/README.md | 2 +- .../PyReleaseValidation/python/upgradeWorkflowComponents.py | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/Configuration/PyReleaseValidation/README.md b/Configuration/PyReleaseValidation/README.md index b67b67479a68c..f124270a5749a 100644 --- a/Configuration/PyReleaseValidation/README.md +++ b/Configuration/PyReleaseValidation/README.md @@ -51,7 +51,7 @@ The offsets currently in use are: * 0.6: HE Collapse (old depth segmentation for 2018) * 0.601: HLT as separate step * 0.7: trackingMkFit modifier -* 0.71: DisplacedRegionalStep tracking iteration for Run-3 +* 0.701: DisplacedRegionalStep tracking iteration for Run-3 * 0.8: BPH Parking (Run-2) * 0.81: Running also HeavyFlavor DQM * 0.9: Vector hits diff --git a/Configuration/PyReleaseValidation/python/upgradeWorkflowComponents.py b/Configuration/PyReleaseValidation/python/upgradeWorkflowComponents.py index e767227c2090b..3548599317d9e 100644 --- a/Configuration/PyReleaseValidation/python/upgradeWorkflowComponents.py +++ b/Configuration/PyReleaseValidation/python/upgradeWorkflowComponents.py @@ -453,7 +453,7 @@ def condition_(self, fragment, stepList, key, hasHarvest): ], PU = [], suffix = '_displacedRegional', - offset = 0.71, + offset = 0.701, ) upgradeWFs['displacedRegional'].step3 = { '--procModifiers': 'displacedRegionalStep' From 7b74c0360ede83f123ec4489a9a2593538c9d98e Mon Sep 17 00:00:00 2001 From: Andrew Hart Date: Wed, 1 Feb 2023 10:39:06 -0500 Subject: [PATCH 13/23] Fixed bug with threshold and only compute cxPtR2 once. --- RecoVertex/V0Producer/src/V0Fitter.cc | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-) diff --git a/RecoVertex/V0Producer/src/V0Fitter.cc b/RecoVertex/V0Producer/src/V0Fitter.cc index 054e8abc97935..ba75035ef00d7 100644 --- a/RecoVertex/V0Producer/src/V0Fitter.cc +++ b/RecoVertex/V0Producer/src/V0Fitter.cc @@ -186,10 +186,12 @@ void V0Fitter::fitAll(const edm::Event& iEvent, // the POCA should at least be in the sensitive volume GlobalPoint cxPt = cApp.crossingPoint(); - if ((cxPt.x() * cxPt.x() + cxPt.y() * cxPt.y()) > 120. * 120. || std::abs(cxPt.z()) > 300.) + const double cxPtR2 = cxPt.x() * cxPt.x() + cxPt.y() * cxPt.y(); + if (cxPtR2 > 120. * 120. || std::abs(cxPt.z()) > 300.) continue; - if (cxPt.x() * cxPt.x() + cxPt.y() * cxPt.y() < innerOuterTkDCAThreshold_) { + // allow for different DCA cuts depending on position of POCA + if (cxPtR2 < innerOuterTkDCAThreshold_ * innerOuterTkDCAThreshold_) { if (dca > innerTkDCACut_) continue; } else { From a37a412aa9ef463d57ba1aed033b5b9822eaa69e Mon Sep 17 00:00:00 2001 From: Andrew Hart Date: Wed, 1 Feb 2023 10:39:26 -0500 Subject: [PATCH 14/23] Fixed name of process modifier. --- .../PyReleaseValidation/python/upgradeWorkflowComponents.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Configuration/PyReleaseValidation/python/upgradeWorkflowComponents.py b/Configuration/PyReleaseValidation/python/upgradeWorkflowComponents.py index 3548599317d9e..d76c84e2acf79 100644 --- a/Configuration/PyReleaseValidation/python/upgradeWorkflowComponents.py +++ b/Configuration/PyReleaseValidation/python/upgradeWorkflowComponents.py @@ -456,7 +456,7 @@ def condition_(self, fragment, stepList, key, hasHarvest): offset = 0.701, ) upgradeWFs['displacedRegional'].step3 = { - '--procModifiers': 'displacedRegionalStep' + '--procModifiers': 'displacedRegionalTracking' } # Vector Hits workflows From 67a2dd15ad57df3df4ee7aff1c8b77e4e137f209 Mon Sep 17 00:00:00 2001 From: Andrew Hart Date: Thu, 2 Feb 2023 17:32:07 -0500 Subject: [PATCH 15/23] Moved DisplacedVertexCluster files into plugins/. --- RecoTracker/DisplacedRegionalTracking/BuildFile.xml | 11 ----------- .../DisplacedRegionalTracking/plugins/BuildFile.xml | 6 +++++- .../plugins/DisplacedRegionSeedingVertexProducer.cc | 2 +- .../{src => plugins}/DisplacedVertexCluster.cc | 2 +- .../{interface => plugins}/DisplacedVertexCluster.h | 0 5 files changed, 7 insertions(+), 14 deletions(-) delete mode 100644 RecoTracker/DisplacedRegionalTracking/BuildFile.xml rename RecoTracker/DisplacedRegionalTracking/{src => plugins}/DisplacedVertexCluster.cc (91%) rename RecoTracker/DisplacedRegionalTracking/{interface => plugins}/DisplacedVertexCluster.h (100%) diff --git a/RecoTracker/DisplacedRegionalTracking/BuildFile.xml b/RecoTracker/DisplacedRegionalTracking/BuildFile.xml deleted file mode 100644 index 332974b5ad00a..0000000000000 --- a/RecoTracker/DisplacedRegionalTracking/BuildFile.xml +++ /dev/null @@ -1,11 +0,0 @@ - - - - - - - - - - - diff --git a/RecoTracker/DisplacedRegionalTracking/plugins/BuildFile.xml b/RecoTracker/DisplacedRegionalTracking/plugins/BuildFile.xml index 7a40b9636ce99..8895fff655cf5 100644 --- a/RecoTracker/DisplacedRegionalTracking/plugins/BuildFile.xml +++ b/RecoTracker/DisplacedRegionalTracking/plugins/BuildFile.xml @@ -1,11 +1,15 @@ + + - + + + diff --git a/RecoTracker/DisplacedRegionalTracking/plugins/DisplacedRegionSeedingVertexProducer.cc b/RecoTracker/DisplacedRegionalTracking/plugins/DisplacedRegionSeedingVertexProducer.cc index df2155ced8ffc..b4a3f77f1633e 100644 --- a/RecoTracker/DisplacedRegionalTracking/plugins/DisplacedRegionSeedingVertexProducer.cc +++ b/RecoTracker/DisplacedRegionalTracking/plugins/DisplacedRegionSeedingVertexProducer.cc @@ -24,7 +24,7 @@ #include "PhysicsTools/TensorFlow/interface/TensorFlow.h" -#include "RecoTracker/DisplacedRegionalTracking/interface/DisplacedVertexCluster.h" +#include "RecoTracker/DisplacedRegionalTracking/plugins/DisplacedVertexCluster.h" using namespace std; typedef DisplacedVertexCluster::Distance Distance; diff --git a/RecoTracker/DisplacedRegionalTracking/src/DisplacedVertexCluster.cc b/RecoTracker/DisplacedRegionalTracking/plugins/DisplacedVertexCluster.cc similarity index 91% rename from RecoTracker/DisplacedRegionalTracking/src/DisplacedVertexCluster.cc rename to RecoTracker/DisplacedRegionalTracking/plugins/DisplacedVertexCluster.cc index 3b22f6600c632..5b9b1832d1dfd 100644 --- a/RecoTracker/DisplacedRegionalTracking/src/DisplacedVertexCluster.cc +++ b/RecoTracker/DisplacedRegionalTracking/plugins/DisplacedVertexCluster.cc @@ -1,4 +1,4 @@ -#include "RecoTracker/DisplacedRegionalTracking/interface/DisplacedVertexCluster.h" +#include "RecoTracker/DisplacedRegionalTracking/plugins/DisplacedVertexCluster.h" DisplacedVertexCluster::DisplacedVertexCluster(const reco::VertexCompositeCandidate *const trackClusterPtr, const double rParam) diff --git a/RecoTracker/DisplacedRegionalTracking/interface/DisplacedVertexCluster.h b/RecoTracker/DisplacedRegionalTracking/plugins/DisplacedVertexCluster.h similarity index 100% rename from RecoTracker/DisplacedRegionalTracking/interface/DisplacedVertexCluster.h rename to RecoTracker/DisplacedRegionalTracking/plugins/DisplacedVertexCluster.h From 5fbe7f96dcf3edde28b8e32e77cb18452ffd337a Mon Sep 17 00:00:00 2001 From: Andrew Hart Date: Thu, 2 Feb 2023 18:04:03 -0500 Subject: [PATCH 16/23] Cleaned up BuildFile. --- RecoTracker/DisplacedRegionalTracking/plugins/BuildFile.xml | 5 ----- 1 file changed, 5 deletions(-) diff --git a/RecoTracker/DisplacedRegionalTracking/plugins/BuildFile.xml b/RecoTracker/DisplacedRegionalTracking/plugins/BuildFile.xml index 8895fff655cf5..ed4fb5e1656c9 100644 --- a/RecoTracker/DisplacedRegionalTracking/plugins/BuildFile.xml +++ b/RecoTracker/DisplacedRegionalTracking/plugins/BuildFile.xml @@ -1,15 +1,10 @@ - - - - - From 50204a82df069d3c461a4f666950ebfffb36b9d4 Mon Sep 17 00:00:00 2001 From: Andrew Hart Date: Fri, 3 Feb 2023 13:22:02 -0500 Subject: [PATCH 17/23] Dropped TOB1+TOB2+MTOB4. --- .../IterativeTracking/python/DisplacedRegionalStep_cff.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/RecoTracker/IterativeTracking/python/DisplacedRegionalStep_cff.py b/RecoTracker/IterativeTracking/python/DisplacedRegionalStep_cff.py index 83f75e9107c61..47f60828c5375 100644 --- a/RecoTracker/IterativeTracking/python/DisplacedRegionalStep_cff.py +++ b/RecoTracker/IterativeTracking/python/DisplacedRegionalStep_cff.py @@ -23,7 +23,7 @@ displacedRegionalStepSeedLayersTripl = _mod.seedingLayersEDProducer.clone( layerList = [ #TOB - 'TOB1+TOB2+MTOB3','TOB1+TOB2+MTOB4', + 'TOB1+TOB2+MTOB3', #TOB+MTEC 'TOB1+TOB2+MTEC1_pos','TOB1+TOB2+MTEC1_neg', ], From e9985f41ac36708c3c543fb7839847f620f03d47 Mon Sep 17 00:00:00 2001 From: Andrew Hart Date: Fri, 10 Feb 2023 18:12:26 -0500 Subject: [PATCH 18/23] Removed deprecated "thread pool" argument. --- .../plugins/DisplacedRegionSeedingVertexProducer.cc | 4 +--- 1 file changed, 1 insertion(+), 3 deletions(-) diff --git a/RecoTracker/DisplacedRegionalTracking/plugins/DisplacedRegionSeedingVertexProducer.cc b/RecoTracker/DisplacedRegionalTracking/plugins/DisplacedRegionSeedingVertexProducer.cc index b4a3f77f1633e..008f2aefaf79c 100644 --- a/RecoTracker/DisplacedRegionalTracking/plugins/DisplacedRegionSeedingVertexProducer.cc +++ b/RecoTracker/DisplacedRegionalTracking/plugins/DisplacedRegionSeedingVertexProducer.cc @@ -65,9 +65,8 @@ DisplacedRegionSeedingVertexProducer::DisplacedRegionSeedingVertexProducer(const trackClustersToken_( consumes >(cfg.getParameter("trackClusters"))) { unsigned nThreads = cfg.getParameter("nThreads"); - string singleThreadPool = cfg.getParameter("singleThreadPool"); tensorflow::SessionOptions sessionOptions; - tensorflow::setThreading(sessionOptions, nThreads, singleThreadPool); + tensorflow::setThreading(sessionOptions, nThreads); string pbFile = cfg.getParameter("graph_path").fullPath(); auto graphDef = tensorflow::loadGraphDef(pbFile); session_ = tensorflow::createSession(graphDef, sessionOptions); @@ -168,7 +167,6 @@ void DisplacedRegionSeedingVertexProducer::fillDescriptions(edm::ConfigurationDe desc.add >("input_names", {"phi_0", "phi_1"}); desc.add >("output_names", {"model_5/activation_10/Softmax"}); desc.add("nThreads", 1); - desc.add("singleThreadPool", "no_threads"); desc.add( "graph_path", edm::FileInPath( From 2df7a27cab5d7f17fcf1ef1557dc3e7c8ced1530 Mon Sep 17 00:00:00 2001 From: Andrew Hart Date: Fri, 10 Feb 2023 18:32:15 -0500 Subject: [PATCH 19/23] Made nThreads an untracked parameter. --- .../plugins/DisplacedRegionSeedingVertexProducer.cc | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/RecoTracker/DisplacedRegionalTracking/plugins/DisplacedRegionSeedingVertexProducer.cc b/RecoTracker/DisplacedRegionalTracking/plugins/DisplacedRegionSeedingVertexProducer.cc index 008f2aefaf79c..027a06df16095 100644 --- a/RecoTracker/DisplacedRegionalTracking/plugins/DisplacedRegionSeedingVertexProducer.cc +++ b/RecoTracker/DisplacedRegionalTracking/plugins/DisplacedRegionSeedingVertexProducer.cc @@ -64,7 +64,7 @@ DisplacedRegionSeedingVertexProducer::DisplacedRegionSeedingVertexProducer(const beamSpotToken_(consumes(cfg.getParameter("beamSpot"))), trackClustersToken_( consumes >(cfg.getParameter("trackClusters"))) { - unsigned nThreads = cfg.getParameter("nThreads"); + unsigned nThreads = cfg.getUntrackedParameter("nThreads"); tensorflow::SessionOptions sessionOptions; tensorflow::setThreading(sessionOptions, nThreads); string pbFile = cfg.getParameter("graph_path").fullPath(); @@ -166,7 +166,7 @@ void DisplacedRegionSeedingVertexProducer::fillDescriptions(edm::ConfigurationDe desc.add("discriminatorCut", -1.0); desc.add >("input_names", {"phi_0", "phi_1"}); desc.add >("output_names", {"model_5/activation_10/Softmax"}); - desc.add("nThreads", 1); + desc.addUntracked("nThreads", 1); desc.add( "graph_path", edm::FileInPath( From ab227d64b8d31779bf10d7748ccd98df76bcc0f6 Mon Sep 17 00:00:00 2001 From: Andrew Hart Date: Tue, 14 Feb 2023 18:24:40 -0500 Subject: [PATCH 20/23] Added near and far threshold parameters. --- .../DisplacedRegionSeedingVertexProducer.cc | 26 ++++++++++++++----- 1 file changed, 20 insertions(+), 6 deletions(-) diff --git a/RecoTracker/DisplacedRegionalTracking/plugins/DisplacedRegionSeedingVertexProducer.cc b/RecoTracker/DisplacedRegionalTracking/plugins/DisplacedRegionSeedingVertexProducer.cc index 027a06df16095..fc6e3c14a58e0 100644 --- a/RecoTracker/DisplacedRegionalTracking/plugins/DisplacedRegionSeedingVertexProducer.cc +++ b/RecoTracker/DisplacedRegionalTracking/plugins/DisplacedRegionSeedingVertexProducer.cc @@ -43,6 +43,8 @@ class DisplacedRegionSeedingVertexProducer : public edm::global::EDProducer<> { // selection parameters const double minRadius_; + const double nearThreshold_; + const double farThreshold_; const double discriminatorCut_; const vector input_names_; const vector output_names_; @@ -58,6 +60,8 @@ class DisplacedRegionSeedingVertexProducer : public edm::global::EDProducer<> { DisplacedRegionSeedingVertexProducer::DisplacedRegionSeedingVertexProducer(const edm::ParameterSet &cfg) : rParam_(cfg.getParameter("rParam")), minRadius_(cfg.getParameter("minRadius")), + nearThreshold_(cfg.getParameter("nearThreshold")), + farThreshold_(cfg.getParameter("farThreshold")), discriminatorCut_(cfg.getParameter("discriminatorCut")), input_names_(cfg.getParameter >("input_names")), output_names_(cfg.getParameter >("output_names")), @@ -71,7 +75,8 @@ DisplacedRegionSeedingVertexProducer::DisplacedRegionSeedingVertexProducer(const auto graphDef = tensorflow::loadGraphDef(pbFile); session_ = tensorflow::createSession(graphDef, sessionOptions); - produces >(); + produces >("nearRegionsOfInterest"); + produces >("farRegionsOfInterest"); } DisplacedRegionSeedingVertexProducer::~DisplacedRegionSeedingVertexProducer() { @@ -137,7 +142,7 @@ void DisplacedRegionSeedingVertexProducer::produce(edm::StreamID streamID, const auto roiPred = [&](const DisplacedVertexCluster &roi) { if (!roi.valid()) return true; - const math::XYZVector &x(roi.centerOfMass()); + const auto &x(roi.centerOfMass()); if ((x - bs).rho() < minRadius_) return true; const double discriminatorValue = ((discriminatorCut_ > 0.0) ? getDiscriminatorValue(roi, beamSpot) : 1.0); @@ -147,15 +152,22 @@ void DisplacedRegionSeedingVertexProducer::produce(edm::StreamID streamID, }; pseudoROIs.remove_if(roiPred); - auto regionsOfInterest = make_unique >(); + auto nearRegionsOfInterest = make_unique >(); + auto farRegionsOfInterest = make_unique >(); constexpr std::array errorA{{1.0, 0.0, 1.0, 0.0, 0.0, 1.0}}; static const reco::Vertex::Error errorRegion(errorA.begin(), errorA.end(), true, true); - for (const auto &roi : pseudoROIs) - regionsOfInterest->emplace_back(reco::Vertex::Point(roi.centerOfMass()), errorRegion); + for (const auto &roi : pseudoROIs) { + const auto &x(roi.centerOfMass()); + if ((x - bs).rho() < nearThreshold_) + nearRegionsOfInterest->emplace_back(reco::Vertex::Point(roi.centerOfMass()), errorRegion); + if ((x - bs).rho() > farThreshold_) + farRegionsOfInterest->emplace_back(reco::Vertex::Point(roi.centerOfMass()), errorRegion); + } - event.put(move(regionsOfInterest)); + event.put(move(nearRegionsOfInterest), "nearRegionsOfInterest"); + event.put(move(farRegionsOfInterest), "farRegionsOfInterest"); } void DisplacedRegionSeedingVertexProducer::fillDescriptions(edm::ConfigurationDescriptions &descriptions) { @@ -163,6 +175,8 @@ void DisplacedRegionSeedingVertexProducer::fillDescriptions(edm::ConfigurationDe desc.add("rParam", 1.0); desc.add("minRadius", -1.0); + desc.add("nearThreshold", 9999.0); + desc.add("farThreshold", -1.0); desc.add("discriminatorCut", -1.0); desc.add >("input_names", {"phi_0", "phi_1"}); desc.add >("output_names", {"model_5/activation_10/Softmax"}); From 5dbcab5d5f26e9ad4c492f16aeb1b1cee31a0e74 Mon Sep 17 00:00:00 2001 From: Andrew Hart Date: Tue, 28 Mar 2023 15:40:29 -0400 Subject: [PATCH 21/23] Current best config file. --- .../python/DisplacedRegionalStep_cff.py | 150 +++++++++++++++--- 1 file changed, 126 insertions(+), 24 deletions(-) diff --git a/RecoTracker/IterativeTracking/python/DisplacedRegionalStep_cff.py b/RecoTracker/IterativeTracking/python/DisplacedRegionalStep_cff.py index 47f60828c5375..c588b0f81c6ad 100644 --- a/RecoTracker/IterativeTracking/python/DisplacedRegionalStep_cff.py +++ b/RecoTracker/IterativeTracking/python/DisplacedRegionalStep_cff.py @@ -23,7 +23,7 @@ displacedRegionalStepSeedLayersTripl = _mod.seedingLayersEDProducer.clone( layerList = [ #TOB - 'TOB1+TOB2+MTOB3', + 'TOB1+TOB2+MTOB3',#'TOB1+TOB2+MTOB4', #TOB+MTEC 'TOB1+TOB2+MTEC1_pos','TOB1+TOB2+MTEC1_neg', ], @@ -70,17 +70,19 @@ ) displacedRegionalStepSeedingVertices = _displacedRegionProducer.clone( minRadius = 2.0, + nearThreshold = 20.0, + farThreshold = -1.0, discriminatorCut = 0.5, trackClusters = ["displacedRegionalStepSeedingV0Candidates", "Kshort"], ) from RecoTracker.TkTrackingRegions.globalTrackingRegionWithVertices_cfi import globalTrackingRegionWithVertices as _globalTrackingRegionWithVertices -displacedRegionalStepTrackingRegionsTripl = _globalTrackingRegionWithVertices.clone(RegionPSet = dict( +displacedRegionalStepFarTrackingRegions = _globalTrackingRegionWithVertices.clone(RegionPSet = dict( originRadius = 1.0, fixedError = 1.0, - VertexCollection = "displacedRegionalStepSeedingVertices", + VertexCollection = ["displacedRegionalStepSeedingVertices", "farRegionsOfInterest"], useFakeVertices = True, - ptMin = 0.55, + ptMin = 0.6, allowEmpty = True )) @@ -95,7 +97,7 @@ from RecoTracker.TkHitPairs.hitPairEDProducer_cfi import hitPairEDProducer as _hitPairEDProducer displacedRegionalStepHitDoubletsTripl = _hitPairEDProducer.clone( seedingLayers = "displacedRegionalStepSeedLayersTripl", - trackingRegions = "displacedRegionalStepTrackingRegionsTripl", + trackingRegions = "displacedRegionalStepFarTrackingRegions", maxElement = 50000000, produceIntermediateHitDoublets = True, ) @@ -131,12 +133,12 @@ # PAIR SEEDING LAYERS displacedRegionalStepSeedLayersPair = _mod.seedingLayersEDProducer.clone( - layerList = ['TOB1+TEC1_pos','TOB1+TEC1_neg', - 'TEC1_pos+TEC2_pos','TEC1_neg+TEC2_neg', - 'TEC2_pos+TEC3_pos','TEC2_neg+TEC3_neg', - 'TEC3_pos+TEC4_pos','TEC3_neg+TEC4_neg', - 'TEC4_pos+TEC5_pos','TEC4_neg+TEC5_neg', - 'TEC5_pos+TEC6_pos','TEC5_neg+TEC6_neg', + layerList = ['TOB1+TEC1_pos','TOB1+TEC1_neg', + 'TEC1_pos+TEC2_pos','TEC1_neg+TEC2_neg', + 'TEC2_pos+TEC3_pos','TEC2_neg+TEC3_neg', + 'TEC3_pos+TEC4_pos','TEC3_neg+TEC4_neg', + 'TEC4_pos+TEC5_pos','TEC4_neg+TEC5_neg', + 'TEC5_pos+TEC6_pos','TEC5_neg+TEC6_neg', 'TEC6_pos+TEC7_pos','TEC6_neg+TEC7_neg'], TOB = dict( TTRHBuilder = cms.string('WithTrackAngle'), @@ -154,20 +156,12 @@ maxRing = cms.int32(5) ) ) -# Pair TrackingRegion -displacedRegionalStepTrackingRegionsPair = _globalTrackingRegionWithVertices.clone(RegionPSet = dict( - originRadius = 1.0, - fixedError = 1.0, - VertexCollection = "displacedRegionalStepSeedingVertices", - useFakeVertices = True, - ptMin = 0.6, - allowEmpty = True -)) + # Pair seeds displacedRegionalStepHitDoubletsPair = _hitPairEDProducer.clone( seedingLayers = "displacedRegionalStepSeedLayersPair", - trackingRegions = "displacedRegionalStepTrackingRegionsPair", + trackingRegions = "displacedRegionalStepFarTrackingRegions", produceSeedingHitSets = True, maxElementTotal = 12000000, ) @@ -177,10 +171,114 @@ SeedComparitorPSet = _displacedRegionalStepSeedComparitorPSet, ) +# FROM PIXELLESS +displacedRegionalStepPLSeedLayersTripl = _mod.seedingLayersEDProducer.clone( + layerList = [ + #TIB + 'TIB1+TIB2+MTIB3',#'TIB1+TIB2+MTIB4', + #TIB+TID + 'TIB1+TIB2+MTID1_pos','TIB1+TIB2+MTID1_neg', + #TID + 'TID1_pos+TID2_pos+TID3_pos','TID1_neg+TID2_neg+TID3_neg',#ring 1-2 (matched) + 'TID1_pos+TID2_pos+MTID3_pos','TID1_neg+TID2_neg+MTID3_neg',#ring 3 (mono) + 'TID1_pos+TID2_pos+MTEC1_pos','TID1_neg+TID2_neg+MTEC1_neg', + #TID+TEC RING 1-3 + 'TID2_pos+TID3_pos+TEC1_pos','TID2_neg+TID3_neg+TEC1_neg',#ring 1-2 (matched) + 'TID2_pos+TID3_pos+MTEC1_pos','TID2_neg+TID3_neg+MTEC1_neg',#ring 3 (mono) + #TEC RING 1-3 + #'TEC1_pos+TEC2_pos+TEC3_pos', 'TEC1_neg+TEC2_neg+TEC3_neg', + #'TEC1_pos+TEC2_pos+MTEC3_pos','TEC1_neg+TEC2_neg+MTEC3_neg', + #'TEC1_pos+TEC2_pos+TEC4_pos', 'TEC1_neg+TEC2_neg+TEC4_neg', + #'TEC1_pos+TEC2_pos+MTEC4_pos','TEC1_neg+TEC2_neg+MTEC4_neg', + #'TEC2_pos+TEC3_pos+TEC4_pos', 'TEC2_neg+TEC3_neg+TEC4_neg', + #'TEC2_pos+TEC3_pos+MTEC4_pos','TEC2_neg+TEC3_neg+MTEC4_neg', + #'TEC2_pos+TEC3_pos+TEC5_pos', 'TEC2_neg+TEC3_neg+TEC5_neg', + #'TEC2_pos+TEC3_pos+TEC6_pos', 'TEC2_neg+TEC3_neg+TEC6_neg', + #'TEC3_pos+TEC4_pos+TEC5_pos', 'TEC3_neg+TEC4_neg+TEC5_neg', + #'TEC3_pos+TEC4_pos+MTEC5_pos','TEC3_neg+TEC4_neg+MTEC5_neg', + #'TEC3_pos+TEC5_pos+TEC6_pos', 'TEC3_neg+TEC5_neg+TEC6_neg', + #'TEC4_pos+TEC5_pos+TEC6_pos', 'TEC4_neg+TEC5_neg+TEC6_neg' + ], + TIB = dict( + TTRHBuilder = cms.string('WithTrackAngle'), + clusterChargeCut = cms.PSet(refToPSet_ = cms.string('SiStripClusterChargeCutTight')), + matchedRecHits = cms.InputTag('siStripMatchedRecHits','matchedRecHit'), + skipClusters = cms.InputTag('displacedRegionalStepClusters') + ), + MTIB = dict( + TTRHBuilder = cms.string('WithTrackAngle'), + clusterChargeCut = cms.PSet(refToPSet_ = cms.string('SiStripClusterChargeCutTight')), + skipClusters = cms.InputTag('displacedRegionalStepClusters'), + rphiRecHits = cms.InputTag('siStripMatchedRecHits','rphiRecHit') + ), + TID = dict( + matchedRecHits = cms.InputTag('siStripMatchedRecHits','matchedRecHit'), + skipClusters = cms.InputTag('displacedRegionalStepClusters'), + useRingSlector = cms.bool(True), + TTRHBuilder = cms.string('WithTrackAngle'), + clusterChargeCut = cms.PSet(refToPSet_ = cms.string('SiStripClusterChargeCutTight')), + minRing = cms.int32(1), + maxRing = cms.int32(2) + ), + MTID = dict( + rphiRecHits = cms.InputTag('siStripMatchedRecHits','rphiRecHit'), + skipClusters = cms.InputTag('displacedRegionalStepClusters'), + useRingSlector = cms.bool(True), + TTRHBuilder = cms.string('WithTrackAngle'), + clusterChargeCut = cms.PSet(refToPSet_ = cms.string('SiStripClusterChargeCutTight')), + minRing = cms.int32(3), + maxRing = cms.int32(3) + ), + TEC = dict( + matchedRecHits = cms.InputTag('siStripMatchedRecHits','matchedRecHit'), + skipClusters = cms.InputTag('displacedRegionalStepClusters'), + useRingSlector = cms.bool(True), + TTRHBuilder = cms.string('WithTrackAngle'), + clusterChargeCut = cms.PSet(refToPSet_ = cms.string('SiStripClusterChargeCutTight')), + minRing = cms.int32(1), + maxRing = cms.int32(2) + ), + MTEC = dict( + rphiRecHits = cms.InputTag('siStripMatchedRecHits','rphiRecHit'), + skipClusters = cms.InputTag('displacedRegionalStepClusters'), + useRingSlector = cms.bool(True), + TTRHBuilder = cms.string('WithTrackAngle'), + clusterChargeCut = cms.PSet(refToPSet_ = cms.string('SiStripClusterChargeCutTight')), + minRing = cms.int32(3), + maxRing = cms.int32(3) + ) +) + +# Pair TrackingRegion +displacedRegionalStepNearTrackingRegions = _globalTrackingRegionWithVertices.clone(RegionPSet = dict( + originRadius = 1.0, + fixedError = 1.0, + VertexCollection = ["displacedRegionalStepSeedingVertices", "nearRegionsOfInterest"], + useFakeVertices = True, + ptMin = 0.6, + allowEmpty = True +)) + +displacedRegionalStepPLHitDoubletsTripl = _hitPairEDProducer.clone( + seedingLayers = 'displacedRegionalStepPLSeedLayersTripl', + trackingRegions = 'displacedRegionalStepNearTrackingRegions', + maxElement = 50000000, + produceIntermediateHitDoublets = True, +) + +displacedRegionalStepPLHitTripletsTripl = _multiHitFromChi2EDProducer.clone( + doublets = 'displacedRegionalStepPLHitDoubletsTripl', +) + +displacedRegionalStepPLSeedsTripl = _seedCreatorFromRegionConsecutiveHitsTripletOnlyEDProducer.clone( + seedingHitSets = 'displacedRegionalStepPLHitTripletsTripl', + SeedComparitorPSet = _displacedRegionalStepSeedComparitorPSet, +) + # Combined seeds import RecoTracker.TkSeedGenerator.GlobalCombinedSeeds_cfi displacedRegionalStepSeeds = RecoTracker.TkSeedGenerator.GlobalCombinedSeeds_cfi.globalCombinedSeeds.clone( - seedCollections = ['displacedRegionalStepSeedsTripl', 'displacedRegionalStepSeedsPair'] + seedCollections = ['displacedRegionalStepSeedsTripl', 'displacedRegionalStepSeedsPair', 'displacedRegionalStepPLSeedsTripl'] ) # QUALITY CUTS DURING TRACK BUILDING (for inwardss and outwards track building steps) @@ -364,14 +462,18 @@ displacedRegionalStepInputTracks, displacedRegionalStepSeedingV0Candidates, displacedRegionalStepSeedingVertices, - displacedRegionalStepTrackingRegionsTripl, + displacedRegionalStepFarTrackingRegions, displacedRegionalStepHitDoubletsTripl, displacedRegionalStepHitTripletsTripl, displacedRegionalStepSeedsTripl, displacedRegionalStepSeedLayersPair, - displacedRegionalStepTrackingRegionsPair, displacedRegionalStepHitDoubletsPair, displacedRegionalStepSeedsPair, + displacedRegionalStepPLSeedLayersTripl, + displacedRegionalStepNearTrackingRegions, + displacedRegionalStepPLHitDoubletsTripl, + displacedRegionalStepPLHitTripletsTripl, + displacedRegionalStepPLSeedsTripl, displacedRegionalStepSeeds, displacedRegionalStepTrackCandidates, displacedRegionalStepTracks, From 31c32bd888781153a19e13dfb8df617e798be815 Mon Sep 17 00:00:00 2001 From: Andrew Hart Date: Wed, 26 Apr 2023 18:05:27 -0400 Subject: [PATCH 22/23] Updated interface to tensorflow. --- .../plugins/DisplacedRegionSeedingVertexProducer.cc | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/RecoTracker/DisplacedRegionalTracking/plugins/DisplacedRegionSeedingVertexProducer.cc b/RecoTracker/DisplacedRegionalTracking/plugins/DisplacedRegionSeedingVertexProducer.cc index fc6e3c14a58e0..a2d8140d6b303 100644 --- a/RecoTracker/DisplacedRegionalTracking/plugins/DisplacedRegionSeedingVertexProducer.cc +++ b/RecoTracker/DisplacedRegionalTracking/plugins/DisplacedRegionSeedingVertexProducer.cc @@ -69,11 +69,11 @@ DisplacedRegionSeedingVertexProducer::DisplacedRegionSeedingVertexProducer(const trackClustersToken_( consumes >(cfg.getParameter("trackClusters"))) { unsigned nThreads = cfg.getUntrackedParameter("nThreads"); - tensorflow::SessionOptions sessionOptions; - tensorflow::setThreading(sessionOptions, nThreads); + tensorflow::Options options; + options.setThreading(nThreads); string pbFile = cfg.getParameter("graph_path").fullPath(); auto graphDef = tensorflow::loadGraphDef(pbFile); - session_ = tensorflow::createSession(graphDef, sessionOptions); + session_ = tensorflow::createSession(graphDef, options); produces >("nearRegionsOfInterest"); produces >("farRegionsOfInterest"); From 26259b06ce08d8d23cd8e12df7ffb077dc7f426a Mon Sep 17 00:00:00 2001 From: Andrew Hart Date: Wed, 26 Apr 2023 18:06:46 -0400 Subject: [PATCH 23/23] Moved RecoPixelVertexing subsystem to RecoTracker. --- .../IterativeTracking/python/DisplacedRegionalStep_cff.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/RecoTracker/IterativeTracking/python/DisplacedRegionalStep_cff.py b/RecoTracker/IterativeTracking/python/DisplacedRegionalStep_cff.py index c588b0f81c6ad..2c9fd21fb7f46 100644 --- a/RecoTracker/IterativeTracking/python/DisplacedRegionalStep_cff.py +++ b/RecoTracker/IterativeTracking/python/DisplacedRegionalStep_cff.py @@ -87,7 +87,7 @@ )) # Triplet seeding -from RecoPixelVertexing.PixelLowPtUtilities.ClusterShapeHitFilterESProducer_cfi import ClusterShapeHitFilterESProducer as _ClusterShapeHitFilterESProducer +from RecoTracker.PixelLowPtUtilities.ClusterShapeHitFilterESProducer_cfi import ClusterShapeHitFilterESProducer as _ClusterShapeHitFilterESProducer displacedRegionalStepClusterShapeHitFilter = _ClusterShapeHitFilterESProducer.clone( ComponentName = 'displacedRegionalStepClusterShapeHitFilter', doStripShapeCut = False, @@ -127,7 +127,7 @@ SeedComparitorPSet = _displacedRegionalStepSeedComparitorPSet, ) -from RecoPixelVertexing.PixelLowPtUtilities.StripSubClusterShapeSeedFilter_cfi import StripSubClusterShapeSeedFilter as _StripSubClusterShapeSeedFilter +from RecoTracker.PixelLowPtUtilities.StripSubClusterShapeSeedFilter_cfi import StripSubClusterShapeSeedFilter as _StripSubClusterShapeSeedFilter from Configuration.ProcessModifiers.approxSiStripClusters_cff import approxSiStripClusters (~approxSiStripClusters).toModify(displacedRegionalStepSeedsTripl.SeedComparitorPSet.comparitors, func = lambda list: list.append(_StripSubClusterShapeSeedFilter.clone()) )