From 9b1732d4107c3298baa16cbe8f1b99f80b35da63 Mon Sep 17 00:00:00 2001 From: Matti Kortelainen Date: Fri, 13 Sep 2019 09:17:14 -0700 Subject: [PATCH 01/20] Add configuration option for duplicate removal, enable by default --- RecoTracker/MkFit/plugins/MkFitProducer.cc | 2 ++ 1 file changed, 2 insertions(+) diff --git a/RecoTracker/MkFit/plugins/MkFitProducer.cc b/RecoTracker/MkFit/plugins/MkFitProducer.cc index 33a2ac0f33853..620171e8b02d1 100644 --- a/RecoTracker/MkFit/plugins/MkFitProducer.cc +++ b/RecoTracker/MkFit/plugins/MkFitProducer.cc @@ -85,6 +85,7 @@ MkFitProducer::MkFitProducer(edm::ParameterSet const& iConfig) // TODO: what to do when we have multiple instances of MkFitProducer in a job? mkfit::MkBuilderWrapper::populate(isFV); mkfit::ConfigWrapper::initializeForCMSSW(seedCleanOpt, backwardFitOpt, mkFitSilent_); + mkfit::ConfigWrapper::setRemoveDuplicates(iConfig.getParameter("removeDuplicates")); } void MkFitProducer::fillDescriptions(edm::ConfigurationDescriptions& descriptions) { @@ -94,6 +95,7 @@ void MkFitProducer::fillDescriptions(edm::ConfigurationDescriptions& description desc.add("buildingRoutine", "cloneEngine") ->setComment("Valid values are: 'bestHit', 'standard', 'cloneEngine', 'fullVector'"); desc.add("seedCleaning", "N2")->setComment("Valid values are: 'none', 'N2'"); + desc.add("removeDuplicates", true)->setComment("Run duplicate removal within mkFit"); desc.add("backwardFitInCMSSW", false) ->setComment("Do backward fit (to innermost hit) in CMSSW (true) or mkFit (false)"); desc.addUntracked("mkFitSilent", true)->setComment("Allows to enables printouts from mkFit with 'False'"); From 9f31c6c9d2dfa596cea0cd2674e6ea798c1b2a23 Mon Sep 17 00:00:00 2001 From: Matti Kortelainen Date: Thu, 3 Oct 2019 09:22:16 -0700 Subject: [PATCH 02/20] Move all geometry-related stuff to an ESProduct --- .../python/InitialStep_cff.py | 3 +- RecoTracker/MkFit/BuildFile.xml | 3 + RecoTracker/MkFit/interface/MkFitGeometry.h | 34 +++++++++ .../MkFit/interface/MkFitInputWrapper.h | 10 +-- .../MkFit/plugins/MkFitGeometryESProducer.cc | 48 ++++++++++++ .../MkFit/plugins/MkFitInputConverter.cc | 10 ++- .../MkFit/plugins/MkFitOutputConverter.cc | 75 ++----------------- RecoTracker/MkFit/plugins/MkFitProducer.cc | 29 ++++--- .../MkFit/python/customizeInitialStepOnly.py | 6 +- RecoTracker/MkFit/src/ES_MkFitGeometry.cc | 3 + RecoTracker/MkFit/src/MkFitGeometry.cc | 57 ++++++++++++++ RecoTracker/MkFit/src/MkFitInputWrapper.cc | 8 +- 12 files changed, 180 insertions(+), 106 deletions(-) create mode 100644 RecoTracker/MkFit/interface/MkFitGeometry.h create mode 100644 RecoTracker/MkFit/plugins/MkFitGeometryESProducer.cc create mode 100644 RecoTracker/MkFit/src/ES_MkFitGeometry.cc create mode 100644 RecoTracker/MkFit/src/MkFitGeometry.cc diff --git a/RecoTracker/IterativeTracking/python/InitialStep_cff.py b/RecoTracker/IterativeTracking/python/InitialStep_cff.py index fb77d3ce0acaf..0244600a2729b 100644 --- a/RecoTracker/IterativeTracking/python/InitialStep_cff.py +++ b/RecoTracker/IterativeTracking/python/InitialStep_cff.py @@ -224,6 +224,7 @@ ) from Configuration.ProcessModifiers.trackingMkFit_cff import trackingMkFit +from RecoTracker.MkFit.mkFitGeometryESProducer_cfi import mkFitGeometryESProducer import RecoTracker.MkFit.mkFitInputConverter_cfi as mkFitInputConverter_cfi import RecoTracker.MkFit.mkFitProducer_cfi as mkFitProducer_cfi import RecoTracker.MkFit.mkFitOutputConverter_cfi as mkFitOutputConverter_cfi @@ -414,7 +415,7 @@ InitialStep = cms.Sequence(InitialStepTask) _InitialStepTask_trackingMkFit = InitialStepTask.copy() -_InitialStepTask_trackingMkFit.add(initialStepTrackCandidatesMkFitInput, initialStepTrackCandidatesMkFit) +_InitialStepTask_trackingMkFit.add(initialStepTrackCandidatesMkFitInput, initialStepTrackCandidatesMkFit, mkFitGeometryESProducer) trackingMkFit.toReplaceWith(InitialStepTask, _InitialStepTask_trackingMkFit) _InitialStepTask_LowPU = InitialStepTask.copyAndExclude([firstStepPrimaryVerticesUnsorted, initialStepTrackRefsForJets, caloJetsForTrkTask, firstStepPrimaryVertices, initialStepClassifier1, initialStepClassifier2, initialStepClassifier3]) diff --git a/RecoTracker/MkFit/BuildFile.xml b/RecoTracker/MkFit/BuildFile.xml index 8d936740b9bf6..177da9dffc6df 100644 --- a/RecoTracker/MkFit/BuildFile.xml +++ b/RecoTracker/MkFit/BuildFile.xml @@ -1,5 +1,8 @@ + + + diff --git a/RecoTracker/MkFit/interface/MkFitGeometry.h b/RecoTracker/MkFit/interface/MkFitGeometry.h new file mode 100644 index 0000000000000..c69c7b83b28bb --- /dev/null +++ b/RecoTracker/MkFit/interface/MkFitGeometry.h @@ -0,0 +1,34 @@ +#ifndef RecoTracker_MkFit_MkFitGeometry_h +#define RecoTracker_MkFit_MkFitGeometry_h + +#include +#include + +namespace mkfit { + class LayerNumberConverter; +} + +class DetLayer; +class GeometricSearchTracker; +class TrackerGeometry; +class TrackerTopology; + +/** + * Collection of geometry-related objects for mkFit + */ +class MkFitGeometry { +public: + explicit MkFitGeometry(const TrackerGeometry& geom, + const GeometricSearchTracker& tracker, + const TrackerTopology& ttopo); + ~MkFitGeometry(); + + mkfit::LayerNumberConverter const& layerNumberConverter() const { return *lnc_; } + const std::vector& detLayers() const { return dets_; } + +private: + std::unique_ptr lnc_; // for pimpl pattern + std::vector dets_; +}; + +#endif diff --git a/RecoTracker/MkFit/interface/MkFitInputWrapper.h b/RecoTracker/MkFit/interface/MkFitInputWrapper.h index 2edc855b5c643..cd6d5647c58cc 100644 --- a/RecoTracker/MkFit/interface/MkFitInputWrapper.h +++ b/RecoTracker/MkFit/interface/MkFitInputWrapper.h @@ -17,10 +17,7 @@ namespace mkfit { class MkFitInputWrapper { public: MkFitInputWrapper(); - MkFitInputWrapper(MkFitHitIndexMap hitIndexMap, - std::vector hits, - mkfit::TrackVec seeds, - mkfit::LayerNumberConverter const& lnc); + MkFitInputWrapper(MkFitHitIndexMap hitIndexMap, std::vector hits, mkfit::TrackVec seeds); ~MkFitInputWrapper(); MkFitInputWrapper(MkFitInputWrapper const&) = delete; @@ -31,14 +28,11 @@ class MkFitInputWrapper { MkFitHitIndexMap const& hitIndexMap() const { return hitIndexMap_; } mkfit::TrackVec const& seeds() const { return *seeds_; } std::vector const& hits() const { return hits_; } - mkfit::LayerNumberConverter const& layerNumberConverter() const { return *lnc_; } - unsigned int nlayers() const; private: MkFitHitIndexMap hitIndexMap_; std::vector hits_; - std::unique_ptr seeds_; // for pimpl pattern - std::unique_ptr lnc_; // for pimpl pattern + std::unique_ptr seeds_; // for pimpl pattern }; #endif diff --git a/RecoTracker/MkFit/plugins/MkFitGeometryESProducer.cc b/RecoTracker/MkFit/plugins/MkFitGeometryESProducer.cc new file mode 100644 index 0000000000000..7442e328e80b8 --- /dev/null +++ b/RecoTracker/MkFit/plugins/MkFitGeometryESProducer.cc @@ -0,0 +1,48 @@ +#include "FWCore/Framework/interface/ModuleFactory.h" +#include "FWCore/Framework/interface/ESProducer.h" + +#include "DataFormats/TrackerCommon/interface/TrackerTopology.h" +#include "Geometry/Records/interface/TrackerTopologyRcd.h" +#include "RecoTracker/TkDetLayers/interface/GeometricSearchTracker.h" +#include "RecoTracker/Record/interface/TrackerRecoGeometryRecord.h" +#include "Geometry/TrackerGeometryBuilder/interface/TrackerGeometry.h" +#include "Geometry/Records/interface/TrackerDigiGeometryRecord.h" + +#include "RecoTracker/MkFit/interface/MkFitGeometry.h" + +// mkFit includes +#include "ConfigWrapper.h" + +#include + +class MkFitGeometryESProducer : public edm::ESProducer { +public: + MkFitGeometryESProducer(const edm::ParameterSet& iConfig); + + static void fillDescriptions(edm::ConfigurationDescriptions& descriptions); + + std::unique_ptr produce(const TrackerRecoGeometryRecord& iRecord); + +private: + edm::ESGetToken geomToken_; + edm::ESGetToken trackerToken_; + edm::ESGetToken ttopoToken_; +}; + +MkFitGeometryESProducer::MkFitGeometryESProducer(const edm::ParameterSet& iConfig) { + auto cc = setWhatProduced(this); + geomToken_ = cc.consumes(); + trackerToken_ = cc.consumes(); + ttopoToken_ = cc.consumes(); +} + +void MkFitGeometryESProducer::fillDescriptions(edm::ConfigurationDescriptions& descriptions) { + edm::ParameterSetDescription desc; + descriptions.addWithDefaultLabel(desc); +} + +std::unique_ptr MkFitGeometryESProducer::produce(const TrackerRecoGeometryRecord& iRecord) { + return std::make_unique(iRecord.get(geomToken_), iRecord.get(trackerToken_), iRecord.get(ttopoToken_)); +} + +DEFINE_FWK_EVENTSETUP_MODULE(MkFitGeometryESProducer); diff --git a/RecoTracker/MkFit/plugins/MkFitInputConverter.cc b/RecoTracker/MkFit/plugins/MkFitInputConverter.cc index 546ca59f6a348..3ed202b8555e9 100644 --- a/RecoTracker/MkFit/plugins/MkFitInputConverter.cc +++ b/RecoTracker/MkFit/plugins/MkFitInputConverter.cc @@ -22,6 +22,8 @@ #include "MagneticField/Records/interface/IdealMagneticFieldRecord.h" #include "RecoTracker/MkFit/interface/MkFitInputWrapper.h" +#include "RecoTracker/MkFit/interface/MkFitGeometry.h" +#include "RecoTracker/Record/interface/TrackerRecoGeometryRecord.h" // ROOT #include "Math/SVector.h" @@ -106,12 +108,14 @@ void MkFitInputConverter::fillDescriptions(edm::ConfigurationDescriptions& descr } void MkFitInputConverter::produce(edm::StreamID iID, edm::Event& iEvent, const edm::EventSetup& iSetup) const { - mkfit::LayerNumberConverter lnc{mkfit::TkLayout::phase1}; - // Then import hits const auto& ttrhBuilder = iSetup.getData(ttrhBuilderToken_); const auto& ttopo = iSetup.getData(ttopoToken_); + edm::ESHandle mkFitGeom; + iSetup.get().get(mkFitGeom); + const auto& lnc = mkFitGeom->layerNumberConverter(); + std::vector mkFitHits(lnc.nLayers()); MkFitHitIndexMap hitIndexMap; int totalHits = 0; // I need to have a global hit index in order to have the hit remapping working? @@ -123,7 +127,7 @@ void MkFitInputConverter::produce(edm::StreamID iID, edm::Event& iEvent, const e // Then import seeds auto mkFitSeeds = convertSeeds(iEvent.get(seedToken_), hitIndexMap, ttrhBuilder, iSetup.getData(mfToken_)); - iEvent.emplace(putToken_, std::move(hitIndexMap), std::move(mkFitHits), std::move(mkFitSeeds), lnc); + iEvent.emplace(putToken_, std::move(hitIndexMap), std::move(mkFitHits), std::move(mkFitSeeds)); } bool MkFitInputConverter::passCCC(const SiStripRecHit2D& hit, const DetId hitId) const { diff --git a/RecoTracker/MkFit/plugins/MkFitOutputConverter.cc b/RecoTracker/MkFit/plugins/MkFitOutputConverter.cc index b21bc7c35b8b0..e195bc384d77a 100644 --- a/RecoTracker/MkFit/plugins/MkFitOutputConverter.cc +++ b/RecoTracker/MkFit/plugins/MkFitOutputConverter.cc @@ -12,12 +12,6 @@ #include "DataFormats/TrackReco/interface/SeedStopInfo.h" #include "DataFormats/TrackingRecHit/interface/InvalidTrackingRecHit.h" -#include "Geometry/TrackerGeometryBuilder/interface/TrackerGeometry.h" -#include "Geometry/Records/interface/TrackerDigiGeometryRecord.h" -#include "DataFormats/TrackerCommon/interface/TrackerTopology.h" -#include "DataFormats/TrackerCommon/interface/TrackerDetSide.h" -#include "Geometry/Records/interface/TrackerTopologyRcd.h" - #include "TrackingTools/Records/interface/TransientRecHitRecord.h" #include "TrackingTools/TransientTrackingRecHit/interface/TransientTrackingRecHitBuilder.h" #include "TrackingTools/TrajectoryState/interface/TrajectoryStateTransform.h" @@ -34,11 +28,10 @@ #include "RecoTracker/TransientTrackingRecHit/interface/TkTransientTrackingRecHitBuilder.h" #include "TrackingTools/MaterialEffects/src/PropagatorWithMaterial.cc" -#include "RecoTracker/MeasurementDet/interface/MeasurementTrackerEvent.h" -#include "RecoTracker/TkDetLayers/interface/GeometricSearchTracker.h" - #include "RecoTracker/MkFit/interface/MkFitInputWrapper.h" #include "RecoTracker/MkFit/interface/MkFitOutputWrapper.h" +#include "RecoTracker/MkFit/interface/MkFitGeometry.h" +#include "RecoTracker/Record/interface/TrackerRecoGeometryRecord.h" // mkFit indludes #include "LayerNumberConverter.h" @@ -68,14 +61,9 @@ class MkFitOutputConverter : public edm::global::EDProducer<> { private: void produce(edm::StreamID, edm::Event& iEvent, const edm::EventSetup& iSetup) const override; - std::vector createDetLayers(const mkfit::LayerNumberConverter& lnc, - const GeometricSearchTracker& tracker, - const TrackerTopology& ttopo) const; - TrackCandidateCollection convertCandidates(const MkFitOutputWrapper& mkFitOutput, const MkFitHitIndexMap& hitIndexMap, const edm::View& seeds, - const TrackerGeometry& geom, const MagneticField& mf, const Propagator& propagatorAlong, const Propagator& propagatorOpposite, @@ -99,13 +87,11 @@ class MkFitOutputConverter : public edm::global::EDProducer<> { edm::EDGetTokenT hitsSeedsToken_; edm::EDGetTokenT tracksToken_; edm::EDGetTokenT> seedToken_; - edm::EDGetTokenT mteToken_; - edm::ESGetToken geomToken_; edm::ESGetToken propagatorAlongToken_; edm::ESGetToken propagatorOppositeToken_; - edm::ESGetToken ttopoToken_; edm::ESGetToken mfToken_; edm::ESGetToken ttrhBuilderToken_; + const edm::ESGetToken mkFitGeomToken_; edm::EDPutTokenT putTrackCandidateToken_; edm::EDPutTokenT> putSeedStopInfoToken_; std::string ttrhBuilderName_; @@ -118,16 +104,14 @@ MkFitOutputConverter::MkFitOutputConverter(edm::ParameterSet const& iConfig) : hitsSeedsToken_{consumes(iConfig.getParameter("hitsSeeds"))}, tracksToken_{consumes(iConfig.getParameter("tracks"))}, seedToken_{consumes>(iConfig.getParameter("seeds"))}, - mteToken_{consumes(iConfig.getParameter("measurementTrackerEvent"))}, - geomToken_{esConsumes()}, propagatorAlongToken_{ esConsumes(iConfig.getParameter("propagatorAlong"))}, propagatorOppositeToken_{esConsumes( iConfig.getParameter("propagatorOpposite"))}, - ttopoToken_{esConsumes()}, mfToken_{esConsumes()}, ttrhBuilderToken_{esConsumes( iConfig.getParameter("ttrhBuilder"))}, + mkFitGeomToken_{esConsumes()}, putTrackCandidateToken_{produces()}, putSeedStopInfoToken_{produces>()}, backwardFitInCMSSW_{iConfig.getParameter("backwardFitInCMSSW")} {} @@ -138,7 +122,6 @@ void MkFitOutputConverter::fillDescriptions(edm::ConfigurationDescriptions& desc desc.add("hitsSeeds", edm::InputTag{"mkFitInputConverter"}); desc.add("tracks", edm::InputTag{"mkFitProducer"}); desc.add("seeds", edm::InputTag{"initialStepSeeds"}); - desc.add("measurementTrackerEvent", edm::InputTag{"MeasurementTrackerEvent"}); desc.add("ttrhBuilder", edm::ESInputTag{"", "WithTrackAngle"}); desc.add("propagatorAlong", edm::ESInputTag{"", "PropagatorWithMaterial"}); desc.add("propagatorOpposite", edm::ESInputTag{"", "PropagatorWithMaterialOpposite"}); @@ -151,79 +134,33 @@ void MkFitOutputConverter::fillDescriptions(edm::ConfigurationDescriptions& desc void MkFitOutputConverter::produce(edm::StreamID iID, edm::Event& iEvent, const edm::EventSetup& iSetup) const { const auto& seeds = iEvent.get(seedToken_); const auto& hitsSeeds = iEvent.get(hitsSeedsToken_); - const auto& mte = iEvent.get(mteToken_); const auto& ttrhBuilder = iSetup.getData(ttrhBuilderToken_); const auto* tkBuilder = dynamic_cast(&ttrhBuilder); if (!tkBuilder) { throw cms::Exception("LogicError") << "TTRHBuilder must be of type TkTransientTrackingRecHitBuilder"; } + const auto& mkFitGeom = iSetup.getData(mkFitGeomToken_); // Convert mkfit presentation back to CMSSW - const auto detlayers = - createDetLayers(hitsSeeds.layerNumberConverter(), *(mte.geometricSearchTracker()), iSetup.getData(ttopoToken_)); iEvent.emplace(putTrackCandidateToken_, convertCandidates(iEvent.get(tracksToken_), hitsSeeds.hitIndexMap(), seeds, - iSetup.getData(geomToken_), iSetup.getData(mfToken_), iSetup.getData(propagatorAlongToken_), iSetup.getData(propagatorOppositeToken_), tkBuilder->cloner(), - detlayers, + mkFitGeom.detLayers(), hitsSeeds.seeds())); // TODO: SeedStopInfo is currently unfilled iEvent.emplace(putSeedStopInfoToken_, seeds.size()); } -std::vector MkFitOutputConverter::createDetLayers(const mkfit::LayerNumberConverter& lnc, - const GeometricSearchTracker& tracker, - const TrackerTopology& ttopo) const { - std::vector dets(lnc.nLayers(), nullptr); - - auto isPlusSide = [&ttopo](const DetId& detid) { - return ttopo.side(detid) == static_cast(TrackerDetSide::PosEndcap); - }; - auto setDet = [&lnc, &dets, &isPlusSide]( - const int subdet, const int layer, const int isStereo, const DetId& detId, const DetLayer* lay) { - const int index = lnc.convertLayerNumber(subdet, layer, false, isStereo, isPlusSide(detId)); - if (index < 0 or static_cast(index) >= dets.size()) { - throw cms::Exception("LogicError") << "Invalid mkFit layer index " << index << " for det rawId " << detId.rawId() - << " " - << " subdet " << subdet << " layer " << layer << " isStereo " << isStereo; - } - dets[index] = lay; - }; - constexpr int monoLayer = 0; - constexpr int stereoLayer = 1; - for (const DetLayer* lay : tracker.allLayers()) { - const auto& comp = lay->basicComponents(); - if (UNLIKELY(comp.empty())) { - throw cms::Exception("LogicError") << "Got a tracker layer (subdet " << lay->subDetector() - << ") with empty basicComponents."; - } - // First component is enough for layer and side information - const auto& detId = comp.front()->geographicalId(); - const auto subdet = detId.subdetId(); - const auto layer = ttopo.layer(detId); - - // TODO: mono/stereo structure is still hardcoded for phase0/1 strip tracker - setDet(subdet, layer, monoLayer, detId, lay); - if (((subdet == StripSubdetector::TIB or subdet == StripSubdetector::TOB) and (layer == 1 or layer == 2)) or - subdet == StripSubdetector::TID or subdet == StripSubdetector::TEC) { - setDet(subdet, layer, stereoLayer, detId, lay); - } - } - - return dets; -} - TrackCandidateCollection MkFitOutputConverter::convertCandidates(const MkFitOutputWrapper& mkFitOutput, const MkFitHitIndexMap& hitIndexMap, const edm::View& seeds, - const TrackerGeometry& geom, const MagneticField& mf, const Propagator& propagatorAlong, const Propagator& propagatorOpposite, diff --git a/RecoTracker/MkFit/plugins/MkFitProducer.cc b/RecoTracker/MkFit/plugins/MkFitProducer.cc index 620171e8b02d1..ed6b375746aaa 100644 --- a/RecoTracker/MkFit/plugins/MkFitProducer.cc +++ b/RecoTracker/MkFit/plugins/MkFitProducer.cc @@ -5,18 +5,15 @@ #include "FWCore/Framework/interface/MakerMacros.h" #include "FWCore/ParameterSet/interface/ParameterSet.h" -#include "DataFormats/SiPixelDetId/interface/PixelSubdetector.h" -#include "DataFormats/SiStripDetId/interface/StripSubdetector.h" - -#include "Geometry/TrackerGeometryBuilder/interface/TrackerGeometry.h" -#include "Geometry/Records/interface/TrackerDigiGeometryRecord.h" - #include "RecoTracker/MkFit/interface/MkFitInputWrapper.h" #include "RecoTracker/MkFit/interface/MkFitOutputWrapper.h" +#include "RecoTracker/MkFit/interface/MkFitGeometry.h" +#include "RecoTracker/Record/interface/TrackerRecoGeometryRecord.h" // mkFit includes #include "ConfigWrapper.h" #include "Event.h" +#include "LayerNumberConverter.h" #include "mkFit/buildtestMPlex.h" #include "mkFit/MkBuilderWrapper.h" @@ -39,7 +36,7 @@ class MkFitProducer : public edm::global::EDProducer hitsSeedsToken_; - edm::ESGetToken geomToken_; + const edm::ESGetToken mkFitGeomToken_; edm::EDPutTokenT putToken_; std::function buildFunction_; bool backwardFitInCMSSW_; @@ -48,7 +45,7 @@ class MkFitProducer : public edm::global::EDProducer(iConfig.getParameter("hitsSeeds"))}, - geomToken_{esConsumes()}, + mkFitGeomToken_{esConsumes()}, putToken_{produces()}, backwardFitInCMSSW_{iConfig.getParameter("backwardFitInCMSSW")}, mkFitSilent_{iConfig.getUntrackedParameter("mkFitSilent")} { @@ -112,17 +109,19 @@ namespace { } void MkFitProducer::produce(edm::StreamID iID, edm::Event& iEvent, const edm::EventSetup& iSetup) const { const auto& hitsSeeds = iEvent.get(hitsSeedsToken_); - const auto& geom = iSetup.getData(geomToken_); - - if (geom.numberOfLayers(PixelSubdetector::PixelBarrel) != 4 || - geom.numberOfLayers(PixelSubdetector::PixelEndcap) != 3) { - throw cms::Exception("Assert") << "For now this code works only with phase1 tracker, you have something else"; - } + // This producer does not strictly speaking need the MkFitGeometry, + // but the ESProducer sets global variables (yes, that "feature" + // should be removed), so getting the MkFitGeometry makes it + // sure that the ESProducer is called even if the input/output + // converters + const auto& mkFitGeom = iSetup.getData(mkFitGeomToken_); // Initialize the number of layers, has to be done exactly once in // the whole program. // TODO: the mechanism needs to be improved... - std::call_once(geometryFlag, [nlayers = hitsSeeds.nlayers()]() { mkfit::ConfigWrapper::setNTotalLayers(nlayers); }); + std::call_once(geometryFlag, [nlayers = mkFitGeom.layerNumberConverter().nLayers()]() { + mkfit::ConfigWrapper::setNTotalLayers(nlayers); + }); // CMSSW event ID (64-bit unsigned) does not fit in int // In addition, unique ID requires also lumi and run diff --git a/RecoTracker/MkFit/python/customizeInitialStepOnly.py b/RecoTracker/MkFit/python/customizeInitialStepOnly.py index 9c4e0ef7f4e3d..4f3e3f356e91c 100644 --- a/RecoTracker/MkFit/python/customizeInitialStepOnly.py +++ b/RecoTracker/MkFit/python/customizeInitialStepOnly.py @@ -12,11 +12,9 @@ def customizeInitialStepOnly(process): process.initialStepSeedLayers.BPix.HitProducer = 'siPixelRecHitsPreSplitting' process.initialStepHitQuadruplets.SeedComparitorPSet.clusterShapeCacheSrc = "siPixelClusterShapeCachePreSplitting" process.initialStepSeeds.SeedComparitorPSet.ClusterShapeCacheSrc = "siPixelClusterShapeCachePreSplitting" - if hasattr(process.initialStepTrackCandidates, "measurementTrackerEvent"): - # mkFit case - process.initialStepTrackCandidates.measurementTrackerEvent = 'MeasurementTrackerEventPreSplitting' + if hasattr(process, "initialStepTrackCandidatesMkFitInput"): process.initialStepTrackCandidatesMkFitInput.pixelRecHits = "siPixelRecHitsPreSplitting" - else: + if hasattr(process.initialStepTrackCandidates, "MeasurementTrackerEvent"): process.initialStepTrackCandidates.MeasurementTrackerEvent = 'MeasurementTrackerEventPreSplitting' process.initialStepTracks.MeasurementTrackerEvent = 'MeasurementTrackerEventPreSplitting' process.iterTrackingTask = cms.Task(process.trackerClusterCheck, diff --git a/RecoTracker/MkFit/src/ES_MkFitGeometry.cc b/RecoTracker/MkFit/src/ES_MkFitGeometry.cc new file mode 100644 index 0000000000000..233f6e3827fda --- /dev/null +++ b/RecoTracker/MkFit/src/ES_MkFitGeometry.cc @@ -0,0 +1,3 @@ +#include "RecoTracker/MkFit/interface/MkFitGeometry.h" +#include "FWCore/Utilities/interface/typelookup.h" +TYPELOOKUP_DATA_REG(MkFitGeometry); diff --git a/RecoTracker/MkFit/src/MkFitGeometry.cc b/RecoTracker/MkFit/src/MkFitGeometry.cc new file mode 100644 index 0000000000000..c03abe96eb80c --- /dev/null +++ b/RecoTracker/MkFit/src/MkFitGeometry.cc @@ -0,0 +1,57 @@ +#include "DataFormats/SiStripDetId/interface/StripSubdetector.h" +#include "DataFormats/TrackerCommon/interface/TrackerTopology.h" +#include "DataFormats/TrackerCommon/interface/TrackerDetSide.h" +#include "Geometry/TrackerGeometryBuilder/interface/TrackerGeometry.h" +#include "RecoTracker/TkDetLayers/interface/GeometricSearchTracker.h" +#include "RecoTracker/MkFit/interface/MkFitGeometry.h" + +#include "LayerNumberConverter.h" + +MkFitGeometry::MkFitGeometry(const TrackerGeometry& geom, + const GeometricSearchTracker& tracker, + const TrackerTopology& ttopo) + : lnc_{std::make_unique(mkfit::TkLayout::phase1)} { + if (geom.numberOfLayers(PixelSubdetector::PixelBarrel) != 4 || + geom.numberOfLayers(PixelSubdetector::PixelEndcap) != 3) { + throw cms::Exception("Assert") << "For now this code works only with phase1 tracker, you have something else"; + } + + // Create DetLayer structure + dets_.resize(lnc_->nLayers(), nullptr); + auto isPlusSide = [&ttopo](const DetId& detid) { + return ttopo.side(detid) == static_cast(TrackerDetSide::PosEndcap); + }; + auto setDet = [this, &isPlusSide]( + const int subdet, const int layer, const int isStereo, const DetId& detId, const DetLayer* lay) { + const int index = lnc_->convertLayerNumber(subdet, layer, false, isStereo, isPlusSide(detId)); + if (index < 0 or static_cast(index) >= dets_.size()) { + throw cms::Exception("LogicError") << "Invalid mkFit layer index " << index << " for DetId " << detId.rawId() + << " subdet " << subdet << " layer " << layer << " isStereo " << isStereo; + } + dets_[index] = lay; + }; + constexpr int monoLayer = 0; + constexpr int stereoLayer = 1; + for (const DetLayer* lay : tracker.allLayers()) { + const auto& comp = lay->basicComponents(); + if (UNLIKELY(comp.empty())) { + throw cms::Exception("LogicError") << "Got a tracker layer (subdet " << lay->subDetector() + << ") with empty basicComponents."; + } + // First component is enough for layer and side information + const auto& detId = comp.front()->geographicalId(); + const auto subdet = detId.subdetId(); + const auto layer = ttopo.layer(detId); + + // TODO: mono/stereo structure is still hardcoded for phase0/1 strip tracker + setDet(subdet, layer, monoLayer, detId, lay); + if (((subdet == StripSubdetector::TIB or subdet == StripSubdetector::TOB) and (layer == 1 or layer == 2)) or + subdet == StripSubdetector::TID or subdet == StripSubdetector::TEC) { + setDet(subdet, layer, stereoLayer, detId, lay); + } + } +} + +// Explicit out-of-line because of the mkfit::LayerNumberConverter is +// only forward declared in the header +MkFitGeometry::~MkFitGeometry() {} diff --git a/RecoTracker/MkFit/src/MkFitInputWrapper.cc b/RecoTracker/MkFit/src/MkFitInputWrapper.cc index 06f6c6d59d74f..f9c31eb22c4fe 100644 --- a/RecoTracker/MkFit/src/MkFitInputWrapper.cc +++ b/RecoTracker/MkFit/src/MkFitInputWrapper.cc @@ -9,16 +9,12 @@ MkFitInputWrapper::MkFitInputWrapper() = default; MkFitInputWrapper::MkFitInputWrapper(MkFitHitIndexMap hitIndexMap, std::vector hits, - mkfit::TrackVec seeds, - mkfit::LayerNumberConverter const& lnc) + mkfit::TrackVec seeds) : hitIndexMap_{std::move(hitIndexMap)}, hits_{std::move(hits)}, - seeds_{std::make_unique(std::move(seeds))}, - lnc_{std::make_unique(lnc)} {} + seeds_{std::make_unique(std::move(seeds))} {} MkFitInputWrapper::~MkFitInputWrapper() = default; MkFitInputWrapper::MkFitInputWrapper(MkFitInputWrapper&&) = default; MkFitInputWrapper& MkFitInputWrapper::operator=(MkFitInputWrapper&&) = default; - -unsigned int MkFitInputWrapper::nlayers() const { return lnc_->nLayers(); } From 465900aef0d28c0f00eb7b363cb259039633061b Mon Sep 17 00:00:00 2001 From: Matti Kortelainen Date: Fri, 4 Oct 2019 12:22:55 -0700 Subject: [PATCH 03/20] Migrate to the updated hit interface --- RecoTracker/MkFit/interface/MkFitGeometry.h | 3 ++ .../MkFit/plugins/MkFitInputConverter.cc | 46 +++++++++++++------ RecoTracker/MkFit/src/MkFitGeometry.cc | 10 ++++ 3 files changed, 46 insertions(+), 13 deletions(-) diff --git a/RecoTracker/MkFit/interface/MkFitGeometry.h b/RecoTracker/MkFit/interface/MkFitGeometry.h index c69c7b83b28bb..670cd446c2c11 100644 --- a/RecoTracker/MkFit/interface/MkFitGeometry.h +++ b/RecoTracker/MkFit/interface/MkFitGeometry.h @@ -2,6 +2,7 @@ #define RecoTracker_MkFit_MkFitGeometry_h #include +#include #include namespace mkfit { @@ -25,10 +26,12 @@ class MkFitGeometry { mkfit::LayerNumberConverter const& layerNumberConverter() const { return *lnc_; } const std::vector& detLayers() const { return dets_; } + unsigned int uniqueIdInLayer(unsigned int detId) const { return detIdToShortId_.at(detId); } private: std::unique_ptr lnc_; // for pimpl pattern std::vector dets_; + std::unordered_map detIdToShortId_; }; #endif diff --git a/RecoTracker/MkFit/plugins/MkFitInputConverter.cc b/RecoTracker/MkFit/plugins/MkFitInputConverter.cc index 3ed202b8555e9..c5764fe629e4d 100644 --- a/RecoTracker/MkFit/plugins/MkFitInputConverter.cc +++ b/RecoTracker/MkFit/plugins/MkFitInputConverter.cc @@ -51,11 +51,14 @@ class MkFitInputConverter : public edm::global::EDProducer<> { int& totalHits, const TrackerTopology& ttopo, const TransientTrackingRecHitBuilder& ttrhBuilder, - const mkfit::LayerNumberConverter& lnc) const; + const MkFitGeometry& mkFitGeom) const; bool passCCC(const SiStripRecHit2D& hit, const DetId hitId) const; bool passCCC(const SiPixelRecHit& hit, const DetId hitId) const; + void setDetails(mkfit::Hit& mhit, const SiPixelRecHit& hit, const DetId hitId, const int shortId) const; + void setDetails(mkfit::Hit& mhit, const SiStripRecHit2D& hit, const DetId hitId, const int shortId) const; + mkfit::TrackVec convertSeeds(const edm::View& seeds, const MkFitHitIndexMap& hitIndexMap, const TransientTrackingRecHitBuilder& ttrhBuilder, @@ -72,6 +75,7 @@ class MkFitInputConverter : public edm::global::EDProducer<> { edm::ESGetToken ttrhBuilderToken_; edm::ESGetToken ttopoToken_; edm::ESGetToken mfToken_; + edm::ESGetToken mkFitGeomToken_; edm::EDPutTokenT putToken_; const float minGoodStripCharge_; }; @@ -87,6 +91,7 @@ MkFitInputConverter::MkFitInputConverter(edm::ParameterSet const& iConfig) iConfig.getParameter("ttrhBuilder"))}, ttopoToken_{esConsumes()}, mfToken_{esConsumes()}, + mkFitGeomToken_{esConsumes()}, putToken_{produces()}, minGoodStripCharge_{static_cast( iConfig.getParameter("minGoodStripCharge").getParameter("value"))} {} @@ -111,18 +116,15 @@ void MkFitInputConverter::produce(edm::StreamID iID, edm::Event& iEvent, const e // Then import hits const auto& ttrhBuilder = iSetup.getData(ttrhBuilderToken_); const auto& ttopo = iSetup.getData(ttopoToken_); + const auto& mkFitGeom = iSetup.getData(mkFitGeomToken_); - edm::ESHandle mkFitGeom; - iSetup.get().get(mkFitGeom); - const auto& lnc = mkFitGeom->layerNumberConverter(); - - std::vector mkFitHits(lnc.nLayers()); + std::vector mkFitHits(mkFitGeom.layerNumberConverter().nLayers()); MkFitHitIndexMap hitIndexMap; int totalHits = 0; // I need to have a global hit index in order to have the hit remapping working? // Process strips first for better memory allocation pattern - convertHits(iEvent.get(stripRphiRecHitToken_), mkFitHits, hitIndexMap, totalHits, ttopo, ttrhBuilder, lnc); - convertHits(iEvent.get(stripStereoRecHitToken_), mkFitHits, hitIndexMap, totalHits, ttopo, ttrhBuilder, lnc); - convertHits(iEvent.get(pixelRecHitToken_), mkFitHits, hitIndexMap, totalHits, ttopo, ttrhBuilder, lnc); + convertHits(iEvent.get(stripRphiRecHitToken_), mkFitHits, hitIndexMap, totalHits, ttopo, ttrhBuilder, mkFitGeom); + convertHits(iEvent.get(stripStereoRecHitToken_), mkFitHits, hitIndexMap, totalHits, ttopo, ttrhBuilder, mkFitGeom); + convertHits(iEvent.get(pixelRecHitToken_), mkFitHits, hitIndexMap, totalHits, ttopo, ttrhBuilder, mkFitGeom); // Then import seeds auto mkFitSeeds = convertSeeds(iEvent.get(seedToken_), hitIndexMap, ttrhBuilder, iSetup.getData(mfToken_)); @@ -136,6 +138,22 @@ bool MkFitInputConverter::passCCC(const SiStripRecHit2D& hit, const DetId hitId) bool MkFitInputConverter::passCCC(const SiPixelRecHit& hit, const DetId hitId) const { return true; } +void MkFitInputConverter::setDetails(mkfit::Hit& mhit, + const SiPixelRecHit& hit, + const DetId hitId, + const int shortId) const { + mhit.setupAsPixel(shortId, hit.cluster()->sizeX(), hit.cluster()->sizeY()); +} + +void MkFitInputConverter::setDetails(mkfit::Hit& mhit, + const SiStripRecHit2D& hit, + const DetId hitId, + const int shortId) const { + mhit.setupAsStrip(shortId, + siStripClusterTools::chargePerCM(hitId, hit.firstClusterRef().stripCluster()), + hit.cluster()->amplitudes().size()); +} + template void MkFitInputConverter::convertHits(const HitCollection& hits, std::vector& mkFitHits, @@ -143,7 +161,7 @@ void MkFitInputConverter::convertHits(const HitCollection& hits, int& totalHits, const TrackerTopology& ttopo, const TransientTrackingRecHitBuilder& ttrhBuilder, - const mkfit::LayerNumberConverter& lnc) const { + const MkFitGeometry& mkFitGeom) const { if (hits.empty()) return; auto isPlusSide = [&ttopo](const DetId& detid) { @@ -152,8 +170,8 @@ void MkFitInputConverter::convertHits(const HitCollection& hits, { const DetId detid{hits.ids().back()}; - const auto ilay = - lnc.convertLayerNumber(detid.subdetId(), ttopo.layer(detid), false, ttopo.isStereo(detid), isPlusSide(detid)); + const auto ilay = mkFitGeom.layerNumberConverter().convertLayerNumber( + detid.subdetId(), ttopo.layer(detid), false, ttopo.isStereo(detid), isPlusSide(detid)); // Do initial reserves to minimize further memory allocations const auto& lastClusterRef = hits.data().back().firstClusterRef(); hitIndexMap.resizeByClusterIndex(lastClusterRef.id(), lastClusterRef.index()); @@ -165,7 +183,8 @@ void MkFitInputConverter::convertHits(const HitCollection& hits, const auto subdet = detid.subdetId(); const auto layer = ttopo.layer(detid); const auto isStereo = ttopo.isStereo(detid); - const auto ilay = lnc.convertLayerNumber(subdet, layer, false, isStereo, isPlusSide(detid)); + const auto ilay = + mkFitGeom.layerNumberConverter().convertLayerNumber(subdet, layer, false, isStereo, isPlusSide(detid)); hitIndexMap.increaseLayerSize(ilay, detset.size()); // to minimize memory allocations for (const auto& hit : detset) { @@ -192,6 +211,7 @@ void MkFitInputConverter::convertHits(const HitCollection& hits, MkFitHitIndexMap::MkFitHit{static_cast(mkFitHits[ilay].size()), ilay}, &hit); mkFitHits[ilay].emplace_back(pos, err, totalHits); + setDetails(mkFitHits[ilay].back(), hit, detid, mkFitGeom.uniqueIdInLayer(detid.rawId())); ++totalHits; } } diff --git a/RecoTracker/MkFit/src/MkFitGeometry.cc b/RecoTracker/MkFit/src/MkFitGeometry.cc index c03abe96eb80c..91d1fa7b55f4e 100644 --- a/RecoTracker/MkFit/src/MkFitGeometry.cc +++ b/RecoTracker/MkFit/src/MkFitGeometry.cc @@ -50,6 +50,16 @@ MkFitGeometry::MkFitGeometry(const TrackerGeometry& geom, setDet(subdet, layer, stereoLayer, detId, lay); } } + + // Create "short id" aka "unique id within layer" + std::vector idInLayer(lnc_->nLayers(), 0); + for (const auto& detId : geom.detIds()) { + const auto ilay = + lnc_->convertLayerNumber(detId.subdetId(), ttopo.layer(detId), false, ttopo.isStereo(detId), isPlusSide(detId)); + detIdToShortId_[detId.rawId()] = idInLayer[ilay]++; + // Make sure the short id fits in the 12 bits... + assert(idInLayer[ilay] < (int)1 << 11); + } } // Explicit out-of-line because of the mkfit::LayerNumberConverter is From 17d5077bd72441b3c134a194c10b3e86860aff3d Mon Sep 17 00:00:00 2001 From: Matti Kortelainen Date: Thu, 10 Oct 2019 12:36:25 -0700 Subject: [PATCH 04/20] Compute cluster charge only once, dereference Refs only once) --- .../MkFit/plugins/MkFitInputConverter.cc | 42 +++++++++---------- 1 file changed, 21 insertions(+), 21 deletions(-) diff --git a/RecoTracker/MkFit/plugins/MkFitInputConverter.cc b/RecoTracker/MkFit/plugins/MkFitInputConverter.cc index c5764fe629e4d..608f5a5e7a7f4 100644 --- a/RecoTracker/MkFit/plugins/MkFitInputConverter.cc +++ b/RecoTracker/MkFit/plugins/MkFitInputConverter.cc @@ -53,11 +53,14 @@ class MkFitInputConverter : public edm::global::EDProducer<> { const TransientTrackingRecHitBuilder& ttrhBuilder, const MkFitGeometry& mkFitGeom) const; - bool passCCC(const SiStripRecHit2D& hit, const DetId hitId) const; - bool passCCC(const SiPixelRecHit& hit, const DetId hitId) const; + float clusterCharge(const SiStripRecHit2D& hit, DetId hitId) const; + std::nullptr_t clusterCharge(const SiPixelRecHit& hit, DetId hitId) const; - void setDetails(mkfit::Hit& mhit, const SiPixelRecHit& hit, const DetId hitId, const int shortId) const; - void setDetails(mkfit::Hit& mhit, const SiStripRecHit2D& hit, const DetId hitId, const int shortId) const; + bool passCCC(float charge) const; + bool passCCC(std::nullptr_t) const; //pixel + + void setDetails(mkfit::Hit& mhit, const SiPixelCluster& cluster, const int shortId, std::nullptr_t) const; + void setDetails(mkfit::Hit& mhit, const SiStripCluster& cluster, const int shortId, float charge) const; mkfit::TrackVec convertSeeds(const edm::View& seeds, const MkFitHitIndexMap& hitIndexMap, @@ -132,26 +135,21 @@ void MkFitInputConverter::produce(edm::StreamID iID, edm::Event& iEvent, const e iEvent.emplace(putToken_, std::move(hitIndexMap), std::move(mkFitHits), std::move(mkFitSeeds)); } -bool MkFitInputConverter::passCCC(const SiStripRecHit2D& hit, const DetId hitId) const { - return (siStripClusterTools::chargePerCM(hitId, hit.firstClusterRef().stripCluster()) > minGoodStripCharge_); +float MkFitInputConverter::clusterCharge(const SiStripRecHit2D& hit, DetId hitId) const { + return siStripClusterTools::chargePerCM(hitId, hit.firstClusterRef().stripCluster()); } +std::nullptr_t MkFitInputConverter::clusterCharge(const SiPixelRecHit& hit, DetId hitId) const { return nullptr; } + +bool MkFitInputConverter::passCCC(float charge) const { return charge > minGoodStripCharge_; } -bool MkFitInputConverter::passCCC(const SiPixelRecHit& hit, const DetId hitId) const { return true; } +bool MkFitInputConverter::passCCC(std::nullptr_t) const { return true; } -void MkFitInputConverter::setDetails(mkfit::Hit& mhit, - const SiPixelRecHit& hit, - const DetId hitId, - const int shortId) const { - mhit.setupAsPixel(shortId, hit.cluster()->sizeX(), hit.cluster()->sizeY()); +void MkFitInputConverter::setDetails(mkfit::Hit& mhit, const SiPixelCluster& cluster, int shortId, std::nullptr_t) const { + mhit.setupAsPixel(shortId, cluster.sizeX(), cluster.sizeY()); } -void MkFitInputConverter::setDetails(mkfit::Hit& mhit, - const SiStripRecHit2D& hit, - const DetId hitId, - const int shortId) const { - mhit.setupAsStrip(shortId, - siStripClusterTools::chargePerCM(hitId, hit.firstClusterRef().stripCluster()), - hit.cluster()->amplitudes().size()); +void MkFitInputConverter::setDetails(mkfit::Hit& mhit, const SiStripCluster& cluster, int shortId, float charge) const { + mhit.setupAsStrip(shortId, charge, cluster.amplitudes().size()); } template @@ -183,12 +181,14 @@ void MkFitInputConverter::convertHits(const HitCollection& hits, const auto subdet = detid.subdetId(); const auto layer = ttopo.layer(detid); const auto isStereo = ttopo.isStereo(detid); + const auto uniqueIdInLayer = mkFitGeom.uniqueIdInLayer(detid.rawId()); const auto ilay = mkFitGeom.layerNumberConverter().convertLayerNumber(subdet, layer, false, isStereo, isPlusSide(detid)); hitIndexMap.increaseLayerSize(ilay, detset.size()); // to minimize memory allocations for (const auto& hit : detset) { - if (!passCCC(hit, detid)) + const auto charge = clusterCharge(hit, detid); + if (!passCCC(charge)) continue; const auto& gpos = hit.globalPosition(); @@ -211,7 +211,7 @@ void MkFitInputConverter::convertHits(const HitCollection& hits, MkFitHitIndexMap::MkFitHit{static_cast(mkFitHits[ilay].size()), ilay}, &hit); mkFitHits[ilay].emplace_back(pos, err, totalHits); - setDetails(mkFitHits[ilay].back(), hit, detid, mkFitGeom.uniqueIdInLayer(detid.rawId())); + setDetails(mkFitHits[ilay].back(), *(hit.cluster()), uniqueIdInLayer, charge); ++totalHits; } } From 5bc116972056aec90eeb68648f50aff50b9cea9c Mon Sep 17 00:00:00 2001 From: Matti Kortelainen Date: Thu, 10 Oct 2019 13:30:45 -0700 Subject: [PATCH 05/20] A hashmap per layer is a bit faster --- RecoTracker/MkFit/interface/MkFitGeometry.h | 4 ++-- RecoTracker/MkFit/plugins/MkFitInputConverter.cc | 2 +- RecoTracker/MkFit/src/MkFitGeometry.cc | 8 +++++--- 3 files changed, 8 insertions(+), 6 deletions(-) diff --git a/RecoTracker/MkFit/interface/MkFitGeometry.h b/RecoTracker/MkFit/interface/MkFitGeometry.h index 670cd446c2c11..b9c6515d356a5 100644 --- a/RecoTracker/MkFit/interface/MkFitGeometry.h +++ b/RecoTracker/MkFit/interface/MkFitGeometry.h @@ -26,12 +26,12 @@ class MkFitGeometry { mkfit::LayerNumberConverter const& layerNumberConverter() const { return *lnc_; } const std::vector& detLayers() const { return dets_; } - unsigned int uniqueIdInLayer(unsigned int detId) const { return detIdToShortId_.at(detId); } + unsigned int uniqueIdInLayer(int layer, unsigned int detId) const { return detIdToShortId_.at(layer).at(detId); } private: std::unique_ptr lnc_; // for pimpl pattern std::vector dets_; - std::unordered_map detIdToShortId_; + std::vector> detIdToShortId_; }; #endif diff --git a/RecoTracker/MkFit/plugins/MkFitInputConverter.cc b/RecoTracker/MkFit/plugins/MkFitInputConverter.cc index 608f5a5e7a7f4..291cd97af07de 100644 --- a/RecoTracker/MkFit/plugins/MkFitInputConverter.cc +++ b/RecoTracker/MkFit/plugins/MkFitInputConverter.cc @@ -181,9 +181,9 @@ void MkFitInputConverter::convertHits(const HitCollection& hits, const auto subdet = detid.subdetId(); const auto layer = ttopo.layer(detid); const auto isStereo = ttopo.isStereo(detid); - const auto uniqueIdInLayer = mkFitGeom.uniqueIdInLayer(detid.rawId()); const auto ilay = mkFitGeom.layerNumberConverter().convertLayerNumber(subdet, layer, false, isStereo, isPlusSide(detid)); + const auto uniqueIdInLayer = mkFitGeom.uniqueIdInLayer(ilay, detid.rawId()); hitIndexMap.increaseLayerSize(ilay, detset.size()); // to minimize memory allocations for (const auto& hit : detset) { diff --git a/RecoTracker/MkFit/src/MkFitGeometry.cc b/RecoTracker/MkFit/src/MkFitGeometry.cc index 91d1fa7b55f4e..a21f67d55d7fa 100644 --- a/RecoTracker/MkFit/src/MkFitGeometry.cc +++ b/RecoTracker/MkFit/src/MkFitGeometry.cc @@ -52,13 +52,15 @@ MkFitGeometry::MkFitGeometry(const TrackerGeometry& geom, } // Create "short id" aka "unique id within layer" - std::vector idInLayer(lnc_->nLayers(), 0); + detIdToShortId_.resize(lnc_->nLayers()); for (const auto& detId : geom.detIds()) { const auto ilay = lnc_->convertLayerNumber(detId.subdetId(), ttopo.layer(detId), false, ttopo.isStereo(detId), isPlusSide(detId)); - detIdToShortId_[detId.rawId()] = idInLayer[ilay]++; + auto& map = detIdToShortId_[ilay]; + const unsigned int ind = map.size(); // Make sure the short id fits in the 12 bits... - assert(idInLayer[ilay] < (int)1 << 11); + assert(ind < (int)1 << 11); + map[detId.rawId()] = ind; } } From 61f2f823c79ef2d91ee39fffbf5e53263bb080a7 Mon Sep 17 00:00:00 2001 From: Matti Kortelainen Date: Tue, 26 Nov 2019 00:04:55 +0100 Subject: [PATCH 06/20] Add customize function to run mkFit on HLT --- .../python/upgradeWorkflowComponents.py | 6 +++ .../MkFit/python/customizeHLTIter0ToMkFit.py | 48 +++++++++++++++++++ 2 files changed, 54 insertions(+) create mode 100644 RecoTracker/MkFit/python/customizeHLTIter0ToMkFit.py diff --git a/Configuration/PyReleaseValidation/python/upgradeWorkflowComponents.py b/Configuration/PyReleaseValidation/python/upgradeWorkflowComponents.py index 8b7ccd217e6c2..724a2e3f0639d 100644 --- a/Configuration/PyReleaseValidation/python/upgradeWorkflowComponents.py +++ b/Configuration/PyReleaseValidation/python/upgradeWorkflowComponents.py @@ -291,11 +291,14 @@ def condition_(self, fragment, stepList, key, hasHarvest): class UpgradeWorkflow_trackingMkFit(UpgradeWorkflowTracking): def setup_(self, step, stepName, stepDict, k, properties): + if 'Digi' in step: stepDict[stepName][k] = merge([self.step2, stepDict[step][k]]) if 'Reco' in step: stepDict[stepName][k] = merge([self.step3, stepDict[step][k]]) def condition_(self, fragment, stepList, key, hasHarvest): return '2017' in key or '2021' in key upgradeWFs['trackingMkFit'] = UpgradeWorkflow_trackingMkFit( steps = [ + 'Digi', + 'DigiTrigger', 'Reco', 'RecoGlobal', ], @@ -303,6 +306,9 @@ def condition_(self, fragment, stepList, key, hasHarvest): suffix = '_trackingMkFit', offset = 0.7, ) +upgradeWFs['trackingMkFit'].step2 = { + '--customise': 'RecoTracker/MkFit/customizeHLTIter0ToMkFit.customizeHLTIter0ToMkFit' +} upgradeWFs['trackingMkFit'].step3 = { '--procModifiers': 'trackingMkFit' } diff --git a/RecoTracker/MkFit/python/customizeHLTIter0ToMkFit.py b/RecoTracker/MkFit/python/customizeHLTIter0ToMkFit.py new file mode 100644 index 0000000000000..1d0eaf99e6988 --- /dev/null +++ b/RecoTracker/MkFit/python/customizeHLTIter0ToMkFit.py @@ -0,0 +1,48 @@ +import FWCore.ParameterSet.Config as cms + +import RecoTracker.MkFit.mkFitGeometryESProducer_cfi as mkFitGeometryESProducer_cfi +import RecoTracker.MkFit.mkFitInputConverter_cfi as mkFitInputConverter_cfi +import RecoTracker.MkFit.mkFitProducer_cfi as mkFitProducer_cfi +import RecoTracker.MkFit.mkFitOutputConverter_cfi as mkFitOutputConverter_cfi +import RecoLocalTracker.SiStripRecHitConverter.SiStripRecHitConverter_cfi as SiStripRecHitConverter_cfi + +def customizeHLTIter0ToMkFit(process): + # mkFit needs all clusters, so switch off the on-demand mode + process.hltSiStripRawToClustersFacility.onDemand = False + + process.hltSiStripRecHits = SiStripRecHitConverter_cfi.siStripMatchedRecHits.clone( + ClusterProducer = "hltSiStripRawToClustersFacility", + StripCPE = "hltESPStripCPEfromTrackAngle:hltESPStripCPEfromTrackAngle", + doMatching = False, + ) + + # Use fourth hit if one is available + process.hltIter0PFLowPixelSeedsFromPixelTracks.includeFourthHit = cms.bool(True) + + process.hltMkFitGeometryESProducer = mkFitGeometryESProducer_cfi.mkFitGeometryESProducer.clone() + + process.hltIter0PFlowCkfTrackCandidatesMkFitInput = mkFitInputConverter_cfi.mkFitInputConverter.clone( + pixelRecHits = "hltSiPixelRecHits", + stripRphiRecHits = "hltSiStripRecHits:rphiRecHit", + stripStereoRecHits = "hltSiStripRecHits:stereoRecHit", + seeds = "hltIter0PFLowPixelSeedsFromPixelTracks", + ttrhBuilder = ":hltESPTTRHBWithTrackAngle", + minGoodStripCharge = dict(refToPSet_ = 'HLTSiStripClusterChargeCutLoose'), + ) + process.hltIter0PFlowCkfTrackCandidatesMkFit = mkFitProducer_cfi.mkFitProducer.clone( + hitsSeeds = "hltIter0PFlowCkfTrackCandidatesMkFitInput", + ) + process.hltIter0PFlowCkfTrackCandidates = mkFitOutputConverter_cfi.mkFitOutputConverter.clone( + seeds = "hltIter0PFLowPixelSeedsFromPixelTracks", + hitsSeeds = "hltIter0PFlowCkfTrackCandidatesMkFitInput", + tracks = "hltIter0PFlowCkfTrackCandidatesMkFit", + ttrhBuilder = ":hltESPTTRHBWithTrackAngle", + propagatorAlong = ":PropagatorWithMaterialParabolicMf", + propagatorOpposite = ":PropagatorWithMaterialParabolicMfOpposite", + ) + + process.HLTDoLocalStripSequence += process.hltSiStripRecHits + process.HLTIterativeTrackingIteration0.replace(process.hltIter0PFlowCkfTrackCandidates, + process.hltIter0PFlowCkfTrackCandidatesMkFitInput+process.hltIter0PFlowCkfTrackCandidatesMkFit+process.hltIter0PFlowCkfTrackCandidates) + + return process From 9ce486376bfc1a45cac2ada08339a49735d257a9 Mon Sep 17 00:00:00 2001 From: Matti Kortelainen Date: Thu, 12 Nov 2020 17:30:16 -0800 Subject: [PATCH 07/20] Split MkFitInput{Converter,Wrapper} to MkFitHit{Converter,Wrapper} and MkFitSeed{Converter,Wrapper} --- .../python/InitialStep_cff.py | 15 ++- RecoTracker/MkFit/interface/MkFitHitWrapper.h | 33 +++++ .../MkFit/interface/MkFitInputWrapper.h | 38 ------ .../MkFit/interface/MkFitSeedWrapper.h | 29 ++++ ...InputConverter.cc => MkFitHitConverter.cc} | 117 ++++------------ .../MkFit/plugins/MkFitOutputConverter.cc | 19 ++- RecoTracker/MkFit/plugins/MkFitProducer.cc | 17 ++- .../MkFit/plugins/MkFitSeedConverter.cc | 125 ++++++++++++++++++ .../MkFit/python/customizeHLTIter0ToMkFit.py | 19 ++- ...verter_cfi.py => mkFitHitConverter_cfi.py} | 4 +- RecoTracker/MkFit/src/MkFitHitWrapper.cc | 14 ++ RecoTracker/MkFit/src/MkFitInputWrapper.cc | 20 --- RecoTracker/MkFit/src/MkFitSeedWrapper.cc | 14 ++ RecoTracker/MkFit/src/classes.h | 3 +- RecoTracker/MkFit/src/classes_def.xml | 7 +- 15 files changed, 298 insertions(+), 176 deletions(-) create mode 100644 RecoTracker/MkFit/interface/MkFitHitWrapper.h delete mode 100644 RecoTracker/MkFit/interface/MkFitInputWrapper.h create mode 100644 RecoTracker/MkFit/interface/MkFitSeedWrapper.h rename RecoTracker/MkFit/plugins/{MkFitInputConverter.cc => MkFitHitConverter.cc} (60%) create mode 100644 RecoTracker/MkFit/plugins/MkFitSeedConverter.cc rename RecoTracker/MkFit/python/{mkFitInputConverter_cfi.py => mkFitHitConverter_cfi.py} (55%) create mode 100644 RecoTracker/MkFit/src/MkFitHitWrapper.cc delete mode 100644 RecoTracker/MkFit/src/MkFitInputWrapper.cc create mode 100644 RecoTracker/MkFit/src/MkFitSeedWrapper.cc diff --git a/RecoTracker/IterativeTracking/python/InitialStep_cff.py b/RecoTracker/IterativeTracking/python/InitialStep_cff.py index 0244600a2729b..c78c336461b10 100644 --- a/RecoTracker/IterativeTracking/python/InitialStep_cff.py +++ b/RecoTracker/IterativeTracking/python/InitialStep_cff.py @@ -225,18 +225,23 @@ from Configuration.ProcessModifiers.trackingMkFit_cff import trackingMkFit from RecoTracker.MkFit.mkFitGeometryESProducer_cfi import mkFitGeometryESProducer -import RecoTracker.MkFit.mkFitInputConverter_cfi as mkFitInputConverter_cfi +import RecoTracker.MkFit.mkFitHitConverter_cfi as mkFitHitConverter_cfi +import RecoTracker.MkFit.mkFitSeedConverter_cfi as mkFitSeedConverter_cfi import RecoTracker.MkFit.mkFitProducer_cfi as mkFitProducer_cfi import RecoTracker.MkFit.mkFitOutputConverter_cfi as mkFitOutputConverter_cfi -initialStepTrackCandidatesMkFitInput = mkFitInputConverter_cfi.mkFitInputConverter.clone( +initialStepTrackCandidatesMkFitHits = mkFitHitConverter_cfi.mkFitHitConverter.clone() +initialStepTrackCandidatesMkFitSeeds = mkFitSeedConverter_cfi.mkFitSeedConverter.clone( + hits = 'initialStepTrackCandidatesMkFitHits', seeds = 'initialStepSeeds', ) initialStepTrackCandidatesMkFit = mkFitProducer_cfi.mkFitProducer.clone( - hitsSeeds = 'initialStepTrackCandidatesMkFitInput', + hits = 'initialStepTrackCandidatesMkFitHits', + seeds = 'initialStepTrackCandidatesMkFitSeeds', ) trackingMkFit.toReplaceWith(initialStepTrackCandidates, mkFitOutputConverter_cfi.mkFitOutputConverter.clone( seeds = 'initialStepSeeds', - hitsSeeds = 'initialStepTrackCandidatesMkFitInput', + mkfitHits = 'initialStepTrackCandidatesMkFitHits', + mkfitSeeds = 'initialStepTrackCandidatesMkFitSeeds', tracks = 'initialStepTrackCandidatesMkFit', )) @@ -415,7 +420,7 @@ InitialStep = cms.Sequence(InitialStepTask) _InitialStepTask_trackingMkFit = InitialStepTask.copy() -_InitialStepTask_trackingMkFit.add(initialStepTrackCandidatesMkFitInput, initialStepTrackCandidatesMkFit, mkFitGeometryESProducer) +_InitialStepTask_trackingMkFit.add(initialStepTrackCandidatesMkFitHits, initialStepTrackCandidatesMkFitSeeds, initialStepTrackCandidatesMkFit, mkFitGeometryESProducer) trackingMkFit.toReplaceWith(InitialStepTask, _InitialStepTask_trackingMkFit) _InitialStepTask_LowPU = InitialStepTask.copyAndExclude([firstStepPrimaryVerticesUnsorted, initialStepTrackRefsForJets, caloJetsForTrkTask, firstStepPrimaryVertices, initialStepClassifier1, initialStepClassifier2, initialStepClassifier3]) diff --git a/RecoTracker/MkFit/interface/MkFitHitWrapper.h b/RecoTracker/MkFit/interface/MkFitHitWrapper.h new file mode 100644 index 0000000000000..b1415d147bc87 --- /dev/null +++ b/RecoTracker/MkFit/interface/MkFitHitWrapper.h @@ -0,0 +1,33 @@ +#ifndef RecoTracker_MkFit_MkFitHitWrapper_h +#define RecoTracker_MkFit_MkFitHitWrapper_h + +#include "RecoTracker/MkFit/interface/MkFitHitIndexMap.h" + +#include + +namespace mkfit { + class Hit; + class LayerNumberConverter; + using HitVec = std::vector; +} // namespace mkfit + +class MkFitHitWrapper { +public: + MkFitHitWrapper(); + MkFitHitWrapper(MkFitHitIndexMap hitIndexMap, std::vector hits); + ~MkFitHitWrapper(); + + MkFitHitWrapper(MkFitHitWrapper const&) = delete; + MkFitHitWrapper& operator=(MkFitHitWrapper const&) = delete; + MkFitHitWrapper(MkFitHitWrapper&&); + MkFitHitWrapper& operator=(MkFitHitWrapper&&); + + MkFitHitIndexMap const& hitIndexMap() const { return hitIndexMap_; } + std::vector const& hits() const { return hits_; } + +private: + MkFitHitIndexMap hitIndexMap_; + std::vector hits_; +}; + +#endif diff --git a/RecoTracker/MkFit/interface/MkFitInputWrapper.h b/RecoTracker/MkFit/interface/MkFitInputWrapper.h deleted file mode 100644 index cd6d5647c58cc..0000000000000 --- a/RecoTracker/MkFit/interface/MkFitInputWrapper.h +++ /dev/null @@ -1,38 +0,0 @@ -#ifndef RecoTracker_MkFit_MkFitInputWrapper_h -#define RecoTracker_MkFit_MkFitInputWrapper_h - -#include "RecoTracker/MkFit/interface/MkFitHitIndexMap.h" - -#include -#include - -namespace mkfit { - class Hit; - class Track; - class LayerNumberConverter; - using HitVec = std::vector; - using TrackVec = std::vector; -} // namespace mkfit - -class MkFitInputWrapper { -public: - MkFitInputWrapper(); - MkFitInputWrapper(MkFitHitIndexMap hitIndexMap, std::vector hits, mkfit::TrackVec seeds); - ~MkFitInputWrapper(); - - MkFitInputWrapper(MkFitInputWrapper const&) = delete; - MkFitInputWrapper& operator=(MkFitInputWrapper const&) = delete; - MkFitInputWrapper(MkFitInputWrapper&&); - MkFitInputWrapper& operator=(MkFitInputWrapper&&); - - MkFitHitIndexMap const& hitIndexMap() const { return hitIndexMap_; } - mkfit::TrackVec const& seeds() const { return *seeds_; } - std::vector const& hits() const { return hits_; } - -private: - MkFitHitIndexMap hitIndexMap_; - std::vector hits_; - std::unique_ptr seeds_; // for pimpl pattern -}; - -#endif diff --git a/RecoTracker/MkFit/interface/MkFitSeedWrapper.h b/RecoTracker/MkFit/interface/MkFitSeedWrapper.h new file mode 100644 index 0000000000000..dbba531bf4fa8 --- /dev/null +++ b/RecoTracker/MkFit/interface/MkFitSeedWrapper.h @@ -0,0 +1,29 @@ +#ifndef RecoTracker_MkFit_MkFitSeedWrapper_h +#define RecoTracker_MkFit_MkFitSeedWrapper_h + +#include +#include + +namespace mkfit { + class Track; + using TrackVec = std::vector; +} // namespace mkfit + +class MkFitSeedWrapper { +public: + MkFitSeedWrapper(); + MkFitSeedWrapper(mkfit::TrackVec seeds); + ~MkFitSeedWrapper(); + + MkFitSeedWrapper(MkFitSeedWrapper const&) = delete; + MkFitSeedWrapper& operator=(MkFitSeedWrapper const&) = delete; + MkFitSeedWrapper(MkFitSeedWrapper&&); + MkFitSeedWrapper& operator=(MkFitSeedWrapper&&); + + mkfit::TrackVec const& seeds() const { return *seeds_; } + +private: + std::unique_ptr seeds_; // for pimpl pattern +}; + +#endif diff --git a/RecoTracker/MkFit/plugins/MkFitInputConverter.cc b/RecoTracker/MkFit/plugins/MkFitHitConverter.cc similarity index 60% rename from RecoTracker/MkFit/plugins/MkFitInputConverter.cc rename to RecoTracker/MkFit/plugins/MkFitHitConverter.cc index 291cd97af07de..9964ebeb68ffb 100644 --- a/RecoTracker/MkFit/plugins/MkFitInputConverter.cc +++ b/RecoTracker/MkFit/plugins/MkFitHitConverter.cc @@ -18,10 +18,7 @@ #include "TrackingTools/TransientTrackingRecHit/interface/TransientTrackingRecHitBuilder.h" #include "TrackingTools/TrajectoryState/interface/TrajectoryStateTransform.h" -#include "MagneticField/Engine/interface/MagneticField.h" -#include "MagneticField/Records/interface/IdealMagneticFieldRecord.h" - -#include "RecoTracker/MkFit/interface/MkFitInputWrapper.h" +#include "RecoTracker/MkFit/interface/MkFitHitWrapper.h" #include "RecoTracker/MkFit/interface/MkFitGeometry.h" #include "RecoTracker/Record/interface/TrackerRecoGeometryRecord.h" @@ -31,13 +28,12 @@ // mkFit includes #include "Hit.h" -#include "Track.h" #include "LayerNumberConverter.h" -class MkFitInputConverter : public edm::global::EDProducer<> { +class MkFitHitConverter : public edm::global::EDProducer<> { public: - explicit MkFitInputConverter(edm::ParameterSet const& iConfig); - ~MkFitInputConverter() override = default; + explicit MkFitHitConverter(edm::ParameterSet const& iConfig); + ~MkFitHitConverter() override = default; static void fillDescriptions(edm::ConfigurationDescriptions& descriptions); @@ -62,11 +58,6 @@ class MkFitInputConverter : public edm::global::EDProducer<> { void setDetails(mkfit::Hit& mhit, const SiPixelCluster& cluster, const int shortId, std::nullptr_t) const; void setDetails(mkfit::Hit& mhit, const SiStripCluster& cluster, const int shortId, float charge) const; - mkfit::TrackVec convertSeeds(const edm::View& seeds, - const MkFitHitIndexMap& hitIndexMap, - const TransientTrackingRecHitBuilder& ttrhBuilder, - const MagneticField& mf) const; - using SVector3 = ROOT::Math::SVector; using SMatrixSym33 = ROOT::Math::SMatrix>; using SMatrixSym66 = ROOT::Math::SMatrix>; @@ -74,48 +65,43 @@ class MkFitInputConverter : public edm::global::EDProducer<> { edm::EDGetTokenT pixelRecHitToken_; edm::EDGetTokenT stripRphiRecHitToken_; edm::EDGetTokenT stripStereoRecHitToken_; - edm::EDGetTokenT> seedToken_; edm::ESGetToken ttrhBuilderToken_; edm::ESGetToken ttopoToken_; - edm::ESGetToken mfToken_; edm::ESGetToken mkFitGeomToken_; - edm::EDPutTokenT putToken_; + edm::EDPutTokenT putToken_; const float minGoodStripCharge_; }; -MkFitInputConverter::MkFitInputConverter(edm::ParameterSet const& iConfig) +MkFitHitConverter::MkFitHitConverter(edm::ParameterSet const& iConfig) : pixelRecHitToken_{consumes(iConfig.getParameter("pixelRecHits"))}, stripRphiRecHitToken_{ consumes(iConfig.getParameter("stripRphiRecHits"))}, stripStereoRecHitToken_{ consumes(iConfig.getParameter("stripStereoRecHits"))}, - seedToken_{consumes>(iConfig.getParameter("seeds"))}, ttrhBuilderToken_{esConsumes( iConfig.getParameter("ttrhBuilder"))}, ttopoToken_{esConsumes()}, - mfToken_{esConsumes()}, mkFitGeomToken_{esConsumes()}, - putToken_{produces()}, + putToken_{produces()}, minGoodStripCharge_{static_cast( iConfig.getParameter("minGoodStripCharge").getParameter("value"))} {} -void MkFitInputConverter::fillDescriptions(edm::ConfigurationDescriptions& descriptions) { +void MkFitHitConverter::fillDescriptions(edm::ConfigurationDescriptions& descriptions) { edm::ParameterSetDescription desc; desc.add("pixelRecHits", edm::InputTag{"siPixelRecHits"}); desc.add("stripRphiRecHits", edm::InputTag{"siStripMatchedRecHits", "rphiRecHit"}); desc.add("stripStereoRecHits", edm::InputTag{"siStripMatchedRecHits", "stereoRecHit"}); - desc.add("seeds", edm::InputTag{"initialStepSeeds"}); desc.add("ttrhBuilder", edm::ESInputTag{"", "WithTrackAngle"}); edm::ParameterSetDescription descCCC; descCCC.add("value"); desc.add("minGoodStripCharge", descCCC); - descriptions.add("mkFitInputConverterDefault", desc); + descriptions.add("mkFitHitConverterDefault", desc); } -void MkFitInputConverter::produce(edm::StreamID iID, edm::Event& iEvent, const edm::EventSetup& iSetup) const { +void MkFitHitConverter::produce(edm::StreamID iID, edm::Event& iEvent, const edm::EventSetup& iSetup) const { // Then import hits const auto& ttrhBuilder = iSetup.getData(ttrhBuilderToken_); const auto& ttopo = iSetup.getData(ttopoToken_); @@ -129,37 +115,34 @@ void MkFitInputConverter::produce(edm::StreamID iID, edm::Event& iEvent, const e convertHits(iEvent.get(stripStereoRecHitToken_), mkFitHits, hitIndexMap, totalHits, ttopo, ttrhBuilder, mkFitGeom); convertHits(iEvent.get(pixelRecHitToken_), mkFitHits, hitIndexMap, totalHits, ttopo, ttrhBuilder, mkFitGeom); - // Then import seeds - auto mkFitSeeds = convertSeeds(iEvent.get(seedToken_), hitIndexMap, ttrhBuilder, iSetup.getData(mfToken_)); - - iEvent.emplace(putToken_, std::move(hitIndexMap), std::move(mkFitHits), std::move(mkFitSeeds)); + iEvent.emplace(putToken_, std::move(hitIndexMap), std::move(mkFitHits)); } -float MkFitInputConverter::clusterCharge(const SiStripRecHit2D& hit, DetId hitId) const { +float MkFitHitConverter::clusterCharge(const SiStripRecHit2D& hit, DetId hitId) const { return siStripClusterTools::chargePerCM(hitId, hit.firstClusterRef().stripCluster()); } -std::nullptr_t MkFitInputConverter::clusterCharge(const SiPixelRecHit& hit, DetId hitId) const { return nullptr; } +std::nullptr_t MkFitHitConverter::clusterCharge(const SiPixelRecHit& hit, DetId hitId) const { return nullptr; } -bool MkFitInputConverter::passCCC(float charge) const { return charge > minGoodStripCharge_; } +bool MkFitHitConverter::passCCC(float charge) const { return charge > minGoodStripCharge_; } -bool MkFitInputConverter::passCCC(std::nullptr_t) const { return true; } +bool MkFitHitConverter::passCCC(std::nullptr_t) const { return true; } -void MkFitInputConverter::setDetails(mkfit::Hit& mhit, const SiPixelCluster& cluster, int shortId, std::nullptr_t) const { +void MkFitHitConverter::setDetails(mkfit::Hit& mhit, const SiPixelCluster& cluster, int shortId, std::nullptr_t) const { mhit.setupAsPixel(shortId, cluster.sizeX(), cluster.sizeY()); } -void MkFitInputConverter::setDetails(mkfit::Hit& mhit, const SiStripCluster& cluster, int shortId, float charge) const { +void MkFitHitConverter::setDetails(mkfit::Hit& mhit, const SiStripCluster& cluster, int shortId, float charge) const { mhit.setupAsStrip(shortId, charge, cluster.amplitudes().size()); } template -void MkFitInputConverter::convertHits(const HitCollection& hits, - std::vector& mkFitHits, - MkFitHitIndexMap& hitIndexMap, - int& totalHits, - const TrackerTopology& ttopo, - const TransientTrackingRecHitBuilder& ttrhBuilder, - const MkFitGeometry& mkFitGeom) const { +void MkFitHitConverter::convertHits(const HitCollection& hits, + std::vector& mkFitHits, + MkFitHitIndexMap& hitIndexMap, + int& totalHits, + const TrackerTopology& ttopo, + const TransientTrackingRecHitBuilder& ttrhBuilder, + const MkFitGeometry& mkFitGeom) const { if (hits.empty()) return; auto isPlusSide = [&ttopo](const DetId& detid) { @@ -202,9 +185,9 @@ void MkFitInputConverter::convertHits(const HitCollection& hits, err.At(0, 2) = gerr.czx(); err.At(1, 2) = gerr.czy(); - LogTrace("MkFitInputConverter") << "Adding hit detid " << detid.rawId() << " subdet " << subdet << " layer " - << layer << " isStereo " << isStereo << " zplus " << isPlusSide(detid) << " ilay " - << ilay; + LogTrace("MkFitHitConverter") << "Adding hit detid " << detid.rawId() << " subdet " << subdet << " layer " + << layer << " isStereo " << isStereo << " zplus " << isPlusSide(detid) << " ilay " + << ilay; hitIndexMap.insert(hit.firstClusterRef().id(), hit.firstClusterRef().index(), @@ -217,48 +200,4 @@ void MkFitInputConverter::convertHits(const HitCollection& hits, } } -mkfit::TrackVec MkFitInputConverter::convertSeeds(const edm::View& seeds, - const MkFitHitIndexMap& hitIndexMap, - const TransientTrackingRecHitBuilder& ttrhBuilder, - const MagneticField& mf) const { - mkfit::TrackVec ret; - ret.reserve(seeds.size()); - int index = 0; - for (const auto& seed : seeds) { - auto const& hitRange = seed.recHits(); - const auto lastRecHit = ttrhBuilder.build(&*(hitRange.end() - 1)); - const auto tsos = trajectoryStateTransform::transientState(seed.startingState(), lastRecHit->surface(), &mf); - const auto& stateGlobal = tsos.globalParameters(); - const auto& gpos = stateGlobal.position(); - const auto& gmom = stateGlobal.momentum(); - SVector3 pos(gpos.x(), gpos.y(), gpos.z()); - SVector3 mom(gmom.x(), gmom.y(), gmom.z()); - - const auto cartError = tsos.cartesianError(); // returns a temporary, so can't chain with the following line - const auto& cov = cartError.matrix(); - SMatrixSym66 err; - for (int i = 0; i < 6; ++i) { - for (int j = i; j < 6; ++j) { - err.At(i, j) = cov[i][j]; - } - } - - mkfit::TrackState state(tsos.charge(), pos, mom, err); - state.convertFromCartesianToCCS(); - ret.emplace_back(state, 0, index, 0, nullptr); - - // Add hits - for (auto const& recHit : hitRange) { - if (not trackerHitRTTI::isFromDet(recHit)) { - throw cms::Exception("Assert") << "Encountered a seed with a hit which is not trackerHitRTTI::isFromDet()"; - } - const auto& clusterRef = static_cast(recHit).firstClusterRef(); - const auto& mkFitHit = hitIndexMap.mkFitHit(clusterRef.id(), clusterRef.index()); - ret.back().addHitIdx(mkFitHit.index(), mkFitHit.layer(), 0); // per-hit chi2 is not known - } - ++index; - } - return ret; -} - -DEFINE_FWK_MODULE(MkFitInputConverter); +DEFINE_FWK_MODULE(MkFitHitConverter); diff --git a/RecoTracker/MkFit/plugins/MkFitOutputConverter.cc b/RecoTracker/MkFit/plugins/MkFitOutputConverter.cc index e195bc384d77a..b11016a64ec89 100644 --- a/RecoTracker/MkFit/plugins/MkFitOutputConverter.cc +++ b/RecoTracker/MkFit/plugins/MkFitOutputConverter.cc @@ -28,7 +28,8 @@ #include "RecoTracker/TransientTrackingRecHit/interface/TkTransientTrackingRecHitBuilder.h" #include "TrackingTools/MaterialEffects/src/PropagatorWithMaterial.cc" -#include "RecoTracker/MkFit/interface/MkFitInputWrapper.h" +#include "RecoTracker/MkFit/interface/MkFitHitWrapper.h" +#include "RecoTracker/MkFit/interface/MkFitSeedWrapper.h" #include "RecoTracker/MkFit/interface/MkFitOutputWrapper.h" #include "RecoTracker/MkFit/interface/MkFitGeometry.h" #include "RecoTracker/Record/interface/TrackerRecoGeometryRecord.h" @@ -84,7 +85,8 @@ class MkFitOutputConverter : public edm::global::EDProducer<> { const Propagator& propagatorAlong, const Propagator& propagatorOpposite) const; - edm::EDGetTokenT hitsSeedsToken_; + const edm::EDGetTokenT mkfitHitToken_; + const edm::EDGetTokenT mkfitSeedToken_; edm::EDGetTokenT tracksToken_; edm::EDGetTokenT> seedToken_; edm::ESGetToken propagatorAlongToken_; @@ -101,7 +103,8 @@ class MkFitOutputConverter : public edm::global::EDProducer<> { }; MkFitOutputConverter::MkFitOutputConverter(edm::ParameterSet const& iConfig) - : hitsSeedsToken_{consumes(iConfig.getParameter("hitsSeeds"))}, + : mkfitHitToken_{consumes(iConfig.getParameter("mkfitHits"))}, + mkfitSeedToken_{consumes(iConfig.getParameter("mkfitSeeds"))}, tracksToken_{consumes(iConfig.getParameter("tracks"))}, seedToken_{consumes>(iConfig.getParameter("seeds"))}, propagatorAlongToken_{ @@ -119,7 +122,8 @@ MkFitOutputConverter::MkFitOutputConverter(edm::ParameterSet const& iConfig) void MkFitOutputConverter::fillDescriptions(edm::ConfigurationDescriptions& descriptions) { edm::ParameterSetDescription desc; - desc.add("hitsSeeds", edm::InputTag{"mkFitInputConverter"}); + desc.add("mkfitHits", edm::InputTag{"mkFitHitConverter"}); + desc.add("mkfitSeeds", edm::InputTag{"mkFitSeedConverter"}); desc.add("tracks", edm::InputTag{"mkFitProducer"}); desc.add("seeds", edm::InputTag{"initialStepSeeds"}); desc.add("ttrhBuilder", edm::ESInputTag{"", "WithTrackAngle"}); @@ -133,7 +137,8 @@ void MkFitOutputConverter::fillDescriptions(edm::ConfigurationDescriptions& desc void MkFitOutputConverter::produce(edm::StreamID iID, edm::Event& iEvent, const edm::EventSetup& iSetup) const { const auto& seeds = iEvent.get(seedToken_); - const auto& hitsSeeds = iEvent.get(hitsSeedsToken_); + const auto& mkfitHits = iEvent.get(mkfitHitToken_); + const auto& mkfitSeeds = iEvent.get(mkfitSeedToken_); const auto& ttrhBuilder = iSetup.getData(ttrhBuilderToken_); const auto* tkBuilder = dynamic_cast(&ttrhBuilder); @@ -145,14 +150,14 @@ void MkFitOutputConverter::produce(edm::StreamID iID, edm::Event& iEvent, const // Convert mkfit presentation back to CMSSW iEvent.emplace(putTrackCandidateToken_, convertCandidates(iEvent.get(tracksToken_), - hitsSeeds.hitIndexMap(), + mkfitHits.hitIndexMap(), seeds, iSetup.getData(mfToken_), iSetup.getData(propagatorAlongToken_), iSetup.getData(propagatorOppositeToken_), tkBuilder->cloner(), mkFitGeom.detLayers(), - hitsSeeds.seeds())); + mkfitSeeds.seeds())); // TODO: SeedStopInfo is currently unfilled iEvent.emplace(putSeedStopInfoToken_, seeds.size()); diff --git a/RecoTracker/MkFit/plugins/MkFitProducer.cc b/RecoTracker/MkFit/plugins/MkFitProducer.cc index ed6b375746aaa..e62e667a8f36f 100644 --- a/RecoTracker/MkFit/plugins/MkFitProducer.cc +++ b/RecoTracker/MkFit/plugins/MkFitProducer.cc @@ -5,7 +5,8 @@ #include "FWCore/Framework/interface/MakerMacros.h" #include "FWCore/ParameterSet/interface/ParameterSet.h" -#include "RecoTracker/MkFit/interface/MkFitInputWrapper.h" +#include "RecoTracker/MkFit/interface/MkFitHitWrapper.h" +#include "RecoTracker/MkFit/interface/MkFitSeedWrapper.h" #include "RecoTracker/MkFit/interface/MkFitOutputWrapper.h" #include "RecoTracker/MkFit/interface/MkFitGeometry.h" #include "RecoTracker/Record/interface/TrackerRecoGeometryRecord.h" @@ -35,7 +36,8 @@ class MkFitProducer : public edm::global::EDProducer hitsSeedsToken_; + const edm::EDGetTokenT hitToken_; + const edm::EDGetTokenT seedToken_; const edm::ESGetToken mkFitGeomToken_; edm::EDPutTokenT putToken_; std::function buildFunction_; @@ -44,7 +46,8 @@ class MkFitProducer : public edm::global::EDProducer(iConfig.getParameter("hitsSeeds"))}, + : hitToken_{consumes(iConfig.getParameter("hits"))}, + seedToken_{consumes(iConfig.getParameter("seeds"))}, mkFitGeomToken_{esConsumes()}, putToken_{produces()}, backwardFitInCMSSW_{iConfig.getParameter("backwardFitInCMSSW")}, @@ -88,7 +91,8 @@ MkFitProducer::MkFitProducer(edm::ParameterSet const& iConfig) void MkFitProducer::fillDescriptions(edm::ConfigurationDescriptions& descriptions) { edm::ParameterSetDescription desc; - desc.add("hitsSeeds", edm::InputTag("mkFitInputConverter")); + desc.add("hits", edm::InputTag("mkFitHitConverter")); + desc.add("seeds", edm::InputTag("mkFitSeedConverter")); desc.add("buildingRoutine", "cloneEngine") ->setComment("Valid values are: 'bestHit', 'standard', 'cloneEngine', 'fullVector'"); desc.add("seedCleaning", "N2")->setComment("Valid values are: 'none', 'N2'"); @@ -108,7 +112,8 @@ namespace { std::once_flag geometryFlag; } void MkFitProducer::produce(edm::StreamID iID, edm::Event& iEvent, const edm::EventSetup& iSetup) const { - const auto& hitsSeeds = iEvent.get(hitsSeedsToken_); + const auto& hits = iEvent.get(hitToken_); + const auto& seeds = iEvent.get(seedToken_); // This producer does not strictly speaking need the MkFitGeometry, // but the ESProducer sets global variables (yes, that "feature" // should be removed), so getting the MkFitGeometry makes it @@ -128,7 +133,7 @@ void MkFitProducer::produce(edm::StreamID iID, edm::Event& iEvent, const edm::Ev // But does the event ID really matter within mkFit? mkfit::Event ev(iEvent.id().event()); - ev.setInputFromCMSSW(hitsSeeds.hits(), hitsSeeds.seeds()); + ev.setInputFromCMSSW(hits.hits(), seeds.seeds()); tbb::this_task_arena::isolate([&]() { buildFunction_(ev, streamCache(iID)->get()); }); diff --git a/RecoTracker/MkFit/plugins/MkFitSeedConverter.cc b/RecoTracker/MkFit/plugins/MkFitSeedConverter.cc new file mode 100644 index 0000000000000..9f814b53d6e5b --- /dev/null +++ b/RecoTracker/MkFit/plugins/MkFitSeedConverter.cc @@ -0,0 +1,125 @@ +#include "FWCore/Framework/interface/global/EDProducer.h" + +#include "FWCore/Framework/interface/Event.h" +#include "FWCore/Framework/interface/MakerMacros.h" +#include "FWCore/ParameterSet/interface/ParameterSet.h" + +#include "DataFormats/TrajectorySeed/interface/TrajectorySeed.h" +#include "DataFormats/TrackerRecHit2D/interface/BaseTrackerRecHit.h" +#include "DataFormats/TrackerRecHit2D/interface/OmniClusterRef.h" +#include "DataFormats/TrackerRecHit2D/interface/trackerHitRTTI.h" + +#include "TrackingTools/Records/interface/TransientRecHitRecord.h" +#include "TrackingTools/TransientTrackingRecHit/interface/TransientTrackingRecHitBuilder.h" +#include "TrackingTools/TrajectoryState/interface/TrajectoryStateTransform.h" + +#include "MagneticField/Engine/interface/MagneticField.h" +#include "MagneticField/Records/interface/IdealMagneticFieldRecord.h" + +#include "RecoTracker/MkFit/interface/MkFitHitWrapper.h" +#include "RecoTracker/MkFit/interface/MkFitSeedWrapper.h" + +// ROOT +#include "Math/SVector.h" +#include "Math/SMatrix.h" + +// mkFit includes +#include "Track.h" + +class MkFitSeedConverter : public edm::global::EDProducer<> { +public: + explicit MkFitSeedConverter(edm::ParameterSet const& iConfig); + ~MkFitSeedConverter() override = default; + + static void fillDescriptions(edm::ConfigurationDescriptions& descriptions); + +private: + void produce(edm::StreamID, edm::Event& iEvent, const edm::EventSetup& iSetup) const override; + + mkfit::TrackVec convertSeeds(const edm::View& seeds, + const MkFitHitIndexMap& hitIndexMap, + const TransientTrackingRecHitBuilder& ttrhBuilder, + const MagneticField& mf) const; + + using SVector3 = ROOT::Math::SVector; + using SMatrixSym33 = ROOT::Math::SMatrix>; + using SMatrixSym66 = ROOT::Math::SMatrix>; + + const edm::EDGetTokenT hitToken_; + const edm::EDGetTokenT> seedToken_; + const edm::ESGetToken ttrhBuilderToken_; + const edm::ESGetToken mfToken_; + const edm::EDPutTokenT putToken_; +}; + +MkFitSeedConverter::MkFitSeedConverter(edm::ParameterSet const& iConfig) + : hitToken_{consumes(iConfig.getParameter("hits"))}, + seedToken_{consumes>(iConfig.getParameter("seeds"))}, + ttrhBuilderToken_{esConsumes( + iConfig.getParameter("ttrhBuilder"))}, + mfToken_{esConsumes()}, + putToken_{produces()} {} + +void MkFitSeedConverter::fillDescriptions(edm::ConfigurationDescriptions& descriptions) { + edm::ParameterSetDescription desc; + + desc.add("hits", edm::InputTag("mkFitHitConverter")); + desc.add("seeds", edm::InputTag{"initialStepSeeds"}); + desc.add("ttrhBuilder", edm::ESInputTag{"", "WithTrackAngle"}); + + descriptions.addWithDefaultLabel(desc); +} + +void MkFitSeedConverter::produce(edm::StreamID iID, edm::Event& iEvent, const edm::EventSetup& iSetup) const { + iEvent.emplace(putToken_, + convertSeeds(iEvent.get(seedToken_), + iEvent.get(hitToken_).hitIndexMap(), + iSetup.getData(ttrhBuilderToken_), + iSetup.getData(mfToken_))); +} + +mkfit::TrackVec MkFitSeedConverter::convertSeeds(const edm::View& seeds, + const MkFitHitIndexMap& hitIndexMap, + const TransientTrackingRecHitBuilder& ttrhBuilder, + const MagneticField& mf) const { + mkfit::TrackVec ret; + ret.reserve(seeds.size()); + int seed_index = 0; + for (const auto& seed : seeds) { + auto const& hitRange = seed.recHits(); + const auto lastRecHit = ttrhBuilder.build(&*(hitRange.end() - 1)); + const auto tsos = trajectoryStateTransform::transientState(seed.startingState(), lastRecHit->surface(), &mf); + const auto& stateGlobal = tsos.globalParameters(); + const auto& gpos = stateGlobal.position(); + const auto& gmom = stateGlobal.momentum(); + SVector3 pos(gpos.x(), gpos.y(), gpos.z()); + SVector3 mom(gmom.x(), gmom.y(), gmom.z()); + + const auto cartError = tsos.cartesianError(); // returns a temporary, so can't chain with the following line + const auto& cov = cartError.matrix(); + SMatrixSym66 err; + for (int i = 0; i < 6; ++i) { + for (int j = i; j < 6; ++j) { + err.At(i, j) = cov[i][j]; + } + } + + mkfit::TrackState state(tsos.charge(), pos, mom, err); + state.convertFromCartesianToCCS(); + ret.emplace_back(state, 0, seed_index, 0, nullptr); + + // Add hits + for (auto const& recHit : hitRange) { + if (not trackerHitRTTI::isFromDet(recHit)) { + throw cms::Exception("Assert") << "Encountered a seed with a hit which is not trackerHitRTTI::isFromDet()"; + } + const auto& clusterRef = static_cast(recHit).firstClusterRef(); + const auto& mkFitHit = hitIndexMap.mkFitHit(clusterRef.id(), clusterRef.index()); + ret.back().addHitIdx(mkFitHit.index(), mkFitHit.layer(), 0); // per-hit chi2 is not known + } + ++seed_index; + } + return ret; +} + +DEFINE_FWK_MODULE(MkFitSeedConverter); diff --git a/RecoTracker/MkFit/python/customizeHLTIter0ToMkFit.py b/RecoTracker/MkFit/python/customizeHLTIter0ToMkFit.py index 1d0eaf99e6988..40618133a82f0 100644 --- a/RecoTracker/MkFit/python/customizeHLTIter0ToMkFit.py +++ b/RecoTracker/MkFit/python/customizeHLTIter0ToMkFit.py @@ -1,7 +1,8 @@ import FWCore.ParameterSet.Config as cms import RecoTracker.MkFit.mkFitGeometryESProducer_cfi as mkFitGeometryESProducer_cfi -import RecoTracker.MkFit.mkFitInputConverter_cfi as mkFitInputConverter_cfi +import RecoTracker.MkFit.mkFitHitConverter_cfi as mkFitHitConverter_cfi +import RecoTracker.MkFit.mkFitSeedConverter_cfi as mkFitSeedConverter_cfi import RecoTracker.MkFit.mkFitProducer_cfi as mkFitProducer_cfi import RecoTracker.MkFit.mkFitOutputConverter_cfi as mkFitOutputConverter_cfi import RecoLocalTracker.SiStripRecHitConverter.SiStripRecHitConverter_cfi as SiStripRecHitConverter_cfi @@ -21,20 +22,26 @@ def customizeHLTIter0ToMkFit(process): process.hltMkFitGeometryESProducer = mkFitGeometryESProducer_cfi.mkFitGeometryESProducer.clone() - process.hltIter0PFlowCkfTrackCandidatesMkFitInput = mkFitInputConverter_cfi.mkFitInputConverter.clone( + process.hltIter0PFlowCkfTrackCandidatesMkFitHits = mkFitHitConverter_cfi.mkFitHitConverter.clone( pixelRecHits = "hltSiPixelRecHits", stripRphiRecHits = "hltSiStripRecHits:rphiRecHit", stripStereoRecHits = "hltSiStripRecHits:stereoRecHit", - seeds = "hltIter0PFLowPixelSeedsFromPixelTracks", ttrhBuilder = ":hltESPTTRHBWithTrackAngle", minGoodStripCharge = dict(refToPSet_ = 'HLTSiStripClusterChargeCutLoose'), ) + process.hltIter0PFlowCkfTrackCandidatesMkFitSeeds = mkFitSeedConverter_cfi.mkFitSeedConverter.clone( + hits = "hltIter0PFlowCkfTrackCandidatesMkFitHits", + seeds = "hltIter0PFLowPixelSeedsFromPixelTracks", + ttrhBuilder = ":hltESPTTRHBWithTrackAngle", + ) process.hltIter0PFlowCkfTrackCandidatesMkFit = mkFitProducer_cfi.mkFitProducer.clone( - hitsSeeds = "hltIter0PFlowCkfTrackCandidatesMkFitInput", + hits = "hltIter0PFlowCkfTrackCandidatesMkFitHits", + seeds = "hltIter0PFlowCkfTrackCandidatesMkFitSeeds", ) process.hltIter0PFlowCkfTrackCandidates = mkFitOutputConverter_cfi.mkFitOutputConverter.clone( seeds = "hltIter0PFLowPixelSeedsFromPixelTracks", - hitsSeeds = "hltIter0PFlowCkfTrackCandidatesMkFitInput", + mkfitHits = "hltIter0PFlowCkfTrackCandidatesMkFitHits", + mkfitSeeds = "hltIter0PFlowCkfTrackCandidatesMkFitSeeds", tracks = "hltIter0PFlowCkfTrackCandidatesMkFit", ttrhBuilder = ":hltESPTTRHBWithTrackAngle", propagatorAlong = ":PropagatorWithMaterialParabolicMf", @@ -43,6 +50,6 @@ def customizeHLTIter0ToMkFit(process): process.HLTDoLocalStripSequence += process.hltSiStripRecHits process.HLTIterativeTrackingIteration0.replace(process.hltIter0PFlowCkfTrackCandidates, - process.hltIter0PFlowCkfTrackCandidatesMkFitInput+process.hltIter0PFlowCkfTrackCandidatesMkFit+process.hltIter0PFlowCkfTrackCandidates) + process.hltIter0PFlowCkfTrackCandidatesMkFitHits+process.hltIter0PFlowCkfTrackCandidatesMkFitSeeds+process.hltIter0PFlowCkfTrackCandidatesMkFit+process.hltIter0PFlowCkfTrackCandidates) return process diff --git a/RecoTracker/MkFit/python/mkFitInputConverter_cfi.py b/RecoTracker/MkFit/python/mkFitHitConverter_cfi.py similarity index 55% rename from RecoTracker/MkFit/python/mkFitInputConverter_cfi.py rename to RecoTracker/MkFit/python/mkFitHitConverter_cfi.py index 3ee427ef0e44e..cc8bb711146a8 100644 --- a/RecoTracker/MkFit/python/mkFitInputConverter_cfi.py +++ b/RecoTracker/MkFit/python/mkFitHitConverter_cfi.py @@ -1,9 +1,9 @@ import FWCore.ParameterSet.Config as cms -from RecoTracker.MkFit.mkFitInputConverterDefault_cfi import mkFitInputConverterDefault as _mkFitInputConverterDefault +from RecoTracker.MkFit.mkFitHitConverterDefault_cfi import mkFitHitConverterDefault as _mkFitHitConverterDefault from RecoLocalTracker.SiStripClusterizer.SiStripClusterChargeCut_cfi import * -mkFitInputConverter = _mkFitInputConverterDefault.clone( +mkFitHitConverter = _mkFitHitConverterDefault.clone( minGoodStripCharge = cms.PSet( refToPSet_ = cms.string('SiStripClusterChargeCutLoose')) ) diff --git a/RecoTracker/MkFit/src/MkFitHitWrapper.cc b/RecoTracker/MkFit/src/MkFitHitWrapper.cc new file mode 100644 index 0000000000000..b4e86f4977c5f --- /dev/null +++ b/RecoTracker/MkFit/src/MkFitHitWrapper.cc @@ -0,0 +1,14 @@ +#include "RecoTracker/MkFit/interface/MkFitHitWrapper.h" + +// mkFit includes +#include "Hit.h" + +MkFitHitWrapper::MkFitHitWrapper() = default; + +MkFitHitWrapper::MkFitHitWrapper(MkFitHitIndexMap hitIndexMap, std::vector hits) + : hitIndexMap_{std::move(hitIndexMap)}, hits_{std::move(hits)} {} + +MkFitHitWrapper::~MkFitHitWrapper() = default; + +MkFitHitWrapper::MkFitHitWrapper(MkFitHitWrapper&&) = default; +MkFitHitWrapper& MkFitHitWrapper::operator=(MkFitHitWrapper&&) = default; diff --git a/RecoTracker/MkFit/src/MkFitInputWrapper.cc b/RecoTracker/MkFit/src/MkFitInputWrapper.cc deleted file mode 100644 index f9c31eb22c4fe..0000000000000 --- a/RecoTracker/MkFit/src/MkFitInputWrapper.cc +++ /dev/null @@ -1,20 +0,0 @@ -#include "RecoTracker/MkFit/interface/MkFitInputWrapper.h" - -// mkFit includes -#include "Hit.h" -#include "LayerNumberConverter.h" -#include "Track.h" - -MkFitInputWrapper::MkFitInputWrapper() = default; - -MkFitInputWrapper::MkFitInputWrapper(MkFitHitIndexMap hitIndexMap, - std::vector hits, - mkfit::TrackVec seeds) - : hitIndexMap_{std::move(hitIndexMap)}, - hits_{std::move(hits)}, - seeds_{std::make_unique(std::move(seeds))} {} - -MkFitInputWrapper::~MkFitInputWrapper() = default; - -MkFitInputWrapper::MkFitInputWrapper(MkFitInputWrapper&&) = default; -MkFitInputWrapper& MkFitInputWrapper::operator=(MkFitInputWrapper&&) = default; diff --git a/RecoTracker/MkFit/src/MkFitSeedWrapper.cc b/RecoTracker/MkFit/src/MkFitSeedWrapper.cc new file mode 100644 index 0000000000000..22964e21df56d --- /dev/null +++ b/RecoTracker/MkFit/src/MkFitSeedWrapper.cc @@ -0,0 +1,14 @@ +#include "RecoTracker/MkFit/interface/MkFitSeedWrapper.h" + +// mkFit includes +#include "Track.h" + +MkFitSeedWrapper::MkFitSeedWrapper() = default; + +MkFitSeedWrapper::MkFitSeedWrapper(mkfit::TrackVec seeds) + : seeds_{std::make_unique(std::move(seeds))} {} + +MkFitSeedWrapper::~MkFitSeedWrapper() = default; + +MkFitSeedWrapper::MkFitSeedWrapper(MkFitSeedWrapper&&) = default; +MkFitSeedWrapper& MkFitSeedWrapper::operator=(MkFitSeedWrapper&&) = default; diff --git a/RecoTracker/MkFit/src/classes.h b/RecoTracker/MkFit/src/classes.h index c092179fb499f..a3f67ec346c4f 100644 --- a/RecoTracker/MkFit/src/classes.h +++ b/RecoTracker/MkFit/src/classes.h @@ -2,7 +2,8 @@ #define RecoTracker_MkFit_classes_h #include "DataFormats/Common/interface/Wrapper.h" -#include "RecoTracker/MkFit/interface/MkFitInputWrapper.h" +#include "RecoTracker/MkFit/interface/MkFitHitWrapper.h" +#include "RecoTracker/MkFit/interface/MkFitSeedWrapper.h" #include "RecoTracker/MkFit/interface/MkFitOutputWrapper.h" #endif diff --git a/RecoTracker/MkFit/src/classes_def.xml b/RecoTracker/MkFit/src/classes_def.xml index e6363f8945f61..2a25d525491cc 100644 --- a/RecoTracker/MkFit/src/classes_def.xml +++ b/RecoTracker/MkFit/src/classes_def.xml @@ -1,6 +1,9 @@ - - + + + + + From 5355fcdd8cc58da6bf6bcbe4f2546bde7c481484 Mon Sep 17 00:00:00 2001 From: Matti Kortelainen Date: Thu, 14 Jan 2021 11:58:36 -0800 Subject: [PATCH 08/20] Remove support for fullVector following its removal from mkFit itself --- RecoTracker/MkFit/plugins/MkFitProducer.cc | 10 +++------- 1 file changed, 3 insertions(+), 7 deletions(-) diff --git a/RecoTracker/MkFit/plugins/MkFitProducer.cc b/RecoTracker/MkFit/plugins/MkFitProducer.cc index e62e667a8f36f..7769a0c361bae 100644 --- a/RecoTracker/MkFit/plugins/MkFitProducer.cc +++ b/RecoTracker/MkFit/plugins/MkFitProducer.cc @@ -53,19 +53,15 @@ MkFitProducer::MkFitProducer(edm::ParameterSet const& iConfig) backwardFitInCMSSW_{iConfig.getParameter("backwardFitInCMSSW")}, mkFitSilent_{iConfig.getUntrackedParameter("mkFitSilent")} { const auto build = iConfig.getParameter("buildingRoutine"); - bool isFV = false; if (build == "bestHit") { buildFunction_ = mkfit::runBuildingTestPlexBestHit; } else if (build == "standard") { buildFunction_ = mkfit::runBuildingTestPlexStandard; } else if (build == "cloneEngine") { buildFunction_ = mkfit::runBuildingTestPlexCloneEngine; - } else if (build == "fullVector") { - isFV = true; - buildFunction_ = mkfit::runBuildingTestPlexFV; } else { throw cms::Exception("Configuration") << "Invalid value for parameter 'buildingRoutine' " << build - << ", allowed are bestHit, standard, cloneEngine, fullVector"; + << ", allowed are bestHit, standard, cloneEngine"; } const auto seedClean = iConfig.getParameter("seedCleaning"); @@ -83,7 +79,7 @@ MkFitProducer::MkFitProducer(edm::ParameterSet const& iConfig) backwardFitInCMSSW_ ? mkfit::ConfigWrapper::BackwardFit::noFit : mkfit::ConfigWrapper::BackwardFit::toFirstLayer; // TODO: what to do when we have multiple instances of MkFitProducer in a job? - mkfit::MkBuilderWrapper::populate(isFV); + mkfit::MkBuilderWrapper::populate(); mkfit::ConfigWrapper::initializeForCMSSW(seedCleanOpt, backwardFitOpt, mkFitSilent_); mkfit::ConfigWrapper::setRemoveDuplicates(iConfig.getParameter("removeDuplicates")); } @@ -94,7 +90,7 @@ void MkFitProducer::fillDescriptions(edm::ConfigurationDescriptions& description desc.add("hits", edm::InputTag("mkFitHitConverter")); desc.add("seeds", edm::InputTag("mkFitSeedConverter")); desc.add("buildingRoutine", "cloneEngine") - ->setComment("Valid values are: 'bestHit', 'standard', 'cloneEngine', 'fullVector'"); + ->setComment("Valid values are: 'bestHit', 'standard', 'cloneEngine'"); desc.add("seedCleaning", "N2")->setComment("Valid values are: 'none', 'N2'"); desc.add("removeDuplicates", true)->setComment("Run duplicate removal within mkFit"); desc.add("backwardFitInCMSSW", false) From 8ea9a9f62aeeaebe4cb8ae4df9b32cd1fcb5604d Mon Sep 17 00:00:00 2001 From: Mario Masciovecchio Date: Tue, 2 Feb 2021 12:58:41 +0100 Subject: [PATCH 09/20] Fixing naming for MTV in 112X --- RecoTracker/MkFit/python/customizeInitialStepOnly.py | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/RecoTracker/MkFit/python/customizeInitialStepOnly.py b/RecoTracker/MkFit/python/customizeInitialStepOnly.py index 4f3e3f356e91c..700de0f204fcc 100644 --- a/RecoTracker/MkFit/python/customizeInitialStepOnly.py +++ b/RecoTracker/MkFit/python/customizeInitialStepOnly.py @@ -12,8 +12,8 @@ def customizeInitialStepOnly(process): process.initialStepSeedLayers.BPix.HitProducer = 'siPixelRecHitsPreSplitting' process.initialStepHitQuadruplets.SeedComparitorPSet.clusterShapeCacheSrc = "siPixelClusterShapeCachePreSplitting" process.initialStepSeeds.SeedComparitorPSet.ClusterShapeCacheSrc = "siPixelClusterShapeCachePreSplitting" - if hasattr(process, "initialStepTrackCandidatesMkFitInput"): - process.initialStepTrackCandidatesMkFitInput.pixelRecHits = "siPixelRecHitsPreSplitting" + if hasattr(process, "initialStepTrackCandidatesMkFitHits"): + process.initialStepTrackCandidatesMkFitHits.pixelRecHits = "siPixelRecHitsPreSplitting" if hasattr(process.initialStepTrackCandidates, "MeasurementTrackerEvent"): process.initialStepTrackCandidates.MeasurementTrackerEvent = 'MeasurementTrackerEventPreSplitting' process.initialStepTracks.MeasurementTrackerEvent = 'MeasurementTrackerEventPreSplitting' @@ -55,10 +55,10 @@ def setInput(mtvs, labels): mod.dodEdxPlots = False mod.doResolutionPlotsForLabels = [] - setInput(["trackValidatorTrackingOnly", "trackValidatorAllTPEfficStandalone", - "trackValidatorTPPtLess09Standalone", "trackValidatorBHadronTrackingOnly"], + setInput(["trackValidatorTrackingOnly", "trackValidatorAllTPEfficTrackingOnly", + "trackValidatorTPPtLess09TrackingOnly", "trackValidatorBHadronTrackingOnly"], ["cutsRecoTracksInitialStep", "cutsRecoTracksPt09InitialStep"]) - setInput(["trackValidatorFromPVStandalone", "trackValidatorFromPVAllTPStandalone"], + setInput(["trackValidatorFromPVTrackingOnly", "trackValidatorFromPVAllTPTrackingOnly"], ["cutsRecoTracksFromPVInitialStep", "cutsRecoTracksFromPVPt09InitialStep"]) setInput(["trackValidatorSeedingTrackingOnly"], ["seedTracksinitialStepSeeds"]) setInput(["trackValidatorBuilding"], ["initialStepTracks"]) From c8b1553410d3a23b26c0550df4c5f4791cc62f89 Mon Sep 17 00:00:00 2001 From: Matti Kortelainen Date: Fri, 12 Feb 2021 13:09:54 -0800 Subject: [PATCH 10/20] Migrate to multi-iteration interface --- .../python/InitialStep_cff.py | 8 +- .../MkFit/interface/MkFitClusterIndexToHit.h | 24 ++++++ RecoTracker/MkFit/interface/MkFitGeometry.h | 12 ++- .../MkFit/interface/MkFitHitIndexMap.h | 86 ------------------- RecoTracker/MkFit/interface/MkFitHitWrapper.h | 27 ++++-- .../MkFit/interface/MkFitOutputWrapper.h | 10 +-- .../MkFit/plugins/MkFitGeometryESProducer.cc | 12 ++- .../MkFit/plugins/MkFitHitConverter.cc | 82 ++++++++++-------- .../MkFit/plugins/MkFitOutputConverter.cc | 41 +++++---- RecoTracker/MkFit/plugins/MkFitProducer.cc | 65 +++++++------- .../MkFit/plugins/MkFitSeedConverter.cc | 47 +++++++--- .../MkFit/python/customizeHLTIter0ToMkFit.py | 1 - RecoTracker/MkFit/src/MkFitGeometry.cc | 13 ++- RecoTracker/MkFit/src/MkFitHitIndexMap.cc | 68 --------------- RecoTracker/MkFit/src/MkFitHitWrapper.cc | 8 +- RecoTracker/MkFit/src/MkFitOutputWrapper.cc | 4 +- RecoTracker/MkFit/src/classes.h | 1 + RecoTracker/MkFit/src/classes_def.xml | 3 + .../python/plotting/trackingPlots.py | 5 +- 19 files changed, 234 insertions(+), 283 deletions(-) create mode 100644 RecoTracker/MkFit/interface/MkFitClusterIndexToHit.h delete mode 100644 RecoTracker/MkFit/interface/MkFitHitIndexMap.h delete mode 100644 RecoTracker/MkFit/src/MkFitHitIndexMap.cc diff --git a/RecoTracker/IterativeTracking/python/InitialStep_cff.py b/RecoTracker/IterativeTracking/python/InitialStep_cff.py index c78c336461b10..0c564303d9e83 100644 --- a/RecoTracker/IterativeTracking/python/InitialStep_cff.py +++ b/RecoTracker/IterativeTracking/python/InitialStep_cff.py @@ -229,18 +229,16 @@ import RecoTracker.MkFit.mkFitSeedConverter_cfi as mkFitSeedConverter_cfi import RecoTracker.MkFit.mkFitProducer_cfi as mkFitProducer_cfi import RecoTracker.MkFit.mkFitOutputConverter_cfi as mkFitOutputConverter_cfi -initialStepTrackCandidatesMkFitHits = mkFitHitConverter_cfi.mkFitHitConverter.clone() +mkFitHits = mkFitHitConverter_cfi.mkFitHitConverter.clone() # TODO: figure out better place for this module? initialStepTrackCandidatesMkFitSeeds = mkFitSeedConverter_cfi.mkFitSeedConverter.clone( - hits = 'initialStepTrackCandidatesMkFitHits', seeds = 'initialStepSeeds', ) initialStepTrackCandidatesMkFit = mkFitProducer_cfi.mkFitProducer.clone( - hits = 'initialStepTrackCandidatesMkFitHits', seeds = 'initialStepTrackCandidatesMkFitSeeds', + iterationNumber = 0, ) trackingMkFit.toReplaceWith(initialStepTrackCandidates, mkFitOutputConverter_cfi.mkFitOutputConverter.clone( seeds = 'initialStepSeeds', - mkfitHits = 'initialStepTrackCandidatesMkFitHits', mkfitSeeds = 'initialStepTrackCandidatesMkFitSeeds', tracks = 'initialStepTrackCandidatesMkFit', )) @@ -420,7 +418,7 @@ InitialStep = cms.Sequence(InitialStepTask) _InitialStepTask_trackingMkFit = InitialStepTask.copy() -_InitialStepTask_trackingMkFit.add(initialStepTrackCandidatesMkFitHits, initialStepTrackCandidatesMkFitSeeds, initialStepTrackCandidatesMkFit, mkFitGeometryESProducer) +_InitialStepTask_trackingMkFit.add(mkFitHits, initialStepTrackCandidatesMkFitSeeds, initialStepTrackCandidatesMkFit, mkFitGeometryESProducer) trackingMkFit.toReplaceWith(InitialStepTask, _InitialStepTask_trackingMkFit) _InitialStepTask_LowPU = InitialStepTask.copyAndExclude([firstStepPrimaryVerticesUnsorted, initialStepTrackRefsForJets, caloJetsForTrkTask, firstStepPrimaryVertices, initialStepClassifier1, initialStepClassifier2, initialStepClassifier3]) diff --git a/RecoTracker/MkFit/interface/MkFitClusterIndexToHit.h b/RecoTracker/MkFit/interface/MkFitClusterIndexToHit.h new file mode 100644 index 0000000000000..1415e8b83a24a --- /dev/null +++ b/RecoTracker/MkFit/interface/MkFitClusterIndexToHit.h @@ -0,0 +1,24 @@ +#ifndef RecoTracker_MkFit_MkFitClusterIndexToHit_h +#define RecoTracker_MkFit_MkFitClusterIndexToHit_h + +#include + +class TrackingRecHit; + +class MkFitClusterIndexToHit { +public: + MkFitClusterIndexToHit() = default; + + std::vector &pixelHits() { return pixelHits_; } + std::vector const &pixelHits() const { return pixelHits_; } + + std::vector &outerHits() { return outerHits_; } + std::vector const &outerHits() const { return outerHits_; } + +private: + // Indexed by cluster index + std::vector pixelHits_; + std::vector outerHits_; +}; + +#endif diff --git a/RecoTracker/MkFit/interface/MkFitGeometry.h b/RecoTracker/MkFit/interface/MkFitGeometry.h index b9c6515d356a5..928d9b13b8891 100644 --- a/RecoTracker/MkFit/interface/MkFitGeometry.h +++ b/RecoTracker/MkFit/interface/MkFitGeometry.h @@ -7,7 +7,9 @@ namespace mkfit { class LayerNumberConverter; -} + class TrackerInfo; + class IterationsInfo; +} // namespace mkfit class DetLayer; class GeometricSearchTracker; @@ -21,15 +23,21 @@ class MkFitGeometry { public: explicit MkFitGeometry(const TrackerGeometry& geom, const GeometricSearchTracker& tracker, - const TrackerTopology& ttopo); + const TrackerTopology& ttopo, + std::unique_ptr trackerInfo, + std::unique_ptr iterationsInfo); ~MkFitGeometry(); mkfit::LayerNumberConverter const& layerNumberConverter() const { return *lnc_; } + mkfit::TrackerInfo const& trackerInfo() const { return *trackerInfo_; } + mkfit::IterationsInfo const& iterationsInfo() const { return *iterationsInfo_; } const std::vector& detLayers() const { return dets_; } unsigned int uniqueIdInLayer(int layer, unsigned int detId) const { return detIdToShortId_.at(layer).at(detId); } private: std::unique_ptr lnc_; // for pimpl pattern + std::unique_ptr trackerInfo_; + std::unique_ptr iterationsInfo_; // only temporarily here, to be moved into proper place later std::vector dets_; std::vector> detIdToShortId_; }; diff --git a/RecoTracker/MkFit/interface/MkFitHitIndexMap.h b/RecoTracker/MkFit/interface/MkFitHitIndexMap.h deleted file mode 100644 index c7b6eea50263a..0000000000000 --- a/RecoTracker/MkFit/interface/MkFitHitIndexMap.h +++ /dev/null @@ -1,86 +0,0 @@ -#ifndef RecoTracker_MkFit_MkFitHitIndexMap_h -#define RecoTracker_MkFit_MkFitHitIndexMap_h - -#include "DataFormats/Provenance/interface/ProductID.h" - -#include - -class TrackingRecHit; - -/** - * This class provides mappings - * - from CMSSW(ProductID, cluster index) to mkFit(layer index, hit index) - * - from mkFit(layer index, hit index) to pointer to CMSSW hit - */ -class MkFitHitIndexMap { -public: - // This class holds the index and layer of a hit in the hit data - // structure passed to mkFit - class MkFitHit { - public: - MkFitHit() = default; - explicit MkFitHit(int i, int l) : index_{i}, layer_{l} {} - - int index() const { return index_; } - int layer() const { return layer_; } - - private: - int index_ = -1; - int layer_ = -1; - }; - - MkFitHitIndexMap() = default; - - /** - * Can be used to preallocate the internal vectors for CMSSW->mkFit mapping - */ - void resizeByClusterIndex(edm::ProductID id, size_t clusterIndex); - - /** - * Can be used to preallocate the internal vectors for mkFit->CMSSW mapping - * - * \param layer Layer index (in mkFit convention) - * \param additionalSize Number of additional elements to make space for - */ - void increaseLayerSize(int layer, size_t additionalSize); - - /** - * Inserts a new hit in the mapping - * - * \param id ProductID of the cluster collection - * \param clusterIndex Index of the cluster in the cluster collection - * \param hit Index and layer of the hit in the mkFit hit data structure - * \param hitPtr Pointer to the TrackingRecHit - */ - void insert(edm::ProductID id, size_t clusterIndex, MkFitHit hit, const TrackingRecHit* hitPtr); - - /// Get mkFit hit index and layer - const MkFitHit& mkFitHit(edm::ProductID id, size_t clusterIndex) const; - - /// Get CMSSW hit pointer - const TrackingRecHit* hitPtr(MkFitHit hit) const { return mkFitToCMSSW_.at(hit.layer()).at(hit.index()).ptr; } - - /// Get CMSSW cluster index (currently used only for debugging) - size_t clusterIndex(MkFitHit hit) const { return mkFitToCMSSW_.at(hit.layer()).at(hit.index()).clusterIndex; } - -private: - // Helper struct to map (edm::ProductID, cluster index) to MkFitHit - struct ClusterToMkFitHit { - explicit ClusterToMkFitHit(edm::ProductID id) : productID(id) {} - edm::ProductID productID; - std::vector mkFitHits; // indexed by cluster index - }; - - // Helper struct to map MkFitHit to (TrackingRecHit *, cluster index) - struct CMSSWHit { - CMSSWHit() = default; - explicit CMSSWHit(const TrackingRecHit* p, size_t i) : ptr{p}, clusterIndex{i} {} - const TrackingRecHit* ptr = nullptr; - size_t clusterIndex = 0; - }; - - std::vector cmsswToMkFit_; // mapping from CMSSW(ProductID, cluster index) -> mkFit(index, layer) - std::vector > mkFitToCMSSW_; // reverse mapping, mkFit(layer, index) -> CMSSW hit -}; - -#endif diff --git a/RecoTracker/MkFit/interface/MkFitHitWrapper.h b/RecoTracker/MkFit/interface/MkFitHitWrapper.h index b1415d147bc87..0af92386a1046 100644 --- a/RecoTracker/MkFit/interface/MkFitHitWrapper.h +++ b/RecoTracker/MkFit/interface/MkFitHitWrapper.h @@ -1,20 +1,20 @@ #ifndef RecoTracker_MkFit_MkFitHitWrapper_h #define RecoTracker_MkFit_MkFitHitWrapper_h -#include "RecoTracker/MkFit/interface/MkFitHitIndexMap.h" - +#include #include namespace mkfit { + class EventOfHits; + class TrackerInfo; class Hit; - class LayerNumberConverter; using HitVec = std::vector; } // namespace mkfit class MkFitHitWrapper { public: MkFitHitWrapper(); - MkFitHitWrapper(MkFitHitIndexMap hitIndexMap, std::vector hits); + MkFitHitWrapper(mkfit::TrackerInfo const& trackerInfo); ~MkFitHitWrapper(); MkFitHitWrapper(MkFitHitWrapper const&) = delete; @@ -22,12 +22,23 @@ class MkFitHitWrapper { MkFitHitWrapper(MkFitHitWrapper&&); MkFitHitWrapper& operator=(MkFitHitWrapper&&); - MkFitHitIndexMap const& hitIndexMap() const { return hitIndexMap_; } - std::vector const& hits() const { return hits_; } + mkfit::EventOfHits& eventOfHits() { return *eventOfHits_; } + mkfit::EventOfHits const& eventOfHits() const { return *eventOfHits_; } + + mkfit::HitVec& pixelHits() { return *pixelHits_; } + mkfit::HitVec const& pixelHits() const { return *pixelHits_; } + + mkfit::HitVec& outerHits() { return *outerHits_; } + mkfit::HitVec const& outerHits() const { return *outerHits_; } private: - MkFitHitIndexMap hitIndexMap_; - std::vector hits_; + std::unique_ptr eventOfHits_; + + // using unique_ptr to guarantee the address of the HitVec doesn't change in moves + // EvenfOfHits relies on that + // Vectors are indexed by the cluster index + std::unique_ptr pixelHits_; + std::unique_ptr outerHits_; }; #endif diff --git a/RecoTracker/MkFit/interface/MkFitOutputWrapper.h b/RecoTracker/MkFit/interface/MkFitOutputWrapper.h index 8297b7c511f77..a658d41151aa3 100644 --- a/RecoTracker/MkFit/interface/MkFitOutputWrapper.h +++ b/RecoTracker/MkFit/interface/MkFitOutputWrapper.h @@ -11,7 +11,7 @@ namespace mkfit { class MkFitOutputWrapper { public: MkFitOutputWrapper(); - MkFitOutputWrapper(mkfit::TrackVec&& candidateTracks, mkfit::TrackVec&& fitTracks); + MkFitOutputWrapper(mkfit::TrackVec tracks, bool propagatedToFirstLayer); ~MkFitOutputWrapper(); MkFitOutputWrapper(MkFitOutputWrapper const&) = delete; @@ -19,12 +19,12 @@ class MkFitOutputWrapper { MkFitOutputWrapper(MkFitOutputWrapper&&); MkFitOutputWrapper& operator=(MkFitOutputWrapper&&); - mkfit::TrackVec const& candidateTracks() const { return candidateTracks_; } - mkfit::TrackVec const& fitTracks() const { return fitTracks_; } + mkfit::TrackVec const& tracks() const { return tracks_; } + bool propagatedToFirstLayer() const { return propagatedToFirstLayer_; } private: - mkfit::TrackVec candidateTracks_; - mkfit::TrackVec fitTracks_; + mkfit::TrackVec tracks_; + bool propagatedToFirstLayer_; }; #endif diff --git a/RecoTracker/MkFit/plugins/MkFitGeometryESProducer.cc b/RecoTracker/MkFit/plugins/MkFitGeometryESProducer.cc index 7442e328e80b8..956dd365af60d 100644 --- a/RecoTracker/MkFit/plugins/MkFitGeometryESProducer.cc +++ b/RecoTracker/MkFit/plugins/MkFitGeometryESProducer.cc @@ -12,6 +12,8 @@ // mkFit includes #include "ConfigWrapper.h" +#include "TrackerInfo.h" +#include "mkFit/IterationConfig.h" #include @@ -42,7 +44,15 @@ void MkFitGeometryESProducer::fillDescriptions(edm::ConfigurationDescriptions& d } std::unique_ptr MkFitGeometryESProducer::produce(const TrackerRecoGeometryRecord& iRecord) { - return std::make_unique(iRecord.get(geomToken_), iRecord.get(trackerToken_), iRecord.get(ttopoToken_)); + auto trackerInfo = std::make_unique(); + auto iterationsInfo = std::make_unique(); + // TODO: absorb the functionality to CMSSW + mkfit::TrackerInfo::ExecTrackerInfoCreatorPlugin("CMS-2017", *trackerInfo, *iterationsInfo); + return std::make_unique(iRecord.get(geomToken_), + iRecord.get(trackerToken_), + iRecord.get(ttopoToken_), + std::move(trackerInfo), + std::move(iterationsInfo)); } DEFINE_FWK_EVENTSETUP_MODULE(MkFitGeometryESProducer); diff --git a/RecoTracker/MkFit/plugins/MkFitHitConverter.cc b/RecoTracker/MkFit/plugins/MkFitHitConverter.cc index 9964ebeb68ffb..e2d03324e2288 100644 --- a/RecoTracker/MkFit/plugins/MkFitHitConverter.cc +++ b/RecoTracker/MkFit/plugins/MkFitHitConverter.cc @@ -3,6 +3,7 @@ #include "FWCore/Framework/interface/Event.h" #include "FWCore/Framework/interface/MakerMacros.h" #include "FWCore/ParameterSet/interface/ParameterSet.h" +#include "FWCore/Utilities/interface/Likely.h" #include "DataFormats/SiStripCluster/interface/SiStripClusterTools.h" #include "DataFormats/TrajectorySeed/interface/TrajectorySeed.h" @@ -19,6 +20,7 @@ #include "TrackingTools/TrajectoryState/interface/TrajectoryStateTransform.h" #include "RecoTracker/MkFit/interface/MkFitHitWrapper.h" +#include "RecoTracker/MkFit/interface/MkFitClusterIndexToHit.h" #include "RecoTracker/MkFit/interface/MkFitGeometry.h" #include "RecoTracker/Record/interface/TrackerRecoGeometryRecord.h" @@ -29,6 +31,8 @@ // mkFit includes #include "Hit.h" #include "LayerNumberConverter.h" +#include "mkFit/HitStructures.h" +#include "mkFit/MkStdSeqs.h" class MkFitHitConverter : public edm::global::EDProducer<> { public: @@ -42,9 +46,9 @@ class MkFitHitConverter : public edm::global::EDProducer<> { template void convertHits(const HitCollection& hits, - std::vector& mkFitHits, - MkFitHitIndexMap& hitIndexMap, - int& totalHits, + mkfit::EventOfHits& mkFitEventOfHits, + mkfit::HitVec& mkFitHits, + std::vector& clusterIndexToHit, const TrackerTopology& ttopo, const TransientTrackingRecHitBuilder& ttrhBuilder, const MkFitGeometry& mkFitGeom) const; @@ -68,7 +72,8 @@ class MkFitHitConverter : public edm::global::EDProducer<> { edm::ESGetToken ttrhBuilderToken_; edm::ESGetToken ttopoToken_; edm::ESGetToken mkFitGeomToken_; - edm::EDPutTokenT putToken_; + edm::EDPutTokenT wrapperPutToken_; + edm::EDPutTokenT clusterIndexPutToken_; const float minGoodStripCharge_; }; @@ -82,7 +87,8 @@ MkFitHitConverter::MkFitHitConverter(edm::ParameterSet const& iConfig) iConfig.getParameter("ttrhBuilder"))}, ttopoToken_{esConsumes()}, mkFitGeomToken_{esConsumes()}, - putToken_{produces()}, + wrapperPutToken_{produces()}, + clusterIndexPutToken_{produces()}, minGoodStripCharge_{static_cast( iConfig.getParameter("minGoodStripCharge").getParameter("value"))} {} @@ -107,15 +113,22 @@ void MkFitHitConverter::produce(edm::StreamID iID, edm::Event& iEvent, const edm const auto& ttopo = iSetup.getData(ttopoToken_); const auto& mkFitGeom = iSetup.getData(mkFitGeomToken_); - std::vector mkFitHits(mkFitGeom.layerNumberConverter().nLayers()); - MkFitHitIndexMap hitIndexMap; - int totalHits = 0; // I need to have a global hit index in order to have the hit remapping working? - // Process strips first for better memory allocation pattern - convertHits(iEvent.get(stripRphiRecHitToken_), mkFitHits, hitIndexMap, totalHits, ttopo, ttrhBuilder, mkFitGeom); - convertHits(iEvent.get(stripStereoRecHitToken_), mkFitHits, hitIndexMap, totalHits, ttopo, ttrhBuilder, mkFitGeom); - convertHits(iEvent.get(pixelRecHitToken_), mkFitHits, hitIndexMap, totalHits, ttopo, ttrhBuilder, mkFitGeom); + MkFitHitWrapper hitWrapper{mkFitGeom.trackerInfo()}; + mkfit::StdSeq::Cmssw_LoadHits_Begin(hitWrapper.eventOfHits(), {&hitWrapper.pixelHits(), &hitWrapper.outerHits()}); - iEvent.emplace(putToken_, std::move(hitIndexMap), std::move(mkFitHits)); + MkFitClusterIndexToHit clusterIndexToHit; + + auto convert = [&](auto& hits, auto& mkFitHits, auto& clusterIndexToHit) { + convertHits(hits, hitWrapper.eventOfHits(), mkFitHits, clusterIndexToHit, ttopo, ttrhBuilder, mkFitGeom); + }; + convert(iEvent.get(pixelRecHitToken_), hitWrapper.pixelHits(), clusterIndexToHit.pixelHits()); + convert(iEvent.get(stripRphiRecHitToken_), hitWrapper.outerHits(), clusterIndexToHit.outerHits()); + convert(iEvent.get(stripStereoRecHitToken_), hitWrapper.outerHits(), clusterIndexToHit.outerHits()); + + mkfit::StdSeq::Cmssw_LoadHits_End(hitWrapper.eventOfHits()); + + iEvent.emplace(wrapperPutToken_, std::move(hitWrapper)); + iEvent.emplace(clusterIndexPutToken_, std::move(clusterIndexToHit)); } float MkFitHitConverter::clusterCharge(const SiStripRecHit2D& hit, DetId hitId) const { @@ -137,9 +150,9 @@ void MkFitHitConverter::setDetails(mkfit::Hit& mhit, const SiStripCluster& clust template void MkFitHitConverter::convertHits(const HitCollection& hits, - std::vector& mkFitHits, - MkFitHitIndexMap& hitIndexMap, - int& totalHits, + mkfit::EventOfHits& mkFitEventOfHits, + mkfit::HitVec& mkFitHits, + std::vector& clusterIndexToHit, const TrackerTopology& ttopo, const TransientTrackingRecHitBuilder& ttrhBuilder, const MkFitGeometry& mkFitGeom) const { @@ -150,13 +163,12 @@ void MkFitHitConverter::convertHits(const HitCollection& hits, }; { - const DetId detid{hits.ids().back()}; - const auto ilay = mkFitGeom.layerNumberConverter().convertLayerNumber( - detid.subdetId(), ttopo.layer(detid), false, ttopo.isStereo(detid), isPlusSide(detid)); - // Do initial reserves to minimize further memory allocations const auto& lastClusterRef = hits.data().back().firstClusterRef(); - hitIndexMap.resizeByClusterIndex(lastClusterRef.id(), lastClusterRef.index()); - hitIndexMap.increaseLayerSize(ilay, hits.detsetSize(hits.ids().size() - 1)); + if (lastClusterRef.index() >= mkFitHits.size()) { + auto const size = lastClusterRef.index(); + mkFitHits.resize(size); + clusterIndexToHit.resize(size, nullptr); + } } for (const auto& detset : hits) { @@ -166,8 +178,6 @@ void MkFitHitConverter::convertHits(const HitCollection& hits, const auto isStereo = ttopo.isStereo(detid); const auto ilay = mkFitGeom.layerNumberConverter().convertLayerNumber(subdet, layer, false, isStereo, isPlusSide(detid)); - const auto uniqueIdInLayer = mkFitGeom.uniqueIdInLayer(ilay, detid.rawId()); - hitIndexMap.increaseLayerSize(ilay, detset.size()); // to minimize memory allocations for (const auto& hit : detset) { const auto charge = clusterCharge(hit, detid); @@ -185,17 +195,21 @@ void MkFitHitConverter::convertHits(const HitCollection& hits, err.At(0, 2) = gerr.czx(); err.At(1, 2) = gerr.czy(); + const auto clusterIndex = hit.firstClusterRef().index(); LogTrace("MkFitHitConverter") << "Adding hit detid " << detid.rawId() << " subdet " << subdet << " layer " - << layer << " isStereo " << isStereo << " zplus " << isPlusSide(detid) << " ilay " - << ilay; - - hitIndexMap.insert(hit.firstClusterRef().id(), - hit.firstClusterRef().index(), - MkFitHitIndexMap::MkFitHit{static_cast(mkFitHits[ilay].size()), ilay}, - &hit); - mkFitHits[ilay].emplace_back(pos, err, totalHits); - setDetails(mkFitHits[ilay].back(), *(hit.cluster()), uniqueIdInLayer, charge); - ++totalHits; + << layer << " isStereo " << isStereo << " zplus " << isPlusSide(detid) << " index " + << clusterIndex << " ilay " << ilay; + + if UNLIKELY (clusterIndex >= mkFitHits.size()) { + mkFitHits.resize(clusterIndex + 1); + clusterIndexToHit.resize(clusterIndex + 1, nullptr); + } + mkFitHits[clusterIndex] = mkfit::Hit(pos, err); + clusterIndexToHit[clusterIndex] = &hit; + const auto uniqueIdInLayer = mkFitGeom.uniqueIdInLayer(ilay, detid.rawId()); + setDetails(mkFitHits[clusterIndex], *(hit.cluster()), uniqueIdInLayer, charge); + + mkFitEventOfHits[ilay].RegisterHit(clusterIndex); } } } diff --git a/RecoTracker/MkFit/plugins/MkFitOutputConverter.cc b/RecoTracker/MkFit/plugins/MkFitOutputConverter.cc index b11016a64ec89..c5ca7ac4226b5 100644 --- a/RecoTracker/MkFit/plugins/MkFitOutputConverter.cc +++ b/RecoTracker/MkFit/plugins/MkFitOutputConverter.cc @@ -29,6 +29,7 @@ #include "TrackingTools/MaterialEffects/src/PropagatorWithMaterial.cc" #include "RecoTracker/MkFit/interface/MkFitHitWrapper.h" +#include "RecoTracker/MkFit/interface/MkFitClusterIndexToHit.h" #include "RecoTracker/MkFit/interface/MkFitSeedWrapper.h" #include "RecoTracker/MkFit/interface/MkFitOutputWrapper.h" #include "RecoTracker/MkFit/interface/MkFitGeometry.h" @@ -37,6 +38,7 @@ // mkFit indludes #include "LayerNumberConverter.h" #include "Track.h" +#include "mkFit/HitStructures.h" namespace { template @@ -63,7 +65,8 @@ class MkFitOutputConverter : public edm::global::EDProducer<> { void produce(edm::StreamID, edm::Event& iEvent, const edm::EventSetup& iSetup) const override; TrackCandidateCollection convertCandidates(const MkFitOutputWrapper& mkFitOutput, - const MkFitHitIndexMap& hitIndexMap, + const mkfit::EventOfHits& eventOfHits, + const MkFitClusterIndexToHit& clusterIndexToHit, const edm::View& seeds, const MagneticField& mf, const Propagator& propagatorAlong, @@ -86,6 +89,7 @@ class MkFitOutputConverter : public edm::global::EDProducer<> { const Propagator& propagatorOpposite) const; const edm::EDGetTokenT mkfitHitToken_; + const edm::EDGetTokenT clusterIndexToHitToken_; const edm::EDGetTokenT mkfitSeedToken_; edm::EDGetTokenT tracksToken_; edm::EDGetTokenT> seedToken_; @@ -99,11 +103,11 @@ class MkFitOutputConverter : public edm::global::EDProducer<> { std::string ttrhBuilderName_; std::string propagatorAlongName_; std::string propagatorOppositeName_; - bool backwardFitInCMSSW_; }; MkFitOutputConverter::MkFitOutputConverter(edm::ParameterSet const& iConfig) : mkfitHitToken_{consumes(iConfig.getParameter("mkfitHits"))}, + clusterIndexToHitToken_{consumes(iConfig.getParameter("mkfitHits"))}, mkfitSeedToken_{consumes(iConfig.getParameter("mkfitSeeds"))}, tracksToken_{consumes(iConfig.getParameter("tracks"))}, seedToken_{consumes>(iConfig.getParameter("seeds"))}, @@ -116,28 +120,24 @@ MkFitOutputConverter::MkFitOutputConverter(edm::ParameterSet const& iConfig) iConfig.getParameter("ttrhBuilder"))}, mkFitGeomToken_{esConsumes()}, putTrackCandidateToken_{produces()}, - putSeedStopInfoToken_{produces>()}, - backwardFitInCMSSW_{iConfig.getParameter("backwardFitInCMSSW")} {} + putSeedStopInfoToken_{produces>()} {} void MkFitOutputConverter::fillDescriptions(edm::ConfigurationDescriptions& descriptions) { edm::ParameterSetDescription desc; - desc.add("mkfitHits", edm::InputTag{"mkFitHitConverter"}); + desc.add("mkfitHits", edm::InputTag{"mkFitHits"}); desc.add("mkfitSeeds", edm::InputTag{"mkFitSeedConverter"}); desc.add("tracks", edm::InputTag{"mkFitProducer"}); desc.add("seeds", edm::InputTag{"initialStepSeeds"}); desc.add("ttrhBuilder", edm::ESInputTag{"", "WithTrackAngle"}); desc.add("propagatorAlong", edm::ESInputTag{"", "PropagatorWithMaterial"}); desc.add("propagatorOpposite", edm::ESInputTag{"", "PropagatorWithMaterialOpposite"}); - desc.add("backwardFitInCMSSW", false) - ->setComment("Do backward fit (to innermost hit) in CMSSW (true) or mkFit (false)"); descriptions.addWithDefaultLabel(desc); } void MkFitOutputConverter::produce(edm::StreamID iID, edm::Event& iEvent, const edm::EventSetup& iSetup) const { const auto& seeds = iEvent.get(seedToken_); - const auto& mkfitHits = iEvent.get(mkfitHitToken_); const auto& mkfitSeeds = iEvent.get(mkfitSeedToken_); const auto& ttrhBuilder = iSetup.getData(ttrhBuilderToken_); @@ -150,7 +150,8 @@ void MkFitOutputConverter::produce(edm::StreamID iID, edm::Event& iEvent, const // Convert mkfit presentation back to CMSSW iEvent.emplace(putTrackCandidateToken_, convertCandidates(iEvent.get(tracksToken_), - mkfitHits.hitIndexMap(), + iEvent.get(mkfitHitToken_).eventOfHits(), + iEvent.get(clusterIndexToHitToken_), seeds, iSetup.getData(mfToken_), iSetup.getData(propagatorAlongToken_), @@ -164,7 +165,8 @@ void MkFitOutputConverter::produce(edm::StreamID iID, edm::Event& iEvent, const } TrackCandidateCollection MkFitOutputConverter::convertCandidates(const MkFitOutputWrapper& mkFitOutput, - const MkFitHitIndexMap& hitIndexMap, + const mkfit::EventOfHits& eventOfHits, + const MkFitClusterIndexToHit& clusterIndexToHit, const edm::View& seeds, const MagneticField& mf, const Propagator& propagatorAlong, @@ -173,10 +175,10 @@ TrackCandidateCollection MkFitOutputConverter::convertCandidates(const MkFitOutp const std::vector& detLayers, const mkfit::TrackVec& mkFitSeeds) const { TrackCandidateCollection output; - const auto& candidates = backwardFitInCMSSW_ ? mkFitOutput.candidateTracks() : mkFitOutput.fitTracks(); + const auto& candidates = mkFitOutput.tracks(); output.reserve(candidates.size()); - LogTrace("MkFitOutputConverter") << "Number of candidates " << mkFitOutput.candidateTracks().size(); + LogTrace("MkFitOutputConverter") << "Number of candidates " << candidates.size(); int candIndex = -1; for (const auto& cand : candidates) { @@ -214,14 +216,15 @@ TrackCandidateCollection MkFitOutputConverter::convertCandidates(const MkFitOutp // them in the TrackProducer. lastHitInvalid = true; } else { - recHits.push_back(hitIndexMap.hitPtr(MkFitHitIndexMap::MkFitHit{hitOnTrack.index, hitOnTrack.layer})->clone()); + auto const isPixel = eventOfHits[hitOnTrack.layer].is_pix_lyr(); + auto const& hits = isPixel ? clusterIndexToHit.pixelHits() : clusterIndexToHit.outerHits(); + + recHits.push_back(hits[hitOnTrack.index]->clone()); LogTrace("MkFitOutputConverter") << " pos " << recHits.back().globalPosition().x() << " " << recHits.back().globalPosition().y() << " " << recHits.back().globalPosition().z() << " mag2 " << recHits.back().globalPosition().mag2() << " detid " - << recHits.back().geographicalId().rawId() << " cluster " - << hitIndexMap.clusterIndex( - MkFitHitIndexMap::MkFitHit{hitOnTrack.index, hitOnTrack.layer}); + << recHits.back().geographicalId().rawId() << " cluster " << hitOnTrack.index; lastHitInvalid = false; } } @@ -296,9 +299,9 @@ TrackCandidateCollection MkFitOutputConverter::convertCandidates(const MkFitOutp } auto tsosDet = - backwardFitInCMSSW_ - ? backwardFit(fts, recHits, propagatorAlong, propagatorOpposite, hitCloner, lastHitInvalid, lastHitChanged) - : convertInnermostState(fts, recHits, propagatorAlong, propagatorOpposite); + mkFitOutput.propagatedToFirstLayer() + ? convertInnermostState(fts, recHits, propagatorAlong, propagatorOpposite) + : backwardFit(fts, recHits, propagatorAlong, propagatorOpposite, hitCloner, lastHitInvalid, lastHitChanged); if (!tsosDet.first.isValid()) { edm::LogWarning("MkFitOutputConverter") << "Backward fit of candidate " << candIndex << " failed, ignoring the candidate"; diff --git a/RecoTracker/MkFit/plugins/MkFitProducer.cc b/RecoTracker/MkFit/plugins/MkFitProducer.cc index 7769a0c361bae..e1562164ff672 100644 --- a/RecoTracker/MkFit/plugins/MkFitProducer.cc +++ b/RecoTracker/MkFit/plugins/MkFitProducer.cc @@ -13,9 +13,9 @@ // mkFit includes #include "ConfigWrapper.h" -#include "Event.h" #include "LayerNumberConverter.h" #include "mkFit/buildtestMPlex.h" +#include "mkFit/IterationConfig.h" #include "mkFit/MkBuilderWrapper.h" // TBB includes @@ -41,7 +41,10 @@ class MkFitProducer : public edm::global::EDProducer mkFitGeomToken_; edm::EDPutTokenT putToken_; std::function buildFunction_; + const int iterationNumber_; // TODO: temporary solution + const bool seedCleaning_; bool backwardFitInCMSSW_; + const bool removeDuplicates_; bool mkFitSilent_; }; @@ -50,48 +53,39 @@ MkFitProducer::MkFitProducer(edm::ParameterSet const& iConfig) seedToken_{consumes(iConfig.getParameter("seeds"))}, mkFitGeomToken_{esConsumes()}, putToken_{produces()}, + iterationNumber_{iConfig.getParameter("iterationNumber")}, + seedCleaning_{iConfig.getParameter("seedCleaning")}, backwardFitInCMSSW_{iConfig.getParameter("backwardFitInCMSSW")}, + removeDuplicates_{iConfig.getParameter("removeDuplicates")}, mkFitSilent_{iConfig.getUntrackedParameter("mkFitSilent")} { const auto build = iConfig.getParameter("buildingRoutine"); if (build == "bestHit") { - buildFunction_ = mkfit::runBuildingTestPlexBestHit; + //buildFunction_ = mkfit::runBuildingTestPlexBestHit; + throw cms::Exception("Configuration") << "bestHit is temporarily disabled"; } else if (build == "standard") { - buildFunction_ = mkfit::runBuildingTestPlexStandard; + //buildFunction_ = mkfit::runBuildingTestPlexStandard; + throw cms::Exception("Configuration") << "standard is temporarily disabled"; } else if (build == "cloneEngine") { - buildFunction_ = mkfit::runBuildingTestPlexCloneEngine; - } else { - throw cms::Exception("Configuration") << "Invalid value for parameter 'buildingRoutine' " << build - << ", allowed are bestHit, standard, cloneEngine"; - } - - const auto seedClean = iConfig.getParameter("seedCleaning"); - auto seedCleanOpt = mkfit::ConfigWrapper::SeedCleaningOpts::noCleaning; - if (seedClean == "none") { - seedCleanOpt = mkfit::ConfigWrapper::SeedCleaningOpts::noCleaning; - } else if (seedClean == "N2") { - seedCleanOpt = mkfit::ConfigWrapper::SeedCleaningOpts::cleanSeedsN2; + //buildFunction_ = mkfit::runBuildingTestPlexCloneEngine; } else { throw cms::Exception("Configuration") - << "Invalida value for parameter 'seedCleaning' " << seedClean << ", allowed are none, N2"; + << "Invalid value for parameter 'buildingRoutine' " << build << ", allowed are bestHit, standard, cloneEngine"; } - auto backwardFitOpt = - backwardFitInCMSSW_ ? mkfit::ConfigWrapper::BackwardFit::noFit : mkfit::ConfigWrapper::BackwardFit::toFirstLayer; - // TODO: what to do when we have multiple instances of MkFitProducer in a job? mkfit::MkBuilderWrapper::populate(); - mkfit::ConfigWrapper::initializeForCMSSW(seedCleanOpt, backwardFitOpt, mkFitSilent_); - mkfit::ConfigWrapper::setRemoveDuplicates(iConfig.getParameter("removeDuplicates")); + mkfit::ConfigWrapper::initializeForCMSSW(mkFitSilent_); } void MkFitProducer::fillDescriptions(edm::ConfigurationDescriptions& descriptions) { edm::ParameterSetDescription desc; - desc.add("hits", edm::InputTag("mkFitHitConverter")); + desc.add("hits", edm::InputTag("mkFitHits")); desc.add("seeds", edm::InputTag("mkFitSeedConverter")); desc.add("buildingRoutine", "cloneEngine") ->setComment("Valid values are: 'bestHit', 'standard', 'cloneEngine'"); - desc.add("seedCleaning", "N2")->setComment("Valid values are: 'none', 'N2'"); + desc.add("iterationNumber", 0)->setComment("Iteration number (default: 0)"); + desc.add("seedCleaning", true)->setComment("Clean seeds within mkFit"); desc.add("removeDuplicates", true)->setComment("Run duplicate removal within mkFit"); desc.add("backwardFitInCMSSW", false) ->setComment("Do backward fit (to innermost hit) in CMSSW (true) or mkFit (false)"); @@ -124,16 +118,23 @@ void MkFitProducer::produce(edm::StreamID iID, edm::Event& iEvent, const edm::Ev mkfit::ConfigWrapper::setNTotalLayers(nlayers); }); - // CMSSW event ID (64-bit unsigned) does not fit in int - // In addition, unique ID requires also lumi and run - // But does the event ID really matter within mkFit? - mkfit::Event ev(iEvent.id().event()); - - ev.setInputFromCMSSW(hits.hits(), seeds.seeds()); - - tbb::this_task_arena::isolate([&]() { buildFunction_(ev, streamCache(iID)->get()); }); + // seeds need to be mutable because of the possible cleaning + auto seeds_mutable = seeds.seeds(); + mkfit::TrackVec tracks; + + tbb::this_task_arena::isolate([&]() { + mkfit::run_OneIteration(mkFitGeom.trackerInfo(), + mkFitGeom.iterationsInfo()[iterationNumber_], + hits.eventOfHits(), + streamCache(iID)->get(), + seeds_mutable, + tracks, + seedCleaning_, + not backwardFitInCMSSW_, + removeDuplicates_); + }); - iEvent.emplace(putToken_, std::move(ev.candidateTracks_), std::move(ev.fitTracks_)); + iEvent.emplace(putToken_, std::move(tracks), not backwardFitInCMSSW_); } DEFINE_FWK_MODULE(MkFitProducer); diff --git a/RecoTracker/MkFit/plugins/MkFitSeedConverter.cc b/RecoTracker/MkFit/plugins/MkFitSeedConverter.cc index 9f814b53d6e5b..4cecdfdb2a71f 100644 --- a/RecoTracker/MkFit/plugins/MkFitSeedConverter.cc +++ b/RecoTracker/MkFit/plugins/MkFitSeedConverter.cc @@ -9,6 +9,10 @@ #include "DataFormats/TrackerRecHit2D/interface/OmniClusterRef.h" #include "DataFormats/TrackerRecHit2D/interface/trackerHitRTTI.h" +#include "DataFormats/TrackerCommon/interface/TrackerTopology.h" +#include "DataFormats/TrackerCommon/interface/TrackerDetSide.h" +#include "Geometry/Records/interface/TrackerTopologyRcd.h" + #include "TrackingTools/Records/interface/TransientRecHitRecord.h" #include "TrackingTools/TransientTrackingRecHit/interface/TransientTrackingRecHitBuilder.h" #include "TrackingTools/TrajectoryState/interface/TrajectoryStateTransform.h" @@ -16,7 +20,9 @@ #include "MagneticField/Engine/interface/MagneticField.h" #include "MagneticField/Records/interface/IdealMagneticFieldRecord.h" -#include "RecoTracker/MkFit/interface/MkFitHitWrapper.h" +#include "RecoTracker/MkFit/interface/MkFitGeometry.h" +#include "RecoTracker/Record/interface/TrackerRecoGeometryRecord.h" + #include "RecoTracker/MkFit/interface/MkFitSeedWrapper.h" // ROOT @@ -24,6 +30,7 @@ #include "Math/SMatrix.h" // mkFit includes +#include "LayerNumberConverter.h" #include "Track.h" class MkFitSeedConverter : public edm::global::EDProducer<> { @@ -37,33 +44,35 @@ class MkFitSeedConverter : public edm::global::EDProducer<> { void produce(edm::StreamID, edm::Event& iEvent, const edm::EventSetup& iSetup) const override; mkfit::TrackVec convertSeeds(const edm::View& seeds, - const MkFitHitIndexMap& hitIndexMap, + const TrackerTopology& ttopo, const TransientTrackingRecHitBuilder& ttrhBuilder, - const MagneticField& mf) const; + const MagneticField& mf, + const MkFitGeometry& mkFitGeom) const; using SVector3 = ROOT::Math::SVector; using SMatrixSym33 = ROOT::Math::SMatrix>; using SMatrixSym66 = ROOT::Math::SMatrix>; - const edm::EDGetTokenT hitToken_; const edm::EDGetTokenT> seedToken_; const edm::ESGetToken ttrhBuilderToken_; + const edm::ESGetToken ttopoToken_; + const edm::ESGetToken mkFitGeomToken_; const edm::ESGetToken mfToken_; const edm::EDPutTokenT putToken_; }; MkFitSeedConverter::MkFitSeedConverter(edm::ParameterSet const& iConfig) - : hitToken_{consumes(iConfig.getParameter("hits"))}, - seedToken_{consumes>(iConfig.getParameter("seeds"))}, + : seedToken_{consumes>(iConfig.getParameter("seeds"))}, ttrhBuilderToken_{esConsumes( iConfig.getParameter("ttrhBuilder"))}, + ttopoToken_{esConsumes()}, + mkFitGeomToken_{esConsumes()}, mfToken_{esConsumes()}, putToken_{produces()} {} void MkFitSeedConverter::fillDescriptions(edm::ConfigurationDescriptions& descriptions) { edm::ParameterSetDescription desc; - desc.add("hits", edm::InputTag("mkFitHitConverter")); desc.add("seeds", edm::InputTag{"initialStepSeeds"}); desc.add("ttrhBuilder", edm::ESInputTag{"", "WithTrackAngle"}); @@ -73,17 +82,24 @@ void MkFitSeedConverter::fillDescriptions(edm::ConfigurationDescriptions& descri void MkFitSeedConverter::produce(edm::StreamID iID, edm::Event& iEvent, const edm::EventSetup& iSetup) const { iEvent.emplace(putToken_, convertSeeds(iEvent.get(seedToken_), - iEvent.get(hitToken_).hitIndexMap(), + iSetup.getData(ttopoToken_), iSetup.getData(ttrhBuilderToken_), - iSetup.getData(mfToken_))); + iSetup.getData(mfToken_), + iSetup.getData(mkFitGeomToken_))); } mkfit::TrackVec MkFitSeedConverter::convertSeeds(const edm::View& seeds, - const MkFitHitIndexMap& hitIndexMap, + const TrackerTopology& ttopo, const TransientTrackingRecHitBuilder& ttrhBuilder, - const MagneticField& mf) const { + const MagneticField& mf, + const MkFitGeometry& mkFitGeom) const { mkfit::TrackVec ret; ret.reserve(seeds.size()); + + auto isPlusSide = [&ttopo](const DetId& detid) { + return ttopo.side(detid) == static_cast(TrackerDetSide::PosEndcap); + }; + int seed_index = 0; for (const auto& seed : seeds) { auto const& hitRange = seed.recHits(); @@ -107,6 +123,7 @@ mkfit::TrackVec MkFitSeedConverter::convertSeeds(const edm::View mkfit::TrackState state(tsos.charge(), pos, mom, err); state.convertFromCartesianToCCS(); ret.emplace_back(state, 0, seed_index, 0, nullptr); + LogTrace("MkFitSeedConverter") << "Inserted seed with index " << seed_index; // Add hits for (auto const& recHit : hitRange) { @@ -114,8 +131,12 @@ mkfit::TrackVec MkFitSeedConverter::convertSeeds(const edm::View throw cms::Exception("Assert") << "Encountered a seed with a hit which is not trackerHitRTTI::isFromDet()"; } const auto& clusterRef = static_cast(recHit).firstClusterRef(); - const auto& mkFitHit = hitIndexMap.mkFitHit(clusterRef.id(), clusterRef.index()); - ret.back().addHitIdx(mkFitHit.index(), mkFitHit.layer(), 0); // per-hit chi2 is not known + const auto detId = recHit.geographicalId(); + const auto ilay = mkFitGeom.layerNumberConverter().convertLayerNumber( + detId.subdetId(), ttopo.layer(detId), false, ttopo.isStereo(detId), isPlusSide(detId)); + LogTrace("MkFitSeedConverter") << " addin hit detid " << detId.rawId() << " index " << clusterRef.index() + << " ilay " << ilay; + ret.back().addHitIdx(clusterRef.index(), ilay, 0); // per-hit chi2 is not known } ++seed_index; } diff --git a/RecoTracker/MkFit/python/customizeHLTIter0ToMkFit.py b/RecoTracker/MkFit/python/customizeHLTIter0ToMkFit.py index 40618133a82f0..40bc9d7b71e66 100644 --- a/RecoTracker/MkFit/python/customizeHLTIter0ToMkFit.py +++ b/RecoTracker/MkFit/python/customizeHLTIter0ToMkFit.py @@ -30,7 +30,6 @@ def customizeHLTIter0ToMkFit(process): minGoodStripCharge = dict(refToPSet_ = 'HLTSiStripClusterChargeCutLoose'), ) process.hltIter0PFlowCkfTrackCandidatesMkFitSeeds = mkFitSeedConverter_cfi.mkFitSeedConverter.clone( - hits = "hltIter0PFlowCkfTrackCandidatesMkFitHits", seeds = "hltIter0PFLowPixelSeedsFromPixelTracks", ttrhBuilder = ":hltESPTTRHBWithTrackAngle", ) diff --git a/RecoTracker/MkFit/src/MkFitGeometry.cc b/RecoTracker/MkFit/src/MkFitGeometry.cc index a21f67d55d7fa..4fc72ef028516 100644 --- a/RecoTracker/MkFit/src/MkFitGeometry.cc +++ b/RecoTracker/MkFit/src/MkFitGeometry.cc @@ -5,12 +5,21 @@ #include "RecoTracker/TkDetLayers/interface/GeometricSearchTracker.h" #include "RecoTracker/MkFit/interface/MkFitGeometry.h" +// these two are only temporarily in this file +#define USE_MATRIPLEX +#include "mkFit/SteeringParams.h" + #include "LayerNumberConverter.h" +#include "TrackerInfo.h" MkFitGeometry::MkFitGeometry(const TrackerGeometry& geom, const GeometricSearchTracker& tracker, - const TrackerTopology& ttopo) - : lnc_{std::make_unique(mkfit::TkLayout::phase1)} { + const TrackerTopology& ttopo, + std::unique_ptr trackerInfo, + std::unique_ptr iterationsInfo) + : lnc_{std::make_unique(mkfit::TkLayout::phase1)}, + trackerInfo_(std::move(trackerInfo)), + iterationsInfo_(std::move(iterationsInfo)) { if (geom.numberOfLayers(PixelSubdetector::PixelBarrel) != 4 || geom.numberOfLayers(PixelSubdetector::PixelEndcap) != 3) { throw cms::Exception("Assert") << "For now this code works only with phase1 tracker, you have something else"; diff --git a/RecoTracker/MkFit/src/MkFitHitIndexMap.cc b/RecoTracker/MkFit/src/MkFitHitIndexMap.cc deleted file mode 100644 index 89260eadbe565..0000000000000 --- a/RecoTracker/MkFit/src/MkFitHitIndexMap.cc +++ /dev/null @@ -1,68 +0,0 @@ -#include "RecoTracker/MkFit/interface/MkFitHitIndexMap.h" - -#include "FWCore/Utilities/interface/Exception.h" - -#include - -namespace { - template - auto resizeByClusterIndexImpl(T& cmsswToMkFit, edm::ProductID id, size_t clusterIndex) -> typename T::iterator { - auto found = - std::find_if(cmsswToMkFit.begin(), cmsswToMkFit.end(), [&](const auto& item) { return item.productID == id; }); - if (found == cmsswToMkFit.end()) { - found = cmsswToMkFit.emplace(cmsswToMkFit.end(), id); - } - if (found->mkFitHits.size() <= clusterIndex) { - found->mkFitHits.resize(clusterIndex + 1); - } - return found; - } -} // namespace - -void MkFitHitIndexMap::resizeByClusterIndex(edm::ProductID id, size_t clusterIndex) { - resizeByClusterIndexImpl(cmsswToMkFit_, id, clusterIndex); -} - -void MkFitHitIndexMap::increaseLayerSize(int layer, size_t additionalSize) { - if (layer >= static_cast(mkFitToCMSSW_.size())) { - mkFitToCMSSW_.resize(layer + 1); - } - mkFitToCMSSW_[layer].resize(mkFitToCMSSW_[layer].size() + additionalSize); -} - -void MkFitHitIndexMap::insert(edm::ProductID id, size_t clusterIndex, MkFitHit hit, const TrackingRecHit* hitPtr) { - // mapping CMSSW->mkfit - auto found = resizeByClusterIndexImpl(cmsswToMkFit_, id, clusterIndex); - found->mkFitHits[clusterIndex] = hit; - - // mapping mkfit->CMSSW - // when client calls increaseLayerSize() the two checks below are - // redundant, but better to keep them - if (hit.layer() >= static_cast(mkFitToCMSSW_.size())) { - mkFitToCMSSW_.resize(hit.layer() + 1); - } - auto& layer = mkFitToCMSSW_[hit.layer()]; - if (hit.index() >= static_cast(layer.size())) { - layer.resize(hit.index() + 1); - } - layer[hit.index()] = CMSSWHit(hitPtr, clusterIndex); -} - -const MkFitHitIndexMap::MkFitHit& MkFitHitIndexMap::mkFitHit(edm::ProductID id, size_t clusterIndex) const { - auto found = - std::find_if(cmsswToMkFit_.begin(), cmsswToMkFit_.end(), [&](const auto& item) { return item.productID == id; }); - if (found == cmsswToMkFit_.end()) { - auto exp = cms::Exception("Assert"); - exp << "Encountered a seed with a hit having productID " << id - << " which is not any of the input hit collections: "; - for (const auto& elem : cmsswToMkFit_) { - exp << elem.productID << " "; - } - throw exp; - } - const MkFitHit& ret = found->mkFitHits.at(clusterIndex); - if (ret.index() < 0) { - throw cms::Exception("Assert") << "No hit index for cluster " << clusterIndex << " of collection " << id; - } - return ret; -} diff --git a/RecoTracker/MkFit/src/MkFitHitWrapper.cc b/RecoTracker/MkFit/src/MkFitHitWrapper.cc index b4e86f4977c5f..759ed19add902 100644 --- a/RecoTracker/MkFit/src/MkFitHitWrapper.cc +++ b/RecoTracker/MkFit/src/MkFitHitWrapper.cc @@ -2,11 +2,13 @@ // mkFit includes #include "Hit.h" +#include "mkFit/HitStructures.h" MkFitHitWrapper::MkFitHitWrapper() = default; - -MkFitHitWrapper::MkFitHitWrapper(MkFitHitIndexMap hitIndexMap, std::vector hits) - : hitIndexMap_{std::move(hitIndexMap)}, hits_{std::move(hits)} {} +MkFitHitWrapper::MkFitHitWrapper(mkfit::TrackerInfo const& trackerInfo) + : eventOfHits_(std::make_unique(trackerInfo)), + pixelHits_(std::make_unique()), + outerHits_(std::make_unique()) {} MkFitHitWrapper::~MkFitHitWrapper() = default; diff --git a/RecoTracker/MkFit/src/MkFitOutputWrapper.cc b/RecoTracker/MkFit/src/MkFitOutputWrapper.cc index 0c670e22a7660..7ad4b457c10dc 100644 --- a/RecoTracker/MkFit/src/MkFitOutputWrapper.cc +++ b/RecoTracker/MkFit/src/MkFitOutputWrapper.cc @@ -5,8 +5,8 @@ MkFitOutputWrapper::MkFitOutputWrapper() = default; -MkFitOutputWrapper::MkFitOutputWrapper(mkfit::TrackVec&& candidateTracks, mkfit::TrackVec&& fitTracks) - : candidateTracks_{std::move(candidateTracks)}, fitTracks_{std::move(fitTracks)} {} +MkFitOutputWrapper::MkFitOutputWrapper(mkfit::TrackVec tracks, bool propagatedToFirstLayer) + : tracks_{std::move(tracks)}, propagatedToFirstLayer_{propagatedToFirstLayer} {} MkFitOutputWrapper::~MkFitOutputWrapper() = default; diff --git a/RecoTracker/MkFit/src/classes.h b/RecoTracker/MkFit/src/classes.h index a3f67ec346c4f..0579533564d3d 100644 --- a/RecoTracker/MkFit/src/classes.h +++ b/RecoTracker/MkFit/src/classes.h @@ -3,6 +3,7 @@ #include "DataFormats/Common/interface/Wrapper.h" #include "RecoTracker/MkFit/interface/MkFitHitWrapper.h" +#include "RecoTracker/MkFit/interface/MkFitClusterIndexToHit.h" #include "RecoTracker/MkFit/interface/MkFitSeedWrapper.h" #include "RecoTracker/MkFit/interface/MkFitOutputWrapper.h" diff --git a/RecoTracker/MkFit/src/classes_def.xml b/RecoTracker/MkFit/src/classes_def.xml index 2a25d525491cc..8ee51da8a9958 100644 --- a/RecoTracker/MkFit/src/classes_def.xml +++ b/RecoTracker/MkFit/src/classes_def.xml @@ -2,6 +2,9 @@ + + + diff --git a/Validation/RecoTrack/python/plotting/trackingPlots.py b/Validation/RecoTrack/python/plotting/trackingPlots.py index fda80114d7e8f..d474159a51108 100644 --- a/Validation/RecoTrack/python/plotting/trackingPlots.py +++ b/Validation/RecoTrack/python/plotting/trackingPlots.py @@ -1472,14 +1472,15 @@ def modules(self): "initialStepClassifier3", "initialStep", "initialStepSelector"], - building=["initialStepTrackCandidatesMkFitInput", + building=["initialStepTrackCandidatesMkFitSeeds", "initialStepTrackCandidatesMkFit", "initialStepTrackCandidates"], other=["firstStepPrimaryVerticesUnsorted", "initialStepTrackRefsForJets", "caloTowerForTrk", "ak4CaloJetsForTrk", - "firstStepPrimaryVertices"]), + "firstStepPrimaryVertices", + "mkFitHits"]), Iteration("highPtTripletStep", selection=["highPtTripletStepClassifier1", "highPtTripletStepClassifier2", From 6ed452ae30f781a848b114bd804369b6228113e2 Mon Sep 17 00:00:00 2001 From: Matti Kortelainen Date: Thu, 18 Feb 2021 17:56:03 -0800 Subject: [PATCH 11/20] Use mkFit in highPtTripletStep --- .../python/HighPtTripletStep_cff.py | 23 +++++++++++++++++++ .../python/plotting/trackingPlots.py | 6 ++--- 2 files changed, 25 insertions(+), 4 deletions(-) diff --git a/RecoTracker/IterativeTracking/python/HighPtTripletStep_cff.py b/RecoTracker/IterativeTracking/python/HighPtTripletStep_cff.py index a249bad2528c6..095fb29c480f9 100644 --- a/RecoTracker/IterativeTracking/python/HighPtTripletStep_cff.py +++ b/RecoTracker/IterativeTracking/python/HighPtTripletStep_cff.py @@ -215,6 +215,24 @@ useHitsSplitting = True ) +from Configuration.ProcessModifiers.trackingMkFit_cff import trackingMkFit +from RecoTracker.MkFit.mkFitGeometryESProducer_cfi import mkFitGeometryESProducer +import RecoTracker.MkFit.mkFitSeedConverter_cfi as mkFitSeedConverter_cfi +import RecoTracker.MkFit.mkFitProducer_cfi as mkFitProducer_cfi +import RecoTracker.MkFit.mkFitOutputConverter_cfi as mkFitOutputConverter_cfi +highPtTripletStepTrackCandidatesMkFitSeeds = mkFitSeedConverter_cfi.mkFitSeedConverter.clone( + seeds = 'highPtTripletStepSeeds', +) +highPtTripletStepTrackCandidatesMkFit = mkFitProducer_cfi.mkFitProducer.clone( + seeds = 'highPtTripletStepTrackCandidatesMkFitSeeds', + iterationNumber = 1, +) +trackingMkFit.toReplaceWith(highPtTripletStepTrackCandidates, mkFitOutputConverter_cfi.mkFitOutputConverter.clone( + seeds = 'highPtTripletStepSeeds', + mkfitSeeds = 'highPtTripletStepTrackCandidatesMkFitSeeds', + tracks = 'highPtTripletStepTrackCandidatesMkFit', +)) + # For Phase2PU140 from TrackingTools.TrajectoryCleaning.TrajectoryCleanerBySharedHits_cfi import trajectoryCleanerBySharedHits as _trajectoryCleanerBySharedHits highPtTripletStepTrajectoryCleanerBySharedHits = _trajectoryCleanerBySharedHits.clone( @@ -332,6 +350,11 @@ highPtTripletStepTracks, highPtTripletStep) HighPtTripletStep = cms.Sequence(HighPtTripletStepTask) + +_HighPtTripletStepTask_trackingMkFit = HighPtTripletStepTask.copy() +_HighPtTripletStepTask_trackingMkFit.add(highPtTripletStepTrackCandidatesMkFitSeeds, highPtTripletStepTrackCandidatesMkFit) +trackingMkFit.toReplaceWith(HighPtTripletStepTask, _HighPtTripletStepTask_trackingMkFit) + _HighPtTripletStepTask_Phase2PU140 = HighPtTripletStepTask.copy() _HighPtTripletStepTask_Phase2PU140.replace(highPtTripletStep, highPtTripletStepSelector) _HighPtTripletStep_Phase2PU140 = cms.Sequence(_HighPtTripletStepTask_Phase2PU140) diff --git a/Validation/RecoTrack/python/plotting/trackingPlots.py b/Validation/RecoTrack/python/plotting/trackingPlots.py index d474159a51108..cb606304ae9f0 100644 --- a/Validation/RecoTrack/python/plotting/trackingPlots.py +++ b/Validation/RecoTrack/python/plotting/trackingPlots.py @@ -1409,7 +1409,8 @@ def _set(param, name, modules): # it's fine to include e.g. quadruplets here also for pair # steps, as non-existing modules are just ignored _set(seeding, "_seeding", [self._name+"SeedingLayers", self._name+"TrackingRegions", self._name+"HitDoublets", self._name+"HitTriplets", self._name+"HitQuadruplets", self._name+"Seeds"]) - _set(building, "_building", [self._name+"TrackCandidates"]) + trackCandidates = self._name+"TrackCandidates" + _set(building, "_building", [trackCandidates+"MkFitSeeds", trackCandidates+"MkFit", trackCandidates]) _set(fit, "_fit", [self._name+"Tracks"]) _set(selection, "_selection", [self._name]) self._other = other @@ -1472,9 +1473,6 @@ def modules(self): "initialStepClassifier3", "initialStep", "initialStepSelector"], - building=["initialStepTrackCandidatesMkFitSeeds", - "initialStepTrackCandidatesMkFit", - "initialStepTrackCandidates"], other=["firstStepPrimaryVerticesUnsorted", "initialStepTrackRefsForJets", "caloTowerForTrk", From 9b878d5536c72187ad3db2fe3f984ea740dde9ef Mon Sep 17 00:00:00 2001 From: Matti Kortelainen Date: Fri, 5 Mar 2021 05:41:42 -0800 Subject: [PATCH 12/20] Add support for cluster mask, use it in HighPtTripletStep --- .../python/HighPtTripletStep_cff.py | 1 + RecoTracker/MkFit/plugins/BuildFile.xml | 3 ++ RecoTracker/MkFit/plugins/MkFitProducer.cc | 32 +++++++++++++++++++ 3 files changed, 36 insertions(+) diff --git a/RecoTracker/IterativeTracking/python/HighPtTripletStep_cff.py b/RecoTracker/IterativeTracking/python/HighPtTripletStep_cff.py index 095fb29c480f9..75a6301f5bf4b 100644 --- a/RecoTracker/IterativeTracking/python/HighPtTripletStep_cff.py +++ b/RecoTracker/IterativeTracking/python/HighPtTripletStep_cff.py @@ -226,6 +226,7 @@ highPtTripletStepTrackCandidatesMkFit = mkFitProducer_cfi.mkFitProducer.clone( seeds = 'highPtTripletStepTrackCandidatesMkFitSeeds', iterationNumber = 1, + clustersToSkip = 'highPtTripletStepClusters', ) trackingMkFit.toReplaceWith(highPtTripletStepTrackCandidates, mkFitOutputConverter_cfi.mkFitOutputConverter.clone( seeds = 'highPtTripletStepSeeds', diff --git a/RecoTracker/MkFit/plugins/BuildFile.xml b/RecoTracker/MkFit/plugins/BuildFile.xml index d94827ff2a2a3..386f8e2a12ab9 100644 --- a/RecoTracker/MkFit/plugins/BuildFile.xml +++ b/RecoTracker/MkFit/plugins/BuildFile.xml @@ -1,4 +1,7 @@ + + + diff --git a/RecoTracker/MkFit/plugins/MkFitProducer.cc b/RecoTracker/MkFit/plugins/MkFitProducer.cc index e1562164ff672..f4505046d3e5f 100644 --- a/RecoTracker/MkFit/plugins/MkFitProducer.cc +++ b/RecoTracker/MkFit/plugins/MkFitProducer.cc @@ -5,6 +5,11 @@ #include "FWCore/Framework/interface/MakerMacros.h" #include "FWCore/ParameterSet/interface/ParameterSet.h" +#include "DataFormats/Common/interface/ContainerMask.h" +#include "DataFormats/Common/interface/DetSetVectorNew.h" +#include "DataFormats/SiPixelCluster/interface/SiPixelCluster.h" +#include "DataFormats/SiStripCluster/interface/SiStripClusterfwd.h" + #include "RecoTracker/MkFit/interface/MkFitHitWrapper.h" #include "RecoTracker/MkFit/interface/MkFitSeedWrapper.h" #include "RecoTracker/MkFit/interface/MkFitOutputWrapper.h" @@ -38,6 +43,8 @@ class MkFitProducer : public edm::global::EDProducer hitToken_; const edm::EDGetTokenT seedToken_; + edm::EDGetTokenT > > pixelMaskToken_; + edm::EDGetTokenT > > stripMaskToken_; const edm::ESGetToken mkFitGeomToken_; edm::EDPutTokenT putToken_; std::function buildFunction_; @@ -58,6 +65,12 @@ MkFitProducer::MkFitProducer(edm::ParameterSet const& iConfig) backwardFitInCMSSW_{iConfig.getParameter("backwardFitInCMSSW")}, removeDuplicates_{iConfig.getParameter("removeDuplicates")}, mkFitSilent_{iConfig.getUntrackedParameter("mkFitSilent")} { + const auto clustersToSkip = iConfig.getParameter("clustersToSkip"); + if (not clustersToSkip.label().empty()) { + pixelMaskToken_ = consumes(clustersToSkip); + stripMaskToken_ = consumes(clustersToSkip); + } + const auto build = iConfig.getParameter("buildingRoutine"); if (build == "bestHit") { //buildFunction_ = mkfit::runBuildingTestPlexBestHit; @@ -82,6 +95,7 @@ void MkFitProducer::fillDescriptions(edm::ConfigurationDescriptions& description desc.add("hits", edm::InputTag("mkFitHits")); desc.add("seeds", edm::InputTag("mkFitSeedConverter")); + desc.add("clustersToSkip", edm::InputTag()); desc.add("buildingRoutine", "cloneEngine") ->setComment("Valid values are: 'bestHit', 'standard', 'cloneEngine'"); desc.add("iterationNumber", 0)->setComment("Iteration number (default: 0)"); @@ -111,6 +125,23 @@ void MkFitProducer::produce(edm::StreamID iID, edm::Event& iEvent, const edm::Ev // converters const auto& mkFitGeom = iSetup.getData(mkFitGeomToken_); + const std::vector* pixelMaskPtr = nullptr; + const std::vector* stripMaskPtr = nullptr; + std::vector pixelMask; + std::vector stripMask; + if (not pixelMaskToken_.isUninitialized()) { + const auto& pixelContainerMask = iEvent.get(pixelMaskToken_); + pixelMask.resize(pixelContainerMask.size(), false); + pixelContainerMask.copyMaskTo(pixelMask); + pixelMaskPtr = &pixelMask; + + const auto& stripContainerMask = iEvent.get(stripMaskToken_); + stripMask.resize(stripContainerMask.size(), false); + stripContainerMask.copyMaskTo(stripMask); + stripMaskPtr = &stripMask; + } + // TODO: add strip cluster charge cut + // Initialize the number of layers, has to be done exactly once in // the whole program. // TODO: the mechanism needs to be improved... @@ -126,6 +157,7 @@ void MkFitProducer::produce(edm::StreamID iID, edm::Event& iEvent, const edm::Ev mkfit::run_OneIteration(mkFitGeom.trackerInfo(), mkFitGeom.iterationsInfo()[iterationNumber_], hits.eventOfHits(), + {pixelMaskPtr, stripMaskPtr}, streamCache(iID)->get(), seeds_mutable, tracks, From 1127f5425589f82e1eb41a300488677694520d54 Mon Sep 17 00:00:00 2001 From: Matti Kortelainen Date: Mon, 8 Mar 2021 17:56:13 -0800 Subject: [PATCH 13/20] Add support for cluster charge cut per iteration --- RecoTracker/MkFit/interface/MkFitHitWrapper.h | 16 ++++ .../MkFit/plugins/MkFitHitConverter.cc | 87 ++++++++++++++----- RecoTracker/MkFit/plugins/MkFitProducer.cc | 27 ++++-- .../MkFit/python/customizeHLTIter0ToMkFit.py | 1 + RecoTracker/MkFit/python/mkFitProducer_cfi.py | 9 ++ RecoTracker/MkFit/src/MkFitHitWrapper.cc | 14 +++ 6 files changed, 126 insertions(+), 28 deletions(-) create mode 100644 RecoTracker/MkFit/python/mkFitProducer_cfi.py diff --git a/RecoTracker/MkFit/interface/MkFitHitWrapper.h b/RecoTracker/MkFit/interface/MkFitHitWrapper.h index 0af92386a1046..241c58864e87e 100644 --- a/RecoTracker/MkFit/interface/MkFitHitWrapper.h +++ b/RecoTracker/MkFit/interface/MkFitHitWrapper.h @@ -1,6 +1,8 @@ #ifndef RecoTracker_MkFit_MkFitHitWrapper_h #define RecoTracker_MkFit_MkFitHitWrapper_h +#include "DataFormats/Provenance/interface/ProductID.h" + #include #include @@ -25,12 +27,21 @@ class MkFitHitWrapper { mkfit::EventOfHits& eventOfHits() { return *eventOfHits_; } mkfit::EventOfHits const& eventOfHits() const { return *eventOfHits_; } + void setPixelClustersID(edm::ProductID id) { pixelClustersID_ = id; } + edm::ProductID pixelClustersID() const { return pixelClustersID_; } + + void setOuterClustersID(edm::ProductID id) { outerClustersID_ = id; } + edm::ProductID outerClustersID() const { return outerClustersID_; } + mkfit::HitVec& pixelHits() { return *pixelHits_; } mkfit::HitVec const& pixelHits() const { return *pixelHits_; } mkfit::HitVec& outerHits() { return *outerHits_; } mkfit::HitVec const& outerHits() const { return *outerHits_; } + std::vector& stripClusterCharge() { return stripClusterCharge_; } + void stripClusterChargeCut(float minThreshold, std::vector& mask) const; + private: std::unique_ptr eventOfHits_; @@ -39,6 +50,11 @@ class MkFitHitWrapper { // Vectors are indexed by the cluster index std::unique_ptr pixelHits_; std::unique_ptr outerHits_; + + std::vector stripClusterCharge_; + + edm::ProductID pixelClustersID_; + edm::ProductID outerClustersID_; }; #endif diff --git a/RecoTracker/MkFit/plugins/MkFitHitConverter.cc b/RecoTracker/MkFit/plugins/MkFitHitConverter.cc index e2d03324e2288..80d9952fc089a 100644 --- a/RecoTracker/MkFit/plugins/MkFitHitConverter.cc +++ b/RecoTracker/MkFit/plugins/MkFitHitConverter.cc @@ -5,6 +5,7 @@ #include "FWCore/ParameterSet/interface/ParameterSet.h" #include "FWCore/Utilities/interface/Likely.h" +#include "DataFormats/Provenance/interface/ProductID.h" #include "DataFormats/SiStripCluster/interface/SiStripClusterTools.h" #include "DataFormats/TrajectorySeed/interface/TrajectorySeed.h" #include "DataFormats/TrackerRecHit2D/interface/SiPixelRecHitCollection.h" @@ -45,13 +46,14 @@ class MkFitHitConverter : public edm::global::EDProducer<> { void produce(edm::StreamID, edm::Event& iEvent, const edm::EventSetup& iSetup) const override; template - void convertHits(const HitCollection& hits, - mkfit::EventOfHits& mkFitEventOfHits, - mkfit::HitVec& mkFitHits, - std::vector& clusterIndexToHit, - const TrackerTopology& ttopo, - const TransientTrackingRecHitBuilder& ttrhBuilder, - const MkFitGeometry& mkFitGeom) const; + edm::ProductID convertHits(const HitCollection& hits, + mkfit::EventOfHits& mkFitEventOfHits, + mkfit::HitVec& mkFitHits, + std::vector& clusterIndexToHit, + std::vector& clusterChargeVec, + const TrackerTopology& ttopo, + const TransientTrackingRecHitBuilder& ttrhBuilder, + const MkFitGeometry& mkFitGeom) const; float clusterCharge(const SiStripRecHit2D& hit, DetId hitId) const; std::nullptr_t clusterCharge(const SiPixelRecHit& hit, DetId hitId) const; @@ -118,12 +120,33 @@ void MkFitHitConverter::produce(edm::StreamID iID, edm::Event& iEvent, const edm MkFitClusterIndexToHit clusterIndexToHit; - auto convert = [&](auto& hits, auto& mkFitHits, auto& clusterIndexToHit) { - convertHits(hits, hitWrapper.eventOfHits(), mkFitHits, clusterIndexToHit, ttopo, ttrhBuilder, mkFitGeom); + auto convert = [&](auto& hits, auto& mkFitHits, auto& clusterIndexToHit, auto& clusterCharge) { + return convertHits( + hits, hitWrapper.eventOfHits(), mkFitHits, clusterIndexToHit, clusterCharge, ttopo, ttrhBuilder, mkFitGeom); }; - convert(iEvent.get(pixelRecHitToken_), hitWrapper.pixelHits(), clusterIndexToHit.pixelHits()); - convert(iEvent.get(stripRphiRecHitToken_), hitWrapper.outerHits(), clusterIndexToHit.outerHits()); - convert(iEvent.get(stripStereoRecHitToken_), hitWrapper.outerHits(), clusterIndexToHit.outerHits()); + std::vector dummy; + auto pixelClusterID = + convert(iEvent.get(pixelRecHitToken_), hitWrapper.pixelHits(), clusterIndexToHit.pixelHits(), dummy); + + edm::ProductID stripClusterID; + const auto& stripRphiHits = iEvent.get(stripRphiRecHitToken_); + const auto& stripStereoHits = iEvent.get(stripStereoRecHitToken_); + if (not stripRphiHits.empty()) { + stripClusterID = + convert(stripRphiHits, hitWrapper.outerHits(), clusterIndexToHit.outerHits(), hitWrapper.stripClusterCharge()); + } + if (not stripStereoHits.empty()) { + auto stripStereoClusterID = convert( + stripStereoHits, hitWrapper.outerHits(), clusterIndexToHit.outerHits(), hitWrapper.stripClusterCharge()); + if (stripRphiHits.empty()) { + stripClusterID = stripStereoClusterID; + } else if (stripClusterID != stripStereoClusterID) { + throw cms::Exception("LogicError") << "Encountered different cluster ProductIDs for strip RPhi hits (" + << stripClusterID << ") and stereo (" << stripStereoClusterID << ")"; + } + } + hitWrapper.setPixelClustersID(pixelClusterID); + hitWrapper.setOuterClustersID(stripClusterID); mkfit::StdSeq::Cmssw_LoadHits_End(hitWrapper.eventOfHits()); @@ -149,25 +172,33 @@ void MkFitHitConverter::setDetails(mkfit::Hit& mhit, const SiStripCluster& clust } template -void MkFitHitConverter::convertHits(const HitCollection& hits, - mkfit::EventOfHits& mkFitEventOfHits, - mkfit::HitVec& mkFitHits, - std::vector& clusterIndexToHit, - const TrackerTopology& ttopo, - const TransientTrackingRecHitBuilder& ttrhBuilder, - const MkFitGeometry& mkFitGeom) const { +edm::ProductID MkFitHitConverter::convertHits(const HitCollection& hits, + mkfit::EventOfHits& mkFitEventOfHits, + mkfit::HitVec& mkFitHits, + std::vector& clusterIndexToHit, + std::vector& clusterChargeVec, + const TrackerTopology& ttopo, + const TransientTrackingRecHitBuilder& ttrhBuilder, + const MkFitGeometry& mkFitGeom) const { if (hits.empty()) - return; + return edm::ProductID{}; auto isPlusSide = [&ttopo](const DetId& detid) { return ttopo.side(detid) == static_cast(TrackerDetSide::PosEndcap); }; + constexpr bool applyCCC = std::is_same_v; + + edm::ProductID clusterID; { const auto& lastClusterRef = hits.data().back().firstClusterRef(); + clusterID = lastClusterRef.id(); if (lastClusterRef.index() >= mkFitHits.size()) { auto const size = lastClusterRef.index(); mkFitHits.resize(size); clusterIndexToHit.resize(size, nullptr); + if constexpr (applyCCC) { + clusterChargeVec.resize(size, -1.f); + } } } @@ -195,7 +226,13 @@ void MkFitHitConverter::convertHits(const HitCollection& hits, err.At(0, 2) = gerr.czx(); err.At(1, 2) = gerr.czy(); - const auto clusterIndex = hit.firstClusterRef().index(); + auto clusterRef = hit.firstClusterRef(); + if UNLIKELY (clusterRef.id() != clusterID) { + throw cms::Exception("LogicError") + << "Input hit collection has Refs to many cluster collections. Last hit had Ref to product " << clusterID + << ", but encountered Ref to product " << clusterRef.id() << " on detid " << detid.rawId(); + } + const auto clusterIndex = clusterRef.index(); LogTrace("MkFitHitConverter") << "Adding hit detid " << detid.rawId() << " subdet " << subdet << " layer " << layer << " isStereo " << isStereo << " zplus " << isPlusSide(detid) << " index " << clusterIndex << " ilay " << ilay; @@ -203,15 +240,23 @@ void MkFitHitConverter::convertHits(const HitCollection& hits, if UNLIKELY (clusterIndex >= mkFitHits.size()) { mkFitHits.resize(clusterIndex + 1); clusterIndexToHit.resize(clusterIndex + 1, nullptr); + if constexpr (applyCCC) { + clusterChargeVec.resize(clusterIndex + 1, -1.f); + } } mkFitHits[clusterIndex] = mkfit::Hit(pos, err); clusterIndexToHit[clusterIndex] = &hit; + if constexpr (applyCCC) { + clusterChargeVec[clusterIndex] = charge; + } + const auto uniqueIdInLayer = mkFitGeom.uniqueIdInLayer(ilay, detid.rawId()); setDetails(mkFitHits[clusterIndex], *(hit.cluster()), uniqueIdInLayer, charge); mkFitEventOfHits[ilay].RegisterHit(clusterIndex); } } + return clusterID; } DEFINE_FWK_MODULE(MkFitHitConverter); diff --git a/RecoTracker/MkFit/plugins/MkFitProducer.cc b/RecoTracker/MkFit/plugins/MkFitProducer.cc index f4505046d3e5f..9c1527a72bf0e 100644 --- a/RecoTracker/MkFit/plugins/MkFitProducer.cc +++ b/RecoTracker/MkFit/plugins/MkFitProducer.cc @@ -48,6 +48,7 @@ class MkFitProducer : public edm::global::EDProducer mkFitGeomToken_; edm::EDPutTokenT putToken_; std::function buildFunction_; + const float minGoodStripCharge_; const int iterationNumber_; // TODO: temporary solution const bool seedCleaning_; bool backwardFitInCMSSW_; @@ -60,6 +61,8 @@ MkFitProducer::MkFitProducer(edm::ParameterSet const& iConfig) seedToken_{consumes(iConfig.getParameter("seeds"))}, mkFitGeomToken_{esConsumes()}, putToken_{produces()}, + minGoodStripCharge_{static_cast( + iConfig.getParameter("minGoodStripCharge").getParameter("value"))}, iterationNumber_{iConfig.getParameter("iterationNumber")}, seedCleaning_{iConfig.getParameter("seedCleaning")}, backwardFitInCMSSW_{iConfig.getParameter("backwardFitInCMSSW")}, @@ -105,7 +108,11 @@ void MkFitProducer::fillDescriptions(edm::ConfigurationDescriptions& description ->setComment("Do backward fit (to innermost hit) in CMSSW (true) or mkFit (false)"); desc.addUntracked("mkFitSilent", true)->setComment("Allows to enables printouts from mkFit with 'False'"); - descriptions.add("mkFitProducer", desc); + edm::ParameterSetDescription descCCC; + descCCC.add("value"); + desc.add("minGoodStripCharge", descCCC); + + descriptions.add("mkFitProducerDefault", desc); } std::unique_ptr MkFitProducer::beginStream(edm::StreamID iID) const { @@ -126,21 +133,27 @@ void MkFitProducer::produce(edm::StreamID iID, edm::Event& iEvent, const edm::Ev const auto& mkFitGeom = iSetup.getData(mkFitGeomToken_); const std::vector* pixelMaskPtr = nullptr; - const std::vector* stripMaskPtr = nullptr; std::vector pixelMask; - std::vector stripMask; + std::vector stripMask(hits.outerHits().size(), false); if (not pixelMaskToken_.isUninitialized()) { const auto& pixelContainerMask = iEvent.get(pixelMaskToken_); pixelMask.resize(pixelContainerMask.size(), false); + if UNLIKELY (pixelContainerMask.refProd().id() != hits.pixelClustersID()) { + throw cms::Exception("LogicError") << "MkFitHitWrapper has pixel cluster ID " << hits.pixelClustersID() + << " but pixel cluster mask has " << pixelContainerMask.refProd().id(); + } pixelContainerMask.copyMaskTo(pixelMask); pixelMaskPtr = &pixelMask; const auto& stripContainerMask = iEvent.get(stripMaskToken_); - stripMask.resize(stripContainerMask.size(), false); + if UNLIKELY (stripContainerMask.refProd().id() != hits.outerClustersID()) { + throw cms::Exception("LogicError") << "MkFitHitWrapper has strip cluster ID " << hits.outerClustersID() + << " but strip cluster mask has " << stripContainerMask.refProd().id(); + } stripContainerMask.copyMaskTo(stripMask); - stripMaskPtr = &stripMask; + } else { + hits.stripClusterChargeCut(minGoodStripCharge_, stripMask); } - // TODO: add strip cluster charge cut // Initialize the number of layers, has to be done exactly once in // the whole program. @@ -157,7 +170,7 @@ void MkFitProducer::produce(edm::StreamID iID, edm::Event& iEvent, const edm::Ev mkfit::run_OneIteration(mkFitGeom.trackerInfo(), mkFitGeom.iterationsInfo()[iterationNumber_], hits.eventOfHits(), - {pixelMaskPtr, stripMaskPtr}, + {pixelMaskPtr, &stripMask}, streamCache(iID)->get(), seeds_mutable, tracks, diff --git a/RecoTracker/MkFit/python/customizeHLTIter0ToMkFit.py b/RecoTracker/MkFit/python/customizeHLTIter0ToMkFit.py index 40bc9d7b71e66..82d88d40c5fb0 100644 --- a/RecoTracker/MkFit/python/customizeHLTIter0ToMkFit.py +++ b/RecoTracker/MkFit/python/customizeHLTIter0ToMkFit.py @@ -36,6 +36,7 @@ def customizeHLTIter0ToMkFit(process): process.hltIter0PFlowCkfTrackCandidatesMkFit = mkFitProducer_cfi.mkFitProducer.clone( hits = "hltIter0PFlowCkfTrackCandidatesMkFitHits", seeds = "hltIter0PFlowCkfTrackCandidatesMkFitSeeds", + minGoodStripCharge = dict(refToPSet_ = 'HLTSiStripClusterChargeCutLoose'), ) process.hltIter0PFlowCkfTrackCandidates = mkFitOutputConverter_cfi.mkFitOutputConverter.clone( seeds = "hltIter0PFLowPixelSeedsFromPixelTracks", diff --git a/RecoTracker/MkFit/python/mkFitProducer_cfi.py b/RecoTracker/MkFit/python/mkFitProducer_cfi.py new file mode 100644 index 0000000000000..4badc5eceb6a9 --- /dev/null +++ b/RecoTracker/MkFit/python/mkFitProducer_cfi.py @@ -0,0 +1,9 @@ +import FWCore.ParameterSet.Config as cms + +from RecoTracker.MkFit.mkFitProducerDefault_cfi import mkFitProducerDefault as _mkFitProducerDefault +from RecoLocalTracker.SiStripClusterizer.SiStripClusterChargeCut_cfi import * + +mkFitProducer = _mkFitProducerDefault.clone( + minGoodStripCharge = cms.PSet( + refToPSet_ = cms.string('SiStripClusterChargeCutLoose')) +) diff --git a/RecoTracker/MkFit/src/MkFitHitWrapper.cc b/RecoTracker/MkFit/src/MkFitHitWrapper.cc index 759ed19add902..e5f7f8d63c712 100644 --- a/RecoTracker/MkFit/src/MkFitHitWrapper.cc +++ b/RecoTracker/MkFit/src/MkFitHitWrapper.cc @@ -1,3 +1,4 @@ +#include "FWCore/Utilities/interface/Exception.h" #include "RecoTracker/MkFit/interface/MkFitHitWrapper.h" // mkFit includes @@ -14,3 +15,16 @@ MkFitHitWrapper::~MkFitHitWrapper() = default; MkFitHitWrapper::MkFitHitWrapper(MkFitHitWrapper&&) = default; MkFitHitWrapper& MkFitHitWrapper::operator=(MkFitHitWrapper&&) = default; + +void MkFitHitWrapper::stripClusterChargeCut(float minThreshold, std::vector& mask) const { + if (mask.size() != stripClusterCharge_.size()) { + cms::Exception e("LogicError"); + e << "Mask size (" << mask.size() << ") inconsistent with number of hits (" << stripClusterCharge_.size() << ")"; + e.addContext("Calling MkFitHitWraper::applyStripClusterCharge()"); + throw e; + } + for (int i = 0, end = stripClusterCharge_.size(); i < end; ++i) { + // mask == true means skip the cluster + mask[i] = mask[i] || (stripClusterCharge_[i] <= minThreshold); + } +} From 7ed601f44cc108100f8af421c6fd841f76cc85c4 Mon Sep 17 00:00:00 2001 From: Matti Kortelainen Date: Thu, 18 Mar 2021 12:18:12 -0700 Subject: [PATCH 14/20] Allow switching individual iterations to mkFit, add customizations and enable in selected iterations --- .../python/trackingMkFitCommon_cff.py | 4 +++ .../trackingMkFitDetachedQuadStep_cff.py | 4 +++ .../trackingMkFitDetachedTripletStep_cff.py | 4 +++ .../trackingMkFitHighPtTripletStep_cff.py | 4 +++ .../python/trackingMkFitInitialStep_cff.py | 4 +++ .../python/trackingMkFitLowPtQuadStep_cff.py | 4 +++ .../trackingMkFitLowPtTripletStep_cff.py | 4 +++ .../trackingMkFitMixedTripletStep_cff.py | 4 +++ .../python/trackingMkFitPixelLessStep_cff.py | 4 +++ .../python/trackingMkFitTobTecStep_cff.py | 4 +++ .../python/trackingMkFit_cff.py | 26 +++++++++++++++++-- .../python/DetachedQuadStep_cff.py | 23 ++++++++++++++++ .../python/DetachedTripletStep_cff.py | 23 ++++++++++++++++ .../python/HighPtTripletStep_cff.py | 7 +++-- .../python/InitialStep_cff.py | 13 +++++++--- .../python/LowPtQuadStep_cff.py | 22 ++++++++++++++++ .../python/LowPtTripletStep_cff.py | 22 ++++++++++++++++ .../python/MixedTripletStep_cff.py | 24 +++++++++++++++++ .../python/PixelLessStep_cff.py | 23 ++++++++++++++++ .../python/TobTecStep_cff.py | 22 ++++++++++++++++ 20 files changed, 235 insertions(+), 10 deletions(-) create mode 100644 Configuration/ProcessModifiers/python/trackingMkFitCommon_cff.py create mode 100644 Configuration/ProcessModifiers/python/trackingMkFitDetachedQuadStep_cff.py create mode 100644 Configuration/ProcessModifiers/python/trackingMkFitDetachedTripletStep_cff.py create mode 100644 Configuration/ProcessModifiers/python/trackingMkFitHighPtTripletStep_cff.py create mode 100644 Configuration/ProcessModifiers/python/trackingMkFitInitialStep_cff.py create mode 100644 Configuration/ProcessModifiers/python/trackingMkFitLowPtQuadStep_cff.py create mode 100644 Configuration/ProcessModifiers/python/trackingMkFitLowPtTripletStep_cff.py create mode 100644 Configuration/ProcessModifiers/python/trackingMkFitMixedTripletStep_cff.py create mode 100644 Configuration/ProcessModifiers/python/trackingMkFitPixelLessStep_cff.py create mode 100644 Configuration/ProcessModifiers/python/trackingMkFitTobTecStep_cff.py diff --git a/Configuration/ProcessModifiers/python/trackingMkFitCommon_cff.py b/Configuration/ProcessModifiers/python/trackingMkFitCommon_cff.py new file mode 100644 index 0000000000000..d6ddd4f9ba133 --- /dev/null +++ b/Configuration/ProcessModifiers/python/trackingMkFitCommon_cff.py @@ -0,0 +1,4 @@ +import FWCore.ParameterSet.Config as cms + +# This modifier does iteration-independent changes for enabling mkFit +trackingMkFitCommon = cms.Modifier() diff --git a/Configuration/ProcessModifiers/python/trackingMkFitDetachedQuadStep_cff.py b/Configuration/ProcessModifiers/python/trackingMkFitDetachedQuadStep_cff.py new file mode 100644 index 0000000000000..18bd2a903f982 --- /dev/null +++ b/Configuration/ProcessModifiers/python/trackingMkFitDetachedQuadStep_cff.py @@ -0,0 +1,4 @@ +import FWCore.ParameterSet.Config as cms + +# This modifier sets replaces the default pattern recognition with mkFit for detachedQuadStep +trackingMkFitDetachedQuadStep = cms.Modifier() diff --git a/Configuration/ProcessModifiers/python/trackingMkFitDetachedTripletStep_cff.py b/Configuration/ProcessModifiers/python/trackingMkFitDetachedTripletStep_cff.py new file mode 100644 index 0000000000000..9cb5bcf705357 --- /dev/null +++ b/Configuration/ProcessModifiers/python/trackingMkFitDetachedTripletStep_cff.py @@ -0,0 +1,4 @@ +import FWCore.ParameterSet.Config as cms + +# This modifier sets replaces the default pattern recognition with mkFit for detachedTripletStep +trackingMkFitDetachedTripletStep = cms.Modifier() diff --git a/Configuration/ProcessModifiers/python/trackingMkFitHighPtTripletStep_cff.py b/Configuration/ProcessModifiers/python/trackingMkFitHighPtTripletStep_cff.py new file mode 100644 index 0000000000000..4db29d1d80275 --- /dev/null +++ b/Configuration/ProcessModifiers/python/trackingMkFitHighPtTripletStep_cff.py @@ -0,0 +1,4 @@ +import FWCore.ParameterSet.Config as cms + +# This modifier sets replaces the default pattern recognition with mkFit for highPtTripletStep +trackingMkFitHighPtTripletStep = cms.Modifier() diff --git a/Configuration/ProcessModifiers/python/trackingMkFitInitialStep_cff.py b/Configuration/ProcessModifiers/python/trackingMkFitInitialStep_cff.py new file mode 100644 index 0000000000000..3c4445795d201 --- /dev/null +++ b/Configuration/ProcessModifiers/python/trackingMkFitInitialStep_cff.py @@ -0,0 +1,4 @@ +import FWCore.ParameterSet.Config as cms + +# This modifier sets replaces the default pattern recognition with mkFit for initialStep +trackingMkFitInitialStep = cms.Modifier() diff --git a/Configuration/ProcessModifiers/python/trackingMkFitLowPtQuadStep_cff.py b/Configuration/ProcessModifiers/python/trackingMkFitLowPtQuadStep_cff.py new file mode 100644 index 0000000000000..5b0c4a622e86a --- /dev/null +++ b/Configuration/ProcessModifiers/python/trackingMkFitLowPtQuadStep_cff.py @@ -0,0 +1,4 @@ +import FWCore.ParameterSet.Config as cms + +# This modifier sets replaces the default pattern recognition with mkFit for lowPtQuadStep +trackingMkFitLowPtQuadStep = cms.Modifier() diff --git a/Configuration/ProcessModifiers/python/trackingMkFitLowPtTripletStep_cff.py b/Configuration/ProcessModifiers/python/trackingMkFitLowPtTripletStep_cff.py new file mode 100644 index 0000000000000..d4ecaf8cb950d --- /dev/null +++ b/Configuration/ProcessModifiers/python/trackingMkFitLowPtTripletStep_cff.py @@ -0,0 +1,4 @@ +import FWCore.ParameterSet.Config as cms + +# This modifier sets replaces the default pattern recognition with mkFit for lowPtTripletStep +trackingMkFitLowPtTripletStep = cms.Modifier() diff --git a/Configuration/ProcessModifiers/python/trackingMkFitMixedTripletStep_cff.py b/Configuration/ProcessModifiers/python/trackingMkFitMixedTripletStep_cff.py new file mode 100644 index 0000000000000..104fc5aeb5029 --- /dev/null +++ b/Configuration/ProcessModifiers/python/trackingMkFitMixedTripletStep_cff.py @@ -0,0 +1,4 @@ +import FWCore.ParameterSet.Config as cms + +# This modifier sets replaces the default pattern recognition with mkFit for mixedTripletStep +trackingMkFitMixedTripletStep = cms.Modifier() diff --git a/Configuration/ProcessModifiers/python/trackingMkFitPixelLessStep_cff.py b/Configuration/ProcessModifiers/python/trackingMkFitPixelLessStep_cff.py new file mode 100644 index 0000000000000..396d80eb7bf2e --- /dev/null +++ b/Configuration/ProcessModifiers/python/trackingMkFitPixelLessStep_cff.py @@ -0,0 +1,4 @@ +import FWCore.ParameterSet.Config as cms + +# This modifier sets replaces the default pattern recognition with mkFit for pixelLessStep +trackingMkFitPixelLessStep = cms.Modifier() diff --git a/Configuration/ProcessModifiers/python/trackingMkFitTobTecStep_cff.py b/Configuration/ProcessModifiers/python/trackingMkFitTobTecStep_cff.py new file mode 100644 index 0000000000000..b8317e86fff68 --- /dev/null +++ b/Configuration/ProcessModifiers/python/trackingMkFitTobTecStep_cff.py @@ -0,0 +1,4 @@ +import FWCore.ParameterSet.Config as cms + +# This modifier sets replaces the default pattern recognition with mkFit for tobTecStep +trackingMkFitTobTecStep = cms.Modifier() diff --git a/Configuration/ProcessModifiers/python/trackingMkFit_cff.py b/Configuration/ProcessModifiers/python/trackingMkFit_cff.py index 08903e6a84258..b62a8d8376937 100644 --- a/Configuration/ProcessModifiers/python/trackingMkFit_cff.py +++ b/Configuration/ProcessModifiers/python/trackingMkFit_cff.py @@ -1,4 +1,26 @@ import FWCore.ParameterSet.Config as cms -# This modifier sets replaces the default pattern recognition with mkFit (possibly in selected iterations only) -trackingMkFit = cms.Modifier() +from Configuration.ProcessModifiers.trackingMkFitCommon_cff import * +from Configuration.ProcessModifiers.trackingMkFitInitialStep_cff import * +from Configuration.ProcessModifiers.trackingMkFitLowPtQuadStep_cff import * +from Configuration.ProcessModifiers.trackingMkFitHighPtTripletStep_cff import * +from Configuration.ProcessModifiers.trackingMkFitLowPtTripletStep_cff import * +from Configuration.ProcessModifiers.trackingMkFitDetachedQuadStep_cff import * +from Configuration.ProcessModifiers.trackingMkFitDetachedTripletStep_cff import * +from Configuration.ProcessModifiers.trackingMkFitMixedTripletStep_cff import * +from Configuration.ProcessModifiers.trackingMkFitPixelLessStep_cff import * +from Configuration.ProcessModifiers.trackingMkFitTobTecStep_cff import * + +# Use mkFit in selected iterations +trackingMkFit = cms.ModifierChain( + trackingMkFitCommon, + trackingMkFitInitialStep, + trackingMkFitLowPtQuadStep, + trackingMkFitHighPtTripletStep, + trackingMkFitLowPtTripletStep, + trackingMkFitDetachedQuadStep, +# trackingMkFitDetachedTripletStep, # to be enabled later +# trackingMkFitMixedTripletStep, # to be enabled later + trackingMkFitPixelLessStep, + trackingMkFitTobTecStep, +) diff --git a/RecoTracker/IterativeTracking/python/DetachedQuadStep_cff.py b/RecoTracker/IterativeTracking/python/DetachedQuadStep_cff.py index 8f0f7e466fb3a..acbb64226eb61 100644 --- a/RecoTracker/IterativeTracking/python/DetachedQuadStep_cff.py +++ b/RecoTracker/IterativeTracking/python/DetachedQuadStep_cff.py @@ -186,6 +186,24 @@ phase2clustersToSkip = cms.InputTag('detachedQuadStepClusters') ) +from Configuration.ProcessModifiers.trackingMkFitDetachedQuadStep_cff import trackingMkFitDetachedQuadStep +import RecoTracker.MkFit.mkFitSeedConverter_cfi as mkFitSeedConverter_cfi +import RecoTracker.MkFit.mkFitProducer_cfi as mkFitProducer_cfi +import RecoTracker.MkFit.mkFitOutputConverter_cfi as mkFitOutputConverter_cfi +detachedQuadStepTrackCandidatesMkFitSeeds = mkFitSeedConverter_cfi.mkFitSeedConverter.clone( + seeds = 'detachedQuadStepSeeds', +) +detachedQuadStepTrackCandidatesMkFit = mkFitProducer_cfi.mkFitProducer.clone( + seeds = 'detachedQuadStepTrackCandidatesMkFitSeeds', + iterationNumber = 4, + clustersToSkip = 'detachedQuadStepClusters', +) +trackingMkFitDetachedQuadStep.toReplaceWith(detachedQuadStepTrackCandidates, mkFitOutputConverter_cfi.mkFitOutputConverter.clone( + seeds = 'detachedQuadStepSeeds', + mkfitSeeds = 'detachedQuadStepTrackCandidatesMkFitSeeds', + tracks = 'detachedQuadStepTrackCandidatesMkFit', +)) + #For FastSim phase1 tracking import FastSimulation.Tracking.TrackCandidateProducer_cfi _fastSim_detachedQuadStepTrackCandidates = FastSimulation.Tracking.TrackCandidateProducer_cfi.trackCandidateProducer.clone( @@ -337,6 +355,11 @@ detachedQuadStepTracks, detachedQuadStep) DetachedQuadStep = cms.Sequence(DetachedQuadStepTask) + +_DetachedQuadStepTask_trackingMkFit = DetachedQuadStepTask.copy() +_DetachedQuadStepTask_trackingMkFit.add(detachedQuadStepTrackCandidatesMkFitSeeds, detachedQuadStepTrackCandidatesMkFit) +trackingMkFitDetachedQuadStep.toReplaceWith(DetachedQuadStepTask, _DetachedQuadStepTask_trackingMkFit) + _DetachedQuadStepTask_Phase2PU140 = DetachedQuadStepTask.copy() _DetachedQuadStepTask_Phase2PU140.replace(detachedQuadStep, cms.Task(detachedQuadStepSelector,detachedQuadStep)) trackingPhase2PU140.toReplaceWith(DetachedQuadStepTask, _DetachedQuadStepTask_Phase2PU140) diff --git a/RecoTracker/IterativeTracking/python/DetachedTripletStep_cff.py b/RecoTracker/IterativeTracking/python/DetachedTripletStep_cff.py index a97483e20256f..58816d142e483 100644 --- a/RecoTracker/IterativeTracking/python/DetachedTripletStep_cff.py +++ b/RecoTracker/IterativeTracking/python/DetachedTripletStep_cff.py @@ -214,6 +214,24 @@ detachedTripletStepTrackCandidates.TrajectoryCleaner = 'detachedTripletStepTrajectoryCleanerBySharedHits' trackingLowPU.toModify(detachedTripletStepTrajectoryCleanerBySharedHits, fractionShared = 0.19) +from Configuration.ProcessModifiers.trackingMkFitDetachedTripletStep_cff import trackingMkFitDetachedTripletStep +import RecoTracker.MkFit.mkFitSeedConverter_cfi as mkFitSeedConverter_cfi +import RecoTracker.MkFit.mkFitProducer_cfi as mkFitProducer_cfi +import RecoTracker.MkFit.mkFitOutputConverter_cfi as mkFitOutputConverter_cfi +detachedTripletStepTrackCandidatesMkFitSeeds = mkFitSeedConverter_cfi.mkFitSeedConverter.clone( + seeds = 'detachedTripletStepSeeds', +) +detachedTripletStepTrackCandidatesMkFit = mkFitProducer_cfi.mkFitProducer.clone( + seeds = 'detachedTripletStepTrackCandidatesMkFitSeeds', + iterationNumber = 5, + clustersToSkip = 'detachedTripletStepClusters', +) +trackingMkFitDetachedTripletStep.toReplaceWith(detachedTripletStepTrackCandidates, mkFitOutputConverter_cfi.mkFitOutputConverter.clone( + seeds = 'detachedTripletStepSeeds', + mkfitSeeds = 'detachedTripletStepTrackCandidatesMkFitSeeds', + tracks = 'detachedTripletStepTrackCandidatesMkFit', +)) + import FastSimulation.Tracking.TrackCandidateProducer_cfi _fastSim_detachedTripletStepTrackCandidates = FastSimulation.Tracking.TrackCandidateProducer_cfi.trackCandidateProducer.clone( src = 'detachedTripletStepSeeds', @@ -379,6 +397,11 @@ detachedTripletStepClassifier1,detachedTripletStepClassifier2, detachedTripletStep) DetachedTripletStep = cms.Sequence(DetachedTripletStepTask) + +_DetachedTripletStepTask_trackingMkFit = DetachedTripletStepTask.copy() +_DetachedTripletStepTask_trackingMkFit.add(detachedTripletStepTrackCandidatesMkFitSeeds, detachedTripletStepTrackCandidatesMkFit) +trackingMkFitDetachedTripletStep.toReplaceWith(DetachedTripletStepTask, _DetachedTripletStepTask_trackingMkFit) + _DetachedTripletStepTask_LowPU = DetachedTripletStepTask.copyAndExclude([detachedTripletStepClassifier2]) _DetachedTripletStepTask_LowPU.replace(detachedTripletStepClassifier1, detachedTripletStepSelector) trackingLowPU.toReplaceWith(DetachedTripletStepTask, _DetachedTripletStepTask_LowPU) diff --git a/RecoTracker/IterativeTracking/python/HighPtTripletStep_cff.py b/RecoTracker/IterativeTracking/python/HighPtTripletStep_cff.py index 75a6301f5bf4b..15f3243916527 100644 --- a/RecoTracker/IterativeTracking/python/HighPtTripletStep_cff.py +++ b/RecoTracker/IterativeTracking/python/HighPtTripletStep_cff.py @@ -215,8 +215,7 @@ useHitsSplitting = True ) -from Configuration.ProcessModifiers.trackingMkFit_cff import trackingMkFit -from RecoTracker.MkFit.mkFitGeometryESProducer_cfi import mkFitGeometryESProducer +from Configuration.ProcessModifiers.trackingMkFitHighPtTripletStep_cff import trackingMkFitHighPtTripletStep import RecoTracker.MkFit.mkFitSeedConverter_cfi as mkFitSeedConverter_cfi import RecoTracker.MkFit.mkFitProducer_cfi as mkFitProducer_cfi import RecoTracker.MkFit.mkFitOutputConverter_cfi as mkFitOutputConverter_cfi @@ -228,7 +227,7 @@ iterationNumber = 1, clustersToSkip = 'highPtTripletStepClusters', ) -trackingMkFit.toReplaceWith(highPtTripletStepTrackCandidates, mkFitOutputConverter_cfi.mkFitOutputConverter.clone( +trackingMkFitHighPtTripletStep.toReplaceWith(highPtTripletStepTrackCandidates, mkFitOutputConverter_cfi.mkFitOutputConverter.clone( seeds = 'highPtTripletStepSeeds', mkfitSeeds = 'highPtTripletStepTrackCandidatesMkFitSeeds', tracks = 'highPtTripletStepTrackCandidatesMkFit', @@ -354,7 +353,7 @@ _HighPtTripletStepTask_trackingMkFit = HighPtTripletStepTask.copy() _HighPtTripletStepTask_trackingMkFit.add(highPtTripletStepTrackCandidatesMkFitSeeds, highPtTripletStepTrackCandidatesMkFit) -trackingMkFit.toReplaceWith(HighPtTripletStepTask, _HighPtTripletStepTask_trackingMkFit) +trackingMkFitHighPtTripletStep.toReplaceWith(HighPtTripletStepTask, _HighPtTripletStepTask_trackingMkFit) _HighPtTripletStepTask_Phase2PU140 = HighPtTripletStepTask.copy() _HighPtTripletStepTask_Phase2PU140.replace(highPtTripletStep, highPtTripletStepSelector) diff --git a/RecoTracker/IterativeTracking/python/InitialStep_cff.py b/RecoTracker/IterativeTracking/python/InitialStep_cff.py index 0c564303d9e83..07804874fea6d 100644 --- a/RecoTracker/IterativeTracking/python/InitialStep_cff.py +++ b/RecoTracker/IterativeTracking/python/InitialStep_cff.py @@ -223,7 +223,7 @@ useHitsSplitting = True ) -from Configuration.ProcessModifiers.trackingMkFit_cff import trackingMkFit +from Configuration.ProcessModifiers.trackingMkFitInitialStep_cff import trackingMkFitInitialStep from RecoTracker.MkFit.mkFitGeometryESProducer_cfi import mkFitGeometryESProducer import RecoTracker.MkFit.mkFitHitConverter_cfi as mkFitHitConverter_cfi import RecoTracker.MkFit.mkFitSeedConverter_cfi as mkFitSeedConverter_cfi @@ -237,7 +237,7 @@ seeds = 'initialStepTrackCandidatesMkFitSeeds', iterationNumber = 0, ) -trackingMkFit.toReplaceWith(initialStepTrackCandidates, mkFitOutputConverter_cfi.mkFitOutputConverter.clone( +trackingMkFitInitialStep.toReplaceWith(initialStepTrackCandidates, mkFitOutputConverter_cfi.mkFitOutputConverter.clone( seeds = 'initialStepSeeds', mkfitSeeds = 'initialStepTrackCandidatesMkFitSeeds', tracks = 'initialStepTrackCandidatesMkFit', @@ -417,9 +417,14 @@ initialStep,caloJetsForTrkTask) InitialStep = cms.Sequence(InitialStepTask) +from Configuration.ProcessModifiers.trackingMkFitCommon_cff import trackingMkFitCommon +_InitialStepTask_trackingMkFitCommon = InitialStepTask.copy() +_InitialStepTask_trackingMkFitCommon.add(mkFitHits, mkFitGeometryESProducer) +trackingMkFitCommon.toReplaceWith(InitialStepTask, _InitialStepTask_trackingMkFitCommon) + _InitialStepTask_trackingMkFit = InitialStepTask.copy() -_InitialStepTask_trackingMkFit.add(mkFitHits, initialStepTrackCandidatesMkFitSeeds, initialStepTrackCandidatesMkFit, mkFitGeometryESProducer) -trackingMkFit.toReplaceWith(InitialStepTask, _InitialStepTask_trackingMkFit) +_InitialStepTask_trackingMkFit.add(initialStepTrackCandidatesMkFitSeeds, initialStepTrackCandidatesMkFit) +trackingMkFitInitialStep.toReplaceWith(InitialStepTask, _InitialStepTask_trackingMkFit) _InitialStepTask_LowPU = InitialStepTask.copyAndExclude([firstStepPrimaryVerticesUnsorted, initialStepTrackRefsForJets, caloJetsForTrkTask, firstStepPrimaryVertices, initialStepClassifier1, initialStepClassifier2, initialStepClassifier3]) _InitialStepTask_LowPU.replace(initialStep, initialStepSelector) diff --git a/RecoTracker/IterativeTracking/python/LowPtQuadStep_cff.py b/RecoTracker/IterativeTracking/python/LowPtQuadStep_cff.py index 93ad826dd28c6..ca0eb1895b86b 100644 --- a/RecoTracker/IterativeTracking/python/LowPtQuadStep_cff.py +++ b/RecoTracker/IterativeTracking/python/LowPtQuadStep_cff.py @@ -176,6 +176,24 @@ phase2clustersToSkip = cms.InputTag('lowPtQuadStepClusters') ) +from Configuration.ProcessModifiers.trackingMkFitLowPtQuadStep_cff import trackingMkFitLowPtQuadStep +import RecoTracker.MkFit.mkFitSeedConverter_cfi as mkFitSeedConverter_cfi +import RecoTracker.MkFit.mkFitProducer_cfi as mkFitProducer_cfi +import RecoTracker.MkFit.mkFitOutputConverter_cfi as mkFitOutputConverter_cfi +lowPtQuadStepTrackCandidatesMkFitSeeds = mkFitSeedConverter_cfi.mkFitSeedConverter.clone( + seeds = 'lowPtQuadStepSeeds', +) +lowPtQuadStepTrackCandidatesMkFit = mkFitProducer_cfi.mkFitProducer.clone( + seeds = 'lowPtQuadStepTrackCandidatesMkFitSeeds', + iterationNumber = 2, + clustersToSkip = 'lowPtQuadStepClusters', +) +trackingMkFitLowPtQuadStep.toReplaceWith(lowPtQuadStepTrackCandidates, mkFitOutputConverter_cfi.mkFitOutputConverter.clone( + seeds = 'lowPtQuadStepSeeds', + mkfitSeeds = 'lowPtQuadStepTrackCandidatesMkFitSeeds', + tracks = 'lowPtQuadStepTrackCandidatesMkFit', +)) + #For FastSim phase1 tracking import FastSimulation.Tracking.TrackCandidateProducer_cfi _fastSim_lowPtQuadStepTrackCandidates = FastSimulation.Tracking.TrackCandidateProducer_cfi.trackCandidateProducer.clone( @@ -278,6 +296,10 @@ lowPtQuadStep) LowPtQuadStep = cms.Sequence(LowPtQuadStepTask) +_LowPtQuadStepTask_trackingMkFit = LowPtQuadStepTask.copy() +_LowPtQuadStepTask_trackingMkFit.add(lowPtQuadStepTrackCandidatesMkFitSeeds, lowPtQuadStepTrackCandidatesMkFit) +trackingMkFitLowPtQuadStep.toReplaceWith(LowPtQuadStepTask, _LowPtQuadStepTask_trackingMkFit) + _LowPtQuadStepTask_Phase2PU140 = LowPtQuadStepTask.copy() _LowPtQuadStepTask_Phase2PU140.replace(lowPtQuadStep, lowPtQuadStepSelector) trackingPhase2PU140.toReplaceWith(LowPtQuadStepTask, _LowPtQuadStepTask_Phase2PU140) diff --git a/RecoTracker/IterativeTracking/python/LowPtTripletStep_cff.py b/RecoTracker/IterativeTracking/python/LowPtTripletStep_cff.py index b20d60df49116..7274d83702441 100644 --- a/RecoTracker/IterativeTracking/python/LowPtTripletStep_cff.py +++ b/RecoTracker/IterativeTracking/python/LowPtTripletStep_cff.py @@ -242,6 +242,24 @@ phase2clustersToSkip = cms.InputTag('lowPtTripletStepClusters') ) +from Configuration.ProcessModifiers.trackingMkFitLowPtTripletStep_cff import trackingMkFitLowPtTripletStep +import RecoTracker.MkFit.mkFitSeedConverter_cfi as mkFitSeedConverter_cfi +import RecoTracker.MkFit.mkFitProducer_cfi as mkFitProducer_cfi +import RecoTracker.MkFit.mkFitOutputConverter_cfi as mkFitOutputConverter_cfi +lowPtTripletStepTrackCandidatesMkFitSeeds = mkFitSeedConverter_cfi.mkFitSeedConverter.clone( + seeds = 'lowPtTripletStepSeeds', +) +lowPtTripletStepTrackCandidatesMkFit = mkFitProducer_cfi.mkFitProducer.clone( + seeds = 'lowPtTripletStepTrackCandidatesMkFitSeeds', + iterationNumber = 3, + clustersToSkip = 'lowPtTripletStepClusters', +) +trackingMkFitLowPtTripletStep.toReplaceWith(lowPtTripletStepTrackCandidates, mkFitOutputConverter_cfi.mkFitOutputConverter.clone( + seeds = 'lowPtTripletStepSeeds', + mkfitSeeds = 'lowPtTripletStepTrackCandidatesMkFitSeeds', + tracks = 'lowPtTripletStepTrackCandidatesMkFit', +)) + import FastSimulation.Tracking.TrackCandidateProducer_cfi fastSim.toReplaceWith(lowPtTripletStepTrackCandidates, FastSimulation.Tracking.TrackCandidateProducer_cfi.trackCandidateProducer.clone( @@ -379,6 +397,10 @@ lowPtTripletStep) LowPtTripletStep = cms.Sequence(LowPtTripletStepTask) +_LowPtTripletStepTask_trackingMkFit = LowPtTripletStepTask.copy() +_LowPtTripletStepTask_trackingMkFit.add(lowPtTripletStepTrackCandidatesMkFitSeeds, lowPtTripletStepTrackCandidatesMkFit) +trackingMkFitLowPtTripletStep.toReplaceWith(LowPtTripletStepTask, _LowPtTripletStepTask_trackingMkFit) + _LowPtTripletStepTask_LowPU_Phase2PU140 = LowPtTripletStepTask.copy() _LowPtTripletStepTask_LowPU_Phase2PU140.replace(lowPtTripletStep, lowPtTripletStepSelector) trackingLowPU.toReplaceWith(LowPtTripletStepTask, _LowPtTripletStepTask_LowPU_Phase2PU140) diff --git a/RecoTracker/IterativeTracking/python/MixedTripletStep_cff.py b/RecoTracker/IterativeTracking/python/MixedTripletStep_cff.py index c3051b3053241..b0857537bc424 100644 --- a/RecoTracker/IterativeTracking/python/MixedTripletStep_cff.py +++ b/RecoTracker/IterativeTracking/python/MixedTripletStep_cff.py @@ -291,6 +291,25 @@ useHitsSplitting = True, TrajectoryCleaner = 'mixedTripletStepTrajectoryCleanerBySharedHits' ) + +from Configuration.ProcessModifiers.trackingMkFitMixedTripletStep_cff import trackingMkFitMixedTripletStep +import RecoTracker.MkFit.mkFitSeedConverter_cfi as mkFitSeedConverter_cfi +import RecoTracker.MkFit.mkFitProducer_cfi as mkFitProducer_cfi +import RecoTracker.MkFit.mkFitOutputConverter_cfi as mkFitOutputConverter_cfi +mixedTripletStepTrackCandidatesMkFitSeeds = mkFitSeedConverter_cfi.mkFitSeedConverter.clone( + seeds = 'mixedTripletStepSeeds', +) +mixedTripletStepTrackCandidatesMkFit = mkFitProducer_cfi.mkFitProducer.clone( + seeds = 'mixedTripletStepTrackCandidatesMkFitSeeds', + iterationNumber = 6, + clustersToSkip = 'mixedTripletStepClusters', +) +trackingMkFitMixedTripletStep.toReplaceWith(mixedTripletStepTrackCandidates, mkFitOutputConverter_cfi.mkFitOutputConverter.clone( + seeds = 'mixedTripletStepSeeds', + mkfitSeeds = 'mixedTripletStepTrackCandidatesMkFitSeeds', + tracks = 'mixedTripletStepTrackCandidatesMkFit', +)) + import FastSimulation.Tracking.TrackCandidateProducer_cfi fastSim.toReplaceWith(mixedTripletStepTrackCandidates, FastSimulation.Tracking.TrackCandidateProducer_cfi.trackCandidateProducer.clone( @@ -475,6 +494,11 @@ mixedTripletStepClassifier1,mixedTripletStepClassifier2, mixedTripletStep) MixedTripletStep = cms.Sequence(MixedTripletStepTask) + +_MixedTripletStepTask_trackingMkFit = MixedTripletStepTask.copy() +_MixedTripletStepTask_trackingMkFit.add(mixedTripletStepTrackCandidatesMkFitSeeds, mixedTripletStepTrackCandidatesMkFit) +trackingMkFitMixedTripletStep.toReplaceWith(MixedTripletStepTask, _MixedTripletStepTask_trackingMkFit) + _MixedTripletStepTask_LowPU = MixedTripletStepTask.copyAndExclude([chargeCut2069Clusters, mixedTripletStepClassifier1]) _MixedTripletStepTask_LowPU.replace(mixedTripletStepClassifier2, mixedTripletStepSelector) trackingLowPU.toReplaceWith(MixedTripletStepTask, _MixedTripletStepTask_LowPU) diff --git a/RecoTracker/IterativeTracking/python/PixelLessStep_cff.py b/RecoTracker/IterativeTracking/python/PixelLessStep_cff.py index de8694abee81b..0594731a44e9f 100644 --- a/RecoTracker/IterativeTracking/python/PixelLessStep_cff.py +++ b/RecoTracker/IterativeTracking/python/PixelLessStep_cff.py @@ -284,6 +284,25 @@ TrajectoryBuilderPSet = cms.PSet(refToPSet_ = cms.string('pixelLessStepTrajectoryBuilder')), TrajectoryCleaner = 'pixelLessStepTrajectoryCleanerBySharedHits' ) + +from Configuration.ProcessModifiers.trackingMkFitPixelLessStep_cff import trackingMkFitPixelLessStep +import RecoTracker.MkFit.mkFitSeedConverter_cfi as mkFitSeedConverter_cfi +import RecoTracker.MkFit.mkFitProducer_cfi as mkFitProducer_cfi +import RecoTracker.MkFit.mkFitOutputConverter_cfi as mkFitOutputConverter_cfi +pixelLessStepTrackCandidatesMkFitSeeds = mkFitSeedConverter_cfi.mkFitSeedConverter.clone( + seeds = 'pixelLessStepSeeds', +) +pixelLessStepTrackCandidatesMkFit = mkFitProducer_cfi.mkFitProducer.clone( + seeds = 'pixelLessStepTrackCandidatesMkFitSeeds', + iterationNumber = 7, + clustersToSkip = 'pixelLessStepClusters', +) +trackingMkFitPixelLessStep.toReplaceWith(pixelLessStepTrackCandidates, mkFitOutputConverter_cfi.mkFitOutputConverter.clone( + seeds = 'pixelLessStepSeeds', + mkfitSeeds = 'pixelLessStepTrackCandidatesMkFitSeeds', + tracks = 'pixelLessStepTrackCandidatesMkFit', +)) + import FastSimulation.Tracking.TrackCandidateProducer_cfi fastSim.toReplaceWith(pixelLessStepTrackCandidates, FastSimulation.Tracking.TrackCandidateProducer_cfi.trackCandidateProducer.clone( @@ -465,6 +484,10 @@ pixelLessStep) PixelLessStep = cms.Sequence(PixelLessStepTask) +_PixelLessStepTask_trackingMkFit = PixelLessStepTask.copy() +_PixelLessStepTask_trackingMkFit.add(pixelLessStepTrackCandidatesMkFitSeeds, pixelLessStepTrackCandidatesMkFit) +trackingMkFitPixelLessStep.toReplaceWith(PixelLessStepTask, _PixelLessStepTask_trackingMkFit) + _PixelLessStepTask_LowPU = PixelLessStepTask.copyAndExclude([pixelLessStepHitTriplets, pixelLessStepClassifier1, pixelLessStepClassifier2]) _PixelLessStepTask_LowPU.replace(pixelLessStep, pixelLessStepSelector) trackingLowPU.toReplaceWith(PixelLessStepTask, _PixelLessStepTask_LowPU) diff --git a/RecoTracker/IterativeTracking/python/TobTecStep_cff.py b/RecoTracker/IterativeTracking/python/TobTecStep_cff.py index af527c2b64769..3eb275cca3c4b 100644 --- a/RecoTracker/IterativeTracking/python/TobTecStep_cff.py +++ b/RecoTracker/IterativeTracking/python/TobTecStep_cff.py @@ -268,6 +268,25 @@ cleanTrajectoryAfterInOut = True, TrajectoryCleaner = 'tobTecStepTrajectoryCleanerBySharedHits' ) + +from Configuration.ProcessModifiers.trackingMkFitTobTecStep_cff import trackingMkFitTobTecStep +import RecoTracker.MkFit.mkFitSeedConverter_cfi as mkFitSeedConverter_cfi +import RecoTracker.MkFit.mkFitProducer_cfi as mkFitProducer_cfi +import RecoTracker.MkFit.mkFitOutputConverter_cfi as mkFitOutputConverter_cfi +tobTecStepTrackCandidatesMkFitSeeds = mkFitSeedConverter_cfi.mkFitSeedConverter.clone( + seeds = 'tobTecStepSeeds', +) +tobTecStepTrackCandidatesMkFit = mkFitProducer_cfi.mkFitProducer.clone( + seeds = 'tobTecStepTrackCandidatesMkFitSeeds', + iterationNumber = 8, + clustersToSkip = 'tobTecStepClusters', +) +trackingMkFitTobTecStep.toReplaceWith(tobTecStepTrackCandidates, mkFitOutputConverter_cfi.mkFitOutputConverter.clone( + seeds = 'tobTecStepSeeds', + mkfitSeeds = 'tobTecStepTrackCandidatesMkFitSeeds', + tracks = 'tobTecStepTrackCandidatesMkFit', +)) + import FastSimulation.Tracking.TrackCandidateProducer_cfi fastSim.toReplaceWith(tobTecStepTrackCandidates, FastSimulation.Tracking.TrackCandidateProducer_cfi.trackCandidateProducer.clone( @@ -449,6 +468,9 @@ tobTecStep) TobTecStep = cms.Sequence(TobTecStepTask) +_TobTecStepTask_trackingMkFit = TobTecStepTask.copy() +_TobTecStepTask_trackingMkFit.add(tobTecStepTrackCandidatesMkFitSeeds, tobTecStepTrackCandidatesMkFit) +trackingMkFitTobTecStep.toReplaceWith(TobTecStepTask, _TobTecStepTask_trackingMkFit) ### Following are specific for LowPU, they're collected here to ### not to interfere too much with the default configuration From 150feaf7e716c852fe1b868b05e4376f98a88122 Mon Sep 17 00:00:00 2001 From: Matti Kortelainen Date: Fri, 19 Mar 2021 09:45:55 -0700 Subject: [PATCH 15/20] Add option to use task_arena limited to 1 thread --- RecoTracker/MkFit/plugins/MkFitProducer.cc | 23 +++++++++++++++++----- 1 file changed, 18 insertions(+), 5 deletions(-) diff --git a/RecoTracker/MkFit/plugins/MkFitProducer.cc b/RecoTracker/MkFit/plugins/MkFitProducer.cc index 9c1527a72bf0e..be833fb0a8fe3 100644 --- a/RecoTracker/MkFit/plugins/MkFitProducer.cc +++ b/RecoTracker/MkFit/plugins/MkFitProducer.cc @@ -51,9 +51,10 @@ class MkFitProducer : public edm::global::EDProducer("seedCleaning")}, backwardFitInCMSSW_{iConfig.getParameter("backwardFitInCMSSW")}, removeDuplicates_{iConfig.getParameter("removeDuplicates")}, - mkFitSilent_{iConfig.getUntrackedParameter("mkFitSilent")} { + mkFitSilent_{iConfig.getUntrackedParameter("mkFitSilent")}, + limitConcurrency_{iConfig.getUntrackedParameter("limitConcurrency")} { const auto clustersToSkip = iConfig.getParameter("clustersToSkip"); if (not clustersToSkip.label().empty()) { pixelMaskToken_ = consumes(clustersToSkip); @@ -107,6 +109,10 @@ void MkFitProducer::fillDescriptions(edm::ConfigurationDescriptions& description desc.add("backwardFitInCMSSW", false) ->setComment("Do backward fit (to innermost hit) in CMSSW (true) or mkFit (false)"); desc.addUntracked("mkFitSilent", true)->setComment("Allows to enables printouts from mkFit with 'False'"); + desc.addUntracked("limitConcurrency", false) + ->setComment( + "Use tbb::task_arena to limit the internal concurrency to 1; useful only for timing studies when measuring " + "the module time"); edm::ParameterSetDescription descCCC; descCCC.add("value"); @@ -166,7 +172,7 @@ void MkFitProducer::produce(edm::StreamID iID, edm::Event& iEvent, const edm::Ev auto seeds_mutable = seeds.seeds(); mkfit::TrackVec tracks; - tbb::this_task_arena::isolate([&]() { + auto lambda = [&]() { mkfit::run_OneIteration(mkFitGeom.trackerInfo(), mkFitGeom.iterationsInfo()[iterationNumber_], hits.eventOfHits(), @@ -177,7 +183,14 @@ void MkFitProducer::produce(edm::StreamID iID, edm::Event& iEvent, const edm::Ev seedCleaning_, not backwardFitInCMSSW_, removeDuplicates_); - }); + }; + + if (limitConcurrency_) { + tbb::task_arena arena(1); + arena.execute(std::move(lambda)); + } else { + tbb::this_task_arena::isolate(std::move(lambda)); + } iEvent.emplace(putToken_, std::move(tracks), not backwardFitInCMSSW_); } From 0f9bd9953f4bfeebfc751d6524c997d89480aa90 Mon Sep 17 00:00:00 2001 From: Giuseppe Date: Wed, 24 Mar 2021 15:20:13 -0400 Subject: [PATCH 16/20] use 1D strip hits in barrel --- RecoTracker/MkFit/plugins/MkFitOutputConverter.cc | 12 +++++++++++- 1 file changed, 11 insertions(+), 1 deletion(-) diff --git a/RecoTracker/MkFit/plugins/MkFitOutputConverter.cc b/RecoTracker/MkFit/plugins/MkFitOutputConverter.cc index c5ca7ac4226b5..e6c567d9f580a 100644 --- a/RecoTracker/MkFit/plugins/MkFitOutputConverter.cc +++ b/RecoTracker/MkFit/plugins/MkFitOutputConverter.cc @@ -11,6 +11,7 @@ #include "DataFormats/TrackCandidate/interface/TrackCandidateCollection.h" #include "DataFormats/TrackReco/interface/SeedStopInfo.h" #include "DataFormats/TrackingRecHit/interface/InvalidTrackingRecHit.h" +#include "DataFormats/TrackerRecHit2D/interface/SiStripRecHit1D.h" #include "TrackingTools/Records/interface/TransientRecHitRecord.h" #include "TrackingTools/TransientTrackingRecHit/interface/TransientTrackingRecHitBuilder.h" @@ -219,7 +220,16 @@ TrackCandidateCollection MkFitOutputConverter::convertCandidates(const MkFitOutp auto const isPixel = eventOfHits[hitOnTrack.layer].is_pix_lyr(); auto const& hits = isPixel ? clusterIndexToHit.pixelHits() : clusterIndexToHit.outerHits(); - recHits.push_back(hits[hitOnTrack.index]->clone()); + auto const& thit = static_cast(*hits[hitOnTrack.index]); + if (thit.firstClusterRef().isPixel() || thit.detUnit()->type().isEndcap()) { + recHits.push_back(hits[hitOnTrack.index]->clone()); + } else { + recHits.push_back(std::make_unique( + thit.localPosition(), + LocalError(thit.localPositionError().xx(), 0.f, std::numeric_limits::max()), + *thit.det(), + thit.firstClusterRef())); + } LogTrace("MkFitOutputConverter") << " pos " << recHits.back().globalPosition().x() << " " << recHits.back().globalPosition().y() << " " << recHits.back().globalPosition().z() << " mag2 " From f35ccac223ffd74f91c3611eccd910030537c96d Mon Sep 17 00:00:00 2001 From: Matti Kortelainen Date: Tue, 23 Mar 2021 11:51:45 -0700 Subject: [PATCH 17/20] Introduce per-iteration JSON files for mkFit configuration --- .../python/DetachedQuadStep_cff.py | 9 ++++- .../python/DetachedTripletStep_cff.py | 9 ++++- .../python/HighPtTripletStep_cff.py | 9 ++++- .../python/InitialStep_cff.py | 9 ++++- .../python/LowPtQuadStep_cff.py | 9 ++++- .../python/LowPtTripletStep_cff.py | 7 +++- .../python/MixedTripletStep_cff.py | 9 ++++- .../python/PixelLessStep_cff.py | 9 ++++- .../python/TobTecStep_cff.py | 9 ++++- .../plugins/MkFitIterationConfigESProducer.cc | 40 +++++++++++++++++++ RecoTracker/MkFit/plugins/MkFitProducer.cc | 18 +++++---- .../MkFit/python/customizeHLTIter0ToMkFit.py | 6 +++ .../MkFit/src/ES_MkFitIterationConfig.cc | 3 ++ RecoTracker/MkFit/src/MkFitGeometry.cc | 5 +-- 14 files changed, 122 insertions(+), 29 deletions(-) create mode 100644 RecoTracker/MkFit/plugins/MkFitIterationConfigESProducer.cc create mode 100644 RecoTracker/MkFit/src/ES_MkFitIterationConfig.cc diff --git a/RecoTracker/IterativeTracking/python/DetachedQuadStep_cff.py b/RecoTracker/IterativeTracking/python/DetachedQuadStep_cff.py index acbb64226eb61..d9c1e21478195 100644 --- a/RecoTracker/IterativeTracking/python/DetachedQuadStep_cff.py +++ b/RecoTracker/IterativeTracking/python/DetachedQuadStep_cff.py @@ -188,14 +188,19 @@ from Configuration.ProcessModifiers.trackingMkFitDetachedQuadStep_cff import trackingMkFitDetachedQuadStep 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 detachedQuadStepTrackCandidatesMkFitSeeds = mkFitSeedConverter_cfi.mkFitSeedConverter.clone( seeds = 'detachedQuadStepSeeds', ) +detachedQuadStepTrackCandidatesMkFitConfig = mkFitIterationConfigESProducer_cfi.mkFitIterationConfigESProducer.clone( + config = 'RecoTracker/MkFit/data/mkfit-phase1-detachedQuadStep.json', + ComponentName = 'detachedQuadStepTrackCandidatesMkFitConfig', +) detachedQuadStepTrackCandidatesMkFit = mkFitProducer_cfi.mkFitProducer.clone( seeds = 'detachedQuadStepTrackCandidatesMkFitSeeds', - iterationNumber = 4, + config = ('', 'detachedQuadStepTrackCandidatesMkFitConfig'), clustersToSkip = 'detachedQuadStepClusters', ) trackingMkFitDetachedQuadStep.toReplaceWith(detachedQuadStepTrackCandidates, mkFitOutputConverter_cfi.mkFitOutputConverter.clone( @@ -357,7 +362,7 @@ DetachedQuadStep = cms.Sequence(DetachedQuadStepTask) _DetachedQuadStepTask_trackingMkFit = DetachedQuadStepTask.copy() -_DetachedQuadStepTask_trackingMkFit.add(detachedQuadStepTrackCandidatesMkFitSeeds, detachedQuadStepTrackCandidatesMkFit) +_DetachedQuadStepTask_trackingMkFit.add(detachedQuadStepTrackCandidatesMkFitSeeds, detachedQuadStepTrackCandidatesMkFit, detachedQuadStepTrackCandidatesMkFitConfig) trackingMkFitDetachedQuadStep.toReplaceWith(DetachedQuadStepTask, _DetachedQuadStepTask_trackingMkFit) _DetachedQuadStepTask_Phase2PU140 = DetachedQuadStepTask.copy() diff --git a/RecoTracker/IterativeTracking/python/DetachedTripletStep_cff.py b/RecoTracker/IterativeTracking/python/DetachedTripletStep_cff.py index 58816d142e483..552036fc967e5 100644 --- a/RecoTracker/IterativeTracking/python/DetachedTripletStep_cff.py +++ b/RecoTracker/IterativeTracking/python/DetachedTripletStep_cff.py @@ -216,14 +216,19 @@ from Configuration.ProcessModifiers.trackingMkFitDetachedTripletStep_cff import trackingMkFitDetachedTripletStep 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 detachedTripletStepTrackCandidatesMkFitSeeds = mkFitSeedConverter_cfi.mkFitSeedConverter.clone( seeds = 'detachedTripletStepSeeds', ) +detachedTripletStepTrackCandidatesMkFitConfig = mkFitIterationConfigESProducer_cfi.mkFitIterationConfigESProducer.clone( + ComponentName = 'detachedTripletStepTrackCandidatesMkFitConfig', + config = 'RecoTracker/MkFit/data/mkfit-phase1-detachedTripletStep.json', +) detachedTripletStepTrackCandidatesMkFit = mkFitProducer_cfi.mkFitProducer.clone( seeds = 'detachedTripletStepTrackCandidatesMkFitSeeds', - iterationNumber = 5, + config = ('', 'detachedTripletStepTrackCandidatesMkFitConfig'), clustersToSkip = 'detachedTripletStepClusters', ) trackingMkFitDetachedTripletStep.toReplaceWith(detachedTripletStepTrackCandidates, mkFitOutputConverter_cfi.mkFitOutputConverter.clone( @@ -399,7 +404,7 @@ DetachedTripletStep = cms.Sequence(DetachedTripletStepTask) _DetachedTripletStepTask_trackingMkFit = DetachedTripletStepTask.copy() -_DetachedTripletStepTask_trackingMkFit.add(detachedTripletStepTrackCandidatesMkFitSeeds, detachedTripletStepTrackCandidatesMkFit) +_DetachedTripletStepTask_trackingMkFit.add(detachedTripletStepTrackCandidatesMkFitSeeds, detachedTripletStepTrackCandidatesMkFit, detachedTripletStepTrackCandidatesMkFitConfig) trackingMkFitDetachedTripletStep.toReplaceWith(DetachedTripletStepTask, _DetachedTripletStepTask_trackingMkFit) _DetachedTripletStepTask_LowPU = DetachedTripletStepTask.copyAndExclude([detachedTripletStepClassifier2]) diff --git a/RecoTracker/IterativeTracking/python/HighPtTripletStep_cff.py b/RecoTracker/IterativeTracking/python/HighPtTripletStep_cff.py index 15f3243916527..c71fd9b0b15ee 100644 --- a/RecoTracker/IterativeTracking/python/HighPtTripletStep_cff.py +++ b/RecoTracker/IterativeTracking/python/HighPtTripletStep_cff.py @@ -217,14 +217,19 @@ from Configuration.ProcessModifiers.trackingMkFitHighPtTripletStep_cff import trackingMkFitHighPtTripletStep 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 highPtTripletStepTrackCandidatesMkFitSeeds = mkFitSeedConverter_cfi.mkFitSeedConverter.clone( seeds = 'highPtTripletStepSeeds', ) +highPtTripletStepTrackCandidatesMkFitConfig = mkFitIterationConfigESProducer_cfi.mkFitIterationConfigESProducer.clone( + ComponentName = 'highPtTripletStepTrackCandidatesMkFitConfig', + config = 'RecoTracker/MkFit/data/mkfit-phase1-highPtTripletStep.json', +) highPtTripletStepTrackCandidatesMkFit = mkFitProducer_cfi.mkFitProducer.clone( seeds = 'highPtTripletStepTrackCandidatesMkFitSeeds', - iterationNumber = 1, + config = ('', 'highPtTripletStepTrackCandidatesMkFitConfig'), clustersToSkip = 'highPtTripletStepClusters', ) trackingMkFitHighPtTripletStep.toReplaceWith(highPtTripletStepTrackCandidates, mkFitOutputConverter_cfi.mkFitOutputConverter.clone( @@ -352,7 +357,7 @@ HighPtTripletStep = cms.Sequence(HighPtTripletStepTask) _HighPtTripletStepTask_trackingMkFit = HighPtTripletStepTask.copy() -_HighPtTripletStepTask_trackingMkFit.add(highPtTripletStepTrackCandidatesMkFitSeeds, highPtTripletStepTrackCandidatesMkFit) +_HighPtTripletStepTask_trackingMkFit.add(highPtTripletStepTrackCandidatesMkFitSeeds, highPtTripletStepTrackCandidatesMkFit, highPtTripletStepTrackCandidatesMkFitConfig) trackingMkFitHighPtTripletStep.toReplaceWith(HighPtTripletStepTask, _HighPtTripletStepTask_trackingMkFit) _HighPtTripletStepTask_Phase2PU140 = HighPtTripletStepTask.copy() diff --git a/RecoTracker/IterativeTracking/python/InitialStep_cff.py b/RecoTracker/IterativeTracking/python/InitialStep_cff.py index 07804874fea6d..095898aa7dc31 100644 --- a/RecoTracker/IterativeTracking/python/InitialStep_cff.py +++ b/RecoTracker/IterativeTracking/python/InitialStep_cff.py @@ -227,15 +227,20 @@ from RecoTracker.MkFit.mkFitGeometryESProducer_cfi import mkFitGeometryESProducer import RecoTracker.MkFit.mkFitHitConverter_cfi as mkFitHitConverter_cfi 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 mkFitHits = mkFitHitConverter_cfi.mkFitHitConverter.clone() # TODO: figure out better place for this module? initialStepTrackCandidatesMkFitSeeds = mkFitSeedConverter_cfi.mkFitSeedConverter.clone( seeds = 'initialStepSeeds', ) +initialStepTrackCandidatesMkFitConfig = mkFitIterationConfigESProducer_cfi.mkFitIterationConfigESProducer.clone( + ComponentName = 'initialStepTrackCandidatesMkFitConfig', + config = 'RecoTracker/MkFit/data/mkfit-phase1-initialStep.json', +) initialStepTrackCandidatesMkFit = mkFitProducer_cfi.mkFitProducer.clone( seeds = 'initialStepTrackCandidatesMkFitSeeds', - iterationNumber = 0, + config = ('', 'initialStepTrackCandidatesMkFitConfig'), ) trackingMkFitInitialStep.toReplaceWith(initialStepTrackCandidates, mkFitOutputConverter_cfi.mkFitOutputConverter.clone( seeds = 'initialStepSeeds', @@ -423,7 +428,7 @@ trackingMkFitCommon.toReplaceWith(InitialStepTask, _InitialStepTask_trackingMkFitCommon) _InitialStepTask_trackingMkFit = InitialStepTask.copy() -_InitialStepTask_trackingMkFit.add(initialStepTrackCandidatesMkFitSeeds, initialStepTrackCandidatesMkFit) +_InitialStepTask_trackingMkFit.add(initialStepTrackCandidatesMkFitSeeds, initialStepTrackCandidatesMkFit, initialStepTrackCandidatesMkFitConfig) trackingMkFitInitialStep.toReplaceWith(InitialStepTask, _InitialStepTask_trackingMkFit) _InitialStepTask_LowPU = InitialStepTask.copyAndExclude([firstStepPrimaryVerticesUnsorted, initialStepTrackRefsForJets, caloJetsForTrkTask, firstStepPrimaryVertices, initialStepClassifier1, initialStepClassifier2, initialStepClassifier3]) diff --git a/RecoTracker/IterativeTracking/python/LowPtQuadStep_cff.py b/RecoTracker/IterativeTracking/python/LowPtQuadStep_cff.py index ca0eb1895b86b..7f92e254e884c 100644 --- a/RecoTracker/IterativeTracking/python/LowPtQuadStep_cff.py +++ b/RecoTracker/IterativeTracking/python/LowPtQuadStep_cff.py @@ -178,14 +178,19 @@ from Configuration.ProcessModifiers.trackingMkFitLowPtQuadStep_cff import trackingMkFitLowPtQuadStep 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 lowPtQuadStepTrackCandidatesMkFitSeeds = mkFitSeedConverter_cfi.mkFitSeedConverter.clone( seeds = 'lowPtQuadStepSeeds', ) +lowPtQuadStepTrackCandidatesMkFitConfig = mkFitIterationConfigESProducer_cfi.mkFitIterationConfigESProducer.clone( + ComponentName = 'lowPtQuadStepTrackCandidatesMkFitConfig', + config = 'RecoTracker/MkFit/data/mkfit-phase1-lowPtQuadStep.json', +) lowPtQuadStepTrackCandidatesMkFit = mkFitProducer_cfi.mkFitProducer.clone( seeds = 'lowPtQuadStepTrackCandidatesMkFitSeeds', - iterationNumber = 2, + config = ('', 'lowPtQuadStepTrackCandidatesMkFitConfig'), clustersToSkip = 'lowPtQuadStepClusters', ) trackingMkFitLowPtQuadStep.toReplaceWith(lowPtQuadStepTrackCandidates, mkFitOutputConverter_cfi.mkFitOutputConverter.clone( @@ -297,7 +302,7 @@ LowPtQuadStep = cms.Sequence(LowPtQuadStepTask) _LowPtQuadStepTask_trackingMkFit = LowPtQuadStepTask.copy() -_LowPtQuadStepTask_trackingMkFit.add(lowPtQuadStepTrackCandidatesMkFitSeeds, lowPtQuadStepTrackCandidatesMkFit) +_LowPtQuadStepTask_trackingMkFit.add(lowPtQuadStepTrackCandidatesMkFitSeeds, lowPtQuadStepTrackCandidatesMkFit, lowPtQuadStepTrackCandidatesMkFitConfig) trackingMkFitLowPtQuadStep.toReplaceWith(LowPtQuadStepTask, _LowPtQuadStepTask_trackingMkFit) _LowPtQuadStepTask_Phase2PU140 = LowPtQuadStepTask.copy() diff --git a/RecoTracker/IterativeTracking/python/LowPtTripletStep_cff.py b/RecoTracker/IterativeTracking/python/LowPtTripletStep_cff.py index 7274d83702441..1ca29d559603d 100644 --- a/RecoTracker/IterativeTracking/python/LowPtTripletStep_cff.py +++ b/RecoTracker/IterativeTracking/python/LowPtTripletStep_cff.py @@ -245,13 +245,18 @@ from Configuration.ProcessModifiers.trackingMkFitLowPtTripletStep_cff import trackingMkFitLowPtTripletStep import RecoTracker.MkFit.mkFitSeedConverter_cfi as mkFitSeedConverter_cfi import RecoTracker.MkFit.mkFitProducer_cfi as mkFitProducer_cfi +import RecoTracker.MkFit.mkFitIterationConfigESProducer_cfi as mkFitIterationConfigESProducer_cfi import RecoTracker.MkFit.mkFitOutputConverter_cfi as mkFitOutputConverter_cfi lowPtTripletStepTrackCandidatesMkFitSeeds = mkFitSeedConverter_cfi.mkFitSeedConverter.clone( seeds = 'lowPtTripletStepSeeds', ) +lowPtTripletStepTrackCandidatesMkFitConfig = mkFitIterationConfigESProducer_cfi.mkFitIterationConfigESProducer.clone( + ComponentName = 'lowPtTripletStepTrackCandidatesMkFitConfig', + config = 'RecoTracker/MkFit/data/mkfit-phase1-lowPtTripletStep.json', +) lowPtTripletStepTrackCandidatesMkFit = mkFitProducer_cfi.mkFitProducer.clone( seeds = 'lowPtTripletStepTrackCandidatesMkFitSeeds', - iterationNumber = 3, + config = ('', 'lowPtTripletStepTrackCandidatesMkFitConfig'), clustersToSkip = 'lowPtTripletStepClusters', ) trackingMkFitLowPtTripletStep.toReplaceWith(lowPtTripletStepTrackCandidates, mkFitOutputConverter_cfi.mkFitOutputConverter.clone( diff --git a/RecoTracker/IterativeTracking/python/MixedTripletStep_cff.py b/RecoTracker/IterativeTracking/python/MixedTripletStep_cff.py index b0857537bc424..621dd54756e6b 100644 --- a/RecoTracker/IterativeTracking/python/MixedTripletStep_cff.py +++ b/RecoTracker/IterativeTracking/python/MixedTripletStep_cff.py @@ -294,14 +294,19 @@ from Configuration.ProcessModifiers.trackingMkFitMixedTripletStep_cff import trackingMkFitMixedTripletStep 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 mixedTripletStepTrackCandidatesMkFitSeeds = mkFitSeedConverter_cfi.mkFitSeedConverter.clone( seeds = 'mixedTripletStepSeeds', ) +mixedTripletStepTrackCandidatesMkFitConfig = mkFitIterationConfigESProducer_cfi.mkFitIterationConfigESProducer.clone( + ComponentName = 'mixedTripletStepTrackCandidatesMkFitConfig', + config = 'RecoTracker/MkFit/data/mkfit-phase1-mixedTripletStep.json', +) mixedTripletStepTrackCandidatesMkFit = mkFitProducer_cfi.mkFitProducer.clone( seeds = 'mixedTripletStepTrackCandidatesMkFitSeeds', - iterationNumber = 6, + config = ('', 'mixedTripletStepTrackCandidatesMkFitConfig'), clustersToSkip = 'mixedTripletStepClusters', ) trackingMkFitMixedTripletStep.toReplaceWith(mixedTripletStepTrackCandidates, mkFitOutputConverter_cfi.mkFitOutputConverter.clone( @@ -496,7 +501,7 @@ MixedTripletStep = cms.Sequence(MixedTripletStepTask) _MixedTripletStepTask_trackingMkFit = MixedTripletStepTask.copy() -_MixedTripletStepTask_trackingMkFit.add(mixedTripletStepTrackCandidatesMkFitSeeds, mixedTripletStepTrackCandidatesMkFit) +_MixedTripletStepTask_trackingMkFit.add(mixedTripletStepTrackCandidatesMkFitSeeds, mixedTripletStepTrackCandidatesMkFit, mixedTripletStepTrackCandidatesMkFitConfig) trackingMkFitMixedTripletStep.toReplaceWith(MixedTripletStepTask, _MixedTripletStepTask_trackingMkFit) _MixedTripletStepTask_LowPU = MixedTripletStepTask.copyAndExclude([chargeCut2069Clusters, mixedTripletStepClassifier1]) diff --git a/RecoTracker/IterativeTracking/python/PixelLessStep_cff.py b/RecoTracker/IterativeTracking/python/PixelLessStep_cff.py index 0594731a44e9f..fece24efdb9cb 100644 --- a/RecoTracker/IterativeTracking/python/PixelLessStep_cff.py +++ b/RecoTracker/IterativeTracking/python/PixelLessStep_cff.py @@ -287,14 +287,19 @@ from Configuration.ProcessModifiers.trackingMkFitPixelLessStep_cff import trackingMkFitPixelLessStep 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 pixelLessStepTrackCandidatesMkFitSeeds = mkFitSeedConverter_cfi.mkFitSeedConverter.clone( seeds = 'pixelLessStepSeeds', ) +pixelLessStepTrackCandidatesMkFitConfig = mkFitIterationConfigESProducer_cfi.mkFitIterationConfigESProducer.clone( + ComponentName = 'pixelLessStepTrackCandidatesMkFitConfig', + config = 'RecoTracker/MkFit/data/mkfit-phase1-pixelLessStep.json', +) pixelLessStepTrackCandidatesMkFit = mkFitProducer_cfi.mkFitProducer.clone( seeds = 'pixelLessStepTrackCandidatesMkFitSeeds', - iterationNumber = 7, + config = ('', 'pixelLessStepTrackCandidatesMkFitConfig'), clustersToSkip = 'pixelLessStepClusters', ) trackingMkFitPixelLessStep.toReplaceWith(pixelLessStepTrackCandidates, mkFitOutputConverter_cfi.mkFitOutputConverter.clone( @@ -485,7 +490,7 @@ PixelLessStep = cms.Sequence(PixelLessStepTask) _PixelLessStepTask_trackingMkFit = PixelLessStepTask.copy() -_PixelLessStepTask_trackingMkFit.add(pixelLessStepTrackCandidatesMkFitSeeds, pixelLessStepTrackCandidatesMkFit) +_PixelLessStepTask_trackingMkFit.add(pixelLessStepTrackCandidatesMkFitSeeds, pixelLessStepTrackCandidatesMkFit, pixelLessStepTrackCandidatesMkFit) trackingMkFitPixelLessStep.toReplaceWith(PixelLessStepTask, _PixelLessStepTask_trackingMkFit) _PixelLessStepTask_LowPU = PixelLessStepTask.copyAndExclude([pixelLessStepHitTriplets, pixelLessStepClassifier1, pixelLessStepClassifier2]) diff --git a/RecoTracker/IterativeTracking/python/TobTecStep_cff.py b/RecoTracker/IterativeTracking/python/TobTecStep_cff.py index 3eb275cca3c4b..408d9e5a0f2b5 100644 --- a/RecoTracker/IterativeTracking/python/TobTecStep_cff.py +++ b/RecoTracker/IterativeTracking/python/TobTecStep_cff.py @@ -271,14 +271,19 @@ from Configuration.ProcessModifiers.trackingMkFitTobTecStep_cff import trackingMkFitTobTecStep 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 tobTecStepTrackCandidatesMkFitSeeds = mkFitSeedConverter_cfi.mkFitSeedConverter.clone( seeds = 'tobTecStepSeeds', ) +tobTecStepTrackCandidatesMkFitConfig = mkFitIterationConfigESProducer_cfi.mkFitIterationConfigESProducer.clone( + ComponentName = 'tobTecStepTrackCandidatesMkFitConfig', + config = 'RecoTracker/MkFit/data/mkfit-phase1-tobTecStep.json', +) tobTecStepTrackCandidatesMkFit = mkFitProducer_cfi.mkFitProducer.clone( seeds = 'tobTecStepTrackCandidatesMkFitSeeds', - iterationNumber = 8, + config = ('', 'tobTecStepTrackCandidatesMkFitConfig'), clustersToSkip = 'tobTecStepClusters', ) trackingMkFitTobTecStep.toReplaceWith(tobTecStepTrackCandidates, mkFitOutputConverter_cfi.mkFitOutputConverter.clone( @@ -469,7 +474,7 @@ TobTecStep = cms.Sequence(TobTecStepTask) _TobTecStepTask_trackingMkFit = TobTecStepTask.copy() -_TobTecStepTask_trackingMkFit.add(tobTecStepTrackCandidatesMkFitSeeds, tobTecStepTrackCandidatesMkFit) +_TobTecStepTask_trackingMkFit.add(tobTecStepTrackCandidatesMkFitSeeds, tobTecStepTrackCandidatesMkFit, tobTecStepTrackCandidatesMkFitConfig) trackingMkFitTobTecStep.toReplaceWith(TobTecStepTask, _TobTecStepTask_trackingMkFit) ### Following are specific for LowPU, they're collected here to diff --git a/RecoTracker/MkFit/plugins/MkFitIterationConfigESProducer.cc b/RecoTracker/MkFit/plugins/MkFitIterationConfigESProducer.cc new file mode 100644 index 0000000000000..dc79d3fbd582a --- /dev/null +++ b/RecoTracker/MkFit/plugins/MkFitIterationConfigESProducer.cc @@ -0,0 +1,40 @@ +#include "FWCore/Framework/interface/ModuleFactory.h" +#include "FWCore/Framework/interface/ESProducer.h" + +#include "RecoTracker/Record/interface/TrackerRecoGeometryRecord.h" + +#include "RecoTracker/MkFit/interface/MkFitGeometry.h" + +// mkFit includes +#include "mkFit/IterationConfig.h" + +class MkFitIterationConfigESProducer : public edm::ESProducer { +public: + MkFitIterationConfigESProducer(const edm::ParameterSet& iConfig); + + static void fillDescriptions(edm::ConfigurationDescriptions& descriptions); + + std::unique_ptr produce(const TrackerRecoGeometryRecord& iRecord); + +private: + const edm::ESGetToken geomToken_; + const std::string configFile_; +}; + +MkFitIterationConfigESProducer::MkFitIterationConfigESProducer(const edm::ParameterSet& iConfig) + : geomToken_{setWhatProduced(this, iConfig.getParameter("ComponentName")).consumes()}, + configFile_{iConfig.getParameter("config").fullPath()} {} + +void MkFitIterationConfigESProducer::fillDescriptions(edm::ConfigurationDescriptions& descriptions) { + edm::ParameterSetDescription desc; + desc.add("ComponentName")->setComment("Product label"); + desc.add("config")->setComment("Path to the JSON file for the mkFit configuration parameters"); + descriptions.addWithDefaultLabel(desc); +} + +std::unique_ptr MkFitIterationConfigESProducer::produce( + const TrackerRecoGeometryRecord& iRecord) { + return mkfit::ConfigJson_Load_File(iRecord.get(geomToken_).iterationsInfo(), configFile_); +} + +DEFINE_FWK_EVENTSETUP_MODULE(MkFitIterationConfigESProducer); diff --git a/RecoTracker/MkFit/plugins/MkFitProducer.cc b/RecoTracker/MkFit/plugins/MkFitProducer.cc index be833fb0a8fe3..53585f92729a8 100644 --- a/RecoTracker/MkFit/plugins/MkFitProducer.cc +++ b/RecoTracker/MkFit/plugins/MkFitProducer.cc @@ -46,10 +46,10 @@ class MkFitProducer : public edm::global::EDProducer > > pixelMaskToken_; edm::EDGetTokenT > > stripMaskToken_; const edm::ESGetToken mkFitGeomToken_; - edm::EDPutTokenT putToken_; + const edm::ESGetToken mkFitIterConfigToken_; + const edm::EDPutTokenT putToken_; std::function buildFunction_; const float minGoodStripCharge_; - const int iterationNumber_; // TODO: temporary solution const bool seedCleaning_; const bool backwardFitInCMSSW_; const bool removeDuplicates_; @@ -58,13 +58,13 @@ class MkFitProducer : public edm::global::EDProducer(iConfig.getParameter("hits"))}, - seedToken_{consumes(iConfig.getParameter("seeds"))}, - mkFitGeomToken_{esConsumes()}, + : hitToken_{consumes(iConfig.getParameter("hits"))}, + seedToken_{consumes(iConfig.getParameter("seeds"))}, + mkFitGeomToken_{esConsumes()}, + mkFitIterConfigToken_{esConsumes(iConfig.getParameter("config"))}, putToken_{produces()}, minGoodStripCharge_{static_cast( iConfig.getParameter("minGoodStripCharge").getParameter("value"))}, - iterationNumber_{iConfig.getParameter("iterationNumber")}, seedCleaning_{iConfig.getParameter("seedCleaning")}, backwardFitInCMSSW_{iConfig.getParameter("backwardFitInCMSSW")}, removeDuplicates_{iConfig.getParameter("removeDuplicates")}, @@ -103,7 +103,8 @@ void MkFitProducer::fillDescriptions(edm::ConfigurationDescriptions& description desc.add("clustersToSkip", edm::InputTag()); desc.add("buildingRoutine", "cloneEngine") ->setComment("Valid values are: 'bestHit', 'standard', 'cloneEngine'"); - desc.add("iterationNumber", 0)->setComment("Iteration number (default: 0)"); + desc.add("config")->setComment( + "ESProduct that has the mkFit configuration parameters for this iteration"); desc.add("seedCleaning", true)->setComment("Clean seeds within mkFit"); desc.add("removeDuplicates", true)->setComment("Run duplicate removal within mkFit"); desc.add("backwardFitInCMSSW", false) @@ -137,6 +138,7 @@ void MkFitProducer::produce(edm::StreamID iID, edm::Event& iEvent, const edm::Ev // sure that the ESProducer is called even if the input/output // converters const auto& mkFitGeom = iSetup.getData(mkFitGeomToken_); + const auto& mkFitIterConfig = iSetup.getData(mkFitIterConfigToken_); const std::vector* pixelMaskPtr = nullptr; std::vector pixelMask; @@ -174,7 +176,7 @@ void MkFitProducer::produce(edm::StreamID iID, edm::Event& iEvent, const edm::Ev auto lambda = [&]() { mkfit::run_OneIteration(mkFitGeom.trackerInfo(), - mkFitGeom.iterationsInfo()[iterationNumber_], + mkFitIterConfig, hits.eventOfHits(), {pixelMaskPtr, &stripMask}, streamCache(iID)->get(), diff --git a/RecoTracker/MkFit/python/customizeHLTIter0ToMkFit.py b/RecoTracker/MkFit/python/customizeHLTIter0ToMkFit.py index 82d88d40c5fb0..9a34552e64e48 100644 --- a/RecoTracker/MkFit/python/customizeHLTIter0ToMkFit.py +++ b/RecoTracker/MkFit/python/customizeHLTIter0ToMkFit.py @@ -3,6 +3,7 @@ import RecoTracker.MkFit.mkFitGeometryESProducer_cfi as mkFitGeometryESProducer_cfi import RecoTracker.MkFit.mkFitHitConverter_cfi as mkFitHitConverter_cfi 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 import RecoLocalTracker.SiStripRecHitConverter.SiStripRecHitConverter_cfi as SiStripRecHitConverter_cfi @@ -33,9 +34,14 @@ def customizeHLTIter0ToMkFit(process): seeds = "hltIter0PFLowPixelSeedsFromPixelTracks", ttrhBuilder = ":hltESPTTRHBWithTrackAngle", ) + process.hltIter0PFlowTrackCandidatesMkFitConfig = mkFitIterationConfigESProducer_cfi.mkFitIterationConfigESProducer.clone( + ComponentName = 'hltIter0PFlowTrackCandidatesMkFitConfig', + config = 'RecoTracker/MkFit/data/mkfit-phase1-initialStep.json', + ) process.hltIter0PFlowCkfTrackCandidatesMkFit = mkFitProducer_cfi.mkFitProducer.clone( hits = "hltIter0PFlowCkfTrackCandidatesMkFitHits", seeds = "hltIter0PFlowCkfTrackCandidatesMkFitSeeds", + config = ('', 'hltIter0PFlowTrackCandidatesMkFitConfig'), minGoodStripCharge = dict(refToPSet_ = 'HLTSiStripClusterChargeCutLoose'), ) process.hltIter0PFlowCkfTrackCandidates = mkFitOutputConverter_cfi.mkFitOutputConverter.clone( diff --git a/RecoTracker/MkFit/src/ES_MkFitIterationConfig.cc b/RecoTracker/MkFit/src/ES_MkFitIterationConfig.cc new file mode 100644 index 0000000000000..9ba5e5559c1ad --- /dev/null +++ b/RecoTracker/MkFit/src/ES_MkFitIterationConfig.cc @@ -0,0 +1,3 @@ +#include "mkFit/IterationConfig.h" +#include "FWCore/Utilities/interface/typelookup.h" +TYPELOOKUP_DATA_REG(mkfit::IterationConfig); diff --git a/RecoTracker/MkFit/src/MkFitGeometry.cc b/RecoTracker/MkFit/src/MkFitGeometry.cc index 4fc72ef028516..51dc72bcde30c 100644 --- a/RecoTracker/MkFit/src/MkFitGeometry.cc +++ b/RecoTracker/MkFit/src/MkFitGeometry.cc @@ -5,12 +5,9 @@ #include "RecoTracker/TkDetLayers/interface/GeometricSearchTracker.h" #include "RecoTracker/MkFit/interface/MkFitGeometry.h" -// these two are only temporarily in this file -#define USE_MATRIPLEX -#include "mkFit/SteeringParams.h" - #include "LayerNumberConverter.h" #include "TrackerInfo.h" +#include "mkFit/IterationConfig.h" MkFitGeometry::MkFitGeometry(const TrackerGeometry& geom, const GeometricSearchTracker& tracker, From b8d4f6821e9151736e56fd6e2847d6077d440f30 Mon Sep 17 00:00:00 2001 From: Matti Kortelainen Date: Tue, 18 May 2021 09:02:41 -0700 Subject: [PATCH 18/20] Copy createCMS2017 from mkFit Original names were CMS-2017.acc, CMS-2017.cc. Changes include - Rename files to adhere CMS' naming conventions - Adhere CMS' naming conventions - Code format - Replace global std::function object with a function - Call createCMS2017 instead of ExecTrackerInfoCreatorPlugin - Add comments on mkFit layer numbering - Add comments on writes to global variables and on MessageLogger --- .../MkFit/plugins/MkFitGeometryESProducer.cc | 5 +- .../plugins/createPhase1TrackerGeometry.cc | 241 ++++ .../plugins/createPhase1TrackerGeometry.h | 11 + .../createPhase1TrackerGeometryAutoGen.acc | 1142 +++++++++++++++++ 4 files changed, 1397 insertions(+), 2 deletions(-) create mode 100644 RecoTracker/MkFit/plugins/createPhase1TrackerGeometry.cc create mode 100644 RecoTracker/MkFit/plugins/createPhase1TrackerGeometry.h create mode 100644 RecoTracker/MkFit/plugins/createPhase1TrackerGeometryAutoGen.acc diff --git a/RecoTracker/MkFit/plugins/MkFitGeometryESProducer.cc b/RecoTracker/MkFit/plugins/MkFitGeometryESProducer.cc index 956dd365af60d..d8e5fb3d93cf6 100644 --- a/RecoTracker/MkFit/plugins/MkFitGeometryESProducer.cc +++ b/RecoTracker/MkFit/plugins/MkFitGeometryESProducer.cc @@ -10,6 +10,8 @@ #include "RecoTracker/MkFit/interface/MkFitGeometry.h" +#include "createPhase1TrackerGeometry.h" + // mkFit includes #include "ConfigWrapper.h" #include "TrackerInfo.h" @@ -46,8 +48,7 @@ void MkFitGeometryESProducer::fillDescriptions(edm::ConfigurationDescriptions& d std::unique_ptr MkFitGeometryESProducer::produce(const TrackerRecoGeometryRecord& iRecord) { auto trackerInfo = std::make_unique(); auto iterationsInfo = std::make_unique(); - // TODO: absorb the functionality to CMSSW - mkfit::TrackerInfo::ExecTrackerInfoCreatorPlugin("CMS-2017", *trackerInfo, *iterationsInfo); + mkfit::createPhase1TrackerGeometry(*trackerInfo, *iterationsInfo, false); return std::make_unique(iRecord.get(geomToken_), iRecord.get(trackerToken_), iRecord.get(ttopoToken_), diff --git a/RecoTracker/MkFit/plugins/createPhase1TrackerGeometry.cc b/RecoTracker/MkFit/plugins/createPhase1TrackerGeometry.cc new file mode 100644 index 0000000000000..ae8706005975e --- /dev/null +++ b/RecoTracker/MkFit/plugins/createPhase1TrackerGeometry.cc @@ -0,0 +1,241 @@ +//------------------- +// Phase1 tracker geometry +//------------------- + +#include "Config.h" +#include "Debug.h" +#include "TrackerInfo.h" +#include "mkFit/IterationConfig.h" +#include "mkFit/HitStructures.h" + +#include + +using namespace mkfit; + +namespace { +#include "createPhase1TrackerGeometryAutoGen.acc" + + void setupSteeringParamsIter0(IterationConfig &ic) { + ic.m_region_order[0] = TrackerInfo::Reg_Transition_Pos; + ic.m_region_order[1] = TrackerInfo::Reg_Transition_Neg; + ic.m_region_order[2] = TrackerInfo::Reg_Endcap_Pos; + ic.m_region_order[3] = TrackerInfo::Reg_Endcap_Neg; + ic.m_region_order[4] = TrackerInfo::Reg_Barrel; + + { + SteeringParams &sp = ic.m_steering_params[TrackerInfo::Reg_Endcap_Neg]; + sp.reserve_plan(3 + 3 + 6 + 18); // BPix + FPix- + TID- + TEC-; BPix4 is out of acceptance + sp.fill_plan(0, 1, false, true); // bk-fit only + sp.append_plan(2, true); // pick-up only + sp.append_plan(45, false); + sp.append_plan(46, false); + sp.append_plan(47, false); + sp.fill_plan(48, 53); // TID, 6 disks (3 mono + 3 stereo) + sp.fill_plan(54, 71); // TEC, 18 disks (3 mono + 3 stereo) + sp.finalize_plan(); + } + { + SteeringParams &sp = ic.m_steering_params[TrackerInfo::Reg_Transition_Neg]; + sp.reserve_plan(4 + 3 + 6 + 6 + 8 + 18); // BPix + FPix- + TIB + TID- + TOB + TEC- + sp.fill_plan(0, 1, false, true); // bk-fit only + sp.append_plan(2, true); + sp.append_plan(3, false); + sp.append_plan(45, false); + sp.append_plan(46, false); + sp.append_plan(47, false); + sp.fill_plan(4, 9); // TIB, 6 layers (4 mono + 2 stereo) + sp.fill_plan(48, 53); // TID, 6 disks (3 mono + 3 stereo) + sp.fill_plan(10, 17); // TOB, 8 layers (6 mono + 2 stereo) + sp.fill_plan(54, 71); // TEC, 18 disks (9 mono + 9 stereo) + sp.finalize_plan(); + } + { + SteeringParams &sp = ic.m_steering_params[TrackerInfo::Reg_Barrel]; + sp.reserve_plan(4 + 6 + 8); // BPix + TIB + TOB + sp.fill_plan(0, 1, false, true); // bk-fit only + sp.append_plan(2, true); // pickup-only + sp.append_plan(3, false); + sp.fill_plan(4, 9); // TIB, 6 layers (4 mono + 2 stereo) + sp.fill_plan(10, 17); // TOB, 8 layers (6 mono + 2 stereo) + sp.finalize_plan(); + } + { + SteeringParams &sp = ic.m_steering_params[TrackerInfo::Reg_Transition_Pos]; + sp.reserve_plan(4 + 3 + 6 + 6 + 8 + 18); // BPix + FPix+ + TIB + TID+ + TOB + TEC+ + sp.fill_plan(0, 1, false, true); // bk-fit only + sp.append_plan(2, true); // pickup-only + sp.append_plan(3, false); + sp.append_plan(18, false); + sp.append_plan(19, false); + sp.append_plan(20, false); + sp.fill_plan(4, 9); // TIB, 6 layers (4 mono + 2 stereo) + sp.fill_plan(21, 26); // TID, 6 disks (3 mono + 3 stereo) + sp.fill_plan(10, 17); // TOB, 8 layers (6 mono + 2 stereo) + sp.fill_plan(27, 44); // TEC, 18 disks (9 mono + 9 stereo) + sp.finalize_plan(); + } + { + SteeringParams &sp = ic.m_steering_params[TrackerInfo::Reg_Endcap_Pos]; + sp.reserve_plan(3 + 3 + 6 + 18); // BPix + FPix+ + TID+ + TEC+; BPix4 is out of acceptance + sp.fill_plan(0, 1, false, true); // bk-fit only + sp.append_plan(2, true); // pickup-only + sp.append_plan(18, false); + sp.append_plan(19, false); + sp.append_plan(20, false); + sp.fill_plan(21, 26); // TID, 6 disks (3 mono + 3 stereo) + sp.fill_plan(27, 44); // TEC, 18 disks (9 mono + 9 stereo) + sp.finalize_plan(); + } + } + + void partitionSeeds0(const TrackerInfo &trk_info, + const TrackVec &in_seeds, + const EventOfHits &eoh, + IterationSeedPartition &part) { + // Seeds are placed into eta regions and sorted on region + eta. + + const int size = in_seeds.size(); + + for (int i = 0; i < size; ++i) { + const Track &S = in_seeds[i]; + + const bool z_dir_pos = S.pz() > 0; + + HitOnTrack hot = S.getLastHitOnTrack(); + // MIMI ACHTUNG -- here we assume seed hits have already been remapped. + // This was true at that time :) + float eta = eoh[hot.layer].GetHit(hot.index).eta(); + // float eta = S.momEta(); + + // Region to be defined by propagation / intersection tests + TrackerInfo::EtaRegion reg; + + // Hardcoded for cms ... needs some lists of layers (hit/miss) for brl / ecp tests. + // MM: Check lambda functions/std::function + const LayerInfo &outer_brl = trk_info.outer_barrel_layer(); + + const LayerInfo &tib1 = trk_info.m_layers[4]; + const LayerInfo &tob1 = trk_info.m_layers[10]; + + const LayerInfo &tecp1 = trk_info.m_layers[27]; + const LayerInfo &tecn1 = trk_info.m_layers[54]; + + const LayerInfo &tec_first = z_dir_pos ? tecp1 : tecn1; + + // If a track hits outer barrel ... it is in the barrel (for central, "outgoing" tracks). + // This is also true for cyl-cow. + // Better check is: hits outer TIB, misses inner TEC (but is +-z dependant). + // XXXX Calculate z ... then check is inside or less that first EC z. + // There are a lot of tracks that go through that crack. + + // XXXX trying a fix for low pT tracks that are in barrel after half circle + float maxR = S.maxReachRadius(); + float z_at_maxr; + + bool can_reach_outer_brl = S.canReachRadius(outer_brl.m_rout); + float z_at_outer_brl; + bool misses_first_tec; + if (can_reach_outer_brl) { + z_at_outer_brl = S.zAtR(outer_brl.m_rout); + if (z_dir_pos) + misses_first_tec = z_at_outer_brl < tec_first.m_zmin; + else + misses_first_tec = z_at_outer_brl > tec_first.m_zmax; + } else { + z_at_maxr = S.zAtR(maxR); + if (z_dir_pos) + misses_first_tec = z_at_maxr < tec_first.m_zmin; + else + misses_first_tec = z_at_maxr > tec_first.m_zmax; + } + + if (/*can_reach_outer_brl &&*/ misses_first_tec) + // outer_brl.is_within_z_limits(S.zAtR(outer_brl.r_mean()))) + { + reg = TrackerInfo::Reg_Barrel; + } else { + // This should be a list of layers + // CMS, first tib, tob: 4, 10 + + if ((S.canReachRadius(tib1.m_rin) && tib1.is_within_z_limits(S.zAtR(tib1.m_rin))) || + (S.canReachRadius(tob1.m_rin) && tob1.is_within_z_limits(S.zAtR(tob1.m_rin)))) { + // transition region ... we are still hitting barrel layers + + reg = z_dir_pos ? TrackerInfo::Reg_Transition_Pos : TrackerInfo::Reg_Transition_Neg; + } else { + // endcap ... no barrel layers will be hit anymore. + + reg = z_dir_pos ? TrackerInfo::Reg_Endcap_Pos : TrackerInfo::Reg_Endcap_Neg; + } + } + + part.m_region[i] = reg; + part.m_sort_score[i] = 5.0f * (reg - 2) + eta; + } + } +} // namespace + +namespace mkfit { + void createPhase1TrackerGeometry(TrackerInfo &ti, IterationsInfo &ii, bool verbose) { + // TODO: these writes to global variables need to be removed + Config::nTotalLayers = 18 + 2 * 27; + + Config::useCMSGeom = true; + + Config::finding_requires_propagation_to_hit_pos = true; + Config::finding_inter_layer_pflags = PropagationFlags(PF_use_param_b_field | PF_apply_material); + Config::finding_intra_layer_pflags = PropagationFlags(PF_none); + Config::backward_fit_pflags = PropagationFlags(PF_use_param_b_field | PF_apply_material); + Config::forward_fit_pflags = PropagationFlags(PF_use_param_b_field | PF_apply_material); + Config::seed_fit_pflags = PropagationFlags(PF_none); + Config::pca_prop_pflags = PropagationFlags(PF_none); + + ti.set_eta_regions(0.9, 1.7, 2.45, false); + ti.create_layers(18, 27, 27); + + ii.resize(9); + ii[0].set_iteration_index_and_track_algorithm(0, (int)TrackBase::TrackAlgorithm::initialStep); + ii[0].set_num_regions_layers(5, 72); + + createPhase1TrackerGeometryAutoGen(ti, ii); + + setupSteeringParamsIter0(ii[0]); + ii[0].m_partition_seeds = partitionSeeds0; + + ii[1].Clone(ii[0]); + ii[1].set_iteration_index_and_track_algorithm(1, (int)TrackBase::TrackAlgorithm::highPtTripletStep); + + ii[2].Clone(ii[0]); + ii[2].set_iteration_index_and_track_algorithm(2, (int)TrackBase::TrackAlgorithm::lowPtQuadStep); + + ii[3].Clone(ii[0]); + ii[3].set_iteration_index_and_track_algorithm(3, (int)TrackBase::TrackAlgorithm::lowPtTripletStep); + + ii[4].Clone(ii[0]); + ii[4].set_iteration_index_and_track_algorithm(4, (int)TrackBase::TrackAlgorithm::detachedQuadStep); + + ii[5].Clone(ii[0]); + ii[5].set_iteration_index_and_track_algorithm(5, (int)TrackBase::TrackAlgorithm::detachedTripletStep); + + ii[6].Clone(ii[0]); + ii[6].set_iteration_index_and_track_algorithm(6, (int)TrackBase::TrackAlgorithm::mixedTripletStep); + + ii[7].Clone(ii[0]); + ii[7].set_iteration_index_and_track_algorithm(7, (int)TrackBase::TrackAlgorithm::pixelLessStep); + + ii[8].Clone(ii[0]); + ii[8].set_iteration_index_and_track_algorithm(8, (int)TrackBase::TrackAlgorithm::tobTecStep); + + //for the latter 2 iter investing in maxCand & stop condition (for time) + QF and Dupl. cleaning (for quality) + + // TODO: replace with MessageLogger + if (verbose) { + printf("==========================================================================================\n"); + printf("Phase1 tracker -- Create_TrackerInfo finished\n"); + printf("==========================================================================================\n"); + for (auto &i : ti.m_layers) + i.print_layer(); + printf("==========================================================================================\n"); + } + } +} // namespace mkfit diff --git a/RecoTracker/MkFit/plugins/createPhase1TrackerGeometry.h b/RecoTracker/MkFit/plugins/createPhase1TrackerGeometry.h new file mode 100644 index 0000000000000..0b90f711df105 --- /dev/null +++ b/RecoTracker/MkFit/plugins/createPhase1TrackerGeometry.h @@ -0,0 +1,11 @@ +#ifndef RecoTracker_MkFit_plugins_createPhase1TrackerGeometry_h +#define RecoTracker_MkFit_plugins_createPhase1TrackerGeometry_h + +namespace mkfit { + class TrackerInfo; + class IterationsInfo; + + void createPhase1TrackerGeometry(TrackerInfo &ti, IterationsInfo &ii, bool verbose); +} // namespace mkfit + +#endif diff --git a/RecoTracker/MkFit/plugins/createPhase1TrackerGeometryAutoGen.acc b/RecoTracker/MkFit/plugins/createPhase1TrackerGeometryAutoGen.acc new file mode 100644 index 0000000000000..b68a96428bdbe --- /dev/null +++ b/RecoTracker/MkFit/plugins/createPhase1TrackerGeometryAutoGen.acc @@ -0,0 +1,1142 @@ +void createPhase1TrackerGeometryAutoGen(TrackerInfo &ti, IterationsInfo &ii) { + // PIXB + + { + LayerInfo &obj = ti.m_layers[0]; + obj.m_layer_type = LayerInfo::Barrel; + obj.set_limits(2.720, 3.390, -26.700, 26.700); + obj.m_propagate_to = obj.r_mean(); + obj.set_next_layers(1, 18, 45); + obj.m_q_bin = 2.000; + obj.m_is_outer = false; + obj.m_is_stereo_lyr = false; + obj.m_is_pixb_lyr = true; + obj.m_is_seed_lyr = true; + } + + { + LayerInfo &obj = ti.m_layers[1]; + obj.m_layer_type = LayerInfo::Barrel; + obj.set_limits(6.560, 7.270, -26.700, 26.700); + obj.m_propagate_to = obj.r_mean(); + obj.set_next_layers(2, 18, 45); + obj.m_q_bin = 2.000; + obj.m_is_outer = false; + obj.m_is_stereo_lyr = false; + obj.m_is_pixb_lyr = true; + obj.m_is_seed_lyr = true; + } + + { + LayerInfo &obj = ti.m_layers[2]; + obj.m_layer_type = LayerInfo::Barrel; + obj.set_limits(10.690, 11.360, -26.700, 26.700); + obj.m_propagate_to = obj.r_mean(); + obj.set_next_layers(3, 18, 45); + obj.m_q_bin = 2.000; + obj.m_is_outer = false; + obj.m_is_stereo_lyr = false; + obj.m_is_pixb_lyr = true; + obj.m_is_seed_lyr = true; + } + + { + LayerInfo &obj = ti.m_layers[3]; + obj.m_layer_type = LayerInfo::Barrel; + obj.set_limits(15.800, 16.460, -26.700, 26.690); + obj.m_propagate_to = obj.r_mean(); + obj.set_next_layers(4, 21, 48); + obj.m_q_bin = 2.000; + obj.m_is_outer = false; + obj.m_is_stereo_lyr = false; + obj.m_is_pixb_lyr = true; + obj.m_is_seed_lyr = true; + } + + // TIB + + { + LayerInfo &obj = ti.m_layers[4]; + obj.m_layer_type = LayerInfo::Barrel; + obj.set_limits(23.450, 27.880, -66.670, 63.930); + obj.m_propagate_to = obj.r_mean(); + obj.set_next_layers(5, 21, 48); + obj.m_q_bin = 6.000; + obj.m_is_outer = false; + obj.m_is_stereo_lyr = false; + obj.m_is_tib_lyr = true; + } + + { + LayerInfo &obj = ti.m_layers[5]; + obj.m_layer_type = LayerInfo::Barrel; + obj.set_limits(23.450, 27.880, -66.670, 63.930); + obj.m_propagate_to = obj.r_mean(); + obj.set_next_layers(6, 21, 48); + obj.m_q_bin = 6.000; + obj.m_is_outer = false; + obj.m_is_stereo_lyr = true; + obj.m_is_tib_lyr = true; + } + + { + LayerInfo &obj = ti.m_layers[6]; + obj.m_layer_type = LayerInfo::Barrel; + obj.set_limits(31.830, 36.240, -65.890, 66.670); + obj.m_propagate_to = obj.r_mean(); + obj.set_next_layers(7, 21, 48); + obj.m_q_bin = 6.000; + obj.m_is_outer = false; + obj.m_is_stereo_lyr = false; + obj.m_is_tib_lyr = true; + } + + { + LayerInfo &obj = ti.m_layers[7]; + obj.m_layer_type = LayerInfo::Barrel; + obj.set_limits(31.830, 36.240, -65.890, 66.670); + obj.m_propagate_to = obj.r_mean(); + obj.set_next_layers(8, 21, 48); + obj.m_q_bin = 6.000; + obj.m_is_outer = false; + obj.m_is_stereo_lyr = true; + obj.m_is_tib_lyr = true; + } + + { + LayerInfo &obj = ti.m_layers[8]; + obj.m_layer_type = LayerInfo::Barrel; + obj.set_limits(39.880, 44.040, -66.400, 65.240); + obj.m_propagate_to = obj.r_mean(); + obj.set_next_layers(9, 21, 48); + obj.m_q_bin = 6.000; + obj.m_is_outer = false; + obj.m_is_stereo_lyr = false; + obj.m_is_tib_lyr = true; + } + + { + LayerInfo &obj = ti.m_layers[9]; + obj.m_layer_type = LayerInfo::Barrel; + obj.set_limits(47.810, 51.980, -66.400, 66.400); + obj.m_propagate_to = obj.r_mean(); + obj.set_next_layers(10, 27, 54); + obj.m_q_bin = 6.000; + obj.m_is_outer = false; + obj.m_is_stereo_lyr = false; + obj.m_is_tib_lyr = true; + } + + // TOB + + { + LayerInfo &obj = ti.m_layers[10]; + obj.m_layer_type = LayerInfo::Barrel; + obj.set_limits(58.410, 63.430, -108.710, 108.710); + obj.m_propagate_to = obj.r_mean(); + obj.set_next_layers(11, 27, 54); + obj.m_q_bin = 9.500; + obj.m_is_outer = false; + obj.m_is_stereo_lyr = false; + obj.m_is_tib_lyr = true; + } + + { + LayerInfo &obj = ti.m_layers[11]; + obj.m_layer_type = LayerInfo::Barrel; + obj.set_limits(58.410, 63.430, -108.710, 108.710); + obj.m_propagate_to = obj.r_mean(); + obj.set_next_layers(12, 27, 54); + obj.m_q_bin = 9.500; + obj.m_is_outer = false; + obj.m_is_stereo_lyr = true; + obj.m_is_tib_lyr = true; + } + + { + LayerInfo &obj = ti.m_layers[12]; + obj.m_layer_type = LayerInfo::Barrel; + obj.set_limits(66.810, 71.740, -108.700, 108.710); + obj.m_propagate_to = obj.r_mean(); + obj.set_next_layers(13, 27, 54); + obj.m_q_bin = 9.500; + obj.m_is_outer = false; + obj.m_is_stereo_lyr = false; + obj.m_is_tib_lyr = true; + } + + { + LayerInfo &obj = ti.m_layers[13]; + obj.m_layer_type = LayerInfo::Barrel; + obj.set_limits(66.810, 71.740, -108.700, 108.710); + obj.m_propagate_to = obj.r_mean(); + obj.set_next_layers(14, 27, 54); + obj.m_q_bin = 9.500; + obj.m_is_outer = false; + obj.m_is_stereo_lyr = true; + obj.m_is_tib_lyr = true; + } + + { + LayerInfo &obj = ti.m_layers[14]; + obj.m_layer_type = LayerInfo::Barrel; + obj.set_limits(76.040, 80.090, -108.300, 108.290); + obj.m_propagate_to = obj.r_mean(); + obj.set_next_layers(15, 27, 54); + obj.m_q_bin = 9.500; + obj.m_is_outer = false; + obj.m_is_stereo_lyr = false; + obj.m_is_tib_lyr = true; + } + + { + LayerInfo &obj = ti.m_layers[15]; + obj.m_layer_type = LayerInfo::Barrel; + obj.set_limits(84.840, 88.880, -108.290, 108.300); + obj.m_propagate_to = obj.r_mean(); + obj.set_next_layers(16, 27, 54); + obj.m_q_bin = 9.500; + obj.m_is_outer = false; + obj.m_is_stereo_lyr = false; + obj.m_is_tib_lyr = true; + } + + { + LayerInfo &obj = ti.m_layers[16]; + obj.m_layer_type = LayerInfo::Barrel; + obj.set_limits(94.540, 98.570, -108.290, 108.290); + obj.m_propagate_to = obj.r_mean(); + obj.set_next_layers(17, 27, 54); + obj.m_q_bin = 9.500; + obj.m_is_outer = false; + obj.m_is_stereo_lyr = false; + obj.m_is_tib_lyr = true; + } + + { + LayerInfo &obj = ti.m_layers[17]; + obj.m_layer_type = LayerInfo::Barrel; + obj.set_limits(106.040, 110.060, -108.290, 108.290); + obj.m_propagate_to = obj.r_mean(); + obj.set_next_layers(-1, -1, -1); + obj.m_q_bin = 9.500; + obj.m_is_outer = true; + obj.m_is_stereo_lyr = false; + obj.m_is_tib_lyr = true; + } + + // PIXE +/- + + { + LayerInfo &obj = ti.m_layers[18]; + obj.m_layer_type = LayerInfo::EndCapPos; + obj.set_limits(4.590, 16.090, 29.440, 35.210); + obj.m_propagate_to = obj.z_mean(); + obj.set_next_layers(4, 19, -1); + obj.m_q_bin = 1.000; + obj.m_is_outer = false; + obj.m_is_stereo_lyr = false; + obj.m_is_pixe_lyr = true; + obj.m_is_seed_lyr = true; + } + { + LayerInfo &obj = ti.m_layers[45]; + obj.m_layer_type = LayerInfo::EndCapNeg; + obj.set_limits(4.590, 16.090, -35.200, -29.440); + obj.m_propagate_to = obj.z_mean(); + obj.set_next_layers(4, -1, 46); + obj.m_q_bin = 1.000; + obj.m_is_outer = false; + obj.m_is_stereo_lyr = false; + obj.m_is_pixe_lyr = true; + obj.m_is_seed_lyr = true; + } + { + LayerInfo &obj = ti.m_layers[19]; + obj.m_layer_type = LayerInfo::EndCapPos; + obj.set_limits(4.590, 16.090, 36.940, 42.700); + obj.m_propagate_to = obj.z_mean(); + obj.set_next_layers(4, 20, -1); + obj.m_q_bin = 1.000; + obj.m_is_outer = false; + obj.m_is_stereo_lyr = false; + obj.m_is_pixe_lyr = true; + obj.m_is_seed_lyr = true; + } + { + LayerInfo &obj = ti.m_layers[46]; + obj.m_layer_type = LayerInfo::EndCapNeg; + obj.set_limits(4.590, 16.090, -42.700, -36.940); + obj.m_propagate_to = obj.z_mean(); + obj.set_next_layers(4, -1, 47); + obj.m_q_bin = 1.000; + obj.m_is_outer = false; + obj.m_is_stereo_lyr = false; + obj.m_is_pixe_lyr = true; + obj.m_is_seed_lyr = true; + } + { + LayerInfo &obj = ti.m_layers[20]; + obj.m_layer_type = LayerInfo::EndCapPos; + obj.set_limits(4.590, 16.090, 46.450, 52.200); + obj.m_propagate_to = obj.z_mean(); + obj.set_next_layers(4, 21, -1); + obj.m_q_bin = 1.000; + obj.m_is_outer = false; + obj.m_is_stereo_lyr = false; + obj.m_is_pixe_lyr = true; + obj.m_is_seed_lyr = true; + } + { + LayerInfo &obj = ti.m_layers[47]; + obj.m_layer_type = LayerInfo::EndCapNeg; + obj.set_limits(4.590, 16.090, -52.210, -46.450); + obj.m_propagate_to = obj.z_mean(); + obj.set_next_layers(4, -1, 48); + obj.m_q_bin = 1.000; + obj.m_is_outer = false; + obj.m_is_stereo_lyr = false; + obj.m_is_pixe_lyr = true; + obj.m_is_seed_lyr = true; + } + + // TID +/- + + { + LayerInfo &obj = ti.m_layers[21]; + obj.m_layer_type = LayerInfo::EndCapPos; + obj.set_limits(22.980, 50.440, 74.350, 84.050); + obj.m_propagate_to = obj.z_mean(); + obj.set_next_layers(10, 22, -1); + obj.m_q_bin = 5.500; + obj.m_is_outer = false; + obj.m_is_stereo_lyr = false; + obj.m_is_tid_lyr = true; + } + { + LayerInfo &obj = ti.m_layers[48]; + obj.m_layer_type = LayerInfo::EndCapNeg; + obj.set_limits(22.980, 50.440, -84.050, -74.350); + obj.m_propagate_to = obj.z_mean(); + obj.set_next_layers(10, -1, 49); + obj.m_q_bin = 5.500; + obj.m_is_outer = false; + obj.m_is_stereo_lyr = false; + obj.m_is_tid_lyr = true; + } + { + LayerInfo &obj = ti.m_layers[22]; + obj.m_layer_type = LayerInfo::EndCapPos; + obj.set_limits(22.800, 42.000, 74.350, 84.050); + obj.m_propagate_to = obj.z_mean(); + obj.set_next_layers(10, 23, -1); + obj.m_q_bin = 5.500; + obj.m_is_outer = false; + obj.m_is_stereo_lyr = true; + obj.m_is_tid_lyr = true; + } + { + LayerInfo &obj = ti.m_layers[49]; + obj.m_layer_type = LayerInfo::EndCapNeg; + obj.set_limits(22.800, 42.000, -84.050, -74.350); + obj.m_propagate_to = obj.z_mean(); + obj.set_next_layers(10, -1, 50); + obj.m_q_bin = 5.500; + obj.m_is_outer = false; + obj.m_is_stereo_lyr = true; + obj.m_is_tid_lyr = true; + } + { + LayerInfo &obj = ti.m_layers[23]; + obj.m_layer_type = LayerInfo::EndCapPos; + obj.set_limits(22.980, 50.440, 87.300, 97.000); + obj.m_propagate_to = obj.z_mean(); + obj.set_next_layers(10, 24, -1); + obj.m_q_bin = 5.500; + obj.m_is_outer = false; + obj.m_is_stereo_lyr = false; + obj.m_is_tid_lyr = true; + } + { + LayerInfo &obj = ti.m_layers[50]; + obj.m_layer_type = LayerInfo::EndCapNeg; + obj.set_limits(22.980, 50.440, -97.000, -87.300); + obj.m_propagate_to = obj.z_mean(); + obj.set_next_layers(10, -1, 51); + obj.m_q_bin = 5.500; + obj.m_is_outer = false; + obj.m_is_stereo_lyr = false; + obj.m_is_tid_lyr = true; + } + { + LayerInfo &obj = ti.m_layers[24]; + obj.m_layer_type = LayerInfo::EndCapPos; + obj.set_limits(22.800, 42.000, 87.300, 97.000); + obj.m_propagate_to = obj.z_mean(); + obj.set_next_layers(10, 25, -1); + obj.m_q_bin = 5.500; + obj.m_is_outer = false; + obj.m_is_stereo_lyr = true; + obj.m_is_tid_lyr = true; + } + { + LayerInfo &obj = ti.m_layers[51]; + obj.m_layer_type = LayerInfo::EndCapNeg; + obj.set_limits(22.800, 42.000, -97.000, -87.300); + obj.m_propagate_to = obj.z_mean(); + obj.set_next_layers(10, -1, 52); + obj.m_q_bin = 5.500; + obj.m_is_outer = false; + obj.m_is_stereo_lyr = true; + obj.m_is_tid_lyr = true; + } + { + LayerInfo &obj = ti.m_layers[25]; + obj.m_layer_type = LayerInfo::EndCapPos; + obj.set_limits(22.980, 50.440, 100.250, 109.950); + obj.m_propagate_to = obj.z_mean(); + obj.set_next_layers(10, 26, -1); + obj.m_q_bin = 5.500; + obj.m_is_outer = false; + obj.m_is_stereo_lyr = false; + obj.m_is_tid_lyr = true; + } + { + LayerInfo &obj = ti.m_layers[52]; + obj.m_layer_type = LayerInfo::EndCapNeg; + obj.set_limits(22.980, 50.440, -109.950, -100.250); + obj.m_propagate_to = obj.z_mean(); + obj.set_next_layers(10, -1, 53); + obj.m_q_bin = 5.500; + obj.m_is_outer = false; + obj.m_is_stereo_lyr = false; + obj.m_is_tid_lyr = true; + } + { + LayerInfo &obj = ti.m_layers[26]; + obj.m_layer_type = LayerInfo::EndCapPos; + obj.set_limits(22.800, 42.000, 100.250, 109.950); + obj.m_propagate_to = obj.z_mean(); + obj.set_next_layers(10, 27, -1); + obj.m_q_bin = 5.500; + obj.m_is_outer = false; + obj.m_is_stereo_lyr = true; + obj.m_is_tid_lyr = true; + } + { + LayerInfo &obj = ti.m_layers[53]; + obj.m_layer_type = LayerInfo::EndCapNeg; + obj.set_limits(22.800, 42.000, -109.950, -100.250); + obj.m_propagate_to = obj.z_mean(); + obj.set_next_layers(10, -1, 54); + obj.m_q_bin = 5.500; + obj.m_is_outer = false; + obj.m_is_stereo_lyr = true; + obj.m_is_tid_lyr = true; + } + + // TEC +/- + + { + LayerInfo &obj = ti.m_layers[27]; + obj.m_layer_type = LayerInfo::EndCapPos; + obj.set_limits(23.370, 109.390, 126.380, 137.390); + obj.m_propagate_to = obj.z_mean(); + obj.set_next_layers(-1, 28, -1); + obj.m_q_bin = 10.000; + obj.m_is_outer = false; + obj.m_is_stereo_lyr = false; + obj.m_is_tec_lyr = true; + } + { + LayerInfo &obj = ti.m_layers[54]; + obj.m_layer_type = LayerInfo::EndCapNeg; + obj.set_limits(23.360, 109.400, -137.390, -126.380); + obj.m_propagate_to = obj.z_mean(); + obj.set_next_layers(-1, -1, 55); + obj.m_q_bin = 10.000; + obj.m_is_outer = false; + obj.m_is_stereo_lyr = false; + obj.m_is_tec_lyr = true; + } + { + LayerInfo &obj = ti.m_layers[28]; + obj.m_layer_type = LayerInfo::EndCapPos; + obj.set_limits(23.300, 76.100, 126.380, 137.390); + obj.m_propagate_to = obj.z_mean(); + obj.set_next_layers(-1, 29, -1); + obj.m_q_bin = 10.000; + obj.m_is_outer = false; + obj.m_is_stereo_lyr = true; + obj.m_is_tec_lyr = true; + obj.set_r_hole_range(42.000, 59.900); + } + { + LayerInfo &obj = ti.m_layers[55]; + obj.m_layer_type = LayerInfo::EndCapNeg; + obj.set_limits(23.300, 76.100, -137.390, -126.380); + obj.m_propagate_to = obj.z_mean(); + obj.set_next_layers(-1, -1, 56); + obj.m_q_bin = 10.000; + obj.m_is_outer = false; + obj.m_is_stereo_lyr = true; + obj.m_is_tec_lyr = true; + obj.set_r_hole_range(42.000, 59.900); + } + { + LayerInfo &obj = ti.m_layers[29]; + obj.m_layer_type = LayerInfo::EndCapPos; + obj.set_limits(23.360, 109.410, 140.380, 151.390); + obj.m_propagate_to = obj.z_mean(); + obj.set_next_layers(-1, 30, -1); + obj.m_q_bin = 10.000; + obj.m_is_outer = false; + obj.m_is_stereo_lyr = false; + obj.m_is_tec_lyr = true; + } + { + LayerInfo &obj = ti.m_layers[56]; + obj.m_layer_type = LayerInfo::EndCapNeg; + obj.set_limits(23.360, 109.390, -151.420, -140.380); + obj.m_propagate_to = obj.z_mean(); + obj.set_next_layers(-1, -1, 57); + obj.m_q_bin = 10.000; + obj.m_is_outer = false; + obj.m_is_stereo_lyr = false; + obj.m_is_tec_lyr = true; + } + { + LayerInfo &obj = ti.m_layers[30]; + obj.m_layer_type = LayerInfo::EndCapPos; + obj.set_limits(23.300, 76.100, 140.380, 151.390); + obj.m_propagate_to = obj.z_mean(); + obj.set_next_layers(-1, 31, -1); + obj.m_q_bin = 10.000; + obj.m_is_outer = false; + obj.m_is_stereo_lyr = true; + obj.m_is_tec_lyr = true; + obj.set_r_hole_range(42.000, 59.900); + } + { + LayerInfo &obj = ti.m_layers[57]; + obj.m_layer_type = LayerInfo::EndCapNeg; + obj.set_limits(23.300, 76.100, -151.420, -140.380); + obj.m_propagate_to = obj.z_mean(); + obj.set_next_layers(-1, -1, 58); + obj.m_q_bin = 10.000; + obj.m_is_outer = false; + obj.m_is_stereo_lyr = true; + obj.m_is_tec_lyr = true; + obj.set_r_hole_range(42.000, 59.900); + } + { + LayerInfo &obj = ti.m_layers[31]; + obj.m_layer_type = LayerInfo::EndCapPos; + obj.set_limits(23.360, 109.390, 154.380, 165.390); + obj.m_propagate_to = obj.z_mean(); + obj.set_next_layers(-1, 32, -1); + obj.m_q_bin = 10.000; + obj.m_is_outer = false; + obj.m_is_stereo_lyr = false; + obj.m_is_tec_lyr = true; + } + { + LayerInfo &obj = ti.m_layers[58]; + obj.m_layer_type = LayerInfo::EndCapNeg; + obj.set_limits(23.360, 109.390, -165.390, -154.380); + obj.m_propagate_to = obj.z_mean(); + obj.set_next_layers(-1, -1, 59); + obj.m_q_bin = 10.000; + obj.m_is_outer = false; + obj.m_is_stereo_lyr = false; + obj.m_is_tec_lyr = true; + } + { + LayerInfo &obj = ti.m_layers[32]; + obj.m_layer_type = LayerInfo::EndCapPos; + obj.set_limits(23.300, 76.100, 154.380, 165.390); + obj.m_propagate_to = obj.z_mean(); + obj.set_next_layers(-1, 33, -1); + obj.m_q_bin = 10.000; + obj.m_is_outer = false; + obj.m_is_stereo_lyr = true; + obj.m_is_tec_lyr = true; + obj.set_r_hole_range(42.000, 59.900); + } + { + LayerInfo &obj = ti.m_layers[59]; + obj.m_layer_type = LayerInfo::EndCapNeg; + obj.set_limits(23.300, 76.100, -165.390, -154.380); + obj.m_propagate_to = obj.z_mean(); + obj.set_next_layers(-1, -1, 60); + obj.m_q_bin = 10.000; + obj.m_is_outer = false; + obj.m_is_stereo_lyr = true; + obj.m_is_tec_lyr = true; + obj.set_r_hole_range(42.000, 59.900); + } + { + LayerInfo &obj = ti.m_layers[33]; + obj.m_layer_type = LayerInfo::EndCapPos; + obj.set_limits(32.110, 109.400, 168.380, 179.380); + obj.m_propagate_to = obj.z_mean(); + obj.set_next_layers(-1, 34, -1); + obj.m_q_bin = 10.000; + obj.m_is_outer = false; + obj.m_is_stereo_lyr = false; + obj.m_is_tec_lyr = true; + } + { + LayerInfo &obj = ti.m_layers[60]; + obj.m_layer_type = LayerInfo::EndCapNeg; + obj.set_limits(32.110, 109.390, -179.390, -168.380); + obj.m_propagate_to = obj.z_mean(); + obj.set_next_layers(-1, -1, 61); + obj.m_q_bin = 10.000; + obj.m_is_outer = false; + obj.m_is_stereo_lyr = false; + obj.m_is_tec_lyr = true; + } + { + LayerInfo &obj = ti.m_layers[34]; + obj.m_layer_type = LayerInfo::EndCapPos; + obj.set_limits(31.600, 75.900, 168.380, 179.380); + obj.m_propagate_to = obj.z_mean(); + obj.set_next_layers(-1, 35, -1); + obj.m_q_bin = 10.000; + obj.m_is_outer = false; + obj.m_is_stereo_lyr = true; + obj.m_is_tec_lyr = true; + obj.set_r_hole_range(42.100, 59.700); + } + { + LayerInfo &obj = ti.m_layers[61]; + obj.m_layer_type = LayerInfo::EndCapNeg; + obj.set_limits(31.600, 75.900, -179.390, -168.380); + obj.m_propagate_to = obj.z_mean(); + obj.set_next_layers(-1, -1, 62); + obj.m_q_bin = 10.000; + obj.m_is_outer = false; + obj.m_is_stereo_lyr = true; + obj.m_is_tec_lyr = true; + obj.set_r_hole_range(42.100, 59.700); + } + { + LayerInfo &obj = ti.m_layers[35]; + obj.m_layer_type = LayerInfo::EndCapPos; + obj.set_limits(32.110, 109.390, 182.370, 193.390); + obj.m_propagate_to = obj.z_mean(); + obj.set_next_layers(-1, 36, -1); + obj.m_q_bin = 10.000; + obj.m_is_outer = false; + obj.m_is_stereo_lyr = false; + obj.m_is_tec_lyr = true; + } + { + LayerInfo &obj = ti.m_layers[62]; + obj.m_layer_type = LayerInfo::EndCapNeg; + obj.set_limits(32.110, 109.390, -193.380, -182.380); + obj.m_propagate_to = obj.z_mean(); + obj.set_next_layers(-1, -1, 63); + obj.m_q_bin = 10.000; + obj.m_is_outer = false; + obj.m_is_stereo_lyr = false; + obj.m_is_tec_lyr = true; + } + { + LayerInfo &obj = ti.m_layers[36]; + obj.m_layer_type = LayerInfo::EndCapPos; + obj.set_limits(31.600, 75.900, 182.370, 193.390); + obj.m_propagate_to = obj.z_mean(); + obj.set_next_layers(-1, 37, -1); + obj.m_q_bin = 10.000; + obj.m_is_outer = false; + obj.m_is_stereo_lyr = true; + obj.m_is_tec_lyr = true; + obj.set_r_hole_range(42.100, 59.700); + } + { + LayerInfo &obj = ti.m_layers[63]; + obj.m_layer_type = LayerInfo::EndCapNeg; + obj.set_limits(31.600, 75.900, -193.380, -182.380); + obj.m_propagate_to = obj.z_mean(); + obj.set_next_layers(-1, -1, 64); + obj.m_q_bin = 10.000; + obj.m_is_outer = false; + obj.m_is_stereo_lyr = true; + obj.m_is_tec_lyr = true; + obj.set_r_hole_range(42.100, 59.700); + } + { + LayerInfo &obj = ti.m_layers[37]; + obj.m_layer_type = LayerInfo::EndCapPos; + obj.set_limits(32.110, 109.390, 199.870, 210.880); + obj.m_propagate_to = obj.z_mean(); + obj.set_next_layers(-1, 38, -1); + obj.m_q_bin = 10.000; + obj.m_is_outer = false; + obj.m_is_stereo_lyr = false; + obj.m_is_tec_lyr = true; + } + { + LayerInfo &obj = ti.m_layers[64]; + obj.m_layer_type = LayerInfo::EndCapNeg; + obj.set_limits(32.110, 109.390, -210.880, -199.870); + obj.m_propagate_to = obj.z_mean(); + obj.set_next_layers(-1, -1, 65); + obj.m_q_bin = 10.000; + obj.m_is_outer = false; + obj.m_is_stereo_lyr = false; + obj.m_is_tec_lyr = true; + } + { + LayerInfo &obj = ti.m_layers[38]; + obj.m_layer_type = LayerInfo::EndCapPos; + obj.set_limits(31.600, 75.900, 199.870, 210.880); + obj.m_propagate_to = obj.z_mean(); + obj.set_next_layers(-1, 39, -1); + obj.m_q_bin = 10.000; + obj.m_is_outer = false; + obj.m_is_stereo_lyr = true; + obj.m_is_tec_lyr = true; + obj.set_r_hole_range(42.100, 59.700); + } + { + LayerInfo &obj = ti.m_layers[65]; + obj.m_layer_type = LayerInfo::EndCapNeg; + obj.set_limits(31.600, 75.900, -210.880, -199.870); + obj.m_propagate_to = obj.z_mean(); + obj.set_next_layers(-1, -1, 66); + obj.m_q_bin = 10.000; + obj.m_is_outer = false; + obj.m_is_stereo_lyr = true; + obj.m_is_tec_lyr = true; + obj.set_r_hole_range(42.100, 59.700); + } + { + LayerInfo &obj = ti.m_layers[39]; + obj.m_layer_type = LayerInfo::EndCapPos; + obj.set_limits(39.200, 109.390, 218.870, 229.860); + obj.m_propagate_to = obj.z_mean(); + obj.set_next_layers(-1, 40, -1); + obj.m_q_bin = 10.000; + obj.m_is_outer = false; + obj.m_is_stereo_lyr = false; + obj.m_is_tec_lyr = true; + } + { + LayerInfo &obj = ti.m_layers[66]; + obj.m_layer_type = LayerInfo::EndCapNeg; + obj.set_limits(39.200, 109.390, -229.860, -218.870); + obj.m_propagate_to = obj.z_mean(); + obj.set_next_layers(-1, -1, 67); + obj.m_q_bin = 10.000; + obj.m_is_outer = false; + obj.m_is_stereo_lyr = false; + obj.m_is_tec_lyr = true; + } + { + LayerInfo &obj = ti.m_layers[40]; + obj.m_layer_type = LayerInfo::EndCapPos; + obj.set_limits(59.900, 75.900, 218.870, 229.860); + obj.m_propagate_to = obj.z_mean(); + obj.set_next_layers(-1, 41, -1); + obj.m_q_bin = 10.000; + obj.m_is_outer = false; + obj.m_is_stereo_lyr = true; + obj.m_is_tec_lyr = true; + } + { + LayerInfo &obj = ti.m_layers[67]; + obj.m_layer_type = LayerInfo::EndCapNeg; + obj.set_limits(59.900, 75.900, -229.860, -218.870); + obj.m_propagate_to = obj.z_mean(); + obj.set_next_layers(-1, -1, 68); + obj.m_q_bin = 10.000; + obj.m_is_outer = false; + obj.m_is_stereo_lyr = true; + obj.m_is_tec_lyr = true; + } + { + LayerInfo &obj = ti.m_layers[41]; + obj.m_layer_type = LayerInfo::EndCapPos; + obj.set_limits(39.200, 109.400, 239.370, 250.360); + obj.m_propagate_to = obj.z_mean(); + obj.set_next_layers(-1, 42, -1); + obj.m_q_bin = 10.000; + obj.m_is_outer = false; + obj.m_is_stereo_lyr = false; + obj.m_is_tec_lyr = true; + } + { + LayerInfo &obj = ti.m_layers[68]; + obj.m_layer_type = LayerInfo::EndCapNeg; + obj.set_limits(39.200, 109.400, -250.360, -239.370); + obj.m_propagate_to = obj.z_mean(); + obj.set_next_layers(-1, -1, 69); + obj.m_q_bin = 10.000; + obj.m_is_outer = false; + obj.m_is_stereo_lyr = false; + obj.m_is_tec_lyr = true; + } + { + LayerInfo &obj = ti.m_layers[42]; + obj.m_layer_type = LayerInfo::EndCapPos; + obj.set_limits(59.900, 75.900, 239.370, 250.360); + obj.m_propagate_to = obj.z_mean(); + obj.set_next_layers(-1, 43, -1); + obj.m_q_bin = 10.000; + obj.m_is_outer = false; + obj.m_is_stereo_lyr = true; + obj.m_is_tec_lyr = true; + } + { + LayerInfo &obj = ti.m_layers[69]; + obj.m_layer_type = LayerInfo::EndCapNeg; + obj.set_limits(59.900, 75.900, -250.360, -239.370); + obj.m_propagate_to = obj.z_mean(); + obj.set_next_layers(-1, -1, 70); + obj.m_q_bin = 10.000; + obj.m_is_outer = false; + obj.m_is_stereo_lyr = true; + obj.m_is_tec_lyr = true; + } + { + LayerInfo &obj = ti.m_layers[43]; + obj.m_layer_type = LayerInfo::EndCapPos; + obj.set_limits(50.410, 109.400, 260.870, 271.870); + obj.m_propagate_to = obj.z_mean(); + obj.set_next_layers(-1, 44, -1); + obj.m_q_bin = 10.000; + obj.m_is_outer = false; + obj.m_is_stereo_lyr = false; + obj.m_is_tec_lyr = true; + } + { + LayerInfo &obj = ti.m_layers[70]; + obj.m_layer_type = LayerInfo::EndCapNeg; + obj.set_limits(50.410, 109.390, -271.880, -260.870); + obj.m_propagate_to = obj.z_mean(); + obj.set_next_layers(-1, -1, 71); + obj.m_q_bin = 10.000; + obj.m_is_outer = false; + obj.m_is_stereo_lyr = false; + obj.m_is_tec_lyr = true; + } + { + LayerInfo &obj = ti.m_layers[44]; + obj.m_layer_type = LayerInfo::EndCapPos; + obj.set_limits(59.900, 75.900, 260.870, 271.870); + obj.m_propagate_to = obj.z_mean(); + obj.set_next_layers(-1, -1, -1); + obj.m_q_bin = 10.000; + obj.m_is_outer = true; + obj.m_is_stereo_lyr = true; + obj.m_is_tec_lyr = true; + } + { + LayerInfo &obj = ti.m_layers[71]; + obj.m_layer_type = LayerInfo::EndCapNeg; + obj.set_limits(59.900, 75.900, -271.880, -260.870); + obj.m_propagate_to = obj.z_mean(); + obj.set_next_layers(-1, -1, -1); + obj.m_q_bin = 10.000; + obj.m_is_outer = true; + obj.m_is_stereo_lyr = true; + obj.m_is_tec_lyr = true; + } + + // Iteration 0 (default) + + { + IterationConfig &ic = ii[0]; + { + IterationLayerConfig &obj = ic.layer(0); + obj.set_selection_limits(0.010000, 0.050000, 1.000000, 2.000000); + } + { + IterationLayerConfig &obj = ic.layer(1); + obj.set_selection_limits(0.010000, 0.050000, 1.000000, 2.000000); + } + { + IterationLayerConfig &obj = ic.layer(2); + obj.set_selection_limits(0.010000, 0.050000, 1.000000, 2.000000); + } + { + IterationLayerConfig &obj = ic.layer(3); + obj.set_selection_limits(0.010000, 0.050000, 1.000000, 2.000000); + } + { + IterationLayerConfig &obj = ic.layer(4); + obj.set_selection_limits(0.010000, 0.015000, 6.000000, 12.000000); + } + { + IterationLayerConfig &obj = ic.layer(5); + obj.set_selection_limits(0.023000, 0.030000, 6.000000, 12.000000); + } + { + IterationLayerConfig &obj = ic.layer(6); + obj.set_selection_limits(0.010000, 0.015000, 6.000000, 12.000000); + } + { + IterationLayerConfig &obj = ic.layer(7); + obj.set_selection_limits(0.016000, 0.030000, 6.000000, 12.000000); + } + { + IterationLayerConfig &obj = ic.layer(8); + obj.set_selection_limits(0.010000, 0.015000, 6.000000, 12.000000); + } + { + IterationLayerConfig &obj = ic.layer(9); + obj.set_selection_limits(0.010000, 0.015000, 6.000000, 12.000000); + } + { + IterationLayerConfig &obj = ic.layer(10); + obj.set_selection_limits(0.010000, 0.015000, 9.500000, 19.000000); + } + { + IterationLayerConfig &obj = ic.layer(11); + obj.set_selection_limits(0.016000, 0.030000, 9.500000, 19.000000); + } + { + IterationLayerConfig &obj = ic.layer(12); + obj.set_selection_limits(0.010000, 0.015000, 9.500000, 19.000000); + } + { + IterationLayerConfig &obj = ic.layer(13); + obj.set_selection_limits(0.013000, 0.030000, 9.500000, 19.000000); + } + { + IterationLayerConfig &obj = ic.layer(14); + obj.set_selection_limits(0.010000, 0.015000, 9.500000, 19.000000); + } + { + IterationLayerConfig &obj = ic.layer(15); + obj.set_selection_limits(0.010000, 0.015000, 9.500000, 19.000000); + } + { + IterationLayerConfig &obj = ic.layer(16); + obj.set_selection_limits(0.010000, 0.015000, 9.500000, 19.000000); + } + { + IterationLayerConfig &obj = ic.layer(17); + obj.set_selection_limits(0.010000, 0.015000, 9.500000, 19.000000); + } + { + IterationLayerConfig &obj = ic.layer(18); + obj.set_selection_limits(0.010000, 0.015000, 0.800000, 1.600000); + } + { + IterationLayerConfig &obj = ic.layer(19); + obj.set_selection_limits(0.010000, 0.015000, 0.800000, 1.600000); + } + { + IterationLayerConfig &obj = ic.layer(20); + obj.set_selection_limits(0.010000, 0.015000, 0.800000, 1.600000); + } + { + IterationLayerConfig &obj = ic.layer(21); + obj.set_selection_limits(0.010000, 0.015000, 5.500000, 11.000000); + } + { + IterationLayerConfig &obj = ic.layer(22); + obj.set_selection_limits(0.010000, 0.030000, 5.500000, 11.000000); + } + { + IterationLayerConfig &obj = ic.layer(23); + obj.set_selection_limits(0.010000, 0.015000, 5.500000, 11.000000); + } + { + IterationLayerConfig &obj = ic.layer(24); + obj.set_selection_limits(0.010000, 0.030000, 5.500000, 11.000000); + } + { + IterationLayerConfig &obj = ic.layer(25); + obj.set_selection_limits(0.010000, 0.015000, 5.500000, 11.000000); + } + { + IterationLayerConfig &obj = ic.layer(26); + obj.set_selection_limits(0.010000, 0.030000, 5.500000, 11.000000); + } + { + IterationLayerConfig &obj = ic.layer(27); + obj.set_selection_limits(0.010000, 0.015000, 10.000000, 20.000000); + } + { + IterationLayerConfig &obj = ic.layer(28); + obj.set_selection_limits(0.010000, 0.030000, 10.000000, 20.000000); + } + { + IterationLayerConfig &obj = ic.layer(29); + obj.set_selection_limits(0.010000, 0.015000, 10.000000, 20.000000); + } + { + IterationLayerConfig &obj = ic.layer(30); + obj.set_selection_limits(0.010000, 0.030000, 10.000000, 20.000000); + } + { + IterationLayerConfig &obj = ic.layer(31); + obj.set_selection_limits(0.010000, 0.015000, 10.000000, 20.000000); + } + { + IterationLayerConfig &obj = ic.layer(32); + obj.set_selection_limits(0.010000, 0.030000, 10.000000, 20.000000); + } + { + IterationLayerConfig &obj = ic.layer(33); + obj.set_selection_limits(0.010000, 0.015000, 10.000000, 20.000000); + } + { + IterationLayerConfig &obj = ic.layer(34); + obj.set_selection_limits(0.010000, 0.030000, 10.000000, 20.000000); + } + { + IterationLayerConfig &obj = ic.layer(35); + obj.set_selection_limits(0.010000, 0.015000, 10.000000, 20.000000); + } + { + IterationLayerConfig &obj = ic.layer(36); + obj.set_selection_limits(0.010000, 0.030000, 10.000000, 20.000000); + } + { + IterationLayerConfig &obj = ic.layer(37); + obj.set_selection_limits(0.010000, 0.015000, 10.000000, 20.000000); + } + { + IterationLayerConfig &obj = ic.layer(38); + obj.set_selection_limits(0.010000, 0.030000, 10.000000, 20.000000); + } + { + IterationLayerConfig &obj = ic.layer(39); + obj.set_selection_limits(0.010000, 0.015000, 10.000000, 20.000000); + } + { + IterationLayerConfig &obj = ic.layer(40); + obj.set_selection_limits(0.010000, 0.030000, 10.000000, 20.000000); + } + { + IterationLayerConfig &obj = ic.layer(41); + obj.set_selection_limits(0.010000, 0.015000, 10.000000, 20.000000); + } + { + IterationLayerConfig &obj = ic.layer(42); + obj.set_selection_limits(0.010000, 0.030000, 10.000000, 20.000000); + } + { + IterationLayerConfig &obj = ic.layer(43); + obj.set_selection_limits(0.010000, 0.015000, 10.000000, 20.000000); + } + { + IterationLayerConfig &obj = ic.layer(44); + obj.set_selection_limits(0.010000, 0.030000, 10.000000, 20.000000); + } + { + IterationLayerConfig &obj = ic.layer(45); + obj.set_selection_limits(0.010000, 0.015000, 0.800000, 1.600000); + } + { + IterationLayerConfig &obj = ic.layer(46); + obj.set_selection_limits(0.010000, 0.015000, 0.800000, 1.600000); + } + { + IterationLayerConfig &obj = ic.layer(47); + obj.set_selection_limits(0.010000, 0.015000, 0.800000, 1.600000); + } + { + IterationLayerConfig &obj = ic.layer(48); + obj.set_selection_limits(0.010000, 0.015000, 5.500000, 11.000000); + } + { + IterationLayerConfig &obj = ic.layer(49); + obj.set_selection_limits(0.010000, 0.030000, 5.500000, 11.000000); + } + { + IterationLayerConfig &obj = ic.layer(50); + obj.set_selection_limits(0.010000, 0.015000, 5.500000, 11.000000); + } + { + IterationLayerConfig &obj = ic.layer(51); + obj.set_selection_limits(0.010000, 0.030000, 5.500000, 11.000000); + } + { + IterationLayerConfig &obj = ic.layer(52); + obj.set_selection_limits(0.010000, 0.015000, 5.500000, 11.000000); + } + { + IterationLayerConfig &obj = ic.layer(53); + obj.set_selection_limits(0.010000, 0.030000, 5.500000, 11.000000); + } + { + IterationLayerConfig &obj = ic.layer(54); + obj.set_selection_limits(0.010000, 0.015000, 10.000000, 20.000000); + } + { + IterationLayerConfig &obj = ic.layer(55); + obj.set_selection_limits(0.010000, 0.030000, 10.000000, 20.000000); + } + { + IterationLayerConfig &obj = ic.layer(56); + obj.set_selection_limits(0.010000, 0.015000, 10.000000, 20.000000); + } + { + IterationLayerConfig &obj = ic.layer(57); + obj.set_selection_limits(0.010000, 0.030000, 10.000000, 20.000000); + } + { + IterationLayerConfig &obj = ic.layer(58); + obj.set_selection_limits(0.010000, 0.015000, 10.000000, 20.000000); + } + { + IterationLayerConfig &obj = ic.layer(59); + obj.set_selection_limits(0.010000, 0.030000, 10.000000, 20.000000); + } + { + IterationLayerConfig &obj = ic.layer(60); + obj.set_selection_limits(0.010000, 0.015000, 10.000000, 20.000000); + } + { + IterationLayerConfig &obj = ic.layer(61); + obj.set_selection_limits(0.010000, 0.030000, 10.000000, 20.000000); + } + { + IterationLayerConfig &obj = ic.layer(62); + obj.set_selection_limits(0.010000, 0.015000, 10.000000, 20.000000); + } + { + IterationLayerConfig &obj = ic.layer(63); + obj.set_selection_limits(0.010000, 0.030000, 10.000000, 20.000000); + } + { + IterationLayerConfig &obj = ic.layer(64); + obj.set_selection_limits(0.010000, 0.015000, 10.000000, 20.000000); + } + { + IterationLayerConfig &obj = ic.layer(65); + obj.set_selection_limits(0.010000, 0.030000, 10.000000, 20.000000); + } + { + IterationLayerConfig &obj = ic.layer(66); + obj.set_selection_limits(0.010000, 0.015000, 10.000000, 20.000000); + } + { + IterationLayerConfig &obj = ic.layer(67); + obj.set_selection_limits(0.010000, 0.030000, 10.000000, 20.000000); + } + { + IterationLayerConfig &obj = ic.layer(68); + obj.set_selection_limits(0.010000, 0.015000, 10.000000, 20.000000); + } + { + IterationLayerConfig &obj = ic.layer(69); + obj.set_selection_limits(0.010000, 0.030000, 10.000000, 20.000000); + } + { + IterationLayerConfig &obj = ic.layer(70); + obj.set_selection_limits(0.010000, 0.015000, 10.000000, 20.000000); + } + { + IterationLayerConfig &obj = ic.layer(71); + obj.set_selection_limits(0.010000, 0.030000, 10.000000, 20.000000); + } + } +} From 27c9d223719dd572bc8292b1caf791a3c05d9f97 Mon Sep 17 00:00:00 2001 From: Matevz Tadel Date: Mon, 24 May 2021 15:26:08 -0700 Subject: [PATCH 19/20] Document configuration parameters in README Co-authored-by: Mario Masciovecchio --- RecoTracker/MkFit/README.md | 48 ++++++++++++++++++++++++++++++++++++- 1 file changed, 47 insertions(+), 1 deletion(-) diff --git a/RecoTracker/MkFit/README.md b/RecoTracker/MkFit/README.md index 6808838744399..3bd44016f71ef 100644 --- a/RecoTracker/MkFit/README.md +++ b/RecoTracker/MkFit/README.md @@ -30,4 +30,50 @@ tracker detector. Support for the phase2 tracker will be added later. These can be used with e.g. ```bash $ runTheMatrix.py -l --apply 2 --command "--procModifiers trackingMkFit --customise RecoTracker/MkFit/customizeInitialStepToMkFit.customizeInitialStepOnly" -``` \ No newline at end of file +``` + +## Description of configuration parameters + +### Iteration configuration [class IterationConfig] + +* *m_track_algorithm:* CMSSW track algorithm (used internally for reporting and consistency checks) +* *m_requires_seed_hit_sorting:* do hits on seed tracks need to be sorted (required for seeds that include strip layers) +* *m_require_quality_filter:* is additional post-processing required for result tracks +* *m_params:* IterationParams structure for this iteration +* *m_layer_configs:* std::vector of per-layer parameters + +### Iteration parameters [class IterationParams] + +* *nlayers_per_seed:* internal mkFit parameter used for standalone validation +* *maxCandsPerSeed:* maximum number of concurrent track candidates per given seed +* *maxHolesPerCand:* maximum number of allowed holes on a candidate +* *maxConsecHoles:* maximum number of allowed consecutive holes on a candidate +* *chi2Cut:* chi2 cut for accepting a new hit +* *chi2CutOverlap:* chi2 cut for accepting an overlap hit +* *pTCutOverlap:* pT cut below which the overlap hits are not picked up + +#### Seed cleaning params (based on elliptical dR-dz cut) + +* *c_ptthr_hpt:* pT threshold used to tighten seed cleaning requirements +* *c_drmax_bh:* dR cut used for seed tracks with std::fabs(eta)<0.9 and pT > c_ptthr_hpt +* *c_dzmax_bh:* dz cut used for seed tracks with std::fabs(eta)<0.9 and pT > c_ptthr_hpt +* *c_drmax_eh:* dR cut used for seed tracks with std::fabs(eta)>0.9 and pT > c_ptthr_hpt +* *c_dzmax_eh:* dz cut used for seed tracks with std::fabs(eta)>0.9 and pT > c_ptthr_hpt +* *c_drmax_bl:* dR cut used for seed tracks with std::fabs(eta)<0.9 and pT < c_ptthr_hpt +* *c_dzmax_bl:* dz cut used for seed tracks with std::fabs(eta)<0.9 and pT < c_ptthr_hpt +* *c_drmax_el:* dR cut used for seed tracks with std::fabs(eta)>0.9 and pT < c_ptthr_hpt +* *c_dzmax_el:* dz cut used for seed tracks with std::fabs(eta)>0.9 and pT < c_ptthr_hpt + +#### Duplicate cleaning parameters + +* *minHitsQF:* min number of hits on track candidate to apply duplicate cleaning based on fraction of shared hits +* *fracSharedHits:* min fraction of shared hits to determine duplicate track candidate + +### Per-layer parameters [class IterationLayerConfig] + +* *m_select_min_dphi, m_select_max_dphi:* geometry-driven dphi baseline selection window cut +* *m_select_min_dq, m_select_max_dq:* geometry-driven dr (endcap) / dz (barrel) baseline selection window cut +* *c_dp_[012]:* dphi selection window cut (= [0]*1/pT + [1]*std::fabs(theta-pi/2) + [2]) +* *c_dp_sf:* additional scaling factor for dphi cut +* *c_dq_[012]:* dr (endcap) / dz (barrel) selection window cut (= [0]*1/pT + [1]*std::fabs(theta-pi/2) + [2]) +* *c_dq_sf:* additional scaling factor for dr (endcap) / dz (barrel) cut From 78094ae37211e4fcc9f84a6ef4f669f9c637ca6d Mon Sep 17 00:00:00 2001 From: Matti Kortelainen Date: Wed, 2 Jun 2021 18:04:19 -0700 Subject: [PATCH 20/20] Split MkFitHitProducer to MkFitSi{Pixel,Strip}HitConverter and MkFitEventOfHitsProducer Pixel and strip hits are needed separately to avoid converting strip hits again when the support for initialStepPreSplitting will eventually be added. It also hides the question on naming (pixel vs strip vs outer). --- .../python/DetachedQuadStep_cff.py | 2 +- .../python/DetachedTripletStep_cff.py | 2 +- .../python/HighPtTripletStep_cff.py | 2 +- .../python/InitialStep_cff.py | 12 +- .../python/LowPtQuadStep_cff.py | 2 +- .../python/LowPtTripletStep_cff.py | 2 +- .../python/MixedTripletStep_cff.py | 2 +- .../python/PixelLessStep_cff.py | 2 +- .../python/TobTecStep_cff.py | 2 +- .../MkFit/interface/MkFitClusterIndexToHit.h | 10 +- .../MkFit/interface/MkFitEventOfHits.h | 36 +++ RecoTracker/MkFit/interface/MkFitGeometry.h | 4 + RecoTracker/MkFit/interface/MkFitHitWrapper.h | 38 +-- RecoTracker/MkFit/plugins/BuildFile.xml | 1 + .../MkFit/plugins/MkFitEventOfHitsProducer.cc | 86 ++++++ .../MkFit/plugins/MkFitHitConverter.cc | 262 ------------------ .../MkFit/plugins/MkFitOutputConverter.cc | 55 ++-- RecoTracker/MkFit/plugins/MkFitProducer.cc | 52 +++- .../MkFit/plugins/MkFitSiPixelHitConverter.cc | 91 ++++++ .../MkFit/plugins/MkFitSiStripHitConverter.cc | 125 +++++++++ RecoTracker/MkFit/plugins/convertHits.h | 103 +++++++ .../MkFit/python/customizeHLTIter0ToMkFit.py | 36 ++- .../python/mkFitSiStripHitConverter_cfi.py | 9 + RecoTracker/MkFit/src/MkFitEventOfHits.cc | 11 + RecoTracker/MkFit/src/MkFitGeometry.cc | 25 +- RecoTracker/MkFit/src/MkFitHitWrapper.cc | 18 -- RecoTracker/MkFit/src/classes.h | 1 + RecoTracker/MkFit/src/classes_def.xml | 3 + .../python/plotting/trackingPlots.py | 4 +- 29 files changed, 611 insertions(+), 387 deletions(-) create mode 100644 RecoTracker/MkFit/interface/MkFitEventOfHits.h create mode 100644 RecoTracker/MkFit/plugins/MkFitEventOfHitsProducer.cc delete mode 100644 RecoTracker/MkFit/plugins/MkFitHitConverter.cc create mode 100644 RecoTracker/MkFit/plugins/MkFitSiPixelHitConverter.cc create mode 100644 RecoTracker/MkFit/plugins/MkFitSiStripHitConverter.cc create mode 100644 RecoTracker/MkFit/plugins/convertHits.h create mode 100644 RecoTracker/MkFit/python/mkFitSiStripHitConverter_cfi.py create mode 100644 RecoTracker/MkFit/src/MkFitEventOfHits.cc diff --git a/RecoTracker/IterativeTracking/python/DetachedQuadStep_cff.py b/RecoTracker/IterativeTracking/python/DetachedQuadStep_cff.py index d9c1e21478195..4e2b04aa63213 100644 --- a/RecoTracker/IterativeTracking/python/DetachedQuadStep_cff.py +++ b/RecoTracker/IterativeTracking/python/DetachedQuadStep_cff.py @@ -205,7 +205,7 @@ ) trackingMkFitDetachedQuadStep.toReplaceWith(detachedQuadStepTrackCandidates, mkFitOutputConverter_cfi.mkFitOutputConverter.clone( seeds = 'detachedQuadStepSeeds', - mkfitSeeds = 'detachedQuadStepTrackCandidatesMkFitSeeds', + mkFitSeeds = 'detachedQuadStepTrackCandidatesMkFitSeeds', tracks = 'detachedQuadStepTrackCandidatesMkFit', )) diff --git a/RecoTracker/IterativeTracking/python/DetachedTripletStep_cff.py b/RecoTracker/IterativeTracking/python/DetachedTripletStep_cff.py index 552036fc967e5..a8748a1b1f627 100644 --- a/RecoTracker/IterativeTracking/python/DetachedTripletStep_cff.py +++ b/RecoTracker/IterativeTracking/python/DetachedTripletStep_cff.py @@ -233,7 +233,7 @@ ) trackingMkFitDetachedTripletStep.toReplaceWith(detachedTripletStepTrackCandidates, mkFitOutputConverter_cfi.mkFitOutputConverter.clone( seeds = 'detachedTripletStepSeeds', - mkfitSeeds = 'detachedTripletStepTrackCandidatesMkFitSeeds', + mkFitSeeds = 'detachedTripletStepTrackCandidatesMkFitSeeds', tracks = 'detachedTripletStepTrackCandidatesMkFit', )) diff --git a/RecoTracker/IterativeTracking/python/HighPtTripletStep_cff.py b/RecoTracker/IterativeTracking/python/HighPtTripletStep_cff.py index c71fd9b0b15ee..cd1d48e1b848d 100644 --- a/RecoTracker/IterativeTracking/python/HighPtTripletStep_cff.py +++ b/RecoTracker/IterativeTracking/python/HighPtTripletStep_cff.py @@ -234,7 +234,7 @@ ) trackingMkFitHighPtTripletStep.toReplaceWith(highPtTripletStepTrackCandidates, mkFitOutputConverter_cfi.mkFitOutputConverter.clone( seeds = 'highPtTripletStepSeeds', - mkfitSeeds = 'highPtTripletStepTrackCandidatesMkFitSeeds', + mkFitSeeds = 'highPtTripletStepTrackCandidatesMkFitSeeds', tracks = 'highPtTripletStepTrackCandidatesMkFit', )) diff --git a/RecoTracker/IterativeTracking/python/InitialStep_cff.py b/RecoTracker/IterativeTracking/python/InitialStep_cff.py index 095898aa7dc31..d8fa10a6768d4 100644 --- a/RecoTracker/IterativeTracking/python/InitialStep_cff.py +++ b/RecoTracker/IterativeTracking/python/InitialStep_cff.py @@ -225,12 +225,16 @@ from Configuration.ProcessModifiers.trackingMkFitInitialStep_cff import trackingMkFitInitialStep from RecoTracker.MkFit.mkFitGeometryESProducer_cfi import mkFitGeometryESProducer -import RecoTracker.MkFit.mkFitHitConverter_cfi as mkFitHitConverter_cfi +import RecoTracker.MkFit.mkFitSiPixelHitConverter_cfi as mkFitSiPixelHitConverter_cfi +import RecoTracker.MkFit.mkFitSiStripHitConverter_cfi as mkFitSiStripHitConverter_cfi +import RecoTracker.MkFit.mkFitEventOfHitsProducer_cfi as mkFitEventOfHitsProducer_cfi 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 -mkFitHits = mkFitHitConverter_cfi.mkFitHitConverter.clone() # TODO: figure out better place for this module? +mkFitSiPixelHits = mkFitSiPixelHitConverter_cfi.mkFitSiPixelHitConverter.clone() # TODO: figure out better place for this module? +mkFitSiStripHits = mkFitSiStripHitConverter_cfi.mkFitSiStripHitConverter.clone() # TODO: figure out better place for this module? +mkFitEventOfHits = mkFitEventOfHitsProducer_cfi.mkFitEventOfHitsProducer.clone() # TODO: figure out better place for this module? initialStepTrackCandidatesMkFitSeeds = mkFitSeedConverter_cfi.mkFitSeedConverter.clone( seeds = 'initialStepSeeds', ) @@ -244,7 +248,7 @@ ) trackingMkFitInitialStep.toReplaceWith(initialStepTrackCandidates, mkFitOutputConverter_cfi.mkFitOutputConverter.clone( seeds = 'initialStepSeeds', - mkfitSeeds = 'initialStepTrackCandidatesMkFitSeeds', + mkFitSeeds = 'initialStepTrackCandidatesMkFitSeeds', tracks = 'initialStepTrackCandidatesMkFit', )) @@ -424,7 +428,7 @@ from Configuration.ProcessModifiers.trackingMkFitCommon_cff import trackingMkFitCommon _InitialStepTask_trackingMkFitCommon = InitialStepTask.copy() -_InitialStepTask_trackingMkFitCommon.add(mkFitHits, mkFitGeometryESProducer) +_InitialStepTask_trackingMkFitCommon.add(mkFitSiPixelHits, mkFitSiStripHits, mkFitEventOfHits, mkFitGeometryESProducer) trackingMkFitCommon.toReplaceWith(InitialStepTask, _InitialStepTask_trackingMkFitCommon) _InitialStepTask_trackingMkFit = InitialStepTask.copy() diff --git a/RecoTracker/IterativeTracking/python/LowPtQuadStep_cff.py b/RecoTracker/IterativeTracking/python/LowPtQuadStep_cff.py index 7f92e254e884c..f7b44fcfe68a4 100644 --- a/RecoTracker/IterativeTracking/python/LowPtQuadStep_cff.py +++ b/RecoTracker/IterativeTracking/python/LowPtQuadStep_cff.py @@ -195,7 +195,7 @@ ) trackingMkFitLowPtQuadStep.toReplaceWith(lowPtQuadStepTrackCandidates, mkFitOutputConverter_cfi.mkFitOutputConverter.clone( seeds = 'lowPtQuadStepSeeds', - mkfitSeeds = 'lowPtQuadStepTrackCandidatesMkFitSeeds', + mkFitSeeds = 'lowPtQuadStepTrackCandidatesMkFitSeeds', tracks = 'lowPtQuadStepTrackCandidatesMkFit', )) diff --git a/RecoTracker/IterativeTracking/python/LowPtTripletStep_cff.py b/RecoTracker/IterativeTracking/python/LowPtTripletStep_cff.py index 1ca29d559603d..66fd32de00ec1 100644 --- a/RecoTracker/IterativeTracking/python/LowPtTripletStep_cff.py +++ b/RecoTracker/IterativeTracking/python/LowPtTripletStep_cff.py @@ -261,7 +261,7 @@ ) trackingMkFitLowPtTripletStep.toReplaceWith(lowPtTripletStepTrackCandidates, mkFitOutputConverter_cfi.mkFitOutputConverter.clone( seeds = 'lowPtTripletStepSeeds', - mkfitSeeds = 'lowPtTripletStepTrackCandidatesMkFitSeeds', + mkFitSeeds = 'lowPtTripletStepTrackCandidatesMkFitSeeds', tracks = 'lowPtTripletStepTrackCandidatesMkFit', )) diff --git a/RecoTracker/IterativeTracking/python/MixedTripletStep_cff.py b/RecoTracker/IterativeTracking/python/MixedTripletStep_cff.py index 621dd54756e6b..82f3b9cb60aeb 100644 --- a/RecoTracker/IterativeTracking/python/MixedTripletStep_cff.py +++ b/RecoTracker/IterativeTracking/python/MixedTripletStep_cff.py @@ -311,7 +311,7 @@ ) trackingMkFitMixedTripletStep.toReplaceWith(mixedTripletStepTrackCandidates, mkFitOutputConverter_cfi.mkFitOutputConverter.clone( seeds = 'mixedTripletStepSeeds', - mkfitSeeds = 'mixedTripletStepTrackCandidatesMkFitSeeds', + mkFitSeeds = 'mixedTripletStepTrackCandidatesMkFitSeeds', tracks = 'mixedTripletStepTrackCandidatesMkFit', )) diff --git a/RecoTracker/IterativeTracking/python/PixelLessStep_cff.py b/RecoTracker/IterativeTracking/python/PixelLessStep_cff.py index fece24efdb9cb..5e6d115c97b21 100644 --- a/RecoTracker/IterativeTracking/python/PixelLessStep_cff.py +++ b/RecoTracker/IterativeTracking/python/PixelLessStep_cff.py @@ -304,7 +304,7 @@ ) trackingMkFitPixelLessStep.toReplaceWith(pixelLessStepTrackCandidates, mkFitOutputConverter_cfi.mkFitOutputConverter.clone( seeds = 'pixelLessStepSeeds', - mkfitSeeds = 'pixelLessStepTrackCandidatesMkFitSeeds', + mkFitSeeds = 'pixelLessStepTrackCandidatesMkFitSeeds', tracks = 'pixelLessStepTrackCandidatesMkFit', )) diff --git a/RecoTracker/IterativeTracking/python/TobTecStep_cff.py b/RecoTracker/IterativeTracking/python/TobTecStep_cff.py index 408d9e5a0f2b5..ec17f33d6f31c 100644 --- a/RecoTracker/IterativeTracking/python/TobTecStep_cff.py +++ b/RecoTracker/IterativeTracking/python/TobTecStep_cff.py @@ -288,7 +288,7 @@ ) trackingMkFitTobTecStep.toReplaceWith(tobTecStepTrackCandidates, mkFitOutputConverter_cfi.mkFitOutputConverter.clone( seeds = 'tobTecStepSeeds', - mkfitSeeds = 'tobTecStepTrackCandidatesMkFitSeeds', + mkFitSeeds = 'tobTecStepTrackCandidatesMkFitSeeds', tracks = 'tobTecStepTrackCandidatesMkFit', )) diff --git a/RecoTracker/MkFit/interface/MkFitClusterIndexToHit.h b/RecoTracker/MkFit/interface/MkFitClusterIndexToHit.h index 1415e8b83a24a..7c8d9db2bb3cf 100644 --- a/RecoTracker/MkFit/interface/MkFitClusterIndexToHit.h +++ b/RecoTracker/MkFit/interface/MkFitClusterIndexToHit.h @@ -9,16 +9,12 @@ class MkFitClusterIndexToHit { public: MkFitClusterIndexToHit() = default; - std::vector &pixelHits() { return pixelHits_; } - std::vector const &pixelHits() const { return pixelHits_; } - - std::vector &outerHits() { return outerHits_; } - std::vector const &outerHits() const { return outerHits_; } + std::vector& hits() { return hits_; } + std::vector const& hits() const { return hits_; } private: // Indexed by cluster index - std::vector pixelHits_; - std::vector outerHits_; + std::vector hits_; }; #endif diff --git a/RecoTracker/MkFit/interface/MkFitEventOfHits.h b/RecoTracker/MkFit/interface/MkFitEventOfHits.h new file mode 100644 index 0000000000000..cb5ea6358da1b --- /dev/null +++ b/RecoTracker/MkFit/interface/MkFitEventOfHits.h @@ -0,0 +1,36 @@ +#ifndef RecoTracker_MkFit_MkFitEventOfHits_h +#define RecoTracker_MkFit_MkFitEventOfHits_h + +#include + +namespace mkfit { + class EventOfHits; +} + +/** + * The mkfit::EventOfHits is a container of mkfit::LayerOfHits + * structures that mkFit uses to group (and index) hits. Having them + * grouped together allows mkFit to pass them easily around top-level + * steering functions. + * + * It has some conceptual similarities to MeasurementTrackerEvent. + */ +class MkFitEventOfHits { +public: + MkFitEventOfHits(); + MkFitEventOfHits(std::unique_ptr); + ~MkFitEventOfHits(); + + MkFitEventOfHits(MkFitEventOfHits const&) = delete; + MkFitEventOfHits& operator=(MkFitEventOfHits const&) = delete; + MkFitEventOfHits(MkFitEventOfHits&&); + MkFitEventOfHits& operator=(MkFitEventOfHits&&); + + mkfit::EventOfHits& get() { return *eventOfHits_; } + mkfit::EventOfHits const& get() const { return *eventOfHits_; } + +private: + std::unique_ptr eventOfHits_; +}; + +#endif diff --git a/RecoTracker/MkFit/interface/MkFitGeometry.h b/RecoTracker/MkFit/interface/MkFitGeometry.h index 928d9b13b8891..1fe5b6447580e 100644 --- a/RecoTracker/MkFit/interface/MkFitGeometry.h +++ b/RecoTracker/MkFit/interface/MkFitGeometry.h @@ -1,6 +1,8 @@ #ifndef RecoTracker_MkFit_MkFitGeometry_h #define RecoTracker_MkFit_MkFitGeometry_h +#include "DataFormats/DetId/interface/DetId.h" + #include #include #include @@ -28,6 +30,7 @@ class MkFitGeometry { std::unique_ptr iterationsInfo); ~MkFitGeometry(); + int mkFitLayerNumber(DetId detId) const; mkfit::LayerNumberConverter const& layerNumberConverter() const { return *lnc_; } mkfit::TrackerInfo const& trackerInfo() const { return *trackerInfo_; } mkfit::IterationsInfo const& iterationsInfo() const { return *iterationsInfo_; } @@ -35,6 +38,7 @@ class MkFitGeometry { unsigned int uniqueIdInLayer(int layer, unsigned int detId) const { return detIdToShortId_.at(layer).at(detId); } private: + const TrackerTopology* ttopo_; std::unique_ptr lnc_; // for pimpl pattern std::unique_ptr trackerInfo_; std::unique_ptr iterationsInfo_; // only temporarily here, to be moved into proper place later diff --git a/RecoTracker/MkFit/interface/MkFitHitWrapper.h b/RecoTracker/MkFit/interface/MkFitHitWrapper.h index 241c58864e87e..c45f634f9925f 100644 --- a/RecoTracker/MkFit/interface/MkFitHitWrapper.h +++ b/RecoTracker/MkFit/interface/MkFitHitWrapper.h @@ -7,8 +7,6 @@ #include namespace mkfit { - class EventOfHits; - class TrackerInfo; class Hit; using HitVec = std::vector; } // namespace mkfit @@ -16,7 +14,6 @@ namespace mkfit { class MkFitHitWrapper { public: MkFitHitWrapper(); - MkFitHitWrapper(mkfit::TrackerInfo const& trackerInfo); ~MkFitHitWrapper(); MkFitHitWrapper(MkFitHitWrapper const&) = delete; @@ -24,37 +21,16 @@ class MkFitHitWrapper { MkFitHitWrapper(MkFitHitWrapper&&); MkFitHitWrapper& operator=(MkFitHitWrapper&&); - mkfit::EventOfHits& eventOfHits() { return *eventOfHits_; } - mkfit::EventOfHits const& eventOfHits() const { return *eventOfHits_; } + void setClustersID(edm::ProductID id) { clustersID_ = id; } + edm::ProductID clustersID() const { return clustersID_; } - void setPixelClustersID(edm::ProductID id) { pixelClustersID_ = id; } - edm::ProductID pixelClustersID() const { return pixelClustersID_; } - - void setOuterClustersID(edm::ProductID id) { outerClustersID_ = id; } - edm::ProductID outerClustersID() const { return outerClustersID_; } - - mkfit::HitVec& pixelHits() { return *pixelHits_; } - mkfit::HitVec const& pixelHits() const { return *pixelHits_; } - - mkfit::HitVec& outerHits() { return *outerHits_; } - mkfit::HitVec const& outerHits() const { return *outerHits_; } - - std::vector& stripClusterCharge() { return stripClusterCharge_; } - void stripClusterChargeCut(float minThreshold, std::vector& mask) const; + mkfit::HitVec& hits() { return hits_; } + mkfit::HitVec const& hits() const { return hits_; } private: - std::unique_ptr eventOfHits_; - - // using unique_ptr to guarantee the address of the HitVec doesn't change in moves - // EvenfOfHits relies on that - // Vectors are indexed by the cluster index - std::unique_ptr pixelHits_; - std::unique_ptr outerHits_; - - std::vector stripClusterCharge_; - - edm::ProductID pixelClustersID_; - edm::ProductID outerClustersID_; + // Vector is indexed by the cluster index + mkfit::HitVec hits_; + edm::ProductID clustersID_; }; #endif diff --git a/RecoTracker/MkFit/plugins/BuildFile.xml b/RecoTracker/MkFit/plugins/BuildFile.xml index 386f8e2a12ab9..b8ec556c28544 100644 --- a/RecoTracker/MkFit/plugins/BuildFile.xml +++ b/RecoTracker/MkFit/plugins/BuildFile.xml @@ -6,6 +6,7 @@ + diff --git a/RecoTracker/MkFit/plugins/MkFitEventOfHitsProducer.cc b/RecoTracker/MkFit/plugins/MkFitEventOfHitsProducer.cc new file mode 100644 index 0000000000000..270bce35fe048 --- /dev/null +++ b/RecoTracker/MkFit/plugins/MkFitEventOfHitsProducer.cc @@ -0,0 +1,86 @@ +#include "FWCore/Framework/interface/global/EDProducer.h" + +#include "FWCore/Framework/interface/Event.h" +#include "FWCore/Framework/interface/MakerMacros.h" +#include "FWCore/ParameterSet/interface/ParameterSet.h" + +#include "DataFormats/TrackingRecHit/interface/TrackingRecHit.h" + +#include "RecoTracker/MkFit/interface/MkFitClusterIndexToHit.h" +#include "RecoTracker/MkFit/interface/MkFitEventOfHits.h" +#include "RecoTracker/MkFit/interface/MkFitGeometry.h" +#include "RecoTracker/MkFit/interface/MkFitHitWrapper.h" +#include "RecoTracker/Record/interface/TrackerRecoGeometryRecord.h" + +// mkFit includes +#include "mkFit/HitStructures.h" +#include "mkFit/MkStdSeqs.h" + +class MkFitEventOfHitsProducer : public edm::global::EDProducer<> { +public: + explicit MkFitEventOfHitsProducer(edm::ParameterSet const& iConfig); + ~MkFitEventOfHitsProducer() override = default; + + static void fillDescriptions(edm::ConfigurationDescriptions& descriptions); + +private: + void produce(edm::StreamID, edm::Event& iEvent, const edm::EventSetup& iSetup) const override; + + void fill(const std::vector& hits, + mkfit::EventOfHits& eventOfHits, + const MkFitGeometry& mkFitGeom) const; + + const edm::EDGetTokenT pixelHitsToken_; + const edm::EDGetTokenT stripHitsToken_; + const edm::EDGetTokenT pixelClusterIndexToHitToken_; + const edm::EDGetTokenT stripClusterIndexToHitToken_; + const edm::ESGetToken mkFitGeomToken_; + const edm::EDPutTokenT putToken_; +}; + +MkFitEventOfHitsProducer::MkFitEventOfHitsProducer(edm::ParameterSet const& iConfig) + : pixelHitsToken_{consumes(iConfig.getParameter("pixelHits"))}, + stripHitsToken_{consumes(iConfig.getParameter("stripHits"))}, + pixelClusterIndexToHitToken_{consumes(iConfig.getParameter("pixelHits"))}, + stripClusterIndexToHitToken_{consumes(iConfig.getParameter("stripHits"))}, + mkFitGeomToken_{esConsumes()}, + putToken_{produces()} {} + +void MkFitEventOfHitsProducer::fillDescriptions(edm::ConfigurationDescriptions& descriptions) { + edm::ParameterSetDescription desc; + + desc.add("pixelHits", edm::InputTag{"mkFitSiPixelHits"}); + desc.add("stripHits", edm::InputTag{"mkFitSiStripHits"}); + + descriptions.addWithDefaultLabel(desc); +} + +void MkFitEventOfHitsProducer::produce(edm::StreamID iID, edm::Event& iEvent, const edm::EventSetup& iSetup) const { + const auto& pixelHits = iEvent.get(pixelHitsToken_); + const auto& stripHits = iEvent.get(stripHitsToken_); + const auto& mkFitGeom = iSetup.getData(mkFitGeomToken_); + + auto eventOfHits = std::make_unique(mkFitGeom.trackerInfo()); + mkfit::StdSeq::Cmssw_LoadHits_Begin(*eventOfHits, {&pixelHits.hits(), &stripHits.hits()}); + + fill(iEvent.get(pixelClusterIndexToHitToken_).hits(), *eventOfHits, mkFitGeom); + fill(iEvent.get(stripClusterIndexToHitToken_).hits(), *eventOfHits, mkFitGeom); + + mkfit::StdSeq::Cmssw_LoadHits_End(*eventOfHits); + + iEvent.emplace(putToken_, std::move(eventOfHits)); +} + +void MkFitEventOfHitsProducer::fill(const std::vector& hits, + mkfit::EventOfHits& eventOfHits, + const MkFitGeometry& mkFitGeom) const { + for (int i = 0, end = hits.size(); i < end; ++i) { + const auto* hit = hits[i]; + if (hit != nullptr) { + const auto ilay = mkFitGeom.mkFitLayerNumber(hit->geographicalId()); + eventOfHits[ilay].RegisterHit(i); + } + } +} + +DEFINE_FWK_MODULE(MkFitEventOfHitsProducer); diff --git a/RecoTracker/MkFit/plugins/MkFitHitConverter.cc b/RecoTracker/MkFit/plugins/MkFitHitConverter.cc deleted file mode 100644 index 80d9952fc089a..0000000000000 --- a/RecoTracker/MkFit/plugins/MkFitHitConverter.cc +++ /dev/null @@ -1,262 +0,0 @@ -#include "FWCore/Framework/interface/global/EDProducer.h" - -#include "FWCore/Framework/interface/Event.h" -#include "FWCore/Framework/interface/MakerMacros.h" -#include "FWCore/ParameterSet/interface/ParameterSet.h" -#include "FWCore/Utilities/interface/Likely.h" - -#include "DataFormats/Provenance/interface/ProductID.h" -#include "DataFormats/SiStripCluster/interface/SiStripClusterTools.h" -#include "DataFormats/TrajectorySeed/interface/TrajectorySeed.h" -#include "DataFormats/TrackerRecHit2D/interface/SiPixelRecHitCollection.h" -#include "DataFormats/TrackerRecHit2D/interface/SiStripRecHit2DCollection.h" -#include "DataFormats/TrackerRecHit2D/interface/trackerHitRTTI.h" - -#include "DataFormats/TrackerCommon/interface/TrackerTopology.h" -#include "DataFormats/TrackerCommon/interface/TrackerDetSide.h" -#include "Geometry/Records/interface/TrackerTopologyRcd.h" - -#include "TrackingTools/Records/interface/TransientRecHitRecord.h" -#include "TrackingTools/TransientTrackingRecHit/interface/TransientTrackingRecHitBuilder.h" -#include "TrackingTools/TrajectoryState/interface/TrajectoryStateTransform.h" - -#include "RecoTracker/MkFit/interface/MkFitHitWrapper.h" -#include "RecoTracker/MkFit/interface/MkFitClusterIndexToHit.h" -#include "RecoTracker/MkFit/interface/MkFitGeometry.h" -#include "RecoTracker/Record/interface/TrackerRecoGeometryRecord.h" - -// ROOT -#include "Math/SVector.h" -#include "Math/SMatrix.h" - -// mkFit includes -#include "Hit.h" -#include "LayerNumberConverter.h" -#include "mkFit/HitStructures.h" -#include "mkFit/MkStdSeqs.h" - -class MkFitHitConverter : public edm::global::EDProducer<> { -public: - explicit MkFitHitConverter(edm::ParameterSet const& iConfig); - ~MkFitHitConverter() override = default; - - static void fillDescriptions(edm::ConfigurationDescriptions& descriptions); - -private: - void produce(edm::StreamID, edm::Event& iEvent, const edm::EventSetup& iSetup) const override; - - template - edm::ProductID convertHits(const HitCollection& hits, - mkfit::EventOfHits& mkFitEventOfHits, - mkfit::HitVec& mkFitHits, - std::vector& clusterIndexToHit, - std::vector& clusterChargeVec, - const TrackerTopology& ttopo, - const TransientTrackingRecHitBuilder& ttrhBuilder, - const MkFitGeometry& mkFitGeom) const; - - float clusterCharge(const SiStripRecHit2D& hit, DetId hitId) const; - std::nullptr_t clusterCharge(const SiPixelRecHit& hit, DetId hitId) const; - - bool passCCC(float charge) const; - bool passCCC(std::nullptr_t) const; //pixel - - void setDetails(mkfit::Hit& mhit, const SiPixelCluster& cluster, const int shortId, std::nullptr_t) const; - void setDetails(mkfit::Hit& mhit, const SiStripCluster& cluster, const int shortId, float charge) const; - - using SVector3 = ROOT::Math::SVector; - using SMatrixSym33 = ROOT::Math::SMatrix>; - using SMatrixSym66 = ROOT::Math::SMatrix>; - - edm::EDGetTokenT pixelRecHitToken_; - edm::EDGetTokenT stripRphiRecHitToken_; - edm::EDGetTokenT stripStereoRecHitToken_; - edm::ESGetToken ttrhBuilderToken_; - edm::ESGetToken ttopoToken_; - edm::ESGetToken mkFitGeomToken_; - edm::EDPutTokenT wrapperPutToken_; - edm::EDPutTokenT clusterIndexPutToken_; - const float minGoodStripCharge_; -}; - -MkFitHitConverter::MkFitHitConverter(edm::ParameterSet const& iConfig) - : pixelRecHitToken_{consumes(iConfig.getParameter("pixelRecHits"))}, - stripRphiRecHitToken_{ - consumes(iConfig.getParameter("stripRphiRecHits"))}, - stripStereoRecHitToken_{ - consumes(iConfig.getParameter("stripStereoRecHits"))}, - ttrhBuilderToken_{esConsumes( - iConfig.getParameter("ttrhBuilder"))}, - ttopoToken_{esConsumes()}, - mkFitGeomToken_{esConsumes()}, - wrapperPutToken_{produces()}, - clusterIndexPutToken_{produces()}, - minGoodStripCharge_{static_cast( - iConfig.getParameter("minGoodStripCharge").getParameter("value"))} {} - -void MkFitHitConverter::fillDescriptions(edm::ConfigurationDescriptions& descriptions) { - edm::ParameterSetDescription desc; - - desc.add("pixelRecHits", edm::InputTag{"siPixelRecHits"}); - desc.add("stripRphiRecHits", edm::InputTag{"siStripMatchedRecHits", "rphiRecHit"}); - desc.add("stripStereoRecHits", edm::InputTag{"siStripMatchedRecHits", "stereoRecHit"}); - desc.add("ttrhBuilder", edm::ESInputTag{"", "WithTrackAngle"}); - - edm::ParameterSetDescription descCCC; - descCCC.add("value"); - desc.add("minGoodStripCharge", descCCC); - - descriptions.add("mkFitHitConverterDefault", desc); -} - -void MkFitHitConverter::produce(edm::StreamID iID, edm::Event& iEvent, const edm::EventSetup& iSetup) const { - // Then import hits - const auto& ttrhBuilder = iSetup.getData(ttrhBuilderToken_); - const auto& ttopo = iSetup.getData(ttopoToken_); - const auto& mkFitGeom = iSetup.getData(mkFitGeomToken_); - - MkFitHitWrapper hitWrapper{mkFitGeom.trackerInfo()}; - mkfit::StdSeq::Cmssw_LoadHits_Begin(hitWrapper.eventOfHits(), {&hitWrapper.pixelHits(), &hitWrapper.outerHits()}); - - MkFitClusterIndexToHit clusterIndexToHit; - - auto convert = [&](auto& hits, auto& mkFitHits, auto& clusterIndexToHit, auto& clusterCharge) { - return convertHits( - hits, hitWrapper.eventOfHits(), mkFitHits, clusterIndexToHit, clusterCharge, ttopo, ttrhBuilder, mkFitGeom); - }; - std::vector dummy; - auto pixelClusterID = - convert(iEvent.get(pixelRecHitToken_), hitWrapper.pixelHits(), clusterIndexToHit.pixelHits(), dummy); - - edm::ProductID stripClusterID; - const auto& stripRphiHits = iEvent.get(stripRphiRecHitToken_); - const auto& stripStereoHits = iEvent.get(stripStereoRecHitToken_); - if (not stripRphiHits.empty()) { - stripClusterID = - convert(stripRphiHits, hitWrapper.outerHits(), clusterIndexToHit.outerHits(), hitWrapper.stripClusterCharge()); - } - if (not stripStereoHits.empty()) { - auto stripStereoClusterID = convert( - stripStereoHits, hitWrapper.outerHits(), clusterIndexToHit.outerHits(), hitWrapper.stripClusterCharge()); - if (stripRphiHits.empty()) { - stripClusterID = stripStereoClusterID; - } else if (stripClusterID != stripStereoClusterID) { - throw cms::Exception("LogicError") << "Encountered different cluster ProductIDs for strip RPhi hits (" - << stripClusterID << ") and stereo (" << stripStereoClusterID << ")"; - } - } - hitWrapper.setPixelClustersID(pixelClusterID); - hitWrapper.setOuterClustersID(stripClusterID); - - mkfit::StdSeq::Cmssw_LoadHits_End(hitWrapper.eventOfHits()); - - iEvent.emplace(wrapperPutToken_, std::move(hitWrapper)); - iEvent.emplace(clusterIndexPutToken_, std::move(clusterIndexToHit)); -} - -float MkFitHitConverter::clusterCharge(const SiStripRecHit2D& hit, DetId hitId) const { - return siStripClusterTools::chargePerCM(hitId, hit.firstClusterRef().stripCluster()); -} -std::nullptr_t MkFitHitConverter::clusterCharge(const SiPixelRecHit& hit, DetId hitId) const { return nullptr; } - -bool MkFitHitConverter::passCCC(float charge) const { return charge > minGoodStripCharge_; } - -bool MkFitHitConverter::passCCC(std::nullptr_t) const { return true; } - -void MkFitHitConverter::setDetails(mkfit::Hit& mhit, const SiPixelCluster& cluster, int shortId, std::nullptr_t) const { - mhit.setupAsPixel(shortId, cluster.sizeX(), cluster.sizeY()); -} - -void MkFitHitConverter::setDetails(mkfit::Hit& mhit, const SiStripCluster& cluster, int shortId, float charge) const { - mhit.setupAsStrip(shortId, charge, cluster.amplitudes().size()); -} - -template -edm::ProductID MkFitHitConverter::convertHits(const HitCollection& hits, - mkfit::EventOfHits& mkFitEventOfHits, - mkfit::HitVec& mkFitHits, - std::vector& clusterIndexToHit, - std::vector& clusterChargeVec, - const TrackerTopology& ttopo, - const TransientTrackingRecHitBuilder& ttrhBuilder, - const MkFitGeometry& mkFitGeom) const { - if (hits.empty()) - return edm::ProductID{}; - auto isPlusSide = [&ttopo](const DetId& detid) { - return ttopo.side(detid) == static_cast(TrackerDetSide::PosEndcap); - }; - - constexpr bool applyCCC = std::is_same_v; - - edm::ProductID clusterID; - { - const auto& lastClusterRef = hits.data().back().firstClusterRef(); - clusterID = lastClusterRef.id(); - if (lastClusterRef.index() >= mkFitHits.size()) { - auto const size = lastClusterRef.index(); - mkFitHits.resize(size); - clusterIndexToHit.resize(size, nullptr); - if constexpr (applyCCC) { - clusterChargeVec.resize(size, -1.f); - } - } - } - - for (const auto& detset : hits) { - const DetId detid = detset.detId(); - const auto subdet = detid.subdetId(); - const auto layer = ttopo.layer(detid); - const auto isStereo = ttopo.isStereo(detid); - const auto ilay = - mkFitGeom.layerNumberConverter().convertLayerNumber(subdet, layer, false, isStereo, isPlusSide(detid)); - - for (const auto& hit : detset) { - const auto charge = clusterCharge(hit, detid); - if (!passCCC(charge)) - continue; - - const auto& gpos = hit.globalPosition(); - SVector3 pos(gpos.x(), gpos.y(), gpos.z()); - const auto& gerr = hit.globalPositionError(); - SMatrixSym33 err; - err.At(0, 0) = gerr.cxx(); - err.At(1, 1) = gerr.cyy(); - err.At(2, 2) = gerr.czz(); - err.At(0, 1) = gerr.cyx(); - err.At(0, 2) = gerr.czx(); - err.At(1, 2) = gerr.czy(); - - auto clusterRef = hit.firstClusterRef(); - if UNLIKELY (clusterRef.id() != clusterID) { - throw cms::Exception("LogicError") - << "Input hit collection has Refs to many cluster collections. Last hit had Ref to product " << clusterID - << ", but encountered Ref to product " << clusterRef.id() << " on detid " << detid.rawId(); - } - const auto clusterIndex = clusterRef.index(); - LogTrace("MkFitHitConverter") << "Adding hit detid " << detid.rawId() << " subdet " << subdet << " layer " - << layer << " isStereo " << isStereo << " zplus " << isPlusSide(detid) << " index " - << clusterIndex << " ilay " << ilay; - - if UNLIKELY (clusterIndex >= mkFitHits.size()) { - mkFitHits.resize(clusterIndex + 1); - clusterIndexToHit.resize(clusterIndex + 1, nullptr); - if constexpr (applyCCC) { - clusterChargeVec.resize(clusterIndex + 1, -1.f); - } - } - mkFitHits[clusterIndex] = mkfit::Hit(pos, err); - clusterIndexToHit[clusterIndex] = &hit; - if constexpr (applyCCC) { - clusterChargeVec[clusterIndex] = charge; - } - - const auto uniqueIdInLayer = mkFitGeom.uniqueIdInLayer(ilay, detid.rawId()); - setDetails(mkFitHits[clusterIndex], *(hit.cluster()), uniqueIdInLayer, charge); - - mkFitEventOfHits[ilay].RegisterHit(clusterIndex); - } - } - return clusterID; -} - -DEFINE_FWK_MODULE(MkFitHitConverter); diff --git a/RecoTracker/MkFit/plugins/MkFitOutputConverter.cc b/RecoTracker/MkFit/plugins/MkFitOutputConverter.cc index e6c567d9f580a..735034c6d1cda 100644 --- a/RecoTracker/MkFit/plugins/MkFitOutputConverter.cc +++ b/RecoTracker/MkFit/plugins/MkFitOutputConverter.cc @@ -29,7 +29,7 @@ #include "RecoTracker/TransientTrackingRecHit/interface/TkTransientTrackingRecHitBuilder.h" #include "TrackingTools/MaterialEffects/src/PropagatorWithMaterial.cc" -#include "RecoTracker/MkFit/interface/MkFitHitWrapper.h" +#include "RecoTracker/MkFit/interface/MkFitEventOfHits.h" #include "RecoTracker/MkFit/interface/MkFitClusterIndexToHit.h" #include "RecoTracker/MkFit/interface/MkFitSeedWrapper.h" #include "RecoTracker/MkFit/interface/MkFitOutputWrapper.h" @@ -67,7 +67,8 @@ class MkFitOutputConverter : public edm::global::EDProducer<> { TrackCandidateCollection convertCandidates(const MkFitOutputWrapper& mkFitOutput, const mkfit::EventOfHits& eventOfHits, - const MkFitClusterIndexToHit& clusterIndexToHit, + const MkFitClusterIndexToHit& pixelClusterIndexToHit, + const MkFitClusterIndexToHit& stripClusterIndexToHit, const edm::View& seeds, const MagneticField& mf, const Propagator& propagatorAlong, @@ -89,27 +90,29 @@ class MkFitOutputConverter : public edm::global::EDProducer<> { const Propagator& propagatorAlong, const Propagator& propagatorOpposite) const; - const edm::EDGetTokenT mkfitHitToken_; - const edm::EDGetTokenT clusterIndexToHitToken_; + const edm::EDGetTokenT eventOfHitsToken_; + const edm::EDGetTokenT pixelClusterIndexToHitToken_; + const edm::EDGetTokenT stripClusterIndexToHitToken_; const edm::EDGetTokenT mkfitSeedToken_; - edm::EDGetTokenT tracksToken_; - edm::EDGetTokenT> seedToken_; - edm::ESGetToken propagatorAlongToken_; - edm::ESGetToken propagatorOppositeToken_; - edm::ESGetToken mfToken_; - edm::ESGetToken ttrhBuilderToken_; + const edm::EDGetTokenT tracksToken_; + const edm::EDGetTokenT> seedToken_; + const edm::ESGetToken propagatorAlongToken_; + const edm::ESGetToken propagatorOppositeToken_; + const edm::ESGetToken mfToken_; + const edm::ESGetToken ttrhBuilderToken_; const edm::ESGetToken mkFitGeomToken_; - edm::EDPutTokenT putTrackCandidateToken_; - edm::EDPutTokenT> putSeedStopInfoToken_; - std::string ttrhBuilderName_; - std::string propagatorAlongName_; - std::string propagatorOppositeName_; + const edm::EDPutTokenT putTrackCandidateToken_; + const edm::EDPutTokenT> putSeedStopInfoToken_; + const std::string ttrhBuilderName_; + const std::string propagatorAlongName_; + const std::string propagatorOppositeName_; }; MkFitOutputConverter::MkFitOutputConverter(edm::ParameterSet const& iConfig) - : mkfitHitToken_{consumes(iConfig.getParameter("mkfitHits"))}, - clusterIndexToHitToken_{consumes(iConfig.getParameter("mkfitHits"))}, - mkfitSeedToken_{consumes(iConfig.getParameter("mkfitSeeds"))}, + : eventOfHitsToken_{consumes(iConfig.getParameter("mkFitEventOfHits"))}, + pixelClusterIndexToHitToken_{consumes(iConfig.getParameter("mkFitPixelHits"))}, + stripClusterIndexToHitToken_{consumes(iConfig.getParameter("mkFitStripHits"))}, + mkfitSeedToken_{consumes(iConfig.getParameter("mkFitSeeds"))}, tracksToken_{consumes(iConfig.getParameter("tracks"))}, seedToken_{consumes>(iConfig.getParameter("seeds"))}, propagatorAlongToken_{ @@ -126,8 +129,10 @@ MkFitOutputConverter::MkFitOutputConverter(edm::ParameterSet const& iConfig) void MkFitOutputConverter::fillDescriptions(edm::ConfigurationDescriptions& descriptions) { edm::ParameterSetDescription desc; - desc.add("mkfitHits", edm::InputTag{"mkFitHits"}); - desc.add("mkfitSeeds", edm::InputTag{"mkFitSeedConverter"}); + desc.add("mkFitEventOfHits", edm::InputTag{"mkFitEventOfHits"}); + desc.add("mkFitPixelHits", edm::InputTag{"mkFitSiPixelHits"}); + desc.add("mkFitStripHits", edm::InputTag{"mkFitSiStripHits"}); + desc.add("mkFitSeeds", edm::InputTag{"mkFitSeedConverter"}); desc.add("tracks", edm::InputTag{"mkFitProducer"}); desc.add("seeds", edm::InputTag{"initialStepSeeds"}); desc.add("ttrhBuilder", edm::ESInputTag{"", "WithTrackAngle"}); @@ -151,8 +156,9 @@ void MkFitOutputConverter::produce(edm::StreamID iID, edm::Event& iEvent, const // Convert mkfit presentation back to CMSSW iEvent.emplace(putTrackCandidateToken_, convertCandidates(iEvent.get(tracksToken_), - iEvent.get(mkfitHitToken_).eventOfHits(), - iEvent.get(clusterIndexToHitToken_), + iEvent.get(eventOfHitsToken_).get(), + iEvent.get(pixelClusterIndexToHitToken_), + iEvent.get(stripClusterIndexToHitToken_), seeds, iSetup.getData(mfToken_), iSetup.getData(propagatorAlongToken_), @@ -167,7 +173,8 @@ void MkFitOutputConverter::produce(edm::StreamID iID, edm::Event& iEvent, const TrackCandidateCollection MkFitOutputConverter::convertCandidates(const MkFitOutputWrapper& mkFitOutput, const mkfit::EventOfHits& eventOfHits, - const MkFitClusterIndexToHit& clusterIndexToHit, + const MkFitClusterIndexToHit& pixelClusterIndexToHit, + const MkFitClusterIndexToHit& stripClusterIndexToHit, const edm::View& seeds, const MagneticField& mf, const Propagator& propagatorAlong, @@ -218,7 +225,7 @@ TrackCandidateCollection MkFitOutputConverter::convertCandidates(const MkFitOutp lastHitInvalid = true; } else { auto const isPixel = eventOfHits[hitOnTrack.layer].is_pix_lyr(); - auto const& hits = isPixel ? clusterIndexToHit.pixelHits() : clusterIndexToHit.outerHits(); + auto const& hits = isPixel ? pixelClusterIndexToHit.hits() : stripClusterIndexToHit.hits(); auto const& thit = static_cast(*hits[hitOnTrack.index]); if (thit.firstClusterRef().isPixel() || thit.detUnit()->type().isEndcap()) { diff --git a/RecoTracker/MkFit/plugins/MkFitProducer.cc b/RecoTracker/MkFit/plugins/MkFitProducer.cc index 53585f92729a8..4d2aa849d6863 100644 --- a/RecoTracker/MkFit/plugins/MkFitProducer.cc +++ b/RecoTracker/MkFit/plugins/MkFitProducer.cc @@ -10,6 +10,7 @@ #include "DataFormats/SiPixelCluster/interface/SiPixelCluster.h" #include "DataFormats/SiStripCluster/interface/SiStripClusterfwd.h" +#include "RecoTracker/MkFit/interface/MkFitEventOfHits.h" #include "RecoTracker/MkFit/interface/MkFitHitWrapper.h" #include "RecoTracker/MkFit/interface/MkFitSeedWrapper.h" #include "RecoTracker/MkFit/interface/MkFitOutputWrapper.h" @@ -29,7 +30,7 @@ // std includes #include -class MkFitProducer : public edm::global::EDProducer > { +class MkFitProducer : public edm::global::EDProducer> { public: explicit MkFitProducer(edm::ParameterSet const& iConfig); ~MkFitProducer() override = default; @@ -41,10 +42,15 @@ class MkFitProducer : public edm::global::EDProducer hitToken_; + void stripClusterChargeCut(const std::vector& stripClusterCharge, std::vector& mask) const; + + const edm::EDGetTokenT pixelHitsToken_; + const edm::EDGetTokenT stripHitsToken_; + const edm::EDGetTokenT> stripClusterChargeToken_; + const edm::EDGetTokenT eventOfHitsToken_; const edm::EDGetTokenT seedToken_; - edm::EDGetTokenT > > pixelMaskToken_; - edm::EDGetTokenT > > stripMaskToken_; + edm::EDGetTokenT>> pixelMaskToken_; + edm::EDGetTokenT>> stripMaskToken_; const edm::ESGetToken mkFitGeomToken_; const edm::ESGetToken mkFitIterConfigToken_; const edm::EDPutTokenT putToken_; @@ -58,7 +64,10 @@ class MkFitProducer : public edm::global::EDProducer("hits"))}, + : pixelHitsToken_{consumes(iConfig.getParameter("pixelHits"))}, + stripHitsToken_{consumes(iConfig.getParameter("stripHits"))}, + stripClusterChargeToken_{consumes(iConfig.getParameter("stripHits"))}, + eventOfHitsToken_{consumes(iConfig.getParameter("eventOfHits"))}, seedToken_{consumes(iConfig.getParameter("seeds"))}, mkFitGeomToken_{esConsumes()}, mkFitIterConfigToken_{esConsumes(iConfig.getParameter("config"))}, @@ -98,7 +107,9 @@ MkFitProducer::MkFitProducer(edm::ParameterSet const& iConfig) void MkFitProducer::fillDescriptions(edm::ConfigurationDescriptions& descriptions) { edm::ParameterSetDescription desc; - desc.add("hits", edm::InputTag("mkFitHits")); + desc.add("pixelHits", edm::InputTag("mkFitSiPixelHits")); + desc.add("stripHits", edm::InputTag("mkFitSiStripHits")); + desc.add("eventOfHits", edm::InputTag("mkFitEventOfHits")); desc.add("seeds", edm::InputTag("mkFitSeedConverter")); desc.add("clustersToSkip", edm::InputTag()); desc.add("buildingRoutine", "cloneEngine") @@ -130,7 +141,9 @@ namespace { std::once_flag geometryFlag; } void MkFitProducer::produce(edm::StreamID iID, edm::Event& iEvent, const edm::EventSetup& iSetup) const { - const auto& hits = iEvent.get(hitToken_); + const auto& pixelHits = iEvent.get(pixelHitsToken_); + const auto& stripHits = iEvent.get(stripHitsToken_); + const auto& eventOfHits = iEvent.get(eventOfHitsToken_); const auto& seeds = iEvent.get(seedToken_); // This producer does not strictly speaking need the MkFitGeometry, // but the ESProducer sets global variables (yes, that "feature" @@ -142,25 +155,25 @@ void MkFitProducer::produce(edm::StreamID iID, edm::Event& iEvent, const edm::Ev const std::vector* pixelMaskPtr = nullptr; std::vector pixelMask; - std::vector stripMask(hits.outerHits().size(), false); + std::vector stripMask(stripHits.hits().size(), false); if (not pixelMaskToken_.isUninitialized()) { const auto& pixelContainerMask = iEvent.get(pixelMaskToken_); pixelMask.resize(pixelContainerMask.size(), false); - if UNLIKELY (pixelContainerMask.refProd().id() != hits.pixelClustersID()) { - throw cms::Exception("LogicError") << "MkFitHitWrapper has pixel cluster ID " << hits.pixelClustersID() + if UNLIKELY (pixelContainerMask.refProd().id() != pixelHits.clustersID()) { + throw cms::Exception("LogicError") << "MkFitHitWrapper has pixel cluster ID " << pixelHits.clustersID() << " but pixel cluster mask has " << pixelContainerMask.refProd().id(); } pixelContainerMask.copyMaskTo(pixelMask); pixelMaskPtr = &pixelMask; const auto& stripContainerMask = iEvent.get(stripMaskToken_); - if UNLIKELY (stripContainerMask.refProd().id() != hits.outerClustersID()) { - throw cms::Exception("LogicError") << "MkFitHitWrapper has strip cluster ID " << hits.outerClustersID() + if UNLIKELY (stripContainerMask.refProd().id() != stripHits.clustersID()) { + throw cms::Exception("LogicError") << "MkFitHitWrapper has strip cluster ID " << stripHits.clustersID() << " but strip cluster mask has " << stripContainerMask.refProd().id(); } stripContainerMask.copyMaskTo(stripMask); } else { - hits.stripClusterChargeCut(minGoodStripCharge_, stripMask); + stripClusterChargeCut(iEvent.get(stripClusterChargeToken_), stripMask); } // Initialize the number of layers, has to be done exactly once in @@ -177,7 +190,7 @@ void MkFitProducer::produce(edm::StreamID iID, edm::Event& iEvent, const edm::Ev auto lambda = [&]() { mkfit::run_OneIteration(mkFitGeom.trackerInfo(), mkFitIterConfig, - hits.eventOfHits(), + eventOfHits.get(), {pixelMaskPtr, &stripMask}, streamCache(iID)->get(), seeds_mutable, @@ -197,4 +210,15 @@ void MkFitProducer::produce(edm::StreamID iID, edm::Event& iEvent, const edm::Ev iEvent.emplace(putToken_, std::move(tracks), not backwardFitInCMSSW_); } +void MkFitProducer::stripClusterChargeCut(const std::vector& stripClusterCharge, std::vector& mask) const { + if (mask.size() != stripClusterCharge.size()) { + throw cms::Exception("LogicError") << "Mask size (" << mask.size() << ") inconsistent with number of hits (" + << stripClusterCharge.size() << ")"; + } + for (int i = 0, end = stripClusterCharge.size(); i < end; ++i) { + // mask == true means skip the cluster + mask[i] = mask[i] || (stripClusterCharge[i] <= minGoodStripCharge_); + } +} + DEFINE_FWK_MODULE(MkFitProducer); diff --git a/RecoTracker/MkFit/plugins/MkFitSiPixelHitConverter.cc b/RecoTracker/MkFit/plugins/MkFitSiPixelHitConverter.cc new file mode 100644 index 0000000000000..39d14c66c2d1c --- /dev/null +++ b/RecoTracker/MkFit/plugins/MkFitSiPixelHitConverter.cc @@ -0,0 +1,91 @@ +#include "FWCore/Framework/interface/global/EDProducer.h" + +#include "FWCore/Framework/interface/Event.h" +#include "FWCore/Framework/interface/MakerMacros.h" +#include "FWCore/ParameterSet/interface/ParameterSet.h" + +#include "DataFormats/TrackerRecHit2D/interface/SiPixelRecHitCollection.h" + +#include "Geometry/Records/interface/TrackerTopologyRcd.h" + +#include "TrackingTools/Records/interface/TransientRecHitRecord.h" + +#include "RecoTracker/MkFit/interface/MkFitHitWrapper.h" +#include "RecoTracker/MkFit/interface/MkFitClusterIndexToHit.h" +#include "RecoTracker/MkFit/interface/MkFitGeometry.h" +#include "RecoTracker/Record/interface/TrackerRecoGeometryRecord.h" + +#include "convertHits.h" + +namespace { + struct ConvertHitTraits { + static constexpr bool applyCCC() { return false; } + static std::nullptr_t clusterCharge(const SiPixelRecHit& hit, DetId hitId) { return nullptr; } + static bool passCCC(std::nullptr_t) { return true; } + static void setDetails(mkfit::Hit& mhit, const SiPixelCluster& cluster, int shortId, std::nullptr_t) { + mhit.setupAsPixel(shortId, cluster.sizeX(), cluster.sizeY()); + } + }; +} // namespace + +class MkFitSiPixelHitConverter : public edm::global::EDProducer<> { +public: + explicit MkFitSiPixelHitConverter(edm::ParameterSet const& iConfig); + ~MkFitSiPixelHitConverter() override = default; + + static void fillDescriptions(edm::ConfigurationDescriptions& descriptions); + +private: + void produce(edm::StreamID, edm::Event& iEvent, const edm::EventSetup& iSetup) const override; + + const edm::EDGetTokenT pixelRecHitToken_; + const edm::ESGetToken ttrhBuilderToken_; + const edm::ESGetToken ttopoToken_; + const edm::ESGetToken mkFitGeomToken_; + const edm::EDPutTokenT wrapperPutToken_; + const edm::EDPutTokenT clusterIndexPutToken_; +}; + +MkFitSiPixelHitConverter::MkFitSiPixelHitConverter(edm::ParameterSet const& iConfig) + : pixelRecHitToken_{consumes(iConfig.getParameter("hits"))}, + ttrhBuilderToken_{esConsumes( + iConfig.getParameter("ttrhBuilder"))}, + ttopoToken_{esConsumes()}, + mkFitGeomToken_{esConsumes()}, + wrapperPutToken_{produces()}, + clusterIndexPutToken_{produces()} {} + +void MkFitSiPixelHitConverter::fillDescriptions(edm::ConfigurationDescriptions& descriptions) { + edm::ParameterSetDescription desc; + + desc.add("hits", edm::InputTag{"siPixelRecHits"}); + desc.add("ttrhBuilder", edm::ESInputTag{"", "WithTrackAngle"}); + + descriptions.addWithDefaultLabel(desc); +} + +void MkFitSiPixelHitConverter::produce(edm::StreamID iID, edm::Event& iEvent, const edm::EventSetup& iSetup) const { + const auto& ttrhBuilder = iSetup.getData(ttrhBuilderToken_); + const auto& ttopo = iSetup.getData(ttopoToken_); + const auto& mkFitGeom = iSetup.getData(mkFitGeomToken_); + + MkFitHitWrapper hitWrapper; + MkFitClusterIndexToHit clusterIndexToHit; + + std::vector dummy; + auto pixelClusterID = mkfit::convertHits(ConvertHitTraits{}, + iEvent.get(pixelRecHitToken_), + hitWrapper.hits(), + clusterIndexToHit.hits(), + dummy, + ttopo, + ttrhBuilder, + mkFitGeom); + + hitWrapper.setClustersID(pixelClusterID); + + iEvent.emplace(wrapperPutToken_, std::move(hitWrapper)); + iEvent.emplace(clusterIndexPutToken_, std::move(clusterIndexToHit)); +} + +DEFINE_FWK_MODULE(MkFitSiPixelHitConverter); diff --git a/RecoTracker/MkFit/plugins/MkFitSiStripHitConverter.cc b/RecoTracker/MkFit/plugins/MkFitSiStripHitConverter.cc new file mode 100644 index 0000000000000..d15dff6788f59 --- /dev/null +++ b/RecoTracker/MkFit/plugins/MkFitSiStripHitConverter.cc @@ -0,0 +1,125 @@ +#include "FWCore/Framework/interface/global/EDProducer.h" + +#include "FWCore/Framework/interface/Event.h" +#include "FWCore/Framework/interface/MakerMacros.h" +#include "FWCore/ParameterSet/interface/ParameterSet.h" + +#include "DataFormats/SiStripCluster/interface/SiStripClusterTools.h" +#include "DataFormats/TrackerRecHit2D/interface/SiStripRecHit2DCollection.h" + +#include "Geometry/Records/interface/TrackerTopologyRcd.h" + +#include "TrackingTools/Records/interface/TransientRecHitRecord.h" + +#include "RecoTracker/MkFit/interface/MkFitHitWrapper.h" +#include "RecoTracker/MkFit/interface/MkFitClusterIndexToHit.h" +#include "RecoTracker/MkFit/interface/MkFitGeometry.h" +#include "RecoTracker/Record/interface/TrackerRecoGeometryRecord.h" + +#include "convertHits.h" + +namespace { + class ConvertHitTraits { + public: + ConvertHitTraits(float minCharge) : minGoodStripCharge_(minCharge) {} + + static constexpr bool applyCCC() { return true; } + static float clusterCharge(const SiStripRecHit2D& hit, DetId hitId) { + return siStripClusterTools::chargePerCM(hitId, hit.firstClusterRef().stripCluster()); + } + bool passCCC(float charge) const { return charge > minGoodStripCharge_; } + static void setDetails(mkfit::Hit& mhit, const SiStripCluster& cluster, int shortId, float charge) { + mhit.setupAsStrip(shortId, charge, cluster.amplitudes().size()); + } + + private: + const float minGoodStripCharge_; + }; +} // namespace + +class MkFitSiStripHitConverter : public edm::global::EDProducer<> { +public: + explicit MkFitSiStripHitConverter(edm::ParameterSet const& iConfig); + ~MkFitSiStripHitConverter() override = default; + + static void fillDescriptions(edm::ConfigurationDescriptions& descriptions); + +private: + void produce(edm::StreamID, edm::Event& iEvent, const edm::EventSetup& iSetup) const override; + + const edm::EDGetTokenT stripRphiRecHitToken_; + const edm::EDGetTokenT stripStereoRecHitToken_; + const edm::ESGetToken ttrhBuilderToken_; + const edm::ESGetToken ttopoToken_; + const edm::ESGetToken mkFitGeomToken_; + const edm::EDPutTokenT wrapperPutToken_; + const edm::EDPutTokenT clusterIndexPutToken_; + const edm::EDPutTokenT> clusterChargePutToken_; + const ConvertHitTraits convertTraits_; +}; + +MkFitSiStripHitConverter::MkFitSiStripHitConverter(edm::ParameterSet const& iConfig) + : stripRphiRecHitToken_{consumes(iConfig.getParameter("rphiHits"))}, + stripStereoRecHitToken_{consumes(iConfig.getParameter("stereoHits"))}, + ttrhBuilderToken_{esConsumes( + iConfig.getParameter("ttrhBuilder"))}, + ttopoToken_{esConsumes()}, + mkFitGeomToken_{esConsumes()}, + wrapperPutToken_{produces()}, + clusterIndexPutToken_{produces()}, + clusterChargePutToken_{produces>()}, + convertTraits_{static_cast( + iConfig.getParameter("minGoodStripCharge").getParameter("value"))} {} + +void MkFitSiStripHitConverter::fillDescriptions(edm::ConfigurationDescriptions& descriptions) { + edm::ParameterSetDescription desc; + + desc.add("rphiHits", edm::InputTag{"siStripMatchedRecHits", "rphiRecHit"}); + desc.add("stereoHits", edm::InputTag{"siStripMatchedRecHits", "stereoRecHit"}); + desc.add("ttrhBuilder", edm::ESInputTag{"", "WithTrackAngle"}); + + edm::ParameterSetDescription descCCC; + descCCC.add("value"); + desc.add("minGoodStripCharge", descCCC); + + descriptions.add("mkFitSiStripHitConverterDefault", desc); +} + +void MkFitSiStripHitConverter::produce(edm::StreamID iID, edm::Event& iEvent, const edm::EventSetup& iSetup) const { + const auto& ttrhBuilder = iSetup.getData(ttrhBuilderToken_); + const auto& ttopo = iSetup.getData(ttopoToken_); + const auto& mkFitGeom = iSetup.getData(mkFitGeomToken_); + + MkFitHitWrapper hitWrapper; + MkFitClusterIndexToHit clusterIndexToHit; + std::vector clusterCharge; + + auto convert = [&](auto& hits) { + return mkfit::convertHits( + convertTraits_, hits, hitWrapper.hits(), clusterIndexToHit.hits(), clusterCharge, ttopo, ttrhBuilder, mkFitGeom); + }; + + edm::ProductID stripClusterID; + const auto& stripRphiHits = iEvent.get(stripRphiRecHitToken_); + const auto& stripStereoHits = iEvent.get(stripStereoRecHitToken_); + if (not stripRphiHits.empty()) { + stripClusterID = convert(stripRphiHits); + } + if (not stripStereoHits.empty()) { + auto stripStereoClusterID = convert(stripStereoHits); + if (stripRphiHits.empty()) { + stripClusterID = stripStereoClusterID; + } else if (stripClusterID != stripStereoClusterID) { + throw cms::Exception("LogicError") << "Encountered different cluster ProductIDs for strip RPhi hits (" + << stripClusterID << ") and stereo (" << stripStereoClusterID << ")"; + } + } + + hitWrapper.setClustersID(stripClusterID); + + iEvent.emplace(wrapperPutToken_, std::move(hitWrapper)); + iEvent.emplace(clusterIndexPutToken_, std::move(clusterIndexToHit)); + iEvent.emplace(clusterChargePutToken_, std::move(clusterCharge)); +} + +DEFINE_FWK_MODULE(MkFitSiStripHitConverter); diff --git a/RecoTracker/MkFit/plugins/convertHits.h b/RecoTracker/MkFit/plugins/convertHits.h new file mode 100644 index 0000000000000..f016b43b0fb0a --- /dev/null +++ b/RecoTracker/MkFit/plugins/convertHits.h @@ -0,0 +1,103 @@ +#ifndef RecoTracker_MkFit_plugins_convertHits_h +#define RecoTracker_MkFit_plugins_convertHits_h + +#include "DataFormats/Provenance/interface/ProductID.h" + +#include "FWCore/Utilities/interface/Likely.h" + +#include "DataFormats/TrackerCommon/interface/TrackerTopology.h" +#include "DataFormats/TrackerCommon/interface/TrackerDetSide.h" + +#include "TrackingTools/TransientTrackingRecHit/interface/TransientTrackingRecHitBuilder.h" + +#include "RecoTracker/MkFit/interface/MkFitGeometry.h" + +// ROOT +#include "Math/SVector.h" +#include "Math/SMatrix.h" + +// mkFit includes +#include "Hit.h" +#include "mkFit/HitStructures.h" + +namespace mkfit { + template + edm::ProductID convertHits(const Traits& traits, + const HitCollection& hits, + mkfit::HitVec& mkFitHits, + std::vector& clusterIndexToHit, + std::vector& clusterChargeVec, + const TrackerTopology& ttopo, + const TransientTrackingRecHitBuilder& ttrhBuilder, + const MkFitGeometry& mkFitGeom) { + if (hits.empty()) + return edm::ProductID{}; + + edm::ProductID clusterID; + { + const auto& lastClusterRef = hits.data().back().firstClusterRef(); + clusterID = lastClusterRef.id(); + if (lastClusterRef.index() >= mkFitHits.size()) { + auto const size = lastClusterRef.index(); + mkFitHits.resize(size); + clusterIndexToHit.resize(size, nullptr); + if constexpr (Traits::applyCCC()) { + clusterChargeVec.resize(size, -1.f); + } + } + } + + for (const auto& detset : hits) { + const DetId detid = detset.detId(); + const auto ilay = mkFitGeom.mkFitLayerNumber(detid); + + for (const auto& hit : detset) { + const auto charge = traits.clusterCharge(hit, detid); + if (!traits.passCCC(charge)) + continue; + + const auto& gpos = hit.globalPosition(); + SVector3 pos(gpos.x(), gpos.y(), gpos.z()); + const auto& gerr = hit.globalPositionError(); + SMatrixSym33 err; + err.At(0, 0) = gerr.cxx(); + err.At(1, 1) = gerr.cyy(); + err.At(2, 2) = gerr.czz(); + err.At(0, 1) = gerr.cyx(); + err.At(0, 2) = gerr.czx(); + err.At(1, 2) = gerr.czy(); + + auto clusterRef = hit.firstClusterRef(); + if UNLIKELY (clusterRef.id() != clusterID) { + throw cms::Exception("LogicError") + << "Input hit collection has Refs to many cluster collections. Last hit had Ref to product " << clusterID + << ", but encountered Ref to product " << clusterRef.id() << " on detid " << detid.rawId(); + } + const auto clusterIndex = clusterRef.index(); + LogTrace("MkFitHitConverter") << "Adding hit detid " << detid.rawId() << " subdet " << detid.subdetId() + << " layer " << ttopo.layer(detid) << " isStereo " << ttopo.isStereo(detid) + << " zplus " + << " index " << clusterIndex << " ilay " << ilay; + + if UNLIKELY (clusterIndex >= mkFitHits.size()) { + mkFitHits.resize(clusterIndex + 1); + clusterIndexToHit.resize(clusterIndex + 1, nullptr); + if constexpr (Traits::applyCCC()) { + clusterChargeVec.resize(clusterIndex + 1, -1.f); + } + } + mkFitHits[clusterIndex] = mkfit::Hit(pos, err); + clusterIndexToHit[clusterIndex] = &hit; + if constexpr (Traits::applyCCC()) { + clusterChargeVec[clusterIndex] = charge; + } + + const auto uniqueIdInLayer = mkFitGeom.uniqueIdInLayer(ilay, detid.rawId()); + traits.setDetails(mkFitHits[clusterIndex], *(hit.cluster()), uniqueIdInLayer, charge); + } + } + return clusterID; + } +} // namespace mkfit + +#endif diff --git a/RecoTracker/MkFit/python/customizeHLTIter0ToMkFit.py b/RecoTracker/MkFit/python/customizeHLTIter0ToMkFit.py index 9a34552e64e48..01b59acd67816 100644 --- a/RecoTracker/MkFit/python/customizeHLTIter0ToMkFit.py +++ b/RecoTracker/MkFit/python/customizeHLTIter0ToMkFit.py @@ -1,7 +1,9 @@ import FWCore.ParameterSet.Config as cms import RecoTracker.MkFit.mkFitGeometryESProducer_cfi as mkFitGeometryESProducer_cfi -import RecoTracker.MkFit.mkFitHitConverter_cfi as mkFitHitConverter_cfi +import RecoTracker.MkFit.mkFitSiPixelHitConverter_cfi as mkFitSiPixelHitConverter_cfi +import RecoTracker.MkFit.mkFitSiStripHitConverter_cfi as mkFitSiStripHitConverter_cfi +import RecoTracker.MkFit.mkFitEventOfHitsProducer_cfi as mkFitEventOfHitsProducer_cfi import RecoTracker.MkFit.mkFitSeedConverter_cfi as mkFitSeedConverter_cfi import RecoTracker.MkFit.mkFitIterationConfigESProducer_cfi as mkFitIterationConfigESProducer_cfi import RecoTracker.MkFit.mkFitProducer_cfi as mkFitProducer_cfi @@ -23,13 +25,20 @@ def customizeHLTIter0ToMkFit(process): process.hltMkFitGeometryESProducer = mkFitGeometryESProducer_cfi.mkFitGeometryESProducer.clone() - process.hltIter0PFlowCkfTrackCandidatesMkFitHits = mkFitHitConverter_cfi.mkFitHitConverter.clone( - pixelRecHits = "hltSiPixelRecHits", - stripRphiRecHits = "hltSiStripRecHits:rphiRecHit", - stripStereoRecHits = "hltSiStripRecHits:stereoRecHit", + process.hltIter0PFlowCkfTrackCandidatesMkFitSiPixelHits = mkFitSiPixelHitConverter_cfi.mkFitSiPixelHitConverter.clone( + hits = "hltSiPixelRecHits", + ttrhBuilder = ":hltESPTTRHBWithTrackAngle", + ) + process.hltIter0PFlowCkfTrackCandidatesMkFitSiStripHits = mkFitSiStripHitConverter_cfi.mkFitSiStripHitConverter.clone( + rphiHits = "hltSiStripRecHits:rphiRecHit", + stereoHits = "hltSiStripRecHits:stereoRecHit", ttrhBuilder = ":hltESPTTRHBWithTrackAngle", minGoodStripCharge = dict(refToPSet_ = 'HLTSiStripClusterChargeCutLoose'), ) + process.hltIter0PFlowCkfTrackCandidatesMkFitEventOfHits = mkFitEventOfHitsProducer_cfi.mkFitEventOfHitsProducer.clone( + pixelHits = "hltIter0PFlowCkfTrackCandidatesMkFitSiPixelHits", + stripHits = "hltIter0PFlowCkfTrackCandidatesMkFitSiStripHits", + ) process.hltIter0PFlowCkfTrackCandidatesMkFitSeeds = mkFitSeedConverter_cfi.mkFitSeedConverter.clone( seeds = "hltIter0PFLowPixelSeedsFromPixelTracks", ttrhBuilder = ":hltESPTTRHBWithTrackAngle", @@ -39,15 +48,19 @@ def customizeHLTIter0ToMkFit(process): config = 'RecoTracker/MkFit/data/mkfit-phase1-initialStep.json', ) process.hltIter0PFlowCkfTrackCandidatesMkFit = mkFitProducer_cfi.mkFitProducer.clone( - hits = "hltIter0PFlowCkfTrackCandidatesMkFitHits", + pixelHits = "hltIter0PFlowCkfTrackCandidatesMkFitSiPixelHits", + stripHits = "hltIter0PFlowCkfTrackCandidatesMkFitSiStripHits", + eventOfHits = "hltIter0PFlowCkfTrackCandidatesMkFitEventOfHits", seeds = "hltIter0PFlowCkfTrackCandidatesMkFitSeeds", config = ('', 'hltIter0PFlowTrackCandidatesMkFitConfig'), minGoodStripCharge = dict(refToPSet_ = 'HLTSiStripClusterChargeCutLoose'), ) process.hltIter0PFlowCkfTrackCandidates = mkFitOutputConverter_cfi.mkFitOutputConverter.clone( seeds = "hltIter0PFLowPixelSeedsFromPixelTracks", - mkfitHits = "hltIter0PFlowCkfTrackCandidatesMkFitHits", - mkfitSeeds = "hltIter0PFlowCkfTrackCandidatesMkFitSeeds", + mkFitEventOfHits = "hltIter0PFlowCkfTrackCandidatesMkFitEventOfHits", + mkFitPixelHits = "hltIter0PFlowCkfTrackCandidatesMkFitSiPixelHits", + mkFitStripHits = "hltIter0PFlowCkfTrackCandidatesMkFitSiStripHits", + mkFitSeeds = "hltIter0PFlowCkfTrackCandidatesMkFitSeeds", tracks = "hltIter0PFlowCkfTrackCandidatesMkFit", ttrhBuilder = ":hltESPTTRHBWithTrackAngle", propagatorAlong = ":PropagatorWithMaterialParabolicMf", @@ -56,6 +69,11 @@ def customizeHLTIter0ToMkFit(process): process.HLTDoLocalStripSequence += process.hltSiStripRecHits process.HLTIterativeTrackingIteration0.replace(process.hltIter0PFlowCkfTrackCandidates, - process.hltIter0PFlowCkfTrackCandidatesMkFitHits+process.hltIter0PFlowCkfTrackCandidatesMkFitSeeds+process.hltIter0PFlowCkfTrackCandidatesMkFit+process.hltIter0PFlowCkfTrackCandidates) + process.hltIter0PFlowCkfTrackCandidatesMkFitSiPixelHits + + process.hltIter0PFlowCkfTrackCandidatesMkFitSiStripHits + + process.hltIter0PFlowCkfTrackCandidatesMkFitEventOfHits + + process.hltIter0PFlowCkfTrackCandidatesMkFitSeeds + + process.hltIter0PFlowCkfTrackCandidatesMkFit + + process.hltIter0PFlowCkfTrackCandidates) return process diff --git a/RecoTracker/MkFit/python/mkFitSiStripHitConverter_cfi.py b/RecoTracker/MkFit/python/mkFitSiStripHitConverter_cfi.py new file mode 100644 index 0000000000000..5f189b4b3fcb5 --- /dev/null +++ b/RecoTracker/MkFit/python/mkFitSiStripHitConverter_cfi.py @@ -0,0 +1,9 @@ +import FWCore.ParameterSet.Config as cms + +from RecoTracker.MkFit.mkFitSiStripHitConverterDefault_cfi import mkFitSiStripHitConverterDefault as _mkFitSiStripHitConverterDefault +from RecoLocalTracker.SiStripClusterizer.SiStripClusterChargeCut_cfi import * + +mkFitSiStripHitConverter = _mkFitSiStripHitConverterDefault.clone( + minGoodStripCharge = cms.PSet( + refToPSet_ = cms.string('SiStripClusterChargeCutLoose')) +) diff --git a/RecoTracker/MkFit/src/MkFitEventOfHits.cc b/RecoTracker/MkFit/src/MkFitEventOfHits.cc new file mode 100644 index 0000000000000..72b6c98345dae --- /dev/null +++ b/RecoTracker/MkFit/src/MkFitEventOfHits.cc @@ -0,0 +1,11 @@ +#include "RecoTracker/MkFit/interface/MkFitEventOfHits.h" + +// mkFit includes +#include "mkFit/HitStructures.h" + +MkFitEventOfHits::MkFitEventOfHits() = default; +MkFitEventOfHits::MkFitEventOfHits(std::unique_ptr eoh) : eventOfHits_(std::move(eoh)) {} +MkFitEventOfHits::~MkFitEventOfHits() = default; + +MkFitEventOfHits::MkFitEventOfHits(MkFitEventOfHits&&) = default; +MkFitEventOfHits& MkFitEventOfHits::operator=(MkFitEventOfHits&&) = default; diff --git a/RecoTracker/MkFit/src/MkFitGeometry.cc b/RecoTracker/MkFit/src/MkFitGeometry.cc index 51dc72bcde30c..fe004dea6e1dd 100644 --- a/RecoTracker/MkFit/src/MkFitGeometry.cc +++ b/RecoTracker/MkFit/src/MkFitGeometry.cc @@ -9,12 +9,19 @@ #include "TrackerInfo.h" #include "mkFit/IterationConfig.h" +namespace { + bool isPlusSide(const TrackerTopology& ttopo, DetId detid) { + return ttopo.side(detid) == static_cast(TrackerDetSide::PosEndcap); + } +} // namespace + MkFitGeometry::MkFitGeometry(const TrackerGeometry& geom, const GeometricSearchTracker& tracker, const TrackerTopology& ttopo, std::unique_ptr trackerInfo, std::unique_ptr iterationsInfo) - : lnc_{std::make_unique(mkfit::TkLayout::phase1)}, + : ttopo_(&ttopo), + lnc_{std::make_unique(mkfit::TkLayout::phase1)}, trackerInfo_(std::move(trackerInfo)), iterationsInfo_(std::move(iterationsInfo)) { if (geom.numberOfLayers(PixelSubdetector::PixelBarrel) != 4 || @@ -24,12 +31,8 @@ MkFitGeometry::MkFitGeometry(const TrackerGeometry& geom, // Create DetLayer structure dets_.resize(lnc_->nLayers(), nullptr); - auto isPlusSide = [&ttopo](const DetId& detid) { - return ttopo.side(detid) == static_cast(TrackerDetSide::PosEndcap); - }; - auto setDet = [this, &isPlusSide]( - const int subdet, const int layer, const int isStereo, const DetId& detId, const DetLayer* lay) { - const int index = lnc_->convertLayerNumber(subdet, layer, false, isStereo, isPlusSide(detId)); + auto setDet = [this](const int subdet, const int layer, const int isStereo, const DetId& detId, const DetLayer* lay) { + const int index = lnc_->convertLayerNumber(subdet, layer, false, isStereo, isPlusSide(*ttopo_, detId)); if (index < 0 or static_cast(index) >= dets_.size()) { throw cms::Exception("LogicError") << "Invalid mkFit layer index " << index << " for DetId " << detId.rawId() << " subdet " << subdet << " layer " << layer << " isStereo " << isStereo; @@ -60,8 +63,7 @@ MkFitGeometry::MkFitGeometry(const TrackerGeometry& geom, // Create "short id" aka "unique id within layer" detIdToShortId_.resize(lnc_->nLayers()); for (const auto& detId : geom.detIds()) { - const auto ilay = - lnc_->convertLayerNumber(detId.subdetId(), ttopo.layer(detId), false, ttopo.isStereo(detId), isPlusSide(detId)); + const auto ilay = mkFitLayerNumber(detId); auto& map = detIdToShortId_[ilay]; const unsigned int ind = map.size(); // Make sure the short id fits in the 12 bits... @@ -73,3 +75,8 @@ MkFitGeometry::MkFitGeometry(const TrackerGeometry& geom, // Explicit out-of-line because of the mkfit::LayerNumberConverter is // only forward declared in the header MkFitGeometry::~MkFitGeometry() {} + +int MkFitGeometry::mkFitLayerNumber(DetId detId) const { + return lnc_->convertLayerNumber( + detId.subdetId(), ttopo_->layer(detId), false, ttopo_->isStereo(detId), isPlusSide(*ttopo_, detId)); +} diff --git a/RecoTracker/MkFit/src/MkFitHitWrapper.cc b/RecoTracker/MkFit/src/MkFitHitWrapper.cc index e5f7f8d63c712..ebef4972f777b 100644 --- a/RecoTracker/MkFit/src/MkFitHitWrapper.cc +++ b/RecoTracker/MkFit/src/MkFitHitWrapper.cc @@ -6,25 +6,7 @@ #include "mkFit/HitStructures.h" MkFitHitWrapper::MkFitHitWrapper() = default; -MkFitHitWrapper::MkFitHitWrapper(mkfit::TrackerInfo const& trackerInfo) - : eventOfHits_(std::make_unique(trackerInfo)), - pixelHits_(std::make_unique()), - outerHits_(std::make_unique()) {} - MkFitHitWrapper::~MkFitHitWrapper() = default; MkFitHitWrapper::MkFitHitWrapper(MkFitHitWrapper&&) = default; MkFitHitWrapper& MkFitHitWrapper::operator=(MkFitHitWrapper&&) = default; - -void MkFitHitWrapper::stripClusterChargeCut(float minThreshold, std::vector& mask) const { - if (mask.size() != stripClusterCharge_.size()) { - cms::Exception e("LogicError"); - e << "Mask size (" << mask.size() << ") inconsistent with number of hits (" << stripClusterCharge_.size() << ")"; - e.addContext("Calling MkFitHitWraper::applyStripClusterCharge()"); - throw e; - } - for (int i = 0, end = stripClusterCharge_.size(); i < end; ++i) { - // mask == true means skip the cluster - mask[i] = mask[i] || (stripClusterCharge_[i] <= minThreshold); - } -} diff --git a/RecoTracker/MkFit/src/classes.h b/RecoTracker/MkFit/src/classes.h index 0579533564d3d..0aa6883c3c69f 100644 --- a/RecoTracker/MkFit/src/classes.h +++ b/RecoTracker/MkFit/src/classes.h @@ -3,6 +3,7 @@ #include "DataFormats/Common/interface/Wrapper.h" #include "RecoTracker/MkFit/interface/MkFitHitWrapper.h" +#include "RecoTracker/MkFit/interface/MkFitEventOfHits.h" #include "RecoTracker/MkFit/interface/MkFitClusterIndexToHit.h" #include "RecoTracker/MkFit/interface/MkFitSeedWrapper.h" #include "RecoTracker/MkFit/interface/MkFitOutputWrapper.h" diff --git a/RecoTracker/MkFit/src/classes_def.xml b/RecoTracker/MkFit/src/classes_def.xml index 8ee51da8a9958..d241cc1bb03e8 100644 --- a/RecoTracker/MkFit/src/classes_def.xml +++ b/RecoTracker/MkFit/src/classes_def.xml @@ -2,6 +2,9 @@ + + + diff --git a/Validation/RecoTrack/python/plotting/trackingPlots.py b/Validation/RecoTrack/python/plotting/trackingPlots.py index cb606304ae9f0..24bdd0c21a86d 100644 --- a/Validation/RecoTrack/python/plotting/trackingPlots.py +++ b/Validation/RecoTrack/python/plotting/trackingPlots.py @@ -1478,7 +1478,9 @@ def modules(self): "caloTowerForTrk", "ak4CaloJetsForTrk", "firstStepPrimaryVertices", - "mkFitHits"]), + "mkFitSiPixelHits", + "mkFitSiStripHits", + "mkFitEventOfHits"]), Iteration("highPtTripletStep", selection=["highPtTripletStepClassifier1", "highPtTripletStepClassifier2",