Merge pull request #26939 from makortel/pluginFactorySeedGeneratorFro…

…mRegionHits Take SeedGeneratorFromRegionHits constructor arguments as unique_ptrs
cms-sw · May 27, 2019 · 6ab9424 · 6ab9424
2 parents 39fdf6d + 7e82060
commit 6ab9424
Show file tree

Hide file tree

Showing 8 changed files with 28 additions and 34 deletions.
diff --git a/RecoEgamma/EgammaElectronAlgos/interface/SeedFilter.h b/RecoEgamma/EgammaElectronAlgos/interface/SeedFilter.h
@@ -45,7 +45,7 @@ class SeedFilter {
   void seeds(edm::Event&, const edm::EventSetup&, const reco::SuperClusterRef &, TrajectorySeedCollection *);
 
  private:
-  SeedGeneratorFromRegionHits *combinatorialSeedGenerator;
+  std::unique_ptr<SeedGeneratorFromRegionHits> combinatorialSeedGenerator;
 
   // remove them FIXME
   double dr_, deta_, dphi_, pt_;

diff --git a/RecoEgamma/EgammaElectronAlgos/src/SeedFilter.cc b/RecoEgamma/EgammaElectronAlgos/src/SeedFilter.cc
@@ -64,26 +64,22 @@ SeedFilter::SeedFilter(const edm::ParameterSet& conf,
     throw cms::Exception("Configuration") << "SeedFilter: useOnDemandTracker must be -1, 0, or 1; got " << tmp;
   hitsfactoryMode_ = RectangularEtaPhiTrackingRegion::intToUseMeasurementTracker(tmp);
 
-  // get orderd hits generator from factory
-  OrderedHitsGenerator*  hitsGenerator = OrderedHitsGeneratorFactory::get()->create(hitsfactoryName, hitsfactoryPSet, iC);
-
   // start seed generator
   edm::ParameterSet seedCreatorPSet = conf.getParameter<edm::ParameterSet>("SeedCreatorPSet");
   std::string seedCreatorType = seedCreatorPSet.getParameter<std::string>("ComponentName");
 
-  combinatorialSeedGenerator = new SeedGeneratorFromRegionHits(hitsGenerator,nullptr,
-							       SeedCreatorFactory::get()->create(seedCreatorType, seedCreatorPSet)
+  combinatorialSeedGenerator = std::make_unique<SeedGeneratorFromRegionHits>(std::unique_ptr<OrderedHitsGenerator>{OrderedHitsGeneratorFactory::get()->create(hitsfactoryName, hitsfactoryPSet, iC)},
+                                                                             nullptr,
+                                                                             std::unique_ptr<SeedCreator>{SeedCreatorFactory::get()->create(seedCreatorType, seedCreatorPSet)}
 				                  	       );
   beamSpotTag_ = tokens.token_bs; ;
   if(hitsfactoryMode_ != RectangularEtaPhiTrackingRegion::UseMeasurementTracker::kNever) {
     measurementTrackerToken_ = iC.consumes<MeasurementTrackerEvent>(conf.getParameter<edm::InputTag>("measurementTrackerEvent"));
   }
- }
-
-SeedFilter::~SeedFilter() {
-  delete combinatorialSeedGenerator;
 }
 
+SeedFilter::~SeedFilter() = default;
+
 void SeedFilter::seeds(edm::Event& e, const edm::EventSetup& setup, const reco::SuperClusterRef &scRef, TrajectorySeedCollection *output) {
 
   setup.get<IdealMagneticFieldRecord>().get(theMagField);

diff --git a/RecoEgamma/EgammaHLTProducers/src/EgammaHLTRegionalPixelSeedGeneratorProducers.cc b/RecoEgamma/EgammaHLTProducers/src/EgammaHLTRegionalPixelSeedGeneratorProducers.cc
@@ -66,9 +66,9 @@ EgammaHLTRegionalPixelSeedGeneratorProducers::EgammaHLTRegionalPixelSeedGenerato
   creatorPSet.addParameter<std::string>("propagator","PropagatorWithMaterial");
 
   edm::ConsumesCollector iC = consumesCollector();
-  combinatorialSeedGenerator = std::make_unique<SeedGeneratorFromRegionHits>( OrderedHitsGeneratorFactory::get()->create( hitsfactoryName, hitsfactoryPSet, iC),
+  combinatorialSeedGenerator = std::make_unique<SeedGeneratorFromRegionHits>( std::unique_ptr<OrderedHitsGenerator>{OrderedHitsGeneratorFactory::get()->create( hitsfactoryName, hitsfactoryPSet, iC)},
                                                                               nullptr,
-                                                                              SeedCreatorFactory::get()->create("SeedFromConsecutiveHitsCreator", creatorPSet)
+                                                                              std::unique_ptr<SeedCreator>{SeedCreatorFactory::get()->create("SeedFromConsecutiveHitsCreator", creatorPSet)}
                                                                               );
   // setup orderedhits setup (in order to tell seed generator to use pairs/triplets, which layers)
 }

diff --git a/RecoMuon/TrackerSeedGenerator/plugins/TSGFromOrderedHits.cc b/RecoMuon/TrackerSeedGenerator/plugins/TSGFromOrderedHits.cc
@@ -20,9 +20,9 @@ TSGFromOrderedHits::TSGFromOrderedHits(const edm::ParameterSet &pset,edm::Consum
   edm::ParameterSet seedCreatorPSet = pset.getParameter<edm::ParameterSet>("SeedCreatorPSet");
   std::string seedCreatorType = seedCreatorPSet.getParameter<std::string>("ComponentName");
 
-  theGenerator = std::make_unique<SeedGeneratorFromRegionHits>(OrderedHitsGeneratorFactory::get()->create( hitsfactoryName, hitsfactoryPSet, iC),
+  theGenerator = std::make_unique<SeedGeneratorFromRegionHits>(std::unique_ptr<OrderedHitsGenerator>{OrderedHitsGeneratorFactory::get()->create( hitsfactoryName, hitsfactoryPSet, iC)},
                                                                nullptr,
-                                                               SeedCreatorFactory::get()->create(seedCreatorType, seedCreatorPSet)
+                                                               std::unique_ptr<SeedCreator>{SeedCreatorFactory::get()->create(seedCreatorType, seedCreatorPSet)}
                                                                );
 
 }

diff --git a/RecoMuon/TrackerSeedGenerator/plugins/TSGSmart.cc b/RecoMuon/TrackerSeedGenerator/plugins/TSGSmart.cc
@@ -21,29 +21,29 @@ TSGSmart::TSGSmart(const edm::ParameterSet &pset,edm::ConsumesCollector& iC)
     PairPSet.getParameter<edm::ParameterSet>("OrderedHitsFactoryPSet");
   std::string pairhitsfactoryName = pairhitsfactoryPSet.getParameter<std::string>("ComponentName");
 
-  thePairGenerator = std::make_unique<SeedGeneratorFromRegionHits>( OrderedHitsGeneratorFactory::get()->create( pairhitsfactoryName, pairhitsfactoryPSet, iC),
+  thePairGenerator = std::make_unique<SeedGeneratorFromRegionHits>( std::unique_ptr<OrderedHitsGenerator>{OrderedHitsGeneratorFactory::get()->create( pairhitsfactoryName, pairhitsfactoryPSet, iC)},
                                                                     nullptr,
-                                                                    SeedCreatorFactory::get()->create("SeedFromConsecutiveHitsCreator", creatorPSet)
+                                                                    std::unique_ptr<SeedCreator>{SeedCreatorFactory::get()->create("SeedFromConsecutiveHitsCreator", creatorPSet)}
                                                                     );
 
   edm::ParameterSet TripletPSet = pset.getParameter<edm::ParameterSet>("PixelTripletGeneratorSet"); 
   edm::ParameterSet triplethitsfactoryPSet =
     TripletPSet.getParameter<edm::ParameterSet>("OrderedHitsFactoryPSet");
   std::string triplethitsfactoryName = triplethitsfactoryPSet.getParameter<std::string>("ComponentName");
 
-  theTripletGenerator = std::make_unique<SeedGeneratorFromRegionHits>( OrderedHitsGeneratorFactory::get()->create( triplethitsfactoryName, triplethitsfactoryPSet, iC),
+  theTripletGenerator = std::make_unique<SeedGeneratorFromRegionHits>( std::unique_ptr<OrderedHitsGenerator>{OrderedHitsGeneratorFactory::get()->create( triplethitsfactoryName, triplethitsfactoryPSet, iC)},
                                                                        nullptr,
-                                                                       SeedCreatorFactory::get()->create("SeedFromConsecutiveHitsCreator", creatorPSet)
+                                                                       std::unique_ptr<SeedCreator>{SeedCreatorFactory::get()->create("SeedFromConsecutiveHitsCreator", creatorPSet)}
                                                                        );
 
   edm::ParameterSet MixedPSet = pset.getParameter<edm::ParameterSet>("MixedGeneratorSet");
   edm::ParameterSet mixedhitsfactoryPSet =
     MixedPSet.getParameter<edm::ParameterSet>("OrderedHitsFactoryPSet");
   std::string mixedhitsfactoryName = mixedhitsfactoryPSet.getParameter<std::string>("ComponentName");
 
-  theMixedGenerator = std::make_unique<SeedGeneratorFromRegionHits>( OrderedHitsGeneratorFactory::get()->create( mixedhitsfactoryName, mixedhitsfactoryPSet, iC),
+  theMixedGenerator = std::make_unique<SeedGeneratorFromRegionHits>( std::unique_ptr<OrderedHitsGenerator>{OrderedHitsGeneratorFactory::get()->create( mixedhitsfactoryName, mixedhitsfactoryPSet, iC)},
                                                                      nullptr,
-                                                                     SeedCreatorFactory::get()->create("SeedFromConsecutiveHitsCreator", creatorPSet)
+                                                                     std::unique_ptr<SeedCreator>{SeedCreatorFactory::get()->create("SeedFromConsecutiveHitsCreator", creatorPSet)}
                                                                      );
 }
 

diff --git a/RecoTracker/TkSeedGenerator/interface/SeedGeneratorFromRegionHits.h b/RecoTracker/TkSeedGenerator/interface/SeedGeneratorFromRegionHits.h
@@ -17,18 +17,11 @@ namespace edm { class Event; class EventSetup; }
 class SeedGeneratorFromRegionHits {
 public:
 
-  template <typename GEN>
-  SeedGeneratorFromRegionHits(GEN aGenerator): SeedGeneratorFromRegionHits(std::move(aGenerator), nullptr, nullptr) {}
-
-  template <typename GEN, typename COMP>
-  SeedGeneratorFromRegionHits(GEN aGenerator, COMP aComparitor): SeedGeneratorFromRegionHits(std::move(aGenerator), std::move(aComparitor), nullptr) {}
-
-  template <typename GEN, typename COMP, typename CREA>
-  SeedGeneratorFromRegionHits(GEN aGenerator, COMP aComparitor, CREA aSeedCreator):
-    theHitsGenerator{std::move(aGenerator)}, theComparitor{std::move(aComparitor)}, theSeedCreator{std::move(aSeedCreator)}
-  {}
-
-
+  SeedGeneratorFromRegionHits(
+      std::unique_ptr<OrderedHitsGenerator> aGenerator,
+      std::unique_ptr<SeedComparitor> aComparitor = nullptr,
+      std::unique_ptr<SeedCreator> aSeedCreator = nullptr
+    );
 
   // make job
   void run(TrajectorySeedCollection & seedCollection, const TrackingRegion & region, 

diff --git a/RecoTracker/TkSeedGenerator/plugins/SeedGeneratorFromRegionHitsEDProducer.cc b/RecoTracker/TkSeedGenerator/plugins/SeedGeneratorFromRegionHitsEDProducer.cc
@@ -54,9 +54,9 @@ SeedGeneratorFromRegionHitsEDProducer::SeedGeneratorFromRegionHitsEDProducer(
 
   std::string creatorName = creatorPSet.getParameter<std::string>("ComponentName");
 
-  theGenerator = std::make_unique<SeedGeneratorFromRegionHits>(OrderedHitsGeneratorFactory::get()->create( hitsfactoryName, hitsfactoryPSet, iC),
+  theGenerator = std::make_unique<SeedGeneratorFromRegionHits>(std::unique_ptr<OrderedHitsGenerator>{OrderedHitsGeneratorFactory::get()->create( hitsfactoryName, hitsfactoryPSet, iC)},
                                                                std::move(aComparitor),
-                                                               SeedCreatorFactory::get()->create( creatorName, creatorPSet));
+                                                               std::unique_ptr<SeedCreator>{SeedCreatorFactory::get()->create( creatorName, creatorPSet)});
 
   produces<TrajectorySeedCollection>();
 }

diff --git a/RecoTracker/TkSeedGenerator/src/SeedGeneratorFromRegionHits.cc b/RecoTracker/TkSeedGenerator/src/SeedGeneratorFromRegionHits.cc
@@ -4,6 +4,11 @@
 #include "RecoTracker/TkSeedingLayers/interface/SeedComparitor.h"
 #include "RecoTracker/TkSeedGenerator/interface/SeedCreator.h"
 
+SeedGeneratorFromRegionHits::SeedGeneratorFromRegionHits(
+  std::unique_ptr<OrderedHitsGenerator> ohg, std::unique_ptr<SeedComparitor> asc, std::unique_ptr<SeedCreator> asp)
+  : theHitsGenerator{std::move(ohg)}, theComparitor{std::move(asc)}, theSeedCreator{std::move(asp)}
+{ }
+
 void SeedGeneratorFromRegionHits::run(TrajectorySeedCollection & seedCollection, 
     const TrackingRegion & region, const edm::Event& ev, const edm::EventSetup& es)
 {