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/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 874c4e3c9786d..41d0693d10e90 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/data/FullDataWithR_Phi-64-126-256_16-32-64_F-256-128-64_Model.pb b/RecoTracker/DisplacedRegionalTracking/data/FullDataWithR_Phi-64-126-256_16-32-64_F-256-128-64_Model.pb new file mode 100644 index 0000000000000..345eaf4f8d8ca Binary files /dev/null and b/RecoTracker/DisplacedRegionalTracking/data/FullDataWithR_Phi-64-126-256_16-32-64_F-256-128-64_Model.pb differ diff --git a/RecoTracker/DisplacedRegionalTracking/data/FullDataWithR_Phi-64-128-256_16-32-64_F-128-64-32_Model.pb b/RecoTracker/DisplacedRegionalTracking/data/FullDataWithR_Phi-64-128-256_16-32-64_F-128-64-32_Model.pb new file mode 100644 index 0000000000000..a30ed87c2c0b6 Binary files /dev/null and b/RecoTracker/DisplacedRegionalTracking/data/FullDataWithR_Phi-64-128-256_16-32-64_F-128-64-32_Model.pb differ diff --git a/RecoTracker/DisplacedRegionalTracking/data/FullData_Phi-64-126-256_16-32-64_F-256-128-64_Model.pb b/RecoTracker/DisplacedRegionalTracking/data/FullData_Phi-64-126-256_16-32-64_F-256-128-64_Model.pb new file mode 100644 index 0000000000000..3115e674e1ce2 Binary files /dev/null and b/RecoTracker/DisplacedRegionalTracking/data/FullData_Phi-64-126-256_16-32-64_F-256-128-64_Model.pb differ diff --git a/RecoTracker/DisplacedRegionalTracking/data/FullData_Phi-64-128-256_16-32-64_F-128-64-32_Model.pb b/RecoTracker/DisplacedRegionalTracking/data/FullData_Phi-64-128-256_16-32-64_F-128-64-32_Model.pb new file mode 100644 index 0000000000000..658ee827e4d9d Binary files /dev/null and b/RecoTracker/DisplacedRegionalTracking/data/FullData_Phi-64-128-256_16-32-64_F-128-64-32_Model.pb differ diff --git a/RecoTracker/DisplacedRegionalTracking/data/MS-15_Phi-64-128-256_16-32-64_F-256-128-32_Model.pb b/RecoTracker/DisplacedRegionalTracking/data/MS-15_Phi-64-128-256_16-32-64_F-256-128-32_Model.pb new file mode 100644 index 0000000000000..4b907ef467991 Binary files /dev/null and b/RecoTracker/DisplacedRegionalTracking/data/MS-15_Phi-64-128-256_16-32-64_F-256-128-32_Model.pb differ 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..621ae51ea0a42 --- /dev/null +++ b/RecoTracker/IterativeTracking/python/DisplacedRegionalStep_cff.py @@ -0,0 +1,330 @@ +import FWCore.ParameterSet.Config as cms +import RecoTracker.IterativeTracking.iterativeTkConfig as _cfg + +############################################################################# +# 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 * +displacedRegionalStepSeedLayersTripl = cms.EDProducer("SeedingLayersEDProducer", + layerList = cms.vstring( + #TOB + 'TOB1+TOB2+MTOB3','TOB1+TOB2+MTOB4', + #TOB+MTEC + 'TOB1+TOB2+MTEC1_pos','TOB1+TOB2+MTEC1_neg', + ), + TOB = cms.PSet( + TTRHBuilder = cms.string('WithTrackAngle'), clusterChargeCut = cms.PSet(refToPSet_ = cms.string('SiStripClusterChargeCutTight')), + matchedRecHits = cms.InputTag("siStripMatchedRecHits","matchedRecHit"), + skipClusters = cms.InputTag('displacedRegionalStepClusters') + ), + MTOB = cms.PSet( + TTRHBuilder = cms.string('WithTrackAngle'), clusterChargeCut = cms.PSet(refToPSet_ = cms.string('SiStripClusterChargeCutTight')), + skipClusters = cms.InputTag('displacedRegionalStepClusters'), + rphiRecHits = cms.InputTag("siStripMatchedRecHits","rphiRecHit") + ), + MTEC = cms.PSet( + 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 +from RecoPixelVertexing.PixelLowPtUtilities.StripSubClusterShapeSeedFilter_cfi import StripSubClusterShapeSeedFilter as _StripSubClusterShapeSeedFilter +_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 + ), + _StripSubClusterShapeSeedFilter.clone() + ) +) +displacedRegionalStepSeedsTripl = _seedCreatorFromRegionConsecutiveHitsTripletOnlyEDProducer.clone( + seedingHitSets = "displacedRegionalStepHitTripletsTripl", + SeedComparitorPSet = _displacedRegionalStepSeedComparitorPSet, +) + +# PAIR SEEDING LAYERS +displacedRegionalStepSeedLayersPair = cms.EDProducer("SeedingLayersEDProducer", + layerList = cms.vstring('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 = cms.PSet( + TTRHBuilder = cms.string('WithTrackAngle'), clusterChargeCut = cms.PSet(refToPSet_ = cms.string('SiStripClusterChargeCutTight')), + matchedRecHits = cms.InputTag("siStripMatchedRecHits","matchedRecHit"), + skipClusters = cms.InputTag('displacedRegionalStepClusters') + ), + TEC = cms.PSet( + 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 = dict(refToPSet_ = 'SiStripClusterChargeCutTight') +) + +# TRACK BUILDING +import RecoTracker.CkfPattern.GroupedCkfTrajectoryBuilder_cfi +displacedRegionalStepTrajectoryBuilder = RecoTracker.CkfPattern.GroupedCkfTrajectoryBuilder_cfi.GroupedCkfTrajectoryBuilder.clone( + MeasurementTrackerName = '', + trajectoryFilter = dict(refToPSet_ = 'displacedRegionalStepTrajectoryFilter'), + inOutTrajectoryFilter = dict(refToPSet_ = 'displacedRegionalStepInOutTrajectoryFilter'), + useSameTrajFilter = False, + minNrOfHitsForRebuild = 4, + alwaysUseInvalidHits = False, + maxCand = 2, + estimator = 'displacedRegionalStepChi2Est', + maxDPhiForLooperReconstruction = cms.double(2.0), + maxPtForLooperReconstruction = cms.double(0.7) + ) + +# MAKING OF TRACK CANDIDATES +import RecoTracker.CkfPattern.CkfTrackCandidates_cfi +displacedRegionalStepTrackCandidates = RecoTracker.CkfPattern.CkfTrackCandidates_cfi.ckfTrackCandidates.clone( + src = 'displacedRegionalStepSeeds', + clustersToSkip = cms.InputTag('displacedRegionalStepClusters'), + ### these two parameters are relevant only for the CachingSeedCleanerBySharedInput + numHitsForSeedCleaner = cms.int32(50), + onlyPixelHitsForSeedCleaner = cms.bool(True), + + TrajectoryBuilderPSet = dict(refToPSet_ = 'displacedRegionalStepTrajectoryBuilder'), + doSeedingRegionRebuilding = True, + useHitsSplitting = True, + cleanTrajectoryAfterInOut = True, + TrajectoryCleaner = 'displacedRegionalStepTrajectoryCleanerBySharedHits' +) + +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.TrackProducer_cfi +displacedRegionalStepTracks = RecoTracker.TrackProducer.TrackProducer_cfi.TrackProducer.clone( + src = 'displacedRegionalStepTrackCandidates', + AlgorithmName = 'displacedRegionalStep', + 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] +)) + +import RecoTracker.FinalTrackSelectors.multiTrackSelector_cfi + +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) diff --git a/RecoTracker/IterativeTracking/python/iterativeTkConfig.py b/RecoTracker/IterativeTracking/python/iterativeTkConfig.py index 7060c51219a32..e4955da907273 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", @@ -95,6 +99,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, @@ -190,7 +198,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 @@ -198,6 +208,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 89efb64bd62aa..842b8b6355aa4 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 @@ -44,6 +45,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 7a841e33e71fe..870b0795e6ca2 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"); @@ -73,6 +74,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); @@ -165,7 +167,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)); } @@ -199,6 +201,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 1fa5484c8bf5c..066776912cb96 100644 --- a/Validation/RecoTrack/python/TrackValidation_cff.py +++ b/Validation/RecoTrack/python/TrackValidation_cff.py @@ -47,12 +47,14 @@ _removeForFastSimSeedProducers =["initialStepSeedsPreSplitting", "jetCoreRegionalStepSeeds", + "displacedRegionalStepSeeds", "muonSeededSeedsInOut", "muonSeededSeedsOutIn"] _seedProducers_fastSim = [ x for x in _seedProducers if x not in _removeForFastSimSeedProducers] _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 3985f8edc9abf..e4f0e751bf474 100644 --- a/Validation/RecoTrack/python/plotting/html.py +++ b/Validation/RecoTrack/python/plotting/html.py @@ -169,6 +169,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 526f513e0755d..d87c228aadcc8 100644 --- a/Validation/RecoTrack/python/plotting/ntupleEnum.py +++ b/Validation/RecoTrack/python/plotting/ntupleEnum.py @@ -43,7 +43,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 fda80114d7e8f..858e47bba4da3 100644 --- a/Validation/RecoTrack/python/plotting/trackingPlots.py +++ b/Validation/RecoTrack/python/plotting/trackingPlots.py @@ -528,6 +528,9 @@ def _makeMVAPlots(num, hp=False): 'jetCoreRegionalStep', 'muonSeededStepInOut', 'muonSeededStepOutIn', + 'displacedRegionalStepPair', # seeds + 'displacedRegionalStepTripl', # seeds + 'displacedRegionalStep', 'duplicateMerge', ] + _possibleTrackingNonIterationColls _possibleTrackingCollsOld = { @@ -1588,6 +1591,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 afc3e34858050..5f98d5b70010f 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']