Support for Phase2 initialStep in CMSSW

Configuration/PyReleaseValidation/python/relval_2026.py

@@ -26,6 +26,7 @@
 numWFIB.extend([24434.0]) #2026D97
 numWFIB.extend([24834.0,24834.911,24834.103]) #2026D98 DDD XML, DD4hep XML, aging
 numWFIB.extend([25061.97]) #2026D98 premixing stage1 (NuGun+PU)
+numWFIB.extend([24834.702]) #2026D98 mkFit tracking (initialStep)
 numWFIB.extend([24834.5,24834.9]) #2026D98 pixelTrackingOnly, vector hits
 numWFIB.extend([25034.99,25034.999]) #2026D98 premixing combined stage1+stage2 (ttbar+PU200, ttbar+PU50 for PR test)
 numWFIB.extend([24834.21,25034.21,25034.9921]) #2026D98 prodlike, prodlike PU, prodlike premix stage1+stage2

Configuration/PyReleaseValidation/python/upgradeWorkflowComponents.py

@@ -437,6 +437,28 @@ def condition_(self, fragment, stepList, key, hasHarvest):
     '--procModifiers': 'trackingMkFitDevel'
 }
 
+# mkFit for phase-2 initialStep tracking
+class UpgradeWorkflow_trackingMkFitPhase2(UpgradeWorkflowTracking):
+    def setup__(self, step, stepName, stepDict, k, properties):
+        if 'Reco' in step: stepDict[stepName][k] = merge([self.step3, stepDict[step][k]])
+    def condition_(self, fragment, stepList, key, hasHarvest):
+        return ('2026' in key)
+upgradeWFs['trackingMkFitPhase2'] = UpgradeWorkflow_trackingMkFitPhase2(
+    steps = [
+        'Reco',
+        'RecoFakeHLT',
+        'RecoGlobal',
+        'RecoNano',
+        'RecoNanoFakeHLT',
+    ],
+    PU = [],
+    suffix = '_trackingMkFitPhase2',
+    offset = 0.702,
+)
+upgradeWFs['trackingMkFitPhase2'].step3 = {
+    '--procModifiers': 'trackingMkFitCommon,trackingMkFitInitialStep'
+}
+
 #DeepCore seeding for JetCore iteration workflow
 class UpgradeWorkflow_seedingDeepCore(UpgradeWorkflow):
     def setup_(self, step, stepName, stepDict, k, properties):

RecoTracker/IterativeTracking/python/InitialStep_cff.py

@@ -234,12 +234,14 @@
 from RecoTracker.MkFit.mkFitGeometryESProducer_cfi import mkFitGeometryESProducer
 import RecoTracker.MkFit.mkFitSiPixelHitConverter_cfi as mkFitSiPixelHitConverter_cfi
 import RecoTracker.MkFit.mkFitSiStripHitConverter_cfi as mkFitSiStripHitConverter_cfi
+import RecoTracker.MkFit.mkFitPhase2HitConverter_cfi as mkFitPhase2HitConverter_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
 mkFitSiPixelHits = mkFitSiPixelHitConverter_cfi.mkFitSiPixelHitConverter.clone() # TODO: figure out better place for this module?
+mkFitSiPhase2Hits = mkFitPhase2HitConverter_cfi.mkFitPhase2HitConverter.clone()
 mkFitEventOfHits = mkFitEventOfHitsProducer_cfi.mkFitEventOfHitsProducer.clone() # TODO: figure out better place for this module?
 initialStepTrackCandidatesMkFitSeeds = mkFitSeedConverter_cfi.mkFitSeedConverter.clone(
     seeds = 'initialStepSeeds',
@@ -444,10 +446,14 @@
                            initialStep,caloJetsForTrkTask)
 InitialStep = cms.Sequence(InitialStepTask)
 
+from RecoLocalTracker.Phase2TrackerRecHits.Phase2TrackerRecHits_cfi import siPhase2RecHits
 from Configuration.ProcessModifiers.trackingMkFitCommon_cff import trackingMkFitCommon
 _InitialStepTask_trackingMkFitCommon = InitialStepTask.copy()
+_InitialStepTask_trackingMkFitCommon_Phase2 = InitialStepTask.copy()
 _InitialStepTask_trackingMkFitCommon.add(mkFitSiPixelHits, mkFitEventOfHits, mkFitGeometryESProducer)
-trackingMkFitCommon.toReplaceWith(InitialStepTask, _InitialStepTask_trackingMkFitCommon)
+_InitialStepTask_trackingMkFitCommon_Phase2.add(siPhase2RecHits, mkFitSiPixelHits, mkFitSiPhase2Hits, mkFitEventOfHits, mkFitGeometryESProducer)
+(trackingMkFitCommon & (~trackingPhase2PU140)).toReplaceWith(InitialStepTask, _InitialStepTask_trackingMkFitCommon)
+(trackingMkFitCommon & trackingPhase2PU140).toReplaceWith(InitialStepTask, _InitialStepTask_trackingMkFitCommon_Phase2)
 
 _InitialStepTask_trackingMkFit = InitialStepTask.copy()
 _InitialStepTask_trackingMkFit.add(initialStepTrackCandidatesMkFitSeeds, initialStepTrackCandidatesMkFit, initialStepTrackCandidatesMkFitConfig)
@@ -465,6 +471,10 @@
 _InitialStepTask_trackingPhase2.replace(initialStepHitTriplets, initialStepHitQuadruplets)
 _InitialStepTask_trackingPhase2.replace(initialStep, initialStepSelector)
 trackingPhase2PU140.toReplaceWith(InitialStepTask, _InitialStepTask_trackingPhase2)
+(trackingMkFitCommon & trackingPhase2PU140).toModify(mkFitEventOfHits, stripHits=cms.InputTag('mkFitSiPhase2Hits'), useStripStripQualityDB=cms.bool(False))
+(trackingMkFitInitialStep & trackingPhase2PU140).toModify(initialStepTrackCandidatesMkFit, stripHits=cms.InputTag('mkFitSiPhase2Hits'))
+(trackingMkFitInitialStep & trackingPhase2PU140).toModify(initialStepTrackCandidates, mkFitStripHits=cms.InputTag('mkFitSiPhase2Hits'))
+(trackingMkFitInitialStep & trackingPhase2PU140).toModify(initialStepTrackCandidatesMkFitConfig, config='RecoTracker/MkFit/data/mkfit-phase2-initialStep.json')
 
 from Configuration.Eras.Modifier_fastSim_cff import fastSim
 _InitialStepTask_fastSim = cms.Task(initialStepTrackingRegions

RecoTracker/MkFit/interface/MkFitGeometry.h

@@ -31,6 +31,8 @@ class MkFitGeometry {
 
   int mkFitLayerNumber(DetId detId) const;
   mkfit::LayerNumberConverter const& layerNumberConverter() const { return *lnc_; }
+  bool isPhase1() const;
+  bool isPhase2() const;
   mkfit::TrackerInfo const& trackerInfo() const { return *trackerInfo_; }
   const std::vector<const DetLayer*>& detLayers() const { return dets_; }
   unsigned int uniqueIdInLayer(int layer, unsigned int detId) const {

RecoTracker/MkFit/plugins/MkFitEventOfHitsProducer.cc

@@ -115,7 +115,7 @@ void MkFitEventOfHitsProducer::produce(edm::StreamID iID, edm::Event& iEvent, co
           deadvectors[ilay].push_back({surf.phiSpan().first, surf.phiSpan().second, q1, q2});
       }
     }
-
+    // For Phase-2, disable (momentarily?) SiStrip quality check
     if (useStripStripQualityDB_) {
       const auto& siStripQuality = iSetup.getData(stripQualityToken_);
       const auto& badStrips = siStripQuality.getBadComponentList();

RecoTracker/MkFit/plugins/MkFitGeometryESProducer.cc

@@ -195,7 +195,22 @@ void MkFitGeometryESProducer::fillShapeAndPlacement(const GeomDet *det,
                                                     mkfit::TrackerInfo &trk_info,
                                                     MaterialHistogram &material_histogram,
                                                     layer_gap_map_t *lgc_map) {
-  DetId detid = det->geographicalId();
+  const DetId detid = det->geographicalId();
+
+  bool doubleSide = false;  //double modules have double material
+  if (detid.subdetId() == SiStripSubdetector::TIB)
+    doubleSide = trackerTopo_->tibIsDoubleSide(detid);
+  else if (detid.subdetId() == SiStripSubdetector::TID)
+    doubleSide = trackerTopo_->tidIsDoubleSide(detid);
+  else if (detid.subdetId() == SiStripSubdetector::TOB)
+    doubleSide = trackerTopo_->tobIsDoubleSide(detid);
+  else if (detid.subdetId() == SiStripSubdetector::TEC)
+    doubleSide = trackerTopo_->tecIsDoubleSide(detid);
+
+  // Double-sided entries (join of two modules) are not used in mkFit and are
+  // also not needed for the material calculation.
+  if (doubleSide)
+    return;
 
   float xy[4][2];
   float half_length, dz;
@@ -248,11 +263,12 @@ void MkFitGeometryESProducer::fillShapeAndPlacement(const GeomDet *det,
                                       trackerTopo_->isStereo(detid),
                                       trackerTopo_->side(detid) == static_cast<unsigned>(TrackerDetSide::PosEndcap));
 #ifdef DUMP_MKF_GEO
-  printf("  subdet=%d layer=%d side=%d is_stereo=%d --> mkflayer=%d\n",
+  printf("  subdet=%d layer=%d side=%d is_stereo=%d is_double_side=%d --> mkflayer=%d\n",
          detid.subdetId(),
          trackerTopo_->layer(detid),
          trackerTopo_->side(detid),
          trackerTopo_->isStereo(detid),
+         doubleSide,
          lay);
 #endif
 
@@ -288,23 +304,15 @@ void MkFitGeometryESProducer::fillShapeAndPlacement(const GeomDet *det,
   layer_info.set_subdet(detid.subdetId());
   layer_info.set_is_pixel(detid.subdetId() <= 2);
   layer_info.set_is_stereo(trackerTopo_->isStereo(detid));
+  if (layerNrConv_.isPhase2() && !layer_info.is_pixel())
+    layer_info.set_has_charge(false);
 
-  bool doubleSide = false;  //double modules have double material
-  if (detid.subdetId() == SiStripSubdetector::TIB)
-    doubleSide = trackerTopo_->tibIsDoubleSide(detid);
-  else if (detid.subdetId() == SiStripSubdetector::TID)
-    doubleSide = trackerTopo_->tidIsDoubleSide(detid);
-  else if (detid.subdetId() == SiStripSubdetector::TOB)
-    doubleSide = trackerTopo_->tobIsDoubleSide(detid);
-  else if (detid.subdetId() == SiStripSubdetector::TEC)
-    doubleSide = trackerTopo_->tecIsDoubleSide(detid);
-
-  if (!doubleSide)  //fill material
+  // Fill material
   {
-    //module material
+    // module material
     const float bbxi = det->surface().mediumProperties().xi();
     const float radL = det->surface().mediumProperties().radLen();
-    //loop over bins to fill histogram with bbxi, radL and their weight, which the overlap surface in r-z with the cmsquare of a bin
+    // loop over bins to fill histogram with bbxi, radL and their weight, which the overlap surface in r-z with the cmsquare of a bin
     const float iBin = trk_info.mat_range_z() / trk_info.mat_nbins_z();
     const float jBin = trk_info.mat_range_r() / trk_info.mat_nbins_r();
     for (int i = std::floor(zbox_min / iBin); i < std::ceil(zbox_max / iBin); i++) {
@@ -534,7 +542,8 @@ std::unique_ptr<MkFitGeometry> MkFitGeometryESProducer::produce(const TrackerRec
 
   MaterialHistogram material_histogram(trackerInfo->mat_nbins_z(), trackerInfo->mat_nbins_r());
 
-  // This is sort of CMS-phase1 specific ... but fireworks code uses it for PhaseII as well.
+  // This works for both Phase1 and Phase2.
+  // Phase2 TrackerGeometry returns empty det-vectors for TIB and TEC.
   addPixBGeometry(*trackerInfo, material_histogram);
   addPixEGeometry(*trackerInfo, material_histogram);
   addTIBGeometry(*trackerInfo, material_histogram);

RecoTracker/MkFit/plugins/MkFitOutputConverter.cc

@@ -12,6 +12,7 @@
 #include "DataFormats/TrackReco/interface/SeedStopInfo.h"
 #include "DataFormats/TrackingRecHit/interface/InvalidTrackingRecHit.h"
 #include "DataFormats/TrackerRecHit2D/interface/SiStripRecHit1D.h"
+#include "DataFormats/TrackerRecHit2D/interface/Phase2TrackerRecHit1D.h"
 
 #include "TrackingTools/Records/interface/TransientRecHitRecord.h"
 #include "TrackingTools/TransientTrackingRecHit/interface/TransientTrackingRecHitBuilder.h"
@@ -81,6 +82,7 @@ class MkFitOutputConverter : public edm::global::EDProducer<> {
                                              const MagneticField& mf,
                                              const Propagator& propagatorAlong,
                                              const Propagator& propagatorOpposite,
+                                             const MkFitGeometry& mkFitGeom,
                                              const TkClonerImpl& hitCloner,
                                              const std::vector<const DetLayer*>& detLayers,
                                              const mkfit::TrackVec& mkFitSeeds,
@@ -243,6 +245,7 @@ void MkFitOutputConverter::produce(edm::StreamID iID, edm::Event& iEvent, const
                                    iSetup.getData(mfToken_),
                                    iSetup.getData(propagatorAlongToken_),
                                    iSetup.getData(propagatorOppositeToken_),
+                                   iSetup.getData(mkFitGeomToken_),
                                    tkBuilder->cloner(),
                                    mkFitGeom.detLayers(),
                                    mkfitSeeds.seeds(),
@@ -262,6 +265,7 @@ TrackCandidateCollection MkFitOutputConverter::convertCandidates(const MkFitOutp
                                                                  const MagneticField& mf,
                                                                  const Propagator& propagatorAlong,
                                                                  const Propagator& propagatorOpposite,
+                                                                 const MkFitGeometry& mkFitGeom,
                                                                  const TkClonerImpl& hitCloner,
                                                                  const std::vector<const DetLayer*>& detLayers,
                                                                  const mkfit::TrackVec& mkFitSeeds,
@@ -370,14 +374,18 @@ TrackCandidateCollection MkFitOutputConverter::convertCandidates(const MkFitOutp
         auto const& hits = isPixel ? pixelClusterIndexToHit.hits() : stripClusterIndexToHit.hits();
 
         auto const& thit = static_cast<BaseTrackerRecHit const&>(*hits[hitOnTrack.index]);
-        if (thit.firstClusterRef().isPixel() || thit.detUnit()->type().isEndcap()) {
-          recHits.push_back(hits[hitOnTrack.index]->clone());
+        if (mkFitGeom.isPhase1()) {
+          if (thit.firstClusterRef().isPixel() || thit.detUnit()->type().isEndcap()) {
+            recHits.push_back(hits[hitOnTrack.index]->clone());
+          } else {
+            recHits.push_back(std::make_unique<SiStripRecHit1D>(
+                thit.localPosition(),
+                LocalError(thit.localPositionError().xx(), 0.f, std::numeric_limits<float>::max()),
+                *thit.det(),
+                thit.firstClusterRef()));
+          }
         } else {
-          recHits.push_back(std::make_unique<SiStripRecHit1D>(
-              thit.localPosition(),
-              LocalError(thit.localPositionError().xx(), 0.f, std::numeric_limits<float>::max()),
-              *thit.det(),
-              thit.firstClusterRef()));
+          recHits.push_back(hits[hitOnTrack.index]->clone());
         }
         LogTrace("MkFitOutputConverter") << "  pos " << recHits.back().globalPosition().x() << " "
                                          << recHits.back().globalPosition().y() << " "

RecoTracker/MkFit/plugins/MkFitPhase2HitConverter.cc

@@ -0,0 +1,103 @@
+#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/Phase2TrackerRecHit1D.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 ConvertHitTraitsPhase2 {
+  public:
+    static constexpr bool applyCCC() { return false; }
+    static std::nullptr_t clusterCharge(const Phase2TrackerRecHit1D& hit, DetId hitId) { return nullptr; }
+    static bool passCCC(std::nullptr_t) { return true; }
+    static void setDetails(mkfit::Hit& mhit, const Phase2TrackerCluster1D& cluster, int shortId, std::nullptr_t) {
+      mhit.setupAsStrip(shortId, (1 << 8) - 1, cluster.size());
+    }
+  };
+}  // namespace
+
+class MkFitPhase2HitConverter : public edm::global::EDProducer<> {
+public:
+  explicit MkFitPhase2HitConverter(edm::ParameterSet const& iConfig);
+  ~MkFitPhase2HitConverter() 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<Phase2TrackerRecHit1DCollectionNew> siPhase2RecHitToken_;
+  const edm::ESGetToken<TransientTrackingRecHitBuilder, TransientRecHitRecord> ttrhBuilderToken_;
+  const edm::ESGetToken<TrackerTopology, TrackerTopologyRcd> ttopoToken_;
+  const edm::ESGetToken<MkFitGeometry, TrackerRecoGeometryRecord> mkFitGeomToken_;
+  const edm::EDPutTokenT<MkFitHitWrapper> wrapperPutToken_;
+  const edm::EDPutTokenT<MkFitClusterIndexToHit> clusterIndexPutToken_;
+  const edm::EDPutTokenT<std::vector<float>> clusterChargePutToken_;
+  const ConvertHitTraitsPhase2 convertTraits_;
+};
+
+MkFitPhase2HitConverter::MkFitPhase2HitConverter(edm::ParameterSet const& iConfig)
+    : siPhase2RecHitToken_{consumes<Phase2TrackerRecHit1DCollectionNew>(
+          iConfig.getParameter<edm::InputTag>("siPhase2Hits"))},
+      ttrhBuilderToken_{esConsumes<TransientTrackingRecHitBuilder, TransientRecHitRecord>(
+          iConfig.getParameter<edm::ESInputTag>("ttrhBuilder"))},
+      ttopoToken_{esConsumes<TrackerTopology, TrackerTopologyRcd>()},
+      mkFitGeomToken_{esConsumes<MkFitGeometry, TrackerRecoGeometryRecord>()},
+      wrapperPutToken_{produces<MkFitHitWrapper>()},
+      clusterIndexPutToken_{produces<MkFitClusterIndexToHit>()},
+      clusterChargePutToken_{produces<std::vector<float>>()},
+      convertTraits_{} {}
+
+void MkFitPhase2HitConverter::fillDescriptions(edm::ConfigurationDescriptions& descriptions) {
+  edm::ParameterSetDescription desc;
+
+  desc.add("siPhase2Hits", edm::InputTag{"siPhase2RecHits"});
+  desc.add("ttrhBuilder", edm::ESInputTag{"", "WithTrackAngle"});
+
+  descriptions.add("mkFitPhase2HitConverterDefault", desc);
+}
+
+void MkFitPhase2HitConverter::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<float> clusterCharge;
+
+  edm::ProductID stripClusterID;
+  const auto& phase2Hits = iEvent.get(siPhase2RecHitToken_);
+  std::vector<float> dummy;
+  if (not phase2Hits.empty()) {
+    stripClusterID = mkfit::convertHits(ConvertHitTraitsPhase2{},
+                                        phase2Hits,
+                                        hitWrapper.hits(),
+                                        clusterIndexToHit.hits(),
+                                        dummy,
+                                        ttopo,
+                                        ttrhBuilder,
+                                        mkFitGeom);
+  }
+
+  hitWrapper.setClustersID(stripClusterID);
+
+  iEvent.emplace(wrapperPutToken_, std::move(hitWrapper));
+  iEvent.emplace(clusterIndexPutToken_, std::move(clusterIndexToHit));
+  iEvent.emplace(clusterChargePutToken_, std::move(clusterCharge));
+}
+
+DEFINE_FWK_MODULE(MkFitPhase2HitConverter);

RecoTracker/MkFit/plugins/MkFitProducer.cc

@@ -175,7 +175,8 @@ void MkFitProducer::produce(edm::StreamID iID, edm::Event& iEvent, const edm::Ev
       stripContainerMask.copyMaskTo(stripMask);
     }
   } else {
-    stripClusterChargeCut(iEvent.get(stripClusterChargeToken_), stripMask);
+    if (mkFitGeom.isPhase1())
+      stripClusterChargeCut(iEvent.get(stripClusterChargeToken_), stripMask);
   }
 
   // seeds need to be mutable because of the possible cleaning

RecoTracker/MkFit/python/mkFitPhase2HitConverter_cfi.py

@@ -0,0 +1,5 @@
+import FWCore.ParameterSet.Config as cms
+
+from RecoTracker.MkFit.mkFitPhase2HitConverterDefault_cfi import mkFitPhase2HitConverterDefault as _mkFitPhase2HitConverterDefault
+
+mkFitPhase2HitConverter = _mkFitPhase2HitConverterDefault.clone()

RecoTracker/MkFit/src/MkFitGeometry.cc

@@ -62,3 +62,7 @@ int MkFitGeometry::mkFitLayerNumber(DetId detId) const {
   return lnc_->convertLayerNumber(
       detId.subdetId(), ttopo_->layer(detId), false, ttopo_->isStereo(detId), isPlusSide(*ttopo_, detId));
 }
+
+bool MkFitGeometry::isPhase1() const { return lnc_->isPhase1(); }
+
+bool MkFitGeometry::isPhase2() const { return lnc_->isPhase2(); }

RecoTracker/MkFitCMS/interface/LayerNumberConverter.h

@@ -21,6 +21,8 @@ namespace mkfit {
       return 10;
     }
     TkLayout getEra() const { return lo_; }
+    bool isPhase1() const { return lo_ == TkLayout::phase1; }
+    bool isPhase2() const { return lo_ == TkLayout::phase2; }
     int convertLayerNumber(int det, int lay, bool useMatched, int isStereo, bool posZ) const {
       if (lo_ == TkLayout::phase2) {
         if (det == 1)