Split MkFitHitProducer to MkFitSi{Pixel,Strip}HitConverter and MkFitE…

…ventOfHitsProducer

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).

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',
 ))
 

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',
 ))
 

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',
 ))
 

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()

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',
 ))
 

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',
 ))
 

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',
 ))
 

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',
 ))
 

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',
 ))
 

RecoTracker/MkFit/interface/MkFitClusterIndexToHit.h

@@ -9,16 +9,12 @@ class MkFitClusterIndexToHit {
 public:
   MkFitClusterIndexToHit() = default;
 
-  std::vector<TrackingRecHit const *> &pixelHits() { return pixelHits_; }
-  std::vector<TrackingRecHit const *> const &pixelHits() const { return pixelHits_; }
-
-  std::vector<TrackingRecHit const *> &outerHits() { return outerHits_; }
-  std::vector<TrackingRecHit const *> const &outerHits() const { return outerHits_; }
+  std::vector<TrackingRecHit const*>& hits() { return hits_; }
+  std::vector<TrackingRecHit const*> const& hits() const { return hits_; }
 
 private:
   // Indexed by cluster index
-  std::vector<TrackingRecHit const *> pixelHits_;
-  std::vector<TrackingRecHit const *> outerHits_;
+  std::vector<TrackingRecHit const*> hits_;
 };
 
 #endif

RecoTracker/MkFit/interface/MkFitEventOfHits.h

@@ -0,0 +1,36 @@
+#ifndef RecoTracker_MkFit_MkFitEventOfHits_h
+#define RecoTracker_MkFit_MkFitEventOfHits_h
+
+#include <memory>
+
+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<mkfit::EventOfHits>);
+  ~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<mkfit::EventOfHits> eventOfHits_;
+};
+
+#endif

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 <memory>
 #include <unordered_map>
 #include <vector>
@@ -28,13 +30,15 @@ class MkFitGeometry {
                          std::unique_ptr<mkfit::IterationsInfo> 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_; }
   const std::vector<const DetLayer*>& detLayers() const { return dets_; }
   unsigned int uniqueIdInLayer(int layer, unsigned int detId) const { return detIdToShortId_.at(layer).at(detId); }
 
 private:
+  const TrackerTopology* ttopo_;
   std::unique_ptr<mkfit::LayerNumberConverter> lnc_;  // for pimpl pattern
   std::unique_ptr<mkfit::TrackerInfo> trackerInfo_;
   std::unique_ptr<mkfit::IterationsInfo> iterationsInfo_;  // only temporarily here, to be moved into proper place later

RecoTracker/MkFit/interface/MkFitHitWrapper.h

@@ -7,54 +7,30 @@
 #include <vector>
 
 namespace mkfit {
-  class EventOfHits;
-  class TrackerInfo;
   class Hit;
   using HitVec = std::vector<Hit>;
 }  // namespace mkfit
 
 class MkFitHitWrapper {
 public:
   MkFitHitWrapper();
-  MkFitHitWrapper(mkfit::TrackerInfo const& trackerInfo);
   ~MkFitHitWrapper();
 
   MkFitHitWrapper(MkFitHitWrapper const&) = delete;
   MkFitHitWrapper& operator=(MkFitHitWrapper const&) = delete;
   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<float>& stripClusterCharge() { return stripClusterCharge_; }
-  void stripClusterChargeCut(float minThreshold, std::vector<bool>& mask) const;
+  mkfit::HitVec& hits() { return hits_; }
+  mkfit::HitVec const& hits() const { return hits_; }
 
 private:
-  std::unique_ptr<mkfit::EventOfHits> 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<mkfit::HitVec> pixelHits_;
-  std::unique_ptr<mkfit::HitVec> outerHits_;
-
-  std::vector<float> stripClusterCharge_;
-
-  edm::ProductID pixelClustersID_;
-  edm::ProductID outerClustersID_;
+  // Vector is indexed by the cluster index
+  mkfit::HitVec hits_;
+  edm::ProductID clustersID_;
 };
 
 #endif

RecoTracker/MkFit/plugins/BuildFile.xml

@@ -6,6 +6,7 @@
   <use name="DataFormats/TrackReco"/>
   <use name="DataFormats/TrackerCommon"/>
   <use name="DataFormats/TrackerRecHit2D"/>
+  <use name="DataFormats/TrackingRecHit"/>
   <use name="DataFormats/TrajectorySeed"/>
   <use name="FWCore/Framework"/>
   <use name="FWCore/ParameterSet"/>

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<const TrackingRecHit*>& hits,
+            mkfit::EventOfHits& eventOfHits,
+            const MkFitGeometry& mkFitGeom) const;
+
+  const edm::EDGetTokenT<MkFitHitWrapper> pixelHitsToken_;
+  const edm::EDGetTokenT<MkFitHitWrapper> stripHitsToken_;
+  const edm::EDGetTokenT<MkFitClusterIndexToHit> pixelClusterIndexToHitToken_;
+  const edm::EDGetTokenT<MkFitClusterIndexToHit> stripClusterIndexToHitToken_;
+  const edm::ESGetToken<MkFitGeometry, TrackerRecoGeometryRecord> mkFitGeomToken_;
+  const edm::EDPutTokenT<MkFitEventOfHits> putToken_;
+};
+
+MkFitEventOfHitsProducer::MkFitEventOfHitsProducer(edm::ParameterSet const& iConfig)
+    : pixelHitsToken_{consumes(iConfig.getParameter<edm::InputTag>("pixelHits"))},
+      stripHitsToken_{consumes(iConfig.getParameter<edm::InputTag>("stripHits"))},
+      pixelClusterIndexToHitToken_{consumes(iConfig.getParameter<edm::InputTag>("pixelHits"))},
+      stripClusterIndexToHitToken_{consumes(iConfig.getParameter<edm::InputTag>("stripHits"))},
+      mkFitGeomToken_{esConsumes()},
+      putToken_{produces<MkFitEventOfHits>()} {}
+
+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<mkfit::EventOfHits>(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<const TrackingRecHit*>& 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);