diff --git a/Configuration/ProcessModifiers/python/trackingMkFitCommon_cff.py b/Configuration/ProcessModifiers/python/trackingMkFitCommon_cff.py new file mode 100644 index 0000000000000..d6ddd4f9ba133 --- /dev/null +++ b/Configuration/ProcessModifiers/python/trackingMkFitCommon_cff.py @@ -0,0 +1,4 @@ +import FWCore.ParameterSet.Config as cms + +# This modifier does iteration-independent changes for enabling mkFit +trackingMkFitCommon = cms.Modifier() diff --git a/Configuration/ProcessModifiers/python/trackingMkFitDetachedQuadStep_cff.py b/Configuration/ProcessModifiers/python/trackingMkFitDetachedQuadStep_cff.py new file mode 100644 index 0000000000000..18bd2a903f982 --- /dev/null +++ b/Configuration/ProcessModifiers/python/trackingMkFitDetachedQuadStep_cff.py @@ -0,0 +1,4 @@ +import FWCore.ParameterSet.Config as cms + +# This modifier sets replaces the default pattern recognition with mkFit for detachedQuadStep +trackingMkFitDetachedQuadStep = cms.Modifier() diff --git a/Configuration/ProcessModifiers/python/trackingMkFitDetachedTripletStep_cff.py b/Configuration/ProcessModifiers/python/trackingMkFitDetachedTripletStep_cff.py new file mode 100644 index 0000000000000..9cb5bcf705357 --- /dev/null +++ b/Configuration/ProcessModifiers/python/trackingMkFitDetachedTripletStep_cff.py @@ -0,0 +1,4 @@ +import FWCore.ParameterSet.Config as cms + +# This modifier sets replaces the default pattern recognition with mkFit for detachedTripletStep +trackingMkFitDetachedTripletStep = cms.Modifier() diff --git a/Configuration/ProcessModifiers/python/trackingMkFitHighPtTripletStep_cff.py b/Configuration/ProcessModifiers/python/trackingMkFitHighPtTripletStep_cff.py new file mode 100644 index 0000000000000..4db29d1d80275 --- /dev/null +++ b/Configuration/ProcessModifiers/python/trackingMkFitHighPtTripletStep_cff.py @@ -0,0 +1,4 @@ +import FWCore.ParameterSet.Config as cms + +# This modifier sets replaces the default pattern recognition with mkFit for highPtTripletStep +trackingMkFitHighPtTripletStep = cms.Modifier() diff --git a/Configuration/ProcessModifiers/python/trackingMkFitInitialStep_cff.py b/Configuration/ProcessModifiers/python/trackingMkFitInitialStep_cff.py new file mode 100644 index 0000000000000..3c4445795d201 --- /dev/null +++ b/Configuration/ProcessModifiers/python/trackingMkFitInitialStep_cff.py @@ -0,0 +1,4 @@ +import FWCore.ParameterSet.Config as cms + +# This modifier sets replaces the default pattern recognition with mkFit for initialStep +trackingMkFitInitialStep = cms.Modifier() diff --git a/Configuration/ProcessModifiers/python/trackingMkFitLowPtQuadStep_cff.py b/Configuration/ProcessModifiers/python/trackingMkFitLowPtQuadStep_cff.py new file mode 100644 index 0000000000000..5b0c4a622e86a --- /dev/null +++ b/Configuration/ProcessModifiers/python/trackingMkFitLowPtQuadStep_cff.py @@ -0,0 +1,4 @@ +import FWCore.ParameterSet.Config as cms + +# This modifier sets replaces the default pattern recognition with mkFit for lowPtQuadStep +trackingMkFitLowPtQuadStep = cms.Modifier() diff --git a/Configuration/ProcessModifiers/python/trackingMkFitLowPtTripletStep_cff.py b/Configuration/ProcessModifiers/python/trackingMkFitLowPtTripletStep_cff.py new file mode 100644 index 0000000000000..d4ecaf8cb950d --- /dev/null +++ b/Configuration/ProcessModifiers/python/trackingMkFitLowPtTripletStep_cff.py @@ -0,0 +1,4 @@ +import FWCore.ParameterSet.Config as cms + +# This modifier sets replaces the default pattern recognition with mkFit for lowPtTripletStep +trackingMkFitLowPtTripletStep = cms.Modifier() diff --git a/Configuration/ProcessModifiers/python/trackingMkFitMixedTripletStep_cff.py b/Configuration/ProcessModifiers/python/trackingMkFitMixedTripletStep_cff.py new file mode 100644 index 0000000000000..104fc5aeb5029 --- /dev/null +++ b/Configuration/ProcessModifiers/python/trackingMkFitMixedTripletStep_cff.py @@ -0,0 +1,4 @@ +import FWCore.ParameterSet.Config as cms + +# This modifier sets replaces the default pattern recognition with mkFit for mixedTripletStep +trackingMkFitMixedTripletStep = cms.Modifier() diff --git a/Configuration/ProcessModifiers/python/trackingMkFitPixelLessStep_cff.py b/Configuration/ProcessModifiers/python/trackingMkFitPixelLessStep_cff.py new file mode 100644 index 0000000000000..396d80eb7bf2e --- /dev/null +++ b/Configuration/ProcessModifiers/python/trackingMkFitPixelLessStep_cff.py @@ -0,0 +1,4 @@ +import FWCore.ParameterSet.Config as cms + +# This modifier sets replaces the default pattern recognition with mkFit for pixelLessStep +trackingMkFitPixelLessStep = cms.Modifier() diff --git a/Configuration/ProcessModifiers/python/trackingMkFitTobTecStep_cff.py b/Configuration/ProcessModifiers/python/trackingMkFitTobTecStep_cff.py new file mode 100644 index 0000000000000..b8317e86fff68 --- /dev/null +++ b/Configuration/ProcessModifiers/python/trackingMkFitTobTecStep_cff.py @@ -0,0 +1,4 @@ +import FWCore.ParameterSet.Config as cms + +# This modifier sets replaces the default pattern recognition with mkFit for tobTecStep +trackingMkFitTobTecStep = cms.Modifier() diff --git a/Configuration/ProcessModifiers/python/trackingMkFit_cff.py b/Configuration/ProcessModifiers/python/trackingMkFit_cff.py index 08903e6a84258..b62a8d8376937 100644 --- a/Configuration/ProcessModifiers/python/trackingMkFit_cff.py +++ b/Configuration/ProcessModifiers/python/trackingMkFit_cff.py @@ -1,4 +1,26 @@ import FWCore.ParameterSet.Config as cms -# This modifier sets replaces the default pattern recognition with mkFit (possibly in selected iterations only) -trackingMkFit = cms.Modifier() +from Configuration.ProcessModifiers.trackingMkFitCommon_cff import * +from Configuration.ProcessModifiers.trackingMkFitInitialStep_cff import * +from Configuration.ProcessModifiers.trackingMkFitLowPtQuadStep_cff import * +from Configuration.ProcessModifiers.trackingMkFitHighPtTripletStep_cff import * +from Configuration.ProcessModifiers.trackingMkFitLowPtTripletStep_cff import * +from Configuration.ProcessModifiers.trackingMkFitDetachedQuadStep_cff import * +from Configuration.ProcessModifiers.trackingMkFitDetachedTripletStep_cff import * +from Configuration.ProcessModifiers.trackingMkFitMixedTripletStep_cff import * +from Configuration.ProcessModifiers.trackingMkFitPixelLessStep_cff import * +from Configuration.ProcessModifiers.trackingMkFitTobTecStep_cff import * + +# Use mkFit in selected iterations +trackingMkFit = cms.ModifierChain( + trackingMkFitCommon, + trackingMkFitInitialStep, + trackingMkFitLowPtQuadStep, + trackingMkFitHighPtTripletStep, + trackingMkFitLowPtTripletStep, + trackingMkFitDetachedQuadStep, +# trackingMkFitDetachedTripletStep, # to be enabled later +# trackingMkFitMixedTripletStep, # to be enabled later + trackingMkFitPixelLessStep, + trackingMkFitTobTecStep, +) diff --git a/Configuration/PyReleaseValidation/python/upgradeWorkflowComponents.py b/Configuration/PyReleaseValidation/python/upgradeWorkflowComponents.py index 8b7ccd217e6c2..724a2e3f0639d 100644 --- a/Configuration/PyReleaseValidation/python/upgradeWorkflowComponents.py +++ b/Configuration/PyReleaseValidation/python/upgradeWorkflowComponents.py @@ -291,11 +291,14 @@ def condition_(self, fragment, stepList, key, hasHarvest): class UpgradeWorkflow_trackingMkFit(UpgradeWorkflowTracking): def setup_(self, step, stepName, stepDict, k, properties): + if 'Digi' in step: stepDict[stepName][k] = merge([self.step2, stepDict[step][k]]) if 'Reco' in step: stepDict[stepName][k] = merge([self.step3, stepDict[step][k]]) def condition_(self, fragment, stepList, key, hasHarvest): return '2017' in key or '2021' in key upgradeWFs['trackingMkFit'] = UpgradeWorkflow_trackingMkFit( steps = [ + 'Digi', + 'DigiTrigger', 'Reco', 'RecoGlobal', ], @@ -303,6 +306,9 @@ def condition_(self, fragment, stepList, key, hasHarvest): suffix = '_trackingMkFit', offset = 0.7, ) +upgradeWFs['trackingMkFit'].step2 = { + '--customise': 'RecoTracker/MkFit/customizeHLTIter0ToMkFit.customizeHLTIter0ToMkFit' +} upgradeWFs['trackingMkFit'].step3 = { '--procModifiers': 'trackingMkFit' } diff --git a/RecoTracker/IterativeTracking/python/DetachedQuadStep_cff.py b/RecoTracker/IterativeTracking/python/DetachedQuadStep_cff.py index 8f0f7e466fb3a..4e2b04aa63213 100644 --- a/RecoTracker/IterativeTracking/python/DetachedQuadStep_cff.py +++ b/RecoTracker/IterativeTracking/python/DetachedQuadStep_cff.py @@ -186,6 +186,29 @@ phase2clustersToSkip = cms.InputTag('detachedQuadStepClusters') ) +from Configuration.ProcessModifiers.trackingMkFitDetachedQuadStep_cff import trackingMkFitDetachedQuadStep +import RecoTracker.MkFit.mkFitSeedConverter_cfi as mkFitSeedConverter_cfi +import RecoTracker.MkFit.mkFitIterationConfigESProducer_cfi as mkFitIterationConfigESProducer_cfi +import RecoTracker.MkFit.mkFitProducer_cfi as mkFitProducer_cfi +import RecoTracker.MkFit.mkFitOutputConverter_cfi as mkFitOutputConverter_cfi +detachedQuadStepTrackCandidatesMkFitSeeds = mkFitSeedConverter_cfi.mkFitSeedConverter.clone( + seeds = 'detachedQuadStepSeeds', +) +detachedQuadStepTrackCandidatesMkFitConfig = mkFitIterationConfigESProducer_cfi.mkFitIterationConfigESProducer.clone( + config = 'RecoTracker/MkFit/data/mkfit-phase1-detachedQuadStep.json', + ComponentName = 'detachedQuadStepTrackCandidatesMkFitConfig', +) +detachedQuadStepTrackCandidatesMkFit = mkFitProducer_cfi.mkFitProducer.clone( + seeds = 'detachedQuadStepTrackCandidatesMkFitSeeds', + config = ('', 'detachedQuadStepTrackCandidatesMkFitConfig'), + clustersToSkip = 'detachedQuadStepClusters', +) +trackingMkFitDetachedQuadStep.toReplaceWith(detachedQuadStepTrackCandidates, mkFitOutputConverter_cfi.mkFitOutputConverter.clone( + seeds = 'detachedQuadStepSeeds', + mkFitSeeds = 'detachedQuadStepTrackCandidatesMkFitSeeds', + tracks = 'detachedQuadStepTrackCandidatesMkFit', +)) + #For FastSim phase1 tracking import FastSimulation.Tracking.TrackCandidateProducer_cfi _fastSim_detachedQuadStepTrackCandidates = FastSimulation.Tracking.TrackCandidateProducer_cfi.trackCandidateProducer.clone( @@ -337,6 +360,11 @@ detachedQuadStepTracks, detachedQuadStep) DetachedQuadStep = cms.Sequence(DetachedQuadStepTask) + +_DetachedQuadStepTask_trackingMkFit = DetachedQuadStepTask.copy() +_DetachedQuadStepTask_trackingMkFit.add(detachedQuadStepTrackCandidatesMkFitSeeds, detachedQuadStepTrackCandidatesMkFit, detachedQuadStepTrackCandidatesMkFitConfig) +trackingMkFitDetachedQuadStep.toReplaceWith(DetachedQuadStepTask, _DetachedQuadStepTask_trackingMkFit) + _DetachedQuadStepTask_Phase2PU140 = DetachedQuadStepTask.copy() _DetachedQuadStepTask_Phase2PU140.replace(detachedQuadStep, cms.Task(detachedQuadStepSelector,detachedQuadStep)) trackingPhase2PU140.toReplaceWith(DetachedQuadStepTask, _DetachedQuadStepTask_Phase2PU140) diff --git a/RecoTracker/IterativeTracking/python/DetachedTripletStep_cff.py b/RecoTracker/IterativeTracking/python/DetachedTripletStep_cff.py index a97483e20256f..a8748a1b1f627 100644 --- a/RecoTracker/IterativeTracking/python/DetachedTripletStep_cff.py +++ b/RecoTracker/IterativeTracking/python/DetachedTripletStep_cff.py @@ -214,6 +214,29 @@ detachedTripletStepTrackCandidates.TrajectoryCleaner = 'detachedTripletStepTrajectoryCleanerBySharedHits' trackingLowPU.toModify(detachedTripletStepTrajectoryCleanerBySharedHits, fractionShared = 0.19) +from Configuration.ProcessModifiers.trackingMkFitDetachedTripletStep_cff import trackingMkFitDetachedTripletStep +import RecoTracker.MkFit.mkFitSeedConverter_cfi as mkFitSeedConverter_cfi +import RecoTracker.MkFit.mkFitIterationConfigESProducer_cfi as mkFitIterationConfigESProducer_cfi +import RecoTracker.MkFit.mkFitProducer_cfi as mkFitProducer_cfi +import RecoTracker.MkFit.mkFitOutputConverter_cfi as mkFitOutputConverter_cfi +detachedTripletStepTrackCandidatesMkFitSeeds = mkFitSeedConverter_cfi.mkFitSeedConverter.clone( + seeds = 'detachedTripletStepSeeds', +) +detachedTripletStepTrackCandidatesMkFitConfig = mkFitIterationConfigESProducer_cfi.mkFitIterationConfigESProducer.clone( + ComponentName = 'detachedTripletStepTrackCandidatesMkFitConfig', + config = 'RecoTracker/MkFit/data/mkfit-phase1-detachedTripletStep.json', +) +detachedTripletStepTrackCandidatesMkFit = mkFitProducer_cfi.mkFitProducer.clone( + seeds = 'detachedTripletStepTrackCandidatesMkFitSeeds', + config = ('', 'detachedTripletStepTrackCandidatesMkFitConfig'), + clustersToSkip = 'detachedTripletStepClusters', +) +trackingMkFitDetachedTripletStep.toReplaceWith(detachedTripletStepTrackCandidates, mkFitOutputConverter_cfi.mkFitOutputConverter.clone( + seeds = 'detachedTripletStepSeeds', + mkFitSeeds = 'detachedTripletStepTrackCandidatesMkFitSeeds', + tracks = 'detachedTripletStepTrackCandidatesMkFit', +)) + import FastSimulation.Tracking.TrackCandidateProducer_cfi _fastSim_detachedTripletStepTrackCandidates = FastSimulation.Tracking.TrackCandidateProducer_cfi.trackCandidateProducer.clone( src = 'detachedTripletStepSeeds', @@ -379,6 +402,11 @@ detachedTripletStepClassifier1,detachedTripletStepClassifier2, detachedTripletStep) DetachedTripletStep = cms.Sequence(DetachedTripletStepTask) + +_DetachedTripletStepTask_trackingMkFit = DetachedTripletStepTask.copy() +_DetachedTripletStepTask_trackingMkFit.add(detachedTripletStepTrackCandidatesMkFitSeeds, detachedTripletStepTrackCandidatesMkFit, detachedTripletStepTrackCandidatesMkFitConfig) +trackingMkFitDetachedTripletStep.toReplaceWith(DetachedTripletStepTask, _DetachedTripletStepTask_trackingMkFit) + _DetachedTripletStepTask_LowPU = DetachedTripletStepTask.copyAndExclude([detachedTripletStepClassifier2]) _DetachedTripletStepTask_LowPU.replace(detachedTripletStepClassifier1, detachedTripletStepSelector) trackingLowPU.toReplaceWith(DetachedTripletStepTask, _DetachedTripletStepTask_LowPU) diff --git a/RecoTracker/IterativeTracking/python/HighPtTripletStep_cff.py b/RecoTracker/IterativeTracking/python/HighPtTripletStep_cff.py index a249bad2528c6..cd1d48e1b848d 100644 --- a/RecoTracker/IterativeTracking/python/HighPtTripletStep_cff.py +++ b/RecoTracker/IterativeTracking/python/HighPtTripletStep_cff.py @@ -215,6 +215,29 @@ useHitsSplitting = True ) +from Configuration.ProcessModifiers.trackingMkFitHighPtTripletStep_cff import trackingMkFitHighPtTripletStep +import RecoTracker.MkFit.mkFitSeedConverter_cfi as mkFitSeedConverter_cfi +import RecoTracker.MkFit.mkFitIterationConfigESProducer_cfi as mkFitIterationConfigESProducer_cfi +import RecoTracker.MkFit.mkFitProducer_cfi as mkFitProducer_cfi +import RecoTracker.MkFit.mkFitOutputConverter_cfi as mkFitOutputConverter_cfi +highPtTripletStepTrackCandidatesMkFitSeeds = mkFitSeedConverter_cfi.mkFitSeedConverter.clone( + seeds = 'highPtTripletStepSeeds', +) +highPtTripletStepTrackCandidatesMkFitConfig = mkFitIterationConfigESProducer_cfi.mkFitIterationConfigESProducer.clone( + ComponentName = 'highPtTripletStepTrackCandidatesMkFitConfig', + config = 'RecoTracker/MkFit/data/mkfit-phase1-highPtTripletStep.json', +) +highPtTripletStepTrackCandidatesMkFit = mkFitProducer_cfi.mkFitProducer.clone( + seeds = 'highPtTripletStepTrackCandidatesMkFitSeeds', + config = ('', 'highPtTripletStepTrackCandidatesMkFitConfig'), + clustersToSkip = 'highPtTripletStepClusters', +) +trackingMkFitHighPtTripletStep.toReplaceWith(highPtTripletStepTrackCandidates, mkFitOutputConverter_cfi.mkFitOutputConverter.clone( + seeds = 'highPtTripletStepSeeds', + mkFitSeeds = 'highPtTripletStepTrackCandidatesMkFitSeeds', + tracks = 'highPtTripletStepTrackCandidatesMkFit', +)) + # For Phase2PU140 from TrackingTools.TrajectoryCleaning.TrajectoryCleanerBySharedHits_cfi import trajectoryCleanerBySharedHits as _trajectoryCleanerBySharedHits highPtTripletStepTrajectoryCleanerBySharedHits = _trajectoryCleanerBySharedHits.clone( @@ -332,6 +355,11 @@ highPtTripletStepTracks, highPtTripletStep) HighPtTripletStep = cms.Sequence(HighPtTripletStepTask) + +_HighPtTripletStepTask_trackingMkFit = HighPtTripletStepTask.copy() +_HighPtTripletStepTask_trackingMkFit.add(highPtTripletStepTrackCandidatesMkFitSeeds, highPtTripletStepTrackCandidatesMkFit, highPtTripletStepTrackCandidatesMkFitConfig) +trackingMkFitHighPtTripletStep.toReplaceWith(HighPtTripletStepTask, _HighPtTripletStepTask_trackingMkFit) + _HighPtTripletStepTask_Phase2PU140 = HighPtTripletStepTask.copy() _HighPtTripletStepTask_Phase2PU140.replace(highPtTripletStep, highPtTripletStepSelector) _HighPtTripletStep_Phase2PU140 = cms.Sequence(_HighPtTripletStepTask_Phase2PU140) diff --git a/RecoTracker/IterativeTracking/python/InitialStep_cff.py b/RecoTracker/IterativeTracking/python/InitialStep_cff.py index fb77d3ce0acaf..d8fa10a6768d4 100644 --- a/RecoTracker/IterativeTracking/python/InitialStep_cff.py +++ b/RecoTracker/IterativeTracking/python/InitialStep_cff.py @@ -223,19 +223,32 @@ useHitsSplitting = True ) -from Configuration.ProcessModifiers.trackingMkFit_cff import trackingMkFit -import RecoTracker.MkFit.mkFitInputConverter_cfi as mkFitInputConverter_cfi +from Configuration.ProcessModifiers.trackingMkFitInitialStep_cff import trackingMkFitInitialStep +from RecoTracker.MkFit.mkFitGeometryESProducer_cfi import mkFitGeometryESProducer +import RecoTracker.MkFit.mkFitSiPixelHitConverter_cfi as mkFitSiPixelHitConverter_cfi +import RecoTracker.MkFit.mkFitSiStripHitConverter_cfi as mkFitSiStripHitConverter_cfi +import RecoTracker.MkFit.mkFitEventOfHitsProducer_cfi as mkFitEventOfHitsProducer_cfi +import RecoTracker.MkFit.mkFitSeedConverter_cfi as mkFitSeedConverter_cfi +import RecoTracker.MkFit.mkFitIterationConfigESProducer_cfi as mkFitIterationConfigESProducer_cfi import RecoTracker.MkFit.mkFitProducer_cfi as mkFitProducer_cfi import RecoTracker.MkFit.mkFitOutputConverter_cfi as mkFitOutputConverter_cfi -initialStepTrackCandidatesMkFitInput = mkFitInputConverter_cfi.mkFitInputConverter.clone( +mkFitSiPixelHits = mkFitSiPixelHitConverter_cfi.mkFitSiPixelHitConverter.clone() # TODO: figure out better place for this module? +mkFitSiStripHits = mkFitSiStripHitConverter_cfi.mkFitSiStripHitConverter.clone() # TODO: figure out better place for this module? +mkFitEventOfHits = mkFitEventOfHitsProducer_cfi.mkFitEventOfHitsProducer.clone() # TODO: figure out better place for this module? +initialStepTrackCandidatesMkFitSeeds = mkFitSeedConverter_cfi.mkFitSeedConverter.clone( seeds = 'initialStepSeeds', ) +initialStepTrackCandidatesMkFitConfig = mkFitIterationConfigESProducer_cfi.mkFitIterationConfigESProducer.clone( + ComponentName = 'initialStepTrackCandidatesMkFitConfig', + config = 'RecoTracker/MkFit/data/mkfit-phase1-initialStep.json', +) initialStepTrackCandidatesMkFit = mkFitProducer_cfi.mkFitProducer.clone( - hitsSeeds = 'initialStepTrackCandidatesMkFitInput', + seeds = 'initialStepTrackCandidatesMkFitSeeds', + config = ('', 'initialStepTrackCandidatesMkFitConfig'), ) -trackingMkFit.toReplaceWith(initialStepTrackCandidates, mkFitOutputConverter_cfi.mkFitOutputConverter.clone( +trackingMkFitInitialStep.toReplaceWith(initialStepTrackCandidates, mkFitOutputConverter_cfi.mkFitOutputConverter.clone( seeds = 'initialStepSeeds', - hitsSeeds = 'initialStepTrackCandidatesMkFitInput', + mkFitSeeds = 'initialStepTrackCandidatesMkFitSeeds', tracks = 'initialStepTrackCandidatesMkFit', )) @@ -413,9 +426,14 @@ initialStep,caloJetsForTrkTask) InitialStep = cms.Sequence(InitialStepTask) +from Configuration.ProcessModifiers.trackingMkFitCommon_cff import trackingMkFitCommon +_InitialStepTask_trackingMkFitCommon = InitialStepTask.copy() +_InitialStepTask_trackingMkFitCommon.add(mkFitSiPixelHits, mkFitSiStripHits, mkFitEventOfHits, mkFitGeometryESProducer) +trackingMkFitCommon.toReplaceWith(InitialStepTask, _InitialStepTask_trackingMkFitCommon) + _InitialStepTask_trackingMkFit = InitialStepTask.copy() -_InitialStepTask_trackingMkFit.add(initialStepTrackCandidatesMkFitInput, initialStepTrackCandidatesMkFit) -trackingMkFit.toReplaceWith(InitialStepTask, _InitialStepTask_trackingMkFit) +_InitialStepTask_trackingMkFit.add(initialStepTrackCandidatesMkFitSeeds, initialStepTrackCandidatesMkFit, initialStepTrackCandidatesMkFitConfig) +trackingMkFitInitialStep.toReplaceWith(InitialStepTask, _InitialStepTask_trackingMkFit) _InitialStepTask_LowPU = InitialStepTask.copyAndExclude([firstStepPrimaryVerticesUnsorted, initialStepTrackRefsForJets, caloJetsForTrkTask, firstStepPrimaryVertices, initialStepClassifier1, initialStepClassifier2, initialStepClassifier3]) _InitialStepTask_LowPU.replace(initialStep, initialStepSelector) diff --git a/RecoTracker/IterativeTracking/python/LowPtQuadStep_cff.py b/RecoTracker/IterativeTracking/python/LowPtQuadStep_cff.py index 93ad826dd28c6..f7b44fcfe68a4 100644 --- a/RecoTracker/IterativeTracking/python/LowPtQuadStep_cff.py +++ b/RecoTracker/IterativeTracking/python/LowPtQuadStep_cff.py @@ -176,6 +176,29 @@ phase2clustersToSkip = cms.InputTag('lowPtQuadStepClusters') ) +from Configuration.ProcessModifiers.trackingMkFitLowPtQuadStep_cff import trackingMkFitLowPtQuadStep +import RecoTracker.MkFit.mkFitSeedConverter_cfi as mkFitSeedConverter_cfi +import RecoTracker.MkFit.mkFitIterationConfigESProducer_cfi as mkFitIterationConfigESProducer_cfi +import RecoTracker.MkFit.mkFitProducer_cfi as mkFitProducer_cfi +import RecoTracker.MkFit.mkFitOutputConverter_cfi as mkFitOutputConverter_cfi +lowPtQuadStepTrackCandidatesMkFitSeeds = mkFitSeedConverter_cfi.mkFitSeedConverter.clone( + seeds = 'lowPtQuadStepSeeds', +) +lowPtQuadStepTrackCandidatesMkFitConfig = mkFitIterationConfigESProducer_cfi.mkFitIterationConfigESProducer.clone( + ComponentName = 'lowPtQuadStepTrackCandidatesMkFitConfig', + config = 'RecoTracker/MkFit/data/mkfit-phase1-lowPtQuadStep.json', +) +lowPtQuadStepTrackCandidatesMkFit = mkFitProducer_cfi.mkFitProducer.clone( + seeds = 'lowPtQuadStepTrackCandidatesMkFitSeeds', + config = ('', 'lowPtQuadStepTrackCandidatesMkFitConfig'), + clustersToSkip = 'lowPtQuadStepClusters', +) +trackingMkFitLowPtQuadStep.toReplaceWith(lowPtQuadStepTrackCandidates, mkFitOutputConverter_cfi.mkFitOutputConverter.clone( + seeds = 'lowPtQuadStepSeeds', + mkFitSeeds = 'lowPtQuadStepTrackCandidatesMkFitSeeds', + tracks = 'lowPtQuadStepTrackCandidatesMkFit', +)) + #For FastSim phase1 tracking import FastSimulation.Tracking.TrackCandidateProducer_cfi _fastSim_lowPtQuadStepTrackCandidates = FastSimulation.Tracking.TrackCandidateProducer_cfi.trackCandidateProducer.clone( @@ -278,6 +301,10 @@ lowPtQuadStep) LowPtQuadStep = cms.Sequence(LowPtQuadStepTask) +_LowPtQuadStepTask_trackingMkFit = LowPtQuadStepTask.copy() +_LowPtQuadStepTask_trackingMkFit.add(lowPtQuadStepTrackCandidatesMkFitSeeds, lowPtQuadStepTrackCandidatesMkFit, lowPtQuadStepTrackCandidatesMkFitConfig) +trackingMkFitLowPtQuadStep.toReplaceWith(LowPtQuadStepTask, _LowPtQuadStepTask_trackingMkFit) + _LowPtQuadStepTask_Phase2PU140 = LowPtQuadStepTask.copy() _LowPtQuadStepTask_Phase2PU140.replace(lowPtQuadStep, lowPtQuadStepSelector) trackingPhase2PU140.toReplaceWith(LowPtQuadStepTask, _LowPtQuadStepTask_Phase2PU140) diff --git a/RecoTracker/IterativeTracking/python/LowPtTripletStep_cff.py b/RecoTracker/IterativeTracking/python/LowPtTripletStep_cff.py index b20d60df49116..66fd32de00ec1 100644 --- a/RecoTracker/IterativeTracking/python/LowPtTripletStep_cff.py +++ b/RecoTracker/IterativeTracking/python/LowPtTripletStep_cff.py @@ -242,6 +242,29 @@ phase2clustersToSkip = cms.InputTag('lowPtTripletStepClusters') ) +from Configuration.ProcessModifiers.trackingMkFitLowPtTripletStep_cff import trackingMkFitLowPtTripletStep +import RecoTracker.MkFit.mkFitSeedConverter_cfi as mkFitSeedConverter_cfi +import RecoTracker.MkFit.mkFitProducer_cfi as mkFitProducer_cfi +import RecoTracker.MkFit.mkFitIterationConfigESProducer_cfi as mkFitIterationConfigESProducer_cfi +import RecoTracker.MkFit.mkFitOutputConverter_cfi as mkFitOutputConverter_cfi +lowPtTripletStepTrackCandidatesMkFitSeeds = mkFitSeedConverter_cfi.mkFitSeedConverter.clone( + seeds = 'lowPtTripletStepSeeds', +) +lowPtTripletStepTrackCandidatesMkFitConfig = mkFitIterationConfigESProducer_cfi.mkFitIterationConfigESProducer.clone( + ComponentName = 'lowPtTripletStepTrackCandidatesMkFitConfig', + config = 'RecoTracker/MkFit/data/mkfit-phase1-lowPtTripletStep.json', +) +lowPtTripletStepTrackCandidatesMkFit = mkFitProducer_cfi.mkFitProducer.clone( + seeds = 'lowPtTripletStepTrackCandidatesMkFitSeeds', + config = ('', 'lowPtTripletStepTrackCandidatesMkFitConfig'), + clustersToSkip = 'lowPtTripletStepClusters', +) +trackingMkFitLowPtTripletStep.toReplaceWith(lowPtTripletStepTrackCandidates, mkFitOutputConverter_cfi.mkFitOutputConverter.clone( + seeds = 'lowPtTripletStepSeeds', + mkFitSeeds = 'lowPtTripletStepTrackCandidatesMkFitSeeds', + tracks = 'lowPtTripletStepTrackCandidatesMkFit', +)) + import FastSimulation.Tracking.TrackCandidateProducer_cfi fastSim.toReplaceWith(lowPtTripletStepTrackCandidates, FastSimulation.Tracking.TrackCandidateProducer_cfi.trackCandidateProducer.clone( @@ -379,6 +402,10 @@ lowPtTripletStep) LowPtTripletStep = cms.Sequence(LowPtTripletStepTask) +_LowPtTripletStepTask_trackingMkFit = LowPtTripletStepTask.copy() +_LowPtTripletStepTask_trackingMkFit.add(lowPtTripletStepTrackCandidatesMkFitSeeds, lowPtTripletStepTrackCandidatesMkFit) +trackingMkFitLowPtTripletStep.toReplaceWith(LowPtTripletStepTask, _LowPtTripletStepTask_trackingMkFit) + _LowPtTripletStepTask_LowPU_Phase2PU140 = LowPtTripletStepTask.copy() _LowPtTripletStepTask_LowPU_Phase2PU140.replace(lowPtTripletStep, lowPtTripletStepSelector) trackingLowPU.toReplaceWith(LowPtTripletStepTask, _LowPtTripletStepTask_LowPU_Phase2PU140) diff --git a/RecoTracker/IterativeTracking/python/MixedTripletStep_cff.py b/RecoTracker/IterativeTracking/python/MixedTripletStep_cff.py index c3051b3053241..82f3b9cb60aeb 100644 --- a/RecoTracker/IterativeTracking/python/MixedTripletStep_cff.py +++ b/RecoTracker/IterativeTracking/python/MixedTripletStep_cff.py @@ -291,6 +291,30 @@ useHitsSplitting = True, TrajectoryCleaner = 'mixedTripletStepTrajectoryCleanerBySharedHits' ) + +from Configuration.ProcessModifiers.trackingMkFitMixedTripletStep_cff import trackingMkFitMixedTripletStep +import RecoTracker.MkFit.mkFitSeedConverter_cfi as mkFitSeedConverter_cfi +import RecoTracker.MkFit.mkFitIterationConfigESProducer_cfi as mkFitIterationConfigESProducer_cfi +import RecoTracker.MkFit.mkFitProducer_cfi as mkFitProducer_cfi +import RecoTracker.MkFit.mkFitOutputConverter_cfi as mkFitOutputConverter_cfi +mixedTripletStepTrackCandidatesMkFitSeeds = mkFitSeedConverter_cfi.mkFitSeedConverter.clone( + seeds = 'mixedTripletStepSeeds', +) +mixedTripletStepTrackCandidatesMkFitConfig = mkFitIterationConfigESProducer_cfi.mkFitIterationConfigESProducer.clone( + ComponentName = 'mixedTripletStepTrackCandidatesMkFitConfig', + config = 'RecoTracker/MkFit/data/mkfit-phase1-mixedTripletStep.json', +) +mixedTripletStepTrackCandidatesMkFit = mkFitProducer_cfi.mkFitProducer.clone( + seeds = 'mixedTripletStepTrackCandidatesMkFitSeeds', + config = ('', 'mixedTripletStepTrackCandidatesMkFitConfig'), + clustersToSkip = 'mixedTripletStepClusters', +) +trackingMkFitMixedTripletStep.toReplaceWith(mixedTripletStepTrackCandidates, mkFitOutputConverter_cfi.mkFitOutputConverter.clone( + seeds = 'mixedTripletStepSeeds', + mkFitSeeds = 'mixedTripletStepTrackCandidatesMkFitSeeds', + tracks = 'mixedTripletStepTrackCandidatesMkFit', +)) + import FastSimulation.Tracking.TrackCandidateProducer_cfi fastSim.toReplaceWith(mixedTripletStepTrackCandidates, FastSimulation.Tracking.TrackCandidateProducer_cfi.trackCandidateProducer.clone( @@ -475,6 +499,11 @@ mixedTripletStepClassifier1,mixedTripletStepClassifier2, mixedTripletStep) MixedTripletStep = cms.Sequence(MixedTripletStepTask) + +_MixedTripletStepTask_trackingMkFit = MixedTripletStepTask.copy() +_MixedTripletStepTask_trackingMkFit.add(mixedTripletStepTrackCandidatesMkFitSeeds, mixedTripletStepTrackCandidatesMkFit, mixedTripletStepTrackCandidatesMkFitConfig) +trackingMkFitMixedTripletStep.toReplaceWith(MixedTripletStepTask, _MixedTripletStepTask_trackingMkFit) + _MixedTripletStepTask_LowPU = MixedTripletStepTask.copyAndExclude([chargeCut2069Clusters, mixedTripletStepClassifier1]) _MixedTripletStepTask_LowPU.replace(mixedTripletStepClassifier2, mixedTripletStepSelector) trackingLowPU.toReplaceWith(MixedTripletStepTask, _MixedTripletStepTask_LowPU) diff --git a/RecoTracker/IterativeTracking/python/PixelLessStep_cff.py b/RecoTracker/IterativeTracking/python/PixelLessStep_cff.py index de8694abee81b..5e6d115c97b21 100644 --- a/RecoTracker/IterativeTracking/python/PixelLessStep_cff.py +++ b/RecoTracker/IterativeTracking/python/PixelLessStep_cff.py @@ -284,6 +284,30 @@ TrajectoryBuilderPSet = cms.PSet(refToPSet_ = cms.string('pixelLessStepTrajectoryBuilder')), TrajectoryCleaner = 'pixelLessStepTrajectoryCleanerBySharedHits' ) + +from Configuration.ProcessModifiers.trackingMkFitPixelLessStep_cff import trackingMkFitPixelLessStep +import RecoTracker.MkFit.mkFitSeedConverter_cfi as mkFitSeedConverter_cfi +import RecoTracker.MkFit.mkFitIterationConfigESProducer_cfi as mkFitIterationConfigESProducer_cfi +import RecoTracker.MkFit.mkFitProducer_cfi as mkFitProducer_cfi +import RecoTracker.MkFit.mkFitOutputConverter_cfi as mkFitOutputConverter_cfi +pixelLessStepTrackCandidatesMkFitSeeds = mkFitSeedConverter_cfi.mkFitSeedConverter.clone( + seeds = 'pixelLessStepSeeds', +) +pixelLessStepTrackCandidatesMkFitConfig = mkFitIterationConfigESProducer_cfi.mkFitIterationConfigESProducer.clone( + ComponentName = 'pixelLessStepTrackCandidatesMkFitConfig', + config = 'RecoTracker/MkFit/data/mkfit-phase1-pixelLessStep.json', +) +pixelLessStepTrackCandidatesMkFit = mkFitProducer_cfi.mkFitProducer.clone( + seeds = 'pixelLessStepTrackCandidatesMkFitSeeds', + config = ('', 'pixelLessStepTrackCandidatesMkFitConfig'), + clustersToSkip = 'pixelLessStepClusters', +) +trackingMkFitPixelLessStep.toReplaceWith(pixelLessStepTrackCandidates, mkFitOutputConverter_cfi.mkFitOutputConverter.clone( + seeds = 'pixelLessStepSeeds', + mkFitSeeds = 'pixelLessStepTrackCandidatesMkFitSeeds', + tracks = 'pixelLessStepTrackCandidatesMkFit', +)) + import FastSimulation.Tracking.TrackCandidateProducer_cfi fastSim.toReplaceWith(pixelLessStepTrackCandidates, FastSimulation.Tracking.TrackCandidateProducer_cfi.trackCandidateProducer.clone( @@ -465,6 +489,10 @@ pixelLessStep) PixelLessStep = cms.Sequence(PixelLessStepTask) +_PixelLessStepTask_trackingMkFit = PixelLessStepTask.copy() +_PixelLessStepTask_trackingMkFit.add(pixelLessStepTrackCandidatesMkFitSeeds, pixelLessStepTrackCandidatesMkFit, pixelLessStepTrackCandidatesMkFit) +trackingMkFitPixelLessStep.toReplaceWith(PixelLessStepTask, _PixelLessStepTask_trackingMkFit) + _PixelLessStepTask_LowPU = PixelLessStepTask.copyAndExclude([pixelLessStepHitTriplets, pixelLessStepClassifier1, pixelLessStepClassifier2]) _PixelLessStepTask_LowPU.replace(pixelLessStep, pixelLessStepSelector) trackingLowPU.toReplaceWith(PixelLessStepTask, _PixelLessStepTask_LowPU) diff --git a/RecoTracker/IterativeTracking/python/TobTecStep_cff.py b/RecoTracker/IterativeTracking/python/TobTecStep_cff.py index af527c2b64769..ec17f33d6f31c 100644 --- a/RecoTracker/IterativeTracking/python/TobTecStep_cff.py +++ b/RecoTracker/IterativeTracking/python/TobTecStep_cff.py @@ -268,6 +268,30 @@ cleanTrajectoryAfterInOut = True, TrajectoryCleaner = 'tobTecStepTrajectoryCleanerBySharedHits' ) + +from Configuration.ProcessModifiers.trackingMkFitTobTecStep_cff import trackingMkFitTobTecStep +import RecoTracker.MkFit.mkFitSeedConverter_cfi as mkFitSeedConverter_cfi +import RecoTracker.MkFit.mkFitIterationConfigESProducer_cfi as mkFitIterationConfigESProducer_cfi +import RecoTracker.MkFit.mkFitProducer_cfi as mkFitProducer_cfi +import RecoTracker.MkFit.mkFitOutputConverter_cfi as mkFitOutputConverter_cfi +tobTecStepTrackCandidatesMkFitSeeds = mkFitSeedConverter_cfi.mkFitSeedConverter.clone( + seeds = 'tobTecStepSeeds', +) +tobTecStepTrackCandidatesMkFitConfig = mkFitIterationConfigESProducer_cfi.mkFitIterationConfigESProducer.clone( + ComponentName = 'tobTecStepTrackCandidatesMkFitConfig', + config = 'RecoTracker/MkFit/data/mkfit-phase1-tobTecStep.json', +) +tobTecStepTrackCandidatesMkFit = mkFitProducer_cfi.mkFitProducer.clone( + seeds = 'tobTecStepTrackCandidatesMkFitSeeds', + config = ('', 'tobTecStepTrackCandidatesMkFitConfig'), + clustersToSkip = 'tobTecStepClusters', +) +trackingMkFitTobTecStep.toReplaceWith(tobTecStepTrackCandidates, mkFitOutputConverter_cfi.mkFitOutputConverter.clone( + seeds = 'tobTecStepSeeds', + mkFitSeeds = 'tobTecStepTrackCandidatesMkFitSeeds', + tracks = 'tobTecStepTrackCandidatesMkFit', +)) + import FastSimulation.Tracking.TrackCandidateProducer_cfi fastSim.toReplaceWith(tobTecStepTrackCandidates, FastSimulation.Tracking.TrackCandidateProducer_cfi.trackCandidateProducer.clone( @@ -449,6 +473,9 @@ tobTecStep) TobTecStep = cms.Sequence(TobTecStepTask) +_TobTecStepTask_trackingMkFit = TobTecStepTask.copy() +_TobTecStepTask_trackingMkFit.add(tobTecStepTrackCandidatesMkFitSeeds, tobTecStepTrackCandidatesMkFit, tobTecStepTrackCandidatesMkFitConfig) +trackingMkFitTobTecStep.toReplaceWith(TobTecStepTask, _TobTecStepTask_trackingMkFit) ### Following are specific for LowPU, they're collected here to ### not to interfere too much with the default configuration diff --git a/RecoTracker/MkFit/BuildFile.xml b/RecoTracker/MkFit/BuildFile.xml index 8d936740b9bf6..177da9dffc6df 100644 --- a/RecoTracker/MkFit/BuildFile.xml +++ b/RecoTracker/MkFit/BuildFile.xml @@ -1,5 +1,8 @@ + + + diff --git a/RecoTracker/MkFit/README.md b/RecoTracker/MkFit/README.md index 6808838744399..3bd44016f71ef 100644 --- a/RecoTracker/MkFit/README.md +++ b/RecoTracker/MkFit/README.md @@ -30,4 +30,50 @@ tracker detector. Support for the phase2 tracker will be added later. These can be used with e.g. ```bash $ runTheMatrix.py -l --apply 2 --command "--procModifiers trackingMkFit --customise RecoTracker/MkFit/customizeInitialStepToMkFit.customizeInitialStepOnly" -``` \ No newline at end of file +``` + +## Description of configuration parameters + +### Iteration configuration [class IterationConfig] + +* *m_track_algorithm:* CMSSW track algorithm (used internally for reporting and consistency checks) +* *m_requires_seed_hit_sorting:* do hits on seed tracks need to be sorted (required for seeds that include strip layers) +* *m_require_quality_filter:* is additional post-processing required for result tracks +* *m_params:* IterationParams structure for this iteration +* *m_layer_configs:* std::vector of per-layer parameters + +### Iteration parameters [class IterationParams] + +* *nlayers_per_seed:* internal mkFit parameter used for standalone validation +* *maxCandsPerSeed:* maximum number of concurrent track candidates per given seed +* *maxHolesPerCand:* maximum number of allowed holes on a candidate +* *maxConsecHoles:* maximum number of allowed consecutive holes on a candidate +* *chi2Cut:* chi2 cut for accepting a new hit +* *chi2CutOverlap:* chi2 cut for accepting an overlap hit +* *pTCutOverlap:* pT cut below which the overlap hits are not picked up + +#### Seed cleaning params (based on elliptical dR-dz cut) + +* *c_ptthr_hpt:* pT threshold used to tighten seed cleaning requirements +* *c_drmax_bh:* dR cut used for seed tracks with std::fabs(eta)<0.9 and pT > c_ptthr_hpt +* *c_dzmax_bh:* dz cut used for seed tracks with std::fabs(eta)<0.9 and pT > c_ptthr_hpt +* *c_drmax_eh:* dR cut used for seed tracks with std::fabs(eta)>0.9 and pT > c_ptthr_hpt +* *c_dzmax_eh:* dz cut used for seed tracks with std::fabs(eta)>0.9 and pT > c_ptthr_hpt +* *c_drmax_bl:* dR cut used for seed tracks with std::fabs(eta)<0.9 and pT < c_ptthr_hpt +* *c_dzmax_bl:* dz cut used for seed tracks with std::fabs(eta)<0.9 and pT < c_ptthr_hpt +* *c_drmax_el:* dR cut used for seed tracks with std::fabs(eta)>0.9 and pT < c_ptthr_hpt +* *c_dzmax_el:* dz cut used for seed tracks with std::fabs(eta)>0.9 and pT < c_ptthr_hpt + +#### Duplicate cleaning parameters + +* *minHitsQF:* min number of hits on track candidate to apply duplicate cleaning based on fraction of shared hits +* *fracSharedHits:* min fraction of shared hits to determine duplicate track candidate + +### Per-layer parameters [class IterationLayerConfig] + +* *m_select_min_dphi, m_select_max_dphi:* geometry-driven dphi baseline selection window cut +* *m_select_min_dq, m_select_max_dq:* geometry-driven dr (endcap) / dz (barrel) baseline selection window cut +* *c_dp_[012]:* dphi selection window cut (= [0]*1/pT + [1]*std::fabs(theta-pi/2) + [2]) +* *c_dp_sf:* additional scaling factor for dphi cut +* *c_dq_[012]:* dr (endcap) / dz (barrel) selection window cut (= [0]*1/pT + [1]*std::fabs(theta-pi/2) + [2]) +* *c_dq_sf:* additional scaling factor for dr (endcap) / dz (barrel) cut diff --git a/RecoTracker/MkFit/interface/MkFitClusterIndexToHit.h b/RecoTracker/MkFit/interface/MkFitClusterIndexToHit.h new file mode 100644 index 0000000000000..7c8d9db2bb3cf --- /dev/null +++ b/RecoTracker/MkFit/interface/MkFitClusterIndexToHit.h @@ -0,0 +1,20 @@ +#ifndef RecoTracker_MkFit_MkFitClusterIndexToHit_h +#define RecoTracker_MkFit_MkFitClusterIndexToHit_h + +#include + +class TrackingRecHit; + +class MkFitClusterIndexToHit { +public: + MkFitClusterIndexToHit() = default; + + std::vector& hits() { return hits_; } + std::vector const& hits() const { return hits_; } + +private: + // Indexed by cluster index + std::vector hits_; +}; + +#endif diff --git a/RecoTracker/MkFit/interface/MkFitEventOfHits.h b/RecoTracker/MkFit/interface/MkFitEventOfHits.h new file mode 100644 index 0000000000000..cb5ea6358da1b --- /dev/null +++ b/RecoTracker/MkFit/interface/MkFitEventOfHits.h @@ -0,0 +1,36 @@ +#ifndef RecoTracker_MkFit_MkFitEventOfHits_h +#define RecoTracker_MkFit_MkFitEventOfHits_h + +#include + +namespace mkfit { + class EventOfHits; +} + +/** + * The mkfit::EventOfHits is a container of mkfit::LayerOfHits + * structures that mkFit uses to group (and index) hits. Having them + * grouped together allows mkFit to pass them easily around top-level + * steering functions. + * + * It has some conceptual similarities to MeasurementTrackerEvent. + */ +class MkFitEventOfHits { +public: + MkFitEventOfHits(); + MkFitEventOfHits(std::unique_ptr); + ~MkFitEventOfHits(); + + MkFitEventOfHits(MkFitEventOfHits const&) = delete; + MkFitEventOfHits& operator=(MkFitEventOfHits const&) = delete; + MkFitEventOfHits(MkFitEventOfHits&&); + MkFitEventOfHits& operator=(MkFitEventOfHits&&); + + mkfit::EventOfHits& get() { return *eventOfHits_; } + mkfit::EventOfHits const& get() const { return *eventOfHits_; } + +private: + std::unique_ptr eventOfHits_; +}; + +#endif diff --git a/RecoTracker/MkFit/interface/MkFitGeometry.h b/RecoTracker/MkFit/interface/MkFitGeometry.h new file mode 100644 index 0000000000000..1fe5b6447580e --- /dev/null +++ b/RecoTracker/MkFit/interface/MkFitGeometry.h @@ -0,0 +1,49 @@ +#ifndef RecoTracker_MkFit_MkFitGeometry_h +#define RecoTracker_MkFit_MkFitGeometry_h + +#include "DataFormats/DetId/interface/DetId.h" + +#include +#include +#include + +namespace mkfit { + class LayerNumberConverter; + class TrackerInfo; + class IterationsInfo; +} // namespace mkfit + +class DetLayer; +class GeometricSearchTracker; +class TrackerGeometry; +class TrackerTopology; + +/** + * Collection of geometry-related objects for mkFit + */ +class MkFitGeometry { +public: + explicit MkFitGeometry(const TrackerGeometry& geom, + const GeometricSearchTracker& tracker, + const TrackerTopology& ttopo, + std::unique_ptr trackerInfo, + std::unique_ptr iterationsInfo); + ~MkFitGeometry(); + + int mkFitLayerNumber(DetId detId) const; + mkfit::LayerNumberConverter const& layerNumberConverter() const { return *lnc_; } + mkfit::TrackerInfo const& trackerInfo() const { return *trackerInfo_; } + mkfit::IterationsInfo const& iterationsInfo() const { return *iterationsInfo_; } + const std::vector& detLayers() const { return dets_; } + unsigned int uniqueIdInLayer(int layer, unsigned int detId) const { return detIdToShortId_.at(layer).at(detId); } + +private: + const TrackerTopology* ttopo_; + std::unique_ptr lnc_; // for pimpl pattern + std::unique_ptr trackerInfo_; + std::unique_ptr iterationsInfo_; // only temporarily here, to be moved into proper place later + std::vector dets_; + std::vector> detIdToShortId_; +}; + +#endif diff --git a/RecoTracker/MkFit/interface/MkFitHitIndexMap.h b/RecoTracker/MkFit/interface/MkFitHitIndexMap.h deleted file mode 100644 index c7b6eea50263a..0000000000000 --- a/RecoTracker/MkFit/interface/MkFitHitIndexMap.h +++ /dev/null @@ -1,86 +0,0 @@ -#ifndef RecoTracker_MkFit_MkFitHitIndexMap_h -#define RecoTracker_MkFit_MkFitHitIndexMap_h - -#include "DataFormats/Provenance/interface/ProductID.h" - -#include - -class TrackingRecHit; - -/** - * This class provides mappings - * - from CMSSW(ProductID, cluster index) to mkFit(layer index, hit index) - * - from mkFit(layer index, hit index) to pointer to CMSSW hit - */ -class MkFitHitIndexMap { -public: - // This class holds the index and layer of a hit in the hit data - // structure passed to mkFit - class MkFitHit { - public: - MkFitHit() = default; - explicit MkFitHit(int i, int l) : index_{i}, layer_{l} {} - - int index() const { return index_; } - int layer() const { return layer_; } - - private: - int index_ = -1; - int layer_ = -1; - }; - - MkFitHitIndexMap() = default; - - /** - * Can be used to preallocate the internal vectors for CMSSW->mkFit mapping - */ - void resizeByClusterIndex(edm::ProductID id, size_t clusterIndex); - - /** - * Can be used to preallocate the internal vectors for mkFit->CMSSW mapping - * - * \param layer Layer index (in mkFit convention) - * \param additionalSize Number of additional elements to make space for - */ - void increaseLayerSize(int layer, size_t additionalSize); - - /** - * Inserts a new hit in the mapping - * - * \param id ProductID of the cluster collection - * \param clusterIndex Index of the cluster in the cluster collection - * \param hit Index and layer of the hit in the mkFit hit data structure - * \param hitPtr Pointer to the TrackingRecHit - */ - void insert(edm::ProductID id, size_t clusterIndex, MkFitHit hit, const TrackingRecHit* hitPtr); - - /// Get mkFit hit index and layer - const MkFitHit& mkFitHit(edm::ProductID id, size_t clusterIndex) const; - - /// Get CMSSW hit pointer - const TrackingRecHit* hitPtr(MkFitHit hit) const { return mkFitToCMSSW_.at(hit.layer()).at(hit.index()).ptr; } - - /// Get CMSSW cluster index (currently used only for debugging) - size_t clusterIndex(MkFitHit hit) const { return mkFitToCMSSW_.at(hit.layer()).at(hit.index()).clusterIndex; } - -private: - // Helper struct to map (edm::ProductID, cluster index) to MkFitHit - struct ClusterToMkFitHit { - explicit ClusterToMkFitHit(edm::ProductID id) : productID(id) {} - edm::ProductID productID; - std::vector mkFitHits; // indexed by cluster index - }; - - // Helper struct to map MkFitHit to (TrackingRecHit *, cluster index) - struct CMSSWHit { - CMSSWHit() = default; - explicit CMSSWHit(const TrackingRecHit* p, size_t i) : ptr{p}, clusterIndex{i} {} - const TrackingRecHit* ptr = nullptr; - size_t clusterIndex = 0; - }; - - std::vector cmsswToMkFit_; // mapping from CMSSW(ProductID, cluster index) -> mkFit(index, layer) - std::vector > mkFitToCMSSW_; // reverse mapping, mkFit(layer, index) -> CMSSW hit -}; - -#endif diff --git a/RecoTracker/MkFit/interface/MkFitHitWrapper.h b/RecoTracker/MkFit/interface/MkFitHitWrapper.h new file mode 100644 index 0000000000000..c45f634f9925f --- /dev/null +++ b/RecoTracker/MkFit/interface/MkFitHitWrapper.h @@ -0,0 +1,36 @@ +#ifndef RecoTracker_MkFit_MkFitHitWrapper_h +#define RecoTracker_MkFit_MkFitHitWrapper_h + +#include "DataFormats/Provenance/interface/ProductID.h" + +#include +#include + +namespace mkfit { + class Hit; + using HitVec = std::vector; +} // namespace mkfit + +class MkFitHitWrapper { +public: + MkFitHitWrapper(); + ~MkFitHitWrapper(); + + MkFitHitWrapper(MkFitHitWrapper const&) = delete; + MkFitHitWrapper& operator=(MkFitHitWrapper const&) = delete; + MkFitHitWrapper(MkFitHitWrapper&&); + MkFitHitWrapper& operator=(MkFitHitWrapper&&); + + void setClustersID(edm::ProductID id) { clustersID_ = id; } + edm::ProductID clustersID() const { return clustersID_; } + + mkfit::HitVec& hits() { return hits_; } + mkfit::HitVec const& hits() const { return hits_; } + +private: + // Vector is indexed by the cluster index + mkfit::HitVec hits_; + edm::ProductID clustersID_; +}; + +#endif diff --git a/RecoTracker/MkFit/interface/MkFitInputWrapper.h b/RecoTracker/MkFit/interface/MkFitInputWrapper.h deleted file mode 100644 index 2edc855b5c643..0000000000000 --- a/RecoTracker/MkFit/interface/MkFitInputWrapper.h +++ /dev/null @@ -1,44 +0,0 @@ -#ifndef RecoTracker_MkFit_MkFitInputWrapper_h -#define RecoTracker_MkFit_MkFitInputWrapper_h - -#include "RecoTracker/MkFit/interface/MkFitHitIndexMap.h" - -#include -#include - -namespace mkfit { - class Hit; - class Track; - class LayerNumberConverter; - using HitVec = std::vector; - using TrackVec = std::vector; -} // namespace mkfit - -class MkFitInputWrapper { -public: - MkFitInputWrapper(); - MkFitInputWrapper(MkFitHitIndexMap hitIndexMap, - std::vector hits, - mkfit::TrackVec seeds, - mkfit::LayerNumberConverter const& lnc); - ~MkFitInputWrapper(); - - MkFitInputWrapper(MkFitInputWrapper const&) = delete; - MkFitInputWrapper& operator=(MkFitInputWrapper const&) = delete; - MkFitInputWrapper(MkFitInputWrapper&&); - MkFitInputWrapper& operator=(MkFitInputWrapper&&); - - MkFitHitIndexMap const& hitIndexMap() const { return hitIndexMap_; } - mkfit::TrackVec const& seeds() const { return *seeds_; } - std::vector const& hits() const { return hits_; } - mkfit::LayerNumberConverter const& layerNumberConverter() const { return *lnc_; } - unsigned int nlayers() const; - -private: - MkFitHitIndexMap hitIndexMap_; - std::vector hits_; - std::unique_ptr seeds_; // for pimpl pattern - std::unique_ptr lnc_; // for pimpl pattern -}; - -#endif diff --git a/RecoTracker/MkFit/interface/MkFitOutputWrapper.h b/RecoTracker/MkFit/interface/MkFitOutputWrapper.h index 8297b7c511f77..a658d41151aa3 100644 --- a/RecoTracker/MkFit/interface/MkFitOutputWrapper.h +++ b/RecoTracker/MkFit/interface/MkFitOutputWrapper.h @@ -11,7 +11,7 @@ namespace mkfit { class MkFitOutputWrapper { public: MkFitOutputWrapper(); - MkFitOutputWrapper(mkfit::TrackVec&& candidateTracks, mkfit::TrackVec&& fitTracks); + MkFitOutputWrapper(mkfit::TrackVec tracks, bool propagatedToFirstLayer); ~MkFitOutputWrapper(); MkFitOutputWrapper(MkFitOutputWrapper const&) = delete; @@ -19,12 +19,12 @@ class MkFitOutputWrapper { MkFitOutputWrapper(MkFitOutputWrapper&&); MkFitOutputWrapper& operator=(MkFitOutputWrapper&&); - mkfit::TrackVec const& candidateTracks() const { return candidateTracks_; } - mkfit::TrackVec const& fitTracks() const { return fitTracks_; } + mkfit::TrackVec const& tracks() const { return tracks_; } + bool propagatedToFirstLayer() const { return propagatedToFirstLayer_; } private: - mkfit::TrackVec candidateTracks_; - mkfit::TrackVec fitTracks_; + mkfit::TrackVec tracks_; + bool propagatedToFirstLayer_; }; #endif diff --git a/RecoTracker/MkFit/interface/MkFitSeedWrapper.h b/RecoTracker/MkFit/interface/MkFitSeedWrapper.h new file mode 100644 index 0000000000000..dbba531bf4fa8 --- /dev/null +++ b/RecoTracker/MkFit/interface/MkFitSeedWrapper.h @@ -0,0 +1,29 @@ +#ifndef RecoTracker_MkFit_MkFitSeedWrapper_h +#define RecoTracker_MkFit_MkFitSeedWrapper_h + +#include +#include + +namespace mkfit { + class Track; + using TrackVec = std::vector; +} // namespace mkfit + +class MkFitSeedWrapper { +public: + MkFitSeedWrapper(); + MkFitSeedWrapper(mkfit::TrackVec seeds); + ~MkFitSeedWrapper(); + + MkFitSeedWrapper(MkFitSeedWrapper const&) = delete; + MkFitSeedWrapper& operator=(MkFitSeedWrapper const&) = delete; + MkFitSeedWrapper(MkFitSeedWrapper&&); + MkFitSeedWrapper& operator=(MkFitSeedWrapper&&); + + mkfit::TrackVec const& seeds() const { return *seeds_; } + +private: + std::unique_ptr seeds_; // for pimpl pattern +}; + +#endif diff --git a/RecoTracker/MkFit/plugins/BuildFile.xml b/RecoTracker/MkFit/plugins/BuildFile.xml index d94827ff2a2a3..b8ec556c28544 100644 --- a/RecoTracker/MkFit/plugins/BuildFile.xml +++ b/RecoTracker/MkFit/plugins/BuildFile.xml @@ -1,8 +1,12 @@ + + + + diff --git a/RecoTracker/MkFit/plugins/MkFitEventOfHitsProducer.cc b/RecoTracker/MkFit/plugins/MkFitEventOfHitsProducer.cc new file mode 100644 index 0000000000000..270bce35fe048 --- /dev/null +++ b/RecoTracker/MkFit/plugins/MkFitEventOfHitsProducer.cc @@ -0,0 +1,86 @@ +#include "FWCore/Framework/interface/global/EDProducer.h" + +#include "FWCore/Framework/interface/Event.h" +#include "FWCore/Framework/interface/MakerMacros.h" +#include "FWCore/ParameterSet/interface/ParameterSet.h" + +#include "DataFormats/TrackingRecHit/interface/TrackingRecHit.h" + +#include "RecoTracker/MkFit/interface/MkFitClusterIndexToHit.h" +#include "RecoTracker/MkFit/interface/MkFitEventOfHits.h" +#include "RecoTracker/MkFit/interface/MkFitGeometry.h" +#include "RecoTracker/MkFit/interface/MkFitHitWrapper.h" +#include "RecoTracker/Record/interface/TrackerRecoGeometryRecord.h" + +// mkFit includes +#include "mkFit/HitStructures.h" +#include "mkFit/MkStdSeqs.h" + +class MkFitEventOfHitsProducer : public edm::global::EDProducer<> { +public: + explicit MkFitEventOfHitsProducer(edm::ParameterSet const& iConfig); + ~MkFitEventOfHitsProducer() override = default; + + static void fillDescriptions(edm::ConfigurationDescriptions& descriptions); + +private: + void produce(edm::StreamID, edm::Event& iEvent, const edm::EventSetup& iSetup) const override; + + void fill(const std::vector& hits, + mkfit::EventOfHits& eventOfHits, + const MkFitGeometry& mkFitGeom) const; + + const edm::EDGetTokenT pixelHitsToken_; + const edm::EDGetTokenT stripHitsToken_; + const edm::EDGetTokenT pixelClusterIndexToHitToken_; + const edm::EDGetTokenT stripClusterIndexToHitToken_; + const edm::ESGetToken mkFitGeomToken_; + const edm::EDPutTokenT putToken_; +}; + +MkFitEventOfHitsProducer::MkFitEventOfHitsProducer(edm::ParameterSet const& iConfig) + : pixelHitsToken_{consumes(iConfig.getParameter("pixelHits"))}, + stripHitsToken_{consumes(iConfig.getParameter("stripHits"))}, + pixelClusterIndexToHitToken_{consumes(iConfig.getParameter("pixelHits"))}, + stripClusterIndexToHitToken_{consumes(iConfig.getParameter("stripHits"))}, + mkFitGeomToken_{esConsumes()}, + putToken_{produces()} {} + +void MkFitEventOfHitsProducer::fillDescriptions(edm::ConfigurationDescriptions& descriptions) { + edm::ParameterSetDescription desc; + + desc.add("pixelHits", edm::InputTag{"mkFitSiPixelHits"}); + desc.add("stripHits", edm::InputTag{"mkFitSiStripHits"}); + + descriptions.addWithDefaultLabel(desc); +} + +void MkFitEventOfHitsProducer::produce(edm::StreamID iID, edm::Event& iEvent, const edm::EventSetup& iSetup) const { + const auto& pixelHits = iEvent.get(pixelHitsToken_); + const auto& stripHits = iEvent.get(stripHitsToken_); + const auto& mkFitGeom = iSetup.getData(mkFitGeomToken_); + + auto eventOfHits = std::make_unique(mkFitGeom.trackerInfo()); + mkfit::StdSeq::Cmssw_LoadHits_Begin(*eventOfHits, {&pixelHits.hits(), &stripHits.hits()}); + + fill(iEvent.get(pixelClusterIndexToHitToken_).hits(), *eventOfHits, mkFitGeom); + fill(iEvent.get(stripClusterIndexToHitToken_).hits(), *eventOfHits, mkFitGeom); + + mkfit::StdSeq::Cmssw_LoadHits_End(*eventOfHits); + + iEvent.emplace(putToken_, std::move(eventOfHits)); +} + +void MkFitEventOfHitsProducer::fill(const std::vector& hits, + mkfit::EventOfHits& eventOfHits, + const MkFitGeometry& mkFitGeom) const { + for (int i = 0, end = hits.size(); i < end; ++i) { + const auto* hit = hits[i]; + if (hit != nullptr) { + const auto ilay = mkFitGeom.mkFitLayerNumber(hit->geographicalId()); + eventOfHits[ilay].RegisterHit(i); + } + } +} + +DEFINE_FWK_MODULE(MkFitEventOfHitsProducer); diff --git a/RecoTracker/MkFit/plugins/MkFitGeometryESProducer.cc b/RecoTracker/MkFit/plugins/MkFitGeometryESProducer.cc new file mode 100644 index 0000000000000..d8e5fb3d93cf6 --- /dev/null +++ b/RecoTracker/MkFit/plugins/MkFitGeometryESProducer.cc @@ -0,0 +1,59 @@ +#include "FWCore/Framework/interface/ModuleFactory.h" +#include "FWCore/Framework/interface/ESProducer.h" + +#include "DataFormats/TrackerCommon/interface/TrackerTopology.h" +#include "Geometry/Records/interface/TrackerTopologyRcd.h" +#include "RecoTracker/TkDetLayers/interface/GeometricSearchTracker.h" +#include "RecoTracker/Record/interface/TrackerRecoGeometryRecord.h" +#include "Geometry/TrackerGeometryBuilder/interface/TrackerGeometry.h" +#include "Geometry/Records/interface/TrackerDigiGeometryRecord.h" + +#include "RecoTracker/MkFit/interface/MkFitGeometry.h" + +#include "createPhase1TrackerGeometry.h" + +// mkFit includes +#include "ConfigWrapper.h" +#include "TrackerInfo.h" +#include "mkFit/IterationConfig.h" + +#include + +class MkFitGeometryESProducer : public edm::ESProducer { +public: + MkFitGeometryESProducer(const edm::ParameterSet& iConfig); + + static void fillDescriptions(edm::ConfigurationDescriptions& descriptions); + + std::unique_ptr produce(const TrackerRecoGeometryRecord& iRecord); + +private: + edm::ESGetToken geomToken_; + edm::ESGetToken trackerToken_; + edm::ESGetToken ttopoToken_; +}; + +MkFitGeometryESProducer::MkFitGeometryESProducer(const edm::ParameterSet& iConfig) { + auto cc = setWhatProduced(this); + geomToken_ = cc.consumes(); + trackerToken_ = cc.consumes(); + ttopoToken_ = cc.consumes(); +} + +void MkFitGeometryESProducer::fillDescriptions(edm::ConfigurationDescriptions& descriptions) { + edm::ParameterSetDescription desc; + descriptions.addWithDefaultLabel(desc); +} + +std::unique_ptr MkFitGeometryESProducer::produce(const TrackerRecoGeometryRecord& iRecord) { + auto trackerInfo = std::make_unique(); + auto iterationsInfo = std::make_unique(); + mkfit::createPhase1TrackerGeometry(*trackerInfo, *iterationsInfo, false); + return std::make_unique(iRecord.get(geomToken_), + iRecord.get(trackerToken_), + iRecord.get(ttopoToken_), + std::move(trackerInfo), + std::move(iterationsInfo)); +} + +DEFINE_FWK_EVENTSETUP_MODULE(MkFitGeometryESProducer); diff --git a/RecoTracker/MkFit/plugins/MkFitInputConverter.cc b/RecoTracker/MkFit/plugins/MkFitInputConverter.cc deleted file mode 100644 index 546ca59f6a348..0000000000000 --- a/RecoTracker/MkFit/plugins/MkFitInputConverter.cc +++ /dev/null @@ -1,240 +0,0 @@ -#include "FWCore/Framework/interface/global/EDProducer.h" - -#include "FWCore/Framework/interface/Event.h" -#include "FWCore/Framework/interface/MakerMacros.h" -#include "FWCore/ParameterSet/interface/ParameterSet.h" - -#include "DataFormats/SiStripCluster/interface/SiStripClusterTools.h" -#include "DataFormats/TrajectorySeed/interface/TrajectorySeed.h" -#include "DataFormats/TrackerRecHit2D/interface/SiPixelRecHitCollection.h" -#include "DataFormats/TrackerRecHit2D/interface/SiStripRecHit2DCollection.h" -#include "DataFormats/TrackerRecHit2D/interface/trackerHitRTTI.h" - -#include "DataFormats/TrackerCommon/interface/TrackerTopology.h" -#include "DataFormats/TrackerCommon/interface/TrackerDetSide.h" -#include "Geometry/Records/interface/TrackerTopologyRcd.h" - -#include "TrackingTools/Records/interface/TransientRecHitRecord.h" -#include "TrackingTools/TransientTrackingRecHit/interface/TransientTrackingRecHitBuilder.h" -#include "TrackingTools/TrajectoryState/interface/TrajectoryStateTransform.h" - -#include "MagneticField/Engine/interface/MagneticField.h" -#include "MagneticField/Records/interface/IdealMagneticFieldRecord.h" - -#include "RecoTracker/MkFit/interface/MkFitInputWrapper.h" - -// ROOT -#include "Math/SVector.h" -#include "Math/SMatrix.h" - -// mkFit includes -#include "Hit.h" -#include "Track.h" -#include "LayerNumberConverter.h" - -class MkFitInputConverter : public edm::global::EDProducer<> { -public: - explicit MkFitInputConverter(edm::ParameterSet const& iConfig); - ~MkFitInputConverter() override = default; - - static void fillDescriptions(edm::ConfigurationDescriptions& descriptions); - -private: - void produce(edm::StreamID, edm::Event& iEvent, const edm::EventSetup& iSetup) const override; - - template - void convertHits(const HitCollection& hits, - std::vector& mkFitHits, - MkFitHitIndexMap& hitIndexMap, - int& totalHits, - const TrackerTopology& ttopo, - const TransientTrackingRecHitBuilder& ttrhBuilder, - const mkfit::LayerNumberConverter& lnc) const; - - bool passCCC(const SiStripRecHit2D& hit, const DetId hitId) const; - bool passCCC(const SiPixelRecHit& hit, const DetId hitId) const; - - mkfit::TrackVec convertSeeds(const edm::View& seeds, - const MkFitHitIndexMap& hitIndexMap, - const TransientTrackingRecHitBuilder& ttrhBuilder, - const MagneticField& mf) const; - - using SVector3 = ROOT::Math::SVector; - using SMatrixSym33 = ROOT::Math::SMatrix>; - using SMatrixSym66 = ROOT::Math::SMatrix>; - - edm::EDGetTokenT pixelRecHitToken_; - edm::EDGetTokenT stripRphiRecHitToken_; - edm::EDGetTokenT stripStereoRecHitToken_; - edm::EDGetTokenT> seedToken_; - edm::ESGetToken ttrhBuilderToken_; - edm::ESGetToken ttopoToken_; - edm::ESGetToken mfToken_; - edm::EDPutTokenT putToken_; - const float minGoodStripCharge_; -}; - -MkFitInputConverter::MkFitInputConverter(edm::ParameterSet const& iConfig) - : pixelRecHitToken_{consumes(iConfig.getParameter("pixelRecHits"))}, - stripRphiRecHitToken_{ - consumes(iConfig.getParameter("stripRphiRecHits"))}, - stripStereoRecHitToken_{ - consumes(iConfig.getParameter("stripStereoRecHits"))}, - seedToken_{consumes>(iConfig.getParameter("seeds"))}, - ttrhBuilderToken_{esConsumes( - iConfig.getParameter("ttrhBuilder"))}, - ttopoToken_{esConsumes()}, - mfToken_{esConsumes()}, - putToken_{produces()}, - minGoodStripCharge_{static_cast( - iConfig.getParameter("minGoodStripCharge").getParameter("value"))} {} - -void MkFitInputConverter::fillDescriptions(edm::ConfigurationDescriptions& descriptions) { - edm::ParameterSetDescription desc; - - desc.add("pixelRecHits", edm::InputTag{"siPixelRecHits"}); - desc.add("stripRphiRecHits", edm::InputTag{"siStripMatchedRecHits", "rphiRecHit"}); - desc.add("stripStereoRecHits", edm::InputTag{"siStripMatchedRecHits", "stereoRecHit"}); - desc.add("seeds", edm::InputTag{"initialStepSeeds"}); - desc.add("ttrhBuilder", edm::ESInputTag{"", "WithTrackAngle"}); - - edm::ParameterSetDescription descCCC; - descCCC.add("value"); - desc.add("minGoodStripCharge", descCCC); - - descriptions.add("mkFitInputConverterDefault", desc); -} - -void MkFitInputConverter::produce(edm::StreamID iID, edm::Event& iEvent, const edm::EventSetup& iSetup) const { - mkfit::LayerNumberConverter lnc{mkfit::TkLayout::phase1}; - - // Then import hits - const auto& ttrhBuilder = iSetup.getData(ttrhBuilderToken_); - const auto& ttopo = iSetup.getData(ttopoToken_); - - std::vector mkFitHits(lnc.nLayers()); - MkFitHitIndexMap hitIndexMap; - int totalHits = 0; // I need to have a global hit index in order to have the hit remapping working? - // Process strips first for better memory allocation pattern - convertHits(iEvent.get(stripRphiRecHitToken_), mkFitHits, hitIndexMap, totalHits, ttopo, ttrhBuilder, lnc); - convertHits(iEvent.get(stripStereoRecHitToken_), mkFitHits, hitIndexMap, totalHits, ttopo, ttrhBuilder, lnc); - convertHits(iEvent.get(pixelRecHitToken_), mkFitHits, hitIndexMap, totalHits, ttopo, ttrhBuilder, lnc); - - // Then import seeds - auto mkFitSeeds = convertSeeds(iEvent.get(seedToken_), hitIndexMap, ttrhBuilder, iSetup.getData(mfToken_)); - - iEvent.emplace(putToken_, std::move(hitIndexMap), std::move(mkFitHits), std::move(mkFitSeeds), lnc); -} - -bool MkFitInputConverter::passCCC(const SiStripRecHit2D& hit, const DetId hitId) const { - return (siStripClusterTools::chargePerCM(hitId, hit.firstClusterRef().stripCluster()) > minGoodStripCharge_); -} - -bool MkFitInputConverter::passCCC(const SiPixelRecHit& hit, const DetId hitId) const { return true; } - -template -void MkFitInputConverter::convertHits(const HitCollection& hits, - std::vector& mkFitHits, - MkFitHitIndexMap& hitIndexMap, - int& totalHits, - const TrackerTopology& ttopo, - const TransientTrackingRecHitBuilder& ttrhBuilder, - const mkfit::LayerNumberConverter& lnc) const { - if (hits.empty()) - return; - auto isPlusSide = [&ttopo](const DetId& detid) { - return ttopo.side(detid) == static_cast(TrackerDetSide::PosEndcap); - }; - - { - const DetId detid{hits.ids().back()}; - const auto ilay = - lnc.convertLayerNumber(detid.subdetId(), ttopo.layer(detid), false, ttopo.isStereo(detid), isPlusSide(detid)); - // Do initial reserves to minimize further memory allocations - const auto& lastClusterRef = hits.data().back().firstClusterRef(); - hitIndexMap.resizeByClusterIndex(lastClusterRef.id(), lastClusterRef.index()); - hitIndexMap.increaseLayerSize(ilay, hits.detsetSize(hits.ids().size() - 1)); - } - - for (const auto& detset : hits) { - const DetId detid = detset.detId(); - const auto subdet = detid.subdetId(); - const auto layer = ttopo.layer(detid); - const auto isStereo = ttopo.isStereo(detid); - const auto ilay = lnc.convertLayerNumber(subdet, layer, false, isStereo, isPlusSide(detid)); - hitIndexMap.increaseLayerSize(ilay, detset.size()); // to minimize memory allocations - - for (const auto& hit : detset) { - if (!passCCC(hit, detid)) - continue; - - const auto& gpos = hit.globalPosition(); - SVector3 pos(gpos.x(), gpos.y(), gpos.z()); - const auto& gerr = hit.globalPositionError(); - SMatrixSym33 err; - err.At(0, 0) = gerr.cxx(); - err.At(1, 1) = gerr.cyy(); - err.At(2, 2) = gerr.czz(); - err.At(0, 1) = gerr.cyx(); - err.At(0, 2) = gerr.czx(); - err.At(1, 2) = gerr.czy(); - - LogTrace("MkFitInputConverter") << "Adding hit detid " << detid.rawId() << " subdet " << subdet << " layer " - << layer << " isStereo " << isStereo << " zplus " << isPlusSide(detid) << " ilay " - << ilay; - - hitIndexMap.insert(hit.firstClusterRef().id(), - hit.firstClusterRef().index(), - MkFitHitIndexMap::MkFitHit{static_cast(mkFitHits[ilay].size()), ilay}, - &hit); - mkFitHits[ilay].emplace_back(pos, err, totalHits); - ++totalHits; - } - } -} - -mkfit::TrackVec MkFitInputConverter::convertSeeds(const edm::View& seeds, - const MkFitHitIndexMap& hitIndexMap, - const TransientTrackingRecHitBuilder& ttrhBuilder, - const MagneticField& mf) const { - mkfit::TrackVec ret; - ret.reserve(seeds.size()); - int index = 0; - for (const auto& seed : seeds) { - auto const& hitRange = seed.recHits(); - const auto lastRecHit = ttrhBuilder.build(&*(hitRange.end() - 1)); - const auto tsos = trajectoryStateTransform::transientState(seed.startingState(), lastRecHit->surface(), &mf); - const auto& stateGlobal = tsos.globalParameters(); - const auto& gpos = stateGlobal.position(); - const auto& gmom = stateGlobal.momentum(); - SVector3 pos(gpos.x(), gpos.y(), gpos.z()); - SVector3 mom(gmom.x(), gmom.y(), gmom.z()); - - const auto cartError = tsos.cartesianError(); // returns a temporary, so can't chain with the following line - const auto& cov = cartError.matrix(); - SMatrixSym66 err; - for (int i = 0; i < 6; ++i) { - for (int j = i; j < 6; ++j) { - err.At(i, j) = cov[i][j]; - } - } - - mkfit::TrackState state(tsos.charge(), pos, mom, err); - state.convertFromCartesianToCCS(); - ret.emplace_back(state, 0, index, 0, nullptr); - - // Add hits - for (auto const& recHit : hitRange) { - if (not trackerHitRTTI::isFromDet(recHit)) { - throw cms::Exception("Assert") << "Encountered a seed with a hit which is not trackerHitRTTI::isFromDet()"; - } - const auto& clusterRef = static_cast(recHit).firstClusterRef(); - const auto& mkFitHit = hitIndexMap.mkFitHit(clusterRef.id(), clusterRef.index()); - ret.back().addHitIdx(mkFitHit.index(), mkFitHit.layer(), 0); // per-hit chi2 is not known - } - ++index; - } - return ret; -} - -DEFINE_FWK_MODULE(MkFitInputConverter); diff --git a/RecoTracker/MkFit/plugins/MkFitIterationConfigESProducer.cc b/RecoTracker/MkFit/plugins/MkFitIterationConfigESProducer.cc new file mode 100644 index 0000000000000..dc79d3fbd582a --- /dev/null +++ b/RecoTracker/MkFit/plugins/MkFitIterationConfigESProducer.cc @@ -0,0 +1,40 @@ +#include "FWCore/Framework/interface/ModuleFactory.h" +#include "FWCore/Framework/interface/ESProducer.h" + +#include "RecoTracker/Record/interface/TrackerRecoGeometryRecord.h" + +#include "RecoTracker/MkFit/interface/MkFitGeometry.h" + +// mkFit includes +#include "mkFit/IterationConfig.h" + +class MkFitIterationConfigESProducer : public edm::ESProducer { +public: + MkFitIterationConfigESProducer(const edm::ParameterSet& iConfig); + + static void fillDescriptions(edm::ConfigurationDescriptions& descriptions); + + std::unique_ptr produce(const TrackerRecoGeometryRecord& iRecord); + +private: + const edm::ESGetToken geomToken_; + const std::string configFile_; +}; + +MkFitIterationConfigESProducer::MkFitIterationConfigESProducer(const edm::ParameterSet& iConfig) + : geomToken_{setWhatProduced(this, iConfig.getParameter("ComponentName")).consumes()}, + configFile_{iConfig.getParameter("config").fullPath()} {} + +void MkFitIterationConfigESProducer::fillDescriptions(edm::ConfigurationDescriptions& descriptions) { + edm::ParameterSetDescription desc; + desc.add("ComponentName")->setComment("Product label"); + desc.add("config")->setComment("Path to the JSON file for the mkFit configuration parameters"); + descriptions.addWithDefaultLabel(desc); +} + +std::unique_ptr MkFitIterationConfigESProducer::produce( + const TrackerRecoGeometryRecord& iRecord) { + return mkfit::ConfigJson_Load_File(iRecord.get(geomToken_).iterationsInfo(), configFile_); +} + +DEFINE_FWK_EVENTSETUP_MODULE(MkFitIterationConfigESProducer); diff --git a/RecoTracker/MkFit/plugins/MkFitOutputConverter.cc b/RecoTracker/MkFit/plugins/MkFitOutputConverter.cc index b21bc7c35b8b0..735034c6d1cda 100644 --- a/RecoTracker/MkFit/plugins/MkFitOutputConverter.cc +++ b/RecoTracker/MkFit/plugins/MkFitOutputConverter.cc @@ -11,12 +11,7 @@ #include "DataFormats/TrackCandidate/interface/TrackCandidateCollection.h" #include "DataFormats/TrackReco/interface/SeedStopInfo.h" #include "DataFormats/TrackingRecHit/interface/InvalidTrackingRecHit.h" - -#include "Geometry/TrackerGeometryBuilder/interface/TrackerGeometry.h" -#include "Geometry/Records/interface/TrackerDigiGeometryRecord.h" -#include "DataFormats/TrackerCommon/interface/TrackerTopology.h" -#include "DataFormats/TrackerCommon/interface/TrackerDetSide.h" -#include "Geometry/Records/interface/TrackerTopologyRcd.h" +#include "DataFormats/TrackerRecHit2D/interface/SiStripRecHit1D.h" #include "TrackingTools/Records/interface/TransientRecHitRecord.h" #include "TrackingTools/TransientTrackingRecHit/interface/TransientTrackingRecHitBuilder.h" @@ -34,15 +29,17 @@ #include "RecoTracker/TransientTrackingRecHit/interface/TkTransientTrackingRecHitBuilder.h" #include "TrackingTools/MaterialEffects/src/PropagatorWithMaterial.cc" -#include "RecoTracker/MeasurementDet/interface/MeasurementTrackerEvent.h" -#include "RecoTracker/TkDetLayers/interface/GeometricSearchTracker.h" - -#include "RecoTracker/MkFit/interface/MkFitInputWrapper.h" +#include "RecoTracker/MkFit/interface/MkFitEventOfHits.h" +#include "RecoTracker/MkFit/interface/MkFitClusterIndexToHit.h" +#include "RecoTracker/MkFit/interface/MkFitSeedWrapper.h" #include "RecoTracker/MkFit/interface/MkFitOutputWrapper.h" +#include "RecoTracker/MkFit/interface/MkFitGeometry.h" +#include "RecoTracker/Record/interface/TrackerRecoGeometryRecord.h" // mkFit indludes #include "LayerNumberConverter.h" #include "Track.h" +#include "mkFit/HitStructures.h" namespace { template @@ -68,14 +65,11 @@ class MkFitOutputConverter : public edm::global::EDProducer<> { private: void produce(edm::StreamID, edm::Event& iEvent, const edm::EventSetup& iSetup) const override; - std::vector createDetLayers(const mkfit::LayerNumberConverter& lnc, - const GeometricSearchTracker& tracker, - const TrackerTopology& ttopo) const; - TrackCandidateCollection convertCandidates(const MkFitOutputWrapper& mkFitOutput, - const MkFitHitIndexMap& hitIndexMap, + const mkfit::EventOfHits& eventOfHits, + const MkFitClusterIndexToHit& pixelClusterIndexToHit, + const MkFitClusterIndexToHit& stripClusterIndexToHit, const edm::View& seeds, - const TrackerGeometry& geom, const MagneticField& mf, const Propagator& propagatorAlong, const Propagator& propagatorOpposite, @@ -96,134 +90,92 @@ class MkFitOutputConverter : public edm::global::EDProducer<> { const Propagator& propagatorAlong, const Propagator& propagatorOpposite) const; - edm::EDGetTokenT hitsSeedsToken_; - edm::EDGetTokenT tracksToken_; - edm::EDGetTokenT> seedToken_; - edm::EDGetTokenT mteToken_; - edm::ESGetToken geomToken_; - edm::ESGetToken propagatorAlongToken_; - edm::ESGetToken propagatorOppositeToken_; - edm::ESGetToken ttopoToken_; - edm::ESGetToken mfToken_; - edm::ESGetToken ttrhBuilderToken_; - edm::EDPutTokenT putTrackCandidateToken_; - edm::EDPutTokenT> putSeedStopInfoToken_; - std::string ttrhBuilderName_; - std::string propagatorAlongName_; - std::string propagatorOppositeName_; - bool backwardFitInCMSSW_; + const edm::EDGetTokenT eventOfHitsToken_; + const edm::EDGetTokenT pixelClusterIndexToHitToken_; + const edm::EDGetTokenT stripClusterIndexToHitToken_; + const edm::EDGetTokenT mkfitSeedToken_; + const edm::EDGetTokenT tracksToken_; + const edm::EDGetTokenT> seedToken_; + const edm::ESGetToken propagatorAlongToken_; + const edm::ESGetToken propagatorOppositeToken_; + const edm::ESGetToken mfToken_; + const edm::ESGetToken ttrhBuilderToken_; + const edm::ESGetToken mkFitGeomToken_; + const edm::EDPutTokenT putTrackCandidateToken_; + const edm::EDPutTokenT> putSeedStopInfoToken_; + const std::string ttrhBuilderName_; + const std::string propagatorAlongName_; + const std::string propagatorOppositeName_; }; MkFitOutputConverter::MkFitOutputConverter(edm::ParameterSet const& iConfig) - : hitsSeedsToken_{consumes(iConfig.getParameter("hitsSeeds"))}, + : eventOfHitsToken_{consumes(iConfig.getParameter("mkFitEventOfHits"))}, + pixelClusterIndexToHitToken_{consumes(iConfig.getParameter("mkFitPixelHits"))}, + stripClusterIndexToHitToken_{consumes(iConfig.getParameter("mkFitStripHits"))}, + mkfitSeedToken_{consumes(iConfig.getParameter("mkFitSeeds"))}, tracksToken_{consumes(iConfig.getParameter("tracks"))}, seedToken_{consumes>(iConfig.getParameter("seeds"))}, - mteToken_{consumes(iConfig.getParameter("measurementTrackerEvent"))}, - geomToken_{esConsumes()}, propagatorAlongToken_{ esConsumes(iConfig.getParameter("propagatorAlong"))}, propagatorOppositeToken_{esConsumes( iConfig.getParameter("propagatorOpposite"))}, - ttopoToken_{esConsumes()}, mfToken_{esConsumes()}, ttrhBuilderToken_{esConsumes( iConfig.getParameter("ttrhBuilder"))}, + mkFitGeomToken_{esConsumes()}, putTrackCandidateToken_{produces()}, - putSeedStopInfoToken_{produces>()}, - backwardFitInCMSSW_{iConfig.getParameter("backwardFitInCMSSW")} {} + putSeedStopInfoToken_{produces>()} {} void MkFitOutputConverter::fillDescriptions(edm::ConfigurationDescriptions& descriptions) { edm::ParameterSetDescription desc; - desc.add("hitsSeeds", edm::InputTag{"mkFitInputConverter"}); + desc.add("mkFitEventOfHits", edm::InputTag{"mkFitEventOfHits"}); + desc.add("mkFitPixelHits", edm::InputTag{"mkFitSiPixelHits"}); + desc.add("mkFitStripHits", edm::InputTag{"mkFitSiStripHits"}); + desc.add("mkFitSeeds", edm::InputTag{"mkFitSeedConverter"}); desc.add("tracks", edm::InputTag{"mkFitProducer"}); desc.add("seeds", edm::InputTag{"initialStepSeeds"}); - desc.add("measurementTrackerEvent", edm::InputTag{"MeasurementTrackerEvent"}); desc.add("ttrhBuilder", edm::ESInputTag{"", "WithTrackAngle"}); desc.add("propagatorAlong", edm::ESInputTag{"", "PropagatorWithMaterial"}); desc.add("propagatorOpposite", edm::ESInputTag{"", "PropagatorWithMaterialOpposite"}); - desc.add("backwardFitInCMSSW", false) - ->setComment("Do backward fit (to innermost hit) in CMSSW (true) or mkFit (false)"); descriptions.addWithDefaultLabel(desc); } void MkFitOutputConverter::produce(edm::StreamID iID, edm::Event& iEvent, const edm::EventSetup& iSetup) const { const auto& seeds = iEvent.get(seedToken_); - const auto& hitsSeeds = iEvent.get(hitsSeedsToken_); - const auto& mte = iEvent.get(mteToken_); + const auto& mkfitSeeds = iEvent.get(mkfitSeedToken_); const auto& ttrhBuilder = iSetup.getData(ttrhBuilderToken_); const auto* tkBuilder = dynamic_cast(&ttrhBuilder); if (!tkBuilder) { throw cms::Exception("LogicError") << "TTRHBuilder must be of type TkTransientTrackingRecHitBuilder"; } + const auto& mkFitGeom = iSetup.getData(mkFitGeomToken_); // Convert mkfit presentation back to CMSSW - const auto detlayers = - createDetLayers(hitsSeeds.layerNumberConverter(), *(mte.geometricSearchTracker()), iSetup.getData(ttopoToken_)); iEvent.emplace(putTrackCandidateToken_, convertCandidates(iEvent.get(tracksToken_), - hitsSeeds.hitIndexMap(), + iEvent.get(eventOfHitsToken_).get(), + iEvent.get(pixelClusterIndexToHitToken_), + iEvent.get(stripClusterIndexToHitToken_), seeds, - iSetup.getData(geomToken_), iSetup.getData(mfToken_), iSetup.getData(propagatorAlongToken_), iSetup.getData(propagatorOppositeToken_), tkBuilder->cloner(), - detlayers, - hitsSeeds.seeds())); + mkFitGeom.detLayers(), + mkfitSeeds.seeds())); // TODO: SeedStopInfo is currently unfilled iEvent.emplace(putSeedStopInfoToken_, seeds.size()); } -std::vector MkFitOutputConverter::createDetLayers(const mkfit::LayerNumberConverter& lnc, - const GeometricSearchTracker& tracker, - const TrackerTopology& ttopo) const { - std::vector dets(lnc.nLayers(), nullptr); - - auto isPlusSide = [&ttopo](const DetId& detid) { - return ttopo.side(detid) == static_cast(TrackerDetSide::PosEndcap); - }; - auto setDet = [&lnc, &dets, &isPlusSide]( - const int subdet, const int layer, const int isStereo, const DetId& detId, const DetLayer* lay) { - const int index = lnc.convertLayerNumber(subdet, layer, false, isStereo, isPlusSide(detId)); - if (index < 0 or static_cast(index) >= dets.size()) { - throw cms::Exception("LogicError") << "Invalid mkFit layer index " << index << " for det rawId " << detId.rawId() - << " " - << " subdet " << subdet << " layer " << layer << " isStereo " << isStereo; - } - dets[index] = lay; - }; - constexpr int monoLayer = 0; - constexpr int stereoLayer = 1; - for (const DetLayer* lay : tracker.allLayers()) { - const auto& comp = lay->basicComponents(); - if (UNLIKELY(comp.empty())) { - throw cms::Exception("LogicError") << "Got a tracker layer (subdet " << lay->subDetector() - << ") with empty basicComponents."; - } - // First component is enough for layer and side information - const auto& detId = comp.front()->geographicalId(); - const auto subdet = detId.subdetId(); - const auto layer = ttopo.layer(detId); - - // TODO: mono/stereo structure is still hardcoded for phase0/1 strip tracker - setDet(subdet, layer, monoLayer, detId, lay); - if (((subdet == StripSubdetector::TIB or subdet == StripSubdetector::TOB) and (layer == 1 or layer == 2)) or - subdet == StripSubdetector::TID or subdet == StripSubdetector::TEC) { - setDet(subdet, layer, stereoLayer, detId, lay); - } - } - - return dets; -} - TrackCandidateCollection MkFitOutputConverter::convertCandidates(const MkFitOutputWrapper& mkFitOutput, - const MkFitHitIndexMap& hitIndexMap, + const mkfit::EventOfHits& eventOfHits, + const MkFitClusterIndexToHit& pixelClusterIndexToHit, + const MkFitClusterIndexToHit& stripClusterIndexToHit, const edm::View& seeds, - const TrackerGeometry& geom, const MagneticField& mf, const Propagator& propagatorAlong, const Propagator& propagatorOpposite, @@ -231,10 +183,10 @@ TrackCandidateCollection MkFitOutputConverter::convertCandidates(const MkFitOutp const std::vector& detLayers, const mkfit::TrackVec& mkFitSeeds) const { TrackCandidateCollection output; - const auto& candidates = backwardFitInCMSSW_ ? mkFitOutput.candidateTracks() : mkFitOutput.fitTracks(); + const auto& candidates = mkFitOutput.tracks(); output.reserve(candidates.size()); - LogTrace("MkFitOutputConverter") << "Number of candidates " << mkFitOutput.candidateTracks().size(); + LogTrace("MkFitOutputConverter") << "Number of candidates " << candidates.size(); int candIndex = -1; for (const auto& cand : candidates) { @@ -272,14 +224,24 @@ TrackCandidateCollection MkFitOutputConverter::convertCandidates(const MkFitOutp // them in the TrackProducer. lastHitInvalid = true; } else { - recHits.push_back(hitIndexMap.hitPtr(MkFitHitIndexMap::MkFitHit{hitOnTrack.index, hitOnTrack.layer})->clone()); + auto const isPixel = eventOfHits[hitOnTrack.layer].is_pix_lyr(); + auto const& hits = isPixel ? pixelClusterIndexToHit.hits() : stripClusterIndexToHit.hits(); + + auto const& thit = static_cast(*hits[hitOnTrack.index]); + if (thit.firstClusterRef().isPixel() || thit.detUnit()->type().isEndcap()) { + recHits.push_back(hits[hitOnTrack.index]->clone()); + } else { + recHits.push_back(std::make_unique( + thit.localPosition(), + LocalError(thit.localPositionError().xx(), 0.f, std::numeric_limits::max()), + *thit.det(), + thit.firstClusterRef())); + } LogTrace("MkFitOutputConverter") << " pos " << recHits.back().globalPosition().x() << " " << recHits.back().globalPosition().y() << " " << recHits.back().globalPosition().z() << " mag2 " << recHits.back().globalPosition().mag2() << " detid " - << recHits.back().geographicalId().rawId() << " cluster " - << hitIndexMap.clusterIndex( - MkFitHitIndexMap::MkFitHit{hitOnTrack.index, hitOnTrack.layer}); + << recHits.back().geographicalId().rawId() << " cluster " << hitOnTrack.index; lastHitInvalid = false; } } @@ -354,9 +316,9 @@ TrackCandidateCollection MkFitOutputConverter::convertCandidates(const MkFitOutp } auto tsosDet = - backwardFitInCMSSW_ - ? backwardFit(fts, recHits, propagatorAlong, propagatorOpposite, hitCloner, lastHitInvalid, lastHitChanged) - : convertInnermostState(fts, recHits, propagatorAlong, propagatorOpposite); + mkFitOutput.propagatedToFirstLayer() + ? convertInnermostState(fts, recHits, propagatorAlong, propagatorOpposite) + : backwardFit(fts, recHits, propagatorAlong, propagatorOpposite, hitCloner, lastHitInvalid, lastHitChanged); if (!tsosDet.first.isValid()) { edm::LogWarning("MkFitOutputConverter") << "Backward fit of candidate " << candIndex << " failed, ignoring the candidate"; diff --git a/RecoTracker/MkFit/plugins/MkFitProducer.cc b/RecoTracker/MkFit/plugins/MkFitProducer.cc index 33a2ac0f33853..4d2aa849d6863 100644 --- a/RecoTracker/MkFit/plugins/MkFitProducer.cc +++ b/RecoTracker/MkFit/plugins/MkFitProducer.cc @@ -5,19 +5,23 @@ #include "FWCore/Framework/interface/MakerMacros.h" #include "FWCore/ParameterSet/interface/ParameterSet.h" -#include "DataFormats/SiPixelDetId/interface/PixelSubdetector.h" -#include "DataFormats/SiStripDetId/interface/StripSubdetector.h" - -#include "Geometry/TrackerGeometryBuilder/interface/TrackerGeometry.h" -#include "Geometry/Records/interface/TrackerDigiGeometryRecord.h" - -#include "RecoTracker/MkFit/interface/MkFitInputWrapper.h" +#include "DataFormats/Common/interface/ContainerMask.h" +#include "DataFormats/Common/interface/DetSetVectorNew.h" +#include "DataFormats/SiPixelCluster/interface/SiPixelCluster.h" +#include "DataFormats/SiStripCluster/interface/SiStripClusterfwd.h" + +#include "RecoTracker/MkFit/interface/MkFitEventOfHits.h" +#include "RecoTracker/MkFit/interface/MkFitHitWrapper.h" +#include "RecoTracker/MkFit/interface/MkFitSeedWrapper.h" #include "RecoTracker/MkFit/interface/MkFitOutputWrapper.h" +#include "RecoTracker/MkFit/interface/MkFitGeometry.h" +#include "RecoTracker/Record/interface/TrackerRecoGeometryRecord.h" // mkFit includes #include "ConfigWrapper.h" -#include "Event.h" +#include "LayerNumberConverter.h" #include "mkFit/buildtestMPlex.h" +#include "mkFit/IterationConfig.h" #include "mkFit/MkBuilderWrapper.h" // TBB includes @@ -26,7 +30,7 @@ // std includes #include -class MkFitProducer : public edm::global::EDProducer > { +class MkFitProducer : public edm::global::EDProducer> { public: explicit MkFitProducer(edm::ParameterSet const& iConfig); ~MkFitProducer() override = default; @@ -38,67 +42,95 @@ class MkFitProducer : public edm::global::EDProducer hitsSeedsToken_; - edm::ESGetToken geomToken_; - edm::EDPutTokenT putToken_; + void stripClusterChargeCut(const std::vector& stripClusterCharge, std::vector& mask) const; + + const edm::EDGetTokenT pixelHitsToken_; + const edm::EDGetTokenT stripHitsToken_; + const edm::EDGetTokenT> stripClusterChargeToken_; + const edm::EDGetTokenT eventOfHitsToken_; + const edm::EDGetTokenT seedToken_; + edm::EDGetTokenT>> pixelMaskToken_; + edm::EDGetTokenT>> stripMaskToken_; + const edm::ESGetToken mkFitGeomToken_; + const edm::ESGetToken mkFitIterConfigToken_; + const edm::EDPutTokenT putToken_; std::function buildFunction_; - bool backwardFitInCMSSW_; - bool mkFitSilent_; + const float minGoodStripCharge_; + const bool seedCleaning_; + const bool backwardFitInCMSSW_; + const bool removeDuplicates_; + const bool mkFitSilent_; + const bool limitConcurrency_; }; MkFitProducer::MkFitProducer(edm::ParameterSet const& iConfig) - : hitsSeedsToken_{consumes(iConfig.getParameter("hitsSeeds"))}, - geomToken_{esConsumes()}, + : pixelHitsToken_{consumes(iConfig.getParameter("pixelHits"))}, + stripHitsToken_{consumes(iConfig.getParameter("stripHits"))}, + stripClusterChargeToken_{consumes(iConfig.getParameter("stripHits"))}, + eventOfHitsToken_{consumes(iConfig.getParameter("eventOfHits"))}, + seedToken_{consumes(iConfig.getParameter("seeds"))}, + mkFitGeomToken_{esConsumes()}, + mkFitIterConfigToken_{esConsumes(iConfig.getParameter("config"))}, putToken_{produces()}, + minGoodStripCharge_{static_cast( + iConfig.getParameter("minGoodStripCharge").getParameter("value"))}, + seedCleaning_{iConfig.getParameter("seedCleaning")}, backwardFitInCMSSW_{iConfig.getParameter("backwardFitInCMSSW")}, - mkFitSilent_{iConfig.getUntrackedParameter("mkFitSilent")} { + removeDuplicates_{iConfig.getParameter("removeDuplicates")}, + mkFitSilent_{iConfig.getUntrackedParameter("mkFitSilent")}, + limitConcurrency_{iConfig.getUntrackedParameter("limitConcurrency")} { + const auto clustersToSkip = iConfig.getParameter("clustersToSkip"); + if (not clustersToSkip.label().empty()) { + pixelMaskToken_ = consumes(clustersToSkip); + stripMaskToken_ = consumes(clustersToSkip); + } + const auto build = iConfig.getParameter("buildingRoutine"); - bool isFV = false; if (build == "bestHit") { - buildFunction_ = mkfit::runBuildingTestPlexBestHit; + //buildFunction_ = mkfit::runBuildingTestPlexBestHit; + throw cms::Exception("Configuration") << "bestHit is temporarily disabled"; } else if (build == "standard") { - buildFunction_ = mkfit::runBuildingTestPlexStandard; + //buildFunction_ = mkfit::runBuildingTestPlexStandard; + throw cms::Exception("Configuration") << "standard is temporarily disabled"; } else if (build == "cloneEngine") { - buildFunction_ = mkfit::runBuildingTestPlexCloneEngine; - } else if (build == "fullVector") { - isFV = true; - buildFunction_ = mkfit::runBuildingTestPlexFV; - } else { - throw cms::Exception("Configuration") << "Invalid value for parameter 'buildingRoutine' " << build - << ", allowed are bestHit, standard, cloneEngine, fullVector"; - } - - const auto seedClean = iConfig.getParameter("seedCleaning"); - auto seedCleanOpt = mkfit::ConfigWrapper::SeedCleaningOpts::noCleaning; - if (seedClean == "none") { - seedCleanOpt = mkfit::ConfigWrapper::SeedCleaningOpts::noCleaning; - } else if (seedClean == "N2") { - seedCleanOpt = mkfit::ConfigWrapper::SeedCleaningOpts::cleanSeedsN2; + //buildFunction_ = mkfit::runBuildingTestPlexCloneEngine; } else { throw cms::Exception("Configuration") - << "Invalida value for parameter 'seedCleaning' " << seedClean << ", allowed are none, N2"; + << "Invalid value for parameter 'buildingRoutine' " << build << ", allowed are bestHit, standard, cloneEngine"; } - auto backwardFitOpt = - backwardFitInCMSSW_ ? mkfit::ConfigWrapper::BackwardFit::noFit : mkfit::ConfigWrapper::BackwardFit::toFirstLayer; - // TODO: what to do when we have multiple instances of MkFitProducer in a job? - mkfit::MkBuilderWrapper::populate(isFV); - mkfit::ConfigWrapper::initializeForCMSSW(seedCleanOpt, backwardFitOpt, mkFitSilent_); + mkfit::MkBuilderWrapper::populate(); + mkfit::ConfigWrapper::initializeForCMSSW(mkFitSilent_); } void MkFitProducer::fillDescriptions(edm::ConfigurationDescriptions& descriptions) { edm::ParameterSetDescription desc; - desc.add("hitsSeeds", edm::InputTag("mkFitInputConverter")); + desc.add("pixelHits", edm::InputTag("mkFitSiPixelHits")); + desc.add("stripHits", edm::InputTag("mkFitSiStripHits")); + desc.add("eventOfHits", edm::InputTag("mkFitEventOfHits")); + desc.add("seeds", edm::InputTag("mkFitSeedConverter")); + desc.add("clustersToSkip", edm::InputTag()); desc.add("buildingRoutine", "cloneEngine") - ->setComment("Valid values are: 'bestHit', 'standard', 'cloneEngine', 'fullVector'"); - desc.add("seedCleaning", "N2")->setComment("Valid values are: 'none', 'N2'"); + ->setComment("Valid values are: 'bestHit', 'standard', 'cloneEngine'"); + desc.add("config")->setComment( + "ESProduct that has the mkFit configuration parameters for this iteration"); + desc.add("seedCleaning", true)->setComment("Clean seeds within mkFit"); + desc.add("removeDuplicates", true)->setComment("Run duplicate removal within mkFit"); desc.add("backwardFitInCMSSW", false) ->setComment("Do backward fit (to innermost hit) in CMSSW (true) or mkFit (false)"); desc.addUntracked("mkFitSilent", true)->setComment("Allows to enables printouts from mkFit with 'False'"); + desc.addUntracked("limitConcurrency", false) + ->setComment( + "Use tbb::task_arena to limit the internal concurrency to 1; useful only for timing studies when measuring " + "the module time"); + + edm::ParameterSetDescription descCCC; + descCCC.add("value"); + desc.add("minGoodStripCharge", descCCC); - descriptions.add("mkFitProducer", desc); + descriptions.add("mkFitProducerDefault", desc); } std::unique_ptr MkFitProducer::beginStream(edm::StreamID iID) const { @@ -109,29 +141,84 @@ namespace { std::once_flag geometryFlag; } void MkFitProducer::produce(edm::StreamID iID, edm::Event& iEvent, const edm::EventSetup& iSetup) const { - const auto& hitsSeeds = iEvent.get(hitsSeedsToken_); - const auto& geom = iSetup.getData(geomToken_); - - if (geom.numberOfLayers(PixelSubdetector::PixelBarrel) != 4 || - geom.numberOfLayers(PixelSubdetector::PixelEndcap) != 3) { - throw cms::Exception("Assert") << "For now this code works only with phase1 tracker, you have something else"; + const auto& pixelHits = iEvent.get(pixelHitsToken_); + const auto& stripHits = iEvent.get(stripHitsToken_); + const auto& eventOfHits = iEvent.get(eventOfHitsToken_); + const auto& seeds = iEvent.get(seedToken_); + // This producer does not strictly speaking need the MkFitGeometry, + // but the ESProducer sets global variables (yes, that "feature" + // should be removed), so getting the MkFitGeometry makes it + // sure that the ESProducer is called even if the input/output + // converters + const auto& mkFitGeom = iSetup.getData(mkFitGeomToken_); + const auto& mkFitIterConfig = iSetup.getData(mkFitIterConfigToken_); + + const std::vector* pixelMaskPtr = nullptr; + std::vector pixelMask; + std::vector stripMask(stripHits.hits().size(), false); + if (not pixelMaskToken_.isUninitialized()) { + const auto& pixelContainerMask = iEvent.get(pixelMaskToken_); + pixelMask.resize(pixelContainerMask.size(), false); + if UNLIKELY (pixelContainerMask.refProd().id() != pixelHits.clustersID()) { + throw cms::Exception("LogicError") << "MkFitHitWrapper has pixel cluster ID " << pixelHits.clustersID() + << " but pixel cluster mask has " << pixelContainerMask.refProd().id(); + } + pixelContainerMask.copyMaskTo(pixelMask); + pixelMaskPtr = &pixelMask; + + const auto& stripContainerMask = iEvent.get(stripMaskToken_); + if UNLIKELY (stripContainerMask.refProd().id() != stripHits.clustersID()) { + throw cms::Exception("LogicError") << "MkFitHitWrapper has strip cluster ID " << stripHits.clustersID() + << " but strip cluster mask has " << stripContainerMask.refProd().id(); + } + stripContainerMask.copyMaskTo(stripMask); + } else { + stripClusterChargeCut(iEvent.get(stripClusterChargeToken_), stripMask); } // Initialize the number of layers, has to be done exactly once in // the whole program. // TODO: the mechanism needs to be improved... - std::call_once(geometryFlag, [nlayers = hitsSeeds.nlayers()]() { mkfit::ConfigWrapper::setNTotalLayers(nlayers); }); - - // CMSSW event ID (64-bit unsigned) does not fit in int - // In addition, unique ID requires also lumi and run - // But does the event ID really matter within mkFit? - mkfit::Event ev(iEvent.id().event()); - - ev.setInputFromCMSSW(hitsSeeds.hits(), hitsSeeds.seeds()); + std::call_once(geometryFlag, [nlayers = mkFitGeom.layerNumberConverter().nLayers()]() { + mkfit::ConfigWrapper::setNTotalLayers(nlayers); + }); + + // seeds need to be mutable because of the possible cleaning + auto seeds_mutable = seeds.seeds(); + mkfit::TrackVec tracks; + + auto lambda = [&]() { + mkfit::run_OneIteration(mkFitGeom.trackerInfo(), + mkFitIterConfig, + eventOfHits.get(), + {pixelMaskPtr, &stripMask}, + streamCache(iID)->get(), + seeds_mutable, + tracks, + seedCleaning_, + not backwardFitInCMSSW_, + removeDuplicates_); + }; + + if (limitConcurrency_) { + tbb::task_arena arena(1); + arena.execute(std::move(lambda)); + } else { + tbb::this_task_arena::isolate(std::move(lambda)); + } - tbb::this_task_arena::isolate([&]() { buildFunction_(ev, streamCache(iID)->get()); }); + iEvent.emplace(putToken_, std::move(tracks), not backwardFitInCMSSW_); +} - iEvent.emplace(putToken_, std::move(ev.candidateTracks_), std::move(ev.fitTracks_)); +void MkFitProducer::stripClusterChargeCut(const std::vector& stripClusterCharge, std::vector& mask) const { + if (mask.size() != stripClusterCharge.size()) { + throw cms::Exception("LogicError") << "Mask size (" << mask.size() << ") inconsistent with number of hits (" + << stripClusterCharge.size() << ")"; + } + for (int i = 0, end = stripClusterCharge.size(); i < end; ++i) { + // mask == true means skip the cluster + mask[i] = mask[i] || (stripClusterCharge[i] <= minGoodStripCharge_); + } } DEFINE_FWK_MODULE(MkFitProducer); diff --git a/RecoTracker/MkFit/plugins/MkFitSeedConverter.cc b/RecoTracker/MkFit/plugins/MkFitSeedConverter.cc new file mode 100644 index 0000000000000..4cecdfdb2a71f --- /dev/null +++ b/RecoTracker/MkFit/plugins/MkFitSeedConverter.cc @@ -0,0 +1,146 @@ +#include "FWCore/Framework/interface/global/EDProducer.h" + +#include "FWCore/Framework/interface/Event.h" +#include "FWCore/Framework/interface/MakerMacros.h" +#include "FWCore/ParameterSet/interface/ParameterSet.h" + +#include "DataFormats/TrajectorySeed/interface/TrajectorySeed.h" +#include "DataFormats/TrackerRecHit2D/interface/BaseTrackerRecHit.h" +#include "DataFormats/TrackerRecHit2D/interface/OmniClusterRef.h" +#include "DataFormats/TrackerRecHit2D/interface/trackerHitRTTI.h" + +#include "DataFormats/TrackerCommon/interface/TrackerTopology.h" +#include "DataFormats/TrackerCommon/interface/TrackerDetSide.h" +#include "Geometry/Records/interface/TrackerTopologyRcd.h" + +#include "TrackingTools/Records/interface/TransientRecHitRecord.h" +#include "TrackingTools/TransientTrackingRecHit/interface/TransientTrackingRecHitBuilder.h" +#include "TrackingTools/TrajectoryState/interface/TrajectoryStateTransform.h" + +#include "MagneticField/Engine/interface/MagneticField.h" +#include "MagneticField/Records/interface/IdealMagneticFieldRecord.h" + +#include "RecoTracker/MkFit/interface/MkFitGeometry.h" +#include "RecoTracker/Record/interface/TrackerRecoGeometryRecord.h" + +#include "RecoTracker/MkFit/interface/MkFitSeedWrapper.h" + +// ROOT +#include "Math/SVector.h" +#include "Math/SMatrix.h" + +// mkFit includes +#include "LayerNumberConverter.h" +#include "Track.h" + +class MkFitSeedConverter : public edm::global::EDProducer<> { +public: + explicit MkFitSeedConverter(edm::ParameterSet const& iConfig); + ~MkFitSeedConverter() override = default; + + static void fillDescriptions(edm::ConfigurationDescriptions& descriptions); + +private: + void produce(edm::StreamID, edm::Event& iEvent, const edm::EventSetup& iSetup) const override; + + mkfit::TrackVec convertSeeds(const edm::View& seeds, + const TrackerTopology& ttopo, + const TransientTrackingRecHitBuilder& ttrhBuilder, + const MagneticField& mf, + const MkFitGeometry& mkFitGeom) const; + + using SVector3 = ROOT::Math::SVector; + using SMatrixSym33 = ROOT::Math::SMatrix>; + using SMatrixSym66 = ROOT::Math::SMatrix>; + + const edm::EDGetTokenT> seedToken_; + const edm::ESGetToken ttrhBuilderToken_; + const edm::ESGetToken ttopoToken_; + const edm::ESGetToken mkFitGeomToken_; + const edm::ESGetToken mfToken_; + const edm::EDPutTokenT putToken_; +}; + +MkFitSeedConverter::MkFitSeedConverter(edm::ParameterSet const& iConfig) + : seedToken_{consumes>(iConfig.getParameter("seeds"))}, + ttrhBuilderToken_{esConsumes( + iConfig.getParameter("ttrhBuilder"))}, + ttopoToken_{esConsumes()}, + mkFitGeomToken_{esConsumes()}, + mfToken_{esConsumes()}, + putToken_{produces()} {} + +void MkFitSeedConverter::fillDescriptions(edm::ConfigurationDescriptions& descriptions) { + edm::ParameterSetDescription desc; + + desc.add("seeds", edm::InputTag{"initialStepSeeds"}); + desc.add("ttrhBuilder", edm::ESInputTag{"", "WithTrackAngle"}); + + descriptions.addWithDefaultLabel(desc); +} + +void MkFitSeedConverter::produce(edm::StreamID iID, edm::Event& iEvent, const edm::EventSetup& iSetup) const { + iEvent.emplace(putToken_, + convertSeeds(iEvent.get(seedToken_), + iSetup.getData(ttopoToken_), + iSetup.getData(ttrhBuilderToken_), + iSetup.getData(mfToken_), + iSetup.getData(mkFitGeomToken_))); +} + +mkfit::TrackVec MkFitSeedConverter::convertSeeds(const edm::View& seeds, + const TrackerTopology& ttopo, + const TransientTrackingRecHitBuilder& ttrhBuilder, + const MagneticField& mf, + const MkFitGeometry& mkFitGeom) const { + mkfit::TrackVec ret; + ret.reserve(seeds.size()); + + auto isPlusSide = [&ttopo](const DetId& detid) { + return ttopo.side(detid) == static_cast(TrackerDetSide::PosEndcap); + }; + + int seed_index = 0; + for (const auto& seed : seeds) { + auto const& hitRange = seed.recHits(); + const auto lastRecHit = ttrhBuilder.build(&*(hitRange.end() - 1)); + const auto tsos = trajectoryStateTransform::transientState(seed.startingState(), lastRecHit->surface(), &mf); + const auto& stateGlobal = tsos.globalParameters(); + const auto& gpos = stateGlobal.position(); + const auto& gmom = stateGlobal.momentum(); + SVector3 pos(gpos.x(), gpos.y(), gpos.z()); + SVector3 mom(gmom.x(), gmom.y(), gmom.z()); + + const auto cartError = tsos.cartesianError(); // returns a temporary, so can't chain with the following line + const auto& cov = cartError.matrix(); + SMatrixSym66 err; + for (int i = 0; i < 6; ++i) { + for (int j = i; j < 6; ++j) { + err.At(i, j) = cov[i][j]; + } + } + + mkfit::TrackState state(tsos.charge(), pos, mom, err); + state.convertFromCartesianToCCS(); + ret.emplace_back(state, 0, seed_index, 0, nullptr); + LogTrace("MkFitSeedConverter") << "Inserted seed with index " << seed_index; + + // Add hits + for (auto const& recHit : hitRange) { + if (not trackerHitRTTI::isFromDet(recHit)) { + throw cms::Exception("Assert") << "Encountered a seed with a hit which is not trackerHitRTTI::isFromDet()"; + } + const auto& clusterRef = static_cast(recHit).firstClusterRef(); + const auto detId = recHit.geographicalId(); + const auto ilay = mkFitGeom.layerNumberConverter().convertLayerNumber( + detId.subdetId(), ttopo.layer(detId), false, ttopo.isStereo(detId), isPlusSide(detId)); + LogTrace("MkFitSeedConverter") << " addin hit detid " << detId.rawId() << " index " << clusterRef.index() + << " ilay " << ilay; + ret.back().addHitIdx(clusterRef.index(), ilay, 0); // per-hit chi2 is not known + } + ++seed_index; + } + return ret; +} + +DEFINE_FWK_MODULE(MkFitSeedConverter); diff --git a/RecoTracker/MkFit/plugins/MkFitSiPixelHitConverter.cc b/RecoTracker/MkFit/plugins/MkFitSiPixelHitConverter.cc new file mode 100644 index 0000000000000..39d14c66c2d1c --- /dev/null +++ b/RecoTracker/MkFit/plugins/MkFitSiPixelHitConverter.cc @@ -0,0 +1,91 @@ +#include "FWCore/Framework/interface/global/EDProducer.h" + +#include "FWCore/Framework/interface/Event.h" +#include "FWCore/Framework/interface/MakerMacros.h" +#include "FWCore/ParameterSet/interface/ParameterSet.h" + +#include "DataFormats/TrackerRecHit2D/interface/SiPixelRecHitCollection.h" + +#include "Geometry/Records/interface/TrackerTopologyRcd.h" + +#include "TrackingTools/Records/interface/TransientRecHitRecord.h" + +#include "RecoTracker/MkFit/interface/MkFitHitWrapper.h" +#include "RecoTracker/MkFit/interface/MkFitClusterIndexToHit.h" +#include "RecoTracker/MkFit/interface/MkFitGeometry.h" +#include "RecoTracker/Record/interface/TrackerRecoGeometryRecord.h" + +#include "convertHits.h" + +namespace { + struct ConvertHitTraits { + static constexpr bool applyCCC() { return false; } + static std::nullptr_t clusterCharge(const SiPixelRecHit& hit, DetId hitId) { return nullptr; } + static bool passCCC(std::nullptr_t) { return true; } + static void setDetails(mkfit::Hit& mhit, const SiPixelCluster& cluster, int shortId, std::nullptr_t) { + mhit.setupAsPixel(shortId, cluster.sizeX(), cluster.sizeY()); + } + }; +} // namespace + +class MkFitSiPixelHitConverter : public edm::global::EDProducer<> { +public: + explicit MkFitSiPixelHitConverter(edm::ParameterSet const& iConfig); + ~MkFitSiPixelHitConverter() override = default; + + static void fillDescriptions(edm::ConfigurationDescriptions& descriptions); + +private: + void produce(edm::StreamID, edm::Event& iEvent, const edm::EventSetup& iSetup) const override; + + const edm::EDGetTokenT pixelRecHitToken_; + const edm::ESGetToken ttrhBuilderToken_; + const edm::ESGetToken ttopoToken_; + const edm::ESGetToken mkFitGeomToken_; + const edm::EDPutTokenT wrapperPutToken_; + const edm::EDPutTokenT clusterIndexPutToken_; +}; + +MkFitSiPixelHitConverter::MkFitSiPixelHitConverter(edm::ParameterSet const& iConfig) + : pixelRecHitToken_{consumes(iConfig.getParameter("hits"))}, + ttrhBuilderToken_{esConsumes( + iConfig.getParameter("ttrhBuilder"))}, + ttopoToken_{esConsumes()}, + mkFitGeomToken_{esConsumes()}, + wrapperPutToken_{produces()}, + clusterIndexPutToken_{produces()} {} + +void MkFitSiPixelHitConverter::fillDescriptions(edm::ConfigurationDescriptions& descriptions) { + edm::ParameterSetDescription desc; + + desc.add("hits", edm::InputTag{"siPixelRecHits"}); + desc.add("ttrhBuilder", edm::ESInputTag{"", "WithTrackAngle"}); + + descriptions.addWithDefaultLabel(desc); +} + +void MkFitSiPixelHitConverter::produce(edm::StreamID iID, edm::Event& iEvent, const edm::EventSetup& iSetup) const { + const auto& ttrhBuilder = iSetup.getData(ttrhBuilderToken_); + const auto& ttopo = iSetup.getData(ttopoToken_); + const auto& mkFitGeom = iSetup.getData(mkFitGeomToken_); + + MkFitHitWrapper hitWrapper; + MkFitClusterIndexToHit clusterIndexToHit; + + std::vector dummy; + auto pixelClusterID = mkfit::convertHits(ConvertHitTraits{}, + iEvent.get(pixelRecHitToken_), + hitWrapper.hits(), + clusterIndexToHit.hits(), + dummy, + ttopo, + ttrhBuilder, + mkFitGeom); + + hitWrapper.setClustersID(pixelClusterID); + + iEvent.emplace(wrapperPutToken_, std::move(hitWrapper)); + iEvent.emplace(clusterIndexPutToken_, std::move(clusterIndexToHit)); +} + +DEFINE_FWK_MODULE(MkFitSiPixelHitConverter); diff --git a/RecoTracker/MkFit/plugins/MkFitSiStripHitConverter.cc b/RecoTracker/MkFit/plugins/MkFitSiStripHitConverter.cc new file mode 100644 index 0000000000000..d15dff6788f59 --- /dev/null +++ b/RecoTracker/MkFit/plugins/MkFitSiStripHitConverter.cc @@ -0,0 +1,125 @@ +#include "FWCore/Framework/interface/global/EDProducer.h" + +#include "FWCore/Framework/interface/Event.h" +#include "FWCore/Framework/interface/MakerMacros.h" +#include "FWCore/ParameterSet/interface/ParameterSet.h" + +#include "DataFormats/SiStripCluster/interface/SiStripClusterTools.h" +#include "DataFormats/TrackerRecHit2D/interface/SiStripRecHit2DCollection.h" + +#include "Geometry/Records/interface/TrackerTopologyRcd.h" + +#include "TrackingTools/Records/interface/TransientRecHitRecord.h" + +#include "RecoTracker/MkFit/interface/MkFitHitWrapper.h" +#include "RecoTracker/MkFit/interface/MkFitClusterIndexToHit.h" +#include "RecoTracker/MkFit/interface/MkFitGeometry.h" +#include "RecoTracker/Record/interface/TrackerRecoGeometryRecord.h" + +#include "convertHits.h" + +namespace { + class ConvertHitTraits { + public: + ConvertHitTraits(float minCharge) : minGoodStripCharge_(minCharge) {} + + static constexpr bool applyCCC() { return true; } + static float clusterCharge(const SiStripRecHit2D& hit, DetId hitId) { + return siStripClusterTools::chargePerCM(hitId, hit.firstClusterRef().stripCluster()); + } + bool passCCC(float charge) const { return charge > minGoodStripCharge_; } + static void setDetails(mkfit::Hit& mhit, const SiStripCluster& cluster, int shortId, float charge) { + mhit.setupAsStrip(shortId, charge, cluster.amplitudes().size()); + } + + private: + const float minGoodStripCharge_; + }; +} // namespace + +class MkFitSiStripHitConverter : public edm::global::EDProducer<> { +public: + explicit MkFitSiStripHitConverter(edm::ParameterSet const& iConfig); + ~MkFitSiStripHitConverter() override = default; + + static void fillDescriptions(edm::ConfigurationDescriptions& descriptions); + +private: + void produce(edm::StreamID, edm::Event& iEvent, const edm::EventSetup& iSetup) const override; + + const edm::EDGetTokenT stripRphiRecHitToken_; + const edm::EDGetTokenT stripStereoRecHitToken_; + const edm::ESGetToken ttrhBuilderToken_; + const edm::ESGetToken ttopoToken_; + const edm::ESGetToken mkFitGeomToken_; + const edm::EDPutTokenT wrapperPutToken_; + const edm::EDPutTokenT clusterIndexPutToken_; + const edm::EDPutTokenT> clusterChargePutToken_; + const ConvertHitTraits convertTraits_; +}; + +MkFitSiStripHitConverter::MkFitSiStripHitConverter(edm::ParameterSet const& iConfig) + : stripRphiRecHitToken_{consumes(iConfig.getParameter("rphiHits"))}, + stripStereoRecHitToken_{consumes(iConfig.getParameter("stereoHits"))}, + ttrhBuilderToken_{esConsumes( + iConfig.getParameter("ttrhBuilder"))}, + ttopoToken_{esConsumes()}, + mkFitGeomToken_{esConsumes()}, + wrapperPutToken_{produces()}, + clusterIndexPutToken_{produces()}, + clusterChargePutToken_{produces>()}, + convertTraits_{static_cast( + iConfig.getParameter("minGoodStripCharge").getParameter("value"))} {} + +void MkFitSiStripHitConverter::fillDescriptions(edm::ConfigurationDescriptions& descriptions) { + edm::ParameterSetDescription desc; + + desc.add("rphiHits", edm::InputTag{"siStripMatchedRecHits", "rphiRecHit"}); + desc.add("stereoHits", edm::InputTag{"siStripMatchedRecHits", "stereoRecHit"}); + desc.add("ttrhBuilder", edm::ESInputTag{"", "WithTrackAngle"}); + + edm::ParameterSetDescription descCCC; + descCCC.add("value"); + desc.add("minGoodStripCharge", descCCC); + + descriptions.add("mkFitSiStripHitConverterDefault", desc); +} + +void MkFitSiStripHitConverter::produce(edm::StreamID iID, edm::Event& iEvent, const edm::EventSetup& iSetup) const { + const auto& ttrhBuilder = iSetup.getData(ttrhBuilderToken_); + const auto& ttopo = iSetup.getData(ttopoToken_); + const auto& mkFitGeom = iSetup.getData(mkFitGeomToken_); + + MkFitHitWrapper hitWrapper; + MkFitClusterIndexToHit clusterIndexToHit; + std::vector clusterCharge; + + auto convert = [&](auto& hits) { + return mkfit::convertHits( + convertTraits_, hits, hitWrapper.hits(), clusterIndexToHit.hits(), clusterCharge, ttopo, ttrhBuilder, mkFitGeom); + }; + + edm::ProductID stripClusterID; + const auto& stripRphiHits = iEvent.get(stripRphiRecHitToken_); + const auto& stripStereoHits = iEvent.get(stripStereoRecHitToken_); + if (not stripRphiHits.empty()) { + stripClusterID = convert(stripRphiHits); + } + if (not stripStereoHits.empty()) { + auto stripStereoClusterID = convert(stripStereoHits); + if (stripRphiHits.empty()) { + stripClusterID = stripStereoClusterID; + } else if (stripClusterID != stripStereoClusterID) { + throw cms::Exception("LogicError") << "Encountered different cluster ProductIDs for strip RPhi hits (" + << stripClusterID << ") and stereo (" << stripStereoClusterID << ")"; + } + } + + hitWrapper.setClustersID(stripClusterID); + + iEvent.emplace(wrapperPutToken_, std::move(hitWrapper)); + iEvent.emplace(clusterIndexPutToken_, std::move(clusterIndexToHit)); + iEvent.emplace(clusterChargePutToken_, std::move(clusterCharge)); +} + +DEFINE_FWK_MODULE(MkFitSiStripHitConverter); diff --git a/RecoTracker/MkFit/plugins/convertHits.h b/RecoTracker/MkFit/plugins/convertHits.h new file mode 100644 index 0000000000000..f016b43b0fb0a --- /dev/null +++ b/RecoTracker/MkFit/plugins/convertHits.h @@ -0,0 +1,103 @@ +#ifndef RecoTracker_MkFit_plugins_convertHits_h +#define RecoTracker_MkFit_plugins_convertHits_h + +#include "DataFormats/Provenance/interface/ProductID.h" + +#include "FWCore/Utilities/interface/Likely.h" + +#include "DataFormats/TrackerCommon/interface/TrackerTopology.h" +#include "DataFormats/TrackerCommon/interface/TrackerDetSide.h" + +#include "TrackingTools/TransientTrackingRecHit/interface/TransientTrackingRecHitBuilder.h" + +#include "RecoTracker/MkFit/interface/MkFitGeometry.h" + +// ROOT +#include "Math/SVector.h" +#include "Math/SMatrix.h" + +// mkFit includes +#include "Hit.h" +#include "mkFit/HitStructures.h" + +namespace mkfit { + template + edm::ProductID convertHits(const Traits& traits, + const HitCollection& hits, + mkfit::HitVec& mkFitHits, + std::vector& clusterIndexToHit, + std::vector& clusterChargeVec, + const TrackerTopology& ttopo, + const TransientTrackingRecHitBuilder& ttrhBuilder, + const MkFitGeometry& mkFitGeom) { + if (hits.empty()) + return edm::ProductID{}; + + edm::ProductID clusterID; + { + const auto& lastClusterRef = hits.data().back().firstClusterRef(); + clusterID = lastClusterRef.id(); + if (lastClusterRef.index() >= mkFitHits.size()) { + auto const size = lastClusterRef.index(); + mkFitHits.resize(size); + clusterIndexToHit.resize(size, nullptr); + if constexpr (Traits::applyCCC()) { + clusterChargeVec.resize(size, -1.f); + } + } + } + + for (const auto& detset : hits) { + const DetId detid = detset.detId(); + const auto ilay = mkFitGeom.mkFitLayerNumber(detid); + + for (const auto& hit : detset) { + const auto charge = traits.clusterCharge(hit, detid); + if (!traits.passCCC(charge)) + continue; + + const auto& gpos = hit.globalPosition(); + SVector3 pos(gpos.x(), gpos.y(), gpos.z()); + const auto& gerr = hit.globalPositionError(); + SMatrixSym33 err; + err.At(0, 0) = gerr.cxx(); + err.At(1, 1) = gerr.cyy(); + err.At(2, 2) = gerr.czz(); + err.At(0, 1) = gerr.cyx(); + err.At(0, 2) = gerr.czx(); + err.At(1, 2) = gerr.czy(); + + auto clusterRef = hit.firstClusterRef(); + if UNLIKELY (clusterRef.id() != clusterID) { + throw cms::Exception("LogicError") + << "Input hit collection has Refs to many cluster collections. Last hit had Ref to product " << clusterID + << ", but encountered Ref to product " << clusterRef.id() << " on detid " << detid.rawId(); + } + const auto clusterIndex = clusterRef.index(); + LogTrace("MkFitHitConverter") << "Adding hit detid " << detid.rawId() << " subdet " << detid.subdetId() + << " layer " << ttopo.layer(detid) << " isStereo " << ttopo.isStereo(detid) + << " zplus " + << " index " << clusterIndex << " ilay " << ilay; + + if UNLIKELY (clusterIndex >= mkFitHits.size()) { + mkFitHits.resize(clusterIndex + 1); + clusterIndexToHit.resize(clusterIndex + 1, nullptr); + if constexpr (Traits::applyCCC()) { + clusterChargeVec.resize(clusterIndex + 1, -1.f); + } + } + mkFitHits[clusterIndex] = mkfit::Hit(pos, err); + clusterIndexToHit[clusterIndex] = &hit; + if constexpr (Traits::applyCCC()) { + clusterChargeVec[clusterIndex] = charge; + } + + const auto uniqueIdInLayer = mkFitGeom.uniqueIdInLayer(ilay, detid.rawId()); + traits.setDetails(mkFitHits[clusterIndex], *(hit.cluster()), uniqueIdInLayer, charge); + } + } + return clusterID; + } +} // namespace mkfit + +#endif diff --git a/RecoTracker/MkFit/plugins/createPhase1TrackerGeometry.cc b/RecoTracker/MkFit/plugins/createPhase1TrackerGeometry.cc new file mode 100644 index 0000000000000..ae8706005975e --- /dev/null +++ b/RecoTracker/MkFit/plugins/createPhase1TrackerGeometry.cc @@ -0,0 +1,241 @@ +//------------------- +// Phase1 tracker geometry +//------------------- + +#include "Config.h" +#include "Debug.h" +#include "TrackerInfo.h" +#include "mkFit/IterationConfig.h" +#include "mkFit/HitStructures.h" + +#include + +using namespace mkfit; + +namespace { +#include "createPhase1TrackerGeometryAutoGen.acc" + + void setupSteeringParamsIter0(IterationConfig &ic) { + ic.m_region_order[0] = TrackerInfo::Reg_Transition_Pos; + ic.m_region_order[1] = TrackerInfo::Reg_Transition_Neg; + ic.m_region_order[2] = TrackerInfo::Reg_Endcap_Pos; + ic.m_region_order[3] = TrackerInfo::Reg_Endcap_Neg; + ic.m_region_order[4] = TrackerInfo::Reg_Barrel; + + { + SteeringParams &sp = ic.m_steering_params[TrackerInfo::Reg_Endcap_Neg]; + sp.reserve_plan(3 + 3 + 6 + 18); // BPix + FPix- + TID- + TEC-; BPix4 is out of acceptance + sp.fill_plan(0, 1, false, true); // bk-fit only + sp.append_plan(2, true); // pick-up only + sp.append_plan(45, false); + sp.append_plan(46, false); + sp.append_plan(47, false); + sp.fill_plan(48, 53); // TID, 6 disks (3 mono + 3 stereo) + sp.fill_plan(54, 71); // TEC, 18 disks (3 mono + 3 stereo) + sp.finalize_plan(); + } + { + SteeringParams &sp = ic.m_steering_params[TrackerInfo::Reg_Transition_Neg]; + sp.reserve_plan(4 + 3 + 6 + 6 + 8 + 18); // BPix + FPix- + TIB + TID- + TOB + TEC- + sp.fill_plan(0, 1, false, true); // bk-fit only + sp.append_plan(2, true); + sp.append_plan(3, false); + sp.append_plan(45, false); + sp.append_plan(46, false); + sp.append_plan(47, false); + sp.fill_plan(4, 9); // TIB, 6 layers (4 mono + 2 stereo) + sp.fill_plan(48, 53); // TID, 6 disks (3 mono + 3 stereo) + sp.fill_plan(10, 17); // TOB, 8 layers (6 mono + 2 stereo) + sp.fill_plan(54, 71); // TEC, 18 disks (9 mono + 9 stereo) + sp.finalize_plan(); + } + { + SteeringParams &sp = ic.m_steering_params[TrackerInfo::Reg_Barrel]; + sp.reserve_plan(4 + 6 + 8); // BPix + TIB + TOB + sp.fill_plan(0, 1, false, true); // bk-fit only + sp.append_plan(2, true); // pickup-only + sp.append_plan(3, false); + sp.fill_plan(4, 9); // TIB, 6 layers (4 mono + 2 stereo) + sp.fill_plan(10, 17); // TOB, 8 layers (6 mono + 2 stereo) + sp.finalize_plan(); + } + { + SteeringParams &sp = ic.m_steering_params[TrackerInfo::Reg_Transition_Pos]; + sp.reserve_plan(4 + 3 + 6 + 6 + 8 + 18); // BPix + FPix+ + TIB + TID+ + TOB + TEC+ + sp.fill_plan(0, 1, false, true); // bk-fit only + sp.append_plan(2, true); // pickup-only + sp.append_plan(3, false); + sp.append_plan(18, false); + sp.append_plan(19, false); + sp.append_plan(20, false); + sp.fill_plan(4, 9); // TIB, 6 layers (4 mono + 2 stereo) + sp.fill_plan(21, 26); // TID, 6 disks (3 mono + 3 stereo) + sp.fill_plan(10, 17); // TOB, 8 layers (6 mono + 2 stereo) + sp.fill_plan(27, 44); // TEC, 18 disks (9 mono + 9 stereo) + sp.finalize_plan(); + } + { + SteeringParams &sp = ic.m_steering_params[TrackerInfo::Reg_Endcap_Pos]; + sp.reserve_plan(3 + 3 + 6 + 18); // BPix + FPix+ + TID+ + TEC+; BPix4 is out of acceptance + sp.fill_plan(0, 1, false, true); // bk-fit only + sp.append_plan(2, true); // pickup-only + sp.append_plan(18, false); + sp.append_plan(19, false); + sp.append_plan(20, false); + sp.fill_plan(21, 26); // TID, 6 disks (3 mono + 3 stereo) + sp.fill_plan(27, 44); // TEC, 18 disks (9 mono + 9 stereo) + sp.finalize_plan(); + } + } + + void partitionSeeds0(const TrackerInfo &trk_info, + const TrackVec &in_seeds, + const EventOfHits &eoh, + IterationSeedPartition &part) { + // Seeds are placed into eta regions and sorted on region + eta. + + const int size = in_seeds.size(); + + for (int i = 0; i < size; ++i) { + const Track &S = in_seeds[i]; + + const bool z_dir_pos = S.pz() > 0; + + HitOnTrack hot = S.getLastHitOnTrack(); + // MIMI ACHTUNG -- here we assume seed hits have already been remapped. + // This was true at that time :) + float eta = eoh[hot.layer].GetHit(hot.index).eta(); + // float eta = S.momEta(); + + // Region to be defined by propagation / intersection tests + TrackerInfo::EtaRegion reg; + + // Hardcoded for cms ... needs some lists of layers (hit/miss) for brl / ecp tests. + // MM: Check lambda functions/std::function + const LayerInfo &outer_brl = trk_info.outer_barrel_layer(); + + const LayerInfo &tib1 = trk_info.m_layers[4]; + const LayerInfo &tob1 = trk_info.m_layers[10]; + + const LayerInfo &tecp1 = trk_info.m_layers[27]; + const LayerInfo &tecn1 = trk_info.m_layers[54]; + + const LayerInfo &tec_first = z_dir_pos ? tecp1 : tecn1; + + // If a track hits outer barrel ... it is in the barrel (for central, "outgoing" tracks). + // This is also true for cyl-cow. + // Better check is: hits outer TIB, misses inner TEC (but is +-z dependant). + // XXXX Calculate z ... then check is inside or less that first EC z. + // There are a lot of tracks that go through that crack. + + // XXXX trying a fix for low pT tracks that are in barrel after half circle + float maxR = S.maxReachRadius(); + float z_at_maxr; + + bool can_reach_outer_brl = S.canReachRadius(outer_brl.m_rout); + float z_at_outer_brl; + bool misses_first_tec; + if (can_reach_outer_brl) { + z_at_outer_brl = S.zAtR(outer_brl.m_rout); + if (z_dir_pos) + misses_first_tec = z_at_outer_brl < tec_first.m_zmin; + else + misses_first_tec = z_at_outer_brl > tec_first.m_zmax; + } else { + z_at_maxr = S.zAtR(maxR); + if (z_dir_pos) + misses_first_tec = z_at_maxr < tec_first.m_zmin; + else + misses_first_tec = z_at_maxr > tec_first.m_zmax; + } + + if (/*can_reach_outer_brl &&*/ misses_first_tec) + // outer_brl.is_within_z_limits(S.zAtR(outer_brl.r_mean()))) + { + reg = TrackerInfo::Reg_Barrel; + } else { + // This should be a list of layers + // CMS, first tib, tob: 4, 10 + + if ((S.canReachRadius(tib1.m_rin) && tib1.is_within_z_limits(S.zAtR(tib1.m_rin))) || + (S.canReachRadius(tob1.m_rin) && tob1.is_within_z_limits(S.zAtR(tob1.m_rin)))) { + // transition region ... we are still hitting barrel layers + + reg = z_dir_pos ? TrackerInfo::Reg_Transition_Pos : TrackerInfo::Reg_Transition_Neg; + } else { + // endcap ... no barrel layers will be hit anymore. + + reg = z_dir_pos ? TrackerInfo::Reg_Endcap_Pos : TrackerInfo::Reg_Endcap_Neg; + } + } + + part.m_region[i] = reg; + part.m_sort_score[i] = 5.0f * (reg - 2) + eta; + } + } +} // namespace + +namespace mkfit { + void createPhase1TrackerGeometry(TrackerInfo &ti, IterationsInfo &ii, bool verbose) { + // TODO: these writes to global variables need to be removed + Config::nTotalLayers = 18 + 2 * 27; + + Config::useCMSGeom = true; + + Config::finding_requires_propagation_to_hit_pos = true; + Config::finding_inter_layer_pflags = PropagationFlags(PF_use_param_b_field | PF_apply_material); + Config::finding_intra_layer_pflags = PropagationFlags(PF_none); + Config::backward_fit_pflags = PropagationFlags(PF_use_param_b_field | PF_apply_material); + Config::forward_fit_pflags = PropagationFlags(PF_use_param_b_field | PF_apply_material); + Config::seed_fit_pflags = PropagationFlags(PF_none); + Config::pca_prop_pflags = PropagationFlags(PF_none); + + ti.set_eta_regions(0.9, 1.7, 2.45, false); + ti.create_layers(18, 27, 27); + + ii.resize(9); + ii[0].set_iteration_index_and_track_algorithm(0, (int)TrackBase::TrackAlgorithm::initialStep); + ii[0].set_num_regions_layers(5, 72); + + createPhase1TrackerGeometryAutoGen(ti, ii); + + setupSteeringParamsIter0(ii[0]); + ii[0].m_partition_seeds = partitionSeeds0; + + ii[1].Clone(ii[0]); + ii[1].set_iteration_index_and_track_algorithm(1, (int)TrackBase::TrackAlgorithm::highPtTripletStep); + + ii[2].Clone(ii[0]); + ii[2].set_iteration_index_and_track_algorithm(2, (int)TrackBase::TrackAlgorithm::lowPtQuadStep); + + ii[3].Clone(ii[0]); + ii[3].set_iteration_index_and_track_algorithm(3, (int)TrackBase::TrackAlgorithm::lowPtTripletStep); + + ii[4].Clone(ii[0]); + ii[4].set_iteration_index_and_track_algorithm(4, (int)TrackBase::TrackAlgorithm::detachedQuadStep); + + ii[5].Clone(ii[0]); + ii[5].set_iteration_index_and_track_algorithm(5, (int)TrackBase::TrackAlgorithm::detachedTripletStep); + + ii[6].Clone(ii[0]); + ii[6].set_iteration_index_and_track_algorithm(6, (int)TrackBase::TrackAlgorithm::mixedTripletStep); + + ii[7].Clone(ii[0]); + ii[7].set_iteration_index_and_track_algorithm(7, (int)TrackBase::TrackAlgorithm::pixelLessStep); + + ii[8].Clone(ii[0]); + ii[8].set_iteration_index_and_track_algorithm(8, (int)TrackBase::TrackAlgorithm::tobTecStep); + + //for the latter 2 iter investing in maxCand & stop condition (for time) + QF and Dupl. cleaning (for quality) + + // TODO: replace with MessageLogger + if (verbose) { + printf("==========================================================================================\n"); + printf("Phase1 tracker -- Create_TrackerInfo finished\n"); + printf("==========================================================================================\n"); + for (auto &i : ti.m_layers) + i.print_layer(); + printf("==========================================================================================\n"); + } + } +} // namespace mkfit diff --git a/RecoTracker/MkFit/plugins/createPhase1TrackerGeometry.h b/RecoTracker/MkFit/plugins/createPhase1TrackerGeometry.h new file mode 100644 index 0000000000000..0b90f711df105 --- /dev/null +++ b/RecoTracker/MkFit/plugins/createPhase1TrackerGeometry.h @@ -0,0 +1,11 @@ +#ifndef RecoTracker_MkFit_plugins_createPhase1TrackerGeometry_h +#define RecoTracker_MkFit_plugins_createPhase1TrackerGeometry_h + +namespace mkfit { + class TrackerInfo; + class IterationsInfo; + + void createPhase1TrackerGeometry(TrackerInfo &ti, IterationsInfo &ii, bool verbose); +} // namespace mkfit + +#endif diff --git a/RecoTracker/MkFit/plugins/createPhase1TrackerGeometryAutoGen.acc b/RecoTracker/MkFit/plugins/createPhase1TrackerGeometryAutoGen.acc new file mode 100644 index 0000000000000..b68a96428bdbe --- /dev/null +++ b/RecoTracker/MkFit/plugins/createPhase1TrackerGeometryAutoGen.acc @@ -0,0 +1,1142 @@ +void createPhase1TrackerGeometryAutoGen(TrackerInfo &ti, IterationsInfo &ii) { + // PIXB + + { + LayerInfo &obj = ti.m_layers[0]; + obj.m_layer_type = LayerInfo::Barrel; + obj.set_limits(2.720, 3.390, -26.700, 26.700); + obj.m_propagate_to = obj.r_mean(); + obj.set_next_layers(1, 18, 45); + obj.m_q_bin = 2.000; + obj.m_is_outer = false; + obj.m_is_stereo_lyr = false; + obj.m_is_pixb_lyr = true; + obj.m_is_seed_lyr = true; + } + + { + LayerInfo &obj = ti.m_layers[1]; + obj.m_layer_type = LayerInfo::Barrel; + obj.set_limits(6.560, 7.270, -26.700, 26.700); + obj.m_propagate_to = obj.r_mean(); + obj.set_next_layers(2, 18, 45); + obj.m_q_bin = 2.000; + obj.m_is_outer = false; + obj.m_is_stereo_lyr = false; + obj.m_is_pixb_lyr = true; + obj.m_is_seed_lyr = true; + } + + { + LayerInfo &obj = ti.m_layers[2]; + obj.m_layer_type = LayerInfo::Barrel; + obj.set_limits(10.690, 11.360, -26.700, 26.700); + obj.m_propagate_to = obj.r_mean(); + obj.set_next_layers(3, 18, 45); + obj.m_q_bin = 2.000; + obj.m_is_outer = false; + obj.m_is_stereo_lyr = false; + obj.m_is_pixb_lyr = true; + obj.m_is_seed_lyr = true; + } + + { + LayerInfo &obj = ti.m_layers[3]; + obj.m_layer_type = LayerInfo::Barrel; + obj.set_limits(15.800, 16.460, -26.700, 26.690); + obj.m_propagate_to = obj.r_mean(); + obj.set_next_layers(4, 21, 48); + obj.m_q_bin = 2.000; + obj.m_is_outer = false; + obj.m_is_stereo_lyr = false; + obj.m_is_pixb_lyr = true; + obj.m_is_seed_lyr = true; + } + + // TIB + + { + LayerInfo &obj = ti.m_layers[4]; + obj.m_layer_type = LayerInfo::Barrel; + obj.set_limits(23.450, 27.880, -66.670, 63.930); + obj.m_propagate_to = obj.r_mean(); + obj.set_next_layers(5, 21, 48); + obj.m_q_bin = 6.000; + obj.m_is_outer = false; + obj.m_is_stereo_lyr = false; + obj.m_is_tib_lyr = true; + } + + { + LayerInfo &obj = ti.m_layers[5]; + obj.m_layer_type = LayerInfo::Barrel; + obj.set_limits(23.450, 27.880, -66.670, 63.930); + obj.m_propagate_to = obj.r_mean(); + obj.set_next_layers(6, 21, 48); + obj.m_q_bin = 6.000; + obj.m_is_outer = false; + obj.m_is_stereo_lyr = true; + obj.m_is_tib_lyr = true; + } + + { + LayerInfo &obj = ti.m_layers[6]; + obj.m_layer_type = LayerInfo::Barrel; + obj.set_limits(31.830, 36.240, -65.890, 66.670); + obj.m_propagate_to = obj.r_mean(); + obj.set_next_layers(7, 21, 48); + obj.m_q_bin = 6.000; + obj.m_is_outer = false; + obj.m_is_stereo_lyr = false; + obj.m_is_tib_lyr = true; + } + + { + LayerInfo &obj = ti.m_layers[7]; + obj.m_layer_type = LayerInfo::Barrel; + obj.set_limits(31.830, 36.240, -65.890, 66.670); + obj.m_propagate_to = obj.r_mean(); + obj.set_next_layers(8, 21, 48); + obj.m_q_bin = 6.000; + obj.m_is_outer = false; + obj.m_is_stereo_lyr = true; + obj.m_is_tib_lyr = true; + } + + { + LayerInfo &obj = ti.m_layers[8]; + obj.m_layer_type = LayerInfo::Barrel; + obj.set_limits(39.880, 44.040, -66.400, 65.240); + obj.m_propagate_to = obj.r_mean(); + obj.set_next_layers(9, 21, 48); + obj.m_q_bin = 6.000; + obj.m_is_outer = false; + obj.m_is_stereo_lyr = false; + obj.m_is_tib_lyr = true; + } + + { + LayerInfo &obj = ti.m_layers[9]; + obj.m_layer_type = LayerInfo::Barrel; + obj.set_limits(47.810, 51.980, -66.400, 66.400); + obj.m_propagate_to = obj.r_mean(); + obj.set_next_layers(10, 27, 54); + obj.m_q_bin = 6.000; + obj.m_is_outer = false; + obj.m_is_stereo_lyr = false; + obj.m_is_tib_lyr = true; + } + + // TOB + + { + LayerInfo &obj = ti.m_layers[10]; + obj.m_layer_type = LayerInfo::Barrel; + obj.set_limits(58.410, 63.430, -108.710, 108.710); + obj.m_propagate_to = obj.r_mean(); + obj.set_next_layers(11, 27, 54); + obj.m_q_bin = 9.500; + obj.m_is_outer = false; + obj.m_is_stereo_lyr = false; + obj.m_is_tib_lyr = true; + } + + { + LayerInfo &obj = ti.m_layers[11]; + obj.m_layer_type = LayerInfo::Barrel; + obj.set_limits(58.410, 63.430, -108.710, 108.710); + obj.m_propagate_to = obj.r_mean(); + obj.set_next_layers(12, 27, 54); + obj.m_q_bin = 9.500; + obj.m_is_outer = false; + obj.m_is_stereo_lyr = true; + obj.m_is_tib_lyr = true; + } + + { + LayerInfo &obj = ti.m_layers[12]; + obj.m_layer_type = LayerInfo::Barrel; + obj.set_limits(66.810, 71.740, -108.700, 108.710); + obj.m_propagate_to = obj.r_mean(); + obj.set_next_layers(13, 27, 54); + obj.m_q_bin = 9.500; + obj.m_is_outer = false; + obj.m_is_stereo_lyr = false; + obj.m_is_tib_lyr = true; + } + + { + LayerInfo &obj = ti.m_layers[13]; + obj.m_layer_type = LayerInfo::Barrel; + obj.set_limits(66.810, 71.740, -108.700, 108.710); + obj.m_propagate_to = obj.r_mean(); + obj.set_next_layers(14, 27, 54); + obj.m_q_bin = 9.500; + obj.m_is_outer = false; + obj.m_is_stereo_lyr = true; + obj.m_is_tib_lyr = true; + } + + { + LayerInfo &obj = ti.m_layers[14]; + obj.m_layer_type = LayerInfo::Barrel; + obj.set_limits(76.040, 80.090, -108.300, 108.290); + obj.m_propagate_to = obj.r_mean(); + obj.set_next_layers(15, 27, 54); + obj.m_q_bin = 9.500; + obj.m_is_outer = false; + obj.m_is_stereo_lyr = false; + obj.m_is_tib_lyr = true; + } + + { + LayerInfo &obj = ti.m_layers[15]; + obj.m_layer_type = LayerInfo::Barrel; + obj.set_limits(84.840, 88.880, -108.290, 108.300); + obj.m_propagate_to = obj.r_mean(); + obj.set_next_layers(16, 27, 54); + obj.m_q_bin = 9.500; + obj.m_is_outer = false; + obj.m_is_stereo_lyr = false; + obj.m_is_tib_lyr = true; + } + + { + LayerInfo &obj = ti.m_layers[16]; + obj.m_layer_type = LayerInfo::Barrel; + obj.set_limits(94.540, 98.570, -108.290, 108.290); + obj.m_propagate_to = obj.r_mean(); + obj.set_next_layers(17, 27, 54); + obj.m_q_bin = 9.500; + obj.m_is_outer = false; + obj.m_is_stereo_lyr = false; + obj.m_is_tib_lyr = true; + } + + { + LayerInfo &obj = ti.m_layers[17]; + obj.m_layer_type = LayerInfo::Barrel; + obj.set_limits(106.040, 110.060, -108.290, 108.290); + obj.m_propagate_to = obj.r_mean(); + obj.set_next_layers(-1, -1, -1); + obj.m_q_bin = 9.500; + obj.m_is_outer = true; + obj.m_is_stereo_lyr = false; + obj.m_is_tib_lyr = true; + } + + // PIXE +/- + + { + LayerInfo &obj = ti.m_layers[18]; + obj.m_layer_type = LayerInfo::EndCapPos; + obj.set_limits(4.590, 16.090, 29.440, 35.210); + obj.m_propagate_to = obj.z_mean(); + obj.set_next_layers(4, 19, -1); + obj.m_q_bin = 1.000; + obj.m_is_outer = false; + obj.m_is_stereo_lyr = false; + obj.m_is_pixe_lyr = true; + obj.m_is_seed_lyr = true; + } + { + LayerInfo &obj = ti.m_layers[45]; + obj.m_layer_type = LayerInfo::EndCapNeg; + obj.set_limits(4.590, 16.090, -35.200, -29.440); + obj.m_propagate_to = obj.z_mean(); + obj.set_next_layers(4, -1, 46); + obj.m_q_bin = 1.000; + obj.m_is_outer = false; + obj.m_is_stereo_lyr = false; + obj.m_is_pixe_lyr = true; + obj.m_is_seed_lyr = true; + } + { + LayerInfo &obj = ti.m_layers[19]; + obj.m_layer_type = LayerInfo::EndCapPos; + obj.set_limits(4.590, 16.090, 36.940, 42.700); + obj.m_propagate_to = obj.z_mean(); + obj.set_next_layers(4, 20, -1); + obj.m_q_bin = 1.000; + obj.m_is_outer = false; + obj.m_is_stereo_lyr = false; + obj.m_is_pixe_lyr = true; + obj.m_is_seed_lyr = true; + } + { + LayerInfo &obj = ti.m_layers[46]; + obj.m_layer_type = LayerInfo::EndCapNeg; + obj.set_limits(4.590, 16.090, -42.700, -36.940); + obj.m_propagate_to = obj.z_mean(); + obj.set_next_layers(4, -1, 47); + obj.m_q_bin = 1.000; + obj.m_is_outer = false; + obj.m_is_stereo_lyr = false; + obj.m_is_pixe_lyr = true; + obj.m_is_seed_lyr = true; + } + { + LayerInfo &obj = ti.m_layers[20]; + obj.m_layer_type = LayerInfo::EndCapPos; + obj.set_limits(4.590, 16.090, 46.450, 52.200); + obj.m_propagate_to = obj.z_mean(); + obj.set_next_layers(4, 21, -1); + obj.m_q_bin = 1.000; + obj.m_is_outer = false; + obj.m_is_stereo_lyr = false; + obj.m_is_pixe_lyr = true; + obj.m_is_seed_lyr = true; + } + { + LayerInfo &obj = ti.m_layers[47]; + obj.m_layer_type = LayerInfo::EndCapNeg; + obj.set_limits(4.590, 16.090, -52.210, -46.450); + obj.m_propagate_to = obj.z_mean(); + obj.set_next_layers(4, -1, 48); + obj.m_q_bin = 1.000; + obj.m_is_outer = false; + obj.m_is_stereo_lyr = false; + obj.m_is_pixe_lyr = true; + obj.m_is_seed_lyr = true; + } + + // TID +/- + + { + LayerInfo &obj = ti.m_layers[21]; + obj.m_layer_type = LayerInfo::EndCapPos; + obj.set_limits(22.980, 50.440, 74.350, 84.050); + obj.m_propagate_to = obj.z_mean(); + obj.set_next_layers(10, 22, -1); + obj.m_q_bin = 5.500; + obj.m_is_outer = false; + obj.m_is_stereo_lyr = false; + obj.m_is_tid_lyr = true; + } + { + LayerInfo &obj = ti.m_layers[48]; + obj.m_layer_type = LayerInfo::EndCapNeg; + obj.set_limits(22.980, 50.440, -84.050, -74.350); + obj.m_propagate_to = obj.z_mean(); + obj.set_next_layers(10, -1, 49); + obj.m_q_bin = 5.500; + obj.m_is_outer = false; + obj.m_is_stereo_lyr = false; + obj.m_is_tid_lyr = true; + } + { + LayerInfo &obj = ti.m_layers[22]; + obj.m_layer_type = LayerInfo::EndCapPos; + obj.set_limits(22.800, 42.000, 74.350, 84.050); + obj.m_propagate_to = obj.z_mean(); + obj.set_next_layers(10, 23, -1); + obj.m_q_bin = 5.500; + obj.m_is_outer = false; + obj.m_is_stereo_lyr = true; + obj.m_is_tid_lyr = true; + } + { + LayerInfo &obj = ti.m_layers[49]; + obj.m_layer_type = LayerInfo::EndCapNeg; + obj.set_limits(22.800, 42.000, -84.050, -74.350); + obj.m_propagate_to = obj.z_mean(); + obj.set_next_layers(10, -1, 50); + obj.m_q_bin = 5.500; + obj.m_is_outer = false; + obj.m_is_stereo_lyr = true; + obj.m_is_tid_lyr = true; + } + { + LayerInfo &obj = ti.m_layers[23]; + obj.m_layer_type = LayerInfo::EndCapPos; + obj.set_limits(22.980, 50.440, 87.300, 97.000); + obj.m_propagate_to = obj.z_mean(); + obj.set_next_layers(10, 24, -1); + obj.m_q_bin = 5.500; + obj.m_is_outer = false; + obj.m_is_stereo_lyr = false; + obj.m_is_tid_lyr = true; + } + { + LayerInfo &obj = ti.m_layers[50]; + obj.m_layer_type = LayerInfo::EndCapNeg; + obj.set_limits(22.980, 50.440, -97.000, -87.300); + obj.m_propagate_to = obj.z_mean(); + obj.set_next_layers(10, -1, 51); + obj.m_q_bin = 5.500; + obj.m_is_outer = false; + obj.m_is_stereo_lyr = false; + obj.m_is_tid_lyr = true; + } + { + LayerInfo &obj = ti.m_layers[24]; + obj.m_layer_type = LayerInfo::EndCapPos; + obj.set_limits(22.800, 42.000, 87.300, 97.000); + obj.m_propagate_to = obj.z_mean(); + obj.set_next_layers(10, 25, -1); + obj.m_q_bin = 5.500; + obj.m_is_outer = false; + obj.m_is_stereo_lyr = true; + obj.m_is_tid_lyr = true; + } + { + LayerInfo &obj = ti.m_layers[51]; + obj.m_layer_type = LayerInfo::EndCapNeg; + obj.set_limits(22.800, 42.000, -97.000, -87.300); + obj.m_propagate_to = obj.z_mean(); + obj.set_next_layers(10, -1, 52); + obj.m_q_bin = 5.500; + obj.m_is_outer = false; + obj.m_is_stereo_lyr = true; + obj.m_is_tid_lyr = true; + } + { + LayerInfo &obj = ti.m_layers[25]; + obj.m_layer_type = LayerInfo::EndCapPos; + obj.set_limits(22.980, 50.440, 100.250, 109.950); + obj.m_propagate_to = obj.z_mean(); + obj.set_next_layers(10, 26, -1); + obj.m_q_bin = 5.500; + obj.m_is_outer = false; + obj.m_is_stereo_lyr = false; + obj.m_is_tid_lyr = true; + } + { + LayerInfo &obj = ti.m_layers[52]; + obj.m_layer_type = LayerInfo::EndCapNeg; + obj.set_limits(22.980, 50.440, -109.950, -100.250); + obj.m_propagate_to = obj.z_mean(); + obj.set_next_layers(10, -1, 53); + obj.m_q_bin = 5.500; + obj.m_is_outer = false; + obj.m_is_stereo_lyr = false; + obj.m_is_tid_lyr = true; + } + { + LayerInfo &obj = ti.m_layers[26]; + obj.m_layer_type = LayerInfo::EndCapPos; + obj.set_limits(22.800, 42.000, 100.250, 109.950); + obj.m_propagate_to = obj.z_mean(); + obj.set_next_layers(10, 27, -1); + obj.m_q_bin = 5.500; + obj.m_is_outer = false; + obj.m_is_stereo_lyr = true; + obj.m_is_tid_lyr = true; + } + { + LayerInfo &obj = ti.m_layers[53]; + obj.m_layer_type = LayerInfo::EndCapNeg; + obj.set_limits(22.800, 42.000, -109.950, -100.250); + obj.m_propagate_to = obj.z_mean(); + obj.set_next_layers(10, -1, 54); + obj.m_q_bin = 5.500; + obj.m_is_outer = false; + obj.m_is_stereo_lyr = true; + obj.m_is_tid_lyr = true; + } + + // TEC +/- + + { + LayerInfo &obj = ti.m_layers[27]; + obj.m_layer_type = LayerInfo::EndCapPos; + obj.set_limits(23.370, 109.390, 126.380, 137.390); + obj.m_propagate_to = obj.z_mean(); + obj.set_next_layers(-1, 28, -1); + obj.m_q_bin = 10.000; + obj.m_is_outer = false; + obj.m_is_stereo_lyr = false; + obj.m_is_tec_lyr = true; + } + { + LayerInfo &obj = ti.m_layers[54]; + obj.m_layer_type = LayerInfo::EndCapNeg; + obj.set_limits(23.360, 109.400, -137.390, -126.380); + obj.m_propagate_to = obj.z_mean(); + obj.set_next_layers(-1, -1, 55); + obj.m_q_bin = 10.000; + obj.m_is_outer = false; + obj.m_is_stereo_lyr = false; + obj.m_is_tec_lyr = true; + } + { + LayerInfo &obj = ti.m_layers[28]; + obj.m_layer_type = LayerInfo::EndCapPos; + obj.set_limits(23.300, 76.100, 126.380, 137.390); + obj.m_propagate_to = obj.z_mean(); + obj.set_next_layers(-1, 29, -1); + obj.m_q_bin = 10.000; + obj.m_is_outer = false; + obj.m_is_stereo_lyr = true; + obj.m_is_tec_lyr = true; + obj.set_r_hole_range(42.000, 59.900); + } + { + LayerInfo &obj = ti.m_layers[55]; + obj.m_layer_type = LayerInfo::EndCapNeg; + obj.set_limits(23.300, 76.100, -137.390, -126.380); + obj.m_propagate_to = obj.z_mean(); + obj.set_next_layers(-1, -1, 56); + obj.m_q_bin = 10.000; + obj.m_is_outer = false; + obj.m_is_stereo_lyr = true; + obj.m_is_tec_lyr = true; + obj.set_r_hole_range(42.000, 59.900); + } + { + LayerInfo &obj = ti.m_layers[29]; + obj.m_layer_type = LayerInfo::EndCapPos; + obj.set_limits(23.360, 109.410, 140.380, 151.390); + obj.m_propagate_to = obj.z_mean(); + obj.set_next_layers(-1, 30, -1); + obj.m_q_bin = 10.000; + obj.m_is_outer = false; + obj.m_is_stereo_lyr = false; + obj.m_is_tec_lyr = true; + } + { + LayerInfo &obj = ti.m_layers[56]; + obj.m_layer_type = LayerInfo::EndCapNeg; + obj.set_limits(23.360, 109.390, -151.420, -140.380); + obj.m_propagate_to = obj.z_mean(); + obj.set_next_layers(-1, -1, 57); + obj.m_q_bin = 10.000; + obj.m_is_outer = false; + obj.m_is_stereo_lyr = false; + obj.m_is_tec_lyr = true; + } + { + LayerInfo &obj = ti.m_layers[30]; + obj.m_layer_type = LayerInfo::EndCapPos; + obj.set_limits(23.300, 76.100, 140.380, 151.390); + obj.m_propagate_to = obj.z_mean(); + obj.set_next_layers(-1, 31, -1); + obj.m_q_bin = 10.000; + obj.m_is_outer = false; + obj.m_is_stereo_lyr = true; + obj.m_is_tec_lyr = true; + obj.set_r_hole_range(42.000, 59.900); + } + { + LayerInfo &obj = ti.m_layers[57]; + obj.m_layer_type = LayerInfo::EndCapNeg; + obj.set_limits(23.300, 76.100, -151.420, -140.380); + obj.m_propagate_to = obj.z_mean(); + obj.set_next_layers(-1, -1, 58); + obj.m_q_bin = 10.000; + obj.m_is_outer = false; + obj.m_is_stereo_lyr = true; + obj.m_is_tec_lyr = true; + obj.set_r_hole_range(42.000, 59.900); + } + { + LayerInfo &obj = ti.m_layers[31]; + obj.m_layer_type = LayerInfo::EndCapPos; + obj.set_limits(23.360, 109.390, 154.380, 165.390); + obj.m_propagate_to = obj.z_mean(); + obj.set_next_layers(-1, 32, -1); + obj.m_q_bin = 10.000; + obj.m_is_outer = false; + obj.m_is_stereo_lyr = false; + obj.m_is_tec_lyr = true; + } + { + LayerInfo &obj = ti.m_layers[58]; + obj.m_layer_type = LayerInfo::EndCapNeg; + obj.set_limits(23.360, 109.390, -165.390, -154.380); + obj.m_propagate_to = obj.z_mean(); + obj.set_next_layers(-1, -1, 59); + obj.m_q_bin = 10.000; + obj.m_is_outer = false; + obj.m_is_stereo_lyr = false; + obj.m_is_tec_lyr = true; + } + { + LayerInfo &obj = ti.m_layers[32]; + obj.m_layer_type = LayerInfo::EndCapPos; + obj.set_limits(23.300, 76.100, 154.380, 165.390); + obj.m_propagate_to = obj.z_mean(); + obj.set_next_layers(-1, 33, -1); + obj.m_q_bin = 10.000; + obj.m_is_outer = false; + obj.m_is_stereo_lyr = true; + obj.m_is_tec_lyr = true; + obj.set_r_hole_range(42.000, 59.900); + } + { + LayerInfo &obj = ti.m_layers[59]; + obj.m_layer_type = LayerInfo::EndCapNeg; + obj.set_limits(23.300, 76.100, -165.390, -154.380); + obj.m_propagate_to = obj.z_mean(); + obj.set_next_layers(-1, -1, 60); + obj.m_q_bin = 10.000; + obj.m_is_outer = false; + obj.m_is_stereo_lyr = true; + obj.m_is_tec_lyr = true; + obj.set_r_hole_range(42.000, 59.900); + } + { + LayerInfo &obj = ti.m_layers[33]; + obj.m_layer_type = LayerInfo::EndCapPos; + obj.set_limits(32.110, 109.400, 168.380, 179.380); + obj.m_propagate_to = obj.z_mean(); + obj.set_next_layers(-1, 34, -1); + obj.m_q_bin = 10.000; + obj.m_is_outer = false; + obj.m_is_stereo_lyr = false; + obj.m_is_tec_lyr = true; + } + { + LayerInfo &obj = ti.m_layers[60]; + obj.m_layer_type = LayerInfo::EndCapNeg; + obj.set_limits(32.110, 109.390, -179.390, -168.380); + obj.m_propagate_to = obj.z_mean(); + obj.set_next_layers(-1, -1, 61); + obj.m_q_bin = 10.000; + obj.m_is_outer = false; + obj.m_is_stereo_lyr = false; + obj.m_is_tec_lyr = true; + } + { + LayerInfo &obj = ti.m_layers[34]; + obj.m_layer_type = LayerInfo::EndCapPos; + obj.set_limits(31.600, 75.900, 168.380, 179.380); + obj.m_propagate_to = obj.z_mean(); + obj.set_next_layers(-1, 35, -1); + obj.m_q_bin = 10.000; + obj.m_is_outer = false; + obj.m_is_stereo_lyr = true; + obj.m_is_tec_lyr = true; + obj.set_r_hole_range(42.100, 59.700); + } + { + LayerInfo &obj = ti.m_layers[61]; + obj.m_layer_type = LayerInfo::EndCapNeg; + obj.set_limits(31.600, 75.900, -179.390, -168.380); + obj.m_propagate_to = obj.z_mean(); + obj.set_next_layers(-1, -1, 62); + obj.m_q_bin = 10.000; + obj.m_is_outer = false; + obj.m_is_stereo_lyr = true; + obj.m_is_tec_lyr = true; + obj.set_r_hole_range(42.100, 59.700); + } + { + LayerInfo &obj = ti.m_layers[35]; + obj.m_layer_type = LayerInfo::EndCapPos; + obj.set_limits(32.110, 109.390, 182.370, 193.390); + obj.m_propagate_to = obj.z_mean(); + obj.set_next_layers(-1, 36, -1); + obj.m_q_bin = 10.000; + obj.m_is_outer = false; + obj.m_is_stereo_lyr = false; + obj.m_is_tec_lyr = true; + } + { + LayerInfo &obj = ti.m_layers[62]; + obj.m_layer_type = LayerInfo::EndCapNeg; + obj.set_limits(32.110, 109.390, -193.380, -182.380); + obj.m_propagate_to = obj.z_mean(); + obj.set_next_layers(-1, -1, 63); + obj.m_q_bin = 10.000; + obj.m_is_outer = false; + obj.m_is_stereo_lyr = false; + obj.m_is_tec_lyr = true; + } + { + LayerInfo &obj = ti.m_layers[36]; + obj.m_layer_type = LayerInfo::EndCapPos; + obj.set_limits(31.600, 75.900, 182.370, 193.390); + obj.m_propagate_to = obj.z_mean(); + obj.set_next_layers(-1, 37, -1); + obj.m_q_bin = 10.000; + obj.m_is_outer = false; + obj.m_is_stereo_lyr = true; + obj.m_is_tec_lyr = true; + obj.set_r_hole_range(42.100, 59.700); + } + { + LayerInfo &obj = ti.m_layers[63]; + obj.m_layer_type = LayerInfo::EndCapNeg; + obj.set_limits(31.600, 75.900, -193.380, -182.380); + obj.m_propagate_to = obj.z_mean(); + obj.set_next_layers(-1, -1, 64); + obj.m_q_bin = 10.000; + obj.m_is_outer = false; + obj.m_is_stereo_lyr = true; + obj.m_is_tec_lyr = true; + obj.set_r_hole_range(42.100, 59.700); + } + { + LayerInfo &obj = ti.m_layers[37]; + obj.m_layer_type = LayerInfo::EndCapPos; + obj.set_limits(32.110, 109.390, 199.870, 210.880); + obj.m_propagate_to = obj.z_mean(); + obj.set_next_layers(-1, 38, -1); + obj.m_q_bin = 10.000; + obj.m_is_outer = false; + obj.m_is_stereo_lyr = false; + obj.m_is_tec_lyr = true; + } + { + LayerInfo &obj = ti.m_layers[64]; + obj.m_layer_type = LayerInfo::EndCapNeg; + obj.set_limits(32.110, 109.390, -210.880, -199.870); + obj.m_propagate_to = obj.z_mean(); + obj.set_next_layers(-1, -1, 65); + obj.m_q_bin = 10.000; + obj.m_is_outer = false; + obj.m_is_stereo_lyr = false; + obj.m_is_tec_lyr = true; + } + { + LayerInfo &obj = ti.m_layers[38]; + obj.m_layer_type = LayerInfo::EndCapPos; + obj.set_limits(31.600, 75.900, 199.870, 210.880); + obj.m_propagate_to = obj.z_mean(); + obj.set_next_layers(-1, 39, -1); + obj.m_q_bin = 10.000; + obj.m_is_outer = false; + obj.m_is_stereo_lyr = true; + obj.m_is_tec_lyr = true; + obj.set_r_hole_range(42.100, 59.700); + } + { + LayerInfo &obj = ti.m_layers[65]; + obj.m_layer_type = LayerInfo::EndCapNeg; + obj.set_limits(31.600, 75.900, -210.880, -199.870); + obj.m_propagate_to = obj.z_mean(); + obj.set_next_layers(-1, -1, 66); + obj.m_q_bin = 10.000; + obj.m_is_outer = false; + obj.m_is_stereo_lyr = true; + obj.m_is_tec_lyr = true; + obj.set_r_hole_range(42.100, 59.700); + } + { + LayerInfo &obj = ti.m_layers[39]; + obj.m_layer_type = LayerInfo::EndCapPos; + obj.set_limits(39.200, 109.390, 218.870, 229.860); + obj.m_propagate_to = obj.z_mean(); + obj.set_next_layers(-1, 40, -1); + obj.m_q_bin = 10.000; + obj.m_is_outer = false; + obj.m_is_stereo_lyr = false; + obj.m_is_tec_lyr = true; + } + { + LayerInfo &obj = ti.m_layers[66]; + obj.m_layer_type = LayerInfo::EndCapNeg; + obj.set_limits(39.200, 109.390, -229.860, -218.870); + obj.m_propagate_to = obj.z_mean(); + obj.set_next_layers(-1, -1, 67); + obj.m_q_bin = 10.000; + obj.m_is_outer = false; + obj.m_is_stereo_lyr = false; + obj.m_is_tec_lyr = true; + } + { + LayerInfo &obj = ti.m_layers[40]; + obj.m_layer_type = LayerInfo::EndCapPos; + obj.set_limits(59.900, 75.900, 218.870, 229.860); + obj.m_propagate_to = obj.z_mean(); + obj.set_next_layers(-1, 41, -1); + obj.m_q_bin = 10.000; + obj.m_is_outer = false; + obj.m_is_stereo_lyr = true; + obj.m_is_tec_lyr = true; + } + { + LayerInfo &obj = ti.m_layers[67]; + obj.m_layer_type = LayerInfo::EndCapNeg; + obj.set_limits(59.900, 75.900, -229.860, -218.870); + obj.m_propagate_to = obj.z_mean(); + obj.set_next_layers(-1, -1, 68); + obj.m_q_bin = 10.000; + obj.m_is_outer = false; + obj.m_is_stereo_lyr = true; + obj.m_is_tec_lyr = true; + } + { + LayerInfo &obj = ti.m_layers[41]; + obj.m_layer_type = LayerInfo::EndCapPos; + obj.set_limits(39.200, 109.400, 239.370, 250.360); + obj.m_propagate_to = obj.z_mean(); + obj.set_next_layers(-1, 42, -1); + obj.m_q_bin = 10.000; + obj.m_is_outer = false; + obj.m_is_stereo_lyr = false; + obj.m_is_tec_lyr = true; + } + { + LayerInfo &obj = ti.m_layers[68]; + obj.m_layer_type = LayerInfo::EndCapNeg; + obj.set_limits(39.200, 109.400, -250.360, -239.370); + obj.m_propagate_to = obj.z_mean(); + obj.set_next_layers(-1, -1, 69); + obj.m_q_bin = 10.000; + obj.m_is_outer = false; + obj.m_is_stereo_lyr = false; + obj.m_is_tec_lyr = true; + } + { + LayerInfo &obj = ti.m_layers[42]; + obj.m_layer_type = LayerInfo::EndCapPos; + obj.set_limits(59.900, 75.900, 239.370, 250.360); + obj.m_propagate_to = obj.z_mean(); + obj.set_next_layers(-1, 43, -1); + obj.m_q_bin = 10.000; + obj.m_is_outer = false; + obj.m_is_stereo_lyr = true; + obj.m_is_tec_lyr = true; + } + { + LayerInfo &obj = ti.m_layers[69]; + obj.m_layer_type = LayerInfo::EndCapNeg; + obj.set_limits(59.900, 75.900, -250.360, -239.370); + obj.m_propagate_to = obj.z_mean(); + obj.set_next_layers(-1, -1, 70); + obj.m_q_bin = 10.000; + obj.m_is_outer = false; + obj.m_is_stereo_lyr = true; + obj.m_is_tec_lyr = true; + } + { + LayerInfo &obj = ti.m_layers[43]; + obj.m_layer_type = LayerInfo::EndCapPos; + obj.set_limits(50.410, 109.400, 260.870, 271.870); + obj.m_propagate_to = obj.z_mean(); + obj.set_next_layers(-1, 44, -1); + obj.m_q_bin = 10.000; + obj.m_is_outer = false; + obj.m_is_stereo_lyr = false; + obj.m_is_tec_lyr = true; + } + { + LayerInfo &obj = ti.m_layers[70]; + obj.m_layer_type = LayerInfo::EndCapNeg; + obj.set_limits(50.410, 109.390, -271.880, -260.870); + obj.m_propagate_to = obj.z_mean(); + obj.set_next_layers(-1, -1, 71); + obj.m_q_bin = 10.000; + obj.m_is_outer = false; + obj.m_is_stereo_lyr = false; + obj.m_is_tec_lyr = true; + } + { + LayerInfo &obj = ti.m_layers[44]; + obj.m_layer_type = LayerInfo::EndCapPos; + obj.set_limits(59.900, 75.900, 260.870, 271.870); + obj.m_propagate_to = obj.z_mean(); + obj.set_next_layers(-1, -1, -1); + obj.m_q_bin = 10.000; + obj.m_is_outer = true; + obj.m_is_stereo_lyr = true; + obj.m_is_tec_lyr = true; + } + { + LayerInfo &obj = ti.m_layers[71]; + obj.m_layer_type = LayerInfo::EndCapNeg; + obj.set_limits(59.900, 75.900, -271.880, -260.870); + obj.m_propagate_to = obj.z_mean(); + obj.set_next_layers(-1, -1, -1); + obj.m_q_bin = 10.000; + obj.m_is_outer = true; + obj.m_is_stereo_lyr = true; + obj.m_is_tec_lyr = true; + } + + // Iteration 0 (default) + + { + IterationConfig &ic = ii[0]; + { + IterationLayerConfig &obj = ic.layer(0); + obj.set_selection_limits(0.010000, 0.050000, 1.000000, 2.000000); + } + { + IterationLayerConfig &obj = ic.layer(1); + obj.set_selection_limits(0.010000, 0.050000, 1.000000, 2.000000); + } + { + IterationLayerConfig &obj = ic.layer(2); + obj.set_selection_limits(0.010000, 0.050000, 1.000000, 2.000000); + } + { + IterationLayerConfig &obj = ic.layer(3); + obj.set_selection_limits(0.010000, 0.050000, 1.000000, 2.000000); + } + { + IterationLayerConfig &obj = ic.layer(4); + obj.set_selection_limits(0.010000, 0.015000, 6.000000, 12.000000); + } + { + IterationLayerConfig &obj = ic.layer(5); + obj.set_selection_limits(0.023000, 0.030000, 6.000000, 12.000000); + } + { + IterationLayerConfig &obj = ic.layer(6); + obj.set_selection_limits(0.010000, 0.015000, 6.000000, 12.000000); + } + { + IterationLayerConfig &obj = ic.layer(7); + obj.set_selection_limits(0.016000, 0.030000, 6.000000, 12.000000); + } + { + IterationLayerConfig &obj = ic.layer(8); + obj.set_selection_limits(0.010000, 0.015000, 6.000000, 12.000000); + } + { + IterationLayerConfig &obj = ic.layer(9); + obj.set_selection_limits(0.010000, 0.015000, 6.000000, 12.000000); + } + { + IterationLayerConfig &obj = ic.layer(10); + obj.set_selection_limits(0.010000, 0.015000, 9.500000, 19.000000); + } + { + IterationLayerConfig &obj = ic.layer(11); + obj.set_selection_limits(0.016000, 0.030000, 9.500000, 19.000000); + } + { + IterationLayerConfig &obj = ic.layer(12); + obj.set_selection_limits(0.010000, 0.015000, 9.500000, 19.000000); + } + { + IterationLayerConfig &obj = ic.layer(13); + obj.set_selection_limits(0.013000, 0.030000, 9.500000, 19.000000); + } + { + IterationLayerConfig &obj = ic.layer(14); + obj.set_selection_limits(0.010000, 0.015000, 9.500000, 19.000000); + } + { + IterationLayerConfig &obj = ic.layer(15); + obj.set_selection_limits(0.010000, 0.015000, 9.500000, 19.000000); + } + { + IterationLayerConfig &obj = ic.layer(16); + obj.set_selection_limits(0.010000, 0.015000, 9.500000, 19.000000); + } + { + IterationLayerConfig &obj = ic.layer(17); + obj.set_selection_limits(0.010000, 0.015000, 9.500000, 19.000000); + } + { + IterationLayerConfig &obj = ic.layer(18); + obj.set_selection_limits(0.010000, 0.015000, 0.800000, 1.600000); + } + { + IterationLayerConfig &obj = ic.layer(19); + obj.set_selection_limits(0.010000, 0.015000, 0.800000, 1.600000); + } + { + IterationLayerConfig &obj = ic.layer(20); + obj.set_selection_limits(0.010000, 0.015000, 0.800000, 1.600000); + } + { + IterationLayerConfig &obj = ic.layer(21); + obj.set_selection_limits(0.010000, 0.015000, 5.500000, 11.000000); + } + { + IterationLayerConfig &obj = ic.layer(22); + obj.set_selection_limits(0.010000, 0.030000, 5.500000, 11.000000); + } + { + IterationLayerConfig &obj = ic.layer(23); + obj.set_selection_limits(0.010000, 0.015000, 5.500000, 11.000000); + } + { + IterationLayerConfig &obj = ic.layer(24); + obj.set_selection_limits(0.010000, 0.030000, 5.500000, 11.000000); + } + { + IterationLayerConfig &obj = ic.layer(25); + obj.set_selection_limits(0.010000, 0.015000, 5.500000, 11.000000); + } + { + IterationLayerConfig &obj = ic.layer(26); + obj.set_selection_limits(0.010000, 0.030000, 5.500000, 11.000000); + } + { + IterationLayerConfig &obj = ic.layer(27); + obj.set_selection_limits(0.010000, 0.015000, 10.000000, 20.000000); + } + { + IterationLayerConfig &obj = ic.layer(28); + obj.set_selection_limits(0.010000, 0.030000, 10.000000, 20.000000); + } + { + IterationLayerConfig &obj = ic.layer(29); + obj.set_selection_limits(0.010000, 0.015000, 10.000000, 20.000000); + } + { + IterationLayerConfig &obj = ic.layer(30); + obj.set_selection_limits(0.010000, 0.030000, 10.000000, 20.000000); + } + { + IterationLayerConfig &obj = ic.layer(31); + obj.set_selection_limits(0.010000, 0.015000, 10.000000, 20.000000); + } + { + IterationLayerConfig &obj = ic.layer(32); + obj.set_selection_limits(0.010000, 0.030000, 10.000000, 20.000000); + } + { + IterationLayerConfig &obj = ic.layer(33); + obj.set_selection_limits(0.010000, 0.015000, 10.000000, 20.000000); + } + { + IterationLayerConfig &obj = ic.layer(34); + obj.set_selection_limits(0.010000, 0.030000, 10.000000, 20.000000); + } + { + IterationLayerConfig &obj = ic.layer(35); + obj.set_selection_limits(0.010000, 0.015000, 10.000000, 20.000000); + } + { + IterationLayerConfig &obj = ic.layer(36); + obj.set_selection_limits(0.010000, 0.030000, 10.000000, 20.000000); + } + { + IterationLayerConfig &obj = ic.layer(37); + obj.set_selection_limits(0.010000, 0.015000, 10.000000, 20.000000); + } + { + IterationLayerConfig &obj = ic.layer(38); + obj.set_selection_limits(0.010000, 0.030000, 10.000000, 20.000000); + } + { + IterationLayerConfig &obj = ic.layer(39); + obj.set_selection_limits(0.010000, 0.015000, 10.000000, 20.000000); + } + { + IterationLayerConfig &obj = ic.layer(40); + obj.set_selection_limits(0.010000, 0.030000, 10.000000, 20.000000); + } + { + IterationLayerConfig &obj = ic.layer(41); + obj.set_selection_limits(0.010000, 0.015000, 10.000000, 20.000000); + } + { + IterationLayerConfig &obj = ic.layer(42); + obj.set_selection_limits(0.010000, 0.030000, 10.000000, 20.000000); + } + { + IterationLayerConfig &obj = ic.layer(43); + obj.set_selection_limits(0.010000, 0.015000, 10.000000, 20.000000); + } + { + IterationLayerConfig &obj = ic.layer(44); + obj.set_selection_limits(0.010000, 0.030000, 10.000000, 20.000000); + } + { + IterationLayerConfig &obj = ic.layer(45); + obj.set_selection_limits(0.010000, 0.015000, 0.800000, 1.600000); + } + { + IterationLayerConfig &obj = ic.layer(46); + obj.set_selection_limits(0.010000, 0.015000, 0.800000, 1.600000); + } + { + IterationLayerConfig &obj = ic.layer(47); + obj.set_selection_limits(0.010000, 0.015000, 0.800000, 1.600000); + } + { + IterationLayerConfig &obj = ic.layer(48); + obj.set_selection_limits(0.010000, 0.015000, 5.500000, 11.000000); + } + { + IterationLayerConfig &obj = ic.layer(49); + obj.set_selection_limits(0.010000, 0.030000, 5.500000, 11.000000); + } + { + IterationLayerConfig &obj = ic.layer(50); + obj.set_selection_limits(0.010000, 0.015000, 5.500000, 11.000000); + } + { + IterationLayerConfig &obj = ic.layer(51); + obj.set_selection_limits(0.010000, 0.030000, 5.500000, 11.000000); + } + { + IterationLayerConfig &obj = ic.layer(52); + obj.set_selection_limits(0.010000, 0.015000, 5.500000, 11.000000); + } + { + IterationLayerConfig &obj = ic.layer(53); + obj.set_selection_limits(0.010000, 0.030000, 5.500000, 11.000000); + } + { + IterationLayerConfig &obj = ic.layer(54); + obj.set_selection_limits(0.010000, 0.015000, 10.000000, 20.000000); + } + { + IterationLayerConfig &obj = ic.layer(55); + obj.set_selection_limits(0.010000, 0.030000, 10.000000, 20.000000); + } + { + IterationLayerConfig &obj = ic.layer(56); + obj.set_selection_limits(0.010000, 0.015000, 10.000000, 20.000000); + } + { + IterationLayerConfig &obj = ic.layer(57); + obj.set_selection_limits(0.010000, 0.030000, 10.000000, 20.000000); + } + { + IterationLayerConfig &obj = ic.layer(58); + obj.set_selection_limits(0.010000, 0.015000, 10.000000, 20.000000); + } + { + IterationLayerConfig &obj = ic.layer(59); + obj.set_selection_limits(0.010000, 0.030000, 10.000000, 20.000000); + } + { + IterationLayerConfig &obj = ic.layer(60); + obj.set_selection_limits(0.010000, 0.015000, 10.000000, 20.000000); + } + { + IterationLayerConfig &obj = ic.layer(61); + obj.set_selection_limits(0.010000, 0.030000, 10.000000, 20.000000); + } + { + IterationLayerConfig &obj = ic.layer(62); + obj.set_selection_limits(0.010000, 0.015000, 10.000000, 20.000000); + } + { + IterationLayerConfig &obj = ic.layer(63); + obj.set_selection_limits(0.010000, 0.030000, 10.000000, 20.000000); + } + { + IterationLayerConfig &obj = ic.layer(64); + obj.set_selection_limits(0.010000, 0.015000, 10.000000, 20.000000); + } + { + IterationLayerConfig &obj = ic.layer(65); + obj.set_selection_limits(0.010000, 0.030000, 10.000000, 20.000000); + } + { + IterationLayerConfig &obj = ic.layer(66); + obj.set_selection_limits(0.010000, 0.015000, 10.000000, 20.000000); + } + { + IterationLayerConfig &obj = ic.layer(67); + obj.set_selection_limits(0.010000, 0.030000, 10.000000, 20.000000); + } + { + IterationLayerConfig &obj = ic.layer(68); + obj.set_selection_limits(0.010000, 0.015000, 10.000000, 20.000000); + } + { + IterationLayerConfig &obj = ic.layer(69); + obj.set_selection_limits(0.010000, 0.030000, 10.000000, 20.000000); + } + { + IterationLayerConfig &obj = ic.layer(70); + obj.set_selection_limits(0.010000, 0.015000, 10.000000, 20.000000); + } + { + IterationLayerConfig &obj = ic.layer(71); + obj.set_selection_limits(0.010000, 0.030000, 10.000000, 20.000000); + } + } +} diff --git a/RecoTracker/MkFit/python/customizeHLTIter0ToMkFit.py b/RecoTracker/MkFit/python/customizeHLTIter0ToMkFit.py new file mode 100644 index 0000000000000..01b59acd67816 --- /dev/null +++ b/RecoTracker/MkFit/python/customizeHLTIter0ToMkFit.py @@ -0,0 +1,79 @@ +import FWCore.ParameterSet.Config as cms + +import RecoTracker.MkFit.mkFitGeometryESProducer_cfi as mkFitGeometryESProducer_cfi +import RecoTracker.MkFit.mkFitSiPixelHitConverter_cfi as mkFitSiPixelHitConverter_cfi +import RecoTracker.MkFit.mkFitSiStripHitConverter_cfi as mkFitSiStripHitConverter_cfi +import RecoTracker.MkFit.mkFitEventOfHitsProducer_cfi as mkFitEventOfHitsProducer_cfi +import RecoTracker.MkFit.mkFitSeedConverter_cfi as mkFitSeedConverter_cfi +import RecoTracker.MkFit.mkFitIterationConfigESProducer_cfi as mkFitIterationConfigESProducer_cfi +import RecoTracker.MkFit.mkFitProducer_cfi as mkFitProducer_cfi +import RecoTracker.MkFit.mkFitOutputConverter_cfi as mkFitOutputConverter_cfi +import RecoLocalTracker.SiStripRecHitConverter.SiStripRecHitConverter_cfi as SiStripRecHitConverter_cfi + +def customizeHLTIter0ToMkFit(process): + # mkFit needs all clusters, so switch off the on-demand mode + process.hltSiStripRawToClustersFacility.onDemand = False + + process.hltSiStripRecHits = SiStripRecHitConverter_cfi.siStripMatchedRecHits.clone( + ClusterProducer = "hltSiStripRawToClustersFacility", + StripCPE = "hltESPStripCPEfromTrackAngle:hltESPStripCPEfromTrackAngle", + doMatching = False, + ) + + # Use fourth hit if one is available + process.hltIter0PFLowPixelSeedsFromPixelTracks.includeFourthHit = cms.bool(True) + + process.hltMkFitGeometryESProducer = mkFitGeometryESProducer_cfi.mkFitGeometryESProducer.clone() + + process.hltIter0PFlowCkfTrackCandidatesMkFitSiPixelHits = mkFitSiPixelHitConverter_cfi.mkFitSiPixelHitConverter.clone( + hits = "hltSiPixelRecHits", + ttrhBuilder = ":hltESPTTRHBWithTrackAngle", + ) + process.hltIter0PFlowCkfTrackCandidatesMkFitSiStripHits = mkFitSiStripHitConverter_cfi.mkFitSiStripHitConverter.clone( + rphiHits = "hltSiStripRecHits:rphiRecHit", + stereoHits = "hltSiStripRecHits:stereoRecHit", + ttrhBuilder = ":hltESPTTRHBWithTrackAngle", + minGoodStripCharge = dict(refToPSet_ = 'HLTSiStripClusterChargeCutLoose'), + ) + process.hltIter0PFlowCkfTrackCandidatesMkFitEventOfHits = mkFitEventOfHitsProducer_cfi.mkFitEventOfHitsProducer.clone( + pixelHits = "hltIter0PFlowCkfTrackCandidatesMkFitSiPixelHits", + stripHits = "hltIter0PFlowCkfTrackCandidatesMkFitSiStripHits", + ) + process.hltIter0PFlowCkfTrackCandidatesMkFitSeeds = mkFitSeedConverter_cfi.mkFitSeedConverter.clone( + seeds = "hltIter0PFLowPixelSeedsFromPixelTracks", + ttrhBuilder = ":hltESPTTRHBWithTrackAngle", + ) + process.hltIter0PFlowTrackCandidatesMkFitConfig = mkFitIterationConfigESProducer_cfi.mkFitIterationConfigESProducer.clone( + ComponentName = 'hltIter0PFlowTrackCandidatesMkFitConfig', + config = 'RecoTracker/MkFit/data/mkfit-phase1-initialStep.json', + ) + process.hltIter0PFlowCkfTrackCandidatesMkFit = mkFitProducer_cfi.mkFitProducer.clone( + pixelHits = "hltIter0PFlowCkfTrackCandidatesMkFitSiPixelHits", + stripHits = "hltIter0PFlowCkfTrackCandidatesMkFitSiStripHits", + eventOfHits = "hltIter0PFlowCkfTrackCandidatesMkFitEventOfHits", + seeds = "hltIter0PFlowCkfTrackCandidatesMkFitSeeds", + config = ('', 'hltIter0PFlowTrackCandidatesMkFitConfig'), + minGoodStripCharge = dict(refToPSet_ = 'HLTSiStripClusterChargeCutLoose'), + ) + process.hltIter0PFlowCkfTrackCandidates = mkFitOutputConverter_cfi.mkFitOutputConverter.clone( + seeds = "hltIter0PFLowPixelSeedsFromPixelTracks", + mkFitEventOfHits = "hltIter0PFlowCkfTrackCandidatesMkFitEventOfHits", + mkFitPixelHits = "hltIter0PFlowCkfTrackCandidatesMkFitSiPixelHits", + mkFitStripHits = "hltIter0PFlowCkfTrackCandidatesMkFitSiStripHits", + mkFitSeeds = "hltIter0PFlowCkfTrackCandidatesMkFitSeeds", + tracks = "hltIter0PFlowCkfTrackCandidatesMkFit", + ttrhBuilder = ":hltESPTTRHBWithTrackAngle", + propagatorAlong = ":PropagatorWithMaterialParabolicMf", + propagatorOpposite = ":PropagatorWithMaterialParabolicMfOpposite", + ) + + process.HLTDoLocalStripSequence += process.hltSiStripRecHits + process.HLTIterativeTrackingIteration0.replace(process.hltIter0PFlowCkfTrackCandidates, + process.hltIter0PFlowCkfTrackCandidatesMkFitSiPixelHits + + process.hltIter0PFlowCkfTrackCandidatesMkFitSiStripHits + + process.hltIter0PFlowCkfTrackCandidatesMkFitEventOfHits + + process.hltIter0PFlowCkfTrackCandidatesMkFitSeeds + + process.hltIter0PFlowCkfTrackCandidatesMkFit + + process.hltIter0PFlowCkfTrackCandidates) + + return process diff --git a/RecoTracker/MkFit/python/customizeInitialStepOnly.py b/RecoTracker/MkFit/python/customizeInitialStepOnly.py index 9c4e0ef7f4e3d..700de0f204fcc 100644 --- a/RecoTracker/MkFit/python/customizeInitialStepOnly.py +++ b/RecoTracker/MkFit/python/customizeInitialStepOnly.py @@ -12,11 +12,9 @@ def customizeInitialStepOnly(process): process.initialStepSeedLayers.BPix.HitProducer = 'siPixelRecHitsPreSplitting' process.initialStepHitQuadruplets.SeedComparitorPSet.clusterShapeCacheSrc = "siPixelClusterShapeCachePreSplitting" process.initialStepSeeds.SeedComparitorPSet.ClusterShapeCacheSrc = "siPixelClusterShapeCachePreSplitting" - if hasattr(process.initialStepTrackCandidates, "measurementTrackerEvent"): - # mkFit case - process.initialStepTrackCandidates.measurementTrackerEvent = 'MeasurementTrackerEventPreSplitting' - process.initialStepTrackCandidatesMkFitInput.pixelRecHits = "siPixelRecHitsPreSplitting" - else: + if hasattr(process, "initialStepTrackCandidatesMkFitHits"): + process.initialStepTrackCandidatesMkFitHits.pixelRecHits = "siPixelRecHitsPreSplitting" + if hasattr(process.initialStepTrackCandidates, "MeasurementTrackerEvent"): process.initialStepTrackCandidates.MeasurementTrackerEvent = 'MeasurementTrackerEventPreSplitting' process.initialStepTracks.MeasurementTrackerEvent = 'MeasurementTrackerEventPreSplitting' process.iterTrackingTask = cms.Task(process.trackerClusterCheck, @@ -57,10 +55,10 @@ def setInput(mtvs, labels): mod.dodEdxPlots = False mod.doResolutionPlotsForLabels = [] - setInput(["trackValidatorTrackingOnly", "trackValidatorAllTPEfficStandalone", - "trackValidatorTPPtLess09Standalone", "trackValidatorBHadronTrackingOnly"], + setInput(["trackValidatorTrackingOnly", "trackValidatorAllTPEfficTrackingOnly", + "trackValidatorTPPtLess09TrackingOnly", "trackValidatorBHadronTrackingOnly"], ["cutsRecoTracksInitialStep", "cutsRecoTracksPt09InitialStep"]) - setInput(["trackValidatorFromPVStandalone", "trackValidatorFromPVAllTPStandalone"], + setInput(["trackValidatorFromPVTrackingOnly", "trackValidatorFromPVAllTPTrackingOnly"], ["cutsRecoTracksFromPVInitialStep", "cutsRecoTracksFromPVPt09InitialStep"]) setInput(["trackValidatorSeedingTrackingOnly"], ["seedTracksinitialStepSeeds"]) setInput(["trackValidatorBuilding"], ["initialStepTracks"]) diff --git a/RecoTracker/MkFit/python/mkFitInputConverter_cfi.py b/RecoTracker/MkFit/python/mkFitHitConverter_cfi.py similarity index 55% rename from RecoTracker/MkFit/python/mkFitInputConverter_cfi.py rename to RecoTracker/MkFit/python/mkFitHitConverter_cfi.py index 3ee427ef0e44e..cc8bb711146a8 100644 --- a/RecoTracker/MkFit/python/mkFitInputConverter_cfi.py +++ b/RecoTracker/MkFit/python/mkFitHitConverter_cfi.py @@ -1,9 +1,9 @@ import FWCore.ParameterSet.Config as cms -from RecoTracker.MkFit.mkFitInputConverterDefault_cfi import mkFitInputConverterDefault as _mkFitInputConverterDefault +from RecoTracker.MkFit.mkFitHitConverterDefault_cfi import mkFitHitConverterDefault as _mkFitHitConverterDefault from RecoLocalTracker.SiStripClusterizer.SiStripClusterChargeCut_cfi import * -mkFitInputConverter = _mkFitInputConverterDefault.clone( +mkFitHitConverter = _mkFitHitConverterDefault.clone( minGoodStripCharge = cms.PSet( refToPSet_ = cms.string('SiStripClusterChargeCutLoose')) ) diff --git a/RecoTracker/MkFit/python/mkFitProducer_cfi.py b/RecoTracker/MkFit/python/mkFitProducer_cfi.py new file mode 100644 index 0000000000000..4badc5eceb6a9 --- /dev/null +++ b/RecoTracker/MkFit/python/mkFitProducer_cfi.py @@ -0,0 +1,9 @@ +import FWCore.ParameterSet.Config as cms + +from RecoTracker.MkFit.mkFitProducerDefault_cfi import mkFitProducerDefault as _mkFitProducerDefault +from RecoLocalTracker.SiStripClusterizer.SiStripClusterChargeCut_cfi import * + +mkFitProducer = _mkFitProducerDefault.clone( + minGoodStripCharge = cms.PSet( + refToPSet_ = cms.string('SiStripClusterChargeCutLoose')) +) diff --git a/RecoTracker/MkFit/python/mkFitSiStripHitConverter_cfi.py b/RecoTracker/MkFit/python/mkFitSiStripHitConverter_cfi.py new file mode 100644 index 0000000000000..5f189b4b3fcb5 --- /dev/null +++ b/RecoTracker/MkFit/python/mkFitSiStripHitConverter_cfi.py @@ -0,0 +1,9 @@ +import FWCore.ParameterSet.Config as cms + +from RecoTracker.MkFit.mkFitSiStripHitConverterDefault_cfi import mkFitSiStripHitConverterDefault as _mkFitSiStripHitConverterDefault +from RecoLocalTracker.SiStripClusterizer.SiStripClusterChargeCut_cfi import * + +mkFitSiStripHitConverter = _mkFitSiStripHitConverterDefault.clone( + minGoodStripCharge = cms.PSet( + refToPSet_ = cms.string('SiStripClusterChargeCutLoose')) +) diff --git a/RecoTracker/MkFit/src/ES_MkFitGeometry.cc b/RecoTracker/MkFit/src/ES_MkFitGeometry.cc new file mode 100644 index 0000000000000..233f6e3827fda --- /dev/null +++ b/RecoTracker/MkFit/src/ES_MkFitGeometry.cc @@ -0,0 +1,3 @@ +#include "RecoTracker/MkFit/interface/MkFitGeometry.h" +#include "FWCore/Utilities/interface/typelookup.h" +TYPELOOKUP_DATA_REG(MkFitGeometry); diff --git a/RecoTracker/MkFit/src/ES_MkFitIterationConfig.cc b/RecoTracker/MkFit/src/ES_MkFitIterationConfig.cc new file mode 100644 index 0000000000000..9ba5e5559c1ad --- /dev/null +++ b/RecoTracker/MkFit/src/ES_MkFitIterationConfig.cc @@ -0,0 +1,3 @@ +#include "mkFit/IterationConfig.h" +#include "FWCore/Utilities/interface/typelookup.h" +TYPELOOKUP_DATA_REG(mkfit::IterationConfig); diff --git a/RecoTracker/MkFit/src/MkFitEventOfHits.cc b/RecoTracker/MkFit/src/MkFitEventOfHits.cc new file mode 100644 index 0000000000000..72b6c98345dae --- /dev/null +++ b/RecoTracker/MkFit/src/MkFitEventOfHits.cc @@ -0,0 +1,11 @@ +#include "RecoTracker/MkFit/interface/MkFitEventOfHits.h" + +// mkFit includes +#include "mkFit/HitStructures.h" + +MkFitEventOfHits::MkFitEventOfHits() = default; +MkFitEventOfHits::MkFitEventOfHits(std::unique_ptr eoh) : eventOfHits_(std::move(eoh)) {} +MkFitEventOfHits::~MkFitEventOfHits() = default; + +MkFitEventOfHits::MkFitEventOfHits(MkFitEventOfHits&&) = default; +MkFitEventOfHits& MkFitEventOfHits::operator=(MkFitEventOfHits&&) = default; diff --git a/RecoTracker/MkFit/src/MkFitGeometry.cc b/RecoTracker/MkFit/src/MkFitGeometry.cc new file mode 100644 index 0000000000000..fe004dea6e1dd --- /dev/null +++ b/RecoTracker/MkFit/src/MkFitGeometry.cc @@ -0,0 +1,82 @@ +#include "DataFormats/SiStripDetId/interface/StripSubdetector.h" +#include "DataFormats/TrackerCommon/interface/TrackerTopology.h" +#include "DataFormats/TrackerCommon/interface/TrackerDetSide.h" +#include "Geometry/TrackerGeometryBuilder/interface/TrackerGeometry.h" +#include "RecoTracker/TkDetLayers/interface/GeometricSearchTracker.h" +#include "RecoTracker/MkFit/interface/MkFitGeometry.h" + +#include "LayerNumberConverter.h" +#include "TrackerInfo.h" +#include "mkFit/IterationConfig.h" + +namespace { + bool isPlusSide(const TrackerTopology& ttopo, DetId detid) { + return ttopo.side(detid) == static_cast(TrackerDetSide::PosEndcap); + } +} // namespace + +MkFitGeometry::MkFitGeometry(const TrackerGeometry& geom, + const GeometricSearchTracker& tracker, + const TrackerTopology& ttopo, + std::unique_ptr trackerInfo, + std::unique_ptr iterationsInfo) + : ttopo_(&ttopo), + lnc_{std::make_unique(mkfit::TkLayout::phase1)}, + trackerInfo_(std::move(trackerInfo)), + iterationsInfo_(std::move(iterationsInfo)) { + if (geom.numberOfLayers(PixelSubdetector::PixelBarrel) != 4 || + geom.numberOfLayers(PixelSubdetector::PixelEndcap) != 3) { + throw cms::Exception("Assert") << "For now this code works only with phase1 tracker, you have something else"; + } + + // Create DetLayer structure + dets_.resize(lnc_->nLayers(), nullptr); + auto setDet = [this](const int subdet, const int layer, const int isStereo, const DetId& detId, const DetLayer* lay) { + const int index = lnc_->convertLayerNumber(subdet, layer, false, isStereo, isPlusSide(*ttopo_, detId)); + if (index < 0 or static_cast(index) >= dets_.size()) { + throw cms::Exception("LogicError") << "Invalid mkFit layer index " << index << " for DetId " << detId.rawId() + << " subdet " << subdet << " layer " << layer << " isStereo " << isStereo; + } + dets_[index] = lay; + }; + constexpr int monoLayer = 0; + constexpr int stereoLayer = 1; + for (const DetLayer* lay : tracker.allLayers()) { + const auto& comp = lay->basicComponents(); + if (UNLIKELY(comp.empty())) { + throw cms::Exception("LogicError") << "Got a tracker layer (subdet " << lay->subDetector() + << ") with empty basicComponents."; + } + // First component is enough for layer and side information + const auto& detId = comp.front()->geographicalId(); + const auto subdet = detId.subdetId(); + const auto layer = ttopo.layer(detId); + + // TODO: mono/stereo structure is still hardcoded for phase0/1 strip tracker + setDet(subdet, layer, monoLayer, detId, lay); + if (((subdet == StripSubdetector::TIB or subdet == StripSubdetector::TOB) and (layer == 1 or layer == 2)) or + subdet == StripSubdetector::TID or subdet == StripSubdetector::TEC) { + setDet(subdet, layer, stereoLayer, detId, lay); + } + } + + // Create "short id" aka "unique id within layer" + detIdToShortId_.resize(lnc_->nLayers()); + for (const auto& detId : geom.detIds()) { + const auto ilay = mkFitLayerNumber(detId); + auto& map = detIdToShortId_[ilay]; + const unsigned int ind = map.size(); + // Make sure the short id fits in the 12 bits... + assert(ind < (int)1 << 11); + map[detId.rawId()] = ind; + } +} + +// Explicit out-of-line because of the mkfit::LayerNumberConverter is +// only forward declared in the header +MkFitGeometry::~MkFitGeometry() {} + +int MkFitGeometry::mkFitLayerNumber(DetId detId) const { + return lnc_->convertLayerNumber( + detId.subdetId(), ttopo_->layer(detId), false, ttopo_->isStereo(detId), isPlusSide(*ttopo_, detId)); +} diff --git a/RecoTracker/MkFit/src/MkFitHitIndexMap.cc b/RecoTracker/MkFit/src/MkFitHitIndexMap.cc deleted file mode 100644 index 89260eadbe565..0000000000000 --- a/RecoTracker/MkFit/src/MkFitHitIndexMap.cc +++ /dev/null @@ -1,68 +0,0 @@ -#include "RecoTracker/MkFit/interface/MkFitHitIndexMap.h" - -#include "FWCore/Utilities/interface/Exception.h" - -#include - -namespace { - template - auto resizeByClusterIndexImpl(T& cmsswToMkFit, edm::ProductID id, size_t clusterIndex) -> typename T::iterator { - auto found = - std::find_if(cmsswToMkFit.begin(), cmsswToMkFit.end(), [&](const auto& item) { return item.productID == id; }); - if (found == cmsswToMkFit.end()) { - found = cmsswToMkFit.emplace(cmsswToMkFit.end(), id); - } - if (found->mkFitHits.size() <= clusterIndex) { - found->mkFitHits.resize(clusterIndex + 1); - } - return found; - } -} // namespace - -void MkFitHitIndexMap::resizeByClusterIndex(edm::ProductID id, size_t clusterIndex) { - resizeByClusterIndexImpl(cmsswToMkFit_, id, clusterIndex); -} - -void MkFitHitIndexMap::increaseLayerSize(int layer, size_t additionalSize) { - if (layer >= static_cast(mkFitToCMSSW_.size())) { - mkFitToCMSSW_.resize(layer + 1); - } - mkFitToCMSSW_[layer].resize(mkFitToCMSSW_[layer].size() + additionalSize); -} - -void MkFitHitIndexMap::insert(edm::ProductID id, size_t clusterIndex, MkFitHit hit, const TrackingRecHit* hitPtr) { - // mapping CMSSW->mkfit - auto found = resizeByClusterIndexImpl(cmsswToMkFit_, id, clusterIndex); - found->mkFitHits[clusterIndex] = hit; - - // mapping mkfit->CMSSW - // when client calls increaseLayerSize() the two checks below are - // redundant, but better to keep them - if (hit.layer() >= static_cast(mkFitToCMSSW_.size())) { - mkFitToCMSSW_.resize(hit.layer() + 1); - } - auto& layer = mkFitToCMSSW_[hit.layer()]; - if (hit.index() >= static_cast(layer.size())) { - layer.resize(hit.index() + 1); - } - layer[hit.index()] = CMSSWHit(hitPtr, clusterIndex); -} - -const MkFitHitIndexMap::MkFitHit& MkFitHitIndexMap::mkFitHit(edm::ProductID id, size_t clusterIndex) const { - auto found = - std::find_if(cmsswToMkFit_.begin(), cmsswToMkFit_.end(), [&](const auto& item) { return item.productID == id; }); - if (found == cmsswToMkFit_.end()) { - auto exp = cms::Exception("Assert"); - exp << "Encountered a seed with a hit having productID " << id - << " which is not any of the input hit collections: "; - for (const auto& elem : cmsswToMkFit_) { - exp << elem.productID << " "; - } - throw exp; - } - const MkFitHit& ret = found->mkFitHits.at(clusterIndex); - if (ret.index() < 0) { - throw cms::Exception("Assert") << "No hit index for cluster " << clusterIndex << " of collection " << id; - } - return ret; -} diff --git a/RecoTracker/MkFit/src/MkFitHitWrapper.cc b/RecoTracker/MkFit/src/MkFitHitWrapper.cc new file mode 100644 index 0000000000000..ebef4972f777b --- /dev/null +++ b/RecoTracker/MkFit/src/MkFitHitWrapper.cc @@ -0,0 +1,12 @@ +#include "FWCore/Utilities/interface/Exception.h" +#include "RecoTracker/MkFit/interface/MkFitHitWrapper.h" + +// mkFit includes +#include "Hit.h" +#include "mkFit/HitStructures.h" + +MkFitHitWrapper::MkFitHitWrapper() = default; +MkFitHitWrapper::~MkFitHitWrapper() = default; + +MkFitHitWrapper::MkFitHitWrapper(MkFitHitWrapper&&) = default; +MkFitHitWrapper& MkFitHitWrapper::operator=(MkFitHitWrapper&&) = default; diff --git a/RecoTracker/MkFit/src/MkFitInputWrapper.cc b/RecoTracker/MkFit/src/MkFitInputWrapper.cc deleted file mode 100644 index 06f6c6d59d74f..0000000000000 --- a/RecoTracker/MkFit/src/MkFitInputWrapper.cc +++ /dev/null @@ -1,24 +0,0 @@ -#include "RecoTracker/MkFit/interface/MkFitInputWrapper.h" - -// mkFit includes -#include "Hit.h" -#include "LayerNumberConverter.h" -#include "Track.h" - -MkFitInputWrapper::MkFitInputWrapper() = default; - -MkFitInputWrapper::MkFitInputWrapper(MkFitHitIndexMap hitIndexMap, - std::vector hits, - mkfit::TrackVec seeds, - mkfit::LayerNumberConverter const& lnc) - : hitIndexMap_{std::move(hitIndexMap)}, - hits_{std::move(hits)}, - seeds_{std::make_unique(std::move(seeds))}, - lnc_{std::make_unique(lnc)} {} - -MkFitInputWrapper::~MkFitInputWrapper() = default; - -MkFitInputWrapper::MkFitInputWrapper(MkFitInputWrapper&&) = default; -MkFitInputWrapper& MkFitInputWrapper::operator=(MkFitInputWrapper&&) = default; - -unsigned int MkFitInputWrapper::nlayers() const { return lnc_->nLayers(); } diff --git a/RecoTracker/MkFit/src/MkFitOutputWrapper.cc b/RecoTracker/MkFit/src/MkFitOutputWrapper.cc index 0c670e22a7660..7ad4b457c10dc 100644 --- a/RecoTracker/MkFit/src/MkFitOutputWrapper.cc +++ b/RecoTracker/MkFit/src/MkFitOutputWrapper.cc @@ -5,8 +5,8 @@ MkFitOutputWrapper::MkFitOutputWrapper() = default; -MkFitOutputWrapper::MkFitOutputWrapper(mkfit::TrackVec&& candidateTracks, mkfit::TrackVec&& fitTracks) - : candidateTracks_{std::move(candidateTracks)}, fitTracks_{std::move(fitTracks)} {} +MkFitOutputWrapper::MkFitOutputWrapper(mkfit::TrackVec tracks, bool propagatedToFirstLayer) + : tracks_{std::move(tracks)}, propagatedToFirstLayer_{propagatedToFirstLayer} {} MkFitOutputWrapper::~MkFitOutputWrapper() = default; diff --git a/RecoTracker/MkFit/src/MkFitSeedWrapper.cc b/RecoTracker/MkFit/src/MkFitSeedWrapper.cc new file mode 100644 index 0000000000000..22964e21df56d --- /dev/null +++ b/RecoTracker/MkFit/src/MkFitSeedWrapper.cc @@ -0,0 +1,14 @@ +#include "RecoTracker/MkFit/interface/MkFitSeedWrapper.h" + +// mkFit includes +#include "Track.h" + +MkFitSeedWrapper::MkFitSeedWrapper() = default; + +MkFitSeedWrapper::MkFitSeedWrapper(mkfit::TrackVec seeds) + : seeds_{std::make_unique(std::move(seeds))} {} + +MkFitSeedWrapper::~MkFitSeedWrapper() = default; + +MkFitSeedWrapper::MkFitSeedWrapper(MkFitSeedWrapper&&) = default; +MkFitSeedWrapper& MkFitSeedWrapper::operator=(MkFitSeedWrapper&&) = default; diff --git a/RecoTracker/MkFit/src/classes.h b/RecoTracker/MkFit/src/classes.h index c092179fb499f..0aa6883c3c69f 100644 --- a/RecoTracker/MkFit/src/classes.h +++ b/RecoTracker/MkFit/src/classes.h @@ -2,7 +2,10 @@ #define RecoTracker_MkFit_classes_h #include "DataFormats/Common/interface/Wrapper.h" -#include "RecoTracker/MkFit/interface/MkFitInputWrapper.h" +#include "RecoTracker/MkFit/interface/MkFitHitWrapper.h" +#include "RecoTracker/MkFit/interface/MkFitEventOfHits.h" +#include "RecoTracker/MkFit/interface/MkFitClusterIndexToHit.h" +#include "RecoTracker/MkFit/interface/MkFitSeedWrapper.h" #include "RecoTracker/MkFit/interface/MkFitOutputWrapper.h" #endif diff --git a/RecoTracker/MkFit/src/classes_def.xml b/RecoTracker/MkFit/src/classes_def.xml index e6363f8945f61..d241cc1bb03e8 100644 --- a/RecoTracker/MkFit/src/classes_def.xml +++ b/RecoTracker/MkFit/src/classes_def.xml @@ -1,6 +1,15 @@ - - + + + + + + + + + + + diff --git a/Validation/RecoTrack/python/plotting/trackingPlots.py b/Validation/RecoTrack/python/plotting/trackingPlots.py index fda80114d7e8f..24bdd0c21a86d 100644 --- a/Validation/RecoTrack/python/plotting/trackingPlots.py +++ b/Validation/RecoTrack/python/plotting/trackingPlots.py @@ -1409,7 +1409,8 @@ def _set(param, name, modules): # 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"]) + trackCandidates = self._name+"TrackCandidates" + _set(building, "_building", [trackCandidates+"MkFitSeeds", trackCandidates+"MkFit", trackCandidates]) _set(fit, "_fit", [self._name+"Tracks"]) _set(selection, "_selection", [self._name]) self._other = other @@ -1472,14 +1473,14 @@ def modules(self): "initialStepClassifier3", "initialStep", "initialStepSelector"], - building=["initialStepTrackCandidatesMkFitInput", - "initialStepTrackCandidatesMkFit", - "initialStepTrackCandidates"], other=["firstStepPrimaryVerticesUnsorted", "initialStepTrackRefsForJets", "caloTowerForTrk", "ak4CaloJetsForTrk", - "firstStepPrimaryVertices"]), + "firstStepPrimaryVertices", + "mkFitSiPixelHits", + "mkFitSiStripHits", + "mkFitEventOfHits"]), Iteration("highPtTripletStep", selection=["highPtTripletStepClassifier1", "highPtTripletStepClassifier2",