diff --git a/Configuration/Applications/python/ConfigBuilder.py b/Configuration/Applications/python/ConfigBuilder.py index ef03741a26178..4afa68680bc44 100644 --- a/Configuration/Applications/python/ConfigBuilder.py +++ b/Configuration/Applications/python/ConfigBuilder.py @@ -2217,6 +2217,16 @@ def prepare(self, doChecking = False): self.pythonCfgCode += self.addCustomiseCmdLine() + # Temporary hack to put the early delete customization after + # everything else + # + # FIXME: remove when no longer needed + if "RECO" in self.stepMap or "RAW2RECO" in self.stepMap: + self.pythonCfgCode += "\n# Add early deletion of temporary data products to reduce peak memory need\n" + self.pythonCfgCode += "from Configuration.StandardSequences.earlyDeleteSettings_cff import customiseEarlyDeleteForRECO\n" + self.pythonCfgCode += "process = customiseEarlyDeleteForRECO(process)\n" + self.pythonCfgCode += "# End adding early deletion\n" + # make the .io file diff --git a/Configuration/StandardSequences/python/Reconstruction_cff.py b/Configuration/StandardSequences/python/Reconstruction_cff.py index 452710bdb7d9c..a135b74c2f198 100644 --- a/Configuration/StandardSequences/python/Reconstruction_cff.py +++ b/Configuration/StandardSequences/python/Reconstruction_cff.py @@ -135,6 +135,10 @@ noTrackingAndDependent.append(siStripZeroSuppression) noTrackingAndDependent.append(siStripClusters) noTrackingAndDependent.append(initialStepSeedLayersPreSplitting) +noTrackingAndDependent.append(trackerClusterCheckPreSplitting) +noTrackingAndDependent.append(initialStepTrackingRegionsPreSplitting) +noTrackingAndDependent.append(initialStepHitDoubletsPreSplitting) +noTrackingAndDependent.append(initialStepHitTripletsPreSplitting) noTrackingAndDependent.append(initialStepSeedsPreSplitting) noTrackingAndDependent.append(initialStepTrackCandidatesPreSplitting) noTrackingAndDependent.append(initialStepTracksPreSplitting) diff --git a/Configuration/StandardSequences/python/earlyDeleteSettings_cff.py b/Configuration/StandardSequences/python/earlyDeleteSettings_cff.py new file mode 100644 index 0000000000000..1c6ff931d9f40 --- /dev/null +++ b/Configuration/StandardSequences/python/earlyDeleteSettings_cff.py @@ -0,0 +1,7 @@ +# Abstract all early deletion settings here + +from RecoTracker.Configuration.customiseEarlyDeleteForSeeding import customiseEarlyDeleteForSeeding + +def customiseEarlyDeleteForRECO(process): + process = customiseEarlyDeleteForSeeding(process) + return process diff --git a/DataFormats/TrackerRecHit2D/src/classes.h b/DataFormats/TrackerRecHit2D/src/classes.h index e62dbf524dc7f..9bcb452602b3f 100644 --- a/DataFormats/TrackerRecHit2D/src/classes.h +++ b/DataFormats/TrackerRecHit2D/src/classes.h @@ -26,6 +26,7 @@ #include "DataFormats/TrackerRecHit2D/interface/FastProjectedTrackerRecHit.h" #include "DataFormats/TrackerRecHit2D/interface/FastTrackerRecHitCollection.h" #include "DataFormats/TrackerRecHit2D/interface/Phase2TrackerRecHit1D.h" +#include "DataFormats/TrackerRecHit2D/interface/BaseTrackerRecHit.h" #include namespace DataFormats_TrackerRecHit2D { @@ -62,7 +63,10 @@ namespace DataFormats_TrackerRecHit2D { edm::ClonePolicy > e3; edm::OwnVector >::const_iterator it10; - + + edm::OwnVector ovbtrh; + edm::Wrapper> wovbtrh; + edm::Wrapper< edm::RangeMap >, diff --git a/DataFormats/TrackerRecHit2D/src/classes_def.xml b/DataFormats/TrackerRecHit2D/src/classes_def.xml index 1d367bbac4bff..c4daab655997e 100644 --- a/DataFormats/TrackerRecHit2D/src/classes_def.xml +++ b/DataFormats/TrackerRecHit2D/src/classes_def.xml @@ -74,6 +74,10 @@ + + + + diff --git a/FastSimulation/Tracking/plugins/TrajectorySeedProducer.cc b/FastSimulation/Tracking/plugins/TrajectorySeedProducer.cc index 45c563cb86b68..b83c5a7da05dc 100644 --- a/FastSimulation/Tracking/plugins/TrajectorySeedProducer.cc +++ b/FastSimulation/Tracking/plugins/TrajectorySeedProducer.cc @@ -39,9 +39,7 @@ #include "DataFormats/TrajectorySeed/interface/TrajectorySeedCollection.h" // reco track classes -#include "RecoTracker/TkTrackingRegions/interface/GlobalTrackingRegion.h" -#include "RecoTracker/TkTrackingRegions/interface/TrackingRegionProducer.h" -#include "RecoTracker/TkTrackingRegions/interface/TrackingRegionProducerFactory.h" +#include "RecoTracker/TkTrackingRegions/interface/TrackingRegion.h" #include "RecoTracker/TkSeedingLayers/interface/SeedingHitSet.h" #include "RecoTracker/TkSeedGenerator/interface/SeedCreator.h" #include "RecoTracker/TkSeedGenerator/interface/SeedCreatorFactory.h" @@ -67,6 +65,7 @@ class TrajectorySeedProducer: edm::EDGetTokenT recHitCombinationsToken; edm::EDGetTokenT > hitMasksToken; + edm::EDGetTokenT > trackingRegionToken; // other data members unsigned int nHitsPerSeed_; @@ -75,7 +74,6 @@ class TrajectorySeedProducer: SeedingTree _seedingTree; std::unique_ptr seedCreator; - std::unique_ptr theRegionProducer; std::string measurementTrackerLabel; std::unique_ptr seedFinderSelector; @@ -139,10 +137,8 @@ TrajectorySeedProducer::TrajectorySeedProducer(const edm::ParameterSet& conf) seedFinderSelector.reset(new SeedFinderSelector(conf.getParameter("seedFinderSelector"),consumesCollector())); } - /// region producer - edm::ParameterSet regfactoryPSet = conf.getParameter("RegionFactoryPSet"); - std::string regfactoryName = regfactoryPSet.getParameter("ComponentName"); - theRegionProducer.reset(TrackingRegionProducerFactory::get()->create(regfactoryName,regfactoryPSet,consumesCollector())); + /// regions + trackingRegionToken = consumes >(conf.getParameter("trackingRegions")); // seed creator const edm::ParameterSet & seedCreatorPSet = conf.getParameter("SeedCreatorPSet"); @@ -174,8 +170,10 @@ void TrajectorySeedProducer::produce(edm::Event& e, const edm::EventSetup& es) // output data std::unique_ptr output(new TrajectorySeedCollection()); - // produce the regions; - const auto regions = theRegionProducer->regions(e,es); + // read the regions; + edm::Handle > hregions; + e.getByToken(trackingRegionToken, hregions); + const auto& regions = *hregions; // and make sure there is at least one region if(regions.size() == 0) { @@ -208,12 +206,12 @@ void TrajectorySeedProducer::produce(edm::Event& e, const edm::EventSetup& es) } // loop over the regions - for(auto region = regions.begin();region != regions.end(); ++region) + for(const auto& region: regions) { // set the region used in the selector if(seedFinderSelector) { - seedFinderSelector->setTrackingRegion(region->get()); + seedFinderSelector->setTrackingRegion(®ion); } // find hits compatible with the seed requirements @@ -233,7 +231,7 @@ void TrajectorySeedProducer::produce(edm::Event& e, const edm::EventSetup& es) fastTrackingUtilities::setRecHitCombinationIndex(seedHits,icomb); // create the seed - seedCreator->init(**region,es,0); + seedCreator->init(region,es,0); seedCreator->makeSeed( *output, SeedingHitSet( diff --git a/FastSimulation/Tracking/python/DetachedTripletStep_cff.py b/FastSimulation/Tracking/python/DetachedTripletStep_cff.py index 4c0590232628e..0c39cd0bb2d37 100644 --- a/FastSimulation/Tracking/python/DetachedTripletStep_cff.py +++ b/FastSimulation/Tracking/python/DetachedTripletStep_cff.py @@ -2,19 +2,23 @@ # import the full tracking equivalent of this file import RecoTracker.IterativeTracking.DetachedTripletStep_cff as _standard +from FastSimulation.Tracking.SeedingMigration import _hitSetProducerToFactoryPSet # fast tracking mask producer import FastSimulation.Tracking.FastTrackerRecHitMaskProducer_cfi detachedTripletStepMasks = FastSimulation.Tracking.FastTrackerRecHitMaskProducer_cfi.maskProducerFromClusterRemover(_standard.detachedTripletStepClusters) +# tracking regions +detachedTripletStepTrackingRegions = _standard.detachedTripletStepTrackingRegions.clone() + # trajectory seeds import FastSimulation.Tracking.TrajectorySeedProducer_cfi detachedTripletStepSeeds = FastSimulation.Tracking.TrajectorySeedProducer_cfi.trajectorySeedProducer.clone( layerList = _standard.detachedTripletStepSeedLayers.layerList.value(), - RegionFactoryPSet = _standard.detachedTripletStepSeeds.RegionFactoryPSet, + trackingRegions = "detachedTripletStepTrackingRegions", hitMasks = cms.InputTag("detachedTripletStepMasks") ) -detachedTripletStepSeeds.seedFinderSelector.pixelTripletGeneratorFactory = _standard.detachedTripletStepSeeds.OrderedHitsFactoryPSet.GeneratorPSet +detachedTripletStepSeeds.seedFinderSelector.pixelTripletGeneratorFactory = _hitSetProducerToFactoryPSet(_standard.detachedTripletStepHitTriplets) # track candidates import FastSimulation.Tracking.TrackCandidateProducer_cfi @@ -36,6 +40,7 @@ # Final sequence DetachedTripletStep = cms.Sequence(detachedTripletStepMasks + +detachedTripletStepTrackingRegions +detachedTripletStepSeeds +detachedTripletStepTrackCandidates +detachedTripletStepTracks diff --git a/FastSimulation/Tracking/python/InitialStep_cff.py b/FastSimulation/Tracking/python/InitialStep_cff.py index b2bcaccc2d117..603334bbd9462 100644 --- a/FastSimulation/Tracking/python/InitialStep_cff.py +++ b/FastSimulation/Tracking/python/InitialStep_cff.py @@ -2,14 +2,18 @@ # import the full tracking equivalent of this file import RecoTracker.IterativeTracking.InitialStep_cff as _standard +from FastSimulation.Tracking.SeedingMigration import _hitSetProducerToFactoryPSet + +# tracking regions +initialStepTrackingRegions = _standard.initialStepTrackingRegions.clone() # trajectory seeds import FastSimulation.Tracking.TrajectorySeedProducer_cfi initialStepSeeds = FastSimulation.Tracking.TrajectorySeedProducer_cfi.trajectorySeedProducer.clone( layerList = _standard.initialStepSeedLayers.layerList.value(), - RegionFactoryPSet = _standard.initialStepSeeds.RegionFactoryPSet + trackingRegions = "initialStepTrackingRegions" ) -initialStepSeeds.seedFinderSelector.pixelTripletGeneratorFactory = _standard.initialStepSeeds.OrderedHitsFactoryPSet.GeneratorPSet +initialStepSeeds.seedFinderSelector.pixelTripletGeneratorFactory = _hitSetProducerToFactoryPSet(_standard.initialStepHitTriplets) initialStepSeeds.seedFinderSelector.pixelTripletGeneratorFactory.SeedComparitorPSet.ComponentName = "none" # track candidates @@ -36,7 +40,8 @@ initialStep = _standard.initialStep.clone() # Final sequence -InitialStep = cms.Sequence(initialStepSeeds +InitialStep = cms.Sequence(initialStepTrackingRegions + +initialStepSeeds +initialStepTrackCandidates +initialStepTracks +firstStepPrimaryVerticesBeforeMixing diff --git a/FastSimulation/Tracking/python/LowPtTripletStep_cff.py b/FastSimulation/Tracking/python/LowPtTripletStep_cff.py index a96a8cbcf6620..875c32903ff09 100644 --- a/FastSimulation/Tracking/python/LowPtTripletStep_cff.py +++ b/FastSimulation/Tracking/python/LowPtTripletStep_cff.py @@ -2,19 +2,23 @@ # import the full tracking equivalent of this file import RecoTracker.IterativeTracking.LowPtTripletStep_cff as _standard +from FastSimulation.Tracking.SeedingMigration import _hitSetProducerToFactoryPSet # fast tracking mask producer import FastSimulation.Tracking.FastTrackerRecHitMaskProducer_cfi lowPtTripletStepMasks = FastSimulation.Tracking.FastTrackerRecHitMaskProducer_cfi.maskProducerFromClusterRemover(_standard.lowPtTripletStepClusters) +# tracking regions +lowPtTripletStepTrackingRegions = _standard.lowPtTripletStepTrackingRegions.clone() + # trajectory seeds import FastSimulation.Tracking.TrajectorySeedProducer_cfi lowPtTripletStepSeeds = FastSimulation.Tracking.TrajectorySeedProducer_cfi.trajectorySeedProducer.clone( layerList = _standard.lowPtTripletStepSeedLayers.layerList.value(), - RegionFactoryPSet = _standard.lowPtTripletStepSeeds.RegionFactoryPSet, + trackingRegions = "lowPtTripletStepTrackingRegions", hitMasks = cms.InputTag("lowPtTripletStepMasks"), ) -lowPtTripletStepSeeds.seedFinderSelector.pixelTripletGeneratorFactory = _standard.lowPtTripletStepSeeds.OrderedHitsFactoryPSet.GeneratorPSet +lowPtTripletStepSeeds.seedFinderSelector.pixelTripletGeneratorFactory = _hitSetProducerToFactoryPSet(_standard.lowPtTripletStepHitTriplets) #lowPtTripletStepSeeds.pixelTripletGeneratorFactory.SeedComparitorPSet=cms.PSet( ComponentName = cms.string( "none" ) ) # track candidates @@ -34,6 +38,7 @@ # Final swquence LowPtTripletStep = cms.Sequence(lowPtTripletStepMasks + +lowPtTripletStepTrackingRegions +lowPtTripletStepSeeds +lowPtTripletStepTrackCandidates +lowPtTripletStepTracks diff --git a/FastSimulation/Tracking/python/MixedTripletStep_cff.py b/FastSimulation/Tracking/python/MixedTripletStep_cff.py index 2aa3feb3bc3cc..bc2b213e09f77 100644 --- a/FastSimulation/Tracking/python/MixedTripletStep_cff.py +++ b/FastSimulation/Tracking/python/MixedTripletStep_cff.py @@ -2,30 +2,36 @@ # import the full tracking equivalent of this file import RecoTracker.IterativeTracking.MixedTripletStep_cff as _standard +from FastSimulation.Tracking.SeedingMigration import _hitSetProducerToFactoryPSet # fast tracking mask producer import FastSimulation.Tracking.FastTrackerRecHitMaskProducer_cfi mixedTripletStepMasks = FastSimulation.Tracking.FastTrackerRecHitMaskProducer_cfi.maskProducerFromClusterRemover(_standard.mixedTripletStepClusters) mixedTripletStepMasks.oldHitRemovalInfo = cms.InputTag("pixelPairStepMasks") +# tracking regions +mixedTripletStepTrackingRegionsA = _standard.mixedTripletStepTrackingRegionsA.clone() + # trajectory seeds import FastSimulation.Tracking.TrajectorySeedProducer_cfi mixedTripletStepSeedsA = FastSimulation.Tracking.TrajectorySeedProducer_cfi.trajectorySeedProducer.clone( layerList = _standard.mixedTripletStepSeedLayersA.layerList.value(), - RegionFactoryPSet = _standard.mixedTripletStepSeedsA.RegionFactoryPSet, + trackingRegions = "mixedTripletStepTrackingRegionsA", hitMasks = cms.InputTag("mixedTripletStepMasks") ) -mixedTripletStepSeedsA.seedFinderSelector.pixelTripletGeneratorFactory = _standard.mixedTripletStepSeedsA.OrderedHitsFactoryPSet.GeneratorPSet +mixedTripletStepSeedsA.seedFinderSelector.pixelTripletGeneratorFactory = _hitSetProducerToFactoryPSet(_standard.mixedTripletStepHitTripletsA) ### +mixedTripletStepTrackingRegionsB = _standard.mixedTripletStepTrackingRegionsB.clone() + import FastSimulation.Tracking.TrajectorySeedProducer_cfi mixedTripletStepSeedsB = FastSimulation.Tracking.TrajectorySeedProducer_cfi.trajectorySeedProducer.clone( layerList = _standard.mixedTripletStepSeedLayersB.layerList.value(), - RegionFactoryPSet = _standard.mixedTripletStepSeedsB.RegionFactoryPSet, + trackingRegions = "mixedTripletStepTrackingRegionsB", hitMasks = cms.InputTag("mixedTripletStepMasks") ) -mixedTripletStepSeedsB.seedFinderSelector.pixelTripletGeneratorFactory = _standard.mixedTripletStepSeedsB.OrderedHitsFactoryPSet.GeneratorPSet +mixedTripletStepSeedsB.seedFinderSelector.pixelTripletGeneratorFactory = _hitSetProducerToFactoryPSet(_standard.mixedTripletStepHitTripletsB) mixedTripletStepSeeds = _standard.mixedTripletStepSeeds.clone() @@ -50,7 +56,9 @@ # Final sequence MixedTripletStep = cms.Sequence(mixedTripletStepMasks + +mixedTripletStepTrackingRegionsA +mixedTripletStepSeedsA + +mixedTripletStepTrackingRegionsB +mixedTripletStepSeedsB +mixedTripletStepSeeds +mixedTripletStepTrackCandidates diff --git a/FastSimulation/Tracking/python/PixelLessStep_cff.py b/FastSimulation/Tracking/python/PixelLessStep_cff.py index 934afb476bdfc..1543d9c286edd 100644 --- a/FastSimulation/Tracking/python/PixelLessStep_cff.py +++ b/FastSimulation/Tracking/python/PixelLessStep_cff.py @@ -2,19 +2,23 @@ # import the full tracking equivalent of this file import RecoTracker.IterativeTracking.PixelLessStep_cff as _standard +from FastSimulation.Tracking.SeedingMigration import _hitSetProducerToFactoryPSet # fast tracking mask producer import FastSimulation.Tracking.FastTrackerRecHitMaskProducer_cfi pixelLessStepMasks = FastSimulation.Tracking.FastTrackerRecHitMaskProducer_cfi.maskProducerFromClusterRemover(_standard.pixelLessStepClusters) +# tracking regions +pixelLessStepTrackingRegions = _standard.pixelLessStepTrackingRegions.clone() + # trajectory seeds import FastSimulation.Tracking.TrajectorySeedProducer_cfi pixelLessStepSeeds = FastSimulation.Tracking.TrajectorySeedProducer_cfi.trajectorySeedProducer.clone( layerList = _standard.pixelLessStepSeedLayers.layerList.value(), - RegionFactoryPSet = _standard.pixelLessStepSeeds.RegionFactoryPSet, + trackingRegions = "pixelLessStepTrackingRegions", hitMasks = cms.InputTag("pixelLessStepMasks"), ) -pixelLessStepSeeds.seedFinderSelector.MultiHitGeneratorFactory = _standard.pixelLessStepSeeds.OrderedHitsFactoryPSet.GeneratorPSet +pixelLessStepSeeds.seedFinderSelector.MultiHitGeneratorFactory = _hitSetProducerToFactoryPSet(_standard.pixelLessStepHitTriplets) pixelLessStepSeeds.seedFinderSelector.MultiHitGeneratorFactory.refitHits = False # track candidates @@ -37,6 +41,7 @@ # Final sequence PixelLessStep = cms.Sequence(pixelLessStepMasks + +pixelLessStepTrackingRegions +pixelLessStepSeeds +pixelLessStepTrackCandidates +pixelLessStepTracks diff --git a/FastSimulation/Tracking/python/PixelPairStep_cff.py b/FastSimulation/Tracking/python/PixelPairStep_cff.py index e8befc4f59c66..e5f2a860f45da 100644 --- a/FastSimulation/Tracking/python/PixelPairStep_cff.py +++ b/FastSimulation/Tracking/python/PixelPairStep_cff.py @@ -7,14 +7,18 @@ import FastSimulation.Tracking.FastTrackerRecHitMaskProducer_cfi pixelPairStepMasks = FastSimulation.Tracking.FastTrackerRecHitMaskProducer_cfi.maskProducerFromClusterRemover(_standard.pixelPairStepClusters) +# tracking regions +pixelPairStepTrackingRegions = _standard.pixelPairStepTrackingRegions.clone( + RegionPSet=dict(VertexCollection = "firstStepPrimaryVerticesBeforeMixing") +) + # trajectory seeds import FastSimulation.Tracking.TrajectorySeedProducer_cfi pixelPairStepSeeds = FastSimulation.Tracking.TrajectorySeedProducer_cfi.trajectorySeedProducer.clone( layerList = _standard.pixelPairStepSeedLayers.layerList.value(), - RegionFactoryPSet = _standard.pixelPairStepSeeds.RegionFactoryPSet, + trackingRegions = "pixelPairStepTrackingRegions", hitMasks = cms.InputTag("pixelPairStepMasks"), ) -pixelPairStepSeeds.RegionFactoryPSet.RegionPSet.VertexCollection = cms.InputTag("firstStepPrimaryVerticesBeforeMixing") # track candidate import FastSimulation.Tracking.TrackCandidateProducer_cfi @@ -33,6 +37,7 @@ # Final sequence PixelPairStep = cms.Sequence(pixelPairStepMasks + +pixelPairStepTrackingRegions +pixelPairStepSeeds +pixelPairStepTrackCandidates +pixelPairStepTracks diff --git a/FastSimulation/Tracking/python/SeedingMigration.py b/FastSimulation/Tracking/python/SeedingMigration.py new file mode 100644 index 0000000000000..be2bfe77bf35f --- /dev/null +++ b/FastSimulation/Tracking/python/SeedingMigration.py @@ -0,0 +1,18 @@ +import FWCore.ParameterSet.Config as cms + +def _copy(old, new, skip=[]): + skipSet = set(skip) + for key in old.parameterNames_(): + if key not in skipSet: + setattr(new, key, getattr(old, key)) + +def _hitSetProducerToFactoryPSet(producer): + _map = { + "PixelTripletHLTEDProducer": "PixelTripletHLTGenerator", + "PixelTripletLargeTipEDProducer": "PixelTripletLargeTipGenerator", + "MultiHitFromChi2EDProducer": "MultiHitGeneratorFromChi2", + } + ret = cms.PSet() + _copy(producer, ret) + ret.ComponentName = cms.string(_map[producer._TypedParameterizable__type]); + return ret diff --git a/FastSimulation/Tracking/python/TobTecStep_cff.py b/FastSimulation/Tracking/python/TobTecStep_cff.py index b4ea8f4068bf5..87595f87a4749 100644 --- a/FastSimulation/Tracking/python/TobTecStep_cff.py +++ b/FastSimulation/Tracking/python/TobTecStep_cff.py @@ -2,27 +2,34 @@ # import the full tracking equivalent of this file import RecoTracker.IterativeTracking.TobTecStep_cff as _standard +from FastSimulation.Tracking.SeedingMigration import _hitSetProducerToFactoryPSet # fast tracking mask producer import FastSimulation.Tracking.FastTrackerRecHitMaskProducer_cfi tobTecStepMasks = FastSimulation.Tracking.FastTrackerRecHitMaskProducer_cfi.maskProducerFromClusterRemover(_standard.tobTecStepClusters) +# tracking regions +tobTecStepTrackingRegionsTripl = _standard.tobTecStepTrackingRegionsTripl.clone() + # trajectory seeds import FastSimulation.Tracking.TrajectorySeedProducer_cfi tobTecStepSeedsTripl = FastSimulation.Tracking.TrajectorySeedProducer_cfi.trajectorySeedProducer.clone( layerList = _standard.tobTecStepSeedLayersTripl.layerList.value(), - RegionFactoryPSet = _standard.tobTecStepSeedsTripl.RegionFactoryPSet, + trackingRegions = "tobTecStepTrackingRegionsTripl", hitMasks = cms.InputTag("tobTecStepMasks"), ) -tobTecStepSeedsTripl.seedFinderSelector.MultiHitGeneratorFactory = _standard.tobTecStepSeedsTripl.OrderedHitsFactoryPSet.GeneratorPSet +tobTecStepSeedsTripl.seedFinderSelector.MultiHitGeneratorFactory = _hitSetProducerToFactoryPSet(_standard.tobTecStepHitTripletsTripl) tobTecStepSeedsTripl.seedFinderSelector.MultiHitGeneratorFactory.SeedComparitorPSet=cms.PSet( ComponentName = cms.string( "none" ) ) tobTecStepSeedsTripl.seedFinderSelector.MultiHitGeneratorFactory.refitHits = False +# pair tracking regions +tobTecStepTrackingRegionsPair = _standard.tobTecStepTrackingRegionsPair.clone() + #pair seeds import FastSimulation.Tracking.TrajectorySeedProducer_cfi tobTecStepSeedsPair = FastSimulation.Tracking.TrajectorySeedProducer_cfi.trajectorySeedProducer.clone( layerList = _standard.tobTecStepSeedLayersPair.layerList.value(), - RegionFactoryPSet = _standard.tobTecStepSeedsPair.RegionFactoryPSet, + trackingRegions = "tobTecStepTrackingRegionsPair", hitMasks = cms.InputTag("tobTecStepMasks"), ) @@ -55,7 +62,9 @@ # Final sequence TobTecStep = cms.Sequence(tobTecStepMasks + +tobTecStepTrackingRegionsTripl +tobTecStepSeedsTripl + +tobTecStepTrackingRegionsPair +tobTecStepSeedsPair +tobTecStepSeeds +tobTecStepTrackCandidates diff --git a/FastSimulation/Tracking/python/TrajectorySeedProducer_cfi.py b/FastSimulation/Tracking/python/TrajectorySeedProducer_cfi.py index 51edf2940a862..c8bb81ca286b8 100644 --- a/FastSimulation/Tracking/python/TrajectorySeedProducer_cfi.py +++ b/FastSimulation/Tracking/python/TrajectorySeedProducer_cfi.py @@ -4,6 +4,7 @@ trajectorySeedProducer = cms.EDProducer( "TrajectorySeedProducer", + trackingRegions = cms.InputTag(""), SeedCreatorPSet = RecoTracker.TkSeedGenerator.SeedFromConsecutiveHitsCreator_cfi.SeedFromConsecutiveHitsCreator.clone( TTRHBuilder = cms.string("WithoutRefit")), recHitCombinations = cms.InputTag("fastMatchedTrackerRecHitCombinations"), diff --git a/FastSimulation/Tracking/python/hltSeeds_cff.py b/FastSimulation/Tracking/python/hltSeeds_cff.py index 74f264fe8f86a..56f21a37d9b80 100644 --- a/FastSimulation/Tracking/python/hltSeeds_cff.py +++ b/FastSimulation/Tracking/python/hltSeeds_cff.py @@ -2,12 +2,15 @@ import FastSimulation.Tracking.TrajectorySeedProducer_cfi import FastSimulation.Tracking.InitialStep_cff +# tracking regions +hltPixelTripletTrackingRegions = FastSimulation.Tracking.InitialStep_cff.initialStepTrackingRegions.clone() + # pixel triplet seeds import RecoTracker.TkSeedingLayers.PixelLayerTriplets_cfi hltPixelTripletSeeds = FastSimulation.Tracking.TrajectorySeedProducer_cfi.trajectorySeedProducer.clone( layerList = RecoTracker.TkSeedingLayers.PixelLayerTriplets_cfi.PixelLayerTriplets.layerList, skipSeedFinderSelector = cms.untracked.bool(True), - RegionFactoryPSet = FastSimulation.Tracking.InitialStep_cff.initialStepSeeds.RegionFactoryPSet.clone() + trackingRegions = "hltPixelTripletTrackingRegions" ) # pixel pair seeds @@ -17,9 +20,9 @@ hltPixelPairSeeds = FastSimulation.Tracking.TrajectorySeedProducer_cfi.trajectorySeedProducer.clone( layerList = RecoTracker.TkSeedingLayers.MixedLayerPairs_cfi.MixedLayerPairs.layerList, skipSeedFinderSelector = cms.untracked.bool(True), - RegionFactoryPSet = FastSimulation.Tracking.InitialStep_cff.initialStepSeeds.RegionFactoryPSet.clone() + trackingRegions = "hltPixelTripletTrackingRegions" ) # todo: add mixed pair seeds? -hltSeedSequence =cms.Sequence(hltPixelTripletSeeds+hltPixelPairSeeds) +hltSeedSequence =cms.Sequence(hltPixelTripletTrackingRegions+hltPixelTripletSeeds+hltPixelPairSeeds) diff --git a/RecoHI/HiMuonAlgos/plugins/HIMuonTrackingRegionProducer.h b/RecoHI/HiMuonAlgos/plugins/HIMuonTrackingRegionProducer.h index 07ec1f6cac0f9..828cdff36455d 100644 --- a/RecoHI/HiMuonAlgos/plugins/HIMuonTrackingRegionProducer.h +++ b/RecoHI/HiMuonAlgos/plugins/HIMuonTrackingRegionProducer.h @@ -39,6 +39,22 @@ class HIMuonTrackingRegionProducer : public TrackingRegionProducer { virtual ~HIMuonTrackingRegionProducer(){} + static void fillDescriptions(edm::ConfigurationDescriptions& descriptions) { + edm::ParameterSetDescription desc; + + desc.add("MuonSrc", edm::InputTag("")); + + edm::ParameterSetDescription descRegion; + MuonTrackingRegionBuilder::fillDescriptionsOffline(descRegion); + desc.add("MuonTrackingRegionBuilder", descRegion); + + edm::ParameterSetDescription descService; + descService.setAllowAnything(); + desc.add("ServiceParameters", descService); + + descriptions.add("HiTrackingRegionEDProducer", desc); + } + virtual std::vector > regions(const edm::Event& ev, const edm::EventSetup& es) const override { // initialize output vector of tracking regions diff --git a/RecoHI/HiMuonAlgos/plugins/SealModule.cc b/RecoHI/HiMuonAlgos/plugins/SealModule.cc index 09eb88f865bf8..43f6ab9b2ea38 100644 --- a/RecoHI/HiMuonAlgos/plugins/SealModule.cc +++ b/RecoHI/HiMuonAlgos/plugins/SealModule.cc @@ -9,3 +9,7 @@ using namespace cms; #include "RecoTracker/TkTrackingRegions/interface/TrackingRegionProducer.h" #include "HIMuonTrackingRegionProducer.h" DEFINE_EDM_PLUGIN(TrackingRegionProducerFactory, HIMuonTrackingRegionProducer, "HIMuonTrackingRegionProducer"); + +#include "RecoTracker/TkTrackingRegions/interface/TrackingRegionEDProducerT.h" +using HIMuonTrackingRegionEDProducer = TrackingRegionEDProducerT; +DEFINE_FWK_MODULE(HIMuonTrackingRegionEDProducer); diff --git a/RecoHI/HiMuonAlgos/python/HiRegitMuonDetachedTripletStep_cff.py b/RecoHI/HiMuonAlgos/python/HiRegitMuonDetachedTripletStep_cff.py index e1902abb8f1c2..7d37f0ecbc87b 100644 --- a/RecoHI/HiMuonAlgos/python/HiRegitMuonDetachedTripletStep_cff.py +++ b/RecoHI/HiMuonAlgos/python/HiRegitMuonDetachedTripletStep_cff.py @@ -5,15 +5,25 @@ ################################### 3rd step: low-pT and displaced tracks from pixel triplets from RecoHI.HiTracking.HITrackingRegionProducer_cfi import * -HiTrackingRegionFactoryFromSTAMuonsBlock.MuonTrackingRegionBuilder.vertexCollection = cms.InputTag("hiSelectedVertex") -HiTrackingRegionFactoryFromSTAMuonsBlock.MuonSrc= cms.InputTag("standAloneMuons","UpdatedAtVtx") - -HiTrackingRegionFactoryFromSTAMuonsBlock.MuonTrackingRegionBuilder.UseVertex = True - -HiTrackingRegionFactoryFromSTAMuonsBlock.MuonTrackingRegionBuilder.Phi_fixed = True -HiTrackingRegionFactoryFromSTAMuonsBlock.MuonTrackingRegionBuilder.Eta_fixed = True -HiTrackingRegionFactoryFromSTAMuonsBlock.MuonTrackingRegionBuilder.DeltaPhi = 0.3 -HiTrackingRegionFactoryFromSTAMuonsBlock.MuonTrackingRegionBuilder.DeltaEta = 0.2 +# Are the following values set to the same in every iteration? If yes, +# why not making the change in HITrackingRegionProducer_cfi directly +# once for all? +hiRegitMuDetachedTripletStepTrackingRegions = HiTrackingRegionFactoryFromSTAMuonsEDProducer.clone( + MuonSrc = "standAloneMuons:UpdatedAtVtx", # this is the same as default, why repeat? + MuonTrackingRegionBuilder = dict( + vertexCollection = "hiSelectedVertex", + UseVertex = True, + Phi_fixed = True, + Eta_fixed = True, + DeltaPhi = 0.3, + DeltaEta = 0.2, + # Ok, the following ones are specific to DetachedTripletStep + Pt_min = 0.9, + DeltaR = 2.0, # default = 0.2 + DeltaZ = 2.0, # this give you the length + Rescale_Dz = 4., # max(DeltaZ_Region,Rescale_Dz*vtx->zError()) + ) +) ################################### from RecoTracker.IterativeTracking.DetachedTripletStep_cff import * @@ -32,14 +42,17 @@ hiRegitMuDetachedTripletStepSeedLayers.FPix.skipClusters = cms.InputTag('hiRegitMuDetachedTripletStepClusters') # seeding -hiRegitMuDetachedTripletStepSeeds = RecoTracker.IterativeTracking.DetachedTripletStep_cff.detachedTripletStepSeeds.clone() -hiRegitMuDetachedTripletStepSeeds.RegionFactoryPSet = HiTrackingRegionFactoryFromSTAMuonsBlock.clone() -hiRegitMuDetachedTripletStepSeeds.ClusterCheckPSet.doClusterCheck = False # do not check for max number of clusters pixel or strips -hiRegitMuDetachedTripletStepSeeds.RegionFactoryPSet.MuonTrackingRegionBuilder.Pt_min = 0.9 -hiRegitMuDetachedTripletStepSeeds.RegionFactoryPSet.MuonTrackingRegionBuilder.DeltaR = 2.0 # default = 0.2 -hiRegitMuDetachedTripletStepSeeds.RegionFactoryPSet.MuonTrackingRegionBuilder.DeltaZ = 2.0 # this give you the length -hiRegitMuDetachedTripletStepSeeds.RegionFactoryPSet.MuonTrackingRegionBuilder.Rescale_Dz = 4. # max(DeltaZ_Region,Rescale_Dz*vtx->zError()) -hiRegitMuDetachedTripletStepSeeds.OrderedHitsFactoryPSet.SeedingLayers = 'hiRegitMuDetachedTripletStepSeedLayers' +hiRegitMuDetachedTripletStepHitDoublets = RecoTracker.IterativeTracking.DetachedTripletStep_cff.detachedTripletStepHitDoublets.clone( + seedingLayers = "hiRegitMuDetachedTripletStepSeedLayers", + trackingRegions = "hiRegitMuDetachedTripletStepTrackingRegions", + clusterCheck = "hiRegitMuClusterCheck", +) +hiRegitMuDetachedTripletStepHitTriplets = RecoTracker.IterativeTracking.DetachedTripletStep_cff.detachedTripletStepHitTriplets.clone( + doublets = "hiRegitMuDetachedTripletStepHitDoublets" +) +hiRegitMuDetachedTripletStepSeeds = RecoTracker.IterativeTracking.DetachedTripletStep_cff.detachedTripletStepSeeds.clone( + seedingHitSets = "hiRegitMuDetachedTripletStepHitTriplets" +) from RecoPixelVertexing.PixelLowPtUtilities.ClusterShapeHitFilterESProducer_cfi import * @@ -102,6 +115,9 @@ hiRegitMuonDetachedTripletStep = cms.Sequence(hiRegitMuDetachedTripletStepClusters* hiRegitMuDetachedTripletStepSeedLayers* + hiRegitMuDetachedTripletStepTrackingRegions* + hiRegitMuDetachedTripletStepHitDoublets* + hiRegitMuDetachedTripletStepHitTriplets* hiRegitMuDetachedTripletStepSeeds* hiRegitMuDetachedTripletStepTrackCandidates* hiRegitMuDetachedTripletStepTracks* diff --git a/RecoHI/HiMuonAlgos/python/HiRegitMuonInitialStep_cff.py b/RecoHI/HiMuonAlgos/python/HiRegitMuonInitialStep_cff.py index eec5c0e42ae5c..1a4d8e8d3a24e 100644 --- a/RecoHI/HiMuonAlgos/python/HiRegitMuonInitialStep_cff.py +++ b/RecoHI/HiMuonAlgos/python/HiRegitMuonInitialStep_cff.py @@ -3,13 +3,25 @@ # pp iterative tracking modified for hiOffline reco (the vertex is the one reconstructed in HI) ################################### 0st step:pixel-triplet seeding, high-pT; from RecoHI.HiTracking.HITrackingRegionProducer_cfi import * -HiTrackingRegionFactoryFromSTAMuonsBlock.MuonTrackingRegionBuilder.vertexCollection = cms.InputTag("hiSelectedVertex") -HiTrackingRegionFactoryFromSTAMuonsBlock.MuonSrc= cms.InputTag("standAloneMuons","UpdatedAtVtx") - -HiTrackingRegionFactoryFromSTAMuonsBlock.MuonTrackingRegionBuilder.Phi_fixed = True -HiTrackingRegionFactoryFromSTAMuonsBlock.MuonTrackingRegionBuilder.Eta_fixed = True -HiTrackingRegionFactoryFromSTAMuonsBlock.MuonTrackingRegionBuilder.DeltaPhi = 0.3 -HiTrackingRegionFactoryFromSTAMuonsBlock.MuonTrackingRegionBuilder.DeltaEta = 0.2 +# Are the following values set to the same in every iteration? If yes, +# why not making the change in HITrackingRegionProducer_cfi directly +# once for all? +hiRegitMuInitialStepTrackingRegions = HiTrackingRegionFactoryFromSTAMuonsEDProducer.clone( + MuonSrc = "standAloneMuons:UpdatedAtVtx", # this is the same as default, why repeat? + MuonTrackingRegionBuilder = dict( + vertexCollection = "hiSelectedVertex", + UseVertex = True, + Phi_fixed = True, + Eta_fixed = True, + DeltaPhi = 0.3, + DeltaEta = 0.2, + # Ok, the following ones are specific to InitialStep + Pt_min = 3.0, + DeltaR = 1, # default = 0.2 + DeltaZ = 1, # this give you the length + Rescale_Dz = 4., # max(DeltaZ_Region,Rescale_Dz*vtx->zError()) + ) +) ################################### from RecoTracker.IterativeTracking.InitialStep_cff import * @@ -18,14 +30,17 @@ hiRegitMuInitialStepSeedLayers = RecoTracker.IterativeTracking.InitialStep_cff.initialStepSeedLayers.clone() # seeding -hiRegitMuInitialStepSeeds = RecoTracker.IterativeTracking.InitialStep_cff.initialStepSeeds.clone() -hiRegitMuInitialStepSeeds.RegionFactoryPSet = HiTrackingRegionFactoryFromSTAMuonsBlock.clone() -hiRegitMuInitialStepSeeds.OrderedHitsFactoryPSet.SeedingLayers = cms.InputTag("hiRegitMuInitialStepSeedLayers") -hiRegitMuInitialStepSeeds.ClusterCheckPSet.doClusterCheck = False # do not check for max number of clusters pixel or strips -hiRegitMuInitialStepSeeds.RegionFactoryPSet.MuonTrackingRegionBuilder.Pt_min = 3.0 -hiRegitMuInitialStepSeeds.RegionFactoryPSet.MuonTrackingRegionBuilder.DeltaR = 1 # default = 0.2 -hiRegitMuInitialStepSeeds.RegionFactoryPSet.MuonTrackingRegionBuilder.DeltaZ = 1 # this give you the length -hiRegitMuInitialStepSeeds.RegionFactoryPSet.MuonTrackingRegionBuilder.Rescale_Dz = 4. # max(DeltaZ_Region,Rescale_Dz*vtx->zError()) +hiRegitMuInitialStepHitDoublets = RecoTracker.IterativeTracking.InitialStep_cff.initialStepHitDoublets.clone( + seedingLayers = "hiRegitMuInitialStepSeedLayers", + trackingRegions = "hiRegitMuInitialStepTrackingRegions", + clusterCheck = "hiRegitMuClusterCheck", +) +hiRegitMuInitialStepHitTriplets = RecoTracker.IterativeTracking.InitialStep_cff.initialStepHitTriplets.clone( + doublets = "hiRegitMuInitialStepHitDoublets" +) +hiRegitMuInitialStepSeeds = RecoTracker.IterativeTracking.InitialStep_cff.initialStepSeeds.clone( + seedingHitSets = "hiRegitMuInitialStepHitTriplets" +) # building: feed the new-named seeds @@ -91,6 +106,9 @@ ) hiRegitMuonInitialStep = cms.Sequence(hiRegitMuInitialStepSeedLayers* + hiRegitMuInitialStepTrackingRegions* + hiRegitMuInitialStepHitDoublets* + hiRegitMuInitialStepHitTriplets* hiRegitMuInitialStepSeeds* hiRegitMuInitialStepTrackCandidates* hiRegitMuInitialStepTracks* diff --git a/RecoHI/HiMuonAlgos/python/HiRegitMuonLowPtTripletStep_cff.py b/RecoHI/HiMuonAlgos/python/HiRegitMuonLowPtTripletStep_cff.py deleted file mode 100644 index 4128eb676c05a..0000000000000 --- a/RecoHI/HiMuonAlgos/python/HiRegitMuonLowPtTripletStep_cff.py +++ /dev/null @@ -1,122 +0,0 @@ -import FWCore.ParameterSet.Config as cms - -# pp iterative tracking modified for hiOffline reco (the vertex is the one reconstructed in HI) -################################### 1st step:pixel-triplet seeding, lower-pT; - -from RecoHI.HiTracking.HITrackingRegionProducer_cfi import * -HiTrackingRegionFactoryFromSTAMuonsBlock.MuonTrackingRegionBuilder.vertexCollection = cms.InputTag("hiSelectedVertex") -HiTrackingRegionFactoryFromSTAMuonsBlock.MuonSrc= cms.InputTag("standAloneMuons","UpdatedAtVtx") - -HiTrackingRegionFactoryFromSTAMuonsBlock.MuonTrackingRegionBuilder.UseVertex = True -HiTrackingRegionFactoryFromSTAMuonsBlock.MuonTrackingRegionBuilder.Phi_fixed = True -HiTrackingRegionFactoryFromSTAMuonsBlock.MuonTrackingRegionBuilder.Eta_fixed = True -HiTrackingRegionFactoryFromSTAMuonsBlock.MuonTrackingRegionBuilder.DeltaPhi = 0.3 -HiTrackingRegionFactoryFromSTAMuonsBlock.MuonTrackingRegionBuilder.DeltaEta = 0.2 - -################################### -from RecoTracker.IterativeTracking.LowPtTripletStep_cff import * - -# remove previously used clusters -hiRegitMuLowPtTripletStepClusters = RecoTracker.IterativeTracking.LowPtTripletStep_cff.lowPtTripletStepClusters.clone( - trajectories = cms.InputTag("hiRegitMuDetachedTripletStepTracks"), - overrideTrkQuals = cms.InputTag('hiRegitMuDetachedTripletStepSelector','hiRegitMuDetachedTripletStep'), - trackClassifier = cms.InputTag(''), - oldClusterRemovalInfo = cms.InputTag("hiRegitMuDetachedTripletStepClusters"), - TrackQuality = cms.string('tight') -) - -# SEEDING LAYERS -hiRegitMuLowPtTripletStepSeedLayers = RecoTracker.IterativeTracking.LowPtTripletStep_cff.lowPtTripletStepSeedLayers.clone() -hiRegitMuLowPtTripletStepSeedLayers.BPix.skipClusters = cms.InputTag('hiRegitMuLowPtTripletStepClusters') -hiRegitMuLowPtTripletStepSeedLayers.FPix.skipClusters = cms.InputTag('hiRegitMuLowPtTripletStepClusters') - -# seeds -hiRegitMuLowPtTripletStepSeeds = RecoTracker.IterativeTracking.LowPtTripletStep_cff.lowPtTripletStepSeeds.clone() -hiRegitMuLowPtTripletStepSeeds.RegionFactoryPSet = HiTrackingRegionFactoryFromSTAMuonsBlock.clone() -hiRegitMuLowPtTripletStepSeeds.ClusterCheckPSet.doClusterCheck = False # do not check for max number of clusters pixel or strips -hiRegitMuLowPtTripletStepSeeds.RegionFactoryPSet.MuonTrackingRegionBuilder.Pt_min = 0.9 -hiRegitMuLowPtTripletStepSeeds.RegionFactoryPSet.MuonTrackingRegionBuilder.DeltaR = 1. # default = 0.2 -hiRegitMuLowPtTripletStepSeeds.RegionFactoryPSet.MuonTrackingRegionBuilder.DeltaZ = 1. # this give you the length -hiRegitMuLowPtTripletStepSeeds.RegionFactoryPSet.MuonTrackingRegionBuilder.Rescale_Dz = 4. # max(DeltaZ_Region,Rescale_Dz*vtx->zError()) -hiRegitMuLowPtTripletStepSeeds.OrderedHitsFactoryPSet.SeedingLayers = 'hiRegitMuLowPtTripletStepSeedLayers' - - - -# building: feed the new-named seeds -hiRegitMuLowPtTripletStepStandardTrajectoryFilter = TrackingTools.TrajectoryFiltering.TrajectoryFilter_cff.CkfBaseTrajectoryFilter_block.clone( - minPt = 0.8 - ) - -hiRegitMuLowPtTripletStepTrajectoryFilter = cms.PSet( - ComponentType = cms.string('CompositeTrajectoryFilter'), - filters = cms.VPSet(cms.PSet( - refToPSet_ = cms.string('hiRegitMuLowPtTripletStepStandardTrajectoryFilter') - ), - cms.PSet( - refToPSet_ = cms.string('ClusterShapeTrajectoryFilter') - )) - ) - - -hiRegitMuLowPtTripletStepTrajectoryBuilder = RecoTracker.IterativeTracking.LowPtTripletStep_cff.lowPtTripletStepTrajectoryBuilder.clone( - trajectoryFilter = cms.PSet( - refToPSet_ = cms.string('hiRegitMuLowPtTripletStepTrajectoryFilter',) - ), -) - -# track candidates -hiRegitMuLowPtTripletStepTrackCandidates = RecoTracker.IterativeTracking.LowPtTripletStep_cff.lowPtTripletStepTrackCandidates.clone( - src = cms.InputTag('hiRegitMuLowPtTripletStepSeeds'), - TrajectoryBuilderPSet = cms.PSet( - refToPSet_ = cms.string('hiRegitMuLowPtTripletStepTrajectoryBuilder') - ), - clustersToSkip = cms.InputTag('hiRegitMuLowPtTripletStepClusters'), - maxNSeeds = cms.uint32(1000000) - ) - -# fitting: feed new-names -hiRegitMuLowPtTripletStepTracks = RecoTracker.IterativeTracking.LowPtTripletStep_cff.lowPtTripletStepTracks.clone( - AlgorithmName = cms.string('hiRegitMuLowPtTripletStep'), - src = 'hiRegitMuLowPtTripletStepTrackCandidates' -) - - -import RecoTracker.FinalTrackSelectors.multiTrackSelector_cfi -import RecoHI.HiTracking.hiMultiTrackSelector_cfi -hiRegitMuLowPtTripletStepSelector = RecoHI.HiTracking.hiMultiTrackSelector_cfi.hiMultiTrackSelector.clone( - src ='hiRegitMuLowPtTripletStepTracks', - vertices = cms.InputTag("hiSelectedVertex"), - useAnyMVA = cms.bool(True), - GBRForestLabel = cms.string('HIMVASelectorIter5'), - GBRForestVars = cms.vstring(['chi2perdofperlayer', 'dxyperdxyerror', 'dzperdzerror', 'relpterr', 'nhits', 'nlayers', 'eta']), - trackSelectors= cms.VPSet( - RecoTracker.FinalTrackSelectors.multiTrackSelector_cfi.looseMTS.clone( - name = 'hiRegitMuLowPtTripletStepLoose', - min_nhits = cms.uint32(8) - ), #end of pset - RecoHI.HiTracking.hiMultiTrackSelector_cfi.hiLooseMTS.clone( - name = 'hiRegitMuLowPtTripletStepTight', - preFilterName = 'hiRegitMuLowPtTripletStepLoose', - min_nhits = cms.uint32(8), - useMVA = cms.bool(True), - minMVA = cms.double(-0.58) - ), - RecoHI.HiTracking.hiMultiTrackSelector_cfi.hiTightMTS.clone( - name = 'hiRegitMuLowPtTripletStep', - preFilterName = 'hiRegitMuLowPtTripletStepTight', - min_nhits = cms.uint32(8), - useMVA = cms.bool(True), - minMVA = cms.double(0.35) - ), - ) #end of vpset -) - -hiRegitMuonLowPtTripletStep = cms.Sequence(hiRegitMuLowPtTripletStepClusters* - hiRegitMuLowPtTripletStepSeedLayers* - hiRegitMuLowPtTripletStepSeeds* - hiRegitMuLowPtTripletStepTrackCandidates* - hiRegitMuLowPtTripletStepTracks* - hiRegitMuLowPtTripletStepSelector) - - - diff --git a/RecoHI/HiMuonAlgos/python/HiRegitMuonMixedTripletStep_cff.py b/RecoHI/HiMuonAlgos/python/HiRegitMuonMixedTripletStep_cff.py index 6f8d88e12ee1e..23109439cd5ea 100644 --- a/RecoHI/HiMuonAlgos/python/HiRegitMuonMixedTripletStep_cff.py +++ b/RecoHI/HiMuonAlgos/python/HiRegitMuonMixedTripletStep_cff.py @@ -5,14 +5,28 @@ ################################### 4th step: large impact parameter tracking using mixed-triplet seeding from RecoHI.HiTracking.HITrackingRegionProducer_cfi import * -HiTrackingRegionFactoryFromSTAMuonsBlock.MuonTrackingRegionBuilder.vertexCollection = cms.InputTag("hiSelectedVertex") -HiTrackingRegionFactoryFromSTAMuonsBlock.MuonSrc= cms.InputTag("standAloneMuons","UpdatedAtVtx") - -HiTrackingRegionFactoryFromSTAMuonsBlock.MuonTrackingRegionBuilder.UseVertex = True -HiTrackingRegionFactoryFromSTAMuonsBlock.MuonTrackingRegionBuilder.Phi_fixed = True -HiTrackingRegionFactoryFromSTAMuonsBlock.MuonTrackingRegionBuilder.Eta_fixed = True -HiTrackingRegionFactoryFromSTAMuonsBlock.MuonTrackingRegionBuilder.DeltaPhi = 0.3 -HiTrackingRegionFactoryFromSTAMuonsBlock.MuonTrackingRegionBuilder.DeltaEta = 0.2 +# Are the following values set to the same in every iteration? If yes, +# why not making the change in HITrackingRegionProducer_cfi directly +# once for all? +hiRegitMuMixedTripletStepTrackingRegionsA = HiTrackingRegionFactoryFromSTAMuonsEDProducer.clone( + MuonSrc = "standAloneMuons:UpdatedAtVtx", # this is the same as default, why repeat? + MuonTrackingRegionBuilder = dict( + vertexCollection = "hiSelectedVertex", + UseVertex = True, + Phi_fixed = True, + Eta_fixed = True, + DeltaPhi = 0.3, + DeltaEta = 0.2, + # Ok, the following ones are specific to MixedTripletStep + Pt_min = 1.3, + DeltaR = 0.5, # default = 0.2 + DeltaZ = 0.5, # this give you the length + Rescale_Dz = 4., # max(DeltaZ_Region,Rescale_Dz*vtx->zError()) + ) +) +hiRegitMuMixedTripletStepTrackingRegionsB = hiRegitMuMixedTripletStepTrackingRegionsA.clone( + MuonTrackingRegionBuilder = dict(Pt_min = 1.5) +) ################################### from RecoTracker.IterativeTracking.MixedTripletStep_cff import * @@ -34,14 +48,17 @@ hiRegitMuMixedTripletStepSeedLayersA.TEC.skipClusters = cms.InputTag('hiRegitMuMixedTripletStepClusters') # SEEDS A -hiRegitMuMixedTripletStepSeedsA = RecoTracker.IterativeTracking.MixedTripletStep_cff.mixedTripletStepSeedsA.clone() -hiRegitMuMixedTripletStepSeedsA.RegionFactoryPSet = HiTrackingRegionFactoryFromSTAMuonsBlock.clone() -hiRegitMuMixedTripletStepSeedsA.ClusterCheckPSet.doClusterCheck = False # do not check for max number of clusters pixel or strips -hiRegitMuMixedTripletStepSeedsA.RegionFactoryPSet.MuonTrackingRegionBuilder.Pt_min = 1.3 -hiRegitMuMixedTripletStepSeedsA.RegionFactoryPSet.MuonTrackingRegionBuilder.DeltaR = 0.5 # default = 0.2 -hiRegitMuMixedTripletStepSeedsA.RegionFactoryPSet.MuonTrackingRegionBuilder.DeltaZ = 0.5 # this give you the length -hiRegitMuMixedTripletStepSeedsA.RegionFactoryPSet.MuonTrackingRegionBuilder.Rescale_Dz = 4. # max(DeltaZ_Region,Rescale_Dz*vtx->zError()) -hiRegitMuMixedTripletStepSeedsA.OrderedHitsFactoryPSet.SeedingLayers = 'hiRegitMuMixedTripletStepSeedLayersA' +hiRegitMuMixedTripletStepHitDoubletsA = RecoTracker.IterativeTracking.MixedTripletStep_cff.mixedTripletStepHitDoubletsA.clone( + seedingLayers = "hiRegitMuMixedTripletStepSeedLayersA", + trackingRegions = "hiRegitMuMixedTripletStepTrackingRegionsA", + clusterCheck = "hiRegitMuClusterCheck", +) +hiRegitMuMixedTripletStepHitTripletsA = RecoTracker.IterativeTracking.MixedTripletStep_cff.mixedTripletStepHitTripletsA.clone( + doublets = "hiRegitMuMixedTripletStepHitDoubletsA" +) +hiRegitMuMixedTripletStepSeedsA = RecoTracker.IterativeTracking.MixedTripletStep_cff.mixedTripletStepSeedsA.clone( + seedingHitSets = "hiRegitMuMixedTripletStepHitTripletsA" +) # SEEDING LAYERS B hiRegitMuMixedTripletStepSeedLayersB = RecoTracker.IterativeTracking.MixedTripletStep_cff.mixedTripletStepSeedLayersB.clone() @@ -49,14 +66,17 @@ hiRegitMuMixedTripletStepSeedLayersB.TIB.skipClusters = cms.InputTag('hiRegitMuMixedTripletStepClusters') -hiRegitMuMixedTripletStepSeedsB = RecoTracker.IterativeTracking.MixedTripletStep_cff.mixedTripletStepSeedsB.clone() -hiRegitMuMixedTripletStepSeedsB.RegionFactoryPSet = HiTrackingRegionFactoryFromSTAMuonsBlock.clone() -hiRegitMuMixedTripletStepSeedsB.ClusterCheckPSet.doClusterCheck = False # do not check for max number of clusters pixel or strips -hiRegitMuMixedTripletStepSeedsB.RegionFactoryPSet.MuonTrackingRegionBuilder.Pt_min = 1.5 -hiRegitMuMixedTripletStepSeedsB.RegionFactoryPSet.MuonTrackingRegionBuilder.DeltaR = 0.5 # default = 0.2 -hiRegitMuMixedTripletStepSeedsB.RegionFactoryPSet.MuonTrackingRegionBuilder.DeltaZ = 0.5 # this give you the length -hiRegitMuMixedTripletStepSeedsB.RegionFactoryPSet.MuonTrackingRegionBuilder.Rescale_Dz = 4. # max(DeltaZ_Region,Rescale_Dz*vtx->zError()) -hiRegitMuMixedTripletStepSeedsB.OrderedHitsFactoryPSet.SeedingLayers = 'hiRegitMuMixedTripletStepSeedLayersB' +hiRegitMuMixedTripletStepHitDoubletsB = RecoTracker.IterativeTracking.MixedTripletStep_cff.mixedTripletStepHitDoubletsB.clone( + seedingLayers = "hiRegitMuMixedTripletStepSeedLayersB", + trackingRegions = "hiRegitMuMixedTripletStepTrackingRegionsB", + clusterCheck = "hiRegitMuClusterCheck", +) +hiRegitMuMixedTripletStepHitTripletsB = RecoTracker.IterativeTracking.MixedTripletStep_cff.mixedTripletStepHitTripletsB.clone( + doublets = "hiRegitMuMixedTripletStepHitDoubletsB" +) +hiRegitMuMixedTripletStepSeedsB = RecoTracker.IterativeTracking.MixedTripletStep_cff.mixedTripletStepSeedsA.clone( + seedingHitSets = "hiRegitMuMixedTripletStepHitTripletsB" +) # combine seeds hiRegitMuMixedTripletStepSeeds = RecoTracker.IterativeTracking.MixedTripletStep_cff.mixedTripletStepSeeds.clone( @@ -132,8 +152,14 @@ hiRegitMuonMixedTripletStep = cms.Sequence(hiRegitMuMixedTripletStepClusters* hiRegitMuMixedTripletStepSeedLayersA* + hiRegitMuMixedTripletStepTrackingRegionsA* + hiRegitMuMixedTripletStepHitDoubletsA* + hiRegitMuMixedTripletStepHitTripletsA* hiRegitMuMixedTripletStepSeedsA* hiRegitMuMixedTripletStepSeedLayersB* + hiRegitMuMixedTripletStepTrackingRegionsB* + hiRegitMuMixedTripletStepHitDoubletsB* + hiRegitMuMixedTripletStepHitTripletsB* hiRegitMuMixedTripletStepSeedsB* hiRegitMuMixedTripletStepSeeds* hiRegitMuMixedTripletStepTrackCandidates* diff --git a/RecoHI/HiMuonAlgos/python/HiRegitMuonPixelLessStep_cff.py b/RecoHI/HiMuonAlgos/python/HiRegitMuonPixelLessStep_cff.py index d9cdd2ed17d83..70a3721581a63 100644 --- a/RecoHI/HiMuonAlgos/python/HiRegitMuonPixelLessStep_cff.py +++ b/RecoHI/HiMuonAlgos/python/HiRegitMuonPixelLessStep_cff.py @@ -4,15 +4,25 @@ ################################### 5th step: large impact parameter tracking using TIB/TID/TEC stereo layer seeding from RecoHI.HiTracking.HITrackingRegionProducer_cfi import * -HiTrackingRegionFactoryFromSTAMuonsBlock.MuonTrackingRegionBuilder.vertexCollection = cms.InputTag("hiSelectedVertex") -HiTrackingRegionFactoryFromSTAMuonsBlock.MuonSrc= cms.InputTag("standAloneMuons","UpdatedAtVtx") - -HiTrackingRegionFactoryFromSTAMuonsBlock.MuonTrackingRegionBuilder.UseVertex = True - -HiTrackingRegionFactoryFromSTAMuonsBlock.MuonTrackingRegionBuilder.Phi_fixed = True -HiTrackingRegionFactoryFromSTAMuonsBlock.MuonTrackingRegionBuilder.Eta_fixed = True -HiTrackingRegionFactoryFromSTAMuonsBlock.MuonTrackingRegionBuilder.DeltaPhi = 0.2 -HiTrackingRegionFactoryFromSTAMuonsBlock.MuonTrackingRegionBuilder.DeltaEta = 0.1 +# Are the following values set to the same in every iteration? If yes, +# why not making the change in HITrackingRegionProducer_cfi directly +# once for all? +hiRegitMuPixelLessStepTrackingRegions = HiTrackingRegionFactoryFromSTAMuonsEDProducer.clone( + MuonSrc = "standAloneMuons:UpdatedAtVtx", # this is the same as default, why repeat? + MuonTrackingRegionBuilder = dict( + vertexCollection = "hiSelectedVertex", + UseVertex = True, + Phi_fixed = True, + Eta_fixed = True, + # Ok, the following ones are specific to PixelLessStep + DeltaPhi = 0.2, + DeltaEta = 0.1, + Pt_min = 2.0, + DeltaR = 0.2, # default = 0.2 + DeltaZ = 0.2, # this give you the length + Rescale_Dz = 4., # max(DeltaZ_Region,Rescale_Dz*vtx->zError()) + ) +) ################################### from RecoTracker.IterativeTracking.PixelLessStep_cff import * @@ -37,14 +47,17 @@ # seeding -hiRegitMuPixelLessStepSeeds = RecoTracker.IterativeTracking.PixelLessStep_cff.pixelLessStepSeeds.clone() -hiRegitMuPixelLessStepSeeds.RegionFactoryPSet = HiTrackingRegionFactoryFromSTAMuonsBlock.clone() -hiRegitMuPixelLessStepSeeds.ClusterCheckPSet.doClusterCheck = False # do not check for max number of clusters pixel or strips -hiRegitMuPixelLessStepSeeds.RegionFactoryPSet.MuonTrackingRegionBuilder.Pt_min = 2.0 -hiRegitMuPixelLessStepSeeds.RegionFactoryPSet.MuonTrackingRegionBuilder.DeltaR = 0.2 # default = 0.2 -hiRegitMuPixelLessStepSeeds.RegionFactoryPSet.MuonTrackingRegionBuilder.DeltaZ = 0.2 # this give you the length -hiRegitMuPixelLessStepSeeds.RegionFactoryPSet.MuonTrackingRegionBuilder.Rescale_Dz = 4. # max(DeltaZ_Region,Rescale_Dz*vtx->zError()) -hiRegitMuPixelLessStepSeeds.OrderedHitsFactoryPSet.SeedingLayers = 'hiRegitMuPixelLessStepSeedLayers' +hiRegitMuPixelLessStepHitDoublets = RecoTracker.IterativeTracking.PixelLessStep_cff.pixelLessStepHitDoublets.clone( + seedingLayers = "hiRegitMuPixelLessStepSeedLayers", + trackingRegions = "hiRegitMuPixelLessStepTrackingRegions", + clusterCheck = "hiRegitMuClusterCheck", +) +hiRegitMuPixelLessStepHitTriplets = RecoTracker.IterativeTracking.PixelLessStep_cff.pixelLessStepHitTriplets.clone( + doublets = "hiRegitMuPixelLessStepHitDoublets" +) +hiRegitMuPixelLessStepSeeds = RecoTracker.IterativeTracking.PixelLessStep_cff.pixelLessStepSeeds.clone( + seedingHitSets = "hiRegitMuPixelLessStepHitTriplets" +) # building: feed the new-named seeds @@ -107,6 +120,9 @@ hiRegitMuonPixelLessStep = cms.Sequence(hiRegitMuPixelLessStepClusters* hiRegitMuPixelLessStepSeedLayers* + hiRegitMuPixelLessStepTrackingRegions* + hiRegitMuPixelLessStepHitDoublets* + hiRegitMuPixelLessStepHitTriplets* hiRegitMuPixelLessStepSeeds* hiRegitMuPixelLessStepTrackCandidates* hiRegitMuPixelLessStepTracks* diff --git a/RecoHI/HiMuonAlgos/python/HiRegitMuonPixelPairStep_cff.py b/RecoHI/HiMuonAlgos/python/HiRegitMuonPixelPairStep_cff.py index e247d0a391b0e..6e36b580d5430 100644 --- a/RecoHI/HiMuonAlgos/python/HiRegitMuonPixelPairStep_cff.py +++ b/RecoHI/HiMuonAlgos/python/HiRegitMuonPixelPairStep_cff.py @@ -5,15 +5,25 @@ ################################### 2nd step: pixel pairs from RecoHI.HiTracking.HITrackingRegionProducer_cfi import * -HiTrackingRegionFactoryFromSTAMuonsBlock.MuonTrackingRegionBuilder.vertexCollection = cms.InputTag("hiSelectedVertex") -HiTrackingRegionFactoryFromSTAMuonsBlock.MuonSrc= cms.InputTag("standAloneMuons","UpdatedAtVtx") - -HiTrackingRegionFactoryFromSTAMuonsBlock.MuonTrackingRegionBuilder.UseVertex = True - -HiTrackingRegionFactoryFromSTAMuonsBlock.MuonTrackingRegionBuilder.Phi_fixed = True -HiTrackingRegionFactoryFromSTAMuonsBlock.MuonTrackingRegionBuilder.Eta_fixed = True -HiTrackingRegionFactoryFromSTAMuonsBlock.MuonTrackingRegionBuilder.DeltaPhi = 0.3 -HiTrackingRegionFactoryFromSTAMuonsBlock.MuonTrackingRegionBuilder.DeltaEta = 0.2 +# Are the following values set to the same in every iteration? If yes, +# why not making the change in HITrackingRegionProducer_cfi directly +# once for all? +hiRegitMuPixelPairStepTrackingRegions = HiTrackingRegionFactoryFromSTAMuonsEDProducer.clone( + MuonSrc = "standAloneMuons:UpdatedAtVtx", # this is the same as default, why repeat? + MuonTrackingRegionBuilder = dict( + vertexCollection = "hiSelectedVertex", + UseVertex = True, + Phi_fixed = True, + Eta_fixed = True, + DeltaPhi = 0.3, + DeltaEta = 0.2, + # Ok, the following ones are specific to PixelPairStep + Pt_min = 1.0, + DeltaR = 0.01, # default = 0.2 + DeltaZ = 0.09, # this give you the length + Rescale_Dz = 0. # max(DeltaZ_Region,Rescale_Dz*vtx->zError()) + ) +) ################################### from RecoTracker.IterativeTracking.PixelPairStep_cff import * @@ -36,14 +46,14 @@ # seeding -hiRegitMuPixelPairStepSeeds = RecoTracker.IterativeTracking.PixelPairStep_cff.pixelPairStepSeeds.clone() -hiRegitMuPixelPairStepSeeds.RegionFactoryPSet = HiTrackingRegionFactoryFromSTAMuonsBlock.clone() -hiRegitMuPixelPairStepSeeds.ClusterCheckPSet.doClusterCheck = False # do not check for max number of clusters pixel or strips -hiRegitMuPixelPairStepSeeds.RegionFactoryPSet.MuonTrackingRegionBuilder.Pt_min = 1.0 -hiRegitMuPixelPairStepSeeds.RegionFactoryPSet.MuonTrackingRegionBuilder.DeltaR = 0.01 # default = 0.2 -hiRegitMuPixelPairStepSeeds.RegionFactoryPSet.MuonTrackingRegionBuilder.DeltaZ = 0.09 # this give you the length -hiRegitMuPixelPairStepSeeds.RegionFactoryPSet.MuonTrackingRegionBuilder.Rescale_Dz = 0. # max(DeltaZ_Region,Rescale_Dz*vtx->zError()) -hiRegitMuPixelPairStepSeeds.OrderedHitsFactoryPSet.SeedingLayers = 'hiRegitMuPixelPairStepSeedLayers' +hiRegitMuPixelPairStepHitDoublets = RecoTracker.IterativeTracking.PixelPairStep_cff.pixelPairStepHitDoublets.clone( + seedingLayers = "hiRegitMuPixelPairStepSeedLayers", + trackingRegions = "hiRegitMuPixelPairStepTrackingRegions", + clusterCheck = "hiRegitMuClusterCheck", +) +hiRegitMuPixelPairStepSeeds = RecoTracker.IterativeTracking.PixelPairStep_cff.pixelPairStepSeeds.clone( + seedingHitSets = "hiRegitMuPixelPairStepHitDoublets" +) # building: feed the new-named seeds @@ -113,6 +123,8 @@ hiRegitMuonPixelPairStep = cms.Sequence(hiRegitMuPixelPairStepClusters* hiRegitMuPixelPairStepSeedLayers* + hiRegitMuPixelPairStepTrackingRegions* + hiRegitMuPixelPairStepHitDoublets* hiRegitMuPixelPairStepSeeds* hiRegitMuPixelPairStepTrackCandidates* hiRegitMuPixelPairStepTracks* diff --git a/RecoHI/HiMuonAlgos/python/HiRegitMuonTobTecStep_cff.py b/RecoHI/HiMuonAlgos/python/HiRegitMuonTobTecStep_cff.py deleted file mode 100644 index ea8e8a2d40e80..0000000000000 --- a/RecoHI/HiMuonAlgos/python/HiRegitMuonTobTecStep_cff.py +++ /dev/null @@ -1,141 +0,0 @@ -import FWCore.ParameterSet.Config as cms - -# pp iterative tracking modified for hiOffline reco (the vertex is the one reconstructed in HI) -################################### 6th step: very large impact parameter trackng using TOB+TEC ring 5 seeding --pair - -from RecoHI.HiTracking.HITrackingRegionProducer_cfi import * -HiTrackingRegionFactoryFromSTAMuonsBlock.MuonTrackingRegionBuilder.vertexCollection = cms.InputTag("hiSelectedVertex") -HiTrackingRegionFactoryFromSTAMuonsBlock.MuonSrc= cms.InputTag("standAloneMuons","UpdatedAtVtx") - -HiTrackingRegionFactoryFromSTAMuonsBlock.MuonTrackingRegionBuilder.UseVertex = True - -HiTrackingRegionFactoryFromSTAMuonsBlock.MuonTrackingRegionBuilder.Phi_fixed = True -HiTrackingRegionFactoryFromSTAMuonsBlock.MuonTrackingRegionBuilder.Eta_fixed = True -HiTrackingRegionFactoryFromSTAMuonsBlock.MuonTrackingRegionBuilder.DeltaPhi = 0.2 -HiTrackingRegionFactoryFromSTAMuonsBlock.MuonTrackingRegionBuilder.DeltaEta = 0.1 - -################################### -from RecoTracker.IterativeTracking.TobTecStep_cff import * - -# remove previously used clusters -hiRegitMuTobTecStepClusters = RecoTracker.IterativeTracking.TobTecStep_cff.tobTecStepClusters.clone( - oldClusterRemovalInfo = cms.InputTag("hiRegitMuPixelLessStepClusters"), - trajectories = cms.InputTag("hiRegitMuPixelLessStepTracks"), - overrideTrkQuals = cms.InputTag('hiRegitMuPixelLessStepSelector','hiRegitMuPixelLessStep'), - trackClassifier = cms.InputTag(''), - TrackQuality = cms.string('tight') -) - -# SEEDING LAYERS -hiRegitMuTobTecStepSeedLayersPair = RecoTracker.IterativeTracking.TobTecStep_cff.tobTecStepSeedLayersPair.clone() -hiRegitMuTobTecStepSeedLayersPair.TOB.skipClusters = cms.InputTag('hiRegitMuTobTecStepClusters') -hiRegitMuTobTecStepSeedLayersPair.TEC.skipClusters = cms.InputTag('hiRegitMuTobTecStepClusters') - -hiRegitMuTobTecStepSeedLayersTripl = RecoTracker.IterativeTracking.TobTecStep_cff.tobTecStepSeedLayersTripl.clone() -hiRegitMuTobTecStepSeedLayersTripl.TOB.skipClusters = cms.InputTag('hiRegitMuTobTecStepClusters') -hiRegitMuTobTecStepSeedLayersTripl.MTOB.skipClusters = cms.InputTag('hiRegitMuTobTecStepClusters') -hiRegitMuTobTecStepSeedLayersTripl.MTEC.skipClusters = cms.InputTag('hiRegitMuTobTecStepClusters') - -# seeding -hiRegitMuTobTecStepSeeds = RecoTracker.IterativeTracking.TobTecStep_cff.tobTecStepSeeds.clone( - seedCollections = cms.VInputTag(cms.InputTag("hiRegitMuTobTecStepSeedsTripl"), cms.InputTag("hiRegitMuTobTecStepSeedsPair")) - ) - -# For now, keep the same parameters for triplets and pairs -hiRegitMuTobTecStepSeedsTripl = RecoTracker.IterativeTracking.TobTecStep_cff.tobTecStepSeedsTripl.clone() -hiRegitMuTobTecStepSeedsTripl.RegionFactoryPSet = HiTrackingRegionFactoryFromSTAMuonsBlock.clone() -hiRegitMuTobTecStepSeedsTripl.ClusterCheckPSet.doClusterCheck = False # do not check for max number of clusters pixel or strips -hiRegitMuTobTecStepSeedsTripl.RegionFactoryPSet.MuonTrackingRegionBuilder.Pt_min = 2.0 -hiRegitMuTobTecStepSeedsTripl.RegionFactoryPSet.MuonTrackingRegionBuilder.DeltaR = 0.2 # default = 0.2 -hiRegitMuTobTecStepSeedsTripl.RegionFactoryPSet.MuonTrackingRegionBuilder.DeltaZ = 0.2 # this give you the length -hiRegitMuTobTecStepSeedsTripl.RegionFactoryPSet.MuonTrackingRegionBuilder.Rescale_Dz = 4. # max(DeltaZ_Region,Rescale_Dz*vtx->zError()) -hiRegitMuTobTecStepSeedsTripl.OrderedHitsFactoryPSet.SeedingLayers = 'hiRegitMuTobTecStepSeedLayersTripl' - -hiRegitMuTobTecStepSeedsPair = RecoTracker.IterativeTracking.TobTecStep_cff.tobTecStepSeedsPair.clone() -hiRegitMuTobTecStepSeedsPair.RegionFactoryPSet = HiTrackingRegionFactoryFromSTAMuonsBlock.clone() -hiRegitMuTobTecStepSeedsPair.ClusterCheckPSet.doClusterCheck = False # do not check for max number of clusters pixel or strips -hiRegitMuTobTecStepSeedsPair.RegionFactoryPSet.MuonTrackingRegionBuilder.Pt_min = 2.0 -hiRegitMuTobTecStepSeedsPair.RegionFactoryPSet.MuonTrackingRegionBuilder.DeltaR = 0.2 # default = 0.2 -hiRegitMuTobTecStepSeedsPair.RegionFactoryPSet.MuonTrackingRegionBuilder.DeltaZ = 0.2 # this give you the length -hiRegitMuTobTecStepSeedsPair.RegionFactoryPSet.MuonTrackingRegionBuilder.Rescale_Dz = 4. # max(DeltaZ_Region,Rescale_Dz*vtx->zError()) -hiRegitMuTobTecStepSeedsPair.OrderedHitsFactoryPSet.SeedingLayers = 'hiRegitMuTobTecStepSeedLayersPair' - -# building: feed the new-named seeds -hiRegitMuTobTecStepInOutTrajectoryFilter = RecoTracker.IterativeTracking.TobTecStep_cff.tobTecStepInOutTrajectoryFilter.clone() -hiRegitMuTobTecStepInOutTrajectoryFilter.minPt = 1.7 -hiRegitMuTobTecStepInOutTrajectoryFilter.minimumNumberOfHits = 6 -hiRegitMuTobTecStepInOutTrajectoryFilter.minHitsMinPt = 4 - - -hiRegitMuTobTecStepTrajectoryFilter = RecoTracker.IterativeTracking.TobTecStep_cff.tobTecStepTrajectoryFilter.clone() -hiRegitMuTobTecStepTrajectoryFilter.minPt = 1.7 -hiRegitMuTobTecStepTrajectoryFilter.minimumNumberOfHits = 6 -hiRegitMuTobTecStepTrajectoryFilter.minHitsMinPt = 4 - -hiRegitMuTobTecStepTrajectoryBuilder = RecoTracker.IterativeTracking.TobTecStep_cff.tobTecStepTrajectoryBuilder.clone( - trajectoryFilter = cms.PSet( - refToPSet_ = cms.string('hiRegitMuTobTecStepTrajectoryFilter') - ), - inOutTrajectoryFilter = cms.PSet( - refToPSet_ = cms.string('hiRegitMuTobTecStepInOutTrajectoryFilter') - ), -) - -hiRegitMuTobTecStepTrackCandidates = RecoTracker.IterativeTracking.TobTecStep_cff.tobTecStepTrackCandidates.clone( - src = cms.InputTag('hiRegitMuTobTecStepSeeds'), - TrajectoryBuilderPSet = cms.PSet( - refToPSet_ = cms.string('hiRegitMuTobTecStepTrajectoryBuilder') - ), - clustersToSkip = cms.InputTag('hiRegitMuTobTecStepClusters'), - maxNSeeds = cms.uint32(1000000) - ) - -# fitting: feed new-names -hiRegitMuTobTecStepTracks = RecoTracker.IterativeTracking.TobTecStep_cff.tobTecStepTracks.clone( - AlgorithmName = cms.string('hiRegitMuTobTecStep'), - src = 'hiRegitMuTobTecStepTrackCandidates' -) - -import RecoTracker.FinalTrackSelectors.multiTrackSelector_cfi -import RecoHI.HiTracking.hiMultiTrackSelector_cfi -hiRegitMuTobTecStepSelector = RecoHI.HiTracking.hiMultiTrackSelector_cfi.hiMultiTrackSelector.clone( - src ='hiRegitMuTobTecStepTracks', - vertices = cms.InputTag("hiSelectedVertex"), - useAnyMVA = cms.bool(True), - GBRForestLabel = cms.string('HIMVASelectorIter7'), - GBRForestVars = cms.vstring(['chi2perdofperlayer', 'nhits', 'nlayers', 'eta']), - trackSelectors= cms.VPSet( - RecoTracker.FinalTrackSelectors.multiTrackSelector_cfi.looseMTS.clone( - name = 'hiRegitMuTobTecStepLoose', - min_nhits = cms.uint32(8) - ), - RecoHI.HiTracking.hiMultiTrackSelector_cfi.hiTightMTS.clone( - name = 'hiRegitMuTobTecStepTight', - preFilterName = 'hiRegitMuTobTecStepLoose', - min_nhits = cms.uint32(8), - useMVA = cms.bool(True), - minMVA = cms.double(-0.2) - ), - RecoHI.HiTracking.hiMultiTrackSelector_cfi.hiHighpurityMTS.clone( - name = 'hiRegitMuTobTecStep', - preFilterName = 'hiRegitMuTobTecStepTight', - min_nhits = cms.uint32(8), - useMVA = cms.bool(True), - minMVA = cms.double(-0.09) - ), - ) #end of vpset - -) - -hiRegitMuonTobTecStep = cms.Sequence(hiRegitMuTobTecStepClusters* - hiRegitMuTobTecStepSeedLayersTripl* - hiRegitMuTobTecStepSeedsTripl* - hiRegitMuTobTecStepSeedLayersPair* - hiRegitMuTobTecStepSeedsPair* - hiRegitMuTobTecStepSeeds* - hiRegitMuTobTecStepTrackCandidates* - hiRegitMuTobTecStepTracks* - hiRegitMuTobTecStepSelector) - - - diff --git a/RecoHI/HiMuonAlgos/python/hiMuonIterativeTk_cff.py b/RecoHI/HiMuonAlgos/python/hiMuonIterativeTk_cff.py index b0433fef1acc3..7c94095d342a6 100644 --- a/RecoHI/HiMuonAlgos/python/hiMuonIterativeTk_cff.py +++ b/RecoHI/HiMuonAlgos/python/hiMuonIterativeTk_cff.py @@ -1,5 +1,10 @@ import FWCore.ParameterSet.Config as cms +from RecoTracker.TkSeedGenerator.trackerClusterCheck_cfi import trackerClusterCheck as _trackerClusterCheck +hiRegitMuClusterCheck = _trackerClusterCheck.clone( + doClusterCheck = False # do not check for max number of clusters pixel or strips +) + from RecoHI.HiMuonAlgos.HiRegitMuonInitialStep_cff import * from RecoHI.HiMuonAlgos.HiRegitMuonPixelPairStep_cff import * from RecoHI.HiMuonAlgos.HiRegitMuonDetachedTripletStep_cff import * @@ -31,7 +36,8 @@ makeReKeyedSeeds = cms.untracked.bool(False) ) -hiRegitMuTracking = cms.Sequence(hiRegitMuonInitialStep +hiRegitMuTracking = cms.Sequence(hiRegitMuClusterCheck + *hiRegitMuonInitialStep *hiRegitMuonPixelPairStep *hiRegitMuonMixedTripletStep *hiRegitMuonPixelLessStep diff --git a/RecoHI/HiMuonAlgos/test/testRegionalMuonTracking_cfg.py b/RecoHI/HiMuonAlgos/test/testRegionalMuonTracking_cfg.py deleted file mode 100644 index 5b08d883b8c1c..0000000000000 --- a/RecoHI/HiMuonAlgos/test/testRegionalMuonTracking_cfg.py +++ /dev/null @@ -1,141 +0,0 @@ -import FWCore.ParameterSet.Config as cms -import FWCore.ParameterSet.VarParsing as VarParsing -import os - -process = cms.Process("TEST") - -process.load("SimGeneral.HepPDTESSource.pythiapdt_cfi") -process.load("Configuration.StandardSequences.Services_cff") -process.load("Configuration.StandardSequences.MagneticField_cff") -process.load("Configuration.StandardSequences.Geometry_cff") - -#global tags for conditions data: https://twiki.cern.ch/twiki/bin/view/CMS/SWGuideFrontierConditions -process.load("Configuration.StandardSequences.FrontierConditions_GlobalTag_cff") -process.GlobalTag.globaltag = 'MC_38Y_V8::All' - -################################################################################## - -# setup 'standard' options -options = VarParsing.VarParsing ('standard') - -# setup any defaults you want -options.output = 'test_out.root' -options.files = [ - '/store/relval/CMSSW_3_8_1/RelValPyquen_ZeemumuJets_pt10_2760GeV/GEN-SIM-RECO/MC_38Y_V8-v1/0013/42AFD8A5-C9A3-DF11-9F6B-001A92811706.root', - '/store/relval/CMSSW_3_8_1/RelValPyquen_ZeemumuJets_pt10_2760GeV/GEN-SIM-RECO/MC_38Y_V8-v1/0013/2225585D-BFA3-DF11-8771-003048678FD6.root' ] -options.maxEvents = 1 - -# get and parse the command line arguments -options.parseArguments() - - -################################################################################## -# Some Services - -process.load("FWCore.MessageService.MessageLogger_cfi") -process.MessageLogger.debugModules = ['*'] -process.MessageLogger.categories = ['HeavyIonVertexing','heavyIonHLTVertexing','MuonTrackingRegionBuilder','MinBiasTracking'] -process.MessageLogger.cerr = cms.untracked.PSet( - threshold = cms.untracked.string('DEBUG'), - DEBUG = cms.untracked.PSet( - limit = cms.untracked.int32(0) - ), - INFO = cms.untracked.PSet( - limit = cms.untracked.int32(0) - ), - HeavyIonVertexing = cms.untracked.PSet( - limit = cms.untracked.int32(-1) - ), - heavyIonHLTVertexing = cms.untracked.PSet( - limit = cms.untracked.int32(-1) - ), - MuonTrackingRegionBuilder = cms.untracked.PSet( - limit = cms.untracked.int32(-1) - ) -) - -process.SimpleMemoryCheck = cms.Service('SimpleMemoryCheck', - ignoreTotal=cms.untracked.int32(0), - oncePerEventMode = cms.untracked.bool(False) - ) - -process.Timing = cms.Service("Timing") - -process.options = cms.untracked.PSet(wantSummary = cms.untracked.bool(True)) - -################################################################################## -# Input Source -process.source = cms.Source('PoolSource',fileNames = cms.untracked.vstring(options.files)) -process.maxEvents = cms.untracked.PSet(input = cms.untracked.int32(options.maxEvents)) - -# GenFilter for opposite-sign status=1 muons from the embedded signal within the acceptance -process.mumugenfilter = cms.EDFilter("MCParticlePairFilter", - moduleLabel = cms.untracked.string("hiSignal"), - Status = cms.untracked.vint32(1, 1), - MinPt = cms.untracked.vdouble(2.5, 2.5), - MaxEta = cms.untracked.vdouble(2.5, 2.5), - MinEta = cms.untracked.vdouble(-2.5, -2.5), - ParticleCharge = cms.untracked.int32(-1), - ParticleID1 = cms.untracked.vint32(13), - ParticleID2 = cms.untracked.vint32(13) -) - -# Reconstruction -process.load("Configuration.StandardSequences.RawToDigi_cff") # RawToDigi -process.load("Configuration.StandardSequences.ReconstructionHeavyIons_cff") # full heavy ion reconstruction -process.load("RecoHI.HiTracking.secondStep_cff") # pair-seeding extension - -### re-run tracking only seeded by stand-alone muons -process.goodStaMuons = cms.EDFilter("TrackSelector", - src = cms.InputTag("standAloneMuons","UpdatedAtVtx"), - cut = cms.string("pt > 5.0"), - filter = cms.bool(True) - ) - -process.HiTrackingRegionFactoryFromSTAMuonsBlock.MuonSrc="goodStaMuons" -#using modified MuonTrackingRegionBuilder.cc to pass (x,y) vertex info -process.HiTrackingRegionFactoryFromSTAMuonsBlock.MuonTrackingRegionBuilder.UseFixedRegion=True -process.HiTrackingRegionFactoryFromSTAMuonsBlock.MuonTrackingRegionBuilder.DeltaR=0.1 -process.HiTrackingRegionFactoryFromSTAMuonsBlock.MuonTrackingRegionBuilder.Dz_min=0.2 -process.HiTrackingRegionFactoryFromSTAMuonsBlock.MuonTrackingRegionBuilder.PtMin_max=5.0 -process.hiPixel3PrimTracks.RegionFactoryPSet = process.HiTrackingRegionFactoryFromSTAMuonsBlock -process.hiNewSeedFromPairs.RegionFactoryPSet = process.HiTrackingRegionFactoryFromSTAMuonsBlock - -process.hiTracksWithLooseQuality.keepAllTracks=True - -process.hiNewTrackCandidates.TrajectoryCleaner = 'TrajectoryCleanerBySharedHits' -process.ckfBaseTrajectoryFilter.filterPset.minimumNumberOfHits=10 # was 6 - -### open up trajectory builder parameters -process.MaterialPropagator.Mass = 0.105 #muon (HI default is pion) -process.OppositeMaterialPropagator.Mass = 0.105 -process.ckfBaseTrajectoryFilter.filterPset.maxLostHits=1 # was 1 -process.ckfBaseTrajectoryFilter.filterPset.maxConsecLostHits=1 # was 1 -process.CkfTrajectoryBuilder.maxCand = 5 # was 5 - -# Output EDM File -process.load("Configuration.EventContent.EventContentHeavyIons_cff") #load keep/drop output commands -process.output = cms.OutputModule("PoolOutputModule", - process.FEVTDEBUGEventContent, - fileName = cms.untracked.string(options.output), - SelectEvents = cms.untracked.PSet(SelectEvents = cms.vstring('filter_step')) - ) -process.output.outputCommands.extend(["keep *_*_*_TEST"]) - -################################################################################## -# Sequences -process.rechits = cms.Sequence(process.siPixelRecHits*process.siStripMatchedRecHits) -process.rerecomuons = cms.Sequence(process.goodStaMuons * process.rechits * process.heavyIonTracking) - -# Paths -process.filter_step = cms.Path(process.mumugenfilter) - -process.path = cms.Path(process.mumugenfilter - * process.rerecomuons # triplet-seeded regional step - * process.secondStep # pair-seeded regional step - ) - -process.save = cms.EndPath(process.output) - -# Schedule -process.schedule = cms.Schedule(process.filter_step, process.path, process.save) diff --git a/RecoHI/HiTracking/python/HITrackingRegionProducer_cfi.py b/RecoHI/HiTracking/python/HITrackingRegionProducer_cfi.py index 54ebd0558e0a9..6a9e500055dae 100644 --- a/RecoHI/HiTracking/python/HITrackingRegionProducer_cfi.py +++ b/RecoHI/HiTracking/python/HITrackingRegionProducer_cfi.py @@ -79,12 +79,13 @@ # limited stand-alone muon-seeded tracking region from RecoMuon.TrackingTools.MuonServiceProxy_cff import MuonServiceProxy from RecoMuon.GlobalTrackingTools.MuonTrackingRegionCommon_cff import MuonTrackingRegionCommon -HiTrackingRegionFactoryFromSTAMuonsBlock = cms.PSet( - MuonServiceProxy, - MuonTrackingRegionCommon, - ComponentName = cms.string('HIMuonTrackingRegionProducer'), - MuonSrc = cms.InputTag("standAloneMuons","UpdatedAtVtx") - ) -HiTrackingRegionFactoryFromSTAMuonsBlock.MuonTrackingRegionBuilder.vertexCollection = cms.InputTag("hiSelectedVertex") -HiTrackingRegionFactoryFromSTAMuonsBlock.MuonTrackingRegionBuilder.UseVertex = cms.bool(True) -HiTrackingRegionFactoryFromSTAMuonsBlock.MuonTrackingRegionBuilder.Rescale_Dz = cms.double(5.0) +from RecoHI.HiMuonAlgos.HiTrackingRegionEDProducer_cfi import HiTrackingRegionEDProducer as _HiTrackingRegionEDProducer +HiTrackingRegionFactoryFromSTAMuonsEDProducer = _HiTrackingRegionEDProducer.clone( + MuonSrc = "standAloneMuons:UpdatedAtVtx", + MuonTrackingRegionBuilder = MuonTrackingRegionCommon.MuonTrackingRegionBuilder.clone( + vertexCollection = "hiSelectedVertex", + UseVertex = True, + Rescale_Dz = 5.0, + ), + ServiceParameters = MuonServiceProxy.ServiceParameters, +) diff --git a/RecoMuon/GlobalTrackingTools/interface/MuonTrackingRegionBuilder.h b/RecoMuon/GlobalTrackingTools/interface/MuonTrackingRegionBuilder.h index 9ad62d9cf072d..4bab866f87eb0 100644 --- a/RecoMuon/GlobalTrackingTools/interface/MuonTrackingRegionBuilder.h +++ b/RecoMuon/GlobalTrackingTools/interface/MuonTrackingRegionBuilder.h @@ -62,6 +62,11 @@ class MuonTrackingRegionBuilder : public TrackingRegionProducer { /// Add Fill Descriptions static void fillDescriptions(edm::ParameterSetDescription& descriptions); + // Separating the offline part of the fillDescriptions() above + // TODO: make similar fillDescriptionsHLT, and switch the + // fillDescriptions() above take edm::ConfigurationDescriptions& + static void fillDescriptionsOffline(edm::ParameterSetDescription& descriptions); + private: void build(const edm::ParameterSet&, edm::ConsumesCollector&); diff --git a/RecoMuon/GlobalTrackingTools/src/MuonTrackingRegionBuilder.cc b/RecoMuon/GlobalTrackingTools/src/MuonTrackingRegionBuilder.cc index c44574828c36e..d902b3217f664 100644 --- a/RecoMuon/GlobalTrackingTools/src/MuonTrackingRegionBuilder.cc +++ b/RecoMuon/GlobalTrackingTools/src/MuonTrackingRegionBuilder.cc @@ -255,32 +255,7 @@ std::unique_ptr MuonTrackingRegionBuilder::regi void MuonTrackingRegionBuilder::fillDescriptions(edm::ParameterSetDescription& descriptions) { { edm::ParameterSetDescription desc; - desc.add("EtaR_UpperLimit_Par1",0.25); - desc.add("DeltaR",0.2); - desc.add("beamSpot",edm::InputTag("")); - desc.add("OnDemand",-1); - desc.add("vertexCollection",edm::InputTag("")); - desc.add("Rescale_phi",3.0); - desc.add("Eta_fixed",false); - desc.add("Rescale_eta",3.0); - desc.add("PhiR_UpperLimit_Par2",0.2); - desc.add("Eta_min",0.05); - desc.add("Phi_fixed",false); - desc.add("Phi_min",0.05); - desc.add("PhiR_UpperLimit_Par1",0.6); - desc.add("EtaR_UpperLimit_Par2",0.15); - desc.add("MeasurementTrackerName",edm::InputTag("")); - desc.add("UseVertex",false); - desc.add("Rescale_Dz",3.0); - desc.add("Pt_fixed",false); - desc.add("Z_fixed",true); - desc.add("Pt_min",1.5); - desc.add("DeltaZ",15.9); - desc.add("DeltaEta",0.2); - desc.add("DeltaPhi",0.2); - desc.add("maxRegions",1); - desc.add("precise",true); - desc.add("input",edm::InputTag("")); + fillDescriptionsOffline(desc); descriptions.add("MuonTrackingRegionBuilder",desc); } { @@ -315,3 +290,32 @@ void MuonTrackingRegionBuilder::fillDescriptions(edm::ParameterSetDescription& d } descriptions.setComment("Build a TrackingRegion around a standalone muon. Options to define region around beamspot or primary vertex and dynamic regions are included."); } + +void MuonTrackingRegionBuilder::fillDescriptionsOffline(edm::ParameterSetDescription& desc) { + desc.add("EtaR_UpperLimit_Par1",0.25); + desc.add("DeltaR",0.2); + desc.add("beamSpot",edm::InputTag("")); + desc.add("OnDemand",-1); + desc.add("vertexCollection",edm::InputTag("")); + desc.add("Rescale_phi",3.0); + desc.add("Eta_fixed",false); + desc.add("Rescale_eta",3.0); + desc.add("PhiR_UpperLimit_Par2",0.2); + desc.add("Eta_min",0.05); + desc.add("Phi_fixed",false); + desc.add("Phi_min",0.05); + desc.add("PhiR_UpperLimit_Par1",0.6); + desc.add("EtaR_UpperLimit_Par2",0.15); + desc.add("MeasurementTrackerName",edm::InputTag("")); + desc.add("UseVertex",false); + desc.add("Rescale_Dz",3.0); + desc.add("Pt_fixed",false); + desc.add("Z_fixed",true); + desc.add("Pt_min",1.5); + desc.add("DeltaZ",15.9); + desc.add("DeltaEta",0.2); + desc.add("DeltaPhi",0.2); + desc.add("maxRegions",1); + desc.add("precise",true); + desc.add("input",edm::InputTag("")); +} diff --git a/RecoPixelVertexing/PixelLowPtUtilities/src/PixelTripletLowPtGenerator.cc b/RecoPixelVertexing/PixelLowPtUtilities/src/PixelTripletLowPtGenerator.cc index 2fce717685787..fd033abf05c37 100644 --- a/RecoPixelVertexing/PixelLowPtUtilities/src/PixelTripletLowPtGenerator.cc +++ b/RecoPixelVertexing/PixelLowPtUtilities/src/PixelTripletLowPtGenerator.cc @@ -100,7 +100,7 @@ void PixelTripletLowPtGenerator::hitTriplets( // Set aliases const RecHitsSortedInPhi **thirdHitMap = new const RecHitsSortedInPhi*[size]; for(int il=0; il diff --git a/RecoPixelVertexing/PixelTriplets/interface/HitTripletEDProducerT.h b/RecoPixelVertexing/PixelTriplets/interface/HitTripletEDProducerT.h new file mode 100644 index 0000000000000..61261b6f6dc81 --- /dev/null +++ b/RecoPixelVertexing/PixelTriplets/interface/HitTripletEDProducerT.h @@ -0,0 +1,343 @@ +#ifndef RecoPixelVertexing_PixelTriplets_HitTripletEDProducerT_H +#define RecoPixelVertexing_PixelTriplets_HitTripletEDProducerT_H + +#include "FWCore/Framework/interface/stream/EDProducer.h" +#include "FWCore/Framework/interface/ConsumesCollector.h" +#include "FWCore/ParameterSet/interface/ParameterSet.h" +#include "FWCore/ParameterSet/interface/ConfigurationDescriptions.h" +#include "FWCore/ParameterSet/interface/ParameterSetDescription.h" +#include "FWCore/Utilities/interface/EDGetToken.h" +#include "FWCore/Framework/interface/Event.h" +#include "DataFormats/Common/interface/Handle.h" +#include "FWCore/Utilities/interface/RunningAverage.h" + +#include "RecoTracker/TkHitPairs/interface/IntermediateHitDoublets.h" +#include "RecoTracker/TkHitPairs/interface/RegionsSeedingHitSets.h" +#include "RecoPixelVertexing/PixelTriplets/interface/OrderedHitTriplets.h" +#include "RecoPixelVertexing/PixelTriplets/interface/IntermediateHitTriplets.h" +#include "RecoPixelVertexing/PixelTriplets/interface/LayerTriplets.h" + +namespace hitTripletEDProducerT { class ImplBase; } + +template +class HitTripletEDProducerT: public edm::stream::EDProducer<> { +public: + HitTripletEDProducerT(const edm::ParameterSet& iConfig); + ~HitTripletEDProducerT() = default; + + static void fillDescriptions(edm::ConfigurationDescriptions& descriptions); + + virtual void produce(edm::Event& iEvent, const edm::EventSetup& iSetup) override; + +private: + edm::EDGetTokenT doubletToken_; + + std::unique_ptr impl_; +}; + +namespace hitTripletEDProducerT { + class ImplBase { + public: + ImplBase() = default; + virtual ~ImplBase() = default; + + virtual void produces(edm::ProducerBase& producer) const = 0; + virtual void produce(const IntermediateHitDoublets& regionDoublets, + edm::Event& iEvent, const edm::EventSetup& iSetup) = 0; + + protected: + edm::RunningAverage localRA_; + }; + + ///// + template + class ImplGeneratorBase: public ImplBase { + public: + ImplGeneratorBase(const edm::ParameterSet& iConfig, edm::ConsumesCollector& iC): + generator_(iConfig, iC) + {} + ~ImplGeneratorBase() = default; + + protected: + T_HitTripletGenerator generator_; + }; + + ///// + template + class Impl: public ImplGeneratorBase { + public: + Impl(const edm::ParameterSet& iConfig, edm::ConsumesCollector& iC): + ImplGeneratorBase(iConfig, iC) {} + ~Impl() = default; + + void produces(edm::ProducerBase& producer) const override { + T_SeedingHitSets::produces(producer); + T_IntermediateHitTriplets::produces(producer); + }; + + void produce(const IntermediateHitDoublets& regionDoublets, + edm::Event& iEvent, const edm::EventSetup& iSetup) override { + const SeedingLayerSetsHits& seedingLayerHits = regionDoublets.seedingLayerHits(); + + auto seedingHitSetsProducer = T_SeedingHitSets(); + auto intermediateHitTripletsProducer = T_IntermediateHitTriplets(&seedingLayerHits); + + if(regionDoublets.empty()) { + seedingHitSetsProducer.putEmpty(iEvent); + intermediateHitTripletsProducer.putEmpty(iEvent); + return; + } + + seedingHitSetsProducer.reserve(regionDoublets.regionSize(), this->localRA_.upper()); + intermediateHitTripletsProducer.reserve(regionDoublets.regionSize(), this->localRA_.upper()); + + // match-making of pair and triplet layers + std::vector trilayers = LayerTriplets::layers(seedingLayerHits); + + OrderedHitTriplets triplets; + triplets.reserve(this->localRA_.upper()); + size_t triplets_total = 0; + + LogDebug("HitTripletEDProducer") << "Creating triplets for " << regionDoublets.regionSize() << " regions, and " << trilayers.size() << " pair+3rd layers from " << regionDoublets.layerPairsSize() << " layer pairs"; + + for(const auto& regionLayerPairs: regionDoublets) { + const TrackingRegion& region = regionLayerPairs.region(); + + auto hitCachePtr_filler_shs = seedingHitSetsProducer.beginRegion(®ion, nullptr); + auto hitCachePtr_filler_iht = intermediateHitTripletsProducer.beginRegion(®ion, std::get<0>(hitCachePtr_filler_shs)); + auto hitCachePtr = std::get<0>(hitCachePtr_filler_iht); + + LayerHitMapCache& hitCache = *hitCachePtr; + hitCache.extend(regionLayerPairs.layerHitMapCache()); + + LogTrace("HitTripletEDProducer") << " starting region"; + + for(const auto& layerPair: regionLayerPairs) { + LogTrace("HitTripletEDProducer") << " starting layer pair " << layerPair.innerLayerIndex() << "," << layerPair.outerLayerIndex(); + + auto found = std::find_if(trilayers.begin(), trilayers.end(), [&](const LayerTriplets::LayerSetAndLayers& a) { + return a.first[0].index() == layerPair.innerLayerIndex() && a.first[1].index() == layerPair.outerLayerIndex(); + }); + if(found == trilayers.end()) { + auto exp = cms::Exception("LogicError") << "Did not find the layer pair from vector. This is a sign of some internal inconsistency\n"; + exp << "I was looking for layer pair " << layerPair.innerLayerIndex() << "," << layerPair.outerLayerIndex() << ". Triplets have the following pairs:\n"; + for(const auto& a: trilayers) { + exp << " " << a.first[0].index() << "," << a.first[1].index() << ": 3rd layers"; + for(const auto& b: a.second) { + exp << " " << b.index(); + } + exp << "\n"; + } + throw exp; + } + const auto& thirdLayers = found->second; + + this->generator_.hitTriplets(region, triplets, iEvent, iSetup, layerPair.doublets(), thirdLayers, + intermediateHitTripletsProducer.tripletLastLayerIndexVector(), hitCache); + +#ifdef EDM_ML_DEBUG + LogTrace("HitTripletEDProducer") << " created " << triplets.size() << " triplets for layer pair " << layerPair.innerLayerIndex() << "," << layerPair.outerLayerIndex() << " and 3rd layers"; + for(const auto& l: thirdLayers) { + LogTrace("HitTripletEDProducer") << " " << l.index(); + } +#endif + + triplets_total += triplets.size(); + seedingHitSetsProducer.fill(std::get<1>(hitCachePtr_filler_shs), triplets); + intermediateHitTripletsProducer.fill(std::get<1>(hitCachePtr_filler_iht), layerPair.layerPair(), thirdLayers, triplets); + + triplets.clear(); + } + } + this->localRA_.update(triplets_total); + + seedingHitSetsProducer.put(iEvent); + intermediateHitTripletsProducer.put(iEvent); + } + }; + + + ///// + class DoNothing { + public: + DoNothing() {} + explicit DoNothing(const SeedingLayerSetsHits *layers) {} + + static void produces(edm::ProducerBase&) {} + + void reserve(size_t, size_t) {} + + auto beginRegion(const TrackingRegion *, LayerHitMapCache *ptr) { + return std::make_tuple(ptr, 0); + } + + std::vector *tripletLastLayerIndexVector() { + return nullptr; + } + + void fill(int, const OrderedHitTriplets&) {} + void fill(int, const IntermediateHitTriplets::LayerPair&, + const std::vector&, + const OrderedHitTriplets&) {} + + + void put(edm::Event& iEvent) {} + void putEmpty(edm::Event& iEvent) {} + }; + + ///// + class ImplSeedingHitSets { + public: + ImplSeedingHitSets(): + seedingHitSets_(std::make_unique()) + {} + + static void produces(edm::ProducerBase& producer) { + producer.produces(); + } + + void reserve(size_t regionsSize, size_t localRAupper) { + seedingHitSets_->reserve(regionsSize, localRAupper); + } + + auto beginRegion(const TrackingRegion *region, LayerHitMapCache *ptr) { + hitCacheTmp_.clear(); + return std::make_tuple(&hitCacheTmp_, seedingHitSets_->beginRegion(region)); + } + + void fill(RegionsSeedingHitSets::RegionFiller& filler, const OrderedHitTriplets& triplets) { + for(const auto& trpl: triplets) { + filler.emplace_back(trpl.inner(), trpl.middle(), trpl.outer()); + } + } + + void put(edm::Event& iEvent) { + seedingHitSets_->shrink_to_fit(); + putEmpty(iEvent); + } + void putEmpty(edm::Event& iEvent) { + iEvent.put(std::move(seedingHitSets_)); + } + + private: + std::unique_ptr seedingHitSets_; + LayerHitMapCache hitCacheTmp_; // used if !produceIntermediateHitDoublets + }; + + ///// + class ImplIntermediateHitTriplets { + public: + explicit ImplIntermediateHitTriplets(const SeedingLayerSetsHits *layers): + intermediateHitTriplets_(std::make_unique(layers)), + layers_(layers) + {} + + static void produces(edm::ProducerBase& producer) { + producer.produces(); + } + + void reserve(size_t regionsSize, size_t localRAupper) { + intermediateHitTriplets_->reserve(regionsSize, layers_->size(), localRAupper); + tripletLastLayerIndex_.reserve(localRAupper); + } + + auto beginRegion(const TrackingRegion *region, LayerHitMapCache *) { + auto filler = intermediateHitTriplets_->beginRegion(region); + return std::make_tuple(&(filler.layerHitMapCache()), std::move(filler)); + } + + std::vector *tripletLastLayerIndexVector() { + return &tripletLastLayerIndex_; + } + + void fill(IntermediateHitTriplets::RegionFiller& filler, + const IntermediateHitTriplets::LayerPair& layerPair, + const std::vector& thirdLayers, + const OrderedHitTriplets& triplets) { + if(tripletLastLayerIndex_.size() != triplets.size()) { + throw cms::Exception("LogicError") << "tripletLastLayerIndex_.size() " << tripletLastLayerIndex_.size() + << " triplets.size() " << triplets.size(); + } + tripletPermutation_.resize(tripletLastLayerIndex_.size()); + std::iota(tripletPermutation_.begin(), tripletPermutation_.end(), 0); // assign 0,1,2,...,N + std::stable_sort(tripletPermutation_.begin(), tripletPermutation_.end(), [&](size_t i, size_t j) { + return tripletLastLayerIndex_[i] < tripletLastLayerIndex_[j]; + }); + + // empty triplets need to propagate here + filler.addTriplets(layerPair, thirdLayers, triplets, tripletLastLayerIndex_, tripletPermutation_); + tripletLastLayerIndex_.clear(); + } + + void put(edm::Event& iEvent) { + intermediateHitTriplets_->shrink_to_fit(); + putEmpty(iEvent); + } + void putEmpty(edm::Event& iEvent) { + iEvent.put(std::move(intermediateHitTriplets_)); + } + + private: + std::unique_ptr intermediateHitTriplets_; + const SeedingLayerSetsHits *layers_; + std::vector tripletPermutation_; + std::vector tripletLastLayerIndex_; + }; +} + + + +template +HitTripletEDProducerT::HitTripletEDProducerT(const edm::ParameterSet& iConfig): + doubletToken_(consumes(iConfig.getParameter("doublets"))) +{ + const bool produceSeedingHitSets = iConfig.getParameter("produceSeedingHitSets"); + const bool produceIntermediateHitTriplets = iConfig.getParameter("produceIntermediateHitTriplets"); + + auto iC = consumesCollector(); + + using namespace hitTripletEDProducerT; + + if(produceSeedingHitSets && produceIntermediateHitTriplets) + impl_ = std::make_unique>(iConfig, iC); + else if(produceSeedingHitSets) + impl_ = std::make_unique>(iConfig, iC); + else if(produceIntermediateHitTriplets) + impl_ = std::make_unique>(iConfig, iC); + else + throw cms::Exception("Configuration") << "HitTripletEDProducerT requires either produceIntermediateHitTriplets or produceSeedingHitSets to be True. If neither are needed, just remove this module from your sequence/path as it doesn't do anything useful"; + + impl_->produces(*this); +} + +template +void HitTripletEDProducerT::fillDescriptions(edm::ConfigurationDescriptions& descriptions) { + edm::ParameterSetDescription desc; + + desc.add("doublets", edm::InputTag("hitPairEDProducer")); + desc.add("produceSeedingHitSets", false); + desc.add("produceIntermediateHitTriplets", false); + + T_HitTripletGenerator::fillDescriptions(desc); + + auto label = T_HitTripletGenerator::fillDescriptionsLabel() + std::string("EDProducerDefault"); + descriptions.add(label, desc); +} + +template +void HitTripletEDProducerT::produce(edm::Event& iEvent, const edm::EventSetup& iSetup) { + edm::Handle hdoublets; + iEvent.getByToken(doubletToken_, hdoublets); + const auto& regionDoublets = *hdoublets; + + const SeedingLayerSetsHits& seedingLayerHits = regionDoublets.seedingLayerHits(); + if(seedingLayerHits.numberOfLayersInSet() < 3) { + throw cms::Exception("LogicError") << "HitTripletEDProducerT expects SeedingLayerSetsHits::numberOfLayersInSet() to be >= 3, got " << seedingLayerHits.numberOfLayersInSet() << ". This is likely caused by a configuration error of this module, HitPairEDProducer, or SeedingLayersEDProducer."; + } + + impl_->produce(regionDoublets, iEvent, iSetup); +} + + +#endif diff --git a/RecoPixelVertexing/PixelTriplets/interface/HitTripletGeneratorFromPairAndLayers.h b/RecoPixelVertexing/PixelTriplets/interface/HitTripletGeneratorFromPairAndLayers.h index b3fa615327711..05c7fcc992268 100644 --- a/RecoPixelVertexing/PixelTriplets/interface/HitTripletGeneratorFromPairAndLayers.h +++ b/RecoPixelVertexing/PixelTriplets/interface/HitTripletGeneratorFromPairAndLayers.h @@ -12,7 +12,7 @@ #include "TrackingTools/TransientTrackingRecHit/interface/SeedingLayerSetsHits.h" #include "RecoTracker/TkHitPairs/interface/LayerHitMapCache.h" -namespace edm { class ParameterSet; class Event; class EventSetup; class ConsumesCollector; } +namespace edm { class ParameterSet; class Event; class EventSetup; class ConsumesCollector; class ParameterSetDescription;} class TrackingRegion; class HitPairGeneratorFromLayerPair; @@ -25,6 +25,8 @@ class HitTripletGeneratorFromPairAndLayers { explicit HitTripletGeneratorFromPairAndLayers(const edm::ParameterSet& pset); virtual ~HitTripletGeneratorFromPairAndLayers(); + static void fillDescriptions(edm::ParameterSetDescription& desc); + void init( std::unique_ptr&& pairs, LayerCacheType* layerCache); const HitPairGeneratorFromLayerPair& pairGenerator() const { return *thePairGenerator; } diff --git a/RecoPixelVertexing/PixelTriplets/interface/IntermediateHitTriplets.h b/RecoPixelVertexing/PixelTriplets/interface/IntermediateHitTriplets.h new file mode 100644 index 0000000000000..b6b309c539ff2 --- /dev/null +++ b/RecoPixelVertexing/PixelTriplets/interface/IntermediateHitTriplets.h @@ -0,0 +1,314 @@ +#ifndef RecoPixelVertexing_PixelTriplets_IntermediateHitTriplets_h +#define RecoPixelVertexing_PixelTriplets_IntermediateHitTriplets_h + +#include "RecoTracker/TkHitPairs/interface/LayerHitMapCache.h" +#include "RecoTracker/TkHitPairs/interface/IntermediateHitDoublets.h" +#include "TrackingTools/TransientTrackingRecHit/interface/SeedingLayerSetsHits.h" +#include "RecoPixelVertexing/PixelTriplets/interface/OrderedHitTriplets.h" + +/** + * Container of temporary information delivered from hit triplet + * generator to hit quadruplet generator via edm::Event. + * + * The iterator loops over regions, the value_type of that has an + * iterator looping over the layer triplets of the region, and the + * value_type of that has an iterator looping over the hit triplets of + * the layer triplet. + * + * Pointers to SeedingLayerSetsHits and TrackingRegion are stored, so + * the lifetime of those objects should be at least as long as the + * lifetime of this object. + */ +class IntermediateHitTriplets { +public: + using LayerPair = std::tuple; + using LayerTriplet = std::tuple; + using RegionIndex = ihd::RegionIndex; + + //////////////////// + + /** + * Helper class holding the layer triplet indices (to + * SeedingLayerSetsHits), and indices of the hit triplets from this + * layer triplet (to the hit triplet vector) + * + * As only the indices of hit triplets are stored, a separate class + * (LayerHitTriplets) is provided with nicer interface. + */ + class PLayerHitTriplets { + public: + PLayerHitTriplets(const LayerTriplet& layerTriplet, unsigned int tripletsBegin): + layerTriplet_(layerTriplet), + tripletsBegin_(tripletsBegin), tripletsEnd_(tripletsBegin) + {} + + void setTripletsEnd(unsigned int end) { tripletsEnd_ = end; } + + const LayerTriplet& layerTriplet() const { return layerTriplet_; } + + unsigned int tripletsBegin() const { return tripletsBegin_; } + unsigned int tripletsEnd() const { return tripletsEnd_; } + + private: + LayerTriplet layerTriplet_; + unsigned int tripletsBegin_; + unsigned int tripletsEnd_; + }; + + //////////////////// + + /** + * Helper class providing a nice interface for the hit triplets of a + * layer triplet. + */ + class LayerHitTriplets { + public: + using const_iterator = std::vector::const_iterator; + + LayerHitTriplets(const IntermediateHitTriplets *hitSets, + const PLayerHitTriplets *layerTriplet): + hitSets_(hitSets), + layerTriplet_(layerTriplet) + {} + + using TripletRange = std::pair::const_iterator, + std::vector::const_iterator>; + + SeedingLayerSetsHits::LayerIndex innerLayerIndex() const { return std::get<0>(layerTriplet_->layerTriplet()); } + SeedingLayerSetsHits::LayerIndex middleLayerIndex() const { return std::get<1>(layerTriplet_->layerTriplet()); } + SeedingLayerSetsHits::LayerIndex outerLayerIndex() const { return std::get<2>(layerTriplet_->layerTriplet()); } + + const_iterator begin() const { return hitSets_->tripletsBegin() + layerTriplet_->tripletsBegin(); } + const_iterator cbegin() const { return begin(); } + const_iterator end() const { return hitSets_->tripletsBegin() + layerTriplet_->tripletsEnd(); } + const_iterator cend() const { return end(); } + + private: + const IntermediateHitTriplets *hitSets_; + const PLayerHitTriplets *layerTriplet_; + }; + + //////////////////// + + /** + * Helper class to provide nice interface to loop over the layer sets of a region + * + * The value_type of the iterator is LayerHitTriplets, which has an + * iterator for the hit triplets. + * + * Can not use ihd::RegionLayerSets here because of having + * separate classes for storage (PLayerHitTriplets) and use + * (LayerHitTriplets). + */ + class RegionLayerSets { + public: + using PLayerHitTripletsConstIterator = std::vector::const_iterator; + using TripletConstIterator = std::vector::const_iterator; + + class const_iterator { + public: + using internal_iterator_type = PLayerHitTripletsConstIterator; + using value_type = LayerHitTriplets; + using difference_type = internal_iterator_type::difference_type; + + struct end_tag {}; + + /** + * Constructor for an iterator pointing to a valid element + */ + const_iterator(const IntermediateHitTriplets *hitSets, const RegionLayerSets *regionLayerSets): + hitSets_(hitSets), + regionLayerSets_(regionLayerSets), + iter_(regionLayerSets->layerSetsBegin()) + { + assert(regionLayerSets->layerSetsBegin() != regionLayerSets->layerSetsEnd()); + } + + /** + * Constructor for an iterator pointing to an invalid element (i.e. end) + * + * The end_tag parameter is used to differentiate this constructor from the other one. + */ + const_iterator(const IntermediateHitTriplets *hitSets, const RegionLayerSets *regionLayerSets, end_tag): + iter_(regionLayerSets->layerSetsEnd()) + {} + + value_type operator*() const { + return value_type(hitSets_, &(*iter_)); + } + + const_iterator& operator++() { + ++iter_; + return *this; + } + + const_iterator operator++(int) { + const_iterator clone(*this); + operator++(); + return clone; + } + + bool operator==(const const_iterator& other) const { return iter_ == other.iter_; } + bool operator!=(const const_iterator& other) const { return !operator==(other); } + + private: + const IntermediateHitTriplets *hitSets_; + const RegionLayerSets *regionLayerSets_; + internal_iterator_type iter_; + }; + + RegionLayerSets(const TrackingRegion* region, + const LayerHitMapCache *cache, + const IntermediateHitTriplets *hitSets, + PLayerHitTripletsConstIterator tripletBegin, + PLayerHitTripletsConstIterator tripletEnd): + region_(region), + cache_(cache), + hitSets_(hitSets), + layerSetsBegin_(tripletBegin), layerSetsEnd_(tripletEnd) + {} + + const TrackingRegion& region() const { return *region_; } + const LayerHitMapCache& layerHitMapCache() const { return *cache_; } + size_t layerTripletsSize() const { return std::distance(layerSetsBegin_, layerSetsEnd_); } + + const_iterator begin() const { + if(layerSetsBegin_ != layerSetsEnd_) + return const_iterator(hitSets_, this); + else + return end(); + } + const_iterator cbegin() const { return begin(); } + const_iterator end() const { return const_iterator(hitSets_, this, const_iterator::end_tag()); } + const_iterator cend() const { return end(); } + + // used internally by the LayerHitTriplets helper class + PLayerHitTripletsConstIterator layerSetsBegin() const { return layerSetsBegin_; } + PLayerHitTripletsConstIterator layerSetsEnd() const { return layerSetsEnd_; } + + private: + const TrackingRegion *region_ = nullptr; + const LayerHitMapCache *cache_ = nullptr; + const IntermediateHitTriplets *hitSets_ = nullptr; + const PLayerHitTripletsConstIterator layerSetsBegin_; + const PLayerHitTripletsConstIterator layerSetsEnd_; + }; + + //////////////////// + + /// Iterator over regions + using const_iterator = ihd::const_iterator; + + //////////////////// + + /// Helper class enforcing correct way of filling the doublets of a region + class RegionFiller { + public: + RegionFiller(): obj_(nullptr) {} + explicit RegionFiller(IntermediateHitTriplets *obj): obj_(obj) {} + + ~RegionFiller() = default; + + bool valid() const { return obj_ != nullptr; } + + LayerHitMapCache& layerHitMapCache() { return obj_->regions_.back().layerHitMapCache(); } + + void addTriplets(const LayerPair& layerPair, + const std::vector& thirdLayers, + const OrderedHitTriplets& triplets, + const std::vector& thirdLayerIndex, + const std::vector& permutations) { + assert(triplets.size() == thirdLayerIndex.size()); + assert(triplets.size() == permutations.size()); + + if(triplets.empty()) { + return; + } + + int prevLayer = -1; + for(size_t i=0, size=permutations.size(); ilayerTriplets_.emplace_back(LayerTriplet(std::get<0>(layerPair), std::get<1>(layerPair), thirdLayers[layer].index()), obj_->hitTriplets_.size()); + } + + obj_->hitTriplets_.emplace_back(triplets[realIndex]); + obj_->layerTriplets_.back().setTripletsEnd(obj_->hitTriplets_.size()); + } + + obj_->regions_.back().setLayerSetsEnd(obj_->layerTriplets_.size()); + } + private: + IntermediateHitTriplets *obj_; + }; + + // allows declaring local variables with auto + static RegionFiller dummyFiller() { return RegionFiller(); } + + //////////////////// + + IntermediateHitTriplets(): seedingLayers_(nullptr) {} + explicit IntermediateHitTriplets(const SeedingLayerSetsHits *seedingLayers): seedingLayers_(seedingLayers) {} + IntermediateHitTriplets(const IntermediateHitTriplets& rh); // only to make ROOT dictionary generation happy + ~IntermediateHitTriplets() = default; + + void swap(IntermediateHitTriplets& rh) { + std::swap(seedingLayers_, rh.seedingLayers_); + std::swap(regions_, rh.regions_); + std::swap(layerTriplets_, rh.layerTriplets_); + std::swap(hitTriplets_, rh.hitTriplets_); + } + + void reserve(size_t nregions, size_t nlayersets, size_t ntriplets) { + regions_.reserve(nregions); + layerTriplets_.reserve(nregions*nlayersets); + hitTriplets_.reserve(ntriplets); + } + + void shrink_to_fit() { + regions_.shrink_to_fit(); + layerTriplets_.shrink_to_fit(); + hitTriplets_.shrink_to_fit(); + } + + RegionFiller beginRegion(const TrackingRegion *region) { + regions_.emplace_back(region, layerTriplets_.size()); + return RegionFiller(this); + } + + const SeedingLayerSetsHits& seedingLayerHits() const { return *seedingLayers_; } + bool empty() const { return regions_.empty(); } + size_t regionSize() const { return regions_.size(); } + size_t tripletsSize() const { return hitTriplets_.size(); } + + const_iterator begin() const { return const_iterator(this, regions_.begin()); } + const_iterator cbegin() const { return begin(); } + const_iterator end() const { return const_iterator(this, regions_.end()); } + const_iterator cend() const { return end(); } + + // used internally by all the helper classes + std::vector::const_iterator regionsBegin() const { return regions_.begin(); } + std::vector::const_iterator regionsEnd() const { return regions_.end(); } + std::vector::const_iterator layerSetsBegin() const { return layerTriplets_.begin(); } + std::vector::const_iterator layerSetsEnd() const { return layerTriplets_.end(); } + std::vector::const_iterator tripletsBegin() const { return hitTriplets_.begin(); } + std::vector::const_iterator tripletsEnd() const { return hitTriplets_.end(); } + +private: + const SeedingLayerSetsHits *seedingLayers_; /// Pointer to SeedingLayerSetsHits (owned elsewhere) + + std::vector regions_; /// Container of regions, each element has indices pointing to layerTriplets_ + std::vector layerTriplets_; /// Container of layer triplets, each element has indices pointing to hitTriplets_ + std::vector hitTriplets_; /// Container of hit triplets for all layer triplets and regions +}; + +#endif diff --git a/RecoPixelVertexing/PixelTriplets/interface/QuadrupletSeedMerger.h b/RecoPixelVertexing/PixelTriplets/interface/QuadrupletSeedMerger.h index 0ce6f29c9af98..4788168e34bc6 100644 --- a/RecoPixelVertexing/PixelTriplets/interface/QuadrupletSeedMerger.h +++ b/RecoPixelVertexing/PixelTriplets/interface/QuadrupletSeedMerger.h @@ -77,6 +77,7 @@ class QuadrupletSeedMerger { public: + explicit QuadrupletSeedMerger(const edm::ParameterSet& iConfig, edm::ConsumesCollector&& iC): QuadrupletSeedMerger(iConfig, iC) {} explicit QuadrupletSeedMerger(const edm::ParameterSet& iConfig, edm::ConsumesCollector& iC); QuadrupletSeedMerger(const edm::ParameterSet& iConfig, const edm::ParameterSet& seedCreatorConfig, edm::ConsumesCollector& iC); ~QuadrupletSeedMerger(); diff --git a/RecoPixelVertexing/PixelTriplets/plugins/CAHitNtupletEDProducerT.cc b/RecoPixelVertexing/PixelTriplets/plugins/CAHitNtupletEDProducerT.cc new file mode 100644 index 0000000000000..cbe05d19363d1 --- /dev/null +++ b/RecoPixelVertexing/PixelTriplets/plugins/CAHitNtupletEDProducerT.cc @@ -0,0 +1,118 @@ +#include "FWCore/Framework/interface/stream/EDProducer.h" +#include "FWCore/Framework/interface/ConsumesCollector.h" +#include "FWCore/ParameterSet/interface/ParameterSet.h" +#include "FWCore/ParameterSet/interface/ConfigurationDescriptions.h" +#include "FWCore/ParameterSet/interface/ParameterSetDescription.h" +#include "FWCore/Utilities/interface/EDGetToken.h" +#include "FWCore/Framework/interface/Event.h" +#include "DataFormats/Common/interface/Handle.h" +#include "FWCore/Utilities/interface/RunningAverage.h" + +#include "RecoTracker/TkHitPairs/interface/RegionsSeedingHitSets.h" +#include "RecoPixelVertexing/PixelTriplets/interface/OrderedHitTriplets.h" +#include "RecoPixelVertexing/PixelTriplets/interface/OrderedHitSeeds.h" +#include "RecoTracker/TkHitPairs/interface/IntermediateHitDoublets.h" + +namespace { + void fillNtuplets(RegionsSeedingHitSets::RegionFiller& seedingHitSetsFiller, + const OrderedHitTriplets& triplets) { + for(const auto& triplet: triplets) { + seedingHitSetsFiller.emplace_back(triplet[0], triplet[1], triplet[2]); + } + } + + void fillNtuplets(RegionsSeedingHitSets::RegionFiller& seedingHitSetsFiller, + const OrderedHitSeeds& quadruplets) { + for(const auto& quad: quadruplets) { + seedingHitSetsFiller.emplace_back(quad[0], quad[1], quad[2], quad[3]); + } + } +} + +template +class CAHitNtupletEDProducerT: public edm::stream::EDProducer<> { +public: + CAHitNtupletEDProducerT(const edm::ParameterSet& iConfig); + ~CAHitNtupletEDProducerT() = default; + + static void fillDescriptions(edm::ConfigurationDescriptions& descriptions); + + virtual void produce(edm::Event& iEvent, const edm::EventSetup& iSetup) override; + +private: + edm::EDGetTokenT doubletToken_; + + edm::RunningAverage localRA_; + + T_Generator generator_; +}; + +template +CAHitNtupletEDProducerT::CAHitNtupletEDProducerT(const edm::ParameterSet& iConfig): + doubletToken_(consumes(iConfig.getParameter("doublets"))), + generator_(iConfig, consumesCollector(), false) +{ + produces(); +} + +template +void CAHitNtupletEDProducerT::fillDescriptions(edm::ConfigurationDescriptions& descriptions) { + edm::ParameterSetDescription desc; + + desc.add("doublets", edm::InputTag("hitPairEDProducer")); + T_Generator::fillDescriptions(desc); + + auto label = T_Generator::fillDescriptionsLabel() + std::string("EDProducer"); + descriptions.add(label, desc); +} + +template +void CAHitNtupletEDProducerT::produce(edm::Event& iEvent, const edm::EventSetup& iSetup) { + edm::Handle hdoublets; + iEvent.getByToken(doubletToken_, hdoublets); + const auto& regionDoublets = *hdoublets; + + const SeedingLayerSetsHits& seedingLayerHits = regionDoublets.seedingLayerHits(); + if(seedingLayerHits.numberOfLayersInSet() < T_Generator::minLayers) { + throw cms::Exception("LogicError") << "CAHitNtupletEDProducer expects SeedingLayerSetsHits::numberOfLayersInSet() to be >= " << T_Generator::minLayers << ", got " << seedingLayerHits.numberOfLayersInSet() << ". This is likely caused by a configuration error of this module, HitPairEDProducer, or SeedingLayersEDProducer."; + } + + auto seedingHitSets = std::make_unique(); + if(regionDoublets.empty()) { + iEvent.put(std::move(seedingHitSets)); + return; + } + seedingHitSets->reserve(regionDoublets.regionSize(), localRA_.upper()); + generator_.initEvent(iEvent, iSetup); + + LogDebug("CAHitNtupletEDProducer") << "Creating ntuplets for " << regionDoublets.regionSize() << " regions, and " << regionDoublets.layerPairsSize() << " layer pairs"; + + typename T_Generator::ResultType ntuplets; + ntuplets.reserve(localRA_.upper()); + + for(const auto& regionLayerPairs: regionDoublets) { + const TrackingRegion& region = regionLayerPairs.region(); + auto seedingHitSetsFiller = seedingHitSets->beginRegion(®ion); + + LogTrace("CAHitNtupletEDProducer") << " starting region"; + + generator_.hitNtuplets(regionLayerPairs, ntuplets, iSetup, seedingLayerHits); + LogTrace("CAHitNtupletEDProducer") << " created " << ntuplets.size() << " ntuplets"; + fillNtuplets(seedingHitSetsFiller, ntuplets); + + ntuplets.clear(); + } + localRA_.update(seedingHitSets->size()); + + iEvent.put(std::move(seedingHitSets)); +} + +#include "FWCore/PluginManager/interface/ModuleDef.h" +#include "FWCore/Framework/interface/MakerMacros.h" +#include "CAHitQuadrupletGenerator.h" +using CAHitQuadrupletEDProducer = CAHitNtupletEDProducerT; +DEFINE_FWK_MODULE(CAHitQuadrupletEDProducer); + +#include "CAHitTripletGenerator.h" +using CAHitTripletEDProducer = CAHitNtupletEDProducerT; +DEFINE_FWK_MODULE(CAHitTripletEDProducer); diff --git a/RecoPixelVertexing/PixelTriplets/plugins/CAHitQuadrupletGenerator.cc b/RecoPixelVertexing/PixelTriplets/plugins/CAHitQuadrupletGenerator.cc index 931f51c08ab5d..31c3588afe94d 100644 --- a/RecoPixelVertexing/PixelTriplets/plugins/CAHitQuadrupletGenerator.cc +++ b/RecoPixelVertexing/PixelTriplets/plugins/CAHitQuadrupletGenerator.cc @@ -4,6 +4,7 @@ #include "RecoPixelVertexing/PixelTriplets/interface/HitQuadrupletGenerator.h" #include "LayerQuadruplets.h" +#include "FWCore/ParameterSet/interface/ParameterSetDescription.h" #include "FWCore/Framework/interface/ConsumesCollector.h" #include "FWCore/Framework/interface/Event.h" #include "DataFormats/Common/interface/Handle.h" @@ -19,6 +20,8 @@ #include "FWCore/Utilities/interface/isFinite.h" +#include + namespace { @@ -34,8 +37,7 @@ namespace using namespace std; using namespace ctfseeding; -CAHitQuadrupletGenerator::CAHitQuadrupletGenerator(const edm::ParameterSet& cfg, edm::ConsumesCollector& iC) : -theSeedingLayerToken(iC.consumes(cfg.getParameter("SeedingLayers"))), +CAHitQuadrupletGenerator::CAHitQuadrupletGenerator(const edm::ParameterSet& cfg, edm::ConsumesCollector& iC, bool needSeedingLayerSetsHits) : extraHitRPhitolerance(cfg.getParameter("extraHitRPhitolerance")), //extra window in ThirdHitPredictionFromCircle range (divide by R to get phi) maxChi2(cfg.getParameter("maxChi2")), fitFastCircle(cfg.getParameter("fitFastCircle")), @@ -45,6 +47,9 @@ caThetaCut(cfg.getParameter("CAThetaCut")), caPhiCut(cfg.getParameter("CAPhiCut")), caHardPtCut(cfg.getParameter("CAHardPtCut")) { + if(needSeedingLayerSetsHits) + theSeedingLayerToken = iC.consumes(cfg.getParameter("SeedingLayers")); + if (cfg.exists("SeedComparitorPSet")) { edm::ParameterSet comparitorPSet = @@ -61,25 +66,37 @@ CAHitQuadrupletGenerator::~CAHitQuadrupletGenerator() { } -void CAHitQuadrupletGenerator::hitQuadruplets(const TrackingRegion& region, - OrderedHitSeeds & result, const edm::Event& ev, - const edm::EventSetup& es) -{ - edm::Handle hlayers; - ev.getByToken(theSeedingLayerToken, hlayers); - const SeedingLayerSetsHits& layers = *hlayers; - if (layers.numberOfLayersInSet() != 4) - throw cms::Exception("Configuration") - << "CAHitQuadrupletsGenerator expects SeedingLayerSetsHits::numberOfLayersInSet() to be 4, got " - << layers.numberOfLayersInSet(); - - CAGraph g; - - - std::vector hitDoublets; +void CAHitQuadrupletGenerator::fillDescriptions(edm::ParameterSetDescription& desc) { + desc.add("extraHitRPhitolerance", 0.1); + desc.add("fitFastCircle", false); + desc.add("fitFastCircleChi2Cut", false); + desc.add("useBendingCorrection", false); + desc.add("CAThetaCut", 0.00125); + desc.add("CAPhiCut", 10); + desc.add("CAHardPtCut", 0); + + edm::ParameterSetDescription descMaxChi2; + descMaxChi2.add("pt1", 0.2); + descMaxChi2.add("pt2", 1.5); + descMaxChi2.add("value1", 500); + descMaxChi2.add("value2", 50); + descMaxChi2.add("enabled", true); + desc.add("maxChi2", descMaxChi2); + + edm::ParameterSetDescription descComparitor; + descComparitor.add("ComponentName", "none"); + descComparitor.setAllowAnything(); // until we have moved SeedComparitor too to EDProducers + desc.add("SeedComparitorPSet", descComparitor); +} +void CAHitQuadrupletGenerator::initEvent(const edm::Event& ev, const edm::EventSetup& es) { + if (theComparitor) theComparitor->init(ev, es); +} - HitPairGeneratorFromLayerPair thePairGenerator(0, 1, &theLayerCache); +namespace { + template + void fillGraph(const SeedingLayerSetsHits& layers, CAGraph& g, T_HitDoublets& hitDoublets, + T_GeneratorOrPairsFunction generatorOrPairsFunction) { for (unsigned int i = 0; i < layers.size(); i++) { for (unsigned int j = 0; j < 4; ++j) @@ -119,28 +136,100 @@ void CAHitQuadrupletGenerator::hitQuadruplets(const TrackingRegion& region, if (std::find(g.theLayerPairs.begin(), g.theLayerPairs.end(), tmpInnerLayerPair) == g.theLayerPairs.end()) { - hitDoublets.emplace_back(thePairGenerator.doublets(region, ev, es, - layers[i][j-1], layers[i][j])); - - g.theLayerPairs.push_back(tmpInnerLayerPair); - g.theLayers[vertexIndex].theInnerLayers.push_back( + const bool nonEmpty = generatorOrPairsFunction(layers[i][j-1], layers[i][j], hitDoublets); + if(nonEmpty) { + g.theLayerPairs.push_back(tmpInnerLayerPair); + g.theLayers[vertexIndex].theInnerLayers.push_back( innerVertex - g.theLayers.begin()); - innerVertex->theOuterLayers.push_back(vertexIndex); - g.theLayers[vertexIndex].theInnerLayerPairs.push_back( + innerVertex->theOuterLayers.push_back(vertexIndex); + g.theLayers[vertexIndex].theInnerLayerPairs.push_back( g.theLayerPairs.size() - 1); - innerVertex->theOuterLayerPairs.push_back( + innerVertex->theOuterLayerPairs.push_back( g.theLayerPairs.size() - 1); - + } } } } } + } +} +void CAHitQuadrupletGenerator::hitQuadruplets(const TrackingRegion& region, + OrderedHitSeeds & result, const edm::Event& ev, + const edm::EventSetup& es) +{ + edm::Handle hlayers; + ev.getByToken(theSeedingLayerToken, hlayers); + const SeedingLayerSetsHits& layers = *hlayers; + if (layers.numberOfLayersInSet() != 4) + throw cms::Exception("Configuration") + << "CAHitQuadrupletsGenerator expects SeedingLayerSetsHits::numberOfLayersInSet() to be 4, got " + << layers.numberOfLayersInSet(); + + CAGraph g; + + + std::vector hitDoublets; + + + HitPairGeneratorFromLayerPair thePairGenerator(0, 1, &theLayerCache); + fillGraph(layers, g, hitDoublets, + [&](const SeedingLayerSetsHits::SeedingLayer& inner, + const SeedingLayerSetsHits::SeedingLayer& outer, + std::vector& hitDoublets) { + hitDoublets.emplace_back(thePairGenerator.doublets(region, ev, es, inner, outer)); + return true; + }); + if (theComparitor) theComparitor->init(ev, es); + + std::vector hitDoubletsPtr; + hitDoubletsPtr.reserve(hitDoublets.size()); + for(const auto& e: hitDoublets) + hitDoubletsPtr.emplace_back(&e); + + hitQuadruplets(region, result, hitDoubletsPtr, g, es); + theLayerCache.clear(); +} + +void CAHitQuadrupletGenerator::hitNtuplets(const IntermediateHitDoublets::RegionLayerSets& regionLayerPairs, + OrderedHitSeeds& result, + const edm::EventSetup& es, + const SeedingLayerSetsHits& layers) { + CAGraph g; + + std::vector hitDoublets; + + auto layerPairEqual = [](const IntermediateHitDoublets::LayerPairHitDoublets& pair, + SeedingLayerSetsHits::LayerIndex inner, + SeedingLayerSetsHits::LayerIndex outer) { + return pair.innerLayerIndex() == inner && pair.outerLayerIndex() == outer; + }; + fillGraph(layers, g, hitDoublets, + [&](const SeedingLayerSetsHits::SeedingLayer& inner, + const SeedingLayerSetsHits::SeedingLayer& outer, + std::vector& hitDoublets) { + using namespace std::placeholders; + auto found = std::find_if(regionLayerPairs.begin(), regionLayerPairs.end(), + std::bind(layerPairEqual, _1, inner.index(), outer.index())); + if(found != regionLayerPairs.end()) { + hitDoublets.emplace_back(&(found->doublets())); + return true; + } + return false; + }); + + hitQuadruplets(regionLayerPairs.region(), result, hitDoublets, g, es); +} + +void CAHitQuadrupletGenerator::hitQuadruplets(const TrackingRegion& region, + OrderedHitSeeds & result, + std::vector& hitDoublets, const CAGraph& g, + const edm::EventSetup& es) { const int numberOfHitsInNtuplet = 4; std::vector foundQuadruplets; @@ -187,6 +276,11 @@ void CAHitQuadrupletGenerator::hitQuadruplets(const TrackingRegion& region, ges[3] = ahit->globalPositionError(); barrels[3] = isBarrel(ahit->geographicalId().subdetId()); + // TODO: + // - 'line' is not used for anything + // - if we decide to always do the circle fit for 4 hits, we don't + // need ThirdHitPredictionFromCircle for the curvature; then we + // could remove extraHitRPhitolerance configuration parameter PixelRecoLineRZ line(gps[0], gps[2]); ThirdHitPredictionFromCircle predictionRPhi(gps[0], gps[2], extraHitRPhitolerance); const float curvature = predictionRPhi.curvature(ThirdHitPredictionFromCircle::Vector2D(gps[1].x(), gps[1].y())); @@ -246,8 +340,6 @@ void CAHitQuadrupletGenerator::hitQuadruplets(const TrackingRegion& region, result.emplace_back(foundQuadruplets[quadId][0]->getInnerHit(), foundQuadruplets[quadId][1]->getInnerHit(), foundQuadruplets[quadId][2]->getInnerHit(), foundQuadruplets[quadId][2]->getOuterHit()); } - - theLayerCache.clear(); } diff --git a/RecoPixelVertexing/PixelTriplets/plugins/CAHitQuadrupletGenerator.h b/RecoPixelVertexing/PixelTriplets/plugins/CAHitQuadrupletGenerator.h index 4defa0177cd37..34e2635fbcce2 100644 --- a/RecoPixelVertexing/PixelTriplets/plugins/CAHitQuadrupletGenerator.h +++ b/RecoPixelVertexing/PixelTriplets/plugins/CAHitQuadrupletGenerator.h @@ -17,33 +17,55 @@ #include "FWCore/ParameterSet/interface/ParameterSet.h" #include "FWCore/Utilities/interface/EDGetToken.h" +#include "RecoTracker/TkHitPairs/interface/IntermediateHitDoublets.h" + class TrackingRegion; class HitQuadrupletGeneratorFromTripletAndLayers; class SeedingLayerSetsHits; namespace edm { class Event; -} -namespace edm { class EventSetup; + class ParameterSetDescription; } class CAHitQuadrupletGenerator : public HitQuadrupletGenerator { public: typedef LayerHitMapCache LayerCacheType; + static constexpr unsigned int minLayers = 4; + typedef OrderedHitSeeds ResultType; + public: - CAHitQuadrupletGenerator(const edm::ParameterSet& cfg, edm::ConsumesCollector& iC); + CAHitQuadrupletGenerator(const edm::ParameterSet& cfg, edm::ConsumesCollector&& iC, bool needSeedingLayerSetsHits=true): CAHitQuadrupletGenerator(cfg, iC, needSeedingLayerSetsHits) {} + CAHitQuadrupletGenerator(const edm::ParameterSet& cfg, edm::ConsumesCollector& iC, bool needSeedingLayerSetsHits=true); virtual ~CAHitQuadrupletGenerator(); + static void fillDescriptions(edm::ParameterSetDescription& desc); + static const char *fillDescriptionsLabel() { return "caHitQuadruplet"; } + + void initEvent(const edm::Event& ev, const edm::EventSetup& es); + + /// from base class virtual void hitQuadruplets(const TrackingRegion& reg, OrderedHitSeeds & quadruplets, const edm::Event & ev, const edm::EventSetup& es); + // new-style + void hitNtuplets(const IntermediateHitDoublets::RegionLayerSets& regionLayerPairs, + OrderedHitSeeds& result, + const edm::EventSetup& es, + const SeedingLayerSetsHits& layers); private: + // actual work + void hitQuadruplets(const TrackingRegion& reg, OrderedHitSeeds& result, + std::vector& hitDoublets, + const CAGraph& g, + const edm::EventSetup& es); + edm::EDGetTokenT theSeedingLayerToken; LayerCacheType theLayerCache; diff --git a/RecoPixelVertexing/PixelTriplets/plugins/CAHitTripletGenerator.cc b/RecoPixelVertexing/PixelTriplets/plugins/CAHitTripletGenerator.cc index 952441ff1854a..c38eef6699921 100644 --- a/RecoPixelVertexing/PixelTriplets/plugins/CAHitTripletGenerator.cc +++ b/RecoPixelVertexing/PixelTriplets/plugins/CAHitTripletGenerator.cc @@ -5,6 +5,7 @@ #include "RecoPixelVertexing/PixelTriplets/interface/ThirdHitPredictionFromCircle.h" #include "RecoPixelVertexing/PixelTriplets/interface/HitTripletGenerator.h" +#include "FWCore/ParameterSet/interface/ParameterSetDescription.h" #include "FWCore/Framework/interface/ConsumesCollector.h" #include "FWCore/Framework/interface/Event.h" #include "DataFormats/Common/interface/Handle.h" @@ -31,8 +32,8 @@ using namespace std; using namespace ctfseeding; CAHitTripletGenerator::CAHitTripletGenerator(const edm::ParameterSet& cfg, - edm::ConsumesCollector& iC) : - theSeedingLayerToken(iC.consumes < SeedingLayerSetsHits > (cfg.getParameter < edm::InputTag > ("SeedingLayers"))), + edm::ConsumesCollector& iC, + bool needSeedingLayerSetsHits) : extraHitRPhitolerance(cfg.getParameter("extraHitRPhitolerance")), //extra window in ThirdHitPredictionFromCircle range (divide by R to get phi) maxChi2(cfg.getParameter < edm::ParameterSet > ("maxChi2")), useBendingCorrection(cfg.getParameter("useBendingCorrection")), @@ -40,6 +41,10 @@ CAHitTripletGenerator::CAHitTripletGenerator(const edm::ParameterSet& cfg, caPhiCut(cfg.getParameter("CAPhiCut")), caHardPtCut(cfg.getParameter("CAHardPtCut")) { + + if(needSeedingLayerSetsHits) + theSeedingLayerToken = iC.consumes(cfg.getParameter("SeedingLayers")); + if (cfg.exists("SeedComparitorPSet")) { edm::ParameterSet comparitorPSet = cfg.getParameter < edm::ParameterSet @@ -59,23 +64,36 @@ CAHitTripletGenerator::~CAHitTripletGenerator() { } -void CAHitTripletGenerator::hitTriplets(const TrackingRegion& region, - OrderedHitTriplets & result, const edm::Event& ev, - const edm::EventSetup& es) -{ - edm::Handle hlayers; - ev.getByToken(theSeedingLayerToken, hlayers); - const SeedingLayerSetsHits& layers = *hlayers; - if (layers.numberOfLayersInSet() != 3) - throw cms::Exception("Configuration") - << "CAHitTripletGenerator expects SeedingLayerSetsHits::numberOfLayersInSet() to be 3, got " - << layers.numberOfLayersInSet(); +void CAHitTripletGenerator::fillDescriptions(edm::ParameterSetDescription& desc) { + desc.add("extraHitRPhitolerance", 0.06); + desc.add("useBendingCorrection", false); + desc.add("CAThetaCut", 0.00125); + desc.add("CAPhiCut", 0.1); + desc.add("CAHardPtCut", 0); + + edm::ParameterSetDescription descMaxChi2; + descMaxChi2.add("pt1", 0.8); + descMaxChi2.add("pt2", 2); + descMaxChi2.add("value1", 50); + descMaxChi2.add("value2", 8); + descMaxChi2.add("enabled", true); + desc.add("maxChi2", descMaxChi2); + + edm::ParameterSetDescription descComparitor; + descComparitor.add("ComponentName", "none"); + descComparitor.setAllowAnything(); // until we have moved SeedComparitor too to EDProducers + desc.add("SeedComparitorPSet", descComparitor); +} - CAGraph g; +void CAHitTripletGenerator::initEvent(const edm::Event& ev, const edm::EventSetup& es) { + if (theComparitor) theComparitor->init(ev, es); +} - std::vector hitDoublets; +namespace { + template + void fillGraph(const SeedingLayerSetsHits& layers, CAGraph& g, T_HitDoublets& hitDoublets, + T_GeneratorOrPairsFunction generatorOrPairsFunction) { - HitPairGeneratorFromLayerPair thePairGenerator(0, 1, &theLayerCache); for (unsigned int i = 0; i < layers.size(); i++) { for (unsigned int j = 0; j < 3; ++j) @@ -116,29 +134,94 @@ void CAHitTripletGenerator::hitTriplets(const TrackingRegion& region, if (std::find(g.theLayerPairs.begin(), g.theLayerPairs.end(), tmpInnerLayerPair) == g.theLayerPairs.end()) { - hitDoublets.emplace_back( - thePairGenerator.doublets(region, ev, es, - layers[i][j - 1], layers[i][j])); - - g.theLayerPairs.push_back(tmpInnerLayerPair); - g.theLayers[vertexIndex].theInnerLayers.push_back( + const bool nonEmpty = generatorOrPairsFunction(layers[i][j - 1], layers[i][j], hitDoublets); + if(nonEmpty) { + g.theLayerPairs.push_back(tmpInnerLayerPair); + g.theLayers[vertexIndex].theInnerLayers.push_back( innerVertex - g.theLayers.begin()); - innerVertex->theOuterLayers.push_back(vertexIndex); - g.theLayers[vertexIndex].theInnerLayerPairs.push_back( + innerVertex->theOuterLayers.push_back(vertexIndex); + g.theLayers[vertexIndex].theInnerLayerPairs.push_back( g.theLayerPairs.size() - 1); - innerVertex->theOuterLayerPairs.push_back( + innerVertex->theOuterLayerPairs.push_back( g.theLayerPairs.size() - 1); - + } } } } } + } +} + +void CAHitTripletGenerator::hitTriplets(const TrackingRegion& region, + OrderedHitTriplets & result, const edm::Event& ev, + const edm::EventSetup& es) +{ + edm::Handle hlayers; + ev.getByToken(theSeedingLayerToken, hlayers); + const SeedingLayerSetsHits& layers = *hlayers; + if (layers.numberOfLayersInSet() != 3) + throw cms::Exception("Configuration") + << "CAHitTripletGenerator expects SeedingLayerSetsHits::numberOfLayersInSet() to be 3, got " + << layers.numberOfLayersInSet(); + + CAGraph g; + + std::vector hitDoublets; + + + + HitPairGeneratorFromLayerPair thePairGenerator(0, 1, &theLayerCache); + fillGraph(layers, g, hitDoublets, [&](const SeedingLayerSetsHits::SeedingLayer& inner, const SeedingLayerSetsHits::SeedingLayer& outer, std::vector& hitDoublets) { + hitDoublets.emplace_back(thePairGenerator.doublets(region, ev, es, inner, outer)); + return true; + }); + if (theComparitor) theComparitor->init(ev, es); + std::vector hitDoubletsPtr; + hitDoubletsPtr.reserve(hitDoublets.size()); + for(const auto& e: hitDoublets) + hitDoubletsPtr.emplace_back(&e); + + hitTriplets(region, result, hitDoubletsPtr, g, es); + theLayerCache.clear(); +} + +void CAHitTripletGenerator::hitNtuplets(const IntermediateHitDoublets::RegionLayerSets& regionLayerPairs, + OrderedHitTriplets& result, + const edm::EventSetup& es, + const SeedingLayerSetsHits& layers) { + CAGraph g; + + std::vector hitDoublets; + + auto layerPairEqual = [](const IntermediateHitDoublets::LayerPairHitDoublets& pair, + SeedingLayerSetsHits::LayerIndex inner, + SeedingLayerSetsHits::LayerIndex outer) { + return pair.innerLayerIndex() == inner && pair.outerLayerIndex() == outer; + }; + fillGraph(layers, g, hitDoublets, [&](const SeedingLayerSetsHits::SeedingLayer& inner, const SeedingLayerSetsHits::SeedingLayer& outer, std::vector& hitDoublets) { + using namespace std::placeholders; + auto found = std::find_if(regionLayerPairs.begin(), regionLayerPairs.end(), std::bind(layerPairEqual, _1, inner.index(), outer.index())); + if(found != regionLayerPairs.end()) { + hitDoublets.emplace_back(&(found->doublets())); + return true; + } + return false; + }); + + hitTriplets(regionLayerPairs.region(), result, hitDoublets, g, es); +} + + +void CAHitTripletGenerator::hitTriplets(const TrackingRegion& region, + OrderedHitTriplets & result, + std::vector& hitDoublets, const CAGraph& g, + const edm::EventSetup& es) { std::vector foundTriplets; CellularAutomaton ca(g); diff --git a/RecoPixelVertexing/PixelTriplets/plugins/CAHitTripletGenerator.h b/RecoPixelVertexing/PixelTriplets/plugins/CAHitTripletGenerator.h index 5e84c76074b0c..a7eff0cfc44f1 100644 --- a/RecoPixelVertexing/PixelTriplets/plugins/CAHitTripletGenerator.h +++ b/RecoPixelVertexing/PixelTriplets/plugins/CAHitTripletGenerator.h @@ -9,6 +9,7 @@ #include "RecoTracker/TkMSParametrization/interface/PixelRecoUtilities.h" #include "RecoTracker/TkMSParametrization/interface/LongitudinalBendingCorrection.h" #include "DataFormats/SiPixelDetId/interface/PixelSubdetector.h" +#include "CAGraph.h" #include "RecoTracker/TkHitPairs/interface/HitPairGeneratorFromLayerPair.h" @@ -16,32 +17,53 @@ #include "FWCore/ParameterSet/interface/ParameterSet.h" #include "FWCore/Utilities/interface/EDGetToken.h" +#include "RecoTracker/TkHitPairs/interface/IntermediateHitDoublets.h" + class TrackingRegion; class SeedingLayerSetsHits; namespace edm { class Event; -} -namespace edm { class EventSetup; + class ParameterSetDescription; } class CAHitTripletGenerator : public HitTripletGenerator { public: typedef LayerHitMapCache LayerCacheType; + static constexpr unsigned int minLayers = 3; + typedef OrderedHitTriplets ResultType; + public: - CAHitTripletGenerator(const edm::ParameterSet& cfg, edm::ConsumesCollector& iC); + CAHitTripletGenerator(const edm::ParameterSet& cfg, edm::ConsumesCollector&& iC, bool needSeedingLayerSetsHits=true): CAHitTripletGenerator(cfg, iC, needSeedingLayerSetsHits) {} + CAHitTripletGenerator(const edm::ParameterSet& cfg, edm::ConsumesCollector& iC, bool needSeedingLayerSetsHits=true); virtual ~CAHitTripletGenerator(); + static void fillDescriptions(edm::ParameterSetDescription& desc); + static const char *fillDescriptionsLabel() { return "caHitTriplet"; } + + void initEvent(const edm::Event& ev, const edm::EventSetup& es); + /// from base class virtual void hitTriplets(const TrackingRegion& reg, OrderedHitTriplets & triplets, const edm::Event & ev, const edm::EventSetup& es); + // new-style + void hitNtuplets(const IntermediateHitDoublets::RegionLayerSets& regionLayerPairs, + OrderedHitTriplets& result, + const edm::EventSetup& es, + const SeedingLayerSetsHits& layers); private: + // actual work + void hitTriplets(const TrackingRegion& reg, OrderedHitTriplets& result, + std::vector& hitDoublets, + const CAGraph& g, + const edm::EventSetup& es); + edm::EDGetTokenT theSeedingLayerToken; LayerCacheType theLayerCache; diff --git a/RecoPixelVertexing/PixelTriplets/plugins/CellularAutomaton.cc b/RecoPixelVertexing/PixelTriplets/plugins/CellularAutomaton.cc index 78d5e34a39d12..7a3f7aef73cb1 100644 --- a/RecoPixelVertexing/PixelTriplets/plugins/CellularAutomaton.cc +++ b/RecoPixelVertexing/PixelTriplets/plugins/CellularAutomaton.cc @@ -1,6 +1,6 @@ #include "CellularAutomaton.h" -void CellularAutomaton::createAndConnectCells(const std::vector& hitDoublets, const TrackingRegion& region, +void CellularAutomaton::createAndConnectCells(const std::vector& hitDoublets, const TrackingRegion& region, const float thetaCut, const float phiCut, const float hardPtCut) { unsigned int cellId = 0; @@ -48,7 +48,7 @@ void CellularAutomaton::createAndConnectCells(const std::vector& hi { const HitDoublets* doubletLayerPairId = - &(hitDoublets[currentLayerPair]); + hitDoublets[currentLayerPair]; auto numberOfDoublets = doubletLayerPairId->size(); currentLayerPairRef.theFoundCells.reserve(numberOfDoublets); for (unsigned int i = 0; i < numberOfDoublets; ++i) @@ -154,7 +154,7 @@ void CellularAutomaton::findNtuplets( } -void CellularAutomaton::findTriplets(const std::vector& hitDoublets,std::vector& foundTriplets, const TrackingRegion& region, +void CellularAutomaton::findTriplets(const std::vector& hitDoublets,std::vector& foundTriplets, const TrackingRegion& region, const float thetaCut, const float phiCut, const float hardPtCut) { unsigned int cellId = 0; @@ -202,7 +202,7 @@ void CellularAutomaton::findTriplets(const std::vector& hitDoublets { const HitDoublets* doubletLayerPairId = - &(hitDoublets[currentLayerPair]); + hitDoublets[currentLayerPair]; auto numberOfDoublets = doubletLayerPairId->size(); currentLayerPairRef.theFoundCells.reserve(numberOfDoublets); for (unsigned int i = 0; i < numberOfDoublets; ++i) diff --git a/RecoPixelVertexing/PixelTriplets/plugins/CellularAutomaton.h b/RecoPixelVertexing/PixelTriplets/plugins/CellularAutomaton.h index dca4de1e197f0..ec144f00985a9 100644 --- a/RecoPixelVertexing/PixelTriplets/plugins/CellularAutomaton.h +++ b/RecoPixelVertexing/PixelTriplets/plugins/CellularAutomaton.h @@ -14,12 +14,12 @@ class CellularAutomaton } - void createAndConnectCells(const std::vector&, + void createAndConnectCells(const std::vector&, const TrackingRegion&, const float, const float, const float); void evolve(const unsigned int); void findNtuplets(std::vector&, const unsigned int); - void findTriplets(const std::vector& hitDoublets,std::vector& foundTriplets, const TrackingRegion& region, + void findTriplets(const std::vector& hitDoublets,std::vector& foundTriplets, const TrackingRegion& region, const float thetaCut, const float phiCut, const float hardPtCut); private: diff --git a/RecoPixelVertexing/PixelTriplets/plugins/PixelQuadrupletEDProducer.cc b/RecoPixelVertexing/PixelTriplets/plugins/PixelQuadrupletEDProducer.cc new file mode 100644 index 0000000000000..1e34c196c65a3 --- /dev/null +++ b/RecoPixelVertexing/PixelTriplets/plugins/PixelQuadrupletEDProducer.cc @@ -0,0 +1,129 @@ +#include "FWCore/Framework/interface/stream/EDProducer.h" +#include "FWCore/Framework/interface/ConsumesCollector.h" +#include "FWCore/ParameterSet/interface/ParameterSet.h" +#include "FWCore/ParameterSet/interface/ConfigurationDescriptions.h" +#include "FWCore/ParameterSet/interface/ParameterSetDescription.h" +#include "FWCore/Utilities/interface/EDGetToken.h" +#include "FWCore/Framework/interface/Event.h" +#include "DataFormats/Common/interface/Handle.h" +#include "FWCore/Utilities/interface/RunningAverage.h" + +#include "RecoTracker/TkHitPairs/interface/RegionsSeedingHitSets.h" +#include "RecoPixelVertexing/PixelTriplets/interface/OrderedHitSeeds.h" +#include "RecoPixelVertexing/PixelTriplets/interface/IntermediateHitTriplets.h" + +#include "PixelQuadrupletGenerator.h" +#include "LayerQuadruplets.h" + +class PixelQuadrupletEDProducer: public edm::stream::EDProducer<> { +public: + PixelQuadrupletEDProducer(const edm::ParameterSet& iConfig); + ~PixelQuadrupletEDProducer() = default; + + static void fillDescriptions(edm::ConfigurationDescriptions& descriptions); + + virtual void produce(edm::Event& iEvent, const edm::EventSetup& iSetup) override; + +private: + edm::EDGetTokenT tripletToken_; + + edm::RunningAverage localRA_; + + PixelQuadrupletGenerator generator_; +}; + +PixelQuadrupletEDProducer::PixelQuadrupletEDProducer(const edm::ParameterSet& iConfig): + tripletToken_(consumes(iConfig.getParameter("triplets"))), + generator_(iConfig, consumesCollector()) +{ + produces(); +} + +void PixelQuadrupletEDProducer::fillDescriptions(edm::ConfigurationDescriptions& descriptions) { + edm::ParameterSetDescription desc; + + desc.add("triplets", edm::InputTag("hitTripletEDProducer")); + PixelQuadrupletGenerator::fillDescriptions(desc); + + descriptions.add("pixelQuadrupletEDProducer", desc); +} + +void PixelQuadrupletEDProducer::produce(edm::Event& iEvent, const edm::EventSetup& iSetup) { + edm::Handle htriplets; + iEvent.getByToken(tripletToken_, htriplets); + const auto& regionTriplets = *htriplets; + + const SeedingLayerSetsHits& seedingLayerHits = regionTriplets.seedingLayerHits(); + if(seedingLayerHits.numberOfLayersInSet() < 4) { + throw cms::Exception("LogicError") << "PixelQuadrupletEDProducer expects SeedingLayerSetsHits::numberOfLayersInSet() to be >= 4, got " << seedingLayerHits.numberOfLayersInSet() << ". This is likely caused by a configuration error of this module, HitPairEDProducer, or SeedingLayersEDProducer."; + } + + auto seedingHitSets = std::make_unique(); + if(regionTriplets.empty()) { + iEvent.put(std::move(seedingHitSets)); + return; + } + seedingHitSets->reserve(regionTriplets.regionSize(), localRA_.upper()); + + // match-making of triplet and quadruplet layers + std::vector quadlayers = LayerQuadruplets::layers(seedingLayerHits); + + LogDebug("PixelQuadrupletEDProducer") << "Creating quadruplets for " << regionTriplets.regionSize() << " regions, and " << quadlayers.size() << " triplet+4th layers from " << regionTriplets.tripletsSize() << " triplets"; + + OrderedHitSeeds quadruplets; + quadruplets.reserve(localRA_.upper()); + + for(const auto& regionLayerTriplets: regionTriplets) { + const TrackingRegion& region = regionLayerTriplets.region(); + auto seedingHitSetsFiller = seedingHitSets->beginRegion(®ion); + + LayerHitMapCache hitCache; + hitCache.extend(regionLayerTriplets.layerHitMapCache()); + + LogTrace("PixelQuadrupletEDProducer") << " starting region, number of layer triplets " << regionLayerTriplets.layerTripletsSize(); + + for(const auto& layerTriplet: regionLayerTriplets) { + LogTrace("PixelQuadrupletEDProducer") << " starting layer triplet " << layerTriplet.innerLayerIndex() << "," << layerTriplet.middleLayerIndex() << "," << layerTriplet.outerLayerIndex(); + auto found = std::find_if(quadlayers.begin(), quadlayers.end(), [&](const LayerQuadruplets::LayerSetAndLayers& a) { + return a.first[0].index() == layerTriplet.innerLayerIndex() && + a.first[1].index() == layerTriplet.middleLayerIndex() && + a.first[2].index() == layerTriplet.outerLayerIndex(); + }); + if(found == quadlayers.end()) { + auto exp = cms::Exception("LogicError") << "Did not find the layer triplet from vector. This is a sign of some internal inconsistency\n"; + exp << "I was looking for layer triplet " << layerTriplet.innerLayerIndex() << "," << layerTriplet.middleLayerIndex() << "," << layerTriplet.outerLayerIndex() + << ". Quadruplets have the following triplets:\n"; + for(const auto& a: quadlayers) { + exp << " " << a.first[0].index() << "," << a.first[1].index() << "," << a.first[2].index() << ": 4th layers"; + for(const auto& b: a.second) { + exp << " " << b.index(); + } + exp << "\n"; + } + throw exp; + } + const auto& fourthLayers = found->second; + + generator_.hitQuadruplets(region, quadruplets, iEvent, iSetup, layerTriplet.begin(), layerTriplet.end(), fourthLayers, hitCache); + +#ifdef EDM_ML_DEBUG + LogTrace("PixelQuadrupletEDProducer") << " created " << quadruplets.size() << " quadruplets for layer triplet " << layerTriplet.innerLayerIndex() << "," << layerTriplet.middleLayerIndex() << "," << layerTriplet.outerLayerIndex() << " and 4th layers"; + for(const auto& l: fourthLayers) { + LogTrace("PixelQuadrupletEDProducer") << " " << l.index(); + } +#endif + + for(const auto& quad: quadruplets) { + seedingHitSetsFiller.emplace_back(quad[0], quad[1], quad[2], quad[3]); + } + quadruplets.clear(); + } + } + localRA_.update(seedingHitSets->size()); + + seedingHitSets->shrink_to_fit(); + iEvent.put(std::move(seedingHitSets)); +} + +#include "FWCore/Framework/interface/MakerMacros.h" +DEFINE_FWK_MODULE(PixelQuadrupletEDProducer); diff --git a/RecoPixelVertexing/PixelTriplets/plugins/PixelQuadrupletGenerator.cc b/RecoPixelVertexing/PixelTriplets/plugins/PixelQuadrupletGenerator.cc index 3b5cb49cd4603..bb27c9f82485d 100644 --- a/RecoPixelVertexing/PixelTriplets/plugins/PixelQuadrupletGenerator.cc +++ b/RecoPixelVertexing/PixelTriplets/plugins/PixelQuadrupletGenerator.cc @@ -2,6 +2,7 @@ #include "ThirdHitRZPrediction.h" #include "RecoPixelVertexing/PixelTriplets/interface/ThirdHitPredictionFromCircle.h" #include "RecoTracker/TkMSParametrization/interface/PixelRecoLineRZ.h" +#include "FWCore/ParameterSet/interface/ParameterSetDescription.h" #include "RecoPixelVertexing/PixelTriplets/plugins/KDTreeLinkerAlgo.h" #include "RecoPixelVertexing/PixelTriplets/plugins/KDTreeLinkerTools.h" @@ -50,20 +51,61 @@ PixelQuadrupletGenerator::PixelQuadrupletGenerator(const edm::ParameterSet& cfg, PixelQuadrupletGenerator::~PixelQuadrupletGenerator() {} +void PixelQuadrupletGenerator::fillDescriptions(edm::ParameterSetDescription& desc) { + desc.add("extraHitRZtolerance", 0.1); + desc.add("extraHitRPhitolerance", 0.1); + + edm::ParameterSetDescription descExtraPhi; + descExtraPhi.add("pt1", 0.1); + descExtraPhi.add("pt2", 0.1); + descExtraPhi.add("value1", 999); + descExtraPhi.add("value2", 0.15); + descExtraPhi.add("enabled", false); + desc.add("extraPhiTolerance", descExtraPhi); + + edm::ParameterSetDescription descMaxChi2; + descMaxChi2.add("pt1", 0.2); + descMaxChi2.add("pt2", 1.5); + descMaxChi2.add("value1", 500); + descMaxChi2.add("value2", 50); + descMaxChi2.add("enabled", true); + desc.add("maxChi2", descMaxChi2); + + desc.add("fitFastCircle", false); + desc.add("fitFastCircleChi2Cut", false); + desc.add("useBendingCorrection", false); + + edm::ParameterSetDescription descComparitor; + descComparitor.add("ComponentName", "none"); + descComparitor.setAllowAnything(); // until we have moved SeedComparitor too to EDProducers + desc.add("SeedComparitorPSet", descComparitor); +} + void PixelQuadrupletGenerator::hitQuadruplets(const TrackingRegion& region, OrderedHitSeeds& result, const edm::Event& ev, const edm::EventSetup& es, const SeedingLayerSetsHits::SeedingLayerSet& tripletLayers, const std::vector& fourthLayers) { - if (theComparitor) theComparitor->init(ev, es); - OrderedHitTriplets triplets; theTripletGenerator->hitTriplets(region, triplets, ev, es, tripletLayers, // pair generator picks the correct two layers from these std::vector{tripletLayers[2]}); if(triplets.empty()) return; + assert(theLayerCache); + hitQuadruplets(region, result, ev, es, triplets.begin(), triplets.end(), fourthLayers, *theLayerCache); +} + +void PixelQuadrupletGenerator::hitQuadruplets(const TrackingRegion& region, OrderedHitSeeds& result, + const edm::Event& ev, const edm::EventSetup& es, + OrderedHitTriplets::const_iterator tripletsBegin, + OrderedHitTriplets::const_iterator tripletsEnd, + const std::vector& fourthLayers, + LayerCacheType& layerCache) +{ + if (theComparitor) theComparitor->init(ev, es); + const size_t size = fourthLayers.size(); const RecHitsSortedInPhi *fourthHitMap[size]; @@ -80,7 +122,7 @@ void PixelQuadrupletGenerator::hitQuadruplets(const TrackingRegion& region, Orde // Build KDtrees for(size_t il=0; il!=size; ++il) { - fourthHitMap[il] = &(*theLayerCache)(fourthLayers[il], region, ev, es); + fourthHitMap[il] = &(layerCache)(fourthLayers[il], region, es); auto const& hits = *fourthHitMap[il]; ThirdHitRZPrediction & pred = preds[il]; @@ -122,7 +164,8 @@ void PixelQuadrupletGenerator::hitQuadruplets(const TrackingRegion& region, Orde std::array barrels; // Loop over triplets - for(const auto& triplet: triplets) { + for(auto iTriplet = tripletsBegin; iTriplet != tripletsEnd; ++iTriplet) { + const auto& triplet = *iTriplet; GlobalPoint gp0 = triplet.inner()->globalPosition(); GlobalPoint gp1 = triplet.middle()->globalPosition(); GlobalPoint gp2 = triplet.outer()->globalPosition(); diff --git a/RecoPixelVertexing/PixelTriplets/plugins/PixelQuadrupletGenerator.h b/RecoPixelVertexing/PixelTriplets/plugins/PixelQuadrupletGenerator.h index edf4caa4eef86..85d3141ffdee7 100644 --- a/RecoPixelVertexing/PixelTriplets/plugins/PixelQuadrupletGenerator.h +++ b/RecoPixelVertexing/PixelTriplets/plugins/PixelQuadrupletGenerator.h @@ -21,15 +21,25 @@ class PixelQuadrupletGenerator : public HitQuadrupletGeneratorFromTripletAndLaye typedef CombinedHitQuadrupletGenerator::LayerCacheType LayerCacheType; public: + PixelQuadrupletGenerator( const edm::ParameterSet& cfg, edm::ConsumesCollector&& iC): PixelQuadrupletGenerator(cfg, iC) {} PixelQuadrupletGenerator( const edm::ParameterSet& cfg, edm::ConsumesCollector& iC); virtual ~PixelQuadrupletGenerator(); + static void fillDescriptions(edm::ParameterSetDescription& desc); + virtual void hitQuadruplets( const TrackingRegion& region, OrderedHitSeeds& result, const edm::Event & ev, const edm::EventSetup& es, const SeedingLayerSetsHits::SeedingLayerSet& tripletLayers, const std::vector& fourthLayers) override; + void hitQuadruplets( const TrackingRegion& region, OrderedHitSeeds& result, + const edm::Event& ev, const edm::EventSetup& es, + OrderedHitTriplets::const_iterator tripletsBegin, + OrderedHitTriplets::const_iterator tripletsEnd, + const std::vector& fourthLayers, + LayerCacheType& layerCache); + private: std::unique_ptr theComparitor; @@ -39,6 +49,8 @@ typedef CombinedHitQuadrupletGenerator::LayerCacheType LayerCacheType; value1_(v1), value2_(v2), curvature1_(c1), curvature2_(c2) {} + static void fillDescriptions(edm::ParameterSetDescription& desc); + float value(float curvature) const { if(value1_ == value2_) // not enabled return value1_; diff --git a/RecoPixelVertexing/PixelTriplets/plugins/PixelQuadrupletMergerEDProducer.cc b/RecoPixelVertexing/PixelTriplets/plugins/PixelQuadrupletMergerEDProducer.cc new file mode 100644 index 0000000000000..ded62ac0c7ca9 --- /dev/null +++ b/RecoPixelVertexing/PixelTriplets/plugins/PixelQuadrupletMergerEDProducer.cc @@ -0,0 +1,166 @@ +#include "FWCore/Framework/interface/stream/EDProducer.h" +#include "FWCore/Framework/interface/ConsumesCollector.h" +#include "FWCore/ParameterSet/interface/ParameterSet.h" +#include "FWCore/ParameterSet/interface/ConfigurationDescriptions.h" +#include "FWCore/ParameterSet/interface/ParameterSetDescription.h" +#include "FWCore/Utilities/interface/EDGetToken.h" +#include "FWCore/Framework/interface/Event.h" +#include "DataFormats/Common/interface/Handle.h" +#include "FWCore/Utilities/interface/RunningAverage.h" + +#include "RecoTracker/TkHitPairs/interface/RegionsSeedingHitSets.h" +#include "RecoPixelVertexing/PixelTriplets/interface/OrderedHitSeeds.h" +#include "RecoPixelVertexing/PixelTriplets/interface/QuadrupletSeedMerger.h" + +// following are needed only to keep the same results +#include "RecoTracker/TkSeedingLayers/interface/SeedComparitorFactory.h" +#include "RecoTracker/TkSeedingLayers/interface/SeedComparitor.h" +#include "RecoTracker/TkSeedGenerator/interface/SeedCreatorFactory.h" +#include "RecoTracker/TkSeedGenerator/interface/SeedCreator.h" + +class PixelQuadrupletMergerEDProducer: public edm::stream::EDProducer<> { +public: + PixelQuadrupletMergerEDProducer(const edm::ParameterSet& iConfig); + ~PixelQuadrupletMergerEDProducer() = default; + + static void fillDescriptions(edm::ConfigurationDescriptions& descriptions); + + virtual void produce(edm::Event& iEvent, const edm::EventSetup& iSetup) override; + +private: + edm::EDGetTokenT tripletToken_; + + edm::RunningAverage localRA_; + + QuadrupletSeedMerger merger_; + + // to keep old results + std::unique_ptr comparitor_; + std::unique_ptr seedCreator_; +}; + +PixelQuadrupletMergerEDProducer::PixelQuadrupletMergerEDProducer(const edm::ParameterSet& iConfig): + tripletToken_(consumes(iConfig.getParameter("triplets"))), + merger_(iConfig.getParameter("layerList"), consumesCollector()) +{ + merger_.setTTRHBuilderLabel(iConfig.getParameter("ttrhBuilderLabel")); + merger_.setMergeTriplets(iConfig.getParameter("mergeTriplets")); + merger_.setAddRemainingTriplets(iConfig.getParameter("addRemainingTriplets")); + + edm::ParameterSet comparitorPSet = iConfig.getParameter("SeedComparitorPSet"); + std::string comparitorName = comparitorPSet.getParameter("ComponentName"); + if(comparitorName != "none") { + auto iC = consumesCollector(); + comparitor_.reset(SeedComparitorFactory::get()->create(comparitorName, comparitorPSet, iC)); + } + + edm::ParameterSet creatorPSet = iConfig.getParameter("SeedCreatorPSet"); + std::string creatorName = creatorPSet.getParameter("ComponentName"); + seedCreator_.reset(SeedCreatorFactory::get()->create( creatorName, creatorPSet)); + + produces(); + produces(); // need to keep these in memory because TrajectorySeed owns its RecHits +} + +void PixelQuadrupletMergerEDProducer::fillDescriptions(edm::ConfigurationDescriptions& descriptions) { + edm::ParameterSetDescription desc; + + desc.add("triplets", edm::InputTag("hitTripletMergerEDProducer")); + desc.add("ttrhBuilderLabel", "PixelTTRHBuilderWithoutAngle"); + desc.add("mergeTriplets", true); + desc.add("addRemainingTriplets", false); + // This would be really on the responsibility of + // QuadrupletSeedMerger and SeedingLayerSetsBuilder. The former is + // almost obsolete by now (so I don't want to put effort there), and + // the latter is better dealt in the context of SeedingLayersEDProducer. + edm::ParameterSetDescription descLayers; + descLayers.setAllowAnything(); + desc.add("layerList", descLayers); + + // to keep old results + edm::ParameterSetDescription descComparitor; + descComparitor.add("ComponentName", "none"); + descComparitor.setAllowAnything(); + desc.add("SeedComparitorPSet", descComparitor); + edm::ParameterSetDescription descCreator; + descCreator.setAllowAnything(); + desc.add("SeedCreatorPSet", descCreator); + + descriptions.add("pixelQuadrupletMergerEDProducer", desc); +} + +void PixelQuadrupletMergerEDProducer::produce(edm::Event& iEvent, const edm::EventSetup& iSetup) { + edm::Handle htriplets; + iEvent.getByToken(tripletToken_, htriplets); + const auto& regionTriplets = *htriplets; + + auto seedingHitSets = std::make_unique(); + if(regionTriplets.empty()) { + iEvent.put(std::move(seedingHitSets)); + return; + } + seedingHitSets->reserve(regionTriplets.regionSize(), localRA_.upper()); + + // to keep old results + auto tmpSeedCollection = std::make_unique(); + + OrderedHitSeeds quadruplets; + quadruplets.reserve(localRA_.upper()); + + OrderedHitSeeds tripletsPerRegion; + tripletsPerRegion.reserve(localRA_.upper()); + + LogDebug("PixelQuadrupletMergerEDProducer") << "Creating quadruplets for " << regionTriplets.regionSize() << " regions from " << regionTriplets.size() << " triplets"; + merger_.update(iSetup); + + // to keep old results + if(comparitor_) comparitor_->init(iEvent, iSetup); + + for(const auto& regionSeedingHitSets: regionTriplets) { + const TrackingRegion& region = regionSeedingHitSets.region(); + auto seedingHitSetsFiller = seedingHitSets->beginRegion(®ion); + + + // Keeping same resuls has been made really difficult... + // Following is from SeedGeneratorFromRegionHits + seedCreator_->init(region, iSetup, comparitor_.get()); + for(const auto& hits: regionSeedingHitSets) { + if(!comparitor_ || comparitor_->compatible(hits)) { + seedCreator_->makeSeed(*tmpSeedCollection, hits); + } + + } + + // then convert seeds back to hits + // awful, but hopefully only temporary to preserve old results + for(const auto& seed: *tmpSeedCollection) { + auto hitRange = seed.recHits(); + assert(std::distance(hitRange.first, hitRange.second) == 3); + tripletsPerRegion.emplace_back(static_cast(&*(hitRange.first)), + static_cast(&*(hitRange.first+1)), + static_cast(&*(hitRange.first+2))); + } + + LogTrace("PixelQuadrupletEDProducer") << " starting region, number of triplets " << tripletsPerRegion.size(); + + const auto& quadruplets = merger_.mergeTriplets(tripletsPerRegion, iSetup); + + LogTrace("PixelQuadrupletEDProducer") << " created " << quadruplets.size() << " quadruplets"; + + for(size_t i=0; i!= quadruplets.size(); ++i) { + const auto& quad = quadruplets[i]; + seedingHitSetsFiller.emplace_back(quad[0], quad[1], quad[2], quad[3]); + } + + tripletsPerRegion.clear(); + } + localRA_.update(seedingHitSets->size()); + + seedingHitSets->shrink_to_fit(); + tmpSeedCollection->shrink_to_fit(); + iEvent.put(std::move(seedingHitSets)); + iEvent.put(std::move(tmpSeedCollection)); +} + +#include "FWCore/Framework/interface/MakerMacros.h" +DEFINE_FWK_MODULE(PixelQuadrupletMergerEDProducer); diff --git a/RecoPixelVertexing/PixelTriplets/plugins/PixelTripletHLTGenerator.cc b/RecoPixelVertexing/PixelTriplets/plugins/PixelTripletHLTGenerator.cc index 6c022e82465ad..dd47c848322d4 100644 --- a/RecoPixelVertexing/PixelTriplets/plugins/PixelTripletHLTGenerator.cc +++ b/RecoPixelVertexing/PixelTriplets/plugins/PixelTripletHLTGenerator.cc @@ -1,5 +1,6 @@ #include "RecoPixelVertexing/PixelTriplets/plugins/PixelTripletHLTGenerator.h" #include "RecoTracker/TkHitPairs/interface/HitPairGeneratorFromLayerPair.h" +#include "FWCore/ParameterSet/interface/ParameterSetDescription.h" #include "ThirdHitPredictionFromInvParabola.h" #include "ThirdHitRZPrediction.h" @@ -53,6 +54,21 @@ PixelTripletHLTGenerator:: PixelTripletHLTGenerator(const edm::ParameterSet& cfg PixelTripletHLTGenerator::~PixelTripletHLTGenerator() {} +void PixelTripletHLTGenerator::fillDescriptions(edm::ParameterSetDescription& desc) { + HitTripletGeneratorFromPairAndLayers::fillDescriptions(desc); + desc.add("extraHitRPhitolerance", 0.032); + desc.add("extraHitRZtolerance", 0.037); + desc.add("useMultScattering", true); + desc.add("useBending", true); + desc.add("useFixedPreFiltering", false); + desc.add("phiPreFiltering", 0.3); + + edm::ParameterSetDescription descComparitor; + descComparitor.add("ComponentName", "none"); + descComparitor.setAllowAnything(); // until we have moved SeedComparitor too to EDProducers + desc.add("SeedComparitorPSet", descComparitor); +} + void PixelTripletHLTGenerator::hitTriplets(const TrackingRegion& region, OrderedHitTriplets & result, const edm::Event & ev, @@ -60,21 +76,30 @@ void PixelTripletHLTGenerator::hitTriplets(const TrackingRegion& region, const SeedingLayerSetsHits::SeedingLayerSet& pairLayers, const std::vector& thirdLayers) { - if (theComparitor) theComparitor->init(ev, es); - auto const & doublets = thePairGenerator->doublets(region,ev,es, pairLayers); - if (doublets.empty()) return; + assert(theLayerCache); + hitTriplets(region, result, ev, es, doublets, thirdLayers, nullptr, *theLayerCache); +} + +void PixelTripletHLTGenerator::hitTriplets(const TrackingRegion& region, OrderedHitTriplets& result, + const edm::Event& ev, const edm::EventSetup& es, + const HitDoublets& doublets, + const std::vector& thirdLayers, + std::vector *tripletLastLayerIndex, + LayerCacheType& layerCache) { + if (theComparitor) theComparitor->init(ev, es); + int size = thirdLayers.size(); const RecHitsSortedInPhi * thirdHitMap[size]; vector thirdLayerDetLayer(size,0); for (int il=0; il & thirdLayerDetLayer, const int nThirdLayers) { - auto outSeq = doublets.detLayer(HitDoublets::outer)->seqNum(); + hitTriplets(region, result, es, doublets, thirdHitMap, thirdLayerDetLayer, nThirdLayers, nullptr); +} - float regOffset = region.origin().perp(); //try to take account of non-centrality (?) - - declareDynArray(ThirdHitRZPrediction, nThirdLayers, preds); - declareDynArray(ThirdHitCorrection, nThirdLayers, corrections); - - typedef RecHitsSortedInPhi::Hit Hit; +void PixelTripletHLTGenerator::hitTriplets(const TrackingRegion& region, OrderedHitTriplets & result, + const edm::EventSetup & es, + const HitDoublets & doublets, + const RecHitsSortedInPhi ** thirdHitMap, + const std::vector & thirdLayerDetLayer, + const int nThirdLayers, + std::vector *tripletLastLayerIndex) { + auto outSeq = doublets.detLayer(HitDoublets::outer)->seqNum(); + + float regOffset = region.origin().perp(); //try to take account of non-centrality (?) + + declareDynArray(ThirdHitRZPrediction, nThirdLayers, preds); + declareDynArray(ThirdHitCorrection, nThirdLayers, corrections); + + typedef RecHitsSortedInPhi::Hit Hit; using NodeInfo = KDTreeNodeInfo; std::vector layerTree; // re-used throughout @@ -311,6 +346,8 @@ void PixelTripletHLTGenerator::hitTriplets( OrderedHitTriplet hittriplet( doublets.hit(ip,HitDoublets::inner), doublets.hit(ip,HitDoublets::outer), hits.theHits[KDdata].hit()); if (!theComparitor || theComparitor->compatible(hittriplet) ) { result.push_back( hittriplet ); + // to bookkeep the triplets and 3rd layers in triplet EDProducer + if(tripletLastLayerIndex) tripletLastLayerIndex->push_back(il); } else { LogDebug("RejectedTriplet") << "rejected triplet from comparitor "; } diff --git a/RecoPixelVertexing/PixelTriplets/plugins/PixelTripletHLTGenerator.h b/RecoPixelVertexing/PixelTriplets/plugins/PixelTripletHLTGenerator.h index 8d64078f4a9a0..ae791997d8d0f 100644 --- a/RecoPixelVertexing/PixelTriplets/plugins/PixelTripletHLTGenerator.h +++ b/RecoPixelVertexing/PixelTriplets/plugins/PixelTripletHLTGenerator.h @@ -22,15 +22,26 @@ class PixelTripletHLTGenerator : public HitTripletGeneratorFromPairAndLayers { typedef CombinedHitTripletGenerator::LayerCacheType LayerCacheType; public: + PixelTripletHLTGenerator( const edm::ParameterSet& cfg, edm::ConsumesCollector&& iC): PixelTripletHLTGenerator(cfg, iC) {} PixelTripletHLTGenerator( const edm::ParameterSet& cfg, edm::ConsumesCollector& iC); virtual ~PixelTripletHLTGenerator(); + static void fillDescriptions(edm::ParameterSetDescription& desc); + static const char *fillDescriptionsLabel() { return "pixelTripletHLT"; } + virtual void hitTriplets( const TrackingRegion& region, OrderedHitTriplets & trs, const edm::Event & ev, const edm::EventSetup& es, const SeedingLayerSetsHits::SeedingLayerSet& pairLayers, const std::vector& thirdLayers) override; + void hitTriplets(const TrackingRegion& region, OrderedHitTriplets& trs, + const edm::Event& ev, const edm::EventSetup& es, + const HitDoublets& doublets, + const std::vector& thirdLayers, + std::vector *tripletLastLayerIndex, + LayerCacheType& layerCache); + void hitTriplets( const TrackingRegion& region, OrderedHitTriplets & result, @@ -40,6 +51,14 @@ typedef CombinedHitTripletGenerator::LayerCacheType LayerCacheType; const std::vector & thirdLayerDetLayer, const int nThirdLayers)override; + void hitTriplets(const TrackingRegion& region, OrderedHitTriplets & result, + const edm::EventSetup & es, + const HitDoublets & doublets, + const RecHitsSortedInPhi ** thirdHitMap, + const std::vector & thirdLayerDetLayer, + const int nThirdLayers, + std::vector *tripletLastLayerIndex); + private: const bool useFixedPreFiltering; const float extraHitRZtolerance; diff --git a/RecoPixelVertexing/PixelTriplets/plugins/PixelTripletLargeTipGenerator.cc b/RecoPixelVertexing/PixelTriplets/plugins/PixelTripletLargeTipGenerator.cc index 7e17d71d77848..de8d206c3be95 100644 --- a/RecoPixelVertexing/PixelTriplets/plugins/PixelTripletLargeTipGenerator.cc +++ b/RecoPixelVertexing/PixelTriplets/plugins/PixelTripletLargeTipGenerator.cc @@ -1,5 +1,6 @@ #include "RecoPixelVertexing/PixelTriplets/plugins/PixelTripletLargeTipGenerator.h" #include "RecoTracker/TkHitPairs/interface/HitPairGeneratorFromLayerPair.h" +#include "FWCore/ParameterSet/interface/ParameterSetDescription.h" #include "RecoPixelVertexing/PixelTriplets/interface/ThirdHitPredictionFromCircle.h" #include "ThirdHitRZPrediction.h" @@ -56,6 +57,18 @@ PixelTripletLargeTipGenerator::PixelTripletLargeTipGenerator(const edm::Paramete PixelTripletLargeTipGenerator::~PixelTripletLargeTipGenerator() {} +void PixelTripletLargeTipGenerator::fillDescriptions(edm::ParameterSetDescription& desc) { + HitTripletGeneratorFromPairAndLayers::fillDescriptions(desc); + // Defaults for the extraHit*tolerance are set to 0 here since that + // was already the case in practice in all offline occurrances. + desc.add("extraHitRPhitolerance", 0); // default in old python was 0.032 + desc.add("extraHitRZtolerance", 0); // default in old python was 0.037 + desc.add("useMultScattering", true); + desc.add("useBending", true); + desc.add("useFixedPreFiltering", false); + desc.add("phiPreFiltering", 0.3); +} + namespace { inline bool intersect(Range &range, const Range &second) @@ -81,16 +94,28 @@ void PixelTripletLargeTipGenerator::hitTriplets(const TrackingRegion& region, if (doublets.empty()) return; + assert(theLayerCache); + hitTriplets(region, result, ev, es, doublets,thirdLayers, nullptr, *theLayerCache); +} + +void PixelTripletLargeTipGenerator::hitTriplets(const TrackingRegion& region, OrderedHitTriplets& result, + const edm::Event& ev, const edm::EventSetup& es, + const HitDoublets& doublets, + const std::vector& thirdLayers, + std::vector *tripletLastLayerIndex, + LayerCacheType& layerCache) { int size = thirdLayers.size(); const RecHitsSortedInPhi * thirdHitMap[size]; vector thirdLayerDetLayer(size,0); for (int il=0; il & thirdLayerDetLayer, const int nThirdLayers) -{ +{ + hitTriplets(region, result, es, doublets, thirdHitMap, thirdLayerDetLayer, nThirdLayers, nullptr); +} + +void PixelTripletLargeTipGenerator::hitTriplets(const TrackingRegion& region, OrderedHitTriplets & result, + const edm::EventSetup & es, + const HitDoublets & doublets, + const RecHitsSortedInPhi ** thirdHitMap, + const std::vector & thirdLayerDetLayer, + const int nThirdLayers, + std::vector *tripletLastLayerIndex) { edm::ESHandle tracker; es.get().get(tracker); @@ -380,6 +415,8 @@ void PixelTripletLargeTipGenerator::hitTriplets( return; } result.emplace_back( doublets.hit(ip,HitDoublets::inner), doublets.hit(ip,HitDoublets::outer), hits.theHits[KDdata].hit()); + // to bookkeep the triplets and 3rd layers in triplet EDProducer + if(tripletLastLayerIndex) tripletLastLayerIndex->push_back(il); } } } diff --git a/RecoPixelVertexing/PixelTriplets/plugins/PixelTripletLargeTipGenerator.h b/RecoPixelVertexing/PixelTriplets/plugins/PixelTripletLargeTipGenerator.h index 98a80d28b2440..49366049f4e5a 100644 --- a/RecoPixelVertexing/PixelTriplets/plugins/PixelTripletLargeTipGenerator.h +++ b/RecoPixelVertexing/PixelTriplets/plugins/PixelTripletLargeTipGenerator.h @@ -21,15 +21,26 @@ class PixelTripletLargeTipGenerator : public HitTripletGeneratorFromPairAndLayer typedef CombinedHitTripletGenerator::LayerCacheType LayerCacheType; public: + PixelTripletLargeTipGenerator( const edm::ParameterSet& cfg, edm::ConsumesCollector&& iC): PixelTripletLargeTipGenerator(cfg, iC) {} PixelTripletLargeTipGenerator( const edm::ParameterSet& cfg, edm::ConsumesCollector& iC); virtual ~PixelTripletLargeTipGenerator(); + static void fillDescriptions(edm::ParameterSetDescription& desc); + static const char *fillDescriptionsLabel() { return "pixelTripletLargeTip"; } + virtual void hitTriplets( const TrackingRegion& region, OrderedHitTriplets & trs, const edm::Event & ev, const edm::EventSetup& es, const SeedingLayerSetsHits::SeedingLayerSet& pairLayers, const std::vector& thirdLayers) override; + void hitTriplets(const TrackingRegion& region, OrderedHitTriplets& trs, + const edm::Event& ev, const edm::EventSetup& es, + const HitDoublets& doublets, + const std::vector& thirdLayers, + std::vector *tripletLastLayerIndex, + LayerCacheType& layerCache); + void hitTriplets( const TrackingRegion& region, OrderedHitTriplets & result, @@ -39,6 +50,14 @@ typedef CombinedHitTripletGenerator::LayerCacheType LayerCacheType; const std::vector & thirdLayerDetLayer, const int nThirdLayers)override; + void hitTriplets(const TrackingRegion& region, OrderedHitTriplets & result, + const edm::EventSetup & es, + const HitDoublets & doublets, + const RecHitsSortedInPhi ** thirdHitMap, + const std::vector & thirdLayerDetLayer, + const int nThirdLayers, + std::vector *tripletLastLayerIndex); + private: const bool useFixedPreFiltering; const float extraHitRZtolerance; diff --git a/RecoPixelVertexing/PixelTriplets/plugins/PixelTripletNoTipGenerator.cc b/RecoPixelVertexing/PixelTriplets/plugins/PixelTripletNoTipGenerator.cc index 80776d19be3f5..57c163f49208c 100644 --- a/RecoPixelVertexing/PixelTriplets/plugins/PixelTripletNoTipGenerator.cc +++ b/RecoPixelVertexing/PixelTriplets/plugins/PixelTripletNoTipGenerator.cc @@ -63,7 +63,7 @@ void PixelTripletNoTipGenerator::hitTriplets( const RecHitsSortedInPhi **thirdHitMap = new const RecHitsSortedInPhi*[size]; for (int il=0; il <=size-1; il++) { - thirdHitMap[il] = &(*theLayerCache)(thirdLayers[il], region, ev, es); + thirdHitMap[il] = &(*theLayerCache)(thirdLayers[il], region, es); } const DetLayer * firstLayer = thePairGenerator->innerLayer(pairLayers).detLayer(); diff --git a/RecoPixelVertexing/PixelTriplets/plugins/SealModule.cc b/RecoPixelVertexing/PixelTriplets/plugins/SealModule.cc index 0554740965413..3effdec36bff4 100644 --- a/RecoPixelVertexing/PixelTriplets/plugins/SealModule.cc +++ b/RecoPixelVertexing/PixelTriplets/plugins/SealModule.cc @@ -31,3 +31,10 @@ DEFINE_EDM_PLUGIN(HitQuadrupletGeneratorFromTripletAndLayersFactory, PixelQuadru #include "CAHitQuadrupletGenerator.h" DEFINE_EDM_PLUGIN(OrderedHitsGeneratorFactory, CAHitQuadrupletGenerator, "CAHitQuadrupletGenerator"); + +#include "RecoPixelVertexing/PixelTriplets/interface/HitTripletEDProducerT.h" +using PixelTripletHLTEDProducer = HitTripletEDProducerT; +DEFINE_FWK_MODULE(PixelTripletHLTEDProducer); + +using PixelTripletLargeTipEDProducer = HitTripletEDProducerT; +DEFINE_FWK_MODULE(PixelTripletLargeTipEDProducer); diff --git a/RecoPixelVertexing/PixelTriplets/python/CAHitQuadrupletGenerator_cfi.py b/RecoPixelVertexing/PixelTriplets/python/CAHitQuadrupletGenerator_cfi.py index c25177f3c8de8..ef48a99f2181f 100644 --- a/RecoPixelVertexing/PixelTriplets/python/CAHitQuadrupletGenerator_cfi.py +++ b/RecoPixelVertexing/PixelTriplets/python/CAHitQuadrupletGenerator_cfi.py @@ -2,6 +2,7 @@ CAHitQuadrupletGenerator = cms.PSet( ComponentName = cms.string("CAHitQuadrupletGenerator"), + SeedingLayers = cms.InputTag("seedingLayersEDProducer"), extraHitRPhitolerance = cms.double(0.1), maxChi2 = cms.PSet( pt1 = cms.double(0.2), pt2 = cms.double(1.5), diff --git a/RecoPixelVertexing/PixelTriplets/python/CAHitTripletGenerator_cfi.py b/RecoPixelVertexing/PixelTriplets/python/CAHitTripletGenerator_cfi.py index d1ac85388022b..907fd7bde55cf 100755 --- a/RecoPixelVertexing/PixelTriplets/python/CAHitTripletGenerator_cfi.py +++ b/RecoPixelVertexing/PixelTriplets/python/CAHitTripletGenerator_cfi.py @@ -2,6 +2,7 @@ CAHitTripletGenerator = cms.PSet( ComponentName = cms.string("CAHitTripletGenerator"), + SeedingLayers = cms.InputTag("seedingLayersEDProducer"), extraHitRPhitolerance = cms.double(0.06), maxChi2 = cms.PSet( pt1 = cms.double(0.8), pt2 = cms.double(2), diff --git a/RecoPixelVertexing/PixelTriplets/python/pixelTripletHLTEDProducer_cfi.py b/RecoPixelVertexing/PixelTriplets/python/pixelTripletHLTEDProducer_cfi.py new file mode 100644 index 0000000000000..91eebb01b9ab5 --- /dev/null +++ b/RecoPixelVertexing/PixelTriplets/python/pixelTripletHLTEDProducer_cfi.py @@ -0,0 +1,9 @@ +from RecoPixelVertexing.PixelTriplets.pixelTripletHLTEDProducerDefault_cfi import pixelTripletHLTEDProducerDefault as _pixelTripletHLTEDProducerDefault + +pixelTripletHLTEDProducer = _pixelTripletHLTEDProducerDefault.clone() +from Configuration.Eras.Modifier_trackingLowPU_cff import trackingLowPU +from Configuration.Eras.Modifier_trackingPhase1PU70_cff import trackingPhase1PU70 +from Configuration.Eras.Modifier_trackingPhase2PU140_cff import trackingPhase2PU140 +trackingLowPU.toModify(pixelTripletHLTEDProducer, maxElement=100000) +trackingPhase1PU70.toModify(pixelTripletHLTEDProducer, maxElement=0) +trackingPhase2PU140.toModify(pixelTripletHLTEDProducer, maxElement=0) diff --git a/RecoPixelVertexing/PixelTriplets/python/pixelTripletLargeTipEDProducer_cfi.py b/RecoPixelVertexing/PixelTriplets/python/pixelTripletLargeTipEDProducer_cfi.py new file mode 100644 index 0000000000000..5b9aa1819d9ff --- /dev/null +++ b/RecoPixelVertexing/PixelTriplets/python/pixelTripletLargeTipEDProducer_cfi.py @@ -0,0 +1,12 @@ +from RecoPixelVertexing.PixelTriplets.pixelTripletLargeTipEDProducerDefault_cfi import pixelTripletLargeTipEDProducerDefault as _pixelTripletLargeTipEDProducerDefault + +pixelTripletLargeTipEDProducer = _pixelTripletLargeTipEDProducerDefault.clone() +from Configuration.Eras.Modifier_trackingLowPU_cff import trackingLowPU +from Configuration.Eras.Modifier_trackingPhase1PU70_cff import trackingPhase1PU70 +from Configuration.Eras.Modifier_trackingPhase2PU140_cff import trackingPhase2PU140 +trackingLowPU.toModify(pixelTripletLargeTipEDProducer, maxElement=100000) +trackingPhase1PU70.toModify(pixelTripletLargeTipEDProducer, maxElement=0) +trackingPhase2PU140.toModify(pixelTripletLargeTipEDProducer, maxElement=0) + +from Configuration.Eras.Modifier_peripheralPbPb_cff import peripheralPbPb +peripheralPbPb.toModify(pixelTripletLargeTipEDProducer, maxElement=1000000) diff --git a/RecoPixelVertexing/PixelTriplets/src/HitTripletGeneratorFromPairAndLayers.cc b/RecoPixelVertexing/PixelTriplets/src/HitTripletGeneratorFromPairAndLayers.cc index 12020295c7fed..364c3409e0340 100644 --- a/RecoPixelVertexing/PixelTriplets/src/HitTripletGeneratorFromPairAndLayers.cc +++ b/RecoPixelVertexing/PixelTriplets/src/HitTripletGeneratorFromPairAndLayers.cc @@ -1,6 +1,7 @@ #include "RecoPixelVertexing/PixelTriplets/interface/HitTripletGeneratorFromPairAndLayers.h" #include "RecoTracker/TkHitPairs/interface/HitPairGeneratorFromLayerPair.h" #include "FWCore/ParameterSet/interface/ParameterSet.h" +#include "FWCore/ParameterSet/interface/ParameterSetDescription.h" HitTripletGeneratorFromPairAndLayers::HitTripletGeneratorFromPairAndLayers(unsigned int maxElement): theLayerCache(nullptr), @@ -13,6 +14,10 @@ HitTripletGeneratorFromPairAndLayers::HitTripletGeneratorFromPairAndLayers(const HitTripletGeneratorFromPairAndLayers::~HitTripletGeneratorFromPairAndLayers() {} +void HitTripletGeneratorFromPairAndLayers::fillDescriptions(edm::ParameterSetDescription& desc) { + desc.add("maxElement", 1000000); +} + void HitTripletGeneratorFromPairAndLayers::init(std::unique_ptr&& pairGenerator, LayerCacheType *layerCache) { thePairGenerator = std::move(pairGenerator); theLayerCache = layerCache; diff --git a/RecoPixelVertexing/PixelTriplets/src/IntermediateHitTriplets.cc b/RecoPixelVertexing/PixelTriplets/src/IntermediateHitTriplets.cc new file mode 100644 index 0000000000000..e25291bc19b6b --- /dev/null +++ b/RecoPixelVertexing/PixelTriplets/src/IntermediateHitTriplets.cc @@ -0,0 +1,7 @@ +#include "RecoPixelVertexing/PixelTriplets/interface/IntermediateHitTriplets.h" +#include "FWCore/Utilities/interface/Exception.h" + +IntermediateHitTriplets::IntermediateHitTriplets(const IntermediateHitTriplets& rh) { + throw cms::Exception("Not Implemented") << "The copy constructor of IntermediateHitTriplets should never be called. The function exists only to make ROOT dictionary generation happy."; +} + diff --git a/RecoPixelVertexing/PixelTriplets/src/LayerTriplets.cc b/RecoPixelVertexing/PixelTriplets/src/LayerTriplets.cc index b283444ae4e27..5af57a8a5ba33 100644 --- a/RecoPixelVertexing/PixelTriplets/src/LayerTriplets.cc +++ b/RecoPixelVertexing/PixelTriplets/src/LayerTriplets.cc @@ -3,7 +3,7 @@ namespace LayerTriplets { std::vector layers(const SeedingLayerSetsHits& sets) { std::vector result; - if(sets.numberOfLayersInSet() != 3) + if(sets.numberOfLayersInSet() < 3) return result; for(LayerSet set: sets) { @@ -13,7 +13,10 @@ std::vector layers(const SeedingLayerSetsHits& sets) { const LayerSet & resSet = ir->first; if (resSet[0].index() == set[0].index() && resSet[1].index() == set[1].index()) { std::vector& thirds = ir->second; - thirds.push_back( set[2] ); + // 3rd layer can already be there if we are dealing with quadruplet layer sets + auto found = std::find_if(thirds.begin(), thirds.end(), [&](const Layer& l) { return l.index() == set[2].index(); }); + if(found == thirds.end()) + thirds.push_back( set[2] ); added = true; break; } diff --git a/RecoPixelVertexing/PixelTriplets/src/classes.h b/RecoPixelVertexing/PixelTriplets/src/classes.h new file mode 100644 index 0000000000000..465decf805c73 --- /dev/null +++ b/RecoPixelVertexing/PixelTriplets/src/classes.h @@ -0,0 +1,11 @@ +#include "RecoPixelVertexing/PixelTriplets/interface/IntermediateHitTriplets.h" +#include "DataFormats/Common/interface/Wrapper.h" + +#include + +namespace RecoPixelVertexing_PixelTriplets { + struct dictionary { + IntermediateHitTriplets iht; + edm::Wrapper wiht; + }; +} diff --git a/RecoPixelVertexing/PixelTriplets/src/classes_def.xml b/RecoPixelVertexing/PixelTriplets/src/classes_def.xml new file mode 100644 index 0000000000000..ea89a65a45dbb --- /dev/null +++ b/RecoPixelVertexing/PixelTriplets/src/classes_def.xml @@ -0,0 +1,4 @@ + + + + diff --git a/RecoTauTag/HLTProducers/src/SealModule.cc b/RecoTauTag/HLTProducers/src/SealModule.cc index 8efc7166eec9b..22830514ade9e 100644 --- a/RecoTauTag/HLTProducers/src/SealModule.cc +++ b/RecoTauTag/HLTProducers/src/SealModule.cc @@ -24,6 +24,10 @@ DEFINE_EDM_PLUGIN(TrackingRegionProducerFactory, TauRegionalPixelSeedGenerator, DEFINE_EDM_PLUGIN(TrackingRegionProducerFactory, TrackingRegionsFromBeamSpotAndL2Tau, "TrackingRegionsFromBeamSpotAndL2Tau"); DEFINE_EDM_PLUGIN(TrackingRegionProducerFactory, CandidateSeededTrackingRegionsProducer, "CandidateSeededTrackingRegionsProducer"); +#include "RecoTracker/TkTrackingRegions/interface/TrackingRegionEDProducerT.h" +using TauRegionalPixelSeedTrackingRegionEDProducer = TrackingRegionEDProducerT; +DEFINE_FWK_MODULE(TauRegionalPixelSeedTrackingRegionEDProducer); + DEFINE_FWK_MODULE(L2TauJetsMerger); DEFINE_FWK_MODULE(L1HLTJetsMatching); DEFINE_FWK_MODULE(L1HLTTauMatching); diff --git a/RecoTauTag/HLTProducers/src/TauRegionalPixelSeedGenerator.h b/RecoTauTag/HLTProducers/src/TauRegionalPixelSeedGenerator.h index 4e72adb79a1af..b5953b439c09c 100644 --- a/RecoTauTag/HLTProducers/src/TauRegionalPixelSeedGenerator.h +++ b/RecoTauTag/HLTProducers/src/TauRegionalPixelSeedGenerator.h @@ -54,12 +54,46 @@ class TauRegionalPixelSeedGenerator : public TrackingRegionProducer { } m_howToUseMeasurementTracker = RectangularEtaPhiTrackingRegion::stringToUseMeasurementTracker(regionPSet.getParameter("howToUseMeasurementTracker")); if(m_howToUseMeasurementTracker != RectangularEtaPhiTrackingRegion::UseMeasurementTracker::kNever) { - token_measurementTracker = iC.consumes(regionPSet.getParameter("measurementTrackerName")); + // temporary until everything migrated to InputTag + edm::InputTag tag; + if(regionPSet.existsAs("measurementTrackerName")) { + tag = regionPSet.getParameter("measurementTrackerName"); + } + else { + tag = edm::InputTag(regionPSet.getParameter("measurementTrackerName")); + } + + token_measurementTracker = iC.consumes(tag); } } virtual ~TauRegionalPixelSeedGenerator() {} + static void fillDescriptions(edm::ConfigurationDescriptions& descriptions) { + edm::ParameterSetDescription desc; + + desc.add("ptMin", 5.0); + desc.add("originHalfLength", 0.2); + desc.add("originRadius", 0.2); + desc.add("deltaEtaRegion", 0.1); + desc.add("deltaPhiRegion", 0.1); + desc.add("JetSrc", edm::InputTag("icone5Tau1")); + desc.add("vertexSrc", edm::InputTag("pixelVertices")); + desc.add("searchOpt", false); + + desc.add("howToUseMeasurementTracker", "ForSiStrips"); + + // allow both InputTag and string for the moment, use InputTag as the default + desc.addNode(edm::ParameterDescription("measurementTrackerName", edm::InputTag("MeasurementTrackerEvent"), true) xor + edm::ParameterDescription("measurementTrackerName", "MeasurementTrackerEvent", true)); + + // Only for backwards-compatibility + edm::ParameterSetDescription descRegion; + descRegion.add("RegionPSet", desc); + + descriptions.add("tauRegionalPixelSeedTrackingRegions", descRegion); + } + virtual std::vector > regions(const edm::Event& e, const edm::EventSetup& es) const override { std::vector > result; diff --git a/RecoTracker/Configuration/python/customiseClusterCheckForHighPileup.py b/RecoTracker/Configuration/python/customiseClusterCheckForHighPileup.py index 9f158c3f22a1f..fbbaacc9c91c2 100644 --- a/RecoTracker/Configuration/python/customiseClusterCheckForHighPileup.py +++ b/RecoTracker/Configuration/python/customiseClusterCheckForHighPileup.py @@ -1,12 +1,27 @@ def customiseClusterCheckForHighPileup(process): + _maxPixel = 80000 + _cut = "strip < 800000 && pixel < 80000 && (strip < 50000 + 10*pixel) && (pixel < 5000 + strip/7.)" + + _maxElement = 1000000 + for module in process._Process__producers.values(): + cppType = module._TypedParameterizable__type + + # cluster multiplicity check + if cppType == "ClusterCheckerEDProducer": + module.MaxNumberOfPixelClusters = _maxPixel + module.cut = _cut if hasattr(module, "ClusterCheckPSet"): - module.ClusterCheckPSet.MaxNumberOfPixelClusters = 80000 + module.ClusterCheckPSet.MaxNumberOfPixelClusters = _maxPixel # PhotonConversionTrajectorySeedProducerFromQuadruplets does not have "cut"... if hasattr(module.ClusterCheckPSet, "cut"): - module.ClusterCheckPSet.cut = "strip < 800000 && pixel < 80000 && (strip < 50000 + 10*pixel) && (pixel < 5000 + strip/7.)" + module.ClusterCheckPSet.cut = _cut + + # maxElement + if cppType in ["PixelTripletLargeTipEDProducer", "MultiHitFromChi2EDProducer"]: + module.maxElement = _maxElement if hasattr(module, "OrderedHitsFactoryPSet") and hasattr(module.OrderedHitsFactoryPSet, "GeneratorPSet"): if module.OrderedHitsFactoryPSet.GeneratorPSet.ComponentName.value() in ["PixelTripletLargeTipGenerator", "MultiHitGeneratorFromChi2"]: - module.OrderedHitsFactoryPSet.GeneratorPSet.maxElement = 1000000 + module.OrderedHitsFactoryPSet.GeneratorPSet.maxElement = _maxElement return process diff --git a/RecoTracker/Configuration/python/customiseEarlyDeleteForSeeding.py b/RecoTracker/Configuration/python/customiseEarlyDeleteForSeeding.py new file mode 100644 index 0000000000000..40cf9a502df5a --- /dev/null +++ b/RecoTracker/Configuration/python/customiseEarlyDeleteForSeeding.py @@ -0,0 +1,100 @@ +import FWCore.ParameterSet.Config as cms + +import collections + +def _hasInputTagModuleLabel(pset, moduleLabel): + for name in pset.parameterNames_(): + value = getattr(pset,name) + if isinstance(value, cms.PSet): + if _hasInputTagModuleLabel(value, moduleLabel): + return True + elif isinstance(value, cms.VPSet): + for ps in value: + if _hasInputTagModuleLabel(ps, moduleLabel): + return True + elif isinstance(value, cms.VInputTag): + for t in value: + t2 = t + if not isinstance(t, cms.InputTag): + t2 = cms.InputTag(t2) + if t2.getModuleLabel() == moduleLabel: + return True + elif isinstance(value, cms.InputTag): + if value.getModuleLabel() == moduleLabel: + return True + return False + + +def customiseEarlyDeleteForSeeding(process): + # Find the producers + products = collections.defaultdict(list) + depends = collections.defaultdict(list) + + def _branchName(productType, moduleLabel, instanceLabel=""): + return "%s_%s_%s_%s" % (productType, moduleLabel, instanceLabel, process.name_()) + + for name, module in process.producers_().iteritems(): + cppType = module._TypedParameterizable__type + if cppType == "HitPairEDProducer": + if module.produceSeedingHitSets: + products[name].append(_branchName("RegionsSeedingHitSets", name)) + if module.produceIntermediateHitDoublets: + products[name].append(_branchName("IntermediateHitDoublets", name)) + elif cppType in ["PixelTripletHLTEDProducer", "PixelTripletLargeTipEDProducer"]: + if module.produceSeedingHitSets: + products[name].append(_branchName("RegionsSeedingHitSets", name)) + if module.produceIntermediateHitTriplets: + products[name].append(_branchName("IntermediateHitTriplets", name)) + depends[name].append(module.doublets.getModuleLabel()) + elif cppType in ["MultiHitFromChi2EDProducer"]: + products[name].extend([ + _branchName("RegionsSeedingHitSets", name), + _branchName("BaseTrackerRecHitsOwned", name) + ]) + elif cppType == "PixelQuadrupletEDProducer": + products[name].append(_branchName("RegionsSeedingHitSets", name)) + elif cppType == "PixelQuadrupletMergerEDProducer": + products[name].extend([ + _branchName("RegionsSeedingHitSets", name), + _branchName("TrajectorySeeds", name) + ]) + + if len(products) == 0: + return process + + # Set process.options + if not hasattr(process, "options"): + process.options = cms.untracked.PSet() + if not hasattr(process.options, "canDeleteEarly"): + process.options.canDeleteEarly = cms.untracked.vstring() + for branches in products.itervalues(): + process.options.canDeleteEarly.extend(branches) + + # Resolve data dependencies + # + # If a productB depends on productA (e.g. by ref or pointer), then + # everybody that mightGet's producB, must also mightGet productA + def _resolve(keys, name): + for dependsOn in depends[name]: + if dependsOn in keys: + _resolve(keys, dependsOn) + keys.remove(dependsOn) + products[name].extend(products[dependsOn]) + + keys = set(depends.keys()) + while len(keys) > 0: + name = keys.pop() + _resolve(keys, name) + + # Find the consumers + for moduleType in [process.producers_(), process.filters_(), process.analyzers_()]: + for name, module in moduleType.iteritems(): + for producer, branches in products.iteritems(): + if _hasInputTagModuleLabel(module, producer): + #print "Module %s mightGet %s" % (name, str(branches)) + if hasattr(module, "mightGet"): + module.mightGet.extend(branches) + else: + module.mightGet = cms.untracked.vstring(branches) + + return process diff --git a/RecoTracker/Configuration/python/customiseForQuadrupletsByCellularAutomaton.py b/RecoTracker/Configuration/python/customiseForQuadrupletsByCellularAutomaton.py index 7f66a385a9230..daac43c60e44c 100644 --- a/RecoTracker/Configuration/python/customiseForQuadrupletsByCellularAutomaton.py +++ b/RecoTracker/Configuration/python/customiseForQuadrupletsByCellularAutomaton.py @@ -1,40 +1,90 @@ import FWCore.ParameterSet.Config as cms -def customiseForQuadrupletsByCellularAutomaton(process): - for module in process._Process__producers.values(): - if not hasattr(module, "OrderedHitsFactoryPSet"): - continue - pset = getattr(module, "OrderedHitsFactoryPSet") - if not hasattr(pset, "ComponentName"): - continue - if not (pset.ComponentName == "CombinedHitQuadrupletGenerator"): - continue - # Adjust seeding layers - seedingLayersName = module.OrderedHitsFactoryPSet.SeedingLayers.getModuleLabel() +_CAParameters = dict( + maxChi2 = dict( + pt1 = 0.8, pt2 = 2, + value1 = 200, value2 = 100, + enabled = True, + ), + useBendingCorrection = True, + fitFastCircle = True, + fitFastCircleChi2Cut = True, + CAThetaCut = 0.00125, + CAPhiCut = 0.1, + CAHardPtCut = 0, +) + +def customiseLegacySeeding(module): + pset = getattr(module, "OrderedHitsFactoryPSet") + if not hasattr(pset, "ComponentName"): + return + if pset.ComponentName != "CombinedHitQuadrupletGenerator": + return + # Adjust seeding layers + seedingLayersName = module.OrderedHitsFactoryPSet.SeedingLayers.getModuleLabel() + # Configure seed generator / pixel track producer + quadruplets = module.OrderedHitsFactoryPSet.clone() + from RecoPixelVertexing.PixelTriplets.CAHitQuadrupletGenerator_cfi import CAHitQuadrupletGenerator as _CAHitQuadrupletGenerator + + module.OrderedHitsFactoryPSet = _CAHitQuadrupletGenerator.clone( + ComponentName = "CAHitQuadrupletGenerator", + extraHitRPhitolerance = quadruplets.GeneratorPSet.extraHitRPhitolerance, + SeedingLayers = seedingLayersName, + **_CAParameters + ) + + if hasattr(quadruplets.GeneratorPSet, "SeedComparitorPSet"): + module.OrderedHitsFactoryPSet.SeedComparitorPSet = quadruplets.GeneratorPSet.SeedComparitorPSet + +def customiseNewSeeding(process, module): + tripletModuleName = module.triplets.getModuleLabel() + tripletModule = getattr(process, tripletModuleName) + doubletModuleName = tripletModule.doublets.getModuleLabel() + doubletModule = getattr(process, doubletModuleName) + + # Generate doublets for all adjacent layer pairs + doubletModule.layerPairs = [ + 0, # layer pair (0,1) + 1, # layer pair (1,2) + 2 # layer pair (2,3) + ] + # Bit of a hack to replace a module with another, but works + # + # In principle setattr(process) could work too, but it expands the + # sequences and I don't want that + modifier = cms.Modifier() + modifier._setChosen() + + # Replace quadruplet generator with the CA version + from RecoPixelVertexing.PixelTriplets.caHitQuadrupletEDProducer_cfi import caHitQuadrupletEDProducer as _caHitQuadrupletEDProducer + modifier.toReplaceWith(module, _caHitQuadrupletEDProducer.clone( + doublets = doubletModuleName, + SeedComparitorPSet = module.SeedComparitorPSet.clone(), + extraHitRPhitolerance = module.extraHitRPhitolerance, + **_CAParameters + )) + + # Remove triplet generator from all sequence and paths + for seqs in [process.sequences_(), process.paths_()]: + for seqName, seq in seqs.iteritems(): + # cms.Sequence.remove() would look simpler, but it expands + # the contained sequences if a replacement occurs there. + try: + index = seq.index(tripletModule) + except: + continue + + seq.remove(tripletModule) + + delattr(process, tripletModuleName) + +def customiseForQuadrupletsByCellularAutomaton(process): + for module in process._Process__producers.values(): + if hasattr(module, "OrderedHitsFactoryPSet"): + customiseLegacySeeding(module) + elif module._TypedParameterizable__type == "PixelQuadrupletEDProducer": + customiseNewSeeding(process, module) - # Configure seed generator / pixel track producer - quadruplets = module.OrderedHitsFactoryPSet.clone() - from RecoPixelVertexing.PixelTriplets.CAHitQuadrupletGenerator_cfi import CAHitQuadrupletGenerator as _CAHitQuadrupletGenerator - - module.OrderedHitsFactoryPSet = _CAHitQuadrupletGenerator.clone( - ComponentName = cms.string("CAHitQuadrupletGenerator"), - extraHitRPhitolerance = quadruplets.GeneratorPSet.extraHitRPhitolerance, - maxChi2 = dict( - pt1 = 0.8, pt2 = 2, - value1 = 200, value2 = 100, - enabled = True, - ), - useBendingCorrection = True, - fitFastCircle = True, - fitFastCircleChi2Cut = True, - SeedingLayers = cms.InputTag(seedingLayersName), - CAThetaCut = cms.double(0.00125), - CAPhiCut = cms.double(0.1), - CAHardPtCut = cms.double(0), - ) - - if hasattr(quadruplets.GeneratorPSet, "SeedComparitorPSet"): - module.OrderedHitsFactoryPSet.SeedComparitorPSet = quadruplets.GeneratorPSet.SeedComparitorPSet return process diff --git a/RecoTracker/Configuration/python/customiseForTripletsByCellularAutomaton.py b/RecoTracker/Configuration/python/customiseForTripletsByCellularAutomaton.py index bffd0ddc0bb96..2a15ace2997ee 100644 --- a/RecoTracker/Configuration/python/customiseForTripletsByCellularAutomaton.py +++ b/RecoTracker/Configuration/python/customiseForTripletsByCellularAutomaton.py @@ -1,38 +1,78 @@ import FWCore.ParameterSet.Config as cms +_CAParameters = dict( + maxChi2 = dict( + pt1 = 0.8, pt2 = 2, + value1 = 20, value2 = 10, + enabled = True, + ), + useBendingCorrection = True, + CAThetaCut = 0.0015, + CAPhiCut = 0.01, + CAHardPtCut = 0, +) + +def customiseLegacySeeding(module): + pset = getattr(module, "OrderedHitsFactoryPSet") + if not hasattr(pset, "ComponentName"): + return + if pset.ComponentName != "StandardHitTripletGenerator": + return + # Adjust seeding layers + seedingLayersName = module.OrderedHitsFactoryPSet.SeedingLayers.getModuleLabel() + + + # Configure seed generator / pixel track producer + Triplets = module.OrderedHitsFactoryPSet.clone() + from RecoPixelVertexing.PixelTriplets.CAHitTripletGenerator_cfi import CAHitTripletGenerator as _CAHitTripletGenerator + + module.OrderedHitsFactoryPSet = _CAHitTripletGenerator.clone( + ComponentName = "CAHitTripletGenerator", + extraHitRPhitolerance = Triplets.GeneratorPSet.extraHitRPhitolerance, + SeedingLayers = seedingLayersName, + **_CAParameters + ) + + if hasattr(Triplets.GeneratorPSet, "SeedComparitorPSet"): + module.OrderedHitsFactoryPSet.SeedComparitorPSet = Triplets.GeneratorPSet.SeedComparitorPSet + +def customiseNewSeeding(process, module): + doubletModuleName = module.doublets.getModuleLabel() + doubletModule = getattr(process, doubletModuleName) + + # Generate doublets for all adjacent layer pairs + doubletModule.layerPairs = [ + 0, # layer pair (0,1) + 1, # layer pair (1,2) + ] + + # Bit of a hack to replace a module with another, but works + # + # In principle setattr(process) could work too, but it expands the + # sequences and I don't want that + modifier = cms.Modifier() + modifier._setChosen() + + comparitor = None + if hasattr(module, "SeedComparitorPSet"): + comparitor = module.SeedComparitorPSet.clone() + + # Replace triplet generator with the CA version + from RecoPixelVertexing.PixelTriplets.caHitTripletEDProducer_cfi import caHitTripletEDProducer as _caHitTripletEDProducer + modifier.toReplaceWith(module, _caHitTripletEDProducer.clone( + doublets = doubletModuleName, + extraHitRPhitolerance = module.extraHitRPhitolerance, + **_CAParameters + )) + + if comparitor: + module.SeedComparitorPSet = comparitor + + def customiseForTripletsByCellularAutomaton(process): for module in process._Process__producers.values(): - if not hasattr(module, "OrderedHitsFactoryPSet"): - continue - pset = getattr(module, "OrderedHitsFactoryPSet") - if not hasattr(pset, "ComponentName"): - continue - if not (pset.ComponentName == "StandardHitTripletGenerator"): - continue - # Adjust seeding layers - seedingLayersName = module.OrderedHitsFactoryPSet.SeedingLayers.getModuleLabel() - - - - # Configure seed generator / pixel track producer - Triplets = module.OrderedHitsFactoryPSet.clone() - from RecoPixelVertexing.PixelTriplets.CAHitTripletGenerator_cfi import CAHitTripletGenerator as _CAHitTripletGenerator - - module.OrderedHitsFactoryPSet = _CAHitTripletGenerator.clone( - ComponentName = cms.string("CAHitTripletGenerator"), - extraHitRPhitolerance = Triplets.GeneratorPSet.extraHitRPhitolerance, - maxChi2 = dict( - pt1 = 0.8, pt2 = 2, - value1 = 20, value2 = 10, - enabled = True, - ), - useBendingCorrection = True, - SeedingLayers = cms.InputTag(seedingLayersName), - CAThetaCut = cms.double(0.0015), - CAPhiCut = cms.double(0.01), - CAHardPtCut = cms.double(0), - ) - - if hasattr(Triplets.GeneratorPSet, "SeedComparitorPSet"): - module.OrderedHitsFactoryPSet.SeedComparitorPSet = Triplets.GeneratorPSet.SeedComparitorPSet + if hasattr(module, "OrderedHitsFactoryPSet"): + customiseLegacySeeding(module) + elif module._TypedParameterizable__type in ["PixelTripletHLTEDProducer", "PixelTripletLargeTipEDProducer"]: + customiseNewSeeding(process, module) return process diff --git a/RecoTracker/ConversionSeedGenerators/plugins/HitPairGeneratorFromLayerPairForPhotonConversion.cc b/RecoTracker/ConversionSeedGenerators/plugins/HitPairGeneratorFromLayerPairForPhotonConversion.cc index 84906fdf66f41..6f6d2dea0623a 100644 --- a/RecoTracker/ConversionSeedGenerators/plugins/HitPairGeneratorFromLayerPairForPhotonConversion.cc +++ b/RecoTracker/ConversionSeedGenerators/plugins/HitPairGeneratorFromLayerPairForPhotonConversion.cc @@ -72,10 +72,10 @@ void HitPairGeneratorFromLayerPairForPhotonConversion::hitPairs(const Conversion if(!checkBoundaries(*outerLayerObj.detLayer(),convRegion,50.,60.)) return; //FIXME, the maxSearchR(Z) are not optimized /*get hit sorted in phi for each layer: NB: doesn't apply any region cut*/ - const RecHitsSortedInPhi & innerHitsMap = theLayerCache(innerLayerObj, region, event, es); + const RecHitsSortedInPhi & innerHitsMap = theLayerCache(innerLayerObj, region, es); if (innerHitsMap.empty()) return; - const RecHitsSortedInPhi& outerHitsMap = theLayerCache(outerLayerObj, region, event, es); + const RecHitsSortedInPhi& outerHitsMap = theLayerCache(outerLayerObj, region, es); if (outerHitsMap.empty()) return; /*----------------*/ diff --git a/RecoTracker/ConversionSeedGenerators/plugins/HitQuadrupletGeneratorFromLayerPairForPhotonConversion.cc b/RecoTracker/ConversionSeedGenerators/plugins/HitQuadrupletGeneratorFromLayerPairForPhotonConversion.cc index b947234d08b7e..b841a18349951 100644 --- a/RecoTracker/ConversionSeedGenerators/plugins/HitQuadrupletGeneratorFromLayerPairForPhotonConversion.cc +++ b/RecoTracker/ConversionSeedGenerators/plugins/HitQuadrupletGeneratorFromLayerPairForPhotonConversion.cc @@ -63,10 +63,10 @@ void HitQuadrupletGeneratorFromLayerPairForPhotonConversion::hitPairs(const Trac #endif /*get hit sorted in phi for each layer: NB: doesn't apply any region cut*/ - const RecHitsSortedInPhi & innerHitsMap = theLayerCache(innerLayerObj, region, event, es); + const RecHitsSortedInPhi & innerHitsMap = theLayerCache(innerLayerObj, region, es); if (innerHitsMap.empty()) return; - const RecHitsSortedInPhi& outerHitsMap = theLayerCache(outerLayerObj, region, event, es); + const RecHitsSortedInPhi& outerHitsMap = theLayerCache(outerLayerObj, region, es); if (outerHitsMap.empty()) return; /*----------------*/ diff --git a/RecoTracker/IterativeTracking/python/DetachedQuadStep_cff.py b/RecoTracker/IterativeTracking/python/DetachedQuadStep_cff.py index ad25b7a4bb121..4ed3f71991f31 100644 --- a/RecoTracker/IterativeTracking/python/DetachedQuadStep_cff.py +++ b/RecoTracker/IterativeTracking/python/DetachedQuadStep_cff.py @@ -26,29 +26,70 @@ layerList = RecoTracker.TkSeedingLayers.PixelLayerTriplets_cfi.PixelLayerTriplets.layerList.value() ) -# SEEDS -from RecoPixelVertexing.PixelTriplets.PixelTripletLargeTipGenerator_cfi import * -PixelTripletLargeTipGenerator.extraHitRZtolerance = 0.0 -PixelTripletLargeTipGenerator.extraHitRPhitolerance = 0.0 -import RecoTracker.TkSeedGenerator.GlobalSeedsFromTriplets_cff -from RecoTracker.TkTrackingRegions.GlobalTrackingRegionFromBeamSpot_cfi import RegionPsetFomBeamSpotBlock as _RegionPsetFomBeamSpotBlock -from RecoPixelVertexing.PixelTriplets.quadrupletseedmerging_cff import * -from RecoPixelVertexing.PixelTriplets.PixelQuadrupletGenerator_cfi import PixelQuadrupletGenerator as _PixelQuadrupletGenerator -detachedQuadStepSeeds = RecoTracker.TkSeedGenerator.GlobalSeedsFromTriplets_cff.globalSeedsFromTriplets.clone( - OrderedHitsFactoryPSet = dict( - SeedingLayers = 'detachedQuadStepSeedLayers', - GeneratorPSet = cms.PSet(PixelTripletLargeTipGenerator) +# TrackingRegion +from RecoTracker.TkTrackingRegions.globalTrackingRegionFromBeamSpotFixedZ_cfi import globalTrackingRegionFromBeamSpotFixedZ as _globalTrackingRegionFromBeamSpotFixedZ +detachedQuadStepTrackingRegions = _globalTrackingRegionFromBeamSpotFixedZ.clone(RegionPSet = dict( + ptMin = 0.3, + originHalfLength = 15.0, + originRadius = 1.5 +)) +from RecoTracker.TkTrackingRegions.globalTrackingRegionFromBeamSpot_cfi import globalTrackingRegionFromBeamSpot as _globalTrackingRegionFromBeamSpot +from Configuration.Eras.Modifier_trackingPhase1PU70_cff import trackingPhase1PU70 +trackingPhase1PU70.toReplaceWith(detachedQuadStepTrackingRegions, _globalTrackingRegionFromBeamSpot.clone(RegionPSet = dict( + ptMin = 0.3, + originRadius = 0.5, + nSigmaZ = 4.0 +))) +trackingPhase2PU140.toReplaceWith(detachedQuadStepTrackingRegions, _globalTrackingRegionFromBeamSpot.clone(RegionPSet = dict( + ptMin = 0.45, + originRadius = 0.7, + nSigmaZ = 4.0 +))) + +# seeding +from RecoTracker.TkHitPairs.hitPairEDProducer_cfi import hitPairEDProducer as _hitPairEDProducer +detachedQuadStepHitDoublets = _hitPairEDProducer.clone( + seedingLayers = "detachedQuadStepSeedLayers", + trackingRegions = "detachedQuadStepTrackingRegions", + maxElement = 0, + produceIntermediateHitDoublets = True, +) +from RecoPixelVertexing.PixelTriplets.pixelTripletLargeTipEDProducer_cfi import pixelTripletLargeTipEDProducer as _pixelTripletLargeTipEDProducer +from RecoPixelVertexing.PixelLowPtUtilities.ClusterShapeHitFilterESProducer_cfi import * +detachedQuadStepHitTriplets = _pixelTripletLargeTipEDProducer.clone( + doublets = "detachedQuadStepHitDoublets", + produceIntermediateHitTriplets = True, +) +from RecoPixelVertexing.PixelTriplets.pixelQuadrupletEDProducer_cfi import pixelQuadrupletEDProducer as _pixelQuadrupletEDProducer +detachedQuadStepHitQuadruplets = _pixelQuadrupletEDProducer.clone( + triplets = "detachedQuadStepHitTriplets", + extraHitRZtolerance = detachedQuadStepHitTriplets.extraHitRZtolerance, + extraHitRPhitolerance = detachedQuadStepHitTriplets.extraHitRPhitolerance, + maxChi2 = dict( + pt1 = 0.8, pt2 = 2, + value1 = 500, value2 = 100, + enabled = True, ), - SeedCreatorPSet = dict(ComponentName = 'SeedFromConsecutiveHitsTripletOnlyCreator'), - RegionFactoryPSet = dict( - RegionPSet = dict( - ptMin = 0.3, - originHalfLength = 15.0, - originRadius = 1.5 - ) + extraPhiTolerance = dict( + pt1 = 0.4, pt2 = 1, + value1 = 0.2, value2 = 0.05, + enabled = True, ), - SeedComparitorPSet = cms.PSet( - ComponentName = cms.string('PixelClusterShapeSeedComparitor'), + useBendingCorrection = True, + fitFastCircle = True, + fitFastCircleChi2Cut = True, +) +from RecoPixelVertexing.PixelTriplets.pixelQuadrupletMergerEDProducer_cfi import pixelQuadrupletMergerEDProducer as _pixelQuadrupletMergerEDProducer +from RecoPixelVertexing.PixelTriplets.quadrupletseedmerging_cff import * +_detachedQuadStepHitQuadrupletsMerging = _pixelQuadrupletMergerEDProducer.clone( + triplets = "detachedQuadStepHitTriplets", + layerList = dict(refToPSet_ = cms.string("PixelSeedMergerQuadruplets")), +) +from RecoTracker.TkSeedGenerator.seedCreatorFromRegionConsecutiveHitsTripletOnlyEDProducer_cff import seedCreatorFromRegionConsecutiveHitsTripletOnlyEDProducer as _seedCreatorFromRegionConsecutiveHitsTripletOnlyEDProducer +detachedQuadStepSeeds = _seedCreatorFromRegionConsecutiveHitsTripletOnlyEDProducer.clone( + seedingHitSets = "detachedQuadStepHitQuadruplets", + SeedComparitorPSet = dict(# FIXME: is this defined in any cfi that could be imported instead of copy-paste? + ComponentName = 'PixelClusterShapeSeedComparitor', FilterAtHelixStage = cms.bool(False), FilterPixelHits = cms.bool(True), FilterStripHits = cms.bool(False), @@ -56,64 +97,26 @@ ClusterShapeCacheSrc = cms.InputTag('siPixelClusterShapeCache') ), ) -trackingPhase1.toModify(detachedQuadStepSeeds, - OrderedHitsFactoryPSet = cms.PSet( - ComponentName = cms.string("CombinedHitQuadrupletGenerator"), - GeneratorPSet = _PixelQuadrupletGenerator.clone( - extraHitRZtolerance = detachedQuadStepSeeds.OrderedHitsFactoryPSet.GeneratorPSet.extraHitRZtolerance, - extraHitRPhitolerance = detachedQuadStepSeeds.OrderedHitsFactoryPSet.GeneratorPSet.extraHitRPhitolerance, - maxChi2 = dict( - pt1 = 0.8, pt2 = 2, - value1 = 500, value2 = 100, - enabled = True, - ), - extraPhiTolerance = dict( - pt1 = 0.4, pt2 = 1, - value1 = 0.2, value2 = 0.05, - enabled = True, - ), - useBendingCorrection = True, - fitFastCircle = True, - fitFastCircleChi2Cut = True, - ), - TripletGeneratorPSet = detachedQuadStepSeeds.OrderedHitsFactoryPSet.GeneratorPSet, - SeedingLayers = detachedQuadStepSeeds.OrderedHitsFactoryPSet.SeedingLayers, - ), -) -from Configuration.Eras.Modifier_trackingPhase1PU70_cff import trackingPhase1PU70 -trackingPhase1PU70.toModify(detachedQuadStepSeeds, - RegionFactoryPSet = dict( - RegionPSet = _RegionPsetFomBeamSpotBlock.RegionPSet.clone( - ptMin = 0.3, - originRadius = 0.5, - nSigmaZ = 4.0 - ) - ), - SeedMergerPSet = cms.PSet( - layerList = cms.PSet(refToPSet_ = cms.string("PixelSeedMergerQuadruplets")), - addRemainingTriplets = cms.bool(False), - mergeTriplets = cms.bool(True), - ttrhBuilderLabel = cms.string('PixelTTRHBuilderWithoutAngle') - ) -) -trackingPhase2PU140.toModify(detachedQuadStepSeeds, - RegionFactoryPSet = dict( - RegionPSet = _RegionPsetFomBeamSpotBlock.RegionPSet.clone( - ptMin = 0.45, - originRadius = 0.7, - nSigmaZ = 4.0 - ) - ), - ClusterCheckPSet = dict(doClusterCheck = False), - OrderedHitsFactoryPSet = dict( GeneratorPSet = dict(maxElement = 0 ) ), - SeedCreatorPSet = dict( magneticField = '', propagator = 'PropagatorWithMaterial'), - SeedMergerPSet = cms.PSet( - layerList = cms.PSet(refToPSet_ = cms.string("PixelSeedMergerQuadruplets")), - addRemainingTriplets = cms.bool(False), - mergeTriplets = cms.bool(True), - ttrhBuilderLabel = cms.string('PixelTTRHBuilderWithoutAngle') - ) +# temporary... +_detachedQuadStepHitQuadrupletsMerging.SeedCreatorPSet = cms.PSet( + ComponentName = cms.string("SeedFromConsecutiveHitsTripletOnlyCreator"), + MinOneOverPtError = detachedQuadStepSeeds.MinOneOverPtError, + OriginTransverseErrorMultiplier = detachedQuadStepSeeds.OriginTransverseErrorMultiplier, + SeedMomentumForBOFF = detachedQuadStepSeeds.SeedMomentumForBOFF, + TTRHBuilder = detachedQuadStepSeeds.TTRHBuilder, + forceKinematicWithRegionDirection = detachedQuadStepSeeds.forceKinematicWithRegionDirection, + magneticField = detachedQuadStepSeeds.magneticField, + propagator = detachedQuadStepSeeds.propagator, ) +_detachedQuadStepHitQuadrupletsMerging.SeedComparitorPSet = detachedQuadStepSeeds.SeedComparitorPSet + +trackingPhase1PU70.toModify(detachedQuadStepHitTriplets, produceIntermediateHitTriplets=False, produceSeedingHitSets=True) +trackingPhase1PU70.toReplaceWith(detachedQuadStepHitQuadruplets, _detachedQuadStepHitQuadrupletsMerging) +trackingPhase1PU70.toModify(detachedQuadStepSeeds, SeedComparitorPSet=cms.PSet(ComponentName=cms.string("none"))) +trackingPhase2PU140.toModify(detachedQuadStepHitTriplets, produceIntermediateHitTriplets=False, produceSeedingHitSets=True) +trackingPhase2PU140.toReplaceWith(detachedQuadStepHitQuadruplets, _detachedQuadStepHitQuadrupletsMerging) +trackingPhase2PU140.toModify(detachedQuadStepSeeds, SeedComparitorPSet=cms.PSet(ComponentName=cms.string("none"))) + # QUALITY CUTS DURING TRACK BUILDING import TrackingTools.TrajectoryFiltering.TrajectoryFilter_cff as _TrajectoryFilter_cff @@ -432,6 +435,10 @@ DetachedQuadStep = cms.Sequence(detachedQuadStepClusters* detachedQuadStepSeedLayers* + detachedQuadStepTrackingRegions* + detachedQuadStepHitDoublets* + detachedQuadStepHitTriplets* + detachedQuadStepHitQuadruplets* detachedQuadStepSeeds* detachedQuadStepTrackCandidates* detachedQuadStepTracks* diff --git a/RecoTracker/IterativeTracking/python/DetachedTripletStep_cff.py b/RecoTracker/IterativeTracking/python/DetachedTripletStep_cff.py index 5ae9bc53b278f..88404c6225a5b 100644 --- a/RecoTracker/IterativeTracking/python/DetachedTripletStep_cff.py +++ b/RecoTracker/IterativeTracking/python/DetachedTripletStep_cff.py @@ -35,27 +35,40 @@ ] ) -# SEEDS -from RecoPixelVertexing.PixelTriplets.PixelTripletLargeTipGenerator_cfi import * -PixelTripletLargeTipGenerator.extraHitRZtolerance = 0.0 -PixelTripletLargeTipGenerator.extraHitRPhitolerance = 0.0 -import RecoTracker.TkSeedGenerator.GlobalSeedsFromTriplets_cff -detachedTripletStepSeeds = RecoTracker.TkSeedGenerator.GlobalSeedsFromTriplets_cff.globalSeedsFromTriplets.clone() -detachedTripletStepSeeds.OrderedHitsFactoryPSet.SeedingLayers = 'detachedTripletStepSeedLayers' -detachedTripletStepSeeds.OrderedHitsFactoryPSet.GeneratorPSet = cms.PSet(PixelTripletLargeTipGenerator) -detachedTripletStepSeeds.SeedCreatorPSet.ComponentName = 'SeedFromConsecutiveHitsTripletOnlyCreator' -detachedTripletStepSeeds.RegionFactoryPSet.RegionPSet.ptMin = 0.3 -detachedTripletStepSeeds.RegionFactoryPSet.RegionPSet.originHalfLength = 15.0 -detachedTripletStepSeeds.RegionFactoryPSet.RegionPSet.originRadius = 1.5 +# TrackingRegion +from RecoTracker.TkTrackingRegions.globalTrackingRegionFromBeamSpotFixedZ_cfi import globalTrackingRegionFromBeamSpotFixedZ as _globalTrackingRegionFromBeamSpotFixedZ +detachedTripletStepTrackingRegions = _globalTrackingRegionFromBeamSpotFixedZ.clone(RegionPSet = dict( + ptMin = 0.3, + originHalfLength = 15.0, + originRadius = 1.5 +)) -detachedTripletStepSeeds.SeedComparitorPSet = cms.PSet( - ComponentName = cms.string('PixelClusterShapeSeedComparitor'), +# seeding +from RecoTracker.TkHitPairs.hitPairEDProducer_cfi import hitPairEDProducer as _hitPairEDProducer +detachedTripletStepHitDoublets = _hitPairEDProducer.clone( + seedingLayers = "detachedTripletStepSeedLayers", + trackingRegions = "detachedTripletStepTrackingRegions", + maxElement = 0, + produceIntermediateHitDoublets = True, +) +from RecoPixelVertexing.PixelTriplets.pixelTripletLargeTipEDProducer_cfi import pixelTripletLargeTipEDProducer as _pixelTripletLargeTipEDProducer +from RecoPixelVertexing.PixelLowPtUtilities.ClusterShapeHitFilterESProducer_cfi import * +detachedTripletStepHitTriplets = _pixelTripletLargeTipEDProducer.clone( + doublets = "detachedTripletStepHitDoublets", + produceSeedingHitSets = True, +) +from RecoTracker.TkSeedGenerator.seedCreatorFromRegionConsecutiveHitsTripletOnlyEDProducer_cff import seedCreatorFromRegionConsecutiveHitsTripletOnlyEDProducer as _seedCreatorFromRegionConsecutiveHitsTripletOnlyEDProducer +detachedTripletStepSeeds = _seedCreatorFromRegionConsecutiveHitsTripletOnlyEDProducer.clone( + seedingHitSets = "detachedTripletStepHitTriplets", + SeedComparitorPSet = dict(# FIXME: is this defined in any cfi that could be imported instead of copy-paste? + ComponentName = 'PixelClusterShapeSeedComparitor', FilterAtHelixStage = cms.bool(False), FilterPixelHits = cms.bool(True), FilterStripHits = cms.bool(False), ClusterShapeHitFilterName = cms.string('ClusterShapeHitFilter'), ClusterShapeCacheSrc = cms.InputTag('siPixelClusterShapeCache') - ) + ), +) # QUALITY CUTS DURING TRACK BUILDING import TrackingTools.TrajectoryFiltering.TrajectoryFilter_cff @@ -262,6 +275,9 @@ DetachedTripletStep = cms.Sequence(detachedTripletStepClusters* detachedTripletStepSeedLayers* + detachedTripletStepTrackingRegions* + detachedTripletStepHitDoublets* + detachedTripletStepHitTriplets* detachedTripletStepSeeds* detachedTripletStepTrackCandidates* detachedTripletStepTracks* diff --git a/RecoTracker/IterativeTracking/python/ElectronSeeds_cff.py b/RecoTracker/IterativeTracking/python/ElectronSeeds_cff.py index 423fce6ba0ccb..3ca4aae0a81eb 100644 --- a/RecoTracker/IterativeTracking/python/ElectronSeeds_cff.py +++ b/RecoTracker/IterativeTracking/python/ElectronSeeds_cff.py @@ -95,26 +95,35 @@ FPix = dict(skipClusters = 'pixelPairStepSeedClusterMask') ) -import RecoTracker.TkSeedGenerator.GlobalSeedsFromTriplets_cff -from RecoTracker.TkTrackingRegions.GlobalTrackingRegionFromBeamSpot_cfi import RegionPsetFomBeamSpotBlock -tripletElectronSeeds = RecoTracker.TkSeedGenerator.GlobalSeedsFromTriplets_cff.globalSeedsFromTriplets.clone( - RegionFactoryPSet = RegionPsetFomBeamSpotBlock.clone( - ComponentName = cms.string('GlobalRegionProducerFromBeamSpot'), - RegionPSet = RegionPsetFomBeamSpotBlock.RegionPSet.clone( +from RecoTracker.TkTrackingRegions.globalTrackingRegionFromBeamSpot_cfi import globalTrackingRegionFromBeamSpot as _globalTrackingRegionFromBeamSpot +tripletElectronTrackingRegions = _globalTrackingRegionFromBeamSpot.clone(RegionPSet = dict( ptMin = 1.0, originRadius = 0.02, nSigmaZ = 4.0 - ) - ) +)) +from RecoTracker.TkHitPairs.hitPairEDProducer_cfi import hitPairEDProducer as _hitPairEDProducer +tripletElectronHitDoublets = _hitPairEDProducer.clone( + seedingLayers = "tripletElectronSeedLayers", + trackingRegions = "tripletElectronTrackingRegions", + maxElement = 0, + produceIntermediateHitDoublets = True, +) +from RecoPixelVertexing.PixelTriplets.pixelTripletHLTEDProducer_cfi import pixelTripletHLTEDProducer as _pixelTripletHLTEDProducer +import RecoPixelVertexing.PixelLowPtUtilities.LowPtClusterShapeSeedComparitor_cfi +tripletElectronHitTriplets = _pixelTripletHLTEDProducer.clone( + doublets = "tripletElectronHitDoublets", + maxElement = 1000000, + produceSeedingHitSets = True, ) -tripletElectronSeeds.OrderedHitsFactoryPSet.SeedingLayers = cms.InputTag('tripletElectronSeedLayers') -trackingPhase1PU70.toModify(tripletElectronSeeds, - OrderedHitsFactoryPSet = dict(maxElement = cms.uint32(0)), # not sure if this has any effect +from RecoTracker.TkSeedGenerator.seedCreatorFromRegionConsecutiveHitsEDProducer_cff import seedCreatorFromRegionConsecutiveHitsEDProducer as _seedCreatorFromRegionConsecutiveHitsEDProducer +tripletElectronSeeds = _seedCreatorFromRegionConsecutiveHitsEDProducer.clone( + seedingHitSets = "tripletElectronHitTriplets", ) -trackingPhase2PU140.toModify(tripletElectronSeeds, - ClusterCheckPSet = dict( doClusterCheck = False ), - OrderedHitsFactoryPSet = dict( GeneratorPSet = dict( maxElement = 0 )), - SeedCreatorPSet = dict( magneticField = '', propagator = 'PropagatorWithMaterial') +trackingPhase1PU70.toModify(tripletElectronHitTriplets, + maxElement = 0, # not sure if this has any effect +) +trackingPhase2PU140.toModify(tripletElectronHitTriplets, + maxElement = 0, ) from RecoLocalTracker.SubCollectionProducers.SeedClusterRemover_cfi import seedClusterRemover @@ -159,12 +168,23 @@ ] ) -import RecoTracker.TkSeedGenerator.GlobalSeedsFromPairsWithVertices_cff -pixelPairElectronSeeds = RecoTracker.TkSeedGenerator.GlobalSeedsFromPairsWithVertices_cff.globalSeedsFromPairsWithVertices.clone() -pixelPairElectronSeeds.RegionFactoryPSet.RegionPSet.ptMin = 1.0 -pixelPairElectronSeeds.RegionFactoryPSet.RegionPSet.originRadius = 0.015 -pixelPairElectronSeeds.RegionFactoryPSet.RegionPSet.fixedError = 0.03 -pixelPairElectronSeeds.OrderedHitsFactoryPSet.SeedingLayers = cms.InputTag('pixelPairElectronSeedLayers') +from RecoTracker.TkTrackingRegions.globalTrackingRegionWithVertices_cff import globalTrackingRegionWithVertices as _globalTrackingRegionWithVertices +pixelPairElectronTrackingRegions = _globalTrackingRegionWithVertices.clone(RegionPSet = dict( + ptMin = 1.0, + originRadius = 0.015, + fixedError = 0.03, +)) +from RecoTracker.TkHitPairs.hitPairEDProducer_cfi import hitPairEDProducer as _hitPairEDProducer +pixelPairElectronHitDoublets = _hitPairEDProducer.clone( + seedingLayers = "pixelPairElectronSeedLayers", + trackingRegions = "pixelPairElectronTrackingRegions", + maxElement = 1000000, + produceSeedingHitSets = True, +) +from RecoTracker.TkSeedGenerator.seedCreatorFromRegionConsecutiveHitsEDProducer_cff import seedCreatorFromRegionConsecutiveHitsEDProducer as _seedCreatorFromRegionConsecutiveHitsEDProducer +pixelPairElectronSeeds = _seedCreatorFromRegionConsecutiveHitsEDProducer.clone( + seedingHitSets = "pixelPairElectronHitDoublets", +) stripPairElectronSeedLayers = cms.EDProducer("SeedingLayersEDProducer", layerList = cms.vstring('TIB1+TIB2', 'TIB1+TID1_pos', 'TIB1+TID1_neg', 'TID2_pos+TID3_pos', 'TID2_neg+TID3_neg', @@ -193,12 +213,24 @@ ) ) -import RecoTracker.TkSeedGenerator.GlobalMixedSeeds_cff -stripPairElectronSeeds = RecoTracker.TkSeedGenerator.GlobalMixedSeeds_cff.globalMixedSeeds.clone() -stripPairElectronSeeds.OrderedHitsFactoryPSet.SeedingLayers = 'stripPairElectronSeedLayers' -stripPairElectronSeeds.RegionFactoryPSet.RegionPSet.ptMin = 1.0 -stripPairElectronSeeds.RegionFactoryPSet.RegionPSet.originHalfLength = 12.0 -stripPairElectronSeeds.RegionFactoryPSet.RegionPSet.originRadius = 0.4 +from RecoTracker.TkTrackingRegions.globalTrackingRegionFromBeamSpotFixedZ_cfi import globalTrackingRegionFromBeamSpotFixedZ as _globalTrackingRegionFromBeamSpotFixedZ +stripPairElectronTrackingRegions = _globalTrackingRegionFromBeamSpotFixedZ.clone(RegionPSet = dict( + ptMin = 1.0, + originHalfLength = 12.0, + originRadius = 0.4, +)) +from RecoTracker.TkHitPairs.hitPairEDProducer_cfi import hitPairEDProducer as _hitPairEDProducer +stripPairElectronHitDoublets = _hitPairEDProducer.clone( + seedingLayers = "stripPairElectronSeedLayers", + trackingRegions = "stripPairElectronTrackingRegions", + maxElement = 1000000, + produceSeedingHitSets = True, +) +from RecoTracker.TkSeedGenerator.seedCreatorFromRegionConsecutiveHitsEDProducer_cff import seedCreatorFromRegionConsecutiveHitsEDProducer as _seedCreatorFromRegionConsecutiveHitsEDProducer +stripPairElectronSeeds = _seedCreatorFromRegionConsecutiveHitsEDProducer.clone( + seedingHitSets = "stripPairElectronHitDoublets", +) + ###This seed collection is produced for electron reconstruction import RecoTracker.TkSeedGenerator.GlobalCombinedSeeds_cfi @@ -240,11 +272,18 @@ mixedTripletStepSeedClusterMask* pixelLessStepSeedClusterMask* tripletElectronSeedLayers* + tripletElectronTrackingRegions* + tripletElectronHitDoublets* + tripletElectronHitTriplets* tripletElectronSeeds* tripletElectronClusterMask* pixelPairElectronSeedLayers* + pixelPairElectronTrackingRegions* + pixelPairElectronHitDoublets* pixelPairElectronSeeds* stripPairElectronSeedLayers* + stripPairElectronTrackingRegions* + stripPairElectronHitDoublets* stripPairElectronSeeds* newCombinedSeeds) _electronSeedsSeq_Phase1 = electronSeedsSeq.copy() @@ -255,6 +294,9 @@ highPtTripletStepSeedClusterMask* pixelPairStepSeedClusterMask* tripletElectronSeedLayers* + tripletElectronTrackingRegions* + tripletElectronHitDoublets* + tripletElectronHitTriplets* tripletElectronSeeds* newCombinedSeeds )) @@ -263,6 +305,9 @@ highPtTripletStepSeedClusterMask* pixelPairStepSeedClusterMask* tripletElectronSeedLayers* + tripletElectronTrackingRegions* + tripletElectronHitDoublets* + tripletElectronHitTriplets* tripletElectronSeeds* newCombinedSeeds )) diff --git a/RecoTracker/IterativeTracking/python/HighPtTripletStep_cff.py b/RecoTracker/IterativeTracking/python/HighPtTripletStep_cff.py index 8f9e873db9c17..955393b74b64e 100644 --- a/RecoTracker/IterativeTracking/python/HighPtTripletStep_cff.py +++ b/RecoTracker/IterativeTracking/python/HighPtTripletStep_cff.py @@ -51,34 +51,36 @@ 'FPix6_pos+FPix7_pos+FPix9_pos', 'FPix6_neg+FPix7_neg+FPix9_neg'] ) -# SEEDS -from RecoTracker.TkSeedGenerator.GlobalSeedsFromTriplets_cff import * -from RecoTracker.TkTrackingRegions.GlobalTrackingRegionFromBeamSpot_cfi import RegionPsetFomBeamSpotBlock +# TrackingRegion +from RecoTracker.TkTrackingRegions.globalTrackingRegionFromBeamSpot_cfi import globalTrackingRegionFromBeamSpot as _globalTrackingRegionFromBeamSpot +highPtTripletStepTrackingRegions = _globalTrackingRegionFromBeamSpot.clone(RegionPSet = dict( + ptMin = 0.6, + originRadius = 0.02, + nSigmaZ = 4.0 +)) +from Configuration.Eras.Modifier_trackingPhase1PU70_cff import trackingPhase1PU70 +trackingPhase1PU70.toModify(highPtTripletStepTrackingRegions, RegionPSet = dict(ptMin = 0.7)) +trackingPhase2PU140.toModify(highPtTripletStepTrackingRegions, RegionPSet = dict(ptMin = 0.9, originRadius = 0.03)) + +# seeding +from RecoTracker.TkHitPairs.hitPairEDProducer_cfi import hitPairEDProducer as _hitPairEDProducer +highPtTripletStepHitDoublets = _hitPairEDProducer.clone( + seedingLayers = "highPtTripletStepSeedLayers", + trackingRegions = "highPtTripletStepTrackingRegions", + maxElement = 0, + produceIntermediateHitDoublets = True, +) +from RecoPixelVertexing.PixelTriplets.pixelTripletHLTEDProducer_cfi import pixelTripletHLTEDProducer as _pixelTripletHLTEDProducer from RecoPixelVertexing.PixelLowPtUtilities.ClusterShapeHitFilterESProducer_cfi import * -import RecoPixelVertexing.PixelLowPtUtilities.LowPtClusterShapeSeedComparitor_cfi as _LowPtClusterShapeSeedComparitor_cfi -highPtTripletStepSeeds = globalSeedsFromTriplets.clone( - RegionFactoryPSet = RegionPsetFomBeamSpotBlock.clone( - ComponentName = cms.string('GlobalRegionProducerFromBeamSpot'), - RegionPSet = RegionPsetFomBeamSpotBlock.RegionPSet.clone( - ptMin = 0.6, - originRadius = 0.02, - nSigmaZ = 4.0 - ) - ), - OrderedHitsFactoryPSet = dict( - SeedingLayers = 'highPtTripletStepSeedLayers', - GeneratorPSet = dict( - SeedComparitorPSet = _LowPtClusterShapeSeedComparitor_cfi.LowPtClusterShapeSeedComparitor - ) - ) +import RecoPixelVertexing.PixelLowPtUtilities.LowPtClusterShapeSeedComparitor_cfi +highPtTripletStepHitTriplets = _pixelTripletHLTEDProducer.clone( + doublets = "highPtTripletStepHitDoublets", + produceSeedingHitSets = True, + SeedComparitorPSet = RecoPixelVertexing.PixelLowPtUtilities.LowPtClusterShapeSeedComparitor_cfi.LowPtClusterShapeSeedComparitor ) -from Configuration.Eras.Modifier_trackingPhase1PU70_cff import trackingPhase1PU70 -trackingPhase1PU70.toModify(highPtTripletStepSeeds, RegionFactoryPSet = dict(RegionPSet = dict(ptMin = 0.7))) -trackingPhase2PU140.toModify(highPtTripletStepSeeds, - ClusterCheckPSet = dict(doClusterCheck = False), - RegionFactoryPSet = dict(RegionPSet = dict(ptMin = 0.9, originRadius = 0.03)), - OrderedHitsFactoryPSet = dict( GeneratorPSet = dict(maxElement = 0 ) ), - SeedCreatorPSet = dict(magneticField = '', propagator = 'PropagatorWithMaterial') +from RecoTracker.TkSeedGenerator.seedCreatorFromRegionConsecutiveHitsEDProducer_cff import seedCreatorFromRegionConsecutiveHitsEDProducer as _seedCreatorFromRegionConsecutiveHitsEDProducer +highPtTripletStepSeeds = _seedCreatorFromRegionConsecutiveHitsEDProducer.clone( + seedingHitSets = "highPtTripletStepHitTriplets", ) # QUALITY CUTS DURING TRACK BUILDING @@ -309,6 +311,9 @@ # Final sequence HighPtTripletStep = cms.Sequence(highPtTripletStepClusters* highPtTripletStepSeedLayers* + highPtTripletStepTrackingRegions* + highPtTripletStepHitDoublets* + highPtTripletStepHitTriplets* highPtTripletStepSeeds* highPtTripletStepTrackCandidates* highPtTripletStepTracks* diff --git a/RecoTracker/IterativeTracking/python/InitialStepPreSplitting_cff.py b/RecoTracker/IterativeTracking/python/InitialStepPreSplitting_cff.py index eab1aa661d160..8a2aa9f110933 100644 --- a/RecoTracker/IterativeTracking/python/InitialStepPreSplitting_cff.py +++ b/RecoTracker/IterativeTracking/python/InitialStepPreSplitting_cff.py @@ -7,6 +7,11 @@ from RecoLocalTracker.SiPixelRecHits.PixelCPEESProducers_cff import * from RecoTracker.TransientTrackingRecHit.TTRHBuilders_cff import * +from RecoTracker.TkSeedGenerator.trackerClusterCheck_cfi import trackerClusterCheck as _trackerClusterCheck +trackerClusterCheckPreSplitting = _trackerClusterCheck.clone( + PixelClusterCollectionLabel = 'siPixelClustersPreSplitting' +) + # SEEDING LAYERS import RecoTracker.TkSeedingLayers.PixelLayerTriplets_cfi import RecoPixelVertexing.PixelTriplets.quadrupletseedmerging_cff @@ -18,52 +23,62 @@ layerList = RecoPixelVertexing.PixelTriplets.quadrupletseedmerging_cff.PixelSeedMergerQuadruplets.layerList.value() ) -# seeding -from RecoTracker.TkSeedGenerator.GlobalSeedsFromTriplets_cff import * -from RecoTracker.TkTrackingRegions.GlobalTrackingRegionFromBeamSpot_cfi import RegionPsetFomBeamSpotBlock -from RecoPixelVertexing.PixelTriplets.PixelQuadrupletGenerator_cfi import PixelQuadrupletGenerator as _PixelQuadrupletGenerator -initialStepSeedsPreSplitting = RecoTracker.TkSeedGenerator.GlobalSeedsFromTriplets_cff.globalSeedsFromTriplets.clone( - RegionFactoryPSet = RegionPsetFomBeamSpotBlock.clone( - ComponentName = cms.string('GlobalRegionProducerFromBeamSpot'), - RegionPSet = RegionPsetFomBeamSpotBlock.RegionPSet.clone( +# TrackingRegion +from RecoTracker.TkTrackingRegions.globalTrackingRegionFromBeamSpot_cfi import globalTrackingRegionFromBeamSpot as _globalTrackingRegionFromBeamSpot +initialStepTrackingRegionsPreSplitting = _globalTrackingRegionFromBeamSpot.clone(RegionPSet = dict( ptMin = 0.6, originRadius = 0.02, nSigmaZ = 4.0 - ) - ) - ) -initialStepSeedsPreSplitting.OrderedHitsFactoryPSet.SeedingLayers = 'initialStepSeedLayersPreSplitting' +)) + +# seeding +from RecoTracker.TkHitPairs.hitPairEDProducer_cfi import hitPairEDProducer as _hitPairEDProducer +initialStepHitDoubletsPreSplitting = _hitPairEDProducer.clone( + seedingLayers = "initialStepSeedLayersPreSplitting", + trackingRegions = "initialStepTrackingRegionsPreSplitting", + clusterCheck = "trackerClusterCheckPreSplitting", + maxElement = 0, + produceIntermediateHitDoublets = True, +) +from RecoPixelVertexing.PixelTriplets.pixelTripletHLTEDProducer_cfi import pixelTripletHLTEDProducer as _pixelTripletHLTEDProducer from RecoPixelVertexing.PixelLowPtUtilities.ClusterShapeHitFilterESProducer_cfi import * import RecoPixelVertexing.PixelLowPtUtilities.LowPtClusterShapeSeedComparitor_cfi -initialStepSeedsPreSplitting.OrderedHitsFactoryPSet.GeneratorPSet.SeedComparitorPSet = RecoPixelVertexing.PixelLowPtUtilities.LowPtClusterShapeSeedComparitor_cfi.LowPtClusterShapeSeedComparitor.clone() -initialStepSeedsPreSplitting.OrderedHitsFactoryPSet.GeneratorPSet.SeedComparitorPSet.clusterShapeCacheSrc = 'siPixelClusterShapeCachePreSplitting' -initialStepSeedsPreSplitting.ClusterCheckPSet.PixelClusterCollectionLabel = 'siPixelClustersPreSplitting' - -trackingPhase1.toModify(initialStepSeedsPreSplitting, - OrderedHitsFactoryPSet = cms.PSet( - ComponentName = cms.string("CombinedHitQuadrupletGenerator"), - GeneratorPSet = _PixelQuadrupletGenerator.clone( - extraHitRZtolerance = initialStepSeedsPreSplitting.OrderedHitsFactoryPSet.GeneratorPSet.extraHitRZtolerance, - extraHitRPhitolerance = initialStepSeedsPreSplitting.OrderedHitsFactoryPSet.GeneratorPSet.extraHitRPhitolerance, - SeedComparitorPSet = initialStepSeedsPreSplitting.OrderedHitsFactoryPSet.GeneratorPSet.SeedComparitorPSet, - maxChi2 = dict( - pt1 = 0.8, pt2 = 2, - value1 = 200, value2 = 100, - enabled = True, - ), - extraPhiTolerance = dict( - pt1 = 0.6, pt2 = 1, - value1 = 0.15, value2 = 0.1, - enabled = True, - ), - useBendingCorrection = True, - fitFastCircle = True, - fitFastCircleChi2Cut = True, - ), - TripletGeneratorPSet = initialStepSeedsPreSplitting.OrderedHitsFactoryPSet.GeneratorPSet, - SeedingLayers = cms.InputTag('initialStepSeedLayersPreSplitting'), - ) +initialStepHitTripletsPreSplitting = _pixelTripletHLTEDProducer.clone( + doublets = "initialStepHitDoubletsPreSplitting", + produceSeedingHitSets = True, + SeedComparitorPSet = RecoPixelVertexing.PixelLowPtUtilities.LowPtClusterShapeSeedComparitor_cfi.LowPtClusterShapeSeedComparitor.clone( + clusterShapeCacheSrc = 'siPixelClusterShapeCachePreSplitting' + ), +) +from RecoPixelVertexing.PixelTriplets.pixelQuadrupletEDProducer_cfi import pixelQuadrupletEDProducer as _pixelQuadrupletEDProducer +initialStepHitQuadrupletsPreSplitting = _pixelQuadrupletEDProducer.clone( + triplets = "initialStepHitTripletsPreSplitting", + extraHitRZtolerance = initialStepHitTripletsPreSplitting.extraHitRZtolerance, + extraHitRPhitolerance = initialStepHitTripletsPreSplitting.extraHitRPhitolerance, + maxChi2 = dict( + pt1 = 0.8, pt2 = 2, + value1 = 200, value2 = 100, + enabled = True, + ), + extraPhiTolerance = dict( + pt1 = 0.6, pt2 = 1, + value1 = 0.15, value2 = 0.1, + enabled = True, + ), + useBendingCorrection = True, + fitFastCircle = True, + fitFastCircleChi2Cut = True, + SeedComparitorPSet = initialStepHitTripletsPreSplitting.SeedComparitorPSet ) +from RecoTracker.TkSeedGenerator.seedCreatorFromRegionConsecutiveHitsEDProducer_cff import seedCreatorFromRegionConsecutiveHitsEDProducer as _seedCreatorFromRegionConsecutiveHitsEDProducer +initialStepSeedsPreSplitting = _seedCreatorFromRegionConsecutiveHitsEDProducer.clone( + seedingHitSets = "initialStepHitTripletsPreSplitting", +) +trackingPhase1.toModify(initialStepHitTripletsPreSplitting, + produceSeedingHitSets = False, + produceIntermediateHitTriplets = True, +) +trackingPhase1.toModify(initialStepSeedsPreSplitting, seedingHitSets = "initialStepHitQuadrupletsPreSplitting") # building @@ -165,7 +180,11 @@ from RecoLocalTracker.SiPixelRecHits.SiPixelRecHits_cfi import siPixelRecHits from RecoTracker.MeasurementDet.MeasurementTrackerEventProducer_cfi import MeasurementTrackerEvent from RecoPixelVertexing.PixelLowPtUtilities.siPixelClusterShapeCache_cfi import * -InitialStepPreSplitting = cms.Sequence(initialStepSeedLayersPreSplitting* +InitialStepPreSplitting = cms.Sequence(trackerClusterCheckPreSplitting* + initialStepSeedLayersPreSplitting* + initialStepTrackingRegionsPreSplitting* + initialStepHitDoubletsPreSplitting* + initialStepHitTripletsPreSplitting* initialStepSeedsPreSplitting* initialStepTrackCandidatesPreSplitting* initialStepTracksPreSplitting* @@ -179,6 +198,10 @@ MeasurementTrackerEvent* siPixelClusterShapeCache) +_InitialStepPreSplitting_trackingPhase1 = InitialStepPreSplitting.copy() +_InitialStepPreSplitting_trackingPhase1.replace(initialStepHitTripletsPreSplitting, initialStepHitTripletsPreSplitting*initialStepHitQuadrupletsPreSplitting) +trackingPhase1.toReplaceWith(InitialStepPreSplitting, _InitialStepPreSplitting_trackingPhase1) + # Although InitialStepPreSplitting is not really part of LowPU/Run1/Phase1PU70 # tracking, we use it to get siPixelClusters and siPixelRecHits # collections for non-splitted pixel clusters. All modules before diff --git a/RecoTracker/IterativeTracking/python/InitialStep_cff.py b/RecoTracker/IterativeTracking/python/InitialStep_cff.py index 6fbef95f4846c..2ab21aa5a2088 100644 --- a/RecoTracker/IterativeTracking/python/InitialStep_cff.py +++ b/RecoTracker/IterativeTracking/python/InitialStep_cff.py @@ -21,48 +21,61 @@ ] ) - -# seeding -from RecoTracker.TkSeedGenerator.GlobalSeedsFromTriplets_cff import * -from RecoTracker.TkTrackingRegions.GlobalTrackingRegionFromBeamSpot_cfi import RegionPsetFomBeamSpotBlock -initialStepSeeds = RecoTracker.TkSeedGenerator.GlobalSeedsFromTriplets_cff.globalSeedsFromTriplets.clone( - RegionFactoryPSet = RegionPsetFomBeamSpotBlock.clone( - ComponentName = cms.string('GlobalRegionProducerFromBeamSpot'), - RegionPSet = RegionPsetFomBeamSpotBlock.RegionPSet.clone( +# TrackingRegion +from RecoTracker.TkTrackingRegions.globalTrackingRegionFromBeamSpot_cfi import globalTrackingRegionFromBeamSpot as _globalTrackingRegionFromBeamSpot +initialStepTrackingRegions = _globalTrackingRegionFromBeamSpot.clone(RegionPSet = dict( ptMin = 0.6, originRadius = 0.02, nSigmaZ = 4.0 - ) - ) - ) -initialStepSeeds.OrderedHitsFactoryPSet.SeedingLayers = 'initialStepSeedLayers' +)) +from Configuration.Eras.Modifier_trackingPhase1PU70_cff import trackingPhase1PU70 +from Configuration.Eras.Modifier_trackingPhase2PU140_cff import trackingPhase2PU140 +trackingPhase1PU70.toModify(initialStepTrackingRegions, RegionPSet = dict(ptMin = 0.7)) +trackingPhase2PU140.toModify(initialStepTrackingRegions, RegionPSet = dict(ptMin = 0.8)) + +# seeding +from RecoTracker.TkHitPairs.hitPairEDProducer_cfi import hitPairEDProducer as _hitPairEDProducer +initialStepHitDoublets = _hitPairEDProducer.clone( + seedingLayers = "initialStepSeedLayers", + trackingRegions = "initialStepTrackingRegions", + maxElement = 0, + produceIntermediateHitDoublets = True, +) +from RecoPixelVertexing.PixelTriplets.pixelTripletHLTEDProducer_cfi import pixelTripletHLTEDProducer as _pixelTripletHLTEDProducer from RecoPixelVertexing.PixelLowPtUtilities.ClusterShapeHitFilterESProducer_cfi import * import RecoPixelVertexing.PixelLowPtUtilities.LowPtClusterShapeSeedComparitor_cfi -initialStepSeeds.OrderedHitsFactoryPSet.GeneratorPSet.SeedComparitorPSet = RecoPixelVertexing.PixelLowPtUtilities.LowPtClusterShapeSeedComparitor_cfi.LowPtClusterShapeSeedComparitor - -_SeedMergerPSet = cms.PSet( - layerList = cms.PSet(refToPSet_ = cms.string("PixelSeedMergerQuadruplets")), - addRemainingTriplets = cms.bool(False), - mergeTriplets = cms.bool(True), - ttrhBuilderLabel = cms.string('PixelTTRHBuilderWithoutAngle') +initialStepHitTriplets = _pixelTripletHLTEDProducer.clone( + doublets = "initialStepHitDoublets", + produceSeedingHitSets = True, + SeedComparitorPSet = RecoPixelVertexing.PixelLowPtUtilities.LowPtClusterShapeSeedComparitor_cfi.LowPtClusterShapeSeedComparitor ) -from Configuration.Eras.Modifier_trackingPhase1PU70_cff import trackingPhase1PU70 -trackingPhase1PU70.toModify(initialStepSeeds, - RegionFactoryPSet = dict(RegionPSet = dict(ptMin = 0.7)), - SeedMergerPSet = _SeedMergerPSet +from RecoPixelVertexing.PixelTriplets.pixelQuadrupletMergerEDProducer_cfi import pixelQuadrupletMergerEDProducer as _pixelQuadrupletMergerEDProducer +from RecoPixelVertexing.PixelTriplets.quadrupletseedmerging_cff import * +initialStepHitQuadruplets = _pixelQuadrupletMergerEDProducer.clone( + triplets = "initialStepHitTriplets", + layerList = dict(refToPSet_ = cms.string("PixelSeedMergerQuadruplets")), ) -from Configuration.Eras.Modifier_trackingPhase2PU140_cff import trackingPhase2PU140 -trackingPhase2PU140.toModify(initialStepSeeds, - ClusterCheckPSet = dict(doClusterCheck = cms.bool(False)), - OrderedHitsFactoryPSet = dict(GeneratorPSet = dict(maxElement = 0)), - RegionFactoryPSet = dict(RegionPSet = dict(ptMin = 0.8)), - SeedCreatorPSet = dict(magneticField = '', propagator = 'PropagatorWithMaterial'), - SeedMergerPSet = _SeedMergerPSet -) +from RecoTracker.TkSeedGenerator.seedCreatorFromRegionConsecutiveHitsEDProducer_cff import seedCreatorFromRegionConsecutiveHitsEDProducer as _seedCreatorFromRegionConsecutiveHitsEDProducer +initialStepSeeds = _seedCreatorFromRegionConsecutiveHitsEDProducer.clone( + seedingHitSets = "initialStepHitTriplets", +) +# temporary... +initialStepHitQuadruplets.SeedCreatorPSet = cms.PSet( + ComponentName = cms.string("SeedFromConsecutiveHitsCreator"), + MinOneOverPtError = initialStepSeeds.MinOneOverPtError, + OriginTransverseErrorMultiplier = initialStepSeeds.OriginTransverseErrorMultiplier, + SeedMomentumForBOFF = initialStepSeeds.SeedMomentumForBOFF, + TTRHBuilder = initialStepSeeds.TTRHBuilder, + forceKinematicWithRegionDirection = initialStepSeeds.forceKinematicWithRegionDirection, + magneticField = initialStepSeeds.magneticField, + propagator = initialStepSeeds.propagator, +) +initialStepHitQuadruplets.SeedComparitorPSet = initialStepSeeds.SeedComparitorPSet + +trackingPhase1PU70.toModify(initialStepSeeds, seedingHitSets="initialStepHitQuadruplets") +trackingPhase2PU140.toModify(initialStepSeeds, seedingHitSets="initialStepHitQuadruplets") -from Configuration.Eras.Modifier_trackingLowPU_cff import trackingLowPU -trackingLowPU.toModify(initialStepSeeds, OrderedHitsFactoryPSet = dict(GeneratorPSet = dict(maxElement = 100000))) # building import TrackingTools.TrajectoryFiltering.TrajectoryFilter_cff @@ -82,6 +95,7 @@ strictSeedExtension = True, # don't allow inactive pixelSeedExtension = True, ) +from Configuration.Eras.Modifier_trackingLowPU_cff import trackingLowPU trackingLowPU.toReplaceWith(initialStepTrajectoryFilterBase, _initialStepTrajectoryFilterBase) trackingPhase1PU70.toReplaceWith(initialStepTrajectoryFilterBase, _initialStepTrajectoryFilterBase) @@ -308,6 +322,9 @@ # Final sequence InitialStep = cms.Sequence(initialStepSeedLayers* + initialStepTrackingRegions* + initialStepHitDoublets* + initialStepHitTriplets* initialStepSeeds* initialStepTrackCandidates* initialStepTracks* @@ -317,7 +334,7 @@ _InitialStep_LowPU = InitialStep.copyAndExclude([firstStepPrimaryVertices, initialStepClassifier1, initialStepClassifier2, initialStepClassifier3]) _InitialStep_LowPU.replace(initialStep, initialStepSelector) trackingLowPU.toReplaceWith(InitialStep, _InitialStep_LowPU) -_InitialStep_Phase1PU70 = InitialStep.copyAndExclude([firstStepPrimaryVertices, initialStepClassifier1, initialStepClassifier2, initialStepClassifier3]) -_InitialStep_Phase1PU70.replace(initialStep, initialStepSelector) +_InitialStep_Phase1PU70 = _InitialStep_LowPU.copy() +_InitialStep_Phase1PU70.replace(initialStepHitTriplets, initialStepHitTriplets+initialStepHitQuadruplets) trackingPhase1PU70.toReplaceWith(InitialStep, _InitialStep_Phase1PU70) trackingPhase2PU140.toReplaceWith(InitialStep, _InitialStep_Phase1PU70) diff --git a/RecoTracker/IterativeTracking/python/JetCoreRegionalStep_cff.py b/RecoTracker/IterativeTracking/python/JetCoreRegionalStep_cff.py index 23d6861654592..6a50a04c74ae3 100644 --- a/RecoTracker/IterativeTracking/python/JetCoreRegionalStep_cff.py +++ b/RecoTracker/IterativeTracking/python/JetCoreRegionalStep_cff.py @@ -63,35 +63,30 @@ ] ) -# SEEDS -import RecoTracker.TkSeedGenerator.GlobalSeedsFromPairsWithVertices_cff -jetCoreRegionalStepSeeds = RecoTracker.TkSeedGenerator.GlobalSeedsFromPairsWithVertices_cff.globalSeedsFromPairsWithVertices.clone() -jetCoreRegionalStepSeeds.RegionFactoryPSet = cms.PSet( - ComponentName = cms.string( "TauRegionalPixelSeedGenerator" ),#not so nice to depend on RecoTau... - RegionPSet = cms.PSet( - precise = cms.bool( True ), - originRadius = cms.double( 0.2 ), - ptMin = cms.double( 10. ), - originHalfLength = cms.double( 0.2 ), - deltaPhiRegion = cms.double( 0.20 ), - deltaEtaRegion = cms.double( 0.20 ), - JetSrc = cms.InputTag( "jetsForCoreTracking" ), -# JetSrc = cms.InputTag( "ak5CaloJets" ), - vertexSrc = cms.InputTag( "firstStepGoodPrimaryVertices" ), - measurementTrackerName = cms.string( "MeasurementTrackerEvent" ), - howToUseMeasurementTracker = cms.string( "Never" ) - ) +# TrackingRegion +from RecoTauTag.HLTProducers.tauRegionalPixelSeedTrackingRegions_cfi import tauRegionalPixelSeedTrackingRegions as _tauRegionalPixelSeedTrackingRegions +jetCoreRegionalStepTrackingRegions = _tauRegionalPixelSeedTrackingRegions.clone(RegionPSet=dict( + ptMin = 10, + deltaPhiRegion = 0.20, + deltaEtaRegion = 0.20, + JetSrc = "jetsForCoreTracking", +# JetSrc = "ak5CaloJets", + vertexSrc = "firstStepGoodPrimaryVertices", + howToUseMeasurementTracker = "Never" +)) + +# Seeding +from RecoTracker.TkHitPairs.hitPairEDProducer_cfi import hitPairEDProducer as _hitPairEDProducer +jetCoreRegionalStepHitDoublets = _hitPairEDProducer.clone( + seedingLayers = "jetCoreRegionalStepSeedLayers", + trackingRegions = "jetCoreRegionalStepTrackingRegions", + produceSeedingHitSets = True, +) +from RecoTracker.TkSeedGenerator.seedCreatorFromRegionConsecutiveHitsEDProducer_cff import seedCreatorFromRegionConsecutiveHitsEDProducer as _seedCreatorFromRegionConsecutiveHitsEDProducer +jetCoreRegionalStepSeeds = _seedCreatorFromRegionConsecutiveHitsEDProducer.clone( + seedingHitSets = "jetCoreRegionalStepHitDoublets", + forceKinematicWithRegionDirection = True ) -jetCoreRegionalStepSeeds.OrderedHitsFactoryPSet.SeedingLayers = 'jetCoreRegionalStepSeedLayers' -jetCoreRegionalStepSeeds.SeedComparitorPSet = cms.PSet( - ComponentName = cms.string('none'), -#PixelClusterShapeSeedComparitor'), -# FilterAtHelixStage = cms.bool(True), -# FilterPixelHits = cms.bool(True), -# FilterStripHits = cms.bool(False), -# ClusterShapeHitFilterName = cms.string('ClusterShapeHitFilter') - ) -jetCoreRegionalStepSeeds.SeedCreatorPSet.forceKinematicWithRegionDirection = cms.bool( True ) # QUALITY CUTS DURING TRACK BUILDING import TrackingTools.TrajectoryFiltering.TrajectoryFilter_cff @@ -182,6 +177,8 @@ firstStepGoodPrimaryVertices* #jetCoreRegionalStepClusters* jetCoreRegionalStepSeedLayers* + jetCoreRegionalStepTrackingRegions* + jetCoreRegionalStepHitDoublets* jetCoreRegionalStepSeeds* jetCoreRegionalStepTrackCandidates* jetCoreRegionalStepTracks* diff --git a/RecoTracker/IterativeTracking/python/LowPtQuadStep_cff.py b/RecoTracker/IterativeTracking/python/LowPtQuadStep_cff.py index e90b5ffff5d2b..b57a35f089b6f 100644 --- a/RecoTracker/IterativeTracking/python/LowPtQuadStep_cff.py +++ b/RecoTracker/IterativeTracking/python/LowPtQuadStep_cff.py @@ -19,76 +19,81 @@ layerList = RecoPixelVertexing.PixelTriplets.quadrupletseedmerging_cff.PixelSeedMergerQuadruplets.layerList.value() ) -# SEEDS -import RecoTracker.TkSeedGenerator.GlobalSeedsFromTriplets_cff -from RecoTracker.TkTrackingRegions.GlobalTrackingRegionFromBeamSpot_cfi import RegionPsetFomBeamSpotBlock -from RecoPixelVertexing.PixelTriplets.quadrupletseedmerging_cff import * +# TrackingRegion +from RecoTracker.TkTrackingRegions.globalTrackingRegionFromBeamSpot_cfi import globalTrackingRegionFromBeamSpot as _globalTrackingRegionFromBeamSpot +lowPtQuadStepTrackingRegions = _globalTrackingRegionFromBeamSpot.clone(RegionPSet = dict( + ptMin = 0.2, + originRadius = 0.02, + nSigmaZ = 4.0 +)) +from Configuration.Eras.Modifier_trackingPhase2PU140_cff import trackingPhase2PU140 +trackingPhase2PU140.toModify(lowPtQuadStepTrackingRegions, RegionPSet = dict(ptMin = 0.35)) + + +# seeding +from RecoTracker.TkHitPairs.hitPairEDProducer_cfi import hitPairEDProducer as _hitPairEDProducer +lowPtQuadStepHitDoublets = _hitPairEDProducer.clone( + seedingLayers = "lowPtQuadStepSeedLayers", + trackingRegions = "lowPtQuadStepTrackingRegions", + maxElement = 0, + produceIntermediateHitDoublets = True, +) +from RecoPixelVertexing.PixelTriplets.pixelTripletHLTEDProducer_cfi import pixelTripletHLTEDProducer as _pixelTripletHLTEDProducer from RecoPixelVertexing.PixelLowPtUtilities.ClusterShapeHitFilterESProducer_cfi import * -from RecoPixelVertexing.PixelTriplets.PixelQuadrupletGenerator_cfi import PixelQuadrupletGenerator as _PixelQuadrupletGenerator -import RecoPixelVertexing.PixelLowPtUtilities.LowPtClusterShapeSeedComparitor_cfi as _LowPtClusterShapeSeedComparitor_cfi -lowPtQuadStepSeeds = RecoTracker.TkSeedGenerator.GlobalSeedsFromTriplets_cff.globalSeedsFromTriplets.clone( - RegionFactoryPSet = RegionPsetFomBeamSpotBlock.clone( - ComponentName = cms.string('GlobalRegionProducerFromBeamSpot'), - RegionPSet = RegionPsetFomBeamSpotBlock.RegionPSet.clone( - ptMin = 0.2, - originRadius = 0.02, - nSigmaZ = 4.0 - ) +import RecoPixelVertexing.PixelLowPtUtilities.LowPtClusterShapeSeedComparitor_cfi +lowPtQuadStepHitTriplets = _pixelTripletHLTEDProducer.clone( + doublets = "lowPtQuadStepHitDoublets", + produceIntermediateHitTriplets = True, + SeedComparitorPSet = RecoPixelVertexing.PixelLowPtUtilities.LowPtClusterShapeSeedComparitor_cfi.LowPtClusterShapeSeedComparitor +) +from RecoPixelVertexing.PixelTriplets.pixelQuadrupletEDProducer_cfi import pixelQuadrupletEDProducer as _pixelQuadrupletEDProducer +lowPtQuadStepHitQuadruplets = _pixelQuadrupletEDProducer.clone( + triplets = "lowPtQuadStepHitTriplets", + extraHitRZtolerance = lowPtQuadStepHitTriplets.extraHitRZtolerance, + extraHitRPhitolerance = lowPtQuadStepHitTriplets.extraHitRPhitolerance, + maxChi2 = dict( + pt1 = 0.8 , pt2 = 2, + value1 = 2000, value2 = 100, + enabled = True, ), - OrderedHitsFactoryPSet = dict( - SeedingLayers = 'lowPtQuadStepSeedLayers', - GeneratorPSet = dict( - SeedComparitorPSet = _LowPtClusterShapeSeedComparitor_cfi.LowPtClusterShapeSeedComparitor - ) + extraPhiTolerance = dict( + pt1 = 0.3, pt2 = 1, + value1 = 0.4, value2 = 0.05, + enabled = True, ), + useBendingCorrection = True, + fitFastCircle = True, + fitFastCircleChi2Cut = True, + SeedComparitorPSet = lowPtQuadStepHitTriplets.SeedComparitorPSet, ) -trackingPhase1.toModify(lowPtQuadStepSeeds, - OrderedHitsFactoryPSet = cms.PSet( - ComponentName = cms.string("CombinedHitQuadrupletGenerator"), - GeneratorPSet = _PixelQuadrupletGenerator.clone( - extraHitRZtolerance = lowPtQuadStepSeeds.OrderedHitsFactoryPSet.GeneratorPSet.extraHitRZtolerance, - extraHitRPhitolerance = lowPtQuadStepSeeds.OrderedHitsFactoryPSet.GeneratorPSet.extraHitRPhitolerance, - SeedComparitorPSet = lowPtQuadStepSeeds.OrderedHitsFactoryPSet.GeneratorPSet.SeedComparitorPSet, - maxChi2 = dict( - pt1 = 0.8 , pt2 = 2, - value1 = 2000, value2 = 100, - enabled = True, - ), - extraPhiTolerance = dict( - pt1 = 0.3, pt2 = 1, - value1 = 0.4, value2 = 0.05, - enabled = True, - ), - useBendingCorrection = True, - fitFastCircle = True, - fitFastCircleChi2Cut = True, - ), - TripletGeneratorPSet = lowPtQuadStepSeeds.OrderedHitsFactoryPSet.GeneratorPSet, - SeedingLayers = lowPtQuadStepSeeds.OrderedHitsFactoryPSet.SeedingLayers, - ), +from RecoPixelVertexing.PixelTriplets.pixelQuadrupletMergerEDProducer_cfi import pixelQuadrupletMergerEDProducer as _pixelQuadrupletMergerEDProducer +from RecoPixelVertexing.PixelTriplets.quadrupletseedmerging_cff import * +_lowPtQuadStepHitQuadrupletsMerging = _pixelQuadrupletMergerEDProducer.clone( + triplets = "lowPtQuadStepHitTriplets", + layerList = dict(refToPSet_ = cms.string("PixelSeedMergerQuadruplets")), ) -from Configuration.Eras.Modifier_trackingPhase1PU70_cff import trackingPhase1PU70 -trackingPhase1PU70.toModify(lowPtQuadStepSeeds, - SeedMergerPSet = cms.PSet( - layerList = cms.PSet(refToPSet_ = cms.string("PixelSeedMergerQuadruplets")), - addRemainingTriplets = cms.bool(False), - mergeTriplets = cms.bool(True), - ttrhBuilderLabel = cms.string('PixelTTRHBuilderWithoutAngle') - ) +from RecoTracker.TkSeedGenerator.seedCreatorFromRegionConsecutiveHitsEDProducer_cff import seedCreatorFromRegionConsecutiveHitsEDProducer as _seedCreatorFromRegionConsecutiveHitsEDProducer +lowPtQuadStepSeeds = _seedCreatorFromRegionConsecutiveHitsEDProducer.clone( + seedingHitSets = "lowPtQuadStepHitQuadruplets", ) -from Configuration.Eras.Modifier_trackingPhase2PU140_cff import trackingPhase2PU140 -trackingPhase2PU140.toModify(lowPtQuadStepSeeds, - ClusterCheckPSet = dict(doClusterCheck = False), - RegionFactoryPSet = dict(RegionPSet = dict(ptMin = 0.35)), - OrderedHitsFactoryPSet = dict( GeneratorPSet = dict(maxElement = 0 ) ), - SeedCreatorPSet = dict( magneticField = '', propagator = 'PropagatorWithMaterial'), - SeedMergerPSet = cms.PSet( - layerList = cms.PSet(refToPSet_ = cms.string("PixelSeedMergerQuadruplets")), - addRemainingTriplets = cms.bool(False), - mergeTriplets = cms.bool(True), - ttrhBuilderLabel = cms.string('PixelTTRHBuilderWithoutAngle') - ) +# temporary... +_lowPtQuadStepHitQuadrupletsMerging.SeedCreatorPSet = cms.PSet( + ComponentName = cms.string("SeedFromConsecutiveHitsCreator"), + MinOneOverPtError = lowPtQuadStepSeeds.MinOneOverPtError, + OriginTransverseErrorMultiplier = lowPtQuadStepSeeds.OriginTransverseErrorMultiplier, + SeedMomentumForBOFF = lowPtQuadStepSeeds.SeedMomentumForBOFF, + TTRHBuilder = lowPtQuadStepSeeds.TTRHBuilder, + forceKinematicWithRegionDirection = lowPtQuadStepSeeds.forceKinematicWithRegionDirection, + magneticField = lowPtQuadStepSeeds.magneticField, + propagator = lowPtQuadStepSeeds.propagator, + ) +_lowPtQuadStepHitQuadrupletsMerging.SeedComparitorPSet = lowPtQuadStepSeeds.SeedComparitorPSet + +trackingPhase1PU70.toModify(lowPtQuadStepHitTriplets, produceIntermediateHitTriplets=False, produceSeedingHitSets=True) +trackingPhase1PU70.toReplaceWith(lowPtQuadStepHitQuadruplets, _lowPtQuadStepHitQuadrupletsMerging) +trackingPhase2PU140.toModify(lowPtQuadStepHitTriplets, produceIntermediateHitTriplets=False, produceSeedingHitSets=True) +trackingPhase2PU140.toReplaceWith(lowPtQuadStepHitQuadruplets, _lowPtQuadStepHitQuadrupletsMerging) # QUALITY CUTS DURING TRACK BUILDING @@ -282,6 +287,10 @@ # Final sequence LowPtQuadStep = cms.Sequence(lowPtQuadStepClusters* lowPtQuadStepSeedLayers* + lowPtQuadStepTrackingRegions* + lowPtQuadStepHitDoublets* + lowPtQuadStepHitTriplets* + lowPtQuadStepHitQuadruplets* lowPtQuadStepSeeds* lowPtQuadStepTrackCandidates* lowPtQuadStepTracks* diff --git a/RecoTracker/IterativeTracking/python/LowPtTripletStep_cff.py b/RecoTracker/IterativeTracking/python/LowPtTripletStep_cff.py index dd2021b03a477..593931479894c 100644 --- a/RecoTracker/IterativeTracking/python/LowPtTripletStep_cff.py +++ b/RecoTracker/IterativeTracking/python/LowPtTripletStep_cff.py @@ -26,8 +26,8 @@ 'BPix1+FPix1_pos+FPix3_pos', 'BPix1+FPix1_neg+FPix3_neg' ] from Configuration.Eras.Modifier_trackingPhase1_cff import trackingPhase1 -trackingPhase1.toModify(lowPtTripletStepSeedLayers, layerList = _layerListForPhase1) from Configuration.Eras.Modifier_trackingPhase1PU70_cff import trackingPhase1PU70 +trackingPhase1.toModify(lowPtTripletStepSeedLayers, layerList = _layerListForPhase1) trackingPhase1PU70.toModify(lowPtTripletStepSeedLayers, layerList = _layerListForPhase1) _layerListForPhase2 = ['BPix1+BPix2+BPix3', 'BPix2+BPix3+BPix4', @@ -46,41 +46,37 @@ from Configuration.Eras.Modifier_trackingPhase2PU140_cff import trackingPhase2PU140 trackingPhase2PU140.toModify(lowPtTripletStepSeedLayers, layerList = _layerListForPhase2) -# SEEDS -import RecoTracker.TkSeedGenerator.GlobalSeedsFromTriplets_cff -from RecoTracker.TkTrackingRegions.GlobalTrackingRegionFromBeamSpot_cfi import RegionPsetFomBeamSpotBlock -lowPtTripletStepSeeds = RecoTracker.TkSeedGenerator.GlobalSeedsFromTriplets_cff.globalSeedsFromTriplets.clone( - RegionFactoryPSet = RegionPsetFomBeamSpotBlock.clone( - ComponentName = cms.string('GlobalRegionProducerFromBeamSpot'), - RegionPSet = RegionPsetFomBeamSpotBlock.RegionPSet.clone( +# TrackingRegion +from RecoTracker.TkTrackingRegions.globalTrackingRegionFromBeamSpot_cfi import globalTrackingRegionFromBeamSpot as _globalTrackingRegionFromBeamSpot +lowPtTripletStepTrackingRegions = _globalTrackingRegionFromBeamSpot.clone(RegionPSet = dict( ptMin = 0.2, originRadius = 0.02, nSigmaZ = 4.0 - ) - ) - ) -lowPtTripletStepSeeds.OrderedHitsFactoryPSet.SeedingLayers = 'lowPtTripletStepSeedLayers' -trackingPhase1.toModify(lowPtTripletStepSeeds, # FIXME: Phase1PU70 value, let's see if we can lower it to Run2 value (0.2) - RegionFactoryPSet = dict(RegionPSet = dict(ptMin = 0.35)), -) -trackingPhase1PU70.toModify(lowPtTripletStepSeeds, - RegionFactoryPSet = dict( - RegionPSet = dict( - ptMin = 0.35, - originRadius = 0.015 - ) - ), -) -trackingPhase2PU140.toModify(lowPtTripletStepSeeds, - ClusterCheckPSet = dict(doClusterCheck = False), - RegionFactoryPSet = dict(RegionPSet = dict(ptMin = 0.45)), - OrderedHitsFactoryPSet = dict( GeneratorPSet = dict(maxElement = 0 ) ), - SeedCreatorPSet = dict( magneticField = '', propagator = 'PropagatorWithMaterial'), -) +)) +trackingPhase1.toModify(lowPtTripletStepTrackingRegions, RegionPSet = dict(ptMin = 0.35)) # FIXME: Phase1PU70 value, let's see if we can lower it to Run2 value (0.2) +trackingPhase1PU70.toModify(lowPtTripletStepTrackingRegions, RegionPSet = dict(ptMin = 0.35, originRadius = 0.015)) +trackingPhase2PU140.toModify(lowPtTripletStepTrackingRegions, RegionPSet = dict(ptMin = 0.45)) +# seeding +from RecoTracker.TkHitPairs.hitPairEDProducer_cfi import hitPairEDProducer as _hitPairEDProducer +lowPtTripletStepHitDoublets = _hitPairEDProducer.clone( + seedingLayers = "lowPtTripletStepSeedLayers", + trackingRegions = "lowPtTripletStepTrackingRegions", + maxElement = 0, + produceIntermediateHitDoublets = True, +) +from RecoPixelVertexing.PixelTriplets.pixelTripletHLTEDProducer_cfi import pixelTripletHLTEDProducer as _pixelTripletHLTEDProducer from RecoPixelVertexing.PixelLowPtUtilities.ClusterShapeHitFilterESProducer_cfi import * import RecoPixelVertexing.PixelLowPtUtilities.LowPtClusterShapeSeedComparitor_cfi -lowPtTripletStepSeeds.OrderedHitsFactoryPSet.GeneratorPSet.SeedComparitorPSet = RecoPixelVertexing.PixelLowPtUtilities.LowPtClusterShapeSeedComparitor_cfi.LowPtClusterShapeSeedComparitor +lowPtTripletStepHitTriplets = _pixelTripletHLTEDProducer.clone( + doublets = "lowPtTripletStepHitDoublets", + produceSeedingHitSets = True, + SeedComparitorPSet = RecoPixelVertexing.PixelLowPtUtilities.LowPtClusterShapeSeedComparitor_cfi.LowPtClusterShapeSeedComparitor +) +from RecoTracker.TkSeedGenerator.seedCreatorFromRegionConsecutiveHitsEDProducer_cff import seedCreatorFromRegionConsecutiveHitsEDProducer as _seedCreatorFromRegionConsecutiveHitsEDProducer +lowPtTripletStepSeeds = _seedCreatorFromRegionConsecutiveHitsEDProducer.clone( + seedingHitSets = "lowPtTripletStepHitTriplets", +) # QUALITY CUTS DURING TRACK BUILDING @@ -333,6 +329,9 @@ # Final sequence LowPtTripletStep = cms.Sequence(lowPtTripletStepClusters* lowPtTripletStepSeedLayers* + lowPtTripletStepTrackingRegions* + lowPtTripletStepHitDoublets* + lowPtTripletStepHitTriplets* lowPtTripletStepSeeds* lowPtTripletStepTrackCandidates* lowPtTripletStepTracks* diff --git a/RecoTracker/IterativeTracking/python/MixedTripletStep_cff.py b/RecoTracker/IterativeTracking/python/MixedTripletStep_cff.py index f27e6e4406787..fdfaff8a3e3d5 100644 --- a/RecoTracker/IterativeTracking/python/MixedTripletStep_cff.py +++ b/RecoTracker/IterativeTracking/python/MixedTripletStep_cff.py @@ -78,41 +78,51 @@ ) ) +# TrackingRegion +from RecoTracker.TkTrackingRegions.globalTrackingRegionFromBeamSpotFixedZ_cfi import globalTrackingRegionFromBeamSpotFixedZ as _globalTrackingRegionFromBeamSpotFixedZ +mixedTripletStepTrackingRegionsA = _globalTrackingRegionFromBeamSpotFixedZ.clone(RegionPSet = dict( + ptMin = 0.4, + originHalfLength = 15.0, + originRadius = 1.5 +)) +trackingLowPU.toModify(mixedTripletStepTrackingRegionsA, RegionPSet = dict(originHalfLength = 10.0)) +trackingPhase1PU70.toModify(mixedTripletStepTrackingRegionsA, RegionPSet = dict(ptMin = 0.7)) -# SEEDS -from RecoPixelVertexing.PixelTriplets.PixelTripletLargeTipGenerator_cfi import * -PixelTripletLargeTipGenerator.extraHitRZtolerance = 0.0 -PixelTripletLargeTipGenerator.extraHitRPhitolerance = 0.0 -import RecoTracker.TkSeedGenerator.GlobalSeedsFromTriplets_cff -mixedTripletStepSeedsA = RecoTracker.TkSeedGenerator.GlobalSeedsFromTriplets_cff.globalSeedsFromTriplets.clone() -mixedTripletStepSeedsA.OrderedHitsFactoryPSet.SeedingLayers = 'mixedTripletStepSeedLayersA' -mixedTripletStepSeedsA.OrderedHitsFactoryPSet.GeneratorPSet = cms.PSet(PixelTripletLargeTipGenerator) -mixedTripletStepSeedsA.SeedCreatorPSet.ComponentName = 'SeedFromConsecutiveHitsTripletOnlyCreator' -mixedTripletStepSeedsA.RegionFactoryPSet.RegionPSet.ptMin = 0.4 -mixedTripletStepSeedsA.RegionFactoryPSet.RegionPSet.originHalfLength = 15.0 -mixedTripletStepSeedsA.RegionFactoryPSet.RegionPSet.originRadius = 1.5 - -import RecoPixelVertexing.PixelLowPtUtilities.ClusterShapeHitFilterESProducer_cfi -mixedTripletStepClusterShapeHitFilter = RecoPixelVertexing.PixelLowPtUtilities.ClusterShapeHitFilterESProducer_cfi.ClusterShapeHitFilterESProducer.clone( - ComponentName = cms.string('mixedTripletStepClusterShapeHitFilter'), - clusterChargeCut = cms.PSet(refToPSet_ = cms.string('SiStripClusterChargeCutTight')) - ) - -mixedTripletStepSeedsA.SeedComparitorPSet = cms.PSet( - ComponentName = cms.string('PixelClusterShapeSeedComparitor'), +# seeding +from RecoPixelVertexing.PixelLowPtUtilities.ClusterShapeHitFilterESProducer_cfi import ClusterShapeHitFilterESProducer as _ClusterShapeHitFilterESProducer +mixedTripletStepClusterShapeHitFilter = _ClusterShapeHitFilterESProducer.clone( + ComponentName = 'mixedTripletStepClusterShapeHitFilter', + clusterChargeCut = dict(refToPSet_ = 'SiStripClusterChargeCutTight') +) +from RecoTracker.TkHitPairs.hitPairEDProducer_cfi import hitPairEDProducer as _hitPairEDProducer +mixedTripletStepHitDoubletsA = _hitPairEDProducer.clone( + seedingLayers = "mixedTripletStepSeedLayersA", + trackingRegions = "mixedTripletStepTrackingRegionsA", + maxElement = 0, + produceIntermediateHitDoublets = True, +) +from RecoPixelVertexing.PixelTriplets.pixelTripletLargeTipEDProducer_cfi import pixelTripletLargeTipEDProducer as _pixelTripletLargeTipEDProducer +from RecoPixelVertexing.PixelLowPtUtilities.ClusterShapeHitFilterESProducer_cfi import * +mixedTripletStepHitTripletsA = _pixelTripletLargeTipEDProducer.clone( + doublets = "mixedTripletStepHitDoubletsA", + produceSeedingHitSets = True, +) +from RecoTracker.TkSeedGenerator.seedCreatorFromRegionConsecutiveHitsTripletOnlyEDProducer_cff import seedCreatorFromRegionConsecutiveHitsTripletOnlyEDProducer as _seedCreatorFromRegionConsecutiveHitsTripletOnlyEDProducer +mixedTripletStepSeedsA = _seedCreatorFromRegionConsecutiveHitsTripletOnlyEDProducer.clone( + seedingHitSets = "mixedTripletStepHitTripletsA", + SeedComparitorPSet = dict(# FIXME: is this defined in any cfi that could be imported instead of copy-paste? + ComponentName = 'PixelClusterShapeSeedComparitor', FilterAtHelixStage = cms.bool(False), FilterPixelHits = cms.bool(True), FilterStripHits = cms.bool(True), ClusterShapeHitFilterName = cms.string('mixedTripletStepClusterShapeHitFilter'), ClusterShapeCacheSrc = cms.InputTag('siPixelClusterShapeCache') - ) + ), +) trackingLowPU.toModify(mixedTripletStepSeedsA, - RegionFactoryPSet = dict(RegionPSet = dict(originHalfLength = 10.0)), SeedComparitorPSet = dict(ClusterShapeHitFilterName = 'ClusterShapeHitFilter') ) -trackingPhase1PU70.toModify( - mixedTripletStepSeedsA, - RegionFactoryPSet = dict(RegionPSet = dict(ptMin = 0.7)), +trackingPhase1PU70.toModify(mixedTripletStepSeedsA, SeedComparitorPSet = dict(ClusterShapeHitFilterName = 'ClusterShapeHitFilter'), ) @@ -142,40 +152,21 @@ TIB = None ) -# SEEDS -from RecoPixelVertexing.PixelTriplets.PixelTripletLargeTipGenerator_cfi import * -PixelTripletLargeTipGenerator.extraHitRZtolerance = 0.0 -PixelTripletLargeTipGenerator.extraHitRPhitolerance = 0.0 -import RecoTracker.TkSeedGenerator.GlobalSeedsFromTriplets_cff -mixedTripletStepSeedsB = RecoTracker.TkSeedGenerator.GlobalSeedsFromTriplets_cff.globalSeedsFromTriplets.clone() -mixedTripletStepSeedsB.OrderedHitsFactoryPSet.SeedingLayers = 'mixedTripletStepSeedLayersB' -mixedTripletStepSeedsB.OrderedHitsFactoryPSet.GeneratorPSet = cms.PSet(PixelTripletLargeTipGenerator) -mixedTripletStepSeedsB.SeedCreatorPSet.ComponentName = 'SeedFromConsecutiveHitsTripletOnlyCreator' -mixedTripletStepSeedsB.RegionFactoryPSet.RegionPSet.ptMin = 0.6 -mixedTripletStepSeedsB.RegionFactoryPSet.RegionPSet.originHalfLength = 10.0 -mixedTripletStepSeedsB.RegionFactoryPSet.RegionPSet.originRadius = 1.5 +# TrackingRegion +mixedTripletStepTrackingRegionsB = mixedTripletStepTrackingRegionsA.clone(RegionPSet = dict(ptMin=0.6, originHalfLength=10.0)) +trackingPhase1PU70.toModify(mixedTripletStepTrackingRegionsB, RegionPSet = dict( + ptMin = 0.5, + originHalfLength = 15.0, + originRadius = 1.0 +)) -mixedTripletStepSeedsB.SeedComparitorPSet = cms.PSet( - ComponentName = cms.string('PixelClusterShapeSeedComparitor'), - FilterAtHelixStage = cms.bool(False), - FilterPixelHits = cms.bool(True), - FilterStripHits = cms.bool(True), - ClusterShapeHitFilterName = cms.string('mixedTripletStepClusterShapeHitFilter'), - ClusterShapeCacheSrc = cms.InputTag('siPixelClusterShapeCache') - ) -trackingLowPU.toModify(mixedTripletStepSeedsB, SeedComparitorPSet = dict(ClusterShapeHitFilterName = 'ClusterShapeHitFilter')) -trackingPhase1PU70.toModify( - mixedTripletStepSeedsB, - RegionFactoryPSet = dict( - RegionPSet = dict( - ptMin = 0.5, - originHalfLength = 15.0, - originRadius = 1.0 - ) - ), - SeedComparitorPSet = dict(ClusterShapeHitFilterName = 'ClusterShapeHitFilter'), +# seeding +mixedTripletStepHitDoubletsB = mixedTripletStepHitDoubletsA.clone( + seedingLayers = "mixedTripletStepSeedLayersB", + trackingRegions = "mixedTripletStepTrackingRegionsB", ) - +mixedTripletStepHitTripletsB = mixedTripletStepHitTripletsA.clone(doublets = "mixedTripletStepHitDoubletsB") +mixedTripletStepSeedsB = mixedTripletStepSeedsA.clone(seedingHitSets = "mixedTripletStepHitTripletsB") import RecoTracker.TkSeedGenerator.GlobalCombinedSeeds_cfi mixedTripletStepSeeds = RecoTracker.TkSeedGenerator.GlobalCombinedSeeds_cfi.globalCombinedSeeds.clone() @@ -486,8 +477,14 @@ MixedTripletStep = cms.Sequence(chargeCut2069Clusters*mixedTripletStepClusters* mixedTripletStepSeedLayersA* + mixedTripletStepTrackingRegionsA* + mixedTripletStepHitDoubletsA* + mixedTripletStepHitTripletsA* mixedTripletStepSeedsA* mixedTripletStepSeedLayersB* + mixedTripletStepTrackingRegionsB* + mixedTripletStepHitDoubletsB* + mixedTripletStepHitTripletsB* mixedTripletStepSeedsB* mixedTripletStepSeeds* mixedTripletStepTrackCandidates* diff --git a/RecoTracker/IterativeTracking/python/PixelLessStep_cff.py b/RecoTracker/IterativeTracking/python/PixelLessStep_cff.py index 3c50e772fad66..69bb2a7398b4e 100644 --- a/RecoTracker/IterativeTracking/python/PixelLessStep_cff.py +++ b/RecoTracker/IterativeTracking/python/PixelLessStep_cff.py @@ -98,33 +98,48 @@ MTEC = None, ) -# SEEDS -import RecoTracker.TkSeedGenerator.GlobalSeedsFromTriplets_cff -pixelLessStepSeeds = RecoTracker.TkSeedGenerator.GlobalSeedsFromTriplets_cff.globalSeedsFromTriplets.clone() -#OrderedHitsFactory -pixelLessStepSeeds.OrderedHitsFactoryPSet.SeedingLayers = 'pixelLessStepSeedLayers' -pixelLessStepSeeds.OrderedHitsFactoryPSet.ComponentName = 'StandardMultiHitGenerator' -import RecoTracker.TkSeedGenerator.MultiHitGeneratorFromChi2_cfi -pixelLessStepSeeds.OrderedHitsFactoryPSet.GeneratorPSet = RecoTracker.TkSeedGenerator.MultiHitGeneratorFromChi2_cfi.MultiHitGeneratorFromChi2.clone() -#SeedCreator -pixelLessStepSeeds.SeedCreatorPSet.ComponentName = 'SeedFromConsecutiveHitsTripletOnlyCreator' -#RegionFactory -pixelLessStepSeeds.RegionFactoryPSet.RegionPSet.ptMin = 0.4 -pixelLessStepSeeds.RegionFactoryPSet.RegionPSet.originHalfLength = 12.0 -pixelLessStepSeeds.RegionFactoryPSet.RegionPSet.originRadius = 1.0 -#SeedComparitor -import RecoPixelVertexing.PixelLowPtUtilities.ClusterShapeHitFilterESProducer_cfi -pixelLessStepClusterShapeHitFilter = RecoPixelVertexing.PixelLowPtUtilities.ClusterShapeHitFilterESProducer_cfi.ClusterShapeHitFilterESProducer.clone( - ComponentName = cms.string('pixelLessStepClusterShapeHitFilter'), - doStripShapeCut = cms.bool(False), - clusterChargeCut = cms.PSet(refToPSet_ = cms.string('SiStripClusterChargeCutTight')) - ) -import RecoPixelVertexing.PixelLowPtUtilities.StripSubClusterShapeSeedFilter_cfi -pixelLessStepSeeds.SeedComparitorPSet = cms.PSet( - ComponentName = cms.string('CombinedSeedComparitor'), +# TrackingRegion +from RecoTracker.TkTrackingRegions.globalTrackingRegionFromBeamSpotFixedZ_cfi import globalTrackingRegionFromBeamSpotFixedZ as _globalTrackingRegionFromBeamSpotFixedZ +pixelLessStepTrackingRegions = _globalTrackingRegionFromBeamSpotFixedZ.clone(RegionPSet = dict( + ptMin = 0.4, + originHalfLength = 12.0, + originRadius = 1.0 +)) +trackingLowPU.toModify(pixelLessStepTrackingRegions, RegionPSet = dict( + ptMin = 0.7, + originHalfLength = 10.0, + originRadius = 2.0, +)) + + +# seeding +from RecoPixelVertexing.PixelLowPtUtilities.ClusterShapeHitFilterESProducer_cfi import ClusterShapeHitFilterESProducer as _ClusterShapeHitFilterESProducer +pixelLessStepClusterShapeHitFilter = _ClusterShapeHitFilterESProducer.clone( + ComponentName = 'pixelLessStepClusterShapeHitFilter', + doStripShapeCut = cms.bool(False), + clusterChargeCut = dict(refToPSet_ = 'SiStripClusterChargeCutTight') +) + +from RecoTracker.TkHitPairs.hitPairEDProducer_cfi import hitPairEDProducer as _hitPairEDProducer +pixelLessStepHitDoublets = _hitPairEDProducer.clone( + seedingLayers = "pixelLessStepSeedLayers", + trackingRegions = "pixelLessStepTrackingRegions", + maxElement = 0, + produceIntermediateHitDoublets = True, +) +from RecoTracker.TkSeedGenerator.multiHitFromChi2EDProducer_cfi import multiHitFromChi2EDProducer as _multiHitFromChi2EDProducer +pixelLessStepHitTriplets = _multiHitFromChi2EDProducer.clone( + doublets = "pixelLessStepHitDoublets", +) +from RecoTracker.TkSeedGenerator.seedCreatorFromRegionConsecutiveHitsTripletOnlyEDProducer_cff import seedCreatorFromRegionConsecutiveHitsTripletOnlyEDProducer as _seedCreatorFromRegionConsecutiveHitsTripletOnlyEDProducer +from RecoPixelVertexing.PixelLowPtUtilities.StripSubClusterShapeSeedFilter_cfi import StripSubClusterShapeSeedFilter as _StripSubClusterShapeSeedFilter +pixelLessStepSeeds = _seedCreatorFromRegionConsecutiveHitsTripletOnlyEDProducer.clone( + seedingHitSets = "pixelLessStepHitTriplets", + SeedComparitorPSet = dict( + ComponentName = 'CombinedSeedComparitor', mode = cms.string("and"), comparitors = cms.VPSet( - cms.PSet( + cms.PSet(# FIXME: is this defined in any cfi that could be imported instead of copy-paste? ComponentName = cms.string('PixelClusterShapeSeedComparitor'), FilterAtHelixStage = cms.bool(True), FilterPixelHits = cms.bool(False), @@ -132,26 +147,22 @@ ClusterShapeHitFilterName = cms.string('pixelLessStepClusterShapeHitFilter'), ClusterShapeCacheSrc = cms.InputTag("siPixelClusterShapeCache") # not really needed here since FilterPixelHits=False ), - RecoPixelVertexing.PixelLowPtUtilities.StripSubClusterShapeSeedFilter_cfi.StripSubClusterShapeSeedFilter.clone() + _StripSubClusterShapeSeedFilter.clone() ) ) -import RecoTracker.TkSeedGenerator.GlobalMixedSeeds_cff -trackingLowPU.toReplaceWith(pixelLessStepSeeds, RecoTracker.TkSeedGenerator.GlobalMixedSeeds_cff.globalMixedSeeds.clone( - OrderedHitsFactoryPSet = dict(SeedingLayers = 'pixelLessStepSeedLayers'), - RegionFactoryPSet = dict(RegionPSet = dict( - ptMin = 0.7, - originHalfLength = 10.0, - originRadius = 2.0, - )), - SeedComparitorPSet = cms.PSet( - ComponentName = cms.string('PixelClusterShapeSeedComparitor'), +) +trackingLowPU.toModify(pixelLessStepHitDoublets, produceSeedingHitSets=True, produceIntermediateHitDoublets=False) +trackingLowPU.toModify(pixelLessStepSeeds, + seedingHitSets = "pixelLessStepHitDoublets", + SeedComparitorPSet = dict(# FIXME: is this defined in any cfi that could be imported instead of copy-paste? + ComponentName = 'PixelClusterShapeSeedComparitor', FilterAtHelixStage = cms.bool(True), FilterPixelHits = cms.bool(False), FilterStripHits = cms.bool(True), ClusterShapeHitFilterName = cms.string('ClusterShapeHitFilter'), ClusterShapeCacheSrc = cms.InputTag("siPixelClusterShapeCache") # not really needed here since FilterPixelHits=False ) -)) +) # QUALITY CUTS DURING TRACK BUILDING @@ -289,11 +300,14 @@ PixelLessStep = cms.Sequence(pixelLessStepClusters* pixelLessStepSeedLayers* + pixelLessStepTrackingRegions* + pixelLessStepHitDoublets* + pixelLessStepHitTriplets* pixelLessStepSeeds* pixelLessStepTrackCandidates* pixelLessStepTracks* pixelLessStepClassifier1*pixelLessStepClassifier2* pixelLessStep) -_PixelLessStep_LowPU = PixelLessStep.copyAndExclude([pixelLessStepClassifier1, pixelLessStepClassifier2]) +_PixelLessStep_LowPU = PixelLessStep.copyAndExclude([pixelLessStepHitTriplets, pixelLessStepClassifier1, pixelLessStepClassifier2]) _PixelLessStep_LowPU.replace(pixelLessStep, pixelLessStepSelector) trackingLowPU.toReplaceWith(PixelLessStep, _PixelLessStep_LowPU) diff --git a/RecoTracker/IterativeTracking/python/PixelPairStep_cff.py b/RecoTracker/IterativeTracking/python/PixelPairStep_cff.py index 583a25d6d1904..575429dd78529 100644 --- a/RecoTracker/IterativeTracking/python/PixelPairStep_cff.py +++ b/RecoTracker/IterativeTracking/python/PixelPairStep_cff.py @@ -65,51 +65,37 @@ ) ) -# SEEDS -import RecoTracker.TkSeedGenerator.GlobalSeedsFromPairsWithVertices_cff -pixelPairStepSeeds = RecoTracker.TkSeedGenerator.GlobalSeedsFromPairsWithVertices_cff.globalSeedsFromPairsWithVertices.clone() -pixelPairStepSeeds.RegionFactoryPSet.RegionPSet.VertexCollection = cms.InputTag("firstStepPrimaryVertices") -pixelPairStepSeeds.RegionFactoryPSet.RegionPSet.ptMin = 0.6 -pixelPairStepSeeds.RegionFactoryPSet.RegionPSet.originRadius = 0.015 -pixelPairStepSeeds.RegionFactoryPSet.RegionPSet.fixedError = 0.03 -pixelPairStepSeeds.RegionFactoryPSet.RegionPSet.useMultipleScattering = True -pixelPairStepSeeds.OrderedHitsFactoryPSet.SeedingLayers = cms.InputTag('pixelPairStepSeedLayers') +# TrackingRegion +from RecoTracker.TkTrackingRegions.globalTrackingRegionWithVertices_cff import globalTrackingRegionWithVertices as _globalTrackingRegionWithVertices +pixelPairStepTrackingRegions = _globalTrackingRegionWithVertices.clone(RegionPSet = dict( + ptMin = 0.6, + originRadius = 0.015, + fixedError = 0.03, + useMultipleScattering = True, +)) +from Configuration.Eras.Modifier_trackingLowPU_cff import trackingLowPU +trackingLowPU.toModify(pixelPairStepTrackingRegions, RegionPSet=dict(useMultipleScattering=False)) +trackingPhase1PU70.toModify(pixelPairStepTrackingRegions, RegionPSet=dict(ptMin = 1.2, useMultipleScattering=False)) +trackingPhase2PU140.toModify(pixelPairStepTrackingRegions, RegionPSet=dict(ptMin = 1.3, useMultipleScattering=False)) -pixelPairStepSeeds.SeedComparitorPSet = cms.PSet( - ComponentName = cms.string('PixelClusterShapeSeedComparitor'), +# SEEDS +from RecoTracker.TkHitPairs.hitPairEDProducer_cfi import hitPairEDProducer as _hitPairEDProducer +pixelPairStepHitDoublets = _hitPairEDProducer.clone( + seedingLayers = "pixelPairStepSeedLayers", + trackingRegions = "pixelPairStepTrackingRegions", + produceSeedingHitSets = True, +) +from RecoTracker.TkSeedGenerator.seedCreatorFromRegionConsecutiveHitsEDProducer_cff import seedCreatorFromRegionConsecutiveHitsEDProducer as _seedCreatorFromRegionConsecutiveHitsEDProducer +pixelPairStepSeeds = _seedCreatorFromRegionConsecutiveHitsEDProducer.clone( + seedingHitSets = "pixelPairStepHitDoublets", + SeedComparitorPSet = dict(# FIXME: is this defined in any cfi that could be imported instead of copy-paste? + ComponentName = 'PixelClusterShapeSeedComparitor', FilterAtHelixStage = cms.bool(True), FilterPixelHits = cms.bool(True), FilterStripHits = cms.bool(False), ClusterShapeHitFilterName = cms.string('ClusterShapeHitFilter'), ClusterShapeCacheSrc = cms.InputTag('siPixelClusterShapeCache'), ) -from Configuration.Eras.Modifier_trackingLowPU_cff import trackingLowPU -trackingLowPU.toModify(pixelPairStepSeeds, - RegionFactoryPSet = dict(RegionPSet = dict( - VertexCollection = 'pixelVertices', - useMultipleScattering = False - )) -) -trackingPhase1PU70.toModify(pixelPairStepSeeds, - RegionFactoryPSet = dict( - RegionPSet = dict( - ptMin = 1.2, - useMultipleScattering = False, - VertexCollection = "pixelVertices", - ) - ), -) -trackingPhase2PU140.toModify(pixelPairStepSeeds, - RegionFactoryPSet = dict( - RegionPSet = dict( - ptMin = 1.3, - useMultipleScattering = False, - VertexCollection = "pixelVertices", - ) - ), - ClusterCheckPSet = dict(doClusterCheck = False), - OrderedHitsFactoryPSet = dict( maxElement = 0 ), - SeedCreatorPSet = dict( magneticField = '', propagator = 'PropagatorWithMaterial'), ) # QUALITY CUTS DURING TRACK BUILDING @@ -335,6 +321,8 @@ # Final sequence PixelPairStep = cms.Sequence(pixelPairStepClusters* pixelPairStepSeedLayers* + pixelPairStepTrackingRegions* + pixelPairStepHitDoublets* pixelPairStepSeeds* pixelPairStepTrackCandidates* pixelPairStepTracks* diff --git a/RecoTracker/IterativeTracking/python/TobTecStep_cff.py b/RecoTracker/IterativeTracking/python/TobTecStep_cff.py index aeb912483fb06..b3b9ddb072761 100644 --- a/RecoTracker/IterativeTracking/python/TobTecStep_cff.py +++ b/RecoTracker/IterativeTracking/python/TobTecStep_cff.py @@ -37,41 +37,58 @@ maxRing = cms.int32(7) ) ) -# TRIPLET SEEDS -import RecoTracker.TkSeedGenerator.GlobalSeedsFromTriplets_cff -tobTecStepSeedsTripl = RecoTracker.TkSeedGenerator.GlobalSeedsFromTriplets_cff.globalSeedsFromTriplets.clone() -#OrderedHitsFactory -tobTecStepSeedsTripl.OrderedHitsFactoryPSet.SeedingLayers = 'tobTecStepSeedLayersTripl' -tobTecStepSeedsTripl.OrderedHitsFactoryPSet.ComponentName = 'StandardMultiHitGenerator' -import RecoTracker.TkSeedGenerator.MultiHitGeneratorFromChi2_cfi -tobTecStepSeedsTripl.OrderedHitsFactoryPSet.GeneratorPSet = RecoTracker.TkSeedGenerator.MultiHitGeneratorFromChi2_cfi.MultiHitGeneratorFromChi2.clone( - extraPhiKDBox = 0.01 + +# Triplet TrackingRegion +from RecoTracker.TkTrackingRegions.globalTrackingRegionFromBeamSpotFixedZ_cfi import globalTrackingRegionFromBeamSpotFixedZ as _globalTrackingRegionFromBeamSpotFixedZ +tobTecStepTrackingRegionsTripl = _globalTrackingRegionFromBeamSpotFixedZ.clone(RegionPSet = dict( + ptMin = 0.55, + originHalfLength = 20.0, + originRadius = 3.5 +)) + +# Triplet seeding +from RecoPixelVertexing.PixelLowPtUtilities.ClusterShapeHitFilterESProducer_cfi import ClusterShapeHitFilterESProducer as _ClusterShapeHitFilterESProducer +tobTecStepClusterShapeHitFilter = _ClusterShapeHitFilterESProducer.clone( + ComponentName = 'tobTecStepClusterShapeHitFilter', + doStripShapeCut = cms.bool(False), + clusterChargeCut = dict(refToPSet_ = 'SiStripClusterChargeCutTight') +) + +from RecoTracker.TkHitPairs.hitPairEDProducer_cfi import hitPairEDProducer as _hitPairEDProducer +tobTecStepHitDoubletsTripl = _hitPairEDProducer.clone( + seedingLayers = "tobTecStepSeedLayersTripl", + trackingRegions = "tobTecStepTrackingRegionsTripl", + maxElement = 0, + produceIntermediateHitDoublets = True, +) +from RecoTracker.TkSeedGenerator.multiHitFromChi2EDProducer_cfi import multiHitFromChi2EDProducer as _multiHitFromChi2EDProducer +tobTecStepHitTripletsTripl = _multiHitFromChi2EDProducer.clone( + doublets = "tobTecStepHitDoubletsTripl", + extraPhiKDBox = 0.01, +) +from RecoTracker.TkSeedGenerator.seedCreatorFromRegionConsecutiveHitsEDProducer_cff import seedCreatorFromRegionConsecutiveHitsEDProducer as _seedCreatorFromRegionConsecutiveHitsTripletOnlyEDProducer +from RecoPixelVertexing.PixelLowPtUtilities.StripSubClusterShapeSeedFilter_cfi import StripSubClusterShapeSeedFilter as _StripSubClusterShapeSeedFilter +_tobTecStepSeedComparitorPSet = dict( + ComponentName = 'CombinedSeedComparitor', + mode = cms.string("and"), + comparitors = cms.VPSet( + cms.PSet(# FIXME: is this defined in any cfi that could be imported instead of copy-paste? + ComponentName = cms.string('PixelClusterShapeSeedComparitor'), + FilterAtHelixStage = cms.bool(True), + FilterPixelHits = cms.bool(False), + FilterStripHits = cms.bool(True), + ClusterShapeHitFilterName = cms.string('tobTecStepClusterShapeHitFilter'), + ClusterShapeCacheSrc = cms.InputTag("siPixelClusterShapeCache") # not really needed here since FilterPixelHits=False + ), + _StripSubClusterShapeSeedFilter.clone() ) -#RegionFactory -tobTecStepSeedsTripl.RegionFactoryPSet.RegionPSet.ptMin = 0.55 -tobTecStepSeedsTripl.RegionFactoryPSet.RegionPSet.originHalfLength = 20.0 -tobTecStepSeedsTripl.RegionFactoryPSet.RegionPSet.originRadius = 3.5 -#SeedCreator -tobTecStepSeedsTripl.SeedCreatorPSet.ComponentName = 'SeedFromConsecutiveHitsCreator' #empirically better than 'SeedFromConsecutiveHitsTripletOnlyCreator' -tobTecStepSeedsTripl.SeedCreatorPSet.OriginTransverseErrorMultiplier = 1.0 -#SeedComparitor -import RecoPixelVertexing.PixelLowPtUtilities.StripSubClusterShapeSeedFilter_cfi - -tobTecStepSeedsTripl.SeedComparitorPSet = cms.PSet( - ComponentName = cms.string('CombinedSeedComparitor'), - mode = cms.string("and"), - comparitors = cms.VPSet( - cms.PSet( - ComponentName = cms.string('PixelClusterShapeSeedComparitor'), - FilterAtHelixStage = cms.bool(True), - FilterPixelHits = cms.bool(False), - FilterStripHits = cms.bool(True), - ClusterShapeHitFilterName = cms.string('tobTecStepClusterShapeHitFilter'), - ClusterShapeCacheSrc = cms.InputTag("siPixelClusterShapeCache") # not really needed here since FilterPixelHits=False - ), - RecoPixelVertexing.PixelLowPtUtilities.StripSubClusterShapeSeedFilter_cfi.StripSubClusterShapeSeedFilter.clone() - ) ) +tobTecStepSeedsTripl = _seedCreatorFromRegionConsecutiveHitsTripletOnlyEDProducer.clone(#empirically better than 'SeedFromConsecutiveHitsTripletOnlyCreator' + seedingHitSets = "tobTecStepHitTripletsTripl", + SeedComparitorPSet = _tobTecStepSeedComparitorPSet, +) + + # PAIR SEEDING LAYERS tobTecStepSeedLayersPair = cms.EDProducer("SeedingLayersEDProducer", layerList = cms.vstring('TOB1+TEC1_pos','TOB1+TEC1_neg', @@ -95,68 +112,47 @@ maxRing = cms.int32(5) ) ) -# PAIR SEEDS -import RecoPixelVertexing.PixelLowPtUtilities.ClusterShapeHitFilterESProducer_cfi -tobTecStepClusterShapeHitFilter = RecoPixelVertexing.PixelLowPtUtilities.ClusterShapeHitFilterESProducer_cfi.ClusterShapeHitFilterESProducer.clone( - ComponentName = cms.string('tobTecStepClusterShapeHitFilter'), - clusterChargeCut = cms.PSet(refToPSet_ = cms.string('SiStripClusterChargeCutTight')), - doStripShapeCut = cms.bool(False) - ) - -import RecoTracker.TkSeedGenerator.GlobalMixedSeeds_cff -tobTecStepSeedsPair = RecoTracker.TkSeedGenerator.GlobalMixedSeeds_cff.globalMixedSeeds.clone() -#OrderedHitsFactory -tobTecStepSeedsPair.OrderedHitsFactoryPSet.ComponentName = cms.string('StandardHitPairGenerator') -tobTecStepSeedsPair.OrderedHitsFactoryPSet.SeedingLayers = 'tobTecStepSeedLayersPair' -#RegionFactory -tobTecStepSeedsPair.RegionFactoryPSet.RegionPSet.ptMin = 0.6 -tobTecStepSeedsPair.RegionFactoryPSet.RegionPSet.originHalfLength = 30.0 -tobTecStepSeedsPair.RegionFactoryPSet.RegionPSet.originRadius = 6.0 -#SeedCreator -tobTecStepSeedsPair.SeedCreatorPSet.OriginTransverseErrorMultiplier = 1.0 -#SeedComparitor -tobTecStepSeedsPair.SeedComparitorPSet = cms.PSet( - ComponentName = cms.string('CombinedSeedComparitor'), - mode = cms.string("and"), - comparitors = cms.VPSet( - cms.PSet( - ComponentName = cms.string('PixelClusterShapeSeedComparitor'), - FilterAtHelixStage = cms.bool(True), - FilterPixelHits = cms.bool(False), - FilterStripHits = cms.bool(True), - ClusterShapeHitFilterName = cms.string('tobTecStepClusterShapeHitFilter'), - ClusterShapeCacheSrc = cms.InputTag("siPixelClusterShapeCache") # not really needed here since FilterPixelHits=False - ), - RecoPixelVertexing.PixelLowPtUtilities.StripSubClusterShapeSeedFilter_cfi.StripSubClusterShapeSeedFilter.clone() - ) +# Pair TrackingRegion +tobTecStepTrackingRegionsPair = _globalTrackingRegionFromBeamSpotFixedZ.clone(RegionPSet = dict( + ptMin = 0.6, + originHalfLength = 30.0, + originRadius = 6.0, +)) + +# Pair seeds +tobTecStepHitDoubletsPair = _hitPairEDProducer.clone( + seedingLayers = "tobTecStepSeedLayersPair", + trackingRegions = "tobTecStepTrackingRegionsPair", + produceSeedingHitSets = True, ) +from RecoTracker.TkSeedGenerator.seedCreatorFromRegionConsecutiveHitsEDProducer_cff import seedCreatorFromRegionConsecutiveHitsEDProducer as _seedCreatorFromRegionConsecutiveHitsEDProducer +tobTecStepSeedsPair = _seedCreatorFromRegionConsecutiveHitsEDProducer.clone( + seedingHitSets = "tobTecStepHitDoubletsPair", + SeedComparitorPSet = _tobTecStepSeedComparitorPSet, +) + +# Combined seeds import RecoTracker.TkSeedGenerator.GlobalCombinedSeeds_cfi tobTecStepSeeds = RecoTracker.TkSeedGenerator.GlobalCombinedSeeds_cfi.globalCombinedSeeds.clone() tobTecStepSeeds.seedCollections = cms.VInputTag(cms.InputTag('tobTecStepSeedsTripl'),cms.InputTag('tobTecStepSeedsPair')) + # LowPU -import RecoTracker.TkSeedGenerator.GlobalMixedSeeds_cff from Configuration.Eras.Modifier_trackingLowPU_cff import trackingLowPU -trackingLowPU.toReplaceWith(tobTecStepSeeds, RecoTracker.TkSeedGenerator.GlobalMixedSeeds_cff.globalMixedSeeds.clone( - OrderedHitsFactoryPSet = dict(SeedingLayers = 'tobTecStepSeedLayers'), - RegionFactoryPSet = dict(RegionPSet = dict( - ptMin = 0.6, - originHalfLength = 30.0, - originRadius = 6.0, - )) +trackingLowPU.toModify(tobTecStepHitDoubletsPair, seedingLayers = 'tobTecStepSeedLayers') +trackingLowPU.toReplaceWith(tobTecStepSeeds, _seedCreatorFromRegionConsecutiveHitsEDProducer.clone( + seedingHitSets = "tobTecStepHitDoubletsPair", )) # Phase1PU70 from Configuration.Eras.Modifier_trackingPhase1PU70_cff import trackingPhase1PU70 -trackingPhase1PU70.toReplaceWith(tobTecStepSeeds, RecoTracker.TkSeedGenerator.GlobalMixedSeeds_cff.globalMixedSeeds.clone( - OrderedHitsFactoryPSet = dict(SeedingLayers = 'tobTecStepSeedLayers'), - RegionFactoryPSet = dict( - RegionPSet = dict( - ptMin = 1.0, - originHalfLength = 15.0, - originRadius = 2.0 - ) - ), - SeedCreatorPSet = dict(OriginTransverseErrorMultiplier = 3.0), - SeedComparitorPSet = cms.PSet( +trackingPhase1PU70.toModify(tobTecStepTrackingRegionsPair, RegionPSet = dict( + ptMin = 1.0, + originHalfLength = 15.0, + originRadius = 2.0 +)) +trackingPhase1PU70.toModify(tobTecStepHitDoubletsPair, seedingLayers = 'tobTecStepSeedLayers') +trackingPhase1PU70.toReplaceWith(tobTecStepSeeds, tobTecStepSeedsPair.clone( + OriginTransverseErrorMultiplier = 3.0, + SeedComparitorPSet = cms.PSet(# FIXME: is this defined in any cfi that could be imported instead of copy-paste? ComponentName = cms.string('PixelClusterShapeSeedComparitor'), FilterAtHelixStage = cms.bool(True), FilterPixelHits = cms.bool(False), @@ -386,8 +382,13 @@ TobTecStep = cms.Sequence(tobTecStepClusters* tobTecStepSeedLayersTripl* + tobTecStepTrackingRegionsTripl* + tobTecStepHitDoubletsTripl* + tobTecStepHitTripletsTripl* tobTecStepSeedsTripl* tobTecStepSeedLayersPair* + tobTecStepTrackingRegionsPair* + tobTecStepHitDoubletsPair* tobTecStepSeedsPair* tobTecStepSeeds* tobTecStepTrackCandidates* @@ -498,6 +499,8 @@ trackingLowPU.toReplaceWith(TobTecStep, cms.Sequence( tobTecStepClusters* tobTecStepSeedLayers* + tobTecStepTrackingRegionsPair* + tobTecStepHitDoubletsPair* tobTecStepSeeds* tobTecStepTrackCandidates* tobTecStepTracks* @@ -507,6 +510,8 @@ tobTecStepClusters* tobTecStepSeedClusters* tobTecStepSeedLayers* + tobTecStepTrackingRegionsPair* + tobTecStepHitDoubletsPair* tobTecStepSeeds* tobTecStepTrackCandidates* tobTecStepTracks* diff --git a/RecoTracker/IterativeTracking/python/iterativeTk_cff.py b/RecoTracker/IterativeTracking/python/iterativeTk_cff.py index 96bed179754aa..c0cb95230708a 100644 --- a/RecoTracker/IterativeTracking/python/iterativeTk_cff.py +++ b/RecoTracker/IterativeTracking/python/iterativeTk_cff.py @@ -1,4 +1,5 @@ import FWCore.ParameterSet.Config as cms +from RecoTracker.TkSeedGenerator.trackerClusterCheck_cfi import * from RecoTracker.IterativeTracking.InitialStepPreSplitting_cff import * from RecoTracker.IterativeTracking.InitialStep_cff import * @@ -28,6 +29,7 @@ _era.toReplaceWith(iterTrackingEarly, _cfg.createEarlySequence(_eraName, _postfix, globals())) iterTracking = cms.Sequence(InitialStepPreSplitting* + trackerClusterCheck* iterTrackingEarly* earlyGeneralTracks* muonSeededStep* diff --git a/RecoTracker/SpecialSeedGenerators/interface/CosmicTrackingRegion.h b/RecoTracker/SpecialSeedGenerators/interface/CosmicTrackingRegion.h index fc2d55f71cb0d..bdb19bfcd5933 100644 --- a/RecoTracker/SpecialSeedGenerators/interface/CosmicTrackingRegion.h +++ b/RecoTracker/SpecialSeedGenerators/interface/CosmicTrackingRegion.h @@ -84,13 +84,11 @@ class CosmicTrackingRegion : public TrackingRegionBase { virtual TrackingRegion::ctfHits hits( - const edm::Event& ev, const edm::EventSetup& es, const ctfseeding::SeedingLayer* layer) const; TrackingRegion::Hits hits( - const edm::Event& ev, const edm::EventSetup& es, const SeedingLayerSetsHits::SeedingLayer& layer) const override; @@ -108,7 +106,6 @@ class CosmicTrackingRegion : public TrackingRegionBase { private: template void hits_( - const edm::Event& ev, const edm::EventSetup& es, const T& layer, TrackingRegion::Hits & result) const; diff --git a/RecoTracker/SpecialSeedGenerators/src/BeamHaloPairGenerator.cc b/RecoTracker/SpecialSeedGenerators/src/BeamHaloPairGenerator.cc index d111a7eb029c6..ba496d01b48b5 100644 --- a/RecoTracker/SpecialSeedGenerators/src/BeamHaloPairGenerator.cc +++ b/RecoTracker/SpecialSeedGenerators/src/BeamHaloPairGenerator.cc @@ -26,8 +26,8 @@ const OrderedSeedingHits& BeamHaloPairGenerator::run(const TrackingRegion& regio if(layers.numberOfLayersInSet() != 2) throw cms::Exception("CtfSpecialSeedGenerator") << "You are using " << layers.numberOfLayersInSet() <<" layers in set instead of 2 "; for(SeedingLayerSetsHits::SeedingLayerSet ls: layers) { - auto innerHits = region.hits(e, es, ls[0]); - auto outerHits = region.hits(e, es, ls[1]); + auto innerHits = region.hits(es, ls[0]); + auto outerHits = region.hits(es, ls[1]); for (auto iOuterHit = outerHits.begin(); iOuterHit != outerHits.end(); iOuterHit++){ for (auto iInnerHit = innerHits.begin(); iInnerHit != innerHits.end(); iInnerHit++){ diff --git a/RecoTracker/SpecialSeedGenerators/src/CosmicTrackingRegion.cc b/RecoTracker/SpecialSeedGenerators/src/CosmicTrackingRegion.cc index 4a5f9053dc6ac..8bf94c5f57818 100644 --- a/RecoTracker/SpecialSeedGenerators/src/CosmicTrackingRegion.cc +++ b/RecoTracker/SpecialSeedGenerators/src/CosmicTrackingRegion.cc @@ -23,31 +23,27 @@ using namespace std; using namespace ctfseeding; -TrackingRegion::ctfHits CosmicTrackingRegion::hits(const edm::Event& ev, - const edm::EventSetup& es, +TrackingRegion::ctfHits CosmicTrackingRegion::hits(const edm::EventSetup& es, const ctfseeding::SeedingLayer* layer) const { TrackingRegion::ctfHits result; TrackingRegion::Hits tmp; - hits_(ev, es, *layer, tmp); + hits_(es, *layer, tmp); result.reserve(tmp.size()); for ( auto h : tmp) result.emplace_back(*h); // not owned return result; } -TrackingRegion::Hits CosmicTrackingRegion::hits(const edm::Event& ev, - const edm::EventSetup& es, +TrackingRegion::Hits CosmicTrackingRegion::hits(const edm::EventSetup& es, const SeedingLayerSetsHits::SeedingLayer& layer) const { TrackingRegion::Hits result; - hits_(ev, es, layer, result); + hits_(es, layer, result); return result; } template -void CosmicTrackingRegion::hits_( - const edm::Event& ev, - const edm::EventSetup& es, +void CosmicTrackingRegion::hits_(const edm::EventSetup& es, const T& layer, TrackingRegion::Hits & result) const { diff --git a/RecoTracker/SpecialSeedGenerators/src/GenericPairGenerator.cc b/RecoTracker/SpecialSeedGenerators/src/GenericPairGenerator.cc index f56daa059cf6e..5f362c68f2885 100644 --- a/RecoTracker/SpecialSeedGenerators/src/GenericPairGenerator.cc +++ b/RecoTracker/SpecialSeedGenerators/src/GenericPairGenerator.cc @@ -26,8 +26,8 @@ const OrderedSeedingHits& GenericPairGenerator::run(const TrackingRegion& region throw cms::Exception("CtfSpecialSeedGenerator") << "You are using " << layers.numberOfLayersInSet() <<" layers in set instead of 2 "; for(SeedingLayerSetsHits::SeedingLayerSet ls: layers) { - auto innerHits = region.hits(e, es, ls[0]); - auto outerHits = region.hits(e, es, ls[1]); + auto innerHits = region.hits(es, ls[0]); + auto outerHits = region.hits(es, ls[1]); for (auto iOuterHit = outerHits.begin(); iOuterHit != outerHits.end(); iOuterHit++){ for (auto iInnerHit = innerHits.begin(); iInnerHit != innerHits.end(); iInnerHit++){ hitPairs.push_back(OrderedHitPair(&(**iInnerHit), diff --git a/RecoTracker/SpecialSeedGenerators/src/GenericTripletGenerator.cc b/RecoTracker/SpecialSeedGenerators/src/GenericTripletGenerator.cc index f4fa17133930d..c0c84d2d5f6ae 100644 --- a/RecoTracker/SpecialSeedGenerators/src/GenericTripletGenerator.cc +++ b/RecoTracker/SpecialSeedGenerators/src/GenericTripletGenerator.cc @@ -27,11 +27,11 @@ const OrderedSeedingHits& GenericTripletGenerator::run(const TrackingRegion& reg throw cms::Exception("CtfSpecialSeedGenerator") << "You are using " << layers.numberOfLayersInSet() <<" layers in set instead of 3 "; std::map radius_triplet_map; for(SeedingLayerSetsHits::SeedingLayerSet ls: layers) { - auto innerHits = region.hits(e, es, ls[0]); + auto innerHits = region.hits(es, ls[0]); //std::cout << "innerHits.size()=" << innerHits.size() << std::endl; - auto middleHits = region.hits(e, es, ls[1]); + auto middleHits = region.hits(es, ls[1]); //std::cout << "middleHits.size()=" << middleHits.size() << std::endl; - auto outerHits = region.hits(e, es, ls[2]); + auto outerHits = region.hits(es, ls[2]); //std::cout << "outerHits.size()=" << outerHits.size() << std::endl; //std::cout << "trying " << innerHits.size()*middleHits.size()*outerHits.size() << " combinations "< 0) { std::cout << "GenericTripletGenerator iLss = " << seedingLayersToString(ls) diff --git a/RecoTracker/TkHitPairs/BuildFile.xml b/RecoTracker/TkHitPairs/BuildFile.xml index cf123072ae3d9..e00b6120f8d4d 100644 --- a/RecoTracker/TkHitPairs/BuildFile.xml +++ b/RecoTracker/TkHitPairs/BuildFile.xml @@ -2,6 +2,7 @@ + diff --git a/RecoTracker/TkHitPairs/interface/HitPairGeneratorFromLayerPair.h b/RecoTracker/TkHitPairs/interface/HitPairGeneratorFromLayerPair.h index 7025d2e91c4d6..7cbb9089b31ff 100644 --- a/RecoTracker/TkHitPairs/interface/HitPairGeneratorFromLayerPair.h +++ b/RecoTracker/TkHitPairs/interface/HitPairGeneratorFromLayerPair.h @@ -24,9 +24,23 @@ class HitPairGeneratorFromLayerPair { ~HitPairGeneratorFromLayerPair(); HitDoublets doublets( const TrackingRegion& reg, - const edm::Event & ev, const edm::EventSetup& es, Layers layers); + const edm::Event & ev, const edm::EventSetup& es, Layers layers) { + assert(theLayerCache); + return doublets(reg, ev, es, layers, *theLayerCache); + } HitDoublets doublets( const TrackingRegion& reg, - const edm::Event & ev, const edm::EventSetup& es, const Layer& innerLayer, const Layer& outerLayer); + const edm::Event & ev, const edm::EventSetup& es, const Layer& innerLayer, const Layer& outerLayer) { + assert(theLayerCache); + return doublets(reg, ev, es, innerLayer, outerLayer, *theLayerCache); + } + HitDoublets doublets( const TrackingRegion& reg, + const edm::Event & ev, const edm::EventSetup& es, Layers layers, LayerCacheType& layerCache) { + Layer innerLayerObj = innerLayer(layers); + Layer outerLayerObj = outerLayer(layers); + return doublets(reg, ev, es, innerLayerObj, outerLayerObj, layerCache); + } + HitDoublets doublets( const TrackingRegion& reg, + const edm::Event & ev, const edm::EventSetup& es, const Layer& innerLayer, const Layer& outerLayer, LayerCacheType& layerCache); void hitPairs( const TrackingRegion& reg, OrderedHitPairs & prs, const edm::Event & ev, const edm::EventSetup& es, Layers layers); @@ -46,7 +60,7 @@ class HitPairGeneratorFromLayerPair { Layer outerLayer(const Layers& layers) const { return layers[theOuterLayer]; } private: - LayerCacheType & theLayerCache; + LayerCacheType *theLayerCache; const unsigned int theOuterLayer; const unsigned int theInnerLayer; const unsigned int theMaxElement; diff --git a/RecoTracker/TkHitPairs/interface/IntermediateHitDoublets.h b/RecoTracker/TkHitPairs/interface/IntermediateHitDoublets.h new file mode 100644 index 0000000000000..834ac284c43a9 --- /dev/null +++ b/RecoTracker/TkHitPairs/interface/IntermediateHitDoublets.h @@ -0,0 +1,243 @@ +#ifndef RecoTracker_TkHitPairs_IntermediateHitDoublets_h +#define RecoTracker_TkHitPairs_IntermediateHitDoublets_h + +#include "RecoTracker/TkHitPairs/interface/LayerHitMapCache.h" +#include "TrackingTools/TransientTrackingRecHit/interface/SeedingLayerSetsHits.h" + +namespace ihd { + /** + * Class to hold TrackingRegion and begin+end indices to a vector of + * seeding layer sets. + * + * The LayerHitMapCache is also hold here as it is a per-region object. + * + * In practice the vector being indexed can be anything. + */ + class RegionIndex { + public: + RegionIndex(const TrackingRegion *reg, unsigned int ind): + region_(reg), + layerSetBeginIndex_(ind), + layerSetEndIndex_(ind) + {} + + void setLayerSetsEnd(unsigned int end) { layerSetEndIndex_ = end; } + + const TrackingRegion& region() const { return *region_; } + + LayerHitMapCache& layerHitMapCache() { return cache_; } + const LayerHitMapCache& layerHitMapCache() const { return cache_; } + + unsigned int layerSetBeginIndex() const { return layerSetBeginIndex_; } + unsigned int layerSetEndIndex() const { return layerSetEndIndex_; } + + private: + const TrackingRegion *region_; /// pointer to TrackingRegion (owned elsewhere) + LayerHitMapCache cache_; + unsigned int layerSetBeginIndex_; /// index of the beginning of layer sets of this region + unsigned int layerSetEndIndex_; /// index of the end (one-past-last) of layer sets of this region + }; + + /** + * Helper class to provide nice interface to loop over the layer sets of a region + * + * \tparam T Concrete type in a vector actually holding the layer sets + * + * Templatized because used here and in RegionSeedingHitSets + */ + template + class RegionLayerSets { + public: + using const_iterator = typename std::vector::const_iterator; + + // Taking T* to have compatible interface with IntermediateHitTriplets::RegionLayerSets + template + RegionLayerSets(const TrackingRegion* region, const LayerHitMapCache *cache, const TMP*, const_iterator begin, const_iterator end): + region_(region), cache_(cache), layerSetsBegin_(begin), layerSetsEnd_(end) {} + + const TrackingRegion& region() const { return *region_; } + const LayerHitMapCache& layerHitMapCache() const { return *cache_; } + + const_iterator begin() const { return layerSetsBegin_; } + const_iterator cbegin() const { return begin(); } + const_iterator end() const { return layerSetsEnd_; } + const_iterator cend() const { return end(); } + + private: + const TrackingRegion *region_; + const LayerHitMapCache *cache_; + const const_iterator layerSetsBegin_; + const const_iterator layerSetsEnd_; + }; + + /** + * Helper class providing a generic iterator to loop over + * TrackingRegions of IntermediateHitDoublets, + * IntermediateHitTriplets, or RegionsSeedingHitSets + * + * \tparam ValueType Type to be returned by operator*() (should be something inexpensive) + * \tparam HitSetType Type of the holder of data (currently IntermediateHitDoublets, IntermediateHitTriplets, or RegionsSeedingHitSets) + */ + template + class const_iterator { + public: + using internal_iterator_type = typename std::vector::const_iterator; + using value_type = ValueType; + using difference_type = internal_iterator_type::difference_type; + + const_iterator(const HitSetType *hst, internal_iterator_type iter): hitSets_(hst), iter_(iter) {} + + value_type operator*() const { + return value_type(&(iter_->region()), + &(iter_->layerHitMapCache()), + hitSets_, + hitSets_->layerSetsBegin() + iter_->layerSetBeginIndex(), + hitSets_->layerSetsBegin() + iter_->layerSetEndIndex()); + } + + const_iterator& operator++() { ++iter_; return *this; } + const_iterator operator++(int) { + const_iterator clone(*this); + ++iter_; + return clone; + } + + bool operator==(const const_iterator& other) const { return iter_ == other.iter_; } + bool operator!=(const const_iterator& other) const { return !operator==(other); } + + private: + const HitSetType *hitSets_; + internal_iterator_type iter_; + }; +} + +/** + * Container of temporary information delivered from hit pair + * generator to hit triplet generator via edm::Event. + * + * The iterator loops over regions, and the value_type of that has an + * iterator looping over the layer pairs of the region. + * + * Pointers to SeedingLayerSetsHits and TrackingRegion are stored, so + * the lifetime of those objects should be at least as long as the + * lifetime of this object. + */ +class IntermediateHitDoublets { +public: + using LayerPair = std::tuple; + using RegionIndex = ihd::RegionIndex; + + /** + * This class stores the indices of a layer pair, and the doublets + * generated from there. + * + * The layer indices are those from SeedingLayerSetsHits. + * + * Since the doublets are stored directly here, the same class works + * nicely for both storage and use. + */ + class LayerPairHitDoublets { + public: + LayerPairHitDoublets(const SeedingLayerSetsHits::SeedingLayerSet& layerSet, HitDoublets&& doublets): + layerPair_(layerSet[0].index(), layerSet[1].index()), + doublets_(std::move(doublets)) + {} + + const LayerPair& layerPair() const { return layerPair_; } + SeedingLayerSetsHits::LayerIndex innerLayerIndex() const { return std::get<0>(layerPair_); } + SeedingLayerSetsHits::LayerIndex outerLayerIndex() const { return std::get<1>(layerPair_); } + + const HitDoublets& doublets() const { return doublets_; } + + private: + LayerPair layerPair_; /// pair of indices to the layer + HitDoublets doublets_; /// container of the doublets + }; + + //////////////////// + + /// Helper class providing nice interface to loop over layer sets of a region + using RegionLayerSets = ihd::RegionLayerSets; + + //////////////////// + + /// Iterator over regions + using const_iterator = ihd::const_iterator; + + //////////////////// + + /// Helper class enforcing correct way of filling the doublets of a region + class RegionFiller { + public: + RegionFiller(): obj_(nullptr) {} + explicit RegionFiller(IntermediateHitDoublets *obj): obj_(obj) {} + + ~RegionFiller() = default; + + bool valid() const { return obj_ != nullptr; } + + LayerHitMapCache& layerHitMapCache() { return obj_->regions_.back().layerHitMapCache(); } + + void addDoublets(const SeedingLayerSetsHits::SeedingLayerSet& layerSet, HitDoublets&& doublets) { + obj_->layerPairs_.emplace_back(layerSet, std::move(doublets)); + obj_->regions_.back().setLayerSetsEnd(obj_->layerPairs_.size()); + } + private: + IntermediateHitDoublets *obj_; + }; + + // allows declaring local variables with auto + static RegionFiller dummyFiller() { return RegionFiller(); } + + //////////////////// + + IntermediateHitDoublets(): seedingLayers_(nullptr) {} + explicit IntermediateHitDoublets(const SeedingLayerSetsHits *seedingLayers): seedingLayers_(seedingLayers) {} + IntermediateHitDoublets(const IntermediateHitDoublets& rh); // only to make ROOT dictionary generation happy + ~IntermediateHitDoublets() = default; + + void swap(IntermediateHitDoublets& rh) { + std::swap(seedingLayers_, rh.seedingLayers_); + std::swap(regions_, rh.regions_); + std::swap(layerPairs_, rh.layerPairs_); + } + + void reserve(size_t nregions, size_t nlayersets) { + regions_.reserve(nregions); + layerPairs_.reserve(nregions*nlayersets); + } + + void shrink_to_fit() { + regions_.shrink_to_fit(); + layerPairs_.shrink_to_fit(); + } + + RegionFiller beginRegion(const TrackingRegion *region) { + regions_.emplace_back(region, layerPairs_.size()); + return RegionFiller(this); + } + + const SeedingLayerSetsHits& seedingLayerHits() const { return *seedingLayers_; } + bool empty() const { return regions_.empty(); } + size_t regionSize() const { return regions_.size(); } + size_t layerPairsSize() const { return layerPairs_.size(); } + + const_iterator begin() const { return const_iterator(this, regions_.begin()); } + const_iterator cbegin() const { return begin(); } + const_iterator end() const { return const_iterator(this, regions_.end()); } + const_iterator cend() const { return end(); } + + // used internally by all the helper classes + std::vector::const_iterator regionsBegin() const { return regions_.begin(); } + std::vector::const_iterator regionsEnd() const { return regions_.end(); } + std::vector::const_iterator layerSetsBegin() const { return layerPairs_.begin(); } + std::vector::const_iterator layerSetsEnd() const { return layerPairs_.end(); } + +private: + const SeedingLayerSetsHits *seedingLayers_; /// Pointer to SeedingLayerSetsHits (owned elsewhere) + + std::vector regions_; /// Container of regions, each element has indices pointing to layerPairs_ + std::vector layerPairs_; /// Container of layer pairs and doublets for all regions +}; + +#endif diff --git a/RecoTracker/TkHitPairs/interface/LayerHitMapCache.h b/RecoTracker/TkHitPairs/interface/LayerHitMapCache.h index 2960ceebc7c38..b399a323b8dd0 100644 --- a/RecoTracker/TkHitPairs/interface/LayerHitMapCache.h +++ b/RecoTracker/TkHitPairs/interface/LayerHitMapCache.h @@ -9,7 +9,7 @@ #include "RecoTracker/TkHitPairs/interface/RecHitsSortedInPhi.h" #include "TrackingTools/TransientTrackingRecHit/interface/SeedingLayerSetsHits.h" #include "FWCore/Framework/interface/EventSetup.h" - +#include "DataFormats/TrackingRecHit/interface/mayown_ptr.h" class LayerHitMapCache { @@ -19,21 +19,32 @@ class LayerHitMapCache { public: using ValueType = RecHitsSortedInPhi; using KeyType = int; - SimpleCache(unsigned int initSize) : theContainer(initSize, nullptr){} + SimpleCache(unsigned int initSize) : theContainer(initSize){} + SimpleCache(SimpleCache&& rh): theContainer(std::move(rh.theContainer)) {} ~SimpleCache() { clear(); } - void resize(int size) { theContainer.resize(size,nullptr); } - const ValueType* get(KeyType key) { return theContainer[key];} + void resize(int size) { theContainer.resize(size); } + const ValueType* get(KeyType key) const { return theContainer[key].get();} /// add object to cache. It is caller responsibility to check that object is not yet there. - void add(KeyType key, const ValueType * value) { + void add(KeyType key, ValueType * value) { if (key>=int(theContainer.size())) resize(key+1); - theContainer[key]=value; + theContainer[key].reset(value); + } + void extend(const SimpleCache& other) { + // N.B. Here we assume that the lifetime of 'other' is longer than of 'this'. + if(other.theContainer.size() > theContainer.size()) + resize(other.theContainer.size()); + + for(size_t i=0, size=other.theContainer.size(); i != size; ++i) { + assert(get(i) == nullptr); // We don't want to override any existing value + theContainer[i].reset(*(other.get(i))); // pass by reference to denote that we don't own it + } } /// emptify cache, delete values associated to Key void clear() { - for ( auto & v : theContainer) { delete v; v=nullptr;} + for ( auto & v : theContainer) { v.reset(); } } private: - std::vector< const ValueType *> theContainer; + std::vector > theContainer; private: SimpleCache(const SimpleCache &) { } }; @@ -42,20 +53,26 @@ class LayerHitMapCache { typedef SimpleCache Cache; public: LayerHitMapCache(unsigned int initSize=50) : theCache(initSize) { } + LayerHitMapCache(LayerHitMapCache&& rh): theCache(std::move(rh.theCache)) {} void clear() { theCache.clear(); } + + void extend(const LayerHitMapCache& other) { + theCache.extend(other.theCache); + } const RecHitsSortedInPhi & operator()(const SeedingLayerSetsHits::SeedingLayer& layer, const TrackingRegion & region, - const edm::Event & iEvent, const edm::EventSetup & iSetup) { + const edm::EventSetup & iSetup) { int key = layer.index(); assert (key>=0); const RecHitsSortedInPhi * lhm = theCache.get(key); if (lhm==nullptr) { - lhm=new RecHitsSortedInPhi (region.hits(iEvent,iSetup,layer), region.origin(), layer.detLayer()); - lhm->theOrigin = region.origin(); + auto tmp=new RecHitsSortedInPhi (region.hits(iSetup,layer), region.origin(), layer.detLayer()); + tmp->theOrigin = region.origin(); + theCache.add( key, tmp); + lhm = tmp; LogDebug("LayerHitMapCache")<<" I got"<< lhm->all().second-lhm->all().first<<" hits in the cache for: "<theOrigin << std::endl; diff --git a/RecoTracker/TkHitPairs/interface/RecHitsSortedInPhi.h b/RecoTracker/TkHitPairs/interface/RecHitsSortedInPhi.h index 0db7b68bd24dc..c61736a94db21 100644 --- a/RecoTracker/TkHitPairs/interface/RecHitsSortedInPhi.h +++ b/RecoTracker/TkHitPairs/interface/RecHitsSortedInPhi.h @@ -91,7 +91,7 @@ class RecHitsSortedInPhi { public: - mutable GlobalPoint theOrigin; + GlobalPoint theOrigin; std::vector theHits; diff --git a/RecoTracker/TkHitPairs/interface/RegionsSeedingHitSets.h b/RecoTracker/TkHitPairs/interface/RegionsSeedingHitSets.h new file mode 100644 index 0000000000000..4ddc111c7cffe --- /dev/null +++ b/RecoTracker/TkHitPairs/interface/RegionsSeedingHitSets.h @@ -0,0 +1,88 @@ +#ifndef RecoTracker_TkHitPairs_RegionsSeedingHitSets_H +#define RecoTracker_TkHitPairs_RegionsSeedingHitSets_H + +#include "RecoTracker/TkSeedingLayers/interface/SeedingHitSet.h" +#include "RecoTracker/TkHitPairs/interface/IntermediateHitDoublets.h" + +/** + * Class to store SeedingHitSets (doublet/triplet/quadruplet) per TrackingRegion + * + * Defined in this package instead of RecoTracker/TkSeedingLayers to avoid circular dependencies + */ +class RegionsSeedingHitSets { +public: + /// Helper class containing a region and indices to hitSets_ + using RegionIndex = ihd::RegionIndex; + + /// Helper class providing nice interface to loop over hit sets of a region + using RegionSeedingHitSets = ihd::RegionLayerSets; + + /// Iterator over regions + using const_iterator = ihd::const_iterator; + + /// Helper class enforcing correct way of filling the doublets of a region + class RegionFiller { + public: + RegionFiller(): obj_(nullptr) {} + explicit RegionFiller(RegionsSeedingHitSets* obj): obj_(obj) {} + + ~RegionFiller() { + if(obj_) obj_->regions_.back().setLayerSetsEnd(obj_->hitSets_.size()); + } + + bool valid() const { return obj_ != nullptr; } + + template + void emplace_back(Args&&... args) { + obj_->hitSets_.emplace_back(std::forward(args)...); + } + private: + RegionsSeedingHitSets *obj_; + }; + + // allows declaring local variables with auto + static RegionFiller dummyFiller() { return RegionFiller(); } + + // constructors + RegionsSeedingHitSets() = default; + ~RegionsSeedingHitSets() = default; + + void swap(RegionsSeedingHitSets& rh) { + regions_.swap(rh.regions_); + hitSets_.swap(rh.hitSets_); + } + + void reserve(size_t nregions, size_t nhitsets) { + regions_.reserve(nregions); + hitSets_.reserve(nhitsets); + } + + void shrink_to_fit() { + regions_.shrink_to_fit(); + hitSets_.shrink_to_fit(); + } + + RegionFiller beginRegion(const TrackingRegion *region) { + regions_.emplace_back(region, hitSets_.size()); + return RegionFiller(this); + } + + bool empty() const { return regions_.empty(); } + size_t regionSize() const { return regions_.size(); } + size_t size() const { return hitSets_.size(); } + + const_iterator begin() const { return const_iterator(this, regions_.begin()); } + const_iterator cbegin() const { return begin(); } + const_iterator end() const { return const_iterator(this, regions_.end()); } + const_iterator cend() const { return end(); } + + // used internally by the helper classes + std::vector::const_iterator layerSetsBegin() const { return hitSets_.begin(); } + std::vector::const_iterator layerSetsEnd() const { return hitSets_.end(); } + +private: + std::vector regions_; /// Container of regions, each element has indices pointing to hitSets_ + std::vector hitSets_; /// Container of hit sets for all regions +}; + +#endif diff --git a/RecoTracker/TkHitPairs/plugins/BuildFile.xml b/RecoTracker/TkHitPairs/plugins/BuildFile.xml index b76e633119491..af7185a4200fb 100644 --- a/RecoTracker/TkHitPairs/plugins/BuildFile.xml +++ b/RecoTracker/TkHitPairs/plugins/BuildFile.xml @@ -1,5 +1,6 @@ + diff --git a/RecoTracker/TkHitPairs/plugins/HitPairEDProducer.cc b/RecoTracker/TkHitPairs/plugins/HitPairEDProducer.cc new file mode 100644 index 0000000000000..69346b4e2c786 --- /dev/null +++ b/RecoTracker/TkHitPairs/plugins/HitPairEDProducer.cc @@ -0,0 +1,310 @@ +#include "FWCore/Framework/interface/stream/EDProducer.h" +#include "FWCore/ParameterSet/interface/ParameterSet.h" +#include "FWCore/ParameterSet/interface/ConfigurationDescriptions.h" +#include "FWCore/ParameterSet/interface/ParameterSetDescription.h" +#include "FWCore/Utilities/interface/EDGetToken.h" +#include "FWCore/Framework/interface/Event.h" +#include "DataFormats/Common/interface/Handle.h" +#include "FWCore/Utilities/interface/RunningAverage.h" + +#include "RecoTracker/TkTrackingRegions/interface/TrackingRegion.h" +#include "DataFormats/Common/interface/OwnVector.h" +#include "TrackingTools/TransientTrackingRecHit/interface/SeedingLayerSetsHits.h" +#include "RecoTracker/TkHitPairs/interface/LayerHitMapCache.h" +#include "RecoTracker/TkHitPairs/interface/HitPairGeneratorFromLayerPair.h" +#include "RecoTracker/TkHitPairs/interface/IntermediateHitDoublets.h" +#include "RecoTracker/TkHitPairs/interface/RegionsSeedingHitSets.h" + +namespace { class ImplBase; } + +class HitPairEDProducer: public edm::stream::EDProducer<> { +public: + HitPairEDProducer(const edm::ParameterSet& iConfig); + ~HitPairEDProducer() = default; + + static void fillDescriptions(edm::ConfigurationDescriptions& descriptions); + + virtual void produce(edm::Event& iEvent, const edm::EventSetup& iSetup) override; + +private: + edm::EDGetTokenT seedingLayerToken_; + edm::EDGetTokenT > regionToken_; + edm::EDGetTokenT clusterCheckToken_; + + std::unique_ptr<::ImplBase> impl_; +}; + +namespace { + class ImplBase { + public: + ImplBase(const edm::ParameterSet& iConfig); + virtual ~ImplBase() = default; + + virtual void produces(edm::ProducerBase& producer) const = 0; + + virtual void produce(const SeedingLayerSetsHits& layers, const edm::OwnVector& regions, const bool clusterCheckOk, + edm::Event& iEvent, const edm::EventSetup& iSetup) = 0; + + protected: + void makeLayerPairs(const SeedingLayerSetsHits& layers, std::vector& layerPairs); + + edm::RunningAverage localRA_; + const unsigned int maxElement_; + + HitPairGeneratorFromLayerPair generator_; + std::vector layerPairBegins_; + }; + ImplBase::ImplBase(const edm::ParameterSet& iConfig): + maxElement_(iConfig.getParameter("maxElement")), + generator_(0, 1, nullptr, maxElement_), // these indices are dummy, TODO: cleanup HitPairGeneratorFromLayerPair + layerPairBegins_(iConfig.getParameter >("layerPairs")) + { + if(layerPairBegins_.empty()) + throw cms::Exception("Configuration") << "HitPairEDProducer requires at least index for layer pairs (layerPairs parameter), none was given"; + } + void ImplBase::makeLayerPairs(const SeedingLayerSetsHits& layers, std::vector& layerPairs) { + if(layers.numberOfLayersInSet() > 2) { + for(const auto& layerSet: layers) { + for(const auto pairBeginIndex: layerPairBegins_) { + if(pairBeginIndex+1 >= layers.numberOfLayersInSet()) { + throw cms::Exception("LogicError") << "Layer pair index " << pairBeginIndex << " is out of bounds, input SeedingLayerSetsHits has only " << layers.numberOfLayersInSet() << " layers per set, and the index+1 must be < than the number of layers in set"; + } + + // Take only the requested pair of the set + SeedingLayerSetsHits::SeedingLayerSet pairCandidate = layerSet.slice(pairBeginIndex, pairBeginIndex+1); + + // it would be trivial to use 128-bit bitfield for O(1) check + // if a layer pair has been inserted, but let's test first how + // a "straightforward" solution works + auto found = std::find_if(layerPairs.begin(), layerPairs.end(), [&](const SeedingLayerSetsHits::SeedingLayerSet& pair) { + return pair[0].index() == pairCandidate[0].index() && pair[1].index() == pairCandidate[1].index(); + }); + if(found != layerPairs.end()) + continue; + + layerPairs.push_back(pairCandidate); + } + } + } + else { + if(layerPairBegins_.size() != 1) { + throw cms::Exception("LogicError") << "With pairs of input layers, it doesn't make sense to specify more than one input layer pair, got " << layerPairBegins_.size(); + } + if(layerPairBegins_[0] != 0) { + throw cms::Exception("LogicError") << "With pairs of input layers, it doesn't make sense to specify other input layer pair than 0; got " << layerPairBegins_[0]; + } + + layerPairs.reserve(layers.size()); + for(const auto& set: layers) + layerPairs.push_back(set); + } + } + + + ///// + template + struct Impl: public ImplBase { + Impl(const edm::ParameterSet& iConfig): ImplBase(iConfig) {} + ~Impl() = default; + + void produces(edm::ProducerBase& producer) const override { + T_SeedingHitSets::produces(producer); + T_IntermediateHitDoublets::produces(producer); + } + + void produce(const SeedingLayerSetsHits& layers, const edm::OwnVector& regions, const bool clusterCheckOk, + edm::Event& iEvent, const edm::EventSetup& iSetup) override { + auto seedingHitSetsProducer = T_SeedingHitSets(&localRA_); + auto intermediateHitDoubletsProducer = T_IntermediateHitDoublets(&layers); + + if(!clusterCheckOk) { + seedingHitSetsProducer.putEmpty(iEvent); + intermediateHitDoubletsProducer.putEmpty(iEvent); + return; + } + + seedingHitSetsProducer.reserve(regions.size()); + intermediateHitDoubletsProducer.reserve(regions.size()); + + std::vector layerPairs; + makeLayerPairs(layers, layerPairs); + + for(const TrackingRegion& region: regions) { + auto hitCachePtr_filler_shs = seedingHitSetsProducer.beginRegion(®ion, nullptr); + auto hitCachePtr_filler_ihd = intermediateHitDoubletsProducer.beginRegion(®ion, std::get<0>(hitCachePtr_filler_shs)); + auto hitCachePtr = std::get<0>(hitCachePtr_filler_ihd); + + for(SeedingLayerSetsHits::SeedingLayerSet layerSet: layerPairs) { + auto doublets = generator_.doublets(region, iEvent, iSetup, layerSet, *hitCachePtr); + LogTrace("HitPairEDProducer") << " created " << doublets.size() << " doublets for layers " << layerSet[0].index() << "," << layerSet[1].index(); + if(doublets.empty()) continue; // don't bother if no pairs from these layers + seedingHitSetsProducer.fill(std::get<1>(hitCachePtr_filler_shs), doublets); + intermediateHitDoubletsProducer.fill(std::get<1>(hitCachePtr_filler_ihd), layerSet, std::move(doublets)); + } + } + + seedingHitSetsProducer.put(iEvent); + intermediateHitDoubletsProducer.put(iEvent); + } + }; + + ///// + class DoNothing { + public: + DoNothing(const SeedingLayerSetsHits *) {} + DoNothing(edm::RunningAverage *) {} + + static void produces(edm::ProducerBase&) {}; + + void reserve(size_t) {} + + auto beginRegion(const TrackingRegion *, LayerHitMapCache *ptr) { + return std::make_tuple(ptr, 0); + } + + void fill(int, const HitDoublets&) {} + void fill(int, const SeedingLayerSetsHits::SeedingLayerSet&, HitDoublets&&) {} + + void put(edm::Event&) {} + void putEmpty(edm::Event&) {} + }; + + ///// + class ImplSeedingHitSets { + public: + ImplSeedingHitSets(edm::RunningAverage *localRA): + seedingHitSets_(std::make_unique()), + localRA_(localRA) + {} + + static void produces(edm::ProducerBase& producer) { + producer.produces(); + } + + void reserve(size_t regionsSize) { + seedingHitSets_->reserve(regionsSize, localRA_->upper()); + } + + auto beginRegion(const TrackingRegion *region, LayerHitMapCache *) { + hitCacheTmp_.clear(); + return std::make_tuple(&hitCacheTmp_, seedingHitSets_->beginRegion(region)); + } + + void fill(RegionsSeedingHitSets::RegionFiller& filler, const HitDoublets& doublets) { + for(size_t i=0, size=doublets.size(); ishrink_to_fit(); + localRA_->update(seedingHitSets_->size()); + putEmpty(iEvent); + } + + void putEmpty(edm::Event& iEvent) { + iEvent.put(std::move(seedingHitSets_)); + } + + private: + std::unique_ptr seedingHitSets_; + edm::RunningAverage *localRA_; + LayerHitMapCache hitCacheTmp_; // used if !produceIntermediateHitDoublets + }; + + ///// + class ImplIntermediateHitDoublets { + public: + ImplIntermediateHitDoublets(const SeedingLayerSetsHits *layers): + intermediateHitDoublets_(std::make_unique(layers)), + layers_(layers) + {} + + static void produces(edm::ProducerBase& producer) { + producer.produces(); + } + + void reserve(size_t regionsSize) { + intermediateHitDoublets_->reserve(regionsSize, layers_->size()); + } + + auto beginRegion(const TrackingRegion *region, LayerHitMapCache *) { + auto filler = intermediateHitDoublets_->beginRegion(region); + return std::make_tuple(&(filler.layerHitMapCache()), std::move(filler)); + } + + void fill(IntermediateHitDoublets::RegionFiller& filler, const SeedingLayerSetsHits::SeedingLayerSet& layerSet, HitDoublets&& doublets) { + filler.addDoublets(layerSet, std::move(doublets)); + } + + void put(edm::Event& iEvent) { + intermediateHitDoublets_->shrink_to_fit(); + putEmpty(iEvent); + } + + void putEmpty(edm::Event& iEvent) { + iEvent.put(std::move(intermediateHitDoublets_)); + } + + private: + std::unique_ptr intermediateHitDoublets_; + const SeedingLayerSetsHits *layers_; + }; +} + + + +HitPairEDProducer::HitPairEDProducer(const edm::ParameterSet& iConfig): + seedingLayerToken_(consumes(iConfig.getParameter("seedingLayers"))), + regionToken_(consumes >(iConfig.getParameter("trackingRegions"))), + clusterCheckToken_(consumes(iConfig.getParameter("clusterCheck"))) +{ + const bool produceSeedingHitSets = iConfig.getParameter("produceSeedingHitSets"); + const bool produceIntermediateHitDoublets = iConfig.getParameter("produceIntermediateHitDoublets"); + + if(produceSeedingHitSets && produceIntermediateHitDoublets) + impl_ = std::make_unique<::Impl<::ImplSeedingHitSets, ::ImplIntermediateHitDoublets>>(iConfig); + else if(produceSeedingHitSets) + impl_ = std::make_unique<::Impl<::ImplSeedingHitSets, ::DoNothing>>(iConfig); + else if(produceIntermediateHitDoublets) + impl_ = std::make_unique<::Impl<::DoNothing, ::ImplIntermediateHitDoublets>>(iConfig); + else + throw cms::Exception("Configuration") << "HitPairEDProducer requires either produceIntermediateHitDoublets or produceSeedingHitSets to be True. If neither are needed, just remove this module from your sequence/path as it doesn't do anything useful"; + + impl_->produces(*this); +} + +void HitPairEDProducer::fillDescriptions(edm::ConfigurationDescriptions& descriptions) { + edm::ParameterSetDescription desc; + + desc.add("seedingLayers", edm::InputTag("seedingLayersEDProducer")); + desc.add("trackingRegions", edm::InputTag("globalTrackingRegionFromBeamSpot")); + desc.add("clusterCheck", edm::InputTag("trackerClusterCheck")); + desc.add("produceSeedingHitSets", false); + desc.add("produceIntermediateHitDoublets", false); + desc.add("maxElement", 1000000); + desc.add >("layerPairs", std::vector{{0}})->setComment("Indices to the pairs of consecutive layers, i.e. 0 means (0,1), 1 (1,2) etc."); + + descriptions.add("hitPairEDProducerDefault", desc); +} + +void HitPairEDProducer::produce(edm::Event& iEvent, const edm::EventSetup& iSetup) { + edm::Handle hclusterCheck; + iEvent.getByToken(clusterCheckToken_, hclusterCheck); + + edm::Handle hlayers; + iEvent.getByToken(seedingLayerToken_, hlayers); + const auto& layers = *hlayers; + if(layers.numberOfLayersInSet() < 2) + throw cms::Exception("LogicError") << "HitPairEDProducer expects SeedingLayerSetsHits::numberOfLayersInSet() to be >= 2, got " << layers.numberOfLayersInSet() << ". This is likely caused by a configuration error of this module, or SeedingLayersEDProducer."; + + edm::Handle > hregions; + iEvent.getByToken(regionToken_, hregions); + + impl_->produce(layers, *hregions, *hclusterCheck, iEvent, iSetup); +} + +#include "FWCore/PluginManager/interface/ModuleDef.h" +#include "FWCore/Framework/interface/MakerMacros.h" +DEFINE_FWK_MODULE(HitPairEDProducer); diff --git a/RecoTracker/TkHitPairs/python/hitPairEDProducer_cfi.py b/RecoTracker/TkHitPairs/python/hitPairEDProducer_cfi.py new file mode 100644 index 0000000000000..181d7e19b4b7a --- /dev/null +++ b/RecoTracker/TkHitPairs/python/hitPairEDProducer_cfi.py @@ -0,0 +1,7 @@ +from RecoTracker.TkHitPairs.hitPairEDProducerDefault_cfi import hitPairEDProducerDefault as _hitPairEDProducerDefault + +hitPairEDProducer = _hitPairEDProducerDefault.clone() +from Configuration.Eras.Modifier_trackingPhase1PU70_cff import trackingPhase1PU70 +from Configuration.Eras.Modifier_trackingPhase2PU140_cff import trackingPhase2PU140 +trackingPhase1PU70.toModify(hitPairEDProducer, maxElement=0) +trackingPhase2PU140.toModify(hitPairEDProducer, maxElement=0) diff --git a/RecoTracker/TkHitPairs/src/HitPairGeneratorFromLayerPair.cc b/RecoTracker/TkHitPairs/src/HitPairGeneratorFromLayerPair.cc index 376abcb73bcc0..0371236b7a62a 100644 --- a/RecoTracker/TkHitPairs/src/HitPairGeneratorFromLayerPair.cc +++ b/RecoTracker/TkHitPairs/src/HitPairGeneratorFromLayerPair.cc @@ -34,7 +34,7 @@ HitPairGeneratorFromLayerPair::HitPairGeneratorFromLayerPair( unsigned int outer, LayerCacheType* layerCache, unsigned int max) - : theLayerCache(*layerCache), theOuterLayer(outer), theInnerLayer(inner), theMaxElement(max) + : theLayerCache(layerCache), theOuterLayer(outer), theInnerLayer(inner), theMaxElement(max) { } @@ -87,41 +87,13 @@ void HitPairGeneratorFromLayerPair::hitPairs( } HitDoublets HitPairGeneratorFromLayerPair::doublets( const TrackingRegion& region, - const edm::Event & iEvent, const edm::EventSetup& iSetup, Layers layers) { + const edm::Event & iEvent, const edm::EventSetup& iSetup, const Layer& innerLayer, const Layer& outerLayer, + LayerCacheType& layerCache) { - typedef OrderedHitPair::InnerRecHit InnerHit; - typedef OrderedHitPair::OuterRecHit OuterHit; - typedef RecHitsSortedInPhi::Hit Hit; - - Layer innerLayerObj = innerLayer(layers); - Layer outerLayerObj = outerLayer(layers); - - const RecHitsSortedInPhi & innerHitsMap = theLayerCache(innerLayerObj, region, iEvent, iSetup); - if (innerHitsMap.empty()) return HitDoublets(innerHitsMap,innerHitsMap); - - const RecHitsSortedInPhi& outerHitsMap = theLayerCache(outerLayerObj, region, iEvent, iSetup); - if (outerHitsMap.empty()) return HitDoublets(innerHitsMap,outerHitsMap); - HitDoublets result(innerHitsMap,outerHitsMap); result.reserve(std::max(innerHitsMap.size(),outerHitsMap.size())); - doublets(region, - *innerLayerObj.detLayer(),*outerLayerObj.detLayer(), - innerHitsMap,outerHitsMap,iSetup,theMaxElement,result); - return result; - -} - - -HitDoublets HitPairGeneratorFromLayerPair::doublets( const TrackingRegion& region, - const edm::Event & iEvent, const edm::EventSetup& iSetup, const Layer& innerLayer, const Layer& outerLayer) { - - typedef OrderedHitPair::InnerRecHit InnerHit; - typedef OrderedHitPair::OuterRecHit OuterHit; - typedef RecHitsSortedInPhi::Hit Hit; - - - const RecHitsSortedInPhi & innerHitsMap = theLayerCache(innerLayer, region, iEvent, iSetup); + const RecHitsSortedInPhi & innerHitsMap = layerCache(innerLayer, region, iSetup); if (innerHitsMap.empty()) return HitDoublets(innerHitsMap,innerHitsMap); - const RecHitsSortedInPhi& outerHitsMap = theLayerCache(outerLayer, region, iEvent, iSetup); + const RecHitsSortedInPhi& outerHitsMap = layerCache(outerLayer, region, iSetup); if (outerHitsMap.empty()) return HitDoublets(innerHitsMap,outerHitsMap); HitDoublets result(innerHitsMap,outerHitsMap); result.reserve(std::max(innerHitsMap.size(),outerHitsMap.size())); doublets(region, diff --git a/RecoTracker/TkHitPairs/src/IntermediateHitDoublets.cc b/RecoTracker/TkHitPairs/src/IntermediateHitDoublets.cc new file mode 100644 index 0000000000000..6aec429d14ebf --- /dev/null +++ b/RecoTracker/TkHitPairs/src/IntermediateHitDoublets.cc @@ -0,0 +1,7 @@ +#include "RecoTracker/TkHitPairs/interface/IntermediateHitDoublets.h" +#include "FWCore/Utilities/interface/Exception.h" + +IntermediateHitDoublets::IntermediateHitDoublets(const IntermediateHitDoublets& rh) { + throw cms::Exception("Not Implemented") << "The copy constructor of IntermediateHitDoublets should never be called. The function exists only to make ROOT dictionary generation happy."; +} + diff --git a/RecoTracker/TkHitPairs/src/classes.h b/RecoTracker/TkHitPairs/src/classes.h new file mode 100644 index 0000000000000..d1922e53407f4 --- /dev/null +++ b/RecoTracker/TkHitPairs/src/classes.h @@ -0,0 +1,15 @@ +#include "RecoTracker/TkHitPairs/interface/IntermediateHitDoublets.h" +#include "RecoTracker/TkHitPairs/interface/RegionsSeedingHitSets.h" +#include "DataFormats/Common/interface/Wrapper.h" + +#include + +namespace RecoTracker_TkHitPairs { + struct dictionary { + IntermediateHitDoublets ihd; + edm::Wrapper wihd; + + RegionsSeedingHitSets rshs; + edm::Wrapper wrshs; + }; +} diff --git a/RecoTracker/TkHitPairs/src/classes_def.xml b/RecoTracker/TkHitPairs/src/classes_def.xml new file mode 100644 index 0000000000000..1bc6b61f2f934 --- /dev/null +++ b/RecoTracker/TkHitPairs/src/classes_def.xml @@ -0,0 +1,6 @@ + + + + + + diff --git a/RecoTracker/TkSeedGenerator/interface/ClusterChecker.h b/RecoTracker/TkSeedGenerator/interface/ClusterChecker.h index f2ee556457bf7..411ed981c2071 100644 --- a/RecoTracker/TkSeedGenerator/interface/ClusterChecker.h +++ b/RecoTracker/TkSeedGenerator/interface/ClusterChecker.h @@ -7,15 +7,9 @@ #include "DataFormats/SiStripCluster/interface/SiStripCluster.h" #include "DataFormats/SiPixelCluster/interface/SiPixelCluster.h" -#if !defined(__CINT__) && !defined(__MAKECINT__) && !defined(__REFLEX__) #include "FWCore/Framework/interface/ConsumesCollector.h" -#else -namespace edm { - class ConsumesCollector; -} -#endif -namespace edm { class Event; class ParameterSet; } +namespace edm { class Event; class ParameterSet; class ParameterSetDescription; } namespace reco { namespace utils { struct ClusterTotals { @@ -29,10 +23,10 @@ namespace reco { namespace utils { class ClusterChecker { public: -#if !defined(__CINT__) && !defined(__MAKECINT__) && !defined(__REFLEX__) ClusterChecker(const edm::ParameterSet & conf, edm::ConsumesCollector & iC) ; ClusterChecker(const edm::ParameterSet & conf, edm::ConsumesCollector && iC) ; -#endif + + static void fillDescriptions(edm::ParameterSetDescription& description); ~ClusterChecker() ; size_t tooManyClusters(const edm::Event & e) const ; @@ -46,10 +40,8 @@ class ClusterChecker { unsigned int maxNrOfPixelClusters_; StringCutObjectSelector selector_; unsigned int ignoreDetsAboveNClusters_; -#if !defined(__CINT__) && !defined(__MAKECINT__) && !defined(__REFLEX__) edm::EDGetTokenT > token_sc; edm::EDGetTokenT > token_pc; -#endif }; #endif diff --git a/RecoTracker/TkSeedGenerator/interface/MultiHitGeneratorFromPairAndLayers.h b/RecoTracker/TkSeedGenerator/interface/MultiHitGeneratorFromPairAndLayers.h index ae78164e04558..90500ed94801c 100644 --- a/RecoTracker/TkSeedGenerator/interface/MultiHitGeneratorFromPairAndLayers.h +++ b/RecoTracker/TkSeedGenerator/interface/MultiHitGeneratorFromPairAndLayers.h @@ -12,7 +12,7 @@ #include "TrackingTools/TransientTrackingRecHit/interface/SeedingLayerSetsHits.h" #include "RecoTracker/TkHitPairs/interface/LayerHitMapCache.h" -namespace edm { class ParameterSet; class Event; class EventSetup; } +namespace edm { class ParameterSet; class Event; class EventSetup; class ParameterSetDescription;} class TrackingRegion; class HitPairGeneratorFromLayerPair; @@ -24,6 +24,8 @@ class MultiHitGeneratorFromPairAndLayers { explicit MultiHitGeneratorFromPairAndLayers(const edm::ParameterSet& pset); virtual ~MultiHitGeneratorFromPairAndLayers(); + static void fillDescriptions(edm::ParameterSetDescription& desc); + virtual void initES(const edm::EventSetup& es) = 0; void init(std::unique_ptr&& pairGenerator, LayerCacheType *layerCache); diff --git a/RecoTracker/TkSeedGenerator/interface/SeedCreatorFromRegionHitsEDProducerT.h b/RecoTracker/TkSeedGenerator/interface/SeedCreatorFromRegionHitsEDProducerT.h new file mode 100644 index 0000000000000..70a7959e750cb --- /dev/null +++ b/RecoTracker/TkSeedGenerator/interface/SeedCreatorFromRegionHitsEDProducerT.h @@ -0,0 +1,95 @@ +#ifndef RecoTracker_TkSeedGenerator_SeedCreatorFromRegionHitsEDProducerT_H +#define RecoTracker_TkSeedGenerator_SeedCreatorFromRegionHitsEDProducerT_H + +#include "FWCore/Framework/interface/stream/EDProducer.h" +#include "FWCore/Framework/interface/Event.h" +#include "FWCore/Framework/interface/EventSetup.h" +#include "FWCore/Utilities/interface/EDGetToken.h" +#include "FWCore/ParameterSet/interface/ParameterSet.h" +#include "FWCore/ParameterSet/interface/ConfigurationDescriptions.h" +#include "FWCore/ParameterSet/interface/ParameterSetDescription.h" +#include "DataFormats/Common/interface/Handle.h" + +#include "DataFormats/TrajectorySeed/interface/TrajectorySeedCollection.h" +#include "RecoTracker/TkSeedingLayers/interface/SeedComparitorFactory.h" +#include "RecoTracker/TkSeedingLayers/interface/SeedComparitor.h" + +#include "RecoTracker/TkHitPairs/interface/RegionsSeedingHitSets.h" + +template +class SeedCreatorFromRegionHitsEDProducerT: public edm::stream::EDProducer<> { +public: + + SeedCreatorFromRegionHitsEDProducerT(const edm::ParameterSet& iConfig); + ~SeedCreatorFromRegionHitsEDProducerT() = default; + + static void fillDescriptions(edm::ConfigurationDescriptions& descriptions); + + virtual void produce(edm::Event& iEvent, const edm::EventSetup& iSetup) override; + +private: + edm::EDGetTokenT seedingHitSetsToken_; + T_SeedCreator seedCreator_; + std::unique_ptr comparitor_; +}; + +template +SeedCreatorFromRegionHitsEDProducerT::SeedCreatorFromRegionHitsEDProducerT(const edm::ParameterSet& iConfig): + seedingHitSetsToken_(consumes(iConfig.getParameter("seedingHitSets"))), + seedCreator_(iConfig) +{ + edm::ConsumesCollector iC = consumesCollector(); + edm::ParameterSet comparitorPSet = iConfig.getParameter("SeedComparitorPSet"); + std::string comparitorName = comparitorPSet.getParameter("ComponentName"); + comparitor_.reset((comparitorName == "none") ? nullptr : SeedComparitorFactory::get()->create(comparitorName, comparitorPSet, iC)); + + produces(); +} + +template +void SeedCreatorFromRegionHitsEDProducerT::fillDescriptions(edm::ConfigurationDescriptions& descriptions) { + edm::ParameterSetDescription desc; + + desc.add("seedingHitSets", edm::InputTag("hitPairEDProducer")); + T_SeedCreator::fillDescriptions(desc); + + edm::ParameterSetDescription descComparitor; + descComparitor.add("ComponentName", "none"); + descComparitor.setAllowAnything(); // until we have moved SeedComparitor too to EDProducers + desc.add("SeedComparitorPSet", descComparitor); + + auto label = std::string("seedCreatorFromRegion") + T_SeedCreator::fillDescriptionsLabel() + "EDProducer"; + descriptions.add(label, desc); +} + +template +void SeedCreatorFromRegionHitsEDProducerT::produce(edm::Event& iEvent, const edm::EventSetup& iSetup) { + edm::Handle hseedingHitSets; + iEvent.getByToken(seedingHitSetsToken_, hseedingHitSets); + const auto& seedingHitSets = *hseedingHitSets; + + auto seeds = std::make_unique(); + seeds->reserve(seedingHitSets.size()); + + if(comparitor_) + comparitor_->init(iEvent, iSetup); + + for(const auto& regionSeedingHitSets: seedingHitSets) { + const TrackingRegion& region = regionSeedingHitSets.region(); + seedCreator_.init(region, iSetup, comparitor_.get()); + + for(const SeedingHitSet& hits: regionSeedingHitSets) { + // TODO: do we really need a comparitor at this point? It is + // used in triplet and quadruplet generators, as well as inside + // seedCreator. + if(!comparitor_ || comparitor_->compatible(hits)) { + seedCreator_.makeSeed(*seeds, hits); + } + } + } + + seeds->shrink_to_fit(); + iEvent.put(std::move(seeds)); +} + +#endif diff --git a/RecoTracker/TkSeedGenerator/plugins/ClusterCheckerEDProducer.cc b/RecoTracker/TkSeedGenerator/plugins/ClusterCheckerEDProducer.cc new file mode 100644 index 0000000000000..6367924c51ae5 --- /dev/null +++ b/RecoTracker/TkSeedGenerator/plugins/ClusterCheckerEDProducer.cc @@ -0,0 +1,55 @@ +#include "FWCore/Framework/interface/stream/EDProducer.h" +#include "FWCore/Framework/interface/Event.h" +#include "FWCore/ParameterSet/interface/ParameterSet.h" +#include "FWCore/ParameterSet/interface/ConfigurationDescriptions.h" +#include "FWCore/ParameterSet/interface/ParameterSetDescription.h" + +#include "RecoTracker/TkSeedGenerator/interface/ClusterChecker.h" + +class ClusterCheckerEDProducer: public edm::stream::EDProducer<> { +public: + + ClusterCheckerEDProducer(const edm::ParameterSet& iConfig); + ~ClusterCheckerEDProducer() = default; + + static void fillDescriptions(edm::ConfigurationDescriptions& descriptions); + + virtual void produce(edm::Event& iEvent, const edm::EventSetup& iSetup) override; + +private: + ClusterChecker theClusterCheck; + bool theSilentOnClusterCheck; +}; + +ClusterCheckerEDProducer::ClusterCheckerEDProducer(const edm::ParameterSet& iConfig): + theClusterCheck(iConfig, consumesCollector()), + theSilentOnClusterCheck(iConfig.getUntrackedParameter("silentClusterCheck")) +{ + produces(); +} + +void ClusterCheckerEDProducer::fillDescriptions(edm::ConfigurationDescriptions& descriptions) { + edm::ParameterSetDescription desc; + ClusterChecker::fillDescriptions(desc); + desc.addUntracked("silentClusterCheck", false); + + descriptions.add("trackerClusterCheckDefault", desc); +} + +void ClusterCheckerEDProducer::produce(edm::Event& iEvent, const edm::EventSetup& iSetup) { + auto ret = std::make_unique(true); + + //protection for big ass events... + size_t clustsOrZero = theClusterCheck.tooManyClusters(iEvent); + if (clustsOrZero){ + if (!theSilentOnClusterCheck) + edm::LogError("TooManyClusters") << "Found too many clusters (" << clustsOrZero << "), bailing out."; + *ret = false; + } + + iEvent.put(std::move(ret)); +} + + +#include "FWCore/Framework/interface/MakerMacros.h" +DEFINE_FWK_MODULE(ClusterCheckerEDProducer); diff --git a/RecoTracker/TkSeedGenerator/plugins/MultiHitFromChi2EDProducer.cc b/RecoTracker/TkSeedGenerator/plugins/MultiHitFromChi2EDProducer.cc new file mode 100644 index 0000000000000..cc4a62f509556 --- /dev/null +++ b/RecoTracker/TkSeedGenerator/plugins/MultiHitFromChi2EDProducer.cc @@ -0,0 +1,143 @@ +#include "FWCore/Framework/interface/stream/EDProducer.h" +#include "FWCore/Framework/interface/ConsumesCollector.h" +#include "FWCore/ParameterSet/interface/ParameterSet.h" +#include "FWCore/ParameterSet/interface/ConfigurationDescriptions.h" +#include "FWCore/ParameterSet/interface/ParameterSetDescription.h" +#include "FWCore/Utilities/interface/EDGetToken.h" +#include "FWCore/Framework/interface/Event.h" +#include "DataFormats/Common/interface/Handle.h" +#include "FWCore/Utilities/interface/RunningAverage.h" + +#include "RecoTracker/TkHitPairs/interface/IntermediateHitDoublets.h" +#include "RecoTracker/TkHitPairs/interface/RegionsSeedingHitSets.h" +#include "DataFormats/Common/interface/OwnVector.h" +#include "RecoPixelVertexing/PixelTriplets/interface/LayerTriplets.h" +#include "MultiHitGeneratorFromChi2.h" + +class MultiHitFromChi2EDProducer: public edm::stream::EDProducer<> { +public: + MultiHitFromChi2EDProducer(const edm::ParameterSet& iConfig); + ~MultiHitFromChi2EDProducer() = default; + + static void fillDescriptions(edm::ConfigurationDescriptions& descriptions); + + virtual void produce(edm::Event& iEvent, const edm::EventSetup& iSetup) override; + +private: + edm::EDGetTokenT doubletToken_; + + edm::RunningAverage localRA_; + + MultiHitGeneratorFromChi2 generator_; +}; + +MultiHitFromChi2EDProducer::MultiHitFromChi2EDProducer(const edm::ParameterSet& iConfig): + doubletToken_(consumes(iConfig.getParameter("doublets"))), + generator_(iConfig) +{ + produces(); + produces >(); +} + +void MultiHitFromChi2EDProducer::fillDescriptions(edm::ConfigurationDescriptions& descriptions) { + edm::ParameterSetDescription desc; + + desc.add("doublets", edm::InputTag("hitPairEDProducer")); + + MultiHitGeneratorFromChi2::fillDescriptions(desc); + + auto label = MultiHitGeneratorFromChi2::fillDescriptionsLabel() + std::string("EDProducerDefault"); + descriptions.add(label, desc); +} + +void MultiHitFromChi2EDProducer::produce(edm::Event& iEvent, const edm::EventSetup& iSetup) { + edm::Handle hdoublets; + iEvent.getByToken(doubletToken_, hdoublets); + const auto& regionDoublets = *hdoublets; + + const SeedingLayerSetsHits& seedingLayerHits = regionDoublets.seedingLayerHits(); + if(seedingLayerHits.numberOfLayersInSet() < 3) { + throw cms::Exception("LogicError") << "MultiHitFromChi2EDProducer expects SeedingLayerSetsHits::numberOfLayersInSet() to be >= 3, got " << seedingLayerHits.numberOfLayersInSet() << ". This is likely caused by a configuration error of this module, HitPairEDProducer, or SeedingLayersEDProducer."; + } + + auto seedingHitSets = std::make_unique(); + if(regionDoublets.empty()) { + iEvent.put(std::move(seedingHitSets)); + return; + } + seedingHitSets->reserve(regionDoublets.regionSize(), localRA_.upper()); + generator_.initES(iSetup); + + // match-making of pair and triplet layers + std::vector trilayers = LayerTriplets::layers(seedingLayerHits); + + OrderedMultiHits multihits; + multihits.reserve(localRA_.upper()); + std::vector > refittedHitStorage; + refittedHitStorage.reserve(localRA_.upper()*2); + + LogDebug("MultiHitFromChi2EDProducer") << "Creating multihits for " << regionDoublets.regionSize() << " regions, and " << trilayers.size() << " pair+3rd layers from " << regionDoublets.layerPairsSize() << " layer pairs"; + + LayerHitMapCache hitCache; + for(const auto& regionLayerPairs: regionDoublets) { + const TrackingRegion& region = regionLayerPairs.region(); + + auto seedingHitSetsFiller = RegionsSeedingHitSets::dummyFiller(); + seedingHitSetsFiller = seedingHitSets->beginRegion(®ion); + + hitCache.clear(); + hitCache.extend(regionLayerPairs.layerHitMapCache()); + + LogTrace("MultiHitFromChi2EDProducer") << " starting region"; + + for(const auto& layerPair: regionLayerPairs) { + LogTrace("MultiHitFromChi2EDProducer") << " starting layer pair " << layerPair.innerLayerIndex() << "," << layerPair.outerLayerIndex(); + + auto found = std::find_if(trilayers.begin(), trilayers.end(), [&](const LayerTriplets::LayerSetAndLayers& a) { + return a.first[0].index() == layerPair.innerLayerIndex() && a.first[1].index() == layerPair.outerLayerIndex(); + }); + if(found == trilayers.end()) { + auto exp = cms::Exception("LogicError") << "Did not find the layer pair from vector. This is a sign of some internal inconsistency\n"; + exp << "I was looking for layer pair " << layerPair.innerLayerIndex() << "," << layerPair.outerLayerIndex() << ". Triplets have the following pairs:\n"; + for(const auto& a: trilayers) { + exp << " " << a.first[0].index() << "," << a.first[1].index() << ": 3rd layers"; + for(const auto& b: a.second) { + exp << " " << b.index(); + } + exp << "\n"; + } + throw exp; + } + const auto& thirdLayers = found->second; + + generator_.hitSets(region, multihits, iEvent, iSetup, layerPair.doublets(), thirdLayers, hitCache, refittedHitStorage); + +#ifdef EDM_ML_DEBUG + LogTrace("MultiHitFromChi2EDProducer") << " created " << multihits.size() << " multihits for layer pair " << layerPair.innerLayerIndex() << "," << layerPair.outerLayerIndex() << " and 3rd layers"; + for(const auto& l: thirdLayers) { + LogTrace("MultiHitFromChi2EDProducer") << " " << l.index(); + } +#endif + + for(const SeedingHitSet& hitSet: multihits) { + seedingHitSetsFiller.emplace_back(hitSet); + } + multihits.clear(); + } + } + localRA_.update(seedingHitSets->size()); + + auto storage = std::make_unique >(); + storage->reserve(refittedHitStorage.size()); + for(auto& ptr: refittedHitStorage) + storage->push_back(ptr.release()); + + seedingHitSets->shrink_to_fit(); + storage->shrink_to_fit(); + iEvent.put(std::move(seedingHitSets)); + iEvent.put(std::move(storage)); +} + +#include "FWCore/PluginManager/interface/ModuleDef.h" +#include "FWCore/Framework/interface/MakerMacros.h" +DEFINE_FWK_MODULE(MultiHitFromChi2EDProducer); diff --git a/RecoTracker/TkSeedGenerator/plugins/MultiHitGeneratorFromChi2.cc b/RecoTracker/TkSeedGenerator/plugins/MultiHitGeneratorFromChi2.cc index 683ccfd1d2638..0b4bd6b9d7440 100644 --- a/RecoTracker/TkSeedGenerator/plugins/MultiHitGeneratorFromChi2.cc +++ b/RecoTracker/TkSeedGenerator/plugins/MultiHitGeneratorFromChi2.cc @@ -1,4 +1,5 @@ #include "RecoTracker/TkSeedGenerator/plugins/MultiHitGeneratorFromChi2.h" +#include "FWCore/ParameterSet/interface/ParameterSetDescription.h" #include "RecoPixelVertexing/PixelTriplets/interface/ThirdHitPredictionFromCircle.h" #include "RecoPixelVertexing/PixelTriplets/plugins/ThirdHitRZPrediction.h" @@ -109,6 +110,39 @@ MultiHitGeneratorFromChi2::MultiHitGeneratorFromChi2(const edm::ParameterSet& cf } MultiHitGeneratorFromChi2::~MultiHitGeneratorFromChi2() {} + + +void MultiHitGeneratorFromChi2::fillDescriptions(edm::ParameterSetDescription& desc) { + MultiHitGeneratorFromPairAndLayers::fillDescriptions(desc); + + // fixed phi filtering + desc.add("useFixedPreFiltering", false); + desc.add("phiPreFiltering", 0.3); + + // box properties + desc.add("extraHitRPhitolerance", 0); + desc.add("extraHitRZtolerance", 0); + desc.add("extraZKDBox", 0.2); + desc.add("extraRKDBox", 0.2); + desc.add("extraPhiKDBox", 0.005); + desc.add("fnSigmaRZ", 2.0); + + // refit&filter hits + desc.add("refitHits", true); + desc.add("ClusterShapeHitFilterName", "ClusterShapeHitFilter"); + desc.add("TTRHBuilder", "WithTrackAngle"); + + // chi2 cuts + desc.add("maxChi2", 5.0); + desc.add("chi2VsPtCut", true); + desc.add >("pt_interv", std::vector{{0.4,0.7,1.0,2.0}}); + desc.add >("chi2_cuts", std::vector{{3.0,4.0,5.0,5.0}}); + + // debugging + desc.add >("detIdsToDebug", std::vector{{0,0,0}}); +} + + void MultiHitGeneratorFromChi2::initES(const edm::EventSetup& es) { @@ -161,17 +195,29 @@ void MultiHitGeneratorFromChi2::hitSets(const TrackingRegion& region, // LogDebug("MultiHitGeneratorFromChi2") << "empy pairs"; return; } + + assert(theLayerCache); + hitSets(region, result, ev, es, doublets, thirdLayers, *theLayerCache, cache); +} + +void MultiHitGeneratorFromChi2::hitSets(const TrackingRegion& region, OrderedMultiHits& result, + const edm::Event& ev, const edm::EventSetup& es, + const HitDoublets& doublets, + const std::vector& thirdLayers, + LayerCacheType& layerCache, + cacheHits& refittedHitStorage) { int size = thirdLayers.size(); const RecHitsSortedInPhi * thirdHitMap[size]; vector thirdLayerDetLayer(size,0); for (int il=0; il & thirdLayerDetLayer, const int nThirdLayers) { + hitSets(region, result, es, doublets, thirdHitMap, thirdLayerDetLayer, nThirdLayers, cache); +} +void MultiHitGeneratorFromChi2::hitSets(const TrackingRegion& region, OrderedMultiHits& result, + const edm::EventSetup& es, + const HitDoublets& doublets, + const RecHitsSortedInPhi **thirdHitMap, + const std::vector& thirdLayerDetLayer, + const int nThirdLayers, + cacheHits& refittedHitStorage) { unsigned int debug_Id0 = detIdsToDebug[0]; unsigned int debug_Id1 = detIdsToDebug[1]; unsigned int debug_Id2 = detIdsToDebug[2]; @@ -637,12 +692,12 @@ void MultiHitGeneratorFromChi2::hitTriplets( assert(bestH2); result.emplace_back(&*hit0,&*hit1,&*bestH2); assert(hit0.isOwn()); assert(hit1.isOwn()); - cache.emplace_back(const_cast(hit0.release())); - cache.emplace_back(const_cast(hit1.release())); - cache.emplace_back(std::move(bestH2)); + refittedHitStorage.emplace_back(const_cast(hit0.release())); + refittedHitStorage.emplace_back(const_cast(hit1.release())); + refittedHitStorage.emplace_back(std::move(bestH2)); assert(hit0.empty()); assert(hit1.empty());assert(!bestH2); } - // LogTrace("MultiHitGeneratorFromChi2") << (usePair ? "pair " : "triplet ") << minChi2 <<' ' << cache.size(); + // LogTrace("MultiHitGeneratorFromChi2") << (usePair ? "pair " : "triplet ") << minChi2 <<' ' << refittedHitStorage.size(); }//loop over pairs diff --git a/RecoTracker/TkSeedGenerator/plugins/MultiHitGeneratorFromChi2.h b/RecoTracker/TkSeedGenerator/plugins/MultiHitGeneratorFromChi2.h index 0952fcf76fa8c..10180b64f66f9 100644 --- a/RecoTracker/TkSeedGenerator/plugins/MultiHitGeneratorFromChi2.h +++ b/RecoTracker/TkSeedGenerator/plugins/MultiHitGeneratorFromChi2.h @@ -33,6 +33,10 @@ typedef CombinedMultiHitGenerator::LayerCacheType LayerCacheType; virtual ~MultiHitGeneratorFromChi2(); + static void fillDescriptions(edm::ParameterSetDescription& desc); + static const char *fillDescriptionsLabel() { return "multiHitFromChi2"; } + + void initES(const edm::EventSetup& es) override; virtual void hitSets( const TrackingRegion& region, OrderedMultiHits & trs, @@ -40,6 +44,13 @@ typedef CombinedMultiHitGenerator::LayerCacheType LayerCacheType; SeedingLayerSetsHits::SeedingLayerSet pairLayers, std::vector thirdLayers); + void hitSets(const TrackingRegion& region, OrderedMultiHits& trs, + const edm::Event& ev, const edm::EventSetup& es, + const HitDoublets& doublets, + const std::vector& thirdLayers, + LayerCacheType& layerCache, + cacheHits& refittedHitStorage); + void hitTriplets( const TrackingRegion& region, OrderedMultiHits & result, @@ -48,6 +59,14 @@ typedef CombinedMultiHitGenerator::LayerCacheType LayerCacheType; const RecHitsSortedInPhi ** thirdHitMap, const std::vector & thirdLayerDetLayer, const int nThirdLayers)override; + + void hitSets(const TrackingRegion& region, OrderedMultiHits& result, + const edm::EventSetup& es, + const HitDoublets& doublets, + const RecHitsSortedInPhi **thirdHitMap, + const std::vector& thirdLayerDetLayer, + const int nThirdLayers, + cacheHits& refittedHitStorage); private: using HitOwnPtr = mayown_ptr; diff --git a/RecoTracker/TkSeedGenerator/plugins/SealModules.cc b/RecoTracker/TkSeedGenerator/plugins/SealModules.cc index 0c9dd46cfd2f8..2ad71ffae8943 100644 --- a/RecoTracker/TkSeedGenerator/plugins/SealModules.cc +++ b/RecoTracker/TkSeedGenerator/plugins/SealModules.cc @@ -28,3 +28,10 @@ DEFINE_EDM_PLUGIN(OrderedHitsGeneratorFactory, CombinedMultiHitGenerator, "Stand #include "RecoTracker/TkSeedGenerator/interface/MultiHitGeneratorFromPairAndLayers.h" #include "RecoTracker/TkSeedGenerator/interface/MultiHitGeneratorFromPairAndLayersFactory.h" DEFINE_EDM_PLUGIN(MultiHitGeneratorFromPairAndLayersFactory, MultiHitGeneratorFromChi2, "MultiHitGeneratorFromChi2"); + +#include "RecoTracker/TkSeedGenerator/interface/SeedCreatorFromRegionHitsEDProducerT.h" +using SeedCreatorFromRegionConsecutiveHitsEDProducer = SeedCreatorFromRegionHitsEDProducerT; +DEFINE_FWK_MODULE(SeedCreatorFromRegionConsecutiveHitsEDProducer); + +using SeedCreatorFromRegionConsecutiveHitsTripletOnlyEDProducer = SeedCreatorFromRegionHitsEDProducerT; +DEFINE_FWK_MODULE(SeedCreatorFromRegionConsecutiveHitsTripletOnlyEDProducer); diff --git a/RecoTracker/TkSeedGenerator/plugins/SeedFromConsecutiveHitsCreator.cc b/RecoTracker/TkSeedGenerator/plugins/SeedFromConsecutiveHitsCreator.cc index bee617d88bd82..853084305e63e 100644 --- a/RecoTracker/TkSeedGenerator/plugins/SeedFromConsecutiveHitsCreator.cc +++ b/RecoTracker/TkSeedGenerator/plugins/SeedFromConsecutiveHitsCreator.cc @@ -5,7 +5,8 @@ #include "RecoTracker/TkSeedGenerator/interface/FastHelix.h" #include "Geometry/Records/interface/TrackerDigiGeometryRecord.h" #include "FWCore/MessageLogger/interface/MessageLogger.h" -#include +#include "FWCore/Utilities/interface/ESInputTag.h" +#include "FWCore/ParameterSet/interface/ParameterSetDescription.h" #include "MagneticField/Records/interface/IdealMagneticFieldRecord.h" #include "TrackingTools/Records/interface/TrackingComponentsRecord.h" #include "TrackingTools/Records/interface/TransientRecHitRecord.h" @@ -24,6 +25,16 @@ namespace { SeedFromConsecutiveHitsCreator::~SeedFromConsecutiveHitsCreator(){} +void SeedFromConsecutiveHitsCreator::fillDescriptions(edm::ParameterSetDescription& desc) { + desc.add("propagator", "PropagatorWithMaterialParabolicMf"); + desc.add("SeedMomentumForBOFF", 5.0); + desc.add("OriginTransverseErrorMultiplier", 1.0); + desc.add("MinOneOverPtError", 1.0); + desc.add("TTRHBuilder", "WithTrackAngle"); + desc.add("magneticField", "ParabolicMf"); + desc.add("forceKinematicWithRegionDirection", false); +} + void SeedFromConsecutiveHitsCreator::init(const TrackingRegion & iregion, const edm::EventSetup& es, const SeedComparitor *ifilter) { diff --git a/RecoTracker/TkSeedGenerator/plugins/SeedFromConsecutiveHitsCreator.h b/RecoTracker/TkSeedGenerator/plugins/SeedFromConsecutiveHitsCreator.h index c0a34c1beddda..f167b68ae7d48 100644 --- a/RecoTracker/TkSeedGenerator/plugins/SeedFromConsecutiveHitsCreator.h +++ b/RecoTracker/TkSeedGenerator/plugins/SeedFromConsecutiveHitsCreator.h @@ -15,7 +15,7 @@ #include "DataFormats/TrackerRecHit2D/interface/BaseTrackerRecHit.h" #include "DataFormats/TrackingRecHit/interface/mayown_ptr.h" - +namespace edm { class ParameterSetDescription; } class FreeTrajectoryState; class dso_hidden SeedFromConsecutiveHitsCreator : public SeedCreator { @@ -34,6 +34,9 @@ class dso_hidden SeedFromConsecutiveHitsCreator : public SeedCreator { //dtor virtual ~SeedFromConsecutiveHitsCreator(); + static void fillDescriptions(edm::ParameterSetDescription& desc); + static const char *fillDescriptionsLabel() { return "ConsecutiveHits"; } + // initialize the "event dependent state" virtual void init(const TrackingRegion & region, const edm::EventSetup& es, diff --git a/RecoTracker/TkSeedGenerator/plugins/SeedFromConsecutiveHitsTripletOnlyCreator.h b/RecoTracker/TkSeedGenerator/plugins/SeedFromConsecutiveHitsTripletOnlyCreator.h index e11178c5cd471..e8a32e6404abf 100644 --- a/RecoTracker/TkSeedGenerator/plugins/SeedFromConsecutiveHitsTripletOnlyCreator.h +++ b/RecoTracker/TkSeedGenerator/plugins/SeedFromConsecutiveHitsTripletOnlyCreator.h @@ -9,6 +9,11 @@ class dso_hidden SeedFromConsecutiveHitsTripletOnlyCreator final : public SeedFr SeedFromConsecutiveHitsTripletOnlyCreator( const edm::ParameterSet & cfg): SeedFromConsecutiveHitsCreator(cfg) { } + static void fillDescriptions(edm::ParameterSetDescription& desc) { + SeedFromConsecutiveHitsCreator::fillDescriptions(desc); + } + static const char *fillDescriptionsLabel() { return "ConsecutiveHitsTripletOnly"; } + virtual ~SeedFromConsecutiveHitsTripletOnlyCreator(){} private: diff --git a/RecoTracker/TkSeedGenerator/python/multiHitFromChi2EDProducer_cfi.py b/RecoTracker/TkSeedGenerator/python/multiHitFromChi2EDProducer_cfi.py new file mode 100644 index 0000000000000..3fd06df88d67f --- /dev/null +++ b/RecoTracker/TkSeedGenerator/python/multiHitFromChi2EDProducer_cfi.py @@ -0,0 +1,5 @@ +from RecoTracker.TkSeedGenerator.multiHitFromChi2EDProducerDefault_cfi import multiHitFromChi2EDProducerDefault as _multiHitFromChi2EDProducerDefault +multiHitFromChi2EDProducer = _multiHitFromChi2EDProducerDefault.clone() + +from Configuration.Eras.Modifier_peripheralPbPb_cff import peripheralPbPb +peripheralPbPb.toModify(multiHitFromChi2EDProducer, maxElement = 1000000) diff --git a/RecoTracker/TkSeedGenerator/python/seedCreatorFromRegionConsecutiveHitsEDProducer_cff.py b/RecoTracker/TkSeedGenerator/python/seedCreatorFromRegionConsecutiveHitsEDProducer_cff.py new file mode 100644 index 0000000000000..d99e306682358 --- /dev/null +++ b/RecoTracker/TkSeedGenerator/python/seedCreatorFromRegionConsecutiveHitsEDProducer_cff.py @@ -0,0 +1,11 @@ +from RecoTracker.TkSeedGenerator.seedCreatorFromRegionConsecutiveHitsEDProducer_cfi import * +from Configuration.Eras.Modifier_trackingPhase1PU70_cff import trackingPhase1PU70 +from Configuration.Eras.Modifier_trackingPhase2PU140_cff import trackingPhase2PU140 +trackingPhase1PU70.toModify(seedCreatorFromRegionConsecutiveHitsEDProducer, + magneticField = '', + propagator = 'PropagatorWithMaterial', +) +trackingPhase2PU140.toModify(seedCreatorFromRegionConsecutiveHitsEDProducer, + magneticField = '', + propagator = 'PropagatorWithMaterial', +) diff --git a/RecoTracker/TkSeedGenerator/python/seedCreatorFromRegionConsecutiveHitsTripletOnlyEDProducer_cff.py b/RecoTracker/TkSeedGenerator/python/seedCreatorFromRegionConsecutiveHitsTripletOnlyEDProducer_cff.py new file mode 100644 index 0000000000000..71fd7b0c9000b --- /dev/null +++ b/RecoTracker/TkSeedGenerator/python/seedCreatorFromRegionConsecutiveHitsTripletOnlyEDProducer_cff.py @@ -0,0 +1,11 @@ +from RecoTracker.TkSeedGenerator.seedCreatorFromRegionConsecutiveHitsTripletOnlyEDProducer_cfi import * +from Configuration.Eras.Modifier_trackingPhase1PU70_cff import trackingPhase1PU70 +from Configuration.Eras.Modifier_trackingPhase2PU140_cff import trackingPhase2PU140 +trackingPhase1PU70.toModify(seedCreatorFromRegionConsecutiveHitsTripletOnlyEDProducer, + magneticField = '', + propagator = 'PropagatorWithMaterial', +) +trackingPhase2PU140.toModify(seedCreatorFromRegionConsecutiveHitsTripletOnlyEDProducer, + magneticField = '', + propagator = 'PropagatorWithMaterial', +) diff --git a/RecoTracker/TkSeedGenerator/python/trackerClusterCheck_cfi.py b/RecoTracker/TkSeedGenerator/python/trackerClusterCheck_cfi.py new file mode 100644 index 0000000000000..0c808ebd13594 --- /dev/null +++ b/RecoTracker/TkSeedGenerator/python/trackerClusterCheck_cfi.py @@ -0,0 +1,13 @@ +from RecoTracker.TkSeedGenerator.trackerClusterCheckDefault_cfi import trackerClusterCheckDefault as _trackerClusterCheckDefault +trackerClusterCheck = _trackerClusterCheckDefault.clone() + +from Configuration.Eras.Modifier_phase1Pixel_cff import phase1Pixel +from Configuration.Eras.Modifier_phase2_tracker_cff import phase2_tracker +# Disable too many clusters check until we have an updated cut string for phase1 and phase2 +phase1Pixel.toModify(trackerClusterCheck, doClusterCheck=False) # FIXME +phase2_tracker.toModify(trackerClusterCheck, doClusterCheck=False) # FIXME + +from Configuration.Eras.Modifier_peripheralPbPb_cff import peripheralPbPb +peripheralPbPb.toModify(trackerClusterCheck, + cut = "strip < 400000 && pixel < 40000 && (strip < 60000 + 7.0*pixel) && (pixel < 8000 + 0.14*strip)" +) diff --git a/RecoTracker/TkSeedGenerator/src/ClusterChecker.cc b/RecoTracker/TkSeedGenerator/src/ClusterChecker.cc index 71371a6b1fd74..01a70790773ba 100644 --- a/RecoTracker/TkSeedGenerator/src/ClusterChecker.cc +++ b/RecoTracker/TkSeedGenerator/src/ClusterChecker.cc @@ -3,6 +3,7 @@ #include "FWCore/Framework/interface/Event.h" #include "DataFormats/Common/interface/Handle.h" #include "FWCore/ParameterSet/interface/ParameterSet.h" +#include "FWCore/ParameterSet/interface/ParameterSetDescription.h" #include "FWCore/MessageLogger/interface/MessageLogger.h" @@ -33,6 +34,15 @@ ClusterChecker::ClusterChecker(const edm::ParameterSet & conf, } } +void ClusterChecker::fillDescriptions(edm::ParameterSetDescription& desc) { + desc.add("doClusterCheck", true); + desc.add("MaxNumberOfCosmicClusters", 400000); + desc.add("ClusterCollectionLabel", edm::InputTag("siStripClusters")); + desc.add("MaxNumberOfPixelClusters", 40000); + desc.add("PixelClusterCollectionLabel", edm::InputTag("siPixelClusters")); + desc.add("cut", "strip < 400000 && pixel < 40000 && (strip < 50000 + 10*pixel) && (pixel < 5000 + 0.1*strip)"); +} + ClusterChecker::~ClusterChecker() { diff --git a/RecoTracker/TkSeedGenerator/src/MultiHitGeneratorFromPairAndLayers.cc b/RecoTracker/TkSeedGenerator/src/MultiHitGeneratorFromPairAndLayers.cc index c30bee5bf3dd6..83d514cfe7281 100644 --- a/RecoTracker/TkSeedGenerator/src/MultiHitGeneratorFromPairAndLayers.cc +++ b/RecoTracker/TkSeedGenerator/src/MultiHitGeneratorFromPairAndLayers.cc @@ -1,6 +1,7 @@ #include "RecoTracker/TkSeedGenerator/interface/MultiHitGeneratorFromPairAndLayers.h" #include "RecoTracker/TkHitPairs/interface/HitPairGeneratorFromLayerPair.h" #include "FWCore/ParameterSet/interface/ParameterSet.h" +#include "FWCore/ParameterSet/interface/ParameterSetDescription.h" MultiHitGeneratorFromPairAndLayers::MultiHitGeneratorFromPairAndLayers(const edm::ParameterSet& pset): theLayerCache(nullptr), @@ -9,6 +10,10 @@ MultiHitGeneratorFromPairAndLayers::MultiHitGeneratorFromPairAndLayers(const edm MultiHitGeneratorFromPairAndLayers::~MultiHitGeneratorFromPairAndLayers() {} +void MultiHitGeneratorFromPairAndLayers::fillDescriptions(edm::ParameterSetDescription& desc) { + desc.add("maxElement", 1000000); +} + void MultiHitGeneratorFromPairAndLayers::init(std::unique_ptr&& pairGenerator, LayerCacheType *layerCache) { thePairGenerator = std::move(pairGenerator); theLayerCache = layerCache; diff --git a/RecoTracker/TkSeedingLayers/BuildFile.xml b/RecoTracker/TkSeedingLayers/BuildFile.xml index 1ddf32f90252e..5711f340fe0ab 100644 --- a/RecoTracker/TkSeedingLayers/BuildFile.xml +++ b/RecoTracker/TkSeedingLayers/BuildFile.xml @@ -1,5 +1,6 @@ + diff --git a/RecoTracker/TkSeedingLayers/src/classes.h b/RecoTracker/TkSeedingLayers/src/classes.h new file mode 100644 index 0000000000000..4a65739ddea37 --- /dev/null +++ b/RecoTracker/TkSeedingLayers/src/classes.h @@ -0,0 +1,11 @@ +#include "RecoTracker/TkSeedingLayers/interface/SeedingHitSet.h" +#include "DataFormats/Common/interface/Wrapper.h" + +#include + +namespace RecoTracker_TkSeedingLayers { + struct dictionary { + std::vector vshs; + edm::Wrapper > wvshs; + }; +} diff --git a/RecoTracker/TkSeedingLayers/src/classes_def.xml b/RecoTracker/TkSeedingLayers/src/classes_def.xml new file mode 100644 index 0000000000000..9f36952c307c7 --- /dev/null +++ b/RecoTracker/TkSeedingLayers/src/classes_def.xml @@ -0,0 +1,4 @@ + + + + diff --git a/RecoTracker/TkTrackingRegions/BuildFile.xml b/RecoTracker/TkTrackingRegions/BuildFile.xml index 93b209f4c16a0..1ce49d49f34e5 100644 --- a/RecoTracker/TkTrackingRegions/BuildFile.xml +++ b/RecoTracker/TkTrackingRegions/BuildFile.xml @@ -1,5 +1,6 @@ + diff --git a/RecoTracker/TkTrackingRegions/interface/GlobalTrackingRegion.h b/RecoTracker/TkTrackingRegions/interface/GlobalTrackingRegion.h index 1386c51f54099..9de4285f13ded 100644 --- a/RecoTracker/TkTrackingRegions/interface/GlobalTrackingRegion.h +++ b/RecoTracker/TkTrackingRegions/interface/GlobalTrackingRegion.h @@ -34,7 +34,6 @@ class GlobalTrackingRegion final : public TrackingRegion { thePrecise(precise) { } TrackingRegion::Hits hits( - const edm::Event& ev, const edm::EventSetup& es, const SeedingLayerSetsHits::SeedingLayer& layer) const override; diff --git a/RecoTracker/TkTrackingRegions/interface/RectangularEtaPhiTrackingRegion.h b/RecoTracker/TkTrackingRegions/interface/RectangularEtaPhiTrackingRegion.h index 5769755e46ba3..e7376099c4d21 100644 --- a/RecoTracker/TkTrackingRegions/interface/RectangularEtaPhiTrackingRegion.h +++ b/RecoTracker/TkTrackingRegions/interface/RectangularEtaPhiTrackingRegion.h @@ -157,7 +157,6 @@ class RectangularEtaPhiTrackingRegion final : public TrackingRegion { bool isPrecise() const { return thePrecise; } virtual TrackingRegion::Hits hits( - const edm::Event& ev, const edm::EventSetup& es, const SeedingLayerSetsHits::SeedingLayer& layer) const override; diff --git a/RecoTracker/TkTrackingRegions/interface/TrackingRegion.h b/RecoTracker/TkTrackingRegions/interface/TrackingRegion.h index 2874271870d6e..bd02430aef83d 100644 --- a/RecoTracker/TkTrackingRegions/interface/TrackingRegion.h +++ b/RecoTracker/TkTrackingRegions/interface/TrackingRegion.h @@ -96,9 +96,7 @@ class TrackingRegion { /// get hits from layer compatible with region constraints - virtual Hits hits( - const edm::Event& ev, - const edm::EventSetup& es, + virtual Hits hits(const edm::EventSetup& es, const SeedingLayerSetsHits::SeedingLayer& layer) const = 0; /// clone region with new vertex position diff --git a/RecoTracker/TkTrackingRegions/interface/TrackingRegionEDProducerT.h b/RecoTracker/TkTrackingRegions/interface/TrackingRegionEDProducerT.h new file mode 100644 index 0000000000000..5d71e9ef264aa --- /dev/null +++ b/RecoTracker/TkTrackingRegions/interface/TrackingRegionEDProducerT.h @@ -0,0 +1,45 @@ +#ifndef RecoTracker_TkTrackingRegions_TrackingRegionEDProducerT_H +#define RecoTracker_TkTrackingRegions_TrackingRegionEDProducerT_H + +#include "FWCore/Framework/interface/stream/EDProducer.h" +#include "FWCore/Framework/interface/ConsumesCollector.h" +#include "FWCore/ParameterSet/interface/ParameterSet.h" + +#include "RecoTracker/TkTrackingRegions/interface/TrackingRegion.h" +#include "DataFormats/Common/interface/OwnVector.h" + +template +class TrackingRegionEDProducerT: public edm::stream::EDProducer<> { +public: + // using OwnVector as vector and vector cause problems + // I can't get dictionary compiled with unique_ptr + // shared_ptr fails with runtime error "Class name 'TrackingRegionstdshared_ptrs' contains an underscore ('_'), which is illegal in the name of a product." + using ProductType = edm::OwnVector; + + TrackingRegionEDProducerT(const edm::ParameterSet& iConfig): + regionProducer_(iConfig, consumesCollector()) { + produces(); + } + + ~TrackingRegionEDProducerT() = default; + + static void fillDescriptions(edm::ConfigurationDescriptions& descriptions) { + T_TrackingRegionProducer::fillDescriptions(descriptions); + } + + virtual void produce(edm::Event& iEvent, const edm::EventSetup& iSetup) override { + auto regions = regionProducer_.regions(iEvent, iSetup); + auto ret = std::make_unique(); + ret->reserve(regions.size()); + for(auto& regionPtr: regions) { + ret->push_back(regionPtr.release()); + } + + iEvent.put(std::move(ret)); + } + +private: + T_TrackingRegionProducer regionProducer_; +}; + +#endif diff --git a/RecoTracker/TkTrackingRegions/plugins/GlobalTrackingRegionProducerFromBeamSpot.h b/RecoTracker/TkTrackingRegions/plugins/GlobalTrackingRegionProducerFromBeamSpot.h index 1fbd231c070ea..22fd77512a279 100644 --- a/RecoTracker/TkTrackingRegions/plugins/GlobalTrackingRegionProducerFromBeamSpot.h +++ b/RecoTracker/TkTrackingRegions/plugins/GlobalTrackingRegionProducerFromBeamSpot.h @@ -4,6 +4,8 @@ #include "RecoTracker/TkTrackingRegions/interface/TrackingRegionProducer.h" #include "RecoTracker/TkTrackingRegions/interface/GlobalTrackingRegion.h" #include "FWCore/ParameterSet/interface/ParameterSet.h" +#include "FWCore/ParameterSet/interface/ConfigurationDescriptions.h" +#include "FWCore/ParameterSet/interface/ParameterSetDescription.h" #include "DataFormats/BeamSpot/interface/BeamSpot.h" #include "FWCore/Utilities/interface/InputTag.h" #include "FWCore/Utilities/interface/Exception.h" @@ -36,6 +38,44 @@ class GlobalTrackingRegionProducerFromBeamSpot : public TrackingRegionProducer { virtual ~GlobalTrackingRegionProducerFromBeamSpot(){} + static void fillDescriptions(edm::ConfigurationDescriptions& descriptions) { + { + edm::ParameterSetDescription desc; + + desc.add("precise", true); + desc.add("useMultipleScattering", false); + desc.add("nSigmaZ", 4.0); + desc.add("originHalfLength", 0.0); // this is the default in constructor + desc.add("originRadius", 0.2); + desc.add("ptMin", 0.9); + desc.add("beamSpot", edm::InputTag("offlineBeamSpot")); + + // Only for backwards-compatibility + edm::ParameterSetDescription descRegion; + descRegion.add("RegionPSet", desc); + + descriptions.add("globalTrackingRegionFromBeamSpot", descRegion); + } + + { + edm::ParameterSetDescription desc; + + desc.add("precise", true); + desc.add("useMultipleScattering", false); + desc.add("nSigmaZ", 0.0); // this is the default in constructor + desc.add("originHalfLength", 21.2); + desc.add("originRadius", 0.2); + desc.add("ptMin", 0.9); + desc.add("beamSpot", edm::InputTag("offlineBeamSpot")); + + // Only for backwards-compatibility + edm::ParameterSetDescription descRegion; + descRegion.add("RegionPSet", desc); + + descriptions.add("globalTrackingRegionFromBeamSpotFixedZ", descRegion); + } + } + virtual std::vector > regions(const edm::Event&ev, const edm::EventSetup&) const override { std::vector > result; edm::Handle bsHandle; diff --git a/RecoTracker/TkTrackingRegions/plugins/GlobalTrackingRegionWithVerticesProducer.h b/RecoTracker/TkTrackingRegions/plugins/GlobalTrackingRegionWithVerticesProducer.h index cff32e357208a..d2e321a93a64b 100644 --- a/RecoTracker/TkTrackingRegions/plugins/GlobalTrackingRegionWithVerticesProducer.h +++ b/RecoTracker/TkTrackingRegions/plugins/GlobalTrackingRegionWithVerticesProducer.h @@ -39,6 +39,29 @@ class GlobalTrackingRegionWithVerticesProducer : public TrackingRegionProducer virtual ~GlobalTrackingRegionWithVerticesProducer(){} + static void fillDescriptions(edm::ConfigurationDescriptions& descriptions) { + edm::ParameterSetDescription desc; + + desc.add("precise", true); + desc.add("useMultipleScattering", false); + desc.add("beamSpot", edm::InputTag("offlineBeamSpot")); + desc.add("useFixedError", true); + desc.add("originRadius", 0.2); + desc.add("sigmaZVertex", 3.0); + desc.add("fixedError", 0.2); + desc.add("VertexCollection", edm::InputTag("firstStepPrimaryVertices")); + desc.add("ptMin", 0.9); + desc.add("useFoundVertices", true); + desc.add("useFakeVertices", false); + desc.add("nSigmaZ", 4.0); + + // Only for backwards-compatibility + edm::ParameterSetDescription descRegion; + descRegion.add("RegionPSet", desc); + + descriptions.add("globalTrackingRegionWithVertices", descRegion); + } + virtual std::vector > regions (const edm::Event& ev, const edm::EventSetup&) const override { diff --git a/RecoTracker/TkTrackingRegions/plugins/SealModule.cc b/RecoTracker/TkTrackingRegions/plugins/SealModule.cc index 5ad4b2cbf4c48..08bf475431b0f 100644 --- a/RecoTracker/TkTrackingRegions/plugins/SealModule.cc +++ b/RecoTracker/TkTrackingRegions/plugins/SealModule.cc @@ -16,3 +16,9 @@ DEFINE_EDM_PLUGIN(TrackingRegionProducerFactory, GlobalTrackingRegionWithVertice DEFINE_EDM_PLUGIN(TrackingRegionProducerFactory, PointSeededTrackingRegionsProducer, "PointSeededTrackingRegionsProducer"); +#include "RecoTracker/TkTrackingRegions/interface/TrackingRegionEDProducerT.h" +using GlobalTrackinRegionFromBeamSpotEDProducer = TrackingRegionEDProducerT; +DEFINE_FWK_MODULE(GlobalTrackinRegionFromBeamSpotEDProducer); + +using GlobalTrackingRegionWithVerticesEDProducer = TrackingRegionEDProducerT; +DEFINE_FWK_MODULE(GlobalTrackingRegionWithVerticesEDProducer); diff --git a/RecoTracker/TkTrackingRegions/python/globalTrackingRegionWithVertices_cff.py b/RecoTracker/TkTrackingRegions/python/globalTrackingRegionWithVertices_cff.py new file mode 100644 index 0000000000000..e75611cb93d2c --- /dev/null +++ b/RecoTracker/TkTrackingRegions/python/globalTrackingRegionWithVertices_cff.py @@ -0,0 +1,7 @@ +from RecoTracker.TkTrackingRegions.globalTrackingRegionWithVertices_cfi import * +from Configuration.Eras.Modifier_trackingLowPU_cff import trackingLowPU +from Configuration.Eras.Modifier_trackingPhase1PU70_cff import trackingPhase1PU70 +from Configuration.Eras.Modifier_trackingPhase2PU140_cff import trackingPhase2PU140 +trackingLowPU.toModify(globalTrackingRegionWithVertices, RegionPSet = dict(VertexCollection = "pixelVertices")) +trackingPhase1PU70.toModify(globalTrackingRegionWithVertices, RegionPSet = dict(VertexCollection = "pixelVertices")) +trackingPhase2PU140.toModify(globalTrackingRegionWithVertices, RegionPSet = dict(VertexCollection = "pixelVertices")) diff --git a/RecoTracker/TkTrackingRegions/src/GlobalTrackingRegion.cc b/RecoTracker/TkTrackingRegions/src/GlobalTrackingRegion.cc index 422f20e0d7fb4..4cdab498eeb62 100644 --- a/RecoTracker/TkTrackingRegions/src/GlobalTrackingRegion.cc +++ b/RecoTracker/TkTrackingRegions/src/GlobalTrackingRegion.cc @@ -25,7 +25,6 @@ std::string GlobalTrackingRegion::print() const { } TrackingRegion::Hits GlobalTrackingRegion::hits( - const edm::Event& ev, const edm::EventSetup& es, const SeedingLayerSetsHits::SeedingLayer& layer) const { return layer.hits(); diff --git a/RecoTracker/TkTrackingRegions/src/RectangularEtaPhiTrackingRegion.cc b/RecoTracker/TkTrackingRegions/src/RectangularEtaPhiTrackingRegion.cc index 0e2c3ba251fd9..24c56d8f1b2b7 100644 --- a/RecoTracker/TkTrackingRegions/src/RectangularEtaPhiTrackingRegion.cc +++ b/RecoTracker/TkTrackingRegions/src/RectangularEtaPhiTrackingRegion.cc @@ -300,7 +300,6 @@ HitRZConstraint } TrackingRegion::Hits RectangularEtaPhiTrackingRegion::hits( - const edm::Event& ev, const edm::EventSetup& es, const SeedingLayerSetsHits::SeedingLayer& layer) const { TrackingRegion::Hits result; diff --git a/RecoTracker/TkTrackingRegions/src/classes.h b/RecoTracker/TkTrackingRegions/src/classes.h new file mode 100644 index 0000000000000..ffc069a394bfa --- /dev/null +++ b/RecoTracker/TkTrackingRegions/src/classes.h @@ -0,0 +1,10 @@ +#include "RecoTracker/TkTrackingRegions/interface/TrackingRegion.h" +#include "DataFormats/Common/interface/OwnVector.h" +#include "DataFormats/Common/interface/Wrapper.h" + +namespace RecoTracker_TkTrackingRegions { + struct dictionary { + edm::OwnVector ovtr; + edm::Wrapper > wovtr; + }; +} diff --git a/RecoTracker/TkTrackingRegions/src/classes_def.xml b/RecoTracker/TkTrackingRegions/src/classes_def.xml new file mode 100644 index 0000000000000..111a5944d4064 --- /dev/null +++ b/RecoTracker/TkTrackingRegions/src/classes_def.xml @@ -0,0 +1,5 @@ + + + + + diff --git a/TrackingTools/TransientTrackingRecHit/interface/SeedingLayerSetsHits.h b/TrackingTools/TransientTrackingRecHit/interface/SeedingLayerSetsHits.h index 70840a54f5f11..c4fbacadca81b 100644 --- a/TrackingTools/TransientTrackingRecHit/interface/SeedingLayerSetsHits.h +++ b/TrackingTools/TransientTrackingRecHit/interface/SeedingLayerSetsHits.h @@ -107,6 +107,25 @@ class SeedingLayerSetsHits { /// Number of layers in this set LayerSetIndex size() const { return end_-begin_; } + /** + * Slices the layer set + * + * E.g. slicing BPix1+BPix2+BPix3+BPix4 with (0,2) will give + * BPix1+BPix2. + * + * \param begin Index for the first layer of the slice + * \param end Index for the one-beyond-last layer of the slice + * + * It is caller's responsibility to guarantee that "begin < + * size()" and "0 < end <= size()" and "begin < end". + */ + SeedingLayerSet slice(size_t begin, size_t end) const { + assert(begin < size()); + assert(0 < end && end <= size()); + assert(begin < end); + return SeedingLayerSet(seedingLayerSets_, begin_+begin, begin_+end); + } + /// Get a given SeedingLayer (index is between 0 and size()-1) SeedingLayer operator[](LayerSetIndex index) const { return SeedingLayer(seedingLayerSets_, *(begin_+index)); diff --git a/Validation/RecoTrack/python/TrackValidation_cff.py b/Validation/RecoTrack/python/TrackValidation_cff.py index 158dbb005ee24..426d0fdeb19ed 100644 --- a/Validation/RecoTrack/python/TrackValidation_cff.py +++ b/Validation/RecoTrack/python/TrackValidation_cff.py @@ -176,16 +176,29 @@ def _setForEra(module, eraName, era, **kwargs): def _getSeedingLayers(seedProducers): import RecoTracker.IterativeTracking.iterativeTk_cff as _iterativeTk_cff + def _findSeedingLayers(name): + prod = getattr(_iterativeTk_cff, name) + if hasattr(prod, "triplets"): + if hasattr(prod, "layerList"): # merger + return prod.layerList.refToPSet_.value() + return _findSeedingLayers(prod.triplets.getModuleLabel()) + elif hasattr(prod, "doublets"): + return _findSeedingLayers(prod.doublets.getModuleLabel()) + return prod.seedingLayers.getModuleLabel() + seedingLayersMerged = [] for seedName in seedProducers: seedProd = getattr(_iterativeTk_cff, seedName) - if not hasattr(seedProd, "OrderedHitsFactoryPSet"): + if hasattr(seedProd, "OrderedHitsFactoryPSet"): + if hasattr(seedProd, "SeedMergerPSet"): + seedingLayersName = seedProd.SeedMergerPSet.layerList.refToPSet_.value() + else: + seedingLayersName = seedProd.OrderedHitsFactoryPSet.SeedingLayers.getModuleLabel() + elif hasattr(seedProd, "seedingHitSets"): + seedingLayersName = _findSeedingLayers(seedProd.seedingHitSets.getModuleLabel()) + else: continue - if hasattr(seedProd, "SeedMergerPSet"): - seedingLayersName = seedProd.SeedMergerPSet.layerList.refToPSet_.value() - else: - seedingLayersName = seedProd.OrderedHitsFactoryPSet.SeedingLayers.getModuleLabel() seedingLayers = getattr(_iterativeTk_cff, seedingLayersName).layerList.value() for layerSet in seedingLayers: if layerSet not in seedingLayersMerged: diff --git a/Validation/RecoTrack/python/plotting/trackingPlots.py b/Validation/RecoTrack/python/plotting/trackingPlots.py index 51718ee4b58cf..4a5fafcaf06e0 100644 --- a/Validation/RecoTrack/python/plotting/trackingPlots.py +++ b/Validation/RecoTrack/python/plotting/trackingPlots.py @@ -1077,7 +1077,9 @@ def _set(param, name, modules): setattr(self, name, modules) _set(clusterMasking, "_clusterMasking", [self._name+"Clusters"]) - _set(seeding, "_seeding", [self._name+"SeedingLayers", self._name+"Seeds"]) + # 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"]) _set(fit, "_fit", [self._name+"Tracks"]) _set(selection, "_selection", [self._name]) @@ -1119,6 +1121,10 @@ def modules(self): _iterations = [ Iteration("initialStepPreSplitting", clusterMasking=[], seeding=["initialStepSeedLayersPreSplitting", + "initialStepTrackingRegionsPreSplitting", + "initialStepHitDoubletsPreSplitting", + "initialStepHitTripletsPreSplitting", + "initialStepHitQuadrupletsPreSplitting", "initialStepSeedsPreSplitting"], building=["initialStepTrackCandidatesPreSplitting"], fit=["initialStepTracksPreSplitting"], @@ -1156,6 +1162,12 @@ def modules(self): Iteration("mixedTripletStep", seeding=["mixedTripletStepSeedLayersA", "mixedTripletStepSeedLayersB", + "mixedTripletStepTrackingRegionsA", + "mixedTripletStepTrackingRegionsB", + "mixedTripletStepHitDoubletsA", + "mixedTripletStepHitDoubletsB", + "mixedTripletStepHitTripletsA", + "mixedTripletStepHitTripletsB", "mixedTripletStepSeedsA", "mixedTripletStepSeedsB", "mixedTripletStepSeeds"], @@ -1169,6 +1181,11 @@ def modules(self): Iteration("tobTecStep", seeding=["tobTecStepSeedLayersTripl", "tobTecStepSeedLayersPair", + "tobTecStepTrackingRegionsTripl", + "tobTecStepTrackingRegionsPair", + "tobTecStepHitDoubletsTripl", + "tobTecStepHitDoubletsPair", + "tobTecStepHitTripletsTripl", "tobTecStepSeedsTripl", "tobTecStepSeedsPair", "tobTecStepSeeds"], @@ -1210,6 +1227,9 @@ def modules(self): building=["convTrackCandidates"], fit=["convStepTracks"], selection=["convStepSelector"]), + Iteration("Other", clusterMasking=[], seeding=[], building=[], fit=[], selection=[], + other=["trackerClusterCheckPreSplitting", + "trackerClusterCheck"]), ] def _iterModuleMap(includeConvStep=True, onlyConvStep=False):