def customiseNewSeeding(process, module): doubletModuleName = module.doublets.getModuleLabel() doubletModule = getattr(process, doubletModuleName) # Generate doublets for all adjacent layer pairs doubletModule.layerPairs = [ 0, # layer pair (0,1) 1, # layer pair (1,2) ] # Bit of a hack to replace a module with another, but works # # In principle setattr(process) could work too, but it expands the # sequences and I don't want that modifier = cms.Modifier() modifier._setChosen() comparitor = None if hasattr(module, "SeedComparitorPSet"): comparitor = module.SeedComparitorPSet.clone() # Replace triplet generator with the CA version from RecoPixelVertexing.PixelTriplets.caHitTripletEDProducer_cfi import caHitTripletEDProducer as _caHitTripletEDProducer modifier.toReplaceWith( module, _caHitTripletEDProducer.clone( doublets=doubletModuleName, extraHitRPhitolerance=module.extraHitRPhitolerance, **_CAParameters)) if comparitor: module.SeedComparitorPSet = comparitor
seedingHitSets="lowPtTripletStepHitTriplets", ) from RecoPixelVertexing.PixelTriplets.caHitTripletEDProducer_cfi import caHitTripletEDProducer as _caHitTripletEDProducer trackingPhase1.toModify(lowPtTripletStepHitDoublets, layerPairs=[0, 1]) # layer pairs (0,1), (1,2) trackingPhase1.toReplaceWith( lowPtTripletStepHitTriplets, _caHitTripletEDProducer.clone( doublets="lowPtTripletStepHitDoublets", extraHitRPhitolerance=lowPtTripletStepHitTriplets. extraHitRPhitolerance, SeedComparitorPSet=lowPtTripletStepHitTriplets.SeedComparitorPSet, maxChi2=dict( pt1=0.8, pt2=2, value1=70, value2=8, ), useBendingCorrection=True, CAThetaCut=0.002, CAPhiCut=0.05, )) trackingPhase2PU140.toModify(lowPtTripletStepHitDoublets, layerPairs=[0, 1]) # layer pairs (0,1), (1,2) trackingPhase2PU140.toReplaceWith( lowPtTripletStepHitTriplets, _caHitTripletEDProducer.clone( doublets="lowPtTripletStepHitDoublets", extraHitRPhitolerance=lowPtTripletStepHitTriplets.
FilterAtHelixStage = cms.bool(False), FilterPixelHits = cms.bool(True), FilterStripHits = cms.bool(False), ClusterShapeHitFilterName = cms.string('ClusterShapeHitFilter'), ClusterShapeCacheSrc = cms.InputTag('siPixelClusterShapeCache') ), ) from RecoPixelVertexing.PixelTriplets.caHitTripletEDProducer_cfi import caHitTripletEDProducer as _caHitTripletEDProducer trackingPhase1.toModify(detachedTripletStepHitDoublets, layerPairs = [0,1]) # layer pairs (0,1), (1,2) trackingPhase1.toReplaceWith(detachedTripletStepHitTriplets, _caHitTripletEDProducer.clone( doublets = "detachedTripletStepHitDoublets", extraHitRPhitolerance = detachedTripletStepHitTriplets.extraHitRPhitolerance, maxChi2 = dict( pt1 = 0.8, pt2 = 2, value1 = 300 , value2 = 10, ), useBendingCorrection = True, CAThetaCut = 0.001, CAPhiCut = 0, CAHardPtCut = 0.2, )) # QUALITY CUTS DURING TRACK BUILDING import TrackingTools.TrajectoryFiltering.TrajectoryFilter_cff _detachedTripletStepTrajectoryFilterBase = TrackingTools.TrajectoryFiltering.TrajectoryFilter_cff.CkfBaseTrajectoryFilter_block.clone( # maxLostHitsFraction = cms.double(1./10.), # constantValueForLostHitsFractionFilter = cms.double(0.701), minimumNumberOfHits = 3, minPt = 0.075, ) detachedTripletStepTrajectoryFilterBase = _detachedTripletStepTrajectoryFilterBase.clone(
maxElement=50000000, produceIntermediateHitDoublets=True, ) from RecoPixelVertexing.PixelTriplets.caHitTripletEDProducer_cfi import caHitTripletEDProducer as _caHitTripletEDProducer from RecoPixelVertexing.PixelTriplets.pixelTripletHLTEDProducer_cfi import pixelTripletHLTEDProducer as _pixelTripletHLTEDProducer from RecoPixelVertexing.PixelLowPtUtilities.ClusterShapeHitFilterESProducer_cfi import * import RecoPixelVertexing.PixelLowPtUtilities.LowPtClusterShapeSeedComparitor_cfi highPtTripletStepHitTriplets = _caHitTripletEDProducer.clone( doublets='highPtTripletStepHitDoublets', extraHitRPhitolerance=_pixelTripletHLTEDProducer.extraHitRPhitolerance, SeedComparitorPSet=RecoPixelVertexing.PixelLowPtUtilities. LowPtClusterShapeSeedComparitor_cfi.LowPtClusterShapeSeedComparitor.clone( ), maxChi2=dict( pt1=0.8, pt2=8, value1=100, value2=6, ), useBendingCorrection=True, CAThetaCut=0.004, CAPhiCut=0.07, CAHardPtCut=0.3, ) trackingPhase2PU140.toModify(highPtTripletStepHitTriplets, CAThetaCut=0.003, CAPhiCut=0.06, CAHardPtCut=0.5) highBetaStar_2018.toModify(highPtTripletStepHitTriplets, CAThetaCut=0.008,
doublets = "hiLowPtTripletStepTracksHitDoublets", #maxElement = 5000000, SeedComparitorPSet = RecoPixelVertexing.PixelLowPtUtilities.LowPtClusterShapeSeedComparitor_cfi.LowPtClusterShapeSeedComparitor.clone(), produceSeedingHitSets = True, ) from RecoPixelVertexing.PixelTriplets.caHitTripletEDProducer_cfi import caHitTripletEDProducer as _caHitTripletEDProducer hiLowPtTripletStepTracksHitDoubletsCA = hiLowPtTripletStepTracksHitDoublets.clone() hiLowPtTripletStepTracksHitDoubletsCA.layerPairs = [0,1] hiLowPtTripletStepTracksHitTripletsCA = _caHitTripletEDProducer.clone( doublets = "hiLowPtTripletStepTracksHitDoubletsCA", extraHitRPhitolerance = hiLowPtTripletStepTracksHitTriplets.extraHitRPhitolerance, SeedComparitorPSet = hiLowPtTripletStepTracksHitTriplets.SeedComparitorPSet, maxChi2 = dict( pt1 = 0.8, pt2 = 2, value1 = 70 , value2 = 8, ), useBendingCorrection = True, CAThetaCut = 0.002, CAPhiCut = 0.05, ) hiLowPtTripletStepPixelTracksFilter = hiFilter.clone( nSigmaLipMaxTolerance = 4.0, nSigmaTipMaxTolerance = 4.0, lipMax = 0, ptMin = 0.4, ) hiLowPtTripletStepPixelTracks = cms.EDProducer("PixelTrackProducer", passLabel = cms.string('Pixel primary tracks with vertex constraint'),
clusterCheck = "", seedingLayers = "hiHighPtTripletStepSeedLayers", trackingRegions = "hiHighPtTripletStepTrackingRegions", maxElement = 0, produceIntermediateHitDoublets = True, layerPairs = [0,1] ) from RecoPixelVertexing.PixelTriplets.caHitTripletEDProducer_cfi import caHitTripletEDProducer as _caHitTripletEDProducer hiHighPtTripletStepTracksHitTripletsCA = _caHitTripletEDProducer.clone( doublets = "hiHighPtTripletStepTracksHitDoubletsCA", extraHitRPhitolerance = 0.0, SeedComparitorPSet = RecoPixelVertexing.PixelLowPtUtilities.LowPtClusterShapeSeedComparitor_cfi.LowPtClusterShapeSeedComparitor.clone(), maxChi2 = dict( pt1 = 0.8, pt2 = 8, value1 = 100, value2 = 6, ), useBendingCorrection = True, CAThetaCut = 0.004, CAPhiCut = 0.07, CAHardPtCut = 0.3, ) hiHighPtTripletStepPixelTracksFilter = hiFilter.clone( nSigmaTipMaxTolerance = 0, lipMax = 1.0, tipMax = 1.0, ptMin = 1.0, #seeding region is 0.6 ) hiHighPtTripletStepPixelTracks = cms.EDProducer("PixelTrackProducer",
FilterAtHelixStage = cms.bool(False), FilterPixelHits = cms.bool(True), FilterStripHits = cms.bool(False), ClusterShapeHitFilterName = cms.string('ClusterShapeHitFilter'), ClusterShapeCacheSrc = cms.InputTag('siPixelClusterShapeCache') ), ) from RecoPixelVertexing.PixelTriplets.caHitTripletEDProducer_cfi import caHitTripletEDProducer as _caHitTripletEDProducer trackingPhase1.toModify(detachedTripletStepHitDoublets, layerPairs = [0,1]) # layer pairs (0,1), (1,2) trackingPhase1.toReplaceWith(detachedTripletStepHitTriplets, _caHitTripletEDProducer.clone( doublets = "detachedTripletStepHitDoublets", extraHitRPhitolerance = detachedTripletStepHitTriplets.extraHitRPhitolerance, maxChi2 = dict( pt1 = 0.8, pt2 = 2, value1 = 300 , value2 = 10, ), useBendingCorrection = True, CAThetaCut = 0.001, CAPhiCut = 0, CAHardPtCut = 0.2, )) highBetaStar_2018.toModify(detachedTripletStepHitTriplets,CAThetaCut = 0.002,CAPhiCut = 0.1,CAHardPtCut = 0) import FastSimulation.Tracking.TrajectorySeedProducer_cfi _fastSim_detachedTripletStepSeeds = FastSimulation.Tracking.TrajectorySeedProducer_cfi.trajectorySeedProducer.clone( trackingRegions = "detachedTripletStepTrackingRegions", hitMasks = cms.InputTag("detachedTripletStepMasks"), seedFinderSelector = dict( pixelTripletGeneratorFactory = _hitSetProducerToFactoryPSet(detachedTripletStepHitTriplets), layerList = detachedTripletStepSeedLayers.layerList.value()) ) #new for phase1
extraHitRZtolerance = 0.0, maxElement = 1000000, SeedComparitorPSet = RecoPixelVertexing.PixelLowPtUtilities.LowPtClusterShapeSeedComparitor_cfi.LowPtClusterShapeSeedComparitor.clone(), produceSeedingHitSets = True, ) from RecoPixelVertexing.PixelTriplets.caHitTripletEDProducer_cfi import caHitTripletEDProducer as _caHitTripletEDProducer hiDetachedTripletStepTracksHitDoubletsCA = hiDetachedTripletStepTracksHitDoublets.clone() hiDetachedTripletStepTracksHitDoubletsCA.layerPairs = [0,1] hiDetachedTripletStepTracksHitTripletsCA = _caHitTripletEDProducer.clone( doublets = "hiDetachedTripletStepTracksHitDoubletsCA", extraHitRPhitolerance = hiDetachedTripletStepTracksHitTriplets.extraHitRPhitolerance, maxChi2 = dict( pt1 = 0.8, pt2 = 2, value1 = 300 , value2 = 10, ), useBendingCorrection = True, CAThetaCut = 0.001, CAPhiCut = 0, CAHardPtCut = 0.2, ) hiDetachedTripletStepPixelTracksFilter = hiFilter.clone( nSigmaTipMaxTolerance = 0, lipMax = 1.0, tipMax = 1.0, ptMin = 0.95, ) hiDetachedTripletStepPixelTracks = cms.EDProducer("PixelTrackProducer", passLabel = cms.string('Pixel detached tracks with vertex constraint'),
SeedComparitorPSet = RecoPixelVertexing.PixelLowPtUtilities.LowPtClusterShapeSeedComparitor_cfi.LowPtClusterShapeSeedComparitor ) from RecoTracker.TkSeedGenerator.seedCreatorFromRegionConsecutiveHitsEDProducer_cff import seedCreatorFromRegionConsecutiveHitsEDProducer as _seedCreatorFromRegionConsecutiveHitsEDProducer highPtTripletStepSeeds = _seedCreatorFromRegionConsecutiveHitsEDProducer.clone( seedingHitSets = "highPtTripletStepHitTriplets", ) from RecoPixelVertexing.PixelTriplets.caHitTripletEDProducer_cfi import caHitTripletEDProducer as _caHitTripletEDProducer trackingPhase1.toModify(highPtTripletStepHitDoublets, layerPairs = [0,1]) # layer pairs (0,1), (1,2) trackingPhase1.toReplaceWith(highPtTripletStepHitTriplets, _caHitTripletEDProducer.clone( doublets = "highPtTripletStepHitDoublets", extraHitRPhitolerance = highPtTripletStepHitTriplets.extraHitRPhitolerance, SeedComparitorPSet = highPtTripletStepHitTriplets.SeedComparitorPSet, maxChi2 = dict( pt1 = 0.8, pt2 = 8, value1 = 100, value2 = 6, ), useBendingCorrection = True, CAThetaCut = 0.004, CAPhiCut = 0.07, CAHardPtCut = 0.3, )) # QUALITY CUTS DURING TRACK BUILDING import TrackingTools.TrajectoryFiltering.TrajectoryFilter_cff as _TrajectoryFilter_cff _highPtTripletStepTrajectoryFilterBase = _TrajectoryFilter_cff.CkfBaseTrajectoryFilter_block.clone( minimumNumberOfHits = 3, minPt = 0.2, ) highPtTripletStepTrajectoryFilterBase = _highPtTripletStepTrajectoryFilterBase.clone( maxCCCLostHits = 0,
produceSeedingHitSets = True, SeedComparitorPSet = RecoPixelVertexing.PixelLowPtUtilities.LowPtClusterShapeSeedComparitor_cfi.LowPtClusterShapeSeedComparitor.clone() ) from RecoTracker.TkSeedGenerator.seedCreatorFromRegionConsecutiveHitsEDProducer_cff import seedCreatorFromRegionConsecutiveHitsEDProducer as _seedCreatorFromRegionConsecutiveHitsEDProducer lowPtTripletStepSeeds = _seedCreatorFromRegionConsecutiveHitsEDProducer.clone( seedingHitSets = 'lowPtTripletStepHitTriplets', ) from RecoPixelVertexing.PixelTriplets.caHitTripletEDProducer_cfi import caHitTripletEDProducer as _caHitTripletEDProducer trackingPhase1.toModify(lowPtTripletStepHitDoublets, layerPairs = [0,1]) # layer pairs (0,1), (1,2) trackingPhase1.toReplaceWith(lowPtTripletStepHitTriplets, _caHitTripletEDProducer.clone( doublets = 'lowPtTripletStepHitDoublets', extraHitRPhitolerance = lowPtTripletStepHitTriplets.extraHitRPhitolerance, SeedComparitorPSet = lowPtTripletStepHitTriplets.SeedComparitorPSet, maxChi2 = dict( pt1 = 0.8, pt2 = 2, value1 = 70 , value2 = 8, ), useBendingCorrection = True, CAThetaCut = 0.002, CAPhiCut = 0.05 ) ) trackingPhase2PU140.toModify(lowPtTripletStepHitDoublets, layerPairs = [0,1]) # layer pairs (0,1), (1,2) trackingPhase2PU140.toReplaceWith(lowPtTripletStepHitTriplets, _caHitTripletEDProducer.clone( doublets = 'lowPtTripletStepHitDoublets', extraHitRPhitolerance = lowPtTripletStepHitTriplets.extraHitRPhitolerance, SeedComparitorPSet = lowPtTripletStepHitTriplets.SeedComparitorPSet, maxChi2 = dict( pt1 = 0.8, pt2 = 2, value1 = 70 , value2 = 8,
trackingRegions = "lowPtTripletStepTrackingRegions", hitMasks = cms.InputTag("lowPtTripletStepMasks"), ) from FastSimulation.Tracking.SeedingMigration import _hitSetProducerToFactoryPSet _fastSim_lowPtTripletStepSeeds.seedFinderSelector.pixelTripletGeneratorFactory = _hitSetProducerToFactoryPSet(lowPtTripletStepHitTriplets) _fastSim_lowPtTripletStepSeeds.seedFinderSelector.pixelTripletGeneratorFactory.SeedComparitorPSet.ComponentName = "none" fastSim.toReplaceWith(lowPtTripletStepSeeds,_fastSim_lowPtTripletStepSeeds) from RecoPixelVertexing.PixelTriplets.caHitTripletEDProducer_cfi import caHitTripletEDProducer as _caHitTripletEDProducer trackingPhase1.toModify(lowPtTripletStepHitDoublets, layerPairs = [0,1]) # layer pairs (0,1), (1,2) trackingPhase1.toReplaceWith(lowPtTripletStepHitTriplets, _caHitTripletEDProducer.clone( doublets = "lowPtTripletStepHitDoublets", extraHitRPhitolerance = lowPtTripletStepHitTriplets.extraHitRPhitolerance, SeedComparitorPSet = lowPtTripletStepHitTriplets.SeedComparitorPSet, maxChi2 = dict( pt1 = 0.8, pt2 = 2, value1 = 70 , value2 = 8, ), useBendingCorrection = True, CAThetaCut = 0.002, CAPhiCut = 0.05, )) trackingPhase2PU140.toModify(lowPtTripletStepHitDoublets, layerPairs = [0,1]) # layer pairs (0,1), (1,2) trackingPhase2PU140.toReplaceWith(lowPtTripletStepHitTriplets, _caHitTripletEDProducer.clone( doublets = "lowPtTripletStepHitDoublets", extraHitRPhitolerance = lowPtTripletStepHitTriplets.extraHitRPhitolerance, SeedComparitorPSet = lowPtTripletStepHitTriplets.SeedComparitorPSet, maxChi2 = dict( pt1 = 0.8, pt2 = 2, value1 = 70 , value2 = 8, ),
def customizeHLTForPFTrackingPhaseI2017(process): if not hasattr(process, 'hltPixelLayerTriplets'): #there could also be a message here that the call is done for non-HLT stuff return process process.hltPixelLayerTriplets.layerList = cms.vstring( 'BPix1+BPix2+BPix3', 'BPix2+BPix3+BPix4', 'BPix1+BPix3+BPix4', 'BPix1+BPix2+BPix4', 'BPix2+BPix3+FPix1_pos', 'BPix2+BPix3+FPix1_neg', 'BPix1+BPix2+FPix1_pos', 'BPix1+BPix2+FPix1_neg', 'BPix2+FPix1_pos+FPix2_pos', 'BPix2+FPix1_neg+FPix2_neg', 'BPix1+FPix1_pos+FPix2_pos', 'BPix1+FPix1_neg+FPix2_neg', 'FPix1_pos+FPix2_pos+FPix3_pos', 'FPix1_neg+FPix2_neg+FPix3_neg') process.hltPixelLayerQuadruplets = cms.EDProducer( "SeedingLayersEDProducer", BPix=cms.PSet(useErrorsFromParam=cms.bool(True), hitErrorRPhi=cms.double(0.0027), TTRHBuilder=cms.string("hltESPTTRHBuilderPixelOnly"), HitProducer=cms.string("hltSiPixelRecHits"), hitErrorRZ=cms.double(0.006)), FPix=cms.PSet(useErrorsFromParam=cms.bool(True), hitErrorRPhi=cms.double(0.0051), TTRHBuilder=cms.string("hltESPTTRHBuilderPixelOnly"), HitProducer=cms.string("hltSiPixelRecHits"), hitErrorRZ=cms.double(0.0036)), MTEC=cms.PSet(), MTIB=cms.PSet(), MTID=cms.PSet(), MTOB=cms.PSet(), TEC=cms.PSet(), TIB=cms.PSet(), TID=cms.PSet(), TOB=cms.PSet(), layerList=cms.vstring('BPix1+BPix2+BPix3+BPix4', 'BPix1+BPix2+BPix3+FPix1_pos', 'BPix1+BPix2+BPix3+FPix1_neg', 'BPix1+BPix2+FPix1_pos+FPix2_pos', 'BPix1+BPix2+FPix1_neg+FPix2_neg', 'BPix1+FPix1_pos+FPix2_pos+FPix3_pos', 'BPix1+FPix1_neg+FPix2_neg+FPix3_neg')) # Configure seed generator / pixel track producer from RecoPixelVertexing.PixelTriplets.caHitQuadrupletEDProducer_cfi import caHitQuadrupletEDProducer as _caHitQuadrupletEDProducer process.hltPixelTracksTrackingRegions.RegionPSet = cms.PSet( precise=cms.bool(True), beamSpot=cms.InputTag("hltOnlineBeamSpot"), originRadius=cms.double(0.02), ptMin=cms.double(0.8), nSigmaZ=cms.double(4.0), ) process.hltPixelTracksHitDoublets.seedingLayers = "hltPixelLayerQuadruplets" process.hltPixelTracksHitDoublets.layerPairs = [ 0, 1, 2 ] # layer pairs (0,1), (1,2), (2,3) process.hltPixelTracksHitQuadruplets = _caHitQuadrupletEDProducer.clone( doublets="hltPixelTracksHitDoublets", extraHitRPhitolerance=cms.double(0.032), maxChi2=dict( pt1=0.7, pt2=2, value1=200, value2=50, enabled=True, ), useBendingCorrection=True, fitFastCircle=True, fitFastCircleChi2Cut=True, CAThetaCut=cms.double(0.002), CAPhiCut=cms.double(0.2), CAHardPtCut=cms.double(0), SeedComparitorPSet=cms.PSet( ComponentName=cms.string("LowPtClusterShapeSeedComparitor"), clusterShapeHitFilter=cms.string('ClusterShapeHitFilter'), clusterShapeCacheSrc=cms.InputTag("hltSiPixelClustersCache"))) process.hltPixelTracks.SeedingHitSets = "hltPixelTracksHitQuadruplets" process.HLTIter0PSetTrajectoryFilterIT.minimumNumberOfHits = cms.int32(4) process.HLTIter0PSetTrajectoryFilterIT.minHitsMinPt = cms.int32(4) process.hltIter0PFlowTrackCutClassifier.mva.minLayers = cms.vint32(3, 3, 4) process.hltIter0PFlowTrackCutClassifier.mva.min3DLayers = cms.vint32( 0, 3, 4) process.hltIter0PFlowTrackCutClassifier.mva.minPixelHits = cms.vint32( 0, 3, 4) process.HLTIter0GroupedCkfTrajectoryBuilderIT = cms.PSet( ComponentType=cms.string('GroupedCkfTrajectoryBuilder'), bestHitOnly=cms.bool(True), propagatorAlong=cms.string('PropagatorWithMaterialParabolicMf'), trajectoryFilter=cms.PSet( refToPSet_=cms.string('HLTIter0PSetTrajectoryFilterIT')), inOutTrajectoryFilter=cms.PSet( refToPSet_=cms.string('HLTIter0PSetTrajectoryFilterIT')), useSameTrajFilter=cms.bool(True), maxCand=cms.int32(2), intermediateCleaning=cms.bool(True), lostHitPenalty=cms.double(30.0), MeasurementTrackerName=cms.string('hltESPMeasurementTracker'), lockHits=cms.bool(True), TTRHBuilder=cms.string('hltESPTTRHBWithTrackAngle'), foundHitBonus=cms.double(5.0), updator=cms.string('hltESPKFUpdator'), alwaysUseInvalidHits=cms.bool(False), requireSeedHitsInRebuild=cms.bool(True), keepOriginalIfRebuildFails=cms.bool(False), estimator=cms.string('hltESPChi2ChargeMeasurementEstimator9'), propagatorOpposite=cms.string( 'PropagatorWithMaterialParabolicMfOpposite'), minNrOfHitsForRebuild=cms.int32(5), maxDPhiForLooperReconstruction=cms.double(2.0), maxPtForLooperReconstruction=cms.double(0.7), cleanTrajectoryAfterInOut=cms.bool(False), useHitsSplitting=cms.bool(False), doSeedingRegionRebuilding=cms.bool(False)) process.hltIter0PFlowCkfTrackCandidates.TrajectoryBuilderPSet = cms.PSet( refToPSet_=cms.string('HLTIter0GroupedCkfTrajectoryBuilderIT')) process.hltIter1PixelLayerQuadruplets = cms.EDProducer( "SeedingLayersEDProducer", BPix=cms.PSet( useErrorsFromParam=cms.bool(True), hitErrorRPhi=cms.double(0.0027), TTRHBuilder=cms.string("hltESPTTRHBuilderPixelOnly"), HitProducer=cms.string("hltSiPixelRecHits"), hitErrorRZ=cms.double(0.006), skipClusters=cms.InputTag("hltIter1ClustersRefRemoval"), ), FPix=cms.PSet( useErrorsFromParam=cms.bool(True), hitErrorRPhi=cms.double(0.0051), TTRHBuilder=cms.string("hltESPTTRHBuilderPixelOnly"), HitProducer=cms.string("hltSiPixelRecHits"), hitErrorRZ=cms.double(0.0036), skipClusters=cms.InputTag("hltIter1ClustersRefRemoval"), ), MTEC=cms.PSet(), MTIB=cms.PSet(), MTID=cms.PSet(), MTOB=cms.PSet(), TEC=cms.PSet(), TIB=cms.PSet(), TID=cms.PSet(), TOB=cms.PSet(), layerList=cms.vstring('BPix1+BPix2+BPix3+BPix4', 'BPix1+BPix2+BPix3+FPix1_pos', 'BPix1+BPix2+BPix3+FPix1_neg', 'BPix1+BPix2+FPix1_pos+FPix2_pos', 'BPix1+BPix2+FPix1_neg+FPix2_neg', 'BPix1+FPix1_pos+FPix2_pos+FPix3_pos', 'BPix1+FPix1_neg+FPix2_neg+FPix3_neg')) process.hltIter1PFlowPixelHitDoublets.layerPairs = [ 0, 1, 2 ] # layer pairs (0,1), (1,2), (2,3) process.hltIter1PFlowPixelHitDoublets.seedingLayers = "hltIter1PixelLayerQuadruplets" process.hltIter1PFlowPixelTrackingRegions.RegionPSet.nSigmaZVertex = cms.double( 4.0) process.hltIter1PFlowPixelTrackingRegions.RegionPSet.nSigmaZBeamSpot = cms.double( 4.0) process.hltIter1PFlowPixelTrackingRegions.RegionPSet.originRadius = cms.double( 0.05) process.hltIter1PFlowPixelTrackingRegions.RegionPSet.ptMin = cms.double( 0.3) process.hltIter1PFlowPixelTrackingRegions.RegionPSet.zErrorVetex = cms.double( 0.1) process.hltIter1PFlowPixelTrackingRegions.RegionPSet.beamSpot = cms.InputTag( "hltOnlineBeamSpot") process.hltIter1PFlowPixelTrackingRegions.RegionPSet.vertexCollection = cms.InputTag( "hltTrimmedPixelVertices") process.hltIter1PFlowPixelTrackingRegions.RegionPSet.deltaEta = cms.double( 1.0) process.hltIter1PFlowPixelTrackingRegions.RegionPSet.deltaPhi = cms.double( 1.0) process.hltIter1PFlowPixelHitQuadruplets = _caHitQuadrupletEDProducer.clone( doublets="hltIter1PFlowPixelHitDoublets", extraHitRPhitolerance=cms.double(0.032), maxChi2=dict( pt1=0.7, pt2=2, value1=2000, value2=150, enabled=True, ), useBendingCorrection=True, fitFastCircle=True, fitFastCircleChi2Cut=True, CAThetaCut=cms.double(0.004), CAPhiCut=cms.double(0.3), CAHardPtCut=cms.double(0), SeedComparitorPSet=cms.PSet( ComponentName=cms.string("none"), clusterShapeHitFilter=cms.string('ClusterShapeHitFilter'), clusterShapeCacheSrc=cms.InputTag("hltSiPixelClustersCache"))) from RecoTracker.TkSeedGenerator.seedCreatorFromRegionConsecutiveHitsEDProducer_cff import seedCreatorFromRegionConsecutiveHitsEDProducer as _seedCreatorFromRegionConsecutiveHitsEDProducer replace_with( process.hltIter1PFlowPixelSeeds, _seedCreatorFromRegionConsecutiveHitsEDProducer.clone( seedingHitSets="hltIter1PFlowPixelHitQuadruplets", TTRHBuilder=cms.string('hltESPTTRHBWithTrackAngle'), )) process.HLTIter1PSetTrajectoryFilterIT = cms.PSet( minPt=cms.double(0.2), minHitsMinPt=cms.int32(3), ComponentType=cms.string("CkfBaseTrajectoryFilter"), maxLostHits=cms.int32(1), maxNumberOfHits=cms.int32(100), maxConsecLostHits=cms.int32(1), minimumNumberOfHits=cms.int32(3), nSigmaMinPt=cms.double(5.0), chargeSignificance=cms.double(-1.0), minGoodStripCharge=cms.PSet( refToPSet_=cms.string("HLTSiStripClusterChargeCutNone")), maxCCCLostHits=cms.int32(0), seedExtension=cms.int32(0), strictSeedExtension=cms.bool(False), minNumberOfHitsForLoopers=cms.int32(13), minNumberOfHitsPerLoop=cms.int32(4), extraNumberOfHitsBeforeTheFirstLoop=cms.int32(4), maxLostHitsFraction=cms.double(999.0), constantValueForLostHitsFractionFilter=cms.double(1.0), seedPairPenalty=cms.int32(0), pixelSeedExtension=cms.bool(False)) process.HLTIter1PSetTrajectoryBuilderIT = cms.PSet( propagatorAlong=cms.string("PropagatorWithMaterialParabolicMf"), trajectoryFilter=cms.PSet( refToPSet_=cms.string("HLTIter1PSetTrajectoryFilterIT")), maxCand=cms.int32(2), ComponentType=cms.string("CkfTrajectoryBuilder"), propagatorOpposite=cms.string( "PropagatorWithMaterialParabolicMfOpposite"), MeasurementTrackerName=cms.string("hltIter1ESPMeasurementTracker"), estimator=cms.string("hltESPChi2ChargeMeasurementEstimator16"), TTRHBuilder=cms.string("hltESPTTRHBWithTrackAngle"), updator=cms.string("hltESPKFUpdator"), alwaysUseInvalidHits=cms.bool(False), intermediateCleaning=cms.bool(True), lostHitPenalty=cms.double(30.0), useSameTrajFilter=cms.bool(True)) process.HLTIter1GroupedCkfTrajectoryBuilderIT = cms.PSet( ComponentType=cms.string('GroupedCkfTrajectoryBuilder'), bestHitOnly=cms.bool(True), propagatorAlong=cms.string('PropagatorWithMaterialParabolicMf'), trajectoryFilter=cms.PSet( refToPSet_=cms.string('HLTIter1PSetTrajectoryFilterIT')), useSameTrajFilter=cms.bool(True), maxCand=cms.int32(2), intermediateCleaning=cms.bool(True), lostHitPenalty=cms.double(30.0), MeasurementTrackerName=cms.string('hltIter1ESPMeasurementTracker'), lockHits=cms.bool(True), TTRHBuilder=cms.string('hltESPTTRHBWithTrackAngle'), foundHitBonus=cms.double(5.0), updator=cms.string('hltESPKFUpdator'), alwaysUseInvalidHits=cms.bool(False), requireSeedHitsInRebuild=cms.bool(True), keepOriginalIfRebuildFails=cms.bool(False), estimator=cms.string('hltESPChi2ChargeMeasurementEstimator16'), propagatorOpposite=cms.string( 'PropagatorWithMaterialParabolicMfOpposite'), minNrOfHitsForRebuild=cms.int32(5)) process.hltIter1PFlowCkfTrackCandidates.TrajectoryBuilderPSet = cms.PSet( refToPSet_=cms.string('HLTIter1GroupedCkfTrajectoryBuilderIT')) replace_with( process.HLTIterativeTrackingIteration1, cms.Sequence(process.hltIter1ClustersRefRemoval + process.hltIter1MaskedMeasurementTrackerEvent + process.hltIter1PixelLayerQuadruplets + process.hltIter1PFlowPixelTrackingRegions + process.hltIter1PFlowPixelClusterCheck + process.hltIter1PFlowPixelHitDoublets + process.hltIter1PFlowPixelHitQuadruplets + process.hltIter1PFlowPixelSeeds + process.hltIter1PFlowCkfTrackCandidates + process.hltIter1PFlowCtfWithMaterialTracks + process.hltIter1PFlowTrackCutClassifierPrompt + process.hltIter1PFlowTrackCutClassifierDetached + process.hltIter1PFlowTrackCutClassifierMerged + process.hltIter1PFlowTrackSelectionHighPurity)) process.hltIter2PixelLayerTriplets = cms.EDProducer( "SeedingLayersEDProducer", layerList=cms.vstring( 'BPix1+BPix2+BPix3', 'BPix2+BPix3+BPix4', 'BPix1+BPix3+BPix4', 'BPix1+BPix2+BPix4', 'BPix2+BPix3+FPix1_pos', 'BPix2+BPix3+FPix1_neg', 'BPix1+BPix2+FPix1_pos', 'BPix1+BPix2+FPix1_neg', 'BPix2+FPix1_pos+FPix2_pos', 'BPix2+FPix1_neg+FPix2_neg', 'BPix1+FPix1_pos+FPix2_pos', 'BPix1+FPix1_neg+FPix2_neg', 'FPix1_pos+FPix2_pos+FPix3_pos', 'FPix1_neg+FPix2_neg+FPix3_neg'), MTOB=cms.PSet(), TEC=cms.PSet(), MTID=cms.PSet(), FPix=cms.PSet(HitProducer=cms.string("hltSiPixelRecHits"), hitErrorRZ=cms.double(0.0036), useErrorsFromParam=cms.bool(True), TTRHBuilder=cms.string("hltESPTTRHBuilderPixelOnly"), skipClusters=cms.InputTag("hltIter2ClustersRefRemoval"), hitErrorRPhi=cms.double(0.0051)), MTEC=cms.PSet(), MTIB=cms.PSet(), TID=cms.PSet(), TOB=cms.PSet(), BPix=cms.PSet(HitProducer=cms.string("hltSiPixelRecHits"), hitErrorRZ=cms.double(0.006), useErrorsFromParam=cms.bool(True), TTRHBuilder=cms.string("hltESPTTRHBuilderPixelOnly"), skipClusters=cms.InputTag("hltIter2ClustersRefRemoval"), hitErrorRPhi=cms.double(0.0027)), TIB=cms.PSet()) process.hltIter2PFlowPixelTrackingRegions.RegionPSet.ptMin = cms.double( 0.8) process.hltIter2PFlowPixelTrackingRegions.RegionPSet.originRadius = cms.double( 0.025) process.hltIter2PFlowPixelTrackingRegions.RegionPSet.nSigmaZVertex = cms.double( 4.0) from RecoPixelVertexing.PixelTriplets.caHitTripletEDProducer_cfi import caHitTripletEDProducer as _caHitTripletEDProducer process.hltIter2PFlowPixelHitDoublets.seedingLayers = "hltIter2PixelLayerTriplets" process.hltIter2PFlowPixelHitDoublets.produceIntermediateHitDoublets = True process.hltIter2PFlowPixelHitDoublets.produceSeedingHitSets = False process.hltIter2PFlowPixelHitDoublets.layerPairs = [0, 1] process.hltIter2PFlowPixelHitTriplets = _caHitTripletEDProducer.clone( doublets=cms.InputTag("hltIter2PFlowPixelHitDoublets"), extraHitRPhitolerance=cms.double(0.032), maxChi2=cms.PSet( pt1=cms.double(0.8), pt2=cms.double(8), value1=cms.double(100), value2=cms.double(6), enabled=cms.bool(True), ), useBendingCorrection=cms.bool(True), CAThetaCut=cms.double(0.004), CAPhiCut=cms.double(0.1), CAHardPtCut=cms.double(0.3), ) def _copy(old, new, skip=[]): skipSet = set(skip) for key in old.parameterNames_(): if key not in skipSet: setattr(new, key, getattr(old, key)) from RecoTracker.TkSeedGenerator.seedCreatorFromRegionConsecutiveHitsTripletOnlyEDProducer_cfi import seedCreatorFromRegionConsecutiveHitsTripletOnlyEDProducer as _seedCreatorFromRegionConsecutiveHitsTripletOnlyEDProducer replace_with( process.hltIter2PFlowPixelSeeds, _seedCreatorFromRegionConsecutiveHitsTripletOnlyEDProducer.clone( seedingHitSets="hltIter2PFlowPixelHitTriplets")) _copy(process.HLTSeedFromConsecutiveHitsTripletOnlyCreator, process.hltIter2PFlowPixelSeeds, skip=["ComponentName"]) process.HLTIter2GroupedCkfTrajectoryBuilderIT = cms.PSet( ComponentType=cms.string('GroupedCkfTrajectoryBuilder'), bestHitOnly=cms.bool(True), propagatorAlong=cms.string('PropagatorWithMaterialParabolicMf'), trajectoryFilter=cms.PSet( refToPSet_=cms.string('HLTIter2PSetTrajectoryFilterIT')), inOutTrajectoryFilter=cms.PSet( refToPSet_=cms.string('HLTIter2PSetTrajectoryFilterIT')), useSameTrajFilter=cms.bool(True), maxCand=cms.int32(2), intermediateCleaning=cms.bool(True), lostHitPenalty=cms.double(30.0), MeasurementTrackerName=cms.string('hltESPMeasurementTracker'), lockHits=cms.bool(True), TTRHBuilder=cms.string('hltESPTTRHBWithTrackAngle'), foundHitBonus=cms.double(5.0), updator=cms.string('hltESPKFUpdator'), alwaysUseInvalidHits=cms.bool(False), requireSeedHitsInRebuild=cms.bool(True), keepOriginalIfRebuildFails=cms.bool(False), estimator=cms.string('hltESPChi2ChargeMeasurementEstimator16'), propagatorOpposite=cms.string( 'PropagatorWithMaterialParabolicMfOpposite'), minNrOfHitsForRebuild=cms.int32(5), maxDPhiForLooperReconstruction=cms.double(2.0), maxPtForLooperReconstruction=cms.double(0.7), cleanTrajectoryAfterInOut=cms.bool(False), useHitsSplitting=cms.bool(False), doSeedingRegionRebuilding=cms.bool(False)) process.hltIter2PFlowCkfTrackCandidates.TrajectoryBuilderPSet = cms.PSet( refToPSet_=cms.string('HLTIter2GroupedCkfTrajectoryBuilderIT')) replace_with( process.HLTIterativeTrackingIteration2, cms.Sequence(process.hltIter2ClustersRefRemoval + process.hltIter2MaskedMeasurementTrackerEvent + process.hltIter2PixelLayerTriplets + process.hltIter2PFlowPixelTrackingRegions + process.hltIter2PFlowPixelClusterCheck + process.hltIter2PFlowPixelHitDoublets + process.hltIter2PFlowPixelHitTriplets + process.hltIter2PFlowPixelSeeds + process.hltIter2PFlowCkfTrackCandidates + process.hltIter2PFlowCtfWithMaterialTracks + process.hltIter2PFlowTrackCutClassifier + process.hltIter2PFlowTrackSelectionHighPurity)) # replace hltPixelLayerTriplets and hltPixelTracksHitTriplets with hltPixelLayerQuadruplets and hltPixelTracksHitQuadruplets # in any Sequence, Paths or EndPath that contains the former and not the latter from FWCore.ParameterSet.SequenceTypes import ModuleNodeVisitor for sequence in itertools.chain(process._Process__sequences.itervalues(), process._Process__paths.itervalues(), process._Process__endpaths.itervalues()): modules = list() sequence.visit(ModuleNodeVisitor(modules)) if process.hltPixelTracks in modules and not process.hltPixelLayerQuadruplets in modules: # note that this module does not necessarily exist in sequence 'sequence', if it doesn't, it does not get removed sequence.remove(process.hltPixelLayerTriplets) index = sequence.index(process.hltPixelTracksHitDoublets) sequence.insert(index, process.hltPixelLayerQuadruplets) index = sequence.index(process.hltPixelTracksHitTriplets) sequence.remove(process.hltPixelTracksHitTriplets) sequence.insert(index, process.hltPixelTracksHitQuadruplets) if process.hltIter1PFlowPixelHitTriplets in modules and not process.hltIter1PFlowPixelHitQuadruplets in modules: index = sequence.index(process.hltIter1PFlowPixelHitTriplets) sequence.insert(index, process.hltIter1PixelTracks) sequence.insert(index, process.hltIter1PFlowPixelHitQuadruplets) sequence.remove(process.hltIter1PFlowPixelHitTriplets) # Remove entirely to avoid warning from the early deleter del process.hltPixelTracksHitTriplets del process.hltIter1PFlowPixelHitTriplets return process