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/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 ) 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/Configuration/PyReleaseValidation/README.md b/Configuration/PyReleaseValidation/README.md index 756cdffc750cc..f124270a5749a 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.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 0cafb088d0b80..d76c84e2acf79 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.701, +) +upgradeWFs['displacedRegional'].step3 = { + '--procModifiers': 'displacedRegionalTracking' +} + # Vector Hits workflows class UpgradeWorkflow_vectorHits(UpgradeWorkflow): def setup_(self, step, stepName, stepDict, k, properties): 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/plugins/BuildFile.xml b/RecoTracker/DisplacedRegionalTracking/plugins/BuildFile.xml new file mode 100644 index 0000000000000..ed4fb5e1656c9 --- /dev/null +++ b/RecoTracker/DisplacedRegionalTracking/plugins/BuildFile.xml @@ -0,0 +1,10 @@ + + + + + + + + + + diff --git a/RecoTracker/DisplacedRegionalTracking/plugins/DisplacedRegionSeedingVertexProducer.cc b/RecoTracker/DisplacedRegionalTracking/plugins/DisplacedRegionSeedingVertexProducer.cc new file mode 100644 index 0000000000000..a2d8140d6b303 --- /dev/null +++ b/RecoTracker/DisplacedRegionalTracking/plugins/DisplacedRegionSeedingVertexProducer.cc @@ -0,0 +1,266 @@ +#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/plugins/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 + const double rParam_; + + // selection parameters + const double minRadius_; + const double nearThreshold_; + const double farThreshold_; + const double discriminatorCut_; + const vector input_names_; + const vector output_names_; + + const edm::EDGetTokenT beamSpotToken_; + const 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")), + nearThreshold_(cfg.getParameter("nearThreshold")), + farThreshold_(cfg.getParameter("farThreshold")), + 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.getUntrackedParameter("nThreads"); + tensorflow::Options options; + options.setThreading(nThreads); + string pbFile = cfg.getParameter("graph_path").fullPath(); + auto graphDef = tensorflow::loadGraphDef(pbFile); + session_ = tensorflow::createSession(graphDef, options); + + produces >("nearRegionsOfInterest"); + produces >("farRegionsOfInterest"); +} + +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.at(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 auto &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 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) { + 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(nearRegionsOfInterest), "nearRegionsOfInterest"); + event.put(move(farRegionsOfInterest), "farRegionsOfInterest"); +} + +void DisplacedRegionSeedingVertexProducer::fillDescriptions(edm::ConfigurationDescriptions &descriptions) { + edm::ParameterSetDescription desc; + + 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"}); + desc.addUntracked("nThreads", 1); + 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/plugins/DisplacedVertexCluster.cc b/RecoTracker/DisplacedRegionalTracking/plugins/DisplacedVertexCluster.cc new file mode 100644 index 0000000000000..5b9b1832d1dfd --- /dev/null +++ b/RecoTracker/DisplacedRegionalTracking/plugins/DisplacedVertexCluster.cc @@ -0,0 +1,23 @@ +#include "RecoTracker/DisplacedRegionalTracking/plugins/DisplacedVertexCluster.h" + +DisplacedVertexCluster::DisplacedVertexCluster(const reco::VertexCompositeCandidate *const trackClusterPtr, + const double rParam) + : valid_(true), + rParam2_(rParam * rParam), + sumOfCenters_(trackClusterPtr->vertex()), + centerOfMass_(trackClusterPtr->vertex()) { + 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/DisplacedRegionalTracking/plugins/DisplacedVertexCluster.h b/RecoTracker/DisplacedRegionalTracking/plugins/DisplacedVertexCluster.h new file mode 100644 index 0000000000000..c66a0c44d00ae --- /dev/null +++ b/RecoTracker/DisplacedRegionalTracking/plugins/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 reco::VertexCompositeCandidate *const, const double); + + ~DisplacedVertexCluster() = default; + + 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/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..2c9fd21fb7f46 --- /dev/null +++ b/RecoTracker/IterativeTracking/python/DisplacedRegionalStep_cff.py @@ -0,0 +1,486 @@ +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, + nearThreshold = 20.0, + farThreshold = -1.0, + discriminatorCut = 0.5, + trackClusters = ["displacedRegionalStepSeedingV0Candidates", "Kshort"], +) + +from RecoTracker.TkTrackingRegions.globalTrackingRegionWithVertices_cfi import globalTrackingRegionWithVertices as _globalTrackingRegionWithVertices +displacedRegionalStepFarTrackingRegions = _globalTrackingRegionWithVertices.clone(RegionPSet = dict( + originRadius = 1.0, + fixedError = 1.0, + VertexCollection = ["displacedRegionalStepSeedingVertices", "farRegionsOfInterest"], + useFakeVertices = True, + ptMin = 0.6, + allowEmpty = True +)) + +# Triplet seeding +from RecoTracker.PixelLowPtUtilities.ClusterShapeHitFilterESProducer_cfi import ClusterShapeHitFilterESProducer as _ClusterShapeHitFilterESProducer +displacedRegionalStepClusterShapeHitFilter = _ClusterShapeHitFilterESProducer.clone( + ComponentName = 'displacedRegionalStepClusterShapeHitFilter', + doStripShapeCut = False, + clusterChargeCut = dict(refToPSet_ = 'SiStripClusterChargeCutTight') +) + +from RecoTracker.TkHitPairs.hitPairEDProducer_cfi import hitPairEDProducer as _hitPairEDProducer +displacedRegionalStepHitDoubletsTripl = _hitPairEDProducer.clone( + seedingLayers = "displacedRegionalStepSeedLayersTripl", + trackingRegions = "displacedRegionalStepFarTrackingRegions", + 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 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()) ) + +# 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 seeds +displacedRegionalStepHitDoubletsPair = _hitPairEDProducer.clone( + seedingLayers = "displacedRegionalStepSeedLayersPair", + trackingRegions = "displacedRegionalStepFarTrackingRegions", + produceSeedingHitSets = True, + maxElementTotal = 12000000, +) +from RecoTracker.TkSeedGenerator.seedCreatorFromRegionConsecutiveHitsEDProducer_cff import seedCreatorFromRegionConsecutiveHitsEDProducer as _seedCreatorFromRegionConsecutiveHitsEDProducer +displacedRegionalStepSeedsPair = _seedCreatorFromRegionConsecutiveHitsEDProducer.clone( + seedingHitSets = "displacedRegionalStepHitDoubletsPair", + 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', 'displacedRegionalStepPLSeedsTripl'] +) + +# 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, + displacedRegionalStepFarTrackingRegions, + displacedRegionalStepHitDoubletsTripl, + displacedRegionalStepHitTripletsTripl, + displacedRegionalStepSeedsTripl, + displacedRegionalStepSeedLayersPair, + displacedRegionalStepHitDoubletsPair, + displacedRegionalStepSeedsPair, + displacedRegionalStepPLSeedLayersTripl, + displacedRegionalStepNearTrackingRegions, + displacedRegionalStepPLHitDoubletsTripl, + displacedRegionalStepPLHitTripletsTripl, + displacedRegionalStepPLSeedsTripl, + 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..6bc8883c5b1a0 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,26 @@ 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), + # 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 outer tracks < + 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..ba75035ef00d7 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,14 @@ 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"); + innerOuterTkDCAThreshold_ = theParameters.getParameter("innerOuterTkDCAThreshold"); + 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 +158,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 +183,28 @@ 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.) + const double cxPtR2 = cxPt.x() * cxPt.x() + cxPt.y() * cxPt.y(); + if (cxPtR2 > 120. * 120. || std::abs(cxPt.z()) > 300.) continue; + // allow for different DCA cuts depending on position of POCA + if (cxPtR2 < innerOuterTkDCAThreshold_ * innerOuterTkDCAThreshold_) { + 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 +222,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 { + useRefTracks_ = false; + AdaptiveVertexFitter theAdaptiveFitter; + theRecoVertex = theAdaptiveFitter.vertex(transTracks); + } } if (!theRecoVertex.isValid()) continue; @@ -222,8 +248,12 @@ 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); + if (distMagXY < vtxDecayXYCut_) + continue; + if (posTransTkPtr->charge() * negTransTkPtr->charge() > 0 && distMagXY < ssVtxDecayXYCut_) + continue; double sigmaDistMagXY = sqrt(ROOT::Math::Similarity(totalCov, distVecXY)) / distMagXY; - if (distMagXY / sigmaDistMagXY < vtxDecaySigXYCut_) + if (distMagXY < vtxDecaySigXYCut_ * sigmaDistMagXY) continue; // 3D decay significance diff --git a/RecoVertex/V0Producer/src/V0Fitter.h b/RecoVertex/V0Producer/src/V0Fitter.h index 5b399f64f6053..9864a036547aa 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,14 @@ class dso_hidden V0Fitter { double vtxChi2Cut_; double vtxDecaySigXYCut_; double vtxDecaySigXYZCut_; + double vtxDecayXYCut_; + double ssVtxDecayXYCut_; // miscellaneous cuts - double tkDCACut_; + bool allowSS_; + double innerOuterTkDCAThreshold_; + 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']