Partial esConsumes migration for TrajectorySeedProducer

FastSimulation/Tracking/interface/SeedFinderSelector.h

@@ -6,32 +6,29 @@
 #include <string>
 
 #include "DataFormats/TrackerCommon/interface/TrackerTopology.h"
+#include "Geometry/Records/interface/TrackerTopologyRcd.h"
 #include "TrackingTools/TransientTrackingRecHit/interface/SeedingLayerSetsHits.h"
+#include "RecoTracker/MeasurementDet/interface/MeasurementTracker.h"
+#include "RecoTracker/Record/interface/CkfComponentsRecord.h"
 #include "RecoTracker/TkSeedingLayers/interface/SeedingLayerSetsBuilder.h"
+#include "FWCore/Framework/interface/FrameworkfwdMostUsed.h"
 #include "FWCore/ParameterSet/interface/ParameterSet.h"
+#include "FWCore/Utilities/interface/ESGetToken.h"
 
 class TrackingRegion;
 class FastTrackerRecHit;
 class MultiHitGeneratorFromPairAndLayers;
 class HitTripletGeneratorFromPairAndLayers;
-class MeasurementTracker;
 class CAHitTripletGenerator;
 class CAHitQuadrupletGenerator;
 
-namespace edm {
-  class Event;
-  class EventSetup;
-  class ParameterSet;
-  class ConsumesCollector;
-}  // namespace edm
-
 class SeedFinderSelector {
 public:
-  SeedFinderSelector(const edm::ParameterSet& cfg, edm::ConsumesCollector&& consumesCollector);
+  SeedFinderSelector(const edm::ParameterSet&, edm::ConsumesCollector&&);
 
   ~SeedFinderSelector();
 
-  void initEvent(const edm::Event& ev, const edm::EventSetup& es);
+  void initEvent(const edm::Event&, const edm::EventSetup&);
 
   void setTrackingRegion(const TrackingRegion* trackingRegion) { trackingRegion_ = trackingRegion; }
 
@@ -46,12 +43,14 @@ class SeedFinderSelector {
   const edm::EventSetup* eventSetup_;
   const MeasurementTracker* measurementTracker_;
   const std::string measurementTrackerLabel_;
+  const edm::ESGetToken<MeasurementTracker, CkfComponentsRecord> measurementTrackerESToken_;
+  const edm::ESGetToken<TrackerTopology, TrackerTopologyRcd> trackerTopologyESToken_;
+  const TrackerTopology* trackerTopology_ = nullptr;
   std::unique_ptr<CAHitTripletGenerator> CAHitTriplGenerator_;
   std::unique_ptr<CAHitQuadrupletGenerator> CAHitQuadGenerator_;
   std::unique_ptr<SeedingLayerSetsBuilder> seedingLayers_;
   std::unique_ptr<SeedingLayerSetsHits> seedingLayer;
   std::vector<unsigned> layerPairs_;
-  edm::ESHandle<TrackerTopology> trackerTopology;
   std::vector<SeedingLayerSetsBuilder::SeedingLayerId> seedingLayerIds;
 };
 

FastSimulation/Tracking/plugins/TrajectorySeedProducer.cc

@@ -27,7 +27,6 @@
 #include "FWCore/Framework/interface/stream/EDProducer.h"
 #include "FWCore/Framework/interface/Event.h"
 #include "FWCore/Framework/interface/EventSetup.h"
-#include "FWCore/Framework/interface/ESHandle.h"
 #include "FWCore/Framework/interface/ConsumesCollector.h"
 #include "FWCore/Utilities/interface/InputTag.h"
 #include "FWCore/ParameterSet/interface/ParameterSet.h"
@@ -63,6 +62,7 @@ class TrajectorySeedProducer : public edm::stream::EDProducer<> {
   edm::EDGetTokenT<FastTrackerRecHitCombinationCollection> recHitCombinationsToken;
   edm::EDGetTokenT<std::vector<bool>> hitMasksToken;
   edm::EDGetTokenT<edm::OwnVector<TrackingRegion>> trackingRegionToken;
+  const edm::ESGetToken<TrackerTopology, TrackerTopologyRcd> trackerTopologyESToken_;
 
   // other data members
   unsigned int nHitsPerSeed_;
@@ -78,13 +78,13 @@ class TrajectorySeedProducer : public edm::stream::EDProducer<> {
 public:
   TrajectorySeedProducer(const edm::ParameterSet& conf);
 
-  void produce(edm::Event& e, const edm::EventSetup& es) override;
+  void produce(edm::Event&, const edm::EventSetup&) override;
 };
 
 template class SeedingTree<TrackingLayer>;
 template class SeedingNode<TrackingLayer>;
 
-TrajectorySeedProducer::TrajectorySeedProducer(const edm::ParameterSet& conf) {
+TrajectorySeedProducer::TrajectorySeedProducer(const edm::ParameterSet& conf) : trackerTopologyESToken_(esConsumes()) {
   // products
   produces<TrajectorySeedCollection>();
 
@@ -133,14 +133,12 @@ TrajectorySeedProducer::TrajectorySeedProducer(const edm::ParameterSet& conf) {
   // seed creator
   const edm::ParameterSet& seedCreatorPSet = conf.getParameter<edm::ParameterSet>("SeedCreatorPSet");
   std::string seedCreatorName = seedCreatorPSet.getParameter<std::string>("ComponentName");
-  seedCreator = SeedCreatorFactory::get()->create(seedCreatorName, seedCreatorPSet);
+  seedCreator = SeedCreatorFactory::get()->create(seedCreatorName, seedCreatorPSet, consumesCollector());
 }
 
 void TrajectorySeedProducer::produce(edm::Event& e, const edm::EventSetup& es) {
   // services
-  edm::ESHandle<TrackerTopology> trackerTopology;
-
-  es.get<TrackerTopologyRcd>().get(trackerTopology);
+  auto const& trackerTopology = es.getData(trackerTopologyESToken_);
 
   // input data
   edm::Handle<FastTrackerRecHitCombinationCollection> recHitCombinations;
@@ -166,7 +164,7 @@ void TrajectorySeedProducer::produce(edm::Event& e, const edm::EventSetup& es) {
   }
 
   // instantiate the seed finder
-  SeedFinder seedFinder(_seedingTree, *trackerTopology.product());
+  SeedFinder seedFinder(_seedingTree, trackerTopology);
   if (seedFinderSelector) {
     seedFinderSelector->initEvent(e, es);
     seedFinder.addHitSelector(seedFinderSelector.get(), nHitsPerSeed_);

FastSimulation/Tracking/src/SeedFinderSelector.cc

@@ -1,17 +1,16 @@
 #include "FastSimulation/Tracking/interface/SeedFinderSelector.h"
 
 // framework
+#include "FWCore/Framework/interface/ConsumesCollector.h"
 #include "FWCore/Framework/interface/EventSetup.h"
 #include "FWCore/Framework/interface/Event.h"
 
 // track reco
-#include "RecoTracker/MeasurementDet/interface/MeasurementTracker.h"
 #include "RecoTracker/TkHitPairs/interface/RecHitsSortedInPhi.h"
 #include "RecoTracker/TkHitPairs/interface/HitPairGeneratorFromLayerPair.h"
 #include "DataFormats/SiPixelDetId/interface/PixelSubdetector.h"
 #include "RecoTracker/TkSeedGenerator/interface/MultiHitGeneratorFromPairAndLayers.h"
 #include "RecoTracker/TkSeedGenerator/interface/MultiHitGeneratorFromPairAndLayersFactory.h"
-#include "RecoTracker/Record/interface/CkfComponentsRecord.h"
 #include "RecoPixelVertexing/PixelTriplets/interface/HitTripletGeneratorFromPairAndLayers.h"
 #include "RecoPixelVertexing/PixelTriplets/interface/HitTripletGeneratorFromPairAndLayersFactory.h"
 #include "RecoPixelVertexing/PixelTriplets/interface/CAHitTripletGenerator.h"
@@ -25,7 +24,9 @@ SeedFinderSelector::SeedFinderSelector(const edm::ParameterSet &cfg, edm::Consum
     : trackingRegion_(nullptr),
       eventSetup_(nullptr),
       measurementTracker_(nullptr),
-      measurementTrackerLabel_(cfg.getParameter<std::string>("measurementTracker")) {
+      measurementTrackerLabel_(cfg.getParameter<std::string>("measurementTracker")),
+      measurementTrackerESToken_(consumesCollector.esConsumes(edm::ESInputTag("", measurementTrackerLabel_))),
+      trackerTopologyESToken_(consumesCollector.esConsumes()) {
   if (cfg.exists("pixelTripletGeneratorFactory")) {
     const edm::ParameterSet &tripletConfig = cfg.getParameter<edm::ParameterSet>("pixelTripletGeneratorFactory");
     pixelTripletGenerator_ = HitTripletGeneratorFromPairAndLayersFactory::get()->create(
@@ -35,7 +36,7 @@ SeedFinderSelector::SeedFinderSelector(const edm::ParameterSet &cfg, edm::Consum
   if (cfg.exists("MultiHitGeneratorFactory")) {
     const edm::ParameterSet &tripletConfig = cfg.getParameter<edm::ParameterSet>("MultiHitGeneratorFactory");
     multiHitGenerator_ = MultiHitGeneratorFromPairAndLayersFactory::get()->create(
-        tripletConfig.getParameter<std::string>("ComponentName"), tripletConfig);
+        tripletConfig.getParameter<std::string>("ComponentName"), tripletConfig, consumesCollector);
   }
 
   if (cfg.exists("CAHitTripletGeneratorFactory")) {
@@ -77,10 +78,8 @@ SeedFinderSelector::~SeedFinderSelector() { ; }
 void SeedFinderSelector::initEvent(const edm::Event &ev, const edm::EventSetup &es) {
   eventSetup_ = &es;
 
-  edm::ESHandle<MeasurementTracker> measurementTrackerHandle;
-  es.get<CkfComponentsRecord>().get(measurementTrackerLabel_, measurementTrackerHandle);
-  es.get<TrackerTopologyRcd>().get(trackerTopology);
-  measurementTracker_ = &(*measurementTrackerHandle);
+  measurementTracker_ = &es.getData(measurementTrackerESToken_);
+  trackerTopology_ = &es.getData(trackerTopologyESToken_);
 
   if (multiHitGenerator_) {
     multiHitGenerator_->initES(es);
@@ -320,19 +319,18 @@ bool SeedFinderSelector::pass(const std::vector<const FastTrackerRecHit *> &hits
 
 //new for Phase1
 SeedingLayerSetsBuilder::SeedingLayerId SeedFinderSelector::Layer_tuple(const FastTrackerRecHit *hit) const {
-  const TrackerTopology *const tTopo = trackerTopology.product();
   GeomDetEnumerators::SubDetector subdet = GeomDetEnumerators::invalidDet;
   TrackerDetSide side = TrackerDetSide::Barrel;
   int idLayer = 0;
 
   if ((hit->det()->geographicalId()).subdetId() == PixelSubdetector::PixelBarrel) {
     subdet = GeomDetEnumerators::PixelBarrel;
     side = TrackerDetSide::Barrel;
-    idLayer = tTopo->pxbLayer(hit->det()->geographicalId());
+    idLayer = trackerTopology_->pxbLayer(hit->det()->geographicalId());
   } else if ((hit->det()->geographicalId()).subdetId() == PixelSubdetector::PixelEndcap) {
     subdet = GeomDetEnumerators::PixelEndcap;
-    idLayer = tTopo->pxfDisk(hit->det()->geographicalId());
-    if (tTopo->pxfSide(hit->det()->geographicalId()) == 1) {
+    idLayer = trackerTopology_->pxfDisk(hit->det()->geographicalId());
+    if (trackerTopology_->pxfSide(hit->det()->geographicalId()) == 1) {
       side = TrackerDetSide::NegEndcap;
     } else {
       side = TrackerDetSide::PosEndcap;

RecoMuon/TrackerSeedGenerator/plugins/TSGFromOrderedHits.cc

@@ -1,5 +1,7 @@
 #include "TSGFromOrderedHits.h"
 
+#include "FWCore/Framework/interface/ConsumesCollector.h"
+#include "FWCore/ParameterSet/interface/ParameterSet.h"
 #include "RecoTracker/TkTrackingRegions/interface/TrackingRegion.h"
 #include "RecoTracker/TkTrackingRegions/interface/OrderedHitsGeneratorFactory.h"
 #include "RecoTracker/TkTrackingRegions/interface/OrderedHitsGenerator.h"
@@ -19,7 +21,7 @@ TSGFromOrderedHits::TSGFromOrderedHits(const edm::ParameterSet &pset, edm::Consu
   theGenerator = std::make_unique<SeedGeneratorFromRegionHits>(
       OrderedHitsGeneratorFactory::get()->create(hitsfactoryName, hitsfactoryPSet, iC),
       nullptr,
-      SeedCreatorFactory::get()->create(seedCreatorType, seedCreatorPSet));
+      SeedCreatorFactory::get()->create(seedCreatorType, seedCreatorPSet, edm::ConsumesCollector(iC)));
 }
 
 TSGFromOrderedHits::~TSGFromOrderedHits() = default;

RecoMuon/TrackerSeedGenerator/plugins/TSGFromOrderedHits.h

@@ -2,9 +2,8 @@
 #define RecoMuon_TrackerSeedGenerator_TSGFromOrderedHits_H
 
 #include "RecoMuon/TrackerSeedGenerator/interface/TrackerSeedGenerator.h"
-#include "FWCore/ParameterSet/interface/ParameterSet.h"
+#include "FWCore/Framework/interface/FrameworkfwdMostUsed.h"
 #include "DataFormats/Provenance/interface/RunID.h"
-#include "FWCore/Framework/interface/ConsumesCollector.h"
 
 class SeedGeneratorFromRegionHits;
 class TrackingRegion;

RecoMuon/TrackerSeedGenerator/plugins/TSGSmart.cc

@@ -1,5 +1,6 @@
 #include "RecoMuon/TrackerSeedGenerator/plugins/TSGSmart.h"
 
+#include "FWCore/Framework/interface/ConsumesCollector.h"
 #include "RecoTracker/TkTrackingRegions/interface/TrackingRegion.h"
 #include "RecoTracker/TkTrackingRegions/interface/OrderedHitsGeneratorFactory.h"
 #include "RecoTracker/TkTrackingRegions/interface/OrderedHitsGenerator.h"
@@ -20,7 +21,7 @@ TSGSmart::TSGSmart(const edm::ParameterSet &pset, edm::ConsumesCollector &iC) {
   thePairGenerator = std::make_unique<SeedGeneratorFromRegionHits>(
       OrderedHitsGeneratorFactory::get()->create(pairhitsfactoryName, pairhitsfactoryPSet, iC),
       nullptr,
-      SeedCreatorFactory::get()->create("SeedFromConsecutiveHitsCreator", creatorPSet));
+      SeedCreatorFactory::get()->create("SeedFromConsecutiveHitsCreator", creatorPSet, edm::ConsumesCollector(iC)));
 
   edm::ParameterSet TripletPSet = pset.getParameter<edm::ParameterSet>("PixelTripletGeneratorSet");
   edm::ParameterSet triplethitsfactoryPSet = TripletPSet.getParameter<edm::ParameterSet>("OrderedHitsFactoryPSet");
@@ -29,7 +30,7 @@ TSGSmart::TSGSmart(const edm::ParameterSet &pset, edm::ConsumesCollector &iC) {
   theTripletGenerator = std::make_unique<SeedGeneratorFromRegionHits>(
       OrderedHitsGeneratorFactory::get()->create(triplethitsfactoryName, triplethitsfactoryPSet, iC),
       nullptr,
-      SeedCreatorFactory::get()->create("SeedFromConsecutiveHitsCreator", creatorPSet));
+      SeedCreatorFactory::get()->create("SeedFromConsecutiveHitsCreator", creatorPSet, edm::ConsumesCollector(iC)));
 
   edm::ParameterSet MixedPSet = pset.getParameter<edm::ParameterSet>("MixedGeneratorSet");
   edm::ParameterSet mixedhitsfactoryPSet = MixedPSet.getParameter<edm::ParameterSet>("OrderedHitsFactoryPSet");
@@ -38,7 +39,7 @@ TSGSmart::TSGSmart(const edm::ParameterSet &pset, edm::ConsumesCollector &iC) {
   theMixedGenerator = std::make_unique<SeedGeneratorFromRegionHits>(
       OrderedHitsGeneratorFactory::get()->create(mixedhitsfactoryName, mixedhitsfactoryPSet, iC),
       nullptr,
-      SeedCreatorFactory::get()->create("SeedFromConsecutiveHitsCreator", creatorPSet));
+      SeedCreatorFactory::get()->create("SeedFromConsecutiveHitsCreator", creatorPSet, edm::ConsumesCollector(iC)));
 }
 
 TSGSmart::~TSGSmart() = default;

RecoMuon/TrackerSeedGenerator/plugins/TSGSmart.h

@@ -2,6 +2,7 @@
 #define RecoMuon_TrackerSeedGenerator_TSGSmart_H
 
 #include "RecoMuon/TrackerSeedGenerator/interface/TrackerSeedGenerator.h"
+#include "FWCore/Framework/interface/FrameworkfwdMostUsed.h"
 #include "FWCore/ParameterSet/interface/ParameterSet.h"
 
 class SeedGeneratorFromRegionHits;

RecoPixelVertexing/PixelLowPtUtilities/interface/LowPtClusterShapeSeedComparitor.h

@@ -2,18 +2,15 @@
 #define _LowPtClusterShapeSeedComparitor_h_
 
 #include "RecoTracker/TkSeedingLayers/interface/SeedComparitor.h"
-#include "FWCore/Framework/interface/ESHandle.h"
+#include "FWCore/Framework/interface/FrameworkfwdMostUsed.h"
 #include "FWCore/Utilities/interface/EDGetToken.h"
+#include "FWCore/Utilities/interface/ESGetToken.h"
 #include "DataFormats/Common/interface/Handle.h"
 #include "DataFormats/SiPixelCluster/interface/SiPixelClusterShapeCache.h"
+#include "DataFormats/TrackerCommon/interface/TrackerTopology.h"
+#include "Geometry/Records/interface/TrackerTopologyRcd.h"
 #include "RecoPixelVertexing/PixelLowPtUtilities/interface/ClusterShapeHitFilter.h"
-
-class TrackerTopology;
-
-namespace edm {
-  class ParameterSet;
-  class EventSetup;
-}  // namespace edm
+#include "RecoTracker/Record/interface/CkfComponentsRecord.h"
 
 class LowPtClusterShapeSeedComparitor : public SeedComparitor {
 public:
@@ -31,12 +28,13 @@ class LowPtClusterShapeSeedComparitor : public SeedComparitor {
   }
 
 private:
-  /// something
-  edm::ESHandle<ClusterShapeHitFilter> theShapeFilter;
-  edm::ESHandle<TrackerTopology> theTTopo;
   edm::EDGetTokenT<SiPixelClusterShapeCache> thePixelClusterShapeCacheToken;
   edm::Handle<SiPixelClusterShapeCache> thePixelClusterShapeCache;
   std::string theShapeFilterLabel_;
+  const edm::ESGetToken<ClusterShapeHitFilter, CkfComponentsRecord> clusterShapeHitFilterESToken_;
+  const edm::ESGetToken<TrackerTopology, TrackerTopologyRcd> trackerTopologyESToken_;
+  const ClusterShapeHitFilter *clusterShapeHitFilter_ = nullptr;
+  const TrackerTopology *trackerTopology_ = nullptr;
 };
 
 #endif

RecoPixelVertexing/PixelLowPtUtilities/plugins/ClusterShapeSeedComparitor.cc

@@ -7,14 +7,15 @@
 #include "DataFormats/TrackerRecHit2D/interface/SiStripRecHit2D.h"
 #include "DataFormats/TrackerRecHit2D/interface/SiStripMatchedRecHit2D.h"
 #include "DataFormats/TrackerRecHit2D/interface/ProjectedSiStripRecHit2D.h"
-#include "FWCore/Framework/interface/ESHandle.h"
 #include "RecoTracker/Record/interface/CkfComponentsRecord.h"
 #include "RecoTracker/TkSeedGenerator/interface/FastHelix.h"
 #include "RecoTracker/TkSeedingLayers/interface/SeedingHitSet.h"
 #include "MagneticField/Engine/interface/MagneticField.h"
 #include "FWCore/Framework/interface/Event.h"
 #include "FWCore/Framework/interface/ConsumesCollector.h"
 #include "FWCore/Utilities/interface/EDGetToken.h"
+#include "FWCore/Utilities/interface/ESGetToken.h"
+#include "FWCore/Utilities/interface/ESInputTag.h"
 #include "DataFormats/Common/interface/Handle.h"
 #include "DataFormats/SiPixelCluster/interface/SiPixelClusterShapeCache.h"
 #include <cstdio>
@@ -37,7 +38,8 @@ class PixelClusterShapeSeedComparitor : public SeedComparitor {
   bool compatibleHit(const TrackingRecHit &hit, const GlobalVector &direction) const;
 
   std::string filterName_;
-  edm::ESHandle<ClusterShapeHitFilter> filterHandle_;
+  const edm::ESGetToken<ClusterShapeHitFilter, CkfComponentsRecord> clusterShapeHitFilterESToken_;
+  const ClusterShapeHitFilter *clusterShapeHitFilter_;
   edm::EDGetTokenT<SiPixelClusterShapeCache> pixelClusterShapeCacheToken_;
   const SiPixelClusterShapeCache *pixelClusterShapeCache_;
   const bool filterAtHelixStage_;
@@ -47,6 +49,7 @@ class PixelClusterShapeSeedComparitor : public SeedComparitor {
 PixelClusterShapeSeedComparitor::PixelClusterShapeSeedComparitor(const edm::ParameterSet &cfg,
                                                                  edm::ConsumesCollector &iC)
     : filterName_(cfg.getParameter<std::string>("ClusterShapeHitFilterName")),
+      clusterShapeHitFilterESToken_(iC.esConsumes(edm::ESInputTag("", filterName_))),
       pixelClusterShapeCache_(nullptr),
       filterAtHelixStage_(cfg.getParameter<bool>("FilterAtHelixStage")),
       filterPixelHits_(cfg.getParameter<bool>("FilterPixelHits")),
@@ -60,7 +63,7 @@ PixelClusterShapeSeedComparitor::PixelClusterShapeSeedComparitor(const edm::Para
 PixelClusterShapeSeedComparitor::~PixelClusterShapeSeedComparitor() {}
 
 void PixelClusterShapeSeedComparitor::init(const edm::Event &ev, const edm::EventSetup &es) {
-  es.get<CkfComponentsRecord>().get(filterName_, filterHandle_);
+  clusterShapeHitFilter_ = &es.getData(clusterShapeHitFilterESToken_);
   if (filterPixelHits_) {
     edm::Handle<SiPixelClusterShapeCache> hcache;
     ev.getByToken(pixelClusterShapeCacheToken_, hcache);
@@ -125,24 +128,25 @@ bool PixelClusterShapeSeedComparitor::compatibleHit(const TrackingRecHit &hit, c
     if (pixhit == nullptr)
       throw cms::Exception("LogicError", "Found a valid hit on the pixel detector which is not a SiPixelRecHit\n");
     //printf("Cheching hi hit on detid %10d, local direction is x = %9.6f, y = %9.6f, z = %9.6f\n", hit.geographicalId().rawId(), direction.x(), direction.y(), direction.z());
-    return filterHandle_->isCompatible(*pixhit, direction, *pixelClusterShapeCache_);
+    return clusterShapeHitFilter_->isCompatible(*pixhit, direction, *pixelClusterShapeCache_);
   } else {
     if (!filterStripHits_)
       return true;
     const std::type_info &tid = typeid(*&hit);
     if (tid == typeid(SiStripMatchedRecHit2D)) {
       const SiStripMatchedRecHit2D *matchedHit = dynamic_cast<const SiStripMatchedRecHit2D *>(&hit);
       assert(matchedHit != nullptr);
-      return (filterHandle_->isCompatible(DetId(matchedHit->monoId()), matchedHit->monoCluster(), direction) &&
-              filterHandle_->isCompatible(DetId(matchedHit->stereoId()), matchedHit->stereoCluster(), direction));
+      return (
+          clusterShapeHitFilter_->isCompatible(DetId(matchedHit->monoId()), matchedHit->monoCluster(), direction) &&
+          clusterShapeHitFilter_->isCompatible(DetId(matchedHit->stereoId()), matchedHit->stereoCluster(), direction));
     } else if (tid == typeid(SiStripRecHit2D)) {
       const SiStripRecHit2D *recHit = dynamic_cast<const SiStripRecHit2D *>(&hit);
       assert(recHit != nullptr);
-      return filterHandle_->isCompatible(*recHit, direction);
+      return clusterShapeHitFilter_->isCompatible(*recHit, direction);
     } else if (tid == typeid(ProjectedSiStripRecHit2D)) {
       const ProjectedSiStripRecHit2D *precHit = dynamic_cast<const ProjectedSiStripRecHit2D *>(&hit);
       assert(precHit != nullptr);
-      return filterHandle_->isCompatible(precHit->originalHit(), direction);
+      return clusterShapeHitFilter_->isCompatible(precHit->originalHit(), direction);
     } else {
       //printf("Questo e' un %s, che ci fo?\n", tid.name());
       return true;