def customiseNewSeeding(process, module): tripletModuleName = module.triplets.getModuleLabel() tripletModule = getattr(process, tripletModuleName) doubletModuleName = tripletModule.doublets.getModuleLabel() doubletModule = getattr(process, doubletModuleName) # Generate doublets for all adjacent layer pairs doubletModule.layerPairs = [ 0, # layer pair (0,1) 1, # layer pair (1,2) 2 # layer pair (2,3) ] # Bit of a hack to replace a module with another, but works # # In principle setattr(process) could work too, but it expands the # sequences and I don't want that modifier = cms.Modifier() modifier._setChosen() # Replace quadruplet generator with the CA version from RecoPixelVertexing.PixelTriplets.caHitQuadrupletEDProducer_cfi import caHitQuadrupletEDProducer as _caHitQuadrupletEDProducer modifier.toReplaceWith( module, _caHitQuadrupletEDProducer.clone( doublets=doubletModuleName, SeedComparitorPSet=module.SeedComparitorPSet.clone(), extraHitRPhitolerance=module.extraHitRPhitolerance, **_CAParameters)) # Remove triplet generator from all sequence and paths for seqs in [process.sequences_(), process.paths_()]: for seqName, seq in seqs.iteritems(): # cms.Sequence.remove() would look simpler, but it expands # the contained sequences if a replacement occurs there. try: index = seq.index(tripletModule) except: continue seq.remove(tripletModule) delattr(process, tripletModuleName)
def customiseNewSeeding(process, module): tripletModuleName = module.triplets.getModuleLabel() tripletModule = getattr(process, tripletModuleName) doubletModuleName = tripletModule.doublets.getModuleLabel() doubletModule = getattr(process, doubletModuleName) # Generate doublets for all adjacent layer pairs doubletModule.layerPairs = [ 0, # layer pair (0,1) 1, # layer pair (1,2) 2 # layer pair (2,3) ] # Bit of a hack to replace a module with another, but works # # In principle setattr(process) could work too, but it expands the # sequences and I don't want that modifier = cms.Modifier() modifier._setChosen() # Replace quadruplet generator with the CA version from RecoPixelVertexing.PixelTriplets.caHitQuadrupletEDProducer_cfi import caHitQuadrupletEDProducer as _caHitQuadrupletEDProducer modifier.toReplaceWith(module, _caHitQuadrupletEDProducer.clone( doublets = doubletModuleName, SeedComparitorPSet = module.SeedComparitorPSet.clone(), extraHitRPhitolerance = module.extraHitRPhitolerance, **_CAParameters )) # Remove triplet generator from all sequence and paths for seqs in [process.sequences_(), process.paths_()]: for seqName, seq in seqs.iteritems(): # cms.Sequence.remove() would look simpler, but it expands # the contained sequences if a replacement occurs there. try: index = seq.index(tripletModule) except: continue seq.remove(tripletModule) delattr(process, tripletModuleName)
trackingRegions = "lowPtQuadStepTrackingRegions", layerPairs = [0,1,2], # layer pairs (0,1), (1,2), (2,3) maxElement = 0, produceIntermediateHitDoublets = True, ) from RecoPixelVertexing.PixelTriplets.caHitQuadrupletEDProducer_cfi import caHitQuadrupletEDProducer as _caHitQuadrupletEDProducer from RecoPixelVertexing.PixelTriplets.pixelTripletHLTEDProducer_cfi import pixelTripletHLTEDProducer as _pixelTripletHLTEDProducer from RecoPixelVertexing.PixelLowPtUtilities.ClusterShapeHitFilterESProducer_cfi import * import RecoPixelVertexing.PixelLowPtUtilities.LowPtClusterShapeSeedComparitor_cfi lowPtQuadStepHitQuadruplets = _caHitQuadrupletEDProducer.clone( doublets = "lowPtQuadStepHitDoublets", extraHitRPhitolerance = _pixelTripletHLTEDProducer.extraHitRPhitolerance, SeedComparitorPSet = RecoPixelVertexing.PixelLowPtUtilities.LowPtClusterShapeSeedComparitor_cfi.LowPtClusterShapeSeedComparitor.clone(), maxChi2 = dict( pt1 = 0.7, pt2 = 2, value1 = 1000, value2 = 150, ), useBendingCorrection = True, fitFastCircle = True, fitFastCircleChi2Cut = True, CAThetaCut = 0.0017, CAPhiCut = 0.3, ) trackingPhase2PU140.toModify(lowPtQuadStepHitQuadruplets,CAThetaCut = 0.0015,CAPhiCut = 0.25) from RecoTracker.TkSeedGenerator.seedCreatorFromRegionConsecutiveHitsEDProducer_cff import seedCreatorFromRegionConsecutiveHitsEDProducer as _seedCreatorFromRegionConsecutiveHitsEDProducer lowPtQuadStepSeeds = _seedCreatorFromRegionConsecutiveHitsEDProducer.clone( seedingHitSets = "lowPtQuadStepHitQuadruplets", ) trackingPhase1QuadProp.toModify(lowPtQuadStepHitDoublets, layerPairs = [0]) lowPtQuadStepHitTriplets = _pixelTripletHLTEDProducer.clone(
clusterCheck="", seedingLayers="hiDetachedQuadStepSeedLayers", trackingRegions="hiDetachedQuadStepTrackingRegions", maxElement=50000000, produceIntermediateHitDoublets=True, layerPairs=[0, 1, 2]) from RecoPixelVertexing.PixelTriplets.caHitQuadrupletEDProducer_cfi import caHitQuadrupletEDProducer as _caHitQuadrupletEDProducer hiDetachedQuadStepTracksHitQuadrupletsCA = _caHitQuadrupletEDProducer.clone( doublets="hiDetachedQuadStepTracksHitDoubletsCA", extraHitRPhitolerance=0.0, maxChi2=dict( pt1=0.8, pt2=2, value1=500, value2=100, ), useBendingCorrection=True, fitFastCircle=True, fitFastCircleChi2Cut=True, CAThetaCut=0.0011, CAPhiCut=0, ) hiDetachedQuadStepPixelTracksFilter = hiFilter.clone( nSigmaTipMaxTolerance=0, lipMax=1.0, tipMax=1.0, ptMin=0.95, #seeding region is 0.3 ) hiDetachedQuadStepPixelTracks = cms.EDProducer(
seedingLayers = "detachedQuadStepSeedLayers", trackingRegions = "detachedQuadStepTrackingRegions", layerPairs = [0,1,2], # layer pairs (0,1), (1,2), (2,3), maxElement = 0, produceIntermediateHitDoublets = True, ) from RecoPixelVertexing.PixelTriplets.caHitQuadrupletEDProducer_cfi import caHitQuadrupletEDProducer as _caHitQuadrupletEDProducer from RecoPixelVertexing.PixelTriplets.pixelTripletLargeTipEDProducer_cfi import pixelTripletLargeTipEDProducer as _pixelTripletLargeTipEDProducer from RecoPixelVertexing.PixelLowPtUtilities.ClusterShapeHitFilterESProducer_cfi import * detachedQuadStepHitQuadruplets = _caHitQuadrupletEDProducer.clone( doublets = "detachedQuadStepHitDoublets", extraHitRPhitolerance = _pixelTripletLargeTipEDProducer.extraHitRPhitolerance, maxChi2 = dict( pt1 = 0.8, pt2 = 2, value1 = 500, value2 = 100, ), useBendingCorrection = True, fitFastCircle = True, fitFastCircleChi2Cut = True, CAThetaCut = 0.0011, CAPhiCut = 0, ) from RecoTracker.TkSeedGenerator.seedCreatorFromRegionConsecutiveHitsTripletOnlyEDProducer_cff import seedCreatorFromRegionConsecutiveHitsTripletOnlyEDProducer as _seedCreatorFromRegionConsecutiveHitsTripletOnlyEDProducer detachedQuadStepSeeds = _seedCreatorFromRegionConsecutiveHitsTripletOnlyEDProducer.clone( seedingHitSets = "detachedQuadStepHitQuadruplets", SeedComparitorPSet = dict(# FIXME: is this defined in any cfi that could be imported instead of copy-paste? ComponentName = 'PixelClusterShapeSeedComparitor', FilterAtHelixStage = cms.bool(False), FilterPixelHits = cms.bool(True), FilterStripHits = cms.bool(False), ClusterShapeHitFilterName = cms.string('ClusterShapeHitFilter'),
value1 = 0.2, value2 = 0.05, enabled = True, ), useBendingCorrection = True, fitFastCircle = True, fitFastCircleChi2Cut = True, ) from RecoPixelVertexing.PixelTriplets.caHitQuadrupletEDProducer_cfi import caHitQuadrupletEDProducer as _caHitQuadrupletEDProducer trackingPhase1.toModify(detachedQuadStepHitDoublets, layerPairs = [0,1,2]) # layer pairs (0,1), (1,2), (2,3) trackingPhase1.toReplaceWith(detachedQuadStepHitQuadruplets, _caHitQuadrupletEDProducer.clone( doublets = "detachedQuadStepHitDoublets", extraHitRPhitolerance = detachedQuadStepHitTriplets.extraHitRPhitolerance, maxChi2 = dict( pt1 = 0.8, pt2 = 2, value1 = 500, value2 = 100, ), useBendingCorrection = True, fitFastCircle = True, fitFastCircleChi2Cut = True, CAThetaCut = 0.0011, CAPhiCut = 0, )) from RecoPixelVertexing.PixelTriplets.pixelQuadrupletMergerEDProducer_cfi import pixelQuadrupletMergerEDProducer as _pixelQuadrupletMergerEDProducer from RecoPixelVertexing.PixelTriplets.quadrupletseedmerging_cff import * _detachedQuadStepHitQuadrupletsMerging = _pixelQuadrupletMergerEDProducer.clone( triplets = "detachedQuadStepHitTriplets", layerList = dict(refToPSet_ = cms.string("PixelSeedMergerQuadruplets")), ) from RecoTracker.TkSeedGenerator.seedCreatorFromRegionConsecutiveHitsTripletOnlyEDProducer_cff import seedCreatorFromRegionConsecutiveHitsTripletOnlyEDProducer as _seedCreatorFromRegionConsecutiveHitsTripletOnlyEDProducer detachedQuadStepSeeds = _seedCreatorFromRegionConsecutiveHitsTripletOnlyEDProducer.clone(
def customise_common_L3Muon(process): process.itLocalReco = cms.Sequence(process.siPhase2Clusters + process.siPixelClusters + process.siPixelClusterShapeCache + process.siPixelRecHits) process.otLocalReco = cms.Sequence(process.MeasurementTrackerEvent + process.bunchSpacingProducer) #Region Definitions process.hltPhase2L3MuonPixelTracksTrackingRegions = cms.EDProducer( "CandidateSeededTrackingRegionsEDProducer", RegionPSet=cms.PSet(beamSpot=cms.InputTag("offlineBeamSpot"), deltaEta=cms.double(0.4), deltaPhi=cms.double(0.4), input=cms.InputTag("hltPhase2L3MuonCandidates"), maxNRegions=cms.int32(10000), maxNVertices=cms.int32(1), measurementTrackerName=cms.InputTag(""), mode=cms.string('BeamSpotSigma'), nSigmaZBeamSpot=cms.double(4.0), nSigmaZVertex=cms.double(3.0), originRadius=cms.double(0.2), precise=cms.bool(True), ptMin=cms.double(0.9), searchOpt=cms.bool(False), vertexCollection=cms.InputTag("notUsed"), whereToUseMeasurementTracker=cms.string('Never'), zErrorBeamSpot=cms.double(24.2), zErrorVetex=cms.double(0.2))) process.hltPhase2L3MuonInitialStepTrackingRegions = process.hltPhase2L3MuonPixelTracksTrackingRegions.clone( ) process.hltPhase2L3MuonHighPtTripletStepTrackingRegions = process.hltPhase2L3MuonPixelTracksTrackingRegions.clone( ) #Seeding layerList = [ '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', 'FPix1_pos+FPix2_pos+FPix3_pos+FPix4_pos', 'FPix1_neg+FPix2_neg+FPix3_neg+FPix4_neg', 'FPix2_pos+FPix3_pos+FPix4_pos+FPix5_pos', 'FPix2_neg+FPix3_neg+FPix4_neg+FPix5_neg', 'FPix3_pos+FPix4_pos+FPix5_pos+FPix6_pos', 'FPix3_neg+FPix4_neg+FPix5_neg+FPix6_neg', 'FPix4_pos+FPix5_pos+FPix6_pos+FPix7_pos', 'FPix4_neg+FPix5_neg+FPix6_neg+FPix7_neg', 'FPix5_pos+FPix6_pos+FPix7_pos+FPix8_pos', 'FPix5_neg+FPix6_neg+FPix7_neg+FPix8_neg' ] from RecoTracker.TkSeedingLayers.seedingLayersEDProducer_cfi import seedingLayersEDProducer #Seed Layers process.hittrack = cms.PSet(HitProducer=cms.string('siPixelRecHits'), TTRHBuilder=cms.string('WithTrackAngle')) process.hltPhase2L3MuonPixelTracksSeedLayers = seedingLayersEDProducer.clone( BPix=process.hittrack, FPix=process.hittrack, layerList=cms.vstring(layerList)) process.hltPhase2L3MuonInitialStepSeedLayers = process.hltPhase2L3MuonPixelTracksSeedLayers.clone( ) #Pixel Tracks from RecoTracker.TkHitPairs.hitPairEDProducerDefault_cfi import hitPairEDProducerDefault process.hltPhase2L3MuonPixelTracksHitDoublets = hitPairEDProducerDefault.clone( layerPairs=cms.vuint32(0, 1, 2), maxElement=cms.uint32(5000000), clusterCheck=cms.InputTag("trackerClusterCheck"), produceIntermediateHitDoublets=cms.bool(True), seedingLayers=cms.InputTag('hltPhase2L3MuonPixelTracksSeedLayers'), trackingRegions=cms.InputTag( 'hltPhase2L3MuonPixelTracksTrackingRegions'), ) from RecoPixelVertexing.PixelTriplets.caHitQuadrupletEDProducer_cfi import caHitQuadrupletEDProducer process.hltPhase2L3MuonPixelTracksHitQuadruplets = caHitQuadrupletEDProducer.clone( CAPhiCut=cms.double(0.2), CAThetaCut=cms.double(0.0012), SeedComparitorPSet=cms.PSet( ComponentName=cms.string('LowPtClusterShapeSeedComparitor'), clusterShapeCacheSrc=cms.InputTag('siPixelClusterShapeCache'), clusterShapeHitFilter=cms.string('ClusterShapeHitFilter')), doublets=cms.InputTag('hltPhase2L3MuonPixelTracksHitDoublets'), extraHitRPhitolerance=cms.double(0.032), fitFastCircle=cms.bool(True), ##TOD fitFastCircleChi2Cut=cms.bool(True), maxChi2=cms.PSet(enabled=cms.bool(True), pt1=cms.double(0.7), pt2=cms.double(2.0), value1=cms.double(200.0), value2=cms.double(50.0)), useBendingCorrection=cms.bool(True)) from RecoPixelVertexing.PixelTrackFitting.pixelTrackFilterByKinematics_cfi import pixelTrackFilterByKinematics process.hltPhase2L3MuonPixelTrackFilterByKinematics = pixelTrackFilterByKinematics.clone( ptMin=cms.double(0.9), ) process.hltPhase2L3MuonPixelTrackCleanerBySharedHits = cms.ESProducer( "PixelTrackCleanerBySharedHitsESProducer", useQuadrupletAlgo=cms.bool(False), ComponentName=cms.string( "hltPhase2L3MuonPixelTrackCleanerBySharedHits"), appendToDataLabel=cms.string("")) process.hltPhase2L3MuonPixelTrackFilterByKinematics = cms.EDProducer( "PixelTrackFilterByKinematicsProducer", nSigmaTipMaxTolerance=cms.double(0.0), chi2=cms.double(1000.0), nSigmaInvPtTolerance=cms.double(0.0), ptMin=cms.double(0.9), #previous 0.1 tipMax=cms.double(1.0)) process.hltPhase2L3MuonPixelFitterByHelixProjections = cms.EDProducer( "PixelFitterByHelixProjectionsProducer", scaleErrorsForBPix1=cms.bool(False), scaleFactor=cms.double(0.65)) process.hltPhase2L3MuonPixelTracks = cms.EDProducer( 'PixelTrackProducer', Cleaner=cms.string('hltPhase2L3MuonPixelTrackCleanerBySharedHits'), Filter=cms.InputTag('hltPhase2L3MuonPixelTrackFilterByKinematics'), Fitter=cms.InputTag('hltPhase2L3MuonPixelFitterByHelixProjections'), SeedingHitSets=cms.InputTag( 'hltPhase2L3MuonPixelTracksHitQuadruplets'), passLabel=cms.string('hltPhase2L3MuonPixelTracks'), mightGet=cms.untracked.vstring( 'RegionsSeedingHitSets_hltPhase2L3MuonPixelTracksHitQuadruplets__RECO' )) from RecoPixelVertexing.PixelVertexFinding.PixelVertexes_cfi import pixelVertices process.hltPhase2L3MuonPixelVertices = pixelVertices.clone( PVcomparer=cms.PSet(refToPSet_=cms.string( 'hltPhase2L3MuonPSetPvClusterComparerForIT')), TrackCollection=cms.InputTag('hltPhase2L3MuonPixelTracks'), ZOffset=cms.double(5.0), ZSeparation=cms.double(0.005), ) process.hltPhase2L3MuonPSetPvClusterComparerForIT = cms.PSet( track_chi2_max=cms.double(20.0), track_pt_max=cms.double(100.0), # track_pt_max = cms.double(100.0 ), track_prob_min=cms.double(-1.0), track_pt_min=cms.double(1.0)) process.hltPhase2L3MuonHighPtTripletStepTrajectoryCleanerBySharedHits = cms.ESProducer( 'TrajectoryCleanerESProducer', ComponentName=cms.string( 'hltPhase2L3MuonHighPtTripletStepTrajectoryCleanerBySharedHits'), ComponentType=cms.string('TrajectoryCleanerBySharedHits'), MissingHitPenalty=cms.double(20.0), ValidHitBonus=cms.double(5.0), allowSharedFirstHit=cms.bool(True), fractionShared=cms.double(0.16)) #Initia Step from RecoTracker.CkfPattern.GroupedCkfTrajectoryBuilder_cfi import GroupedCkfTrajectoryBuilder process.hltPhase2L3MuonInitialStepTrajectoryBuilder = GroupedCkfTrajectoryBuilder.clone( ComponentType=cms.string('GroupedCkfTrajectoryBuilder'), alwaysUseInvalidHits=cms.bool(False), estimator=cms.string('hltPhase2L3MuonInitialStepChi2Est'), inOutTrajectoryFilter=cms.PSet(refToPSet_=cms.string( 'hltPhase2L3MuonInitialStepTrajectoryFilter')), keepOriginalIfRebuildFails=cms.bool(True), maxCand=cms.int32(2), maxDPhiForLooperReconstruction=cms.double(2.0), maxPtForLooperReconstruction=cms.double(0.7), minNrOfHitsForRebuild=cms.int32(1), propagatorAlong=cms.string('PropagatorWithMaterialParabolicMf'), propagatorOpposite=cms.string( 'PropagatorWithMaterialParabolicMfOpposite'), trajectoryFilter=cms.PSet(refToPSet_=cms.string( 'hltPhase2L3MuonInitialStepTrajectoryFilter')), seedPairPenalty=cms.int32(0), minPt=cms.double(0.9), maxLostHitsFraction=cms.double(999.0), # previous 0.1 maxNumberOfHits=cms.int32(100)) process.hltPhase2L3MuonHighPtTripletStepTrajectoryBuilder = process.hltPhase2L3MuonInitialStepTrajectoryBuilder.clone( ComponentType=cms.string( 'GroupedCkfTrajectoryBuilder'), #needs to stay like this for now MeasurementTrackerName=cms.string(''), #?? TTRHBuilder=cms.string('WithTrackAngle'), alwaysUseInvalidHits=cms.bool(False), # previous True bestHitOnly=cms.bool(True), estimator=cms.string('hltPhase2L3MuonHighPtTripletStepChi2Est'), foundHitBonus=cms.double(10.0), inOutTrajectoryFilter=cms.PSet(refToPSet_=cms.string( 'hltPhase2L3MuonHighPtTripletStepTrajectoryFilterInOut') #?? ), intermediateCleaning=cms.bool(True), keepOriginalIfRebuildFails=cms.bool(False), lockHits=cms.bool(True), lostHitPenalty=cms.double(30.0), maxCand=cms.int32(2), # previous 3 maxDPhiForLooperReconstruction=cms.double(2.0), maxPtForLooperReconstruction=cms.double(0.7), minNrOfHitsForRebuild=cms.int32(5), propagatorAlong=cms.string('PropagatorWithMaterialParabolicMf' ), # previous PropagatorWithMaterial propagatorOpposite=cms.string( 'PropagatorWithMaterialParabolicMfOpposite' ), # previous PropagatorWithMaterialOpposite requireSeedHitsInRebuild=cms.bool(True), seedAs5DHit=cms.bool(False), #cmssw_11_0 trajectoryFilter=cms.PSet(refToPSet_=cms.string( 'hltPhase2L3MuonHighPtTripletStepTrajectoryFilter')), updator=cms.string('KFUpdator'), useSameTrajFilter=cms.bool(False)) from RecoTracker.MeasurementDet.Chi2ChargeMeasurementEstimator_cfi import Chi2ChargeMeasurementEstimator process.hltPhase2L3MuonInitialStepChi2Est = Chi2ChargeMeasurementEstimator.clone( ComponentName=cms.string('hltPhase2L3MuonInitialStepChi2Est'), MaxChi2=cms.double(9.0), MaxDisplacement=cms.double(0.5), MaxSagitta=cms.double(2), MinPtForHitRecoveryInGluedDet=cms.double(1000000.0), MinimalTolerance=cms.double(0.5), appendToDataLabel=cms.string(''), clusterChargeCut=cms.PSet( refToPSet_=cms.string('SiStripClusterChargeCutLoose')), nSigma=cms.double(3.0), pTChargeCutThreshold=cms.double(15.0)) process.hltPhase2L3MuonHighPtTripletStepChi2Est = process.hltPhase2L3MuonInitialStepChi2Est.clone( ComponentName=cms.string('hltPhase2L3MuonHighPtTripletStepChi2Est'), MaxChi2=cms.double(16.0), nSigma=cms.double(3), pTChargeCutThreshold=cms.double(-1), ) from TrackingTools.TrajectoryFiltering.TrajectoryFilter_cff import CkfBaseTrajectoryFilter_block process.hltPhase2L3MuonInitialStepTrajectoryFilter = CkfBaseTrajectoryFilter_block.clone( maxLostHits=cms.int32(1), constantValueForLostHitsFractionFilter=cms.double(1.0), minHitsMinPt=cms.int32(4), minPt=cms.double(0.9), minimumNumberOfHits=cms.int32(4), maxNumberOfHits=cms.int32(100), maxCCCLostHits=cms.int32(0), maxLostHitsFraction=cms.double(999), ) process.hltPhase2L3MuonHighPtTripletStepTrajectoryFilterInOut = CkfBaseTrajectoryFilter_block.clone( maxNumberOfHits=cms.int32(100), minimumNumberOfHits=cms.int32(4), nSigmaMinPt=cms.double(5.0), seedExtension=cms.int32(1), minPt=cms.double(0.9)) process.hltPhase2L3MuonHighPtTripletStepTrajectoryFilterBase = CkfBaseTrajectoryFilter_block.clone( ComponentType=cms.string('CkfBaseTrajectoryFilter'), chargeSignificance=cms.double(-1.0), constantValueForLostHitsFractionFilter=cms.double(1.0), extraNumberOfHitsBeforeTheFirstLoop=cms.int32(4), maxCCCLostHits=cms.int32(0), maxConsecLostHits=cms.int32(1), maxLostHits=cms.int32(1), maxLostHitsFraction=cms.double(999.0), minPt=cms.double(0.9), minimumNumberOfHits=cms.int32(3), seedExtension=cms.int32(1)) process.hltPhase2L3MuonHighPtTripletStepTrajectoryFilter = cms.PSet( ComponentType=cms.string('CompositeTrajectoryFilter'), filters=cms.VPSet( cms.PSet(refToPSet_=cms.string( 'hltPhase2L3MuonHighPtTripletStepTrajectoryFilterBase')), cms.PSet(refToPSet_=cms.string('ClusterShapeTrajectoryFilter')))) from RecoTracker.CkfPattern.CkfTrackCandidates_cfi import ckfTrackCandidates process.hltPhase2L3MuonInitialStepTrackCandidates = ckfTrackCandidates.clone( propagatorAlongTISE=cms.string('PropagatorWithMaterialParabolicMf'), propagatorOppositeTISE=cms.string( 'PropagatorWithMaterialParabolicMfOpposite'), SimpleMagneticField=cms.string('ParabolicMf'), TrajectoryBuilderPSet=cms.PSet(refToPSet_=cms.string( 'hltPhase2L3MuonInitialStepTrajectoryBuilder')), maxNSeeds=cms.uint32(100000), maxSeedsBeforeCleaning=cms.uint32(1000), numHitsForSeedCleaner=cms.int32(50), onlyPixelHitsForSeedCleaner=cms.bool(True), src=cms.InputTag('hltPhase2L3MuonInitialStepSeeds'), useHitsSplitting=cms.bool(False), ) process.hltPhase2L3MuonHighPtTripletStepTrackCandidates = process.hltPhase2L3MuonInitialStepTrackCandidates.clone( propagatorAlongTISE=cms.string('PropagatorWithMaterialParabolicMf'), propagatorOppositeTISE=cms.string( 'PropagatorWithMaterialParabolicMfOpposite'), TrajectoryBuilderPSet=cms.PSet(refToPSet_=cms.string( 'hltPhase2L3MuonHighPtTripletStepTrajectoryBuilder')), TrajectoryCleaner=cms.string( 'hltPhase2L3MuonHighPtTripletStepTrajectoryCleanerBySharedHits'), phase2clustersToSkip=cms.InputTag( 'hltPhase2L3MuonHighPtTripletStepClusters'), src=cms.InputTag('hltPhase2L3MuonHighPtTripletStepSeeds'), ) process.hltPhase2L3MuonHighPtTripletStepSeeds = cms.EDProducer( 'SeedCreatorFromRegionConsecutiveHitsEDProducer', MinOneOverPtError=cms.double(1), OriginTransverseErrorMultiplier=cms.double(1), SeedComparitorPSet=cms.PSet(ComponentName=cms.string('none')), SeedMomentumForBOFF=cms.double(5), TTRHBuilder=cms.string('WithTrackAngle'), forceKinematicWithRegionDirection=cms.bool(False), magneticField=cms.string(''), propagator=cms.string('PropagatorWithMaterial'), seedingHitSets=cms.InputTag( 'hltPhase2L3MuonHighPtTripletStepHitTriplets')) from RecoTracker.TrackProducer.TrackProducer_cfi import TrackProducer process.hltPhase2L3MuonInitialStepTracks = TrackProducer.clone( AlgorithmName=cms.string('initialStep'), Fitter=cms.string('FlexibleKFFittingSmoother'), TTRHBuilder=cms.string('WithTrackAngle'), src=cms.InputTag('hltPhase2L3MuonInitialStepTrackCandidates'), useHitsSplitting=cms.bool(False), ) process.hltPhase2L3MuonHighPtTripletStepTracks = process.hltPhase2L3MuonInitialStepTracks.clone( AlgorithmName=cms.string('highPtTripletStep'), src=cms.InputTag("hltPhase2L3MuonHighPtTripletStepTrackCandidates"), ) process.hltPhase2L3MuonInitialStepTrackCutClassifier = cms.EDProducer( 'TrackCutClassifier', beamspot=cms.InputTag('offlineBeamSpot'), ignoreVertices=cms.bool(False), mva=cms.PSet(dr_par=cms.PSet(d0err=cms.vdouble(0.003, 0.003, 0.003), d0err_par=cms.vdouble( 0.001, 0.001, 0.001), dr_exp=cms.vint32(4, 4, 4), dr_par1=cms.vdouble(0.8, 0.7, 0.6), dr_par2=cms.vdouble(0.6, 0.5, 0.45)), dz_par=cms.PSet(dz_exp=cms.vint32(4, 4, 4), dz_par1=cms.vdouble(0.9, 0.8, 0.7), dz_par2=cms.vdouble(0.8, 0.7, 0.55)), maxChi2=cms.vdouble(9999.0, 25.0, 16.0), maxChi2n=cms.vdouble(2.0, 1.4, 1.2), maxDr=cms.vdouble(0.5, 0.03, 3.40282346639e+38), maxDz=cms.vdouble(0.5, 0.2, 3.40282346639e+38), maxDzWrtBS=cms.vdouble(3.40282346639e+38, 24.0, 15.0), maxLostLayers=cms.vint32(3, 2, 2), min3DLayers=cms.vint32(3, 3, 3), minLayers=cms.vint32(3, 3, 3), minNVtxTrk=cms.int32(3), minNdof=cms.vdouble(1e-05, 1e-05, 1e-05), minPixelHits=cms.vint32(0, 0, 3)), qualityCuts=cms.vdouble(-0.7, 0.1, 0.7), src=cms.InputTag('hltPhase2L3MuonInitialStepTracks'), vertices=cms.InputTag('hltPhase2L3MuonPixelVertices')) process.hltPhase2L3MuonInitialStepTracksSelectionHighPurity = cms.EDProducer( 'TrackCollectionFilterCloner', copyExtras=cms.untracked.bool(True), copyTrajectories=cms.untracked.bool(False), minQuality=cms.string("highPurity"), originalMVAVals=cms.InputTag( 'hltPhase2L3MuonInitialStepTrackCutClassifier', 'MVAValues'), originalQualVals=cms.InputTag( 'hltPhase2L3MuonInitialStepTrackCutClassifier', 'QualityMasks'), originalSource=cms.InputTag('hltPhase2L3MuonInitialStepTracks') # originalSource = cms.InputTag('hltPhase2L3MuonInitialStepTracks','','RECO2') ) process.hltPhase2L3MuonHighPtTripletStepClusters = cms.EDProducer( 'TrackClusterRemoverPhase2', TrackQuality=cms.string('highPurity'), maxChi2=cms.double(9.0), mightGet=cms.optional.untracked.vstring, minNumberOfLayersWithMeasBeforeFiltering=cms.int32(0), oldClusterRemovalInfo=cms.InputTag(''), overrideTrkQuals=cms.InputTag(''), phase2OTClusters=cms.InputTag('siPhase2Clusters'), phase2pixelClusters=cms.InputTag('siPixelClusters'), trackClassifier=cms.InputTag('', 'QualityMasks'), trajectories=cms.InputTag( 'hltPhase2L3MuonInitialStepTracksSelectionHighPurity')) process.hltPhase2L3MuonHighPtTripletStepSeedLayers = cms.EDProducer( 'SeedingLayersEDProducer', BPix=cms.PSet(HitProducer=cms.string('siPixelRecHits'), TTRHBuilder=cms.string('WithTrackAngle'), skipClusters=cms.InputTag( 'hltPhase2L3MuonHighPtTripletStepClusters')), FPix=cms.PSet(HitProducer=cms.string('siPixelRecHits'), TTRHBuilder=cms.string('WithTrackAngle'), skipClusters=cms.InputTag( 'hltPhase2L3MuonHighPtTripletStepClusters')), 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', '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', 'BPix1+FPix2_pos+FPix3_pos', 'BPix1+FPix2_neg+FPix3_neg', 'FPix2_pos+FPix3_pos+FPix4_pos', 'FPix2_neg+FPix3_neg+FPix4_neg', 'FPix3_pos+FPix4_pos+FPix5_pos', 'FPix3_neg+FPix4_neg+FPix5_neg', 'FPix4_pos+FPix5_pos+FPix6_pos', 'FPix4_neg+FPix5_neg+FPix6_neg', 'FPix5_pos+FPix6_pos+FPix7_pos', 'FPix5_neg+FPix6_neg+FPix7_neg', 'FPix6_pos+FPix7_pos+FPix8_pos', 'FPix6_neg+FPix7_neg+FPix8_neg'), mightGet=cms.optional.untracked.vstring) process.hltPhase2L3MuonHighPtTripletStepHitDoublets = cms.EDProducer( 'HitPairEDProducer', clusterCheck=cms.InputTag('trackerClusterCheck'), layerPairs=cms.vuint32(0, 1), maxElement=cms.uint32(50000000), maxElementTotal=cms.uint32(50000000), mightGet=cms.optional.untracked.vstring, produceIntermediateHitDoublets=cms.bool(True), produceSeedingHitSets=cms.bool(False), seedingLayers=cms.InputTag( 'hltPhase2L3MuonHighPtTripletStepSeedLayers'), trackingRegions=cms.InputTag( 'hltPhase2L3MuonHighPtTripletStepTrackingRegions'), trackingRegionsSeedingLayers=cms.InputTag('')) process.hltPhase2L3MuonHighPtTripletStepHitTriplets = cms.EDProducer( 'CAHitTripletEDProducer', CAHardPtCut=cms.double(0.5), CAPhiCut=cms.double(0.06), CAThetaCut=cms.double(0.003), SeedComparitorPSet=cms.PSet( ComponentName=cms.string('LowPtClusterShapeSeedComparitor'), clusterShapeCacheSrc=cms.InputTag('siPixelClusterShapeCache'), clusterShapeHitFilter=cms.string('ClusterShapeHitFilter')), doublets=cms.InputTag('hltPhase2L3MuonHighPtTripletStepHitDoublets'), extraHitRPhitolerance=cms.double(0.032), maxChi2=cms.PSet(enabled=cms.bool(True), pt1=cms.double(0.8), pt2=cms.double(8), value1=cms.double(100), value2=cms.double(6)), useBendingCorrection=cms.bool(True), mightGet=cms.untracked.vstring( 'IntermediateHitDoublets_highPtTripletStepHitDoublets__RECO'), ) process.hltPhase2L3MuonHighPtTripletStepTrackCutClassifier = cms.EDProducer( 'TrackCutClassifier', beamspot=cms.InputTag('offlineBeamSpot'), ignoreVertices=cms.bool(False), mva=cms.PSet(dr_par=cms.PSet(d0err=cms.vdouble(0.003, 0.003, 0.003), d0err_par=cms.vdouble( 0.002, 0.002, 0.001), dr_exp=cms.vint32(4, 4, 4), dr_par1=cms.vdouble(0.7, 0.6, 0.6), dr_par2=cms.vdouble(0.6, 0.5, 0.45)), dz_par=cms.PSet(dz_exp=cms.vint32(4, 4, 4), dz_par1=cms.vdouble(0.8, 0.7, 0.7), dz_par2=cms.vdouble(0.6, 0.6, 0.55)), maxChi2=cms.vdouble(9999.0, 9999.0, 9999.0), maxChi2n=cms.vdouble(2.0, 1.0, 0.8), maxDr=cms.vdouble(0.5, 0.03, 3.40282346639e+38), maxDz=cms.vdouble(0.5, 0.2, 3.40282346639e+38), maxDzWrtBS=cms.vdouble(3.40282346639e+38, 24.0, 15.0), maxLostLayers=cms.vint32(3, 3, 2), min3DLayers=cms.vint32(3, 3, 4), minLayers=cms.vint32(3, 3, 4), minNVtxTrk=cms.int32(3), minNdof=cms.vdouble(1e-05, 1e-05, 1e-05), minPixelHits=cms.vint32(0, 0, 3)), qualityCuts=cms.vdouble(-0.7, 0.1, 0.7), src=cms.InputTag('hltPhase2L3MuonHighPtTripletStepTracks'), vertices=cms.InputTag('hltPhase2L3MuonPixelVertices')) process.hltPhase2L3MuonHighPtTripletStepTracksSelectionHighPurity = cms.EDProducer( 'TrackCollectionFilterCloner', copyExtras=cms.untracked.bool(True), copyTrajectories=cms.untracked.bool(False), minQuality=cms.string('highPurity'), originalMVAVals=cms.InputTag( 'hltPhase2L3MuonHighPtTripletStepTrackCutClassifier', 'MVAValues'), originalQualVals=cms.InputTag( 'hltPhase2L3MuonHighPtTripletStepTrackCutClassifier', 'QualityMasks'), originalSource=cms.InputTag('hltPhase2L3MuonHighPtTripletStepTracks') # originalSource = cms.InputTag('hltPhase2L3MuonHighPtTripletStepTracks','','RECO2') ) process.hltPhase2L3MuonTrackAlgoPriorityOrder = cms.ESProducer( 'TrackAlgoPriorityOrderESProducer', ComponentName=cms.string('hltPhase2L3MuonTrackAlgoPriorityOrder'), algoOrder=cms.vstring('initialStep', 'highPtTripletStep'), appendToDataLabel=cms.string('')) process.hltPhase2L3MuonGeneralTracks = cms.EDProducer( 'TrackListMerger', Epsilon=cms.double(-0.001), FoundHitBonus=cms.double(5.0), LostHitPenalty=cms.double(5.0), MaxNormalizedChisq=cms.double(1000.0), MinFound=cms.int32(3), MinPT=cms.double(0.9), ShareFrac=cms.double(0.19), TrackProducers=cms.VInputTag( 'hltPhase2L3MuonInitialStepTracksSelectionHighPurity', 'hltPhase2L3MuonHighPtTripletStepTracksSelectionHighPurity'), allowFirstHitShare=cms.bool(True), copyExtras=cms.untracked.bool(True), copyMVA=cms.bool(False), hasSelector=cms.vint32(0, 0), indivShareFrac=cms.vdouble(1.0, 1.0), makeReKeyedSeeds=cms.untracked.bool(False), newQuality=cms.string('confirmed'), selectedTrackQuals=cms.VInputTag( cms.InputTag( 'hltPhase2L3MuonInitialStepTracksSelectionHighPurity'), cms.InputTag( 'hltPhase2L3MuonHighPtTripletStepTracksSelectionHighPurity')), setsToMerge=cms.VPSet( cms.PSet(pQual=cms.bool(True), tLists=cms.vint32(0, 1))), trackAlgoPriorityOrder=cms.string( 'hltPhase2L3MuonTrackAlgoPriorityOrder'), writeOnlyTrkQuals=cms.bool(False)) return process
clusterCheck = "", seedingLayers = "hiDetachedQuadStepSeedLayers", trackingRegions = "hiDetachedQuadStepTrackingRegions", maxElement = 50000000, produceIntermediateHitDoublets = True, layerPairs = [0,1,2] ) from RecoPixelVertexing.PixelTriplets.caHitQuadrupletEDProducer_cfi import caHitQuadrupletEDProducer as _caHitQuadrupletEDProducer hiDetachedQuadStepTracksHitQuadrupletsCA = _caHitQuadrupletEDProducer.clone( doublets = "hiDetachedQuadStepTracksHitDoubletsCA", extraHitRPhitolerance = 0.0, maxChi2 = dict( pt1 = 0.8, pt2 = 2, value1 = 500, value2 = 100, ), useBendingCorrection = True, fitFastCircle = True, fitFastCircleChi2Cut = True, CAThetaCut = 0.0011, CAPhiCut = 0, ) hiDetachedQuadStepPixelTracksFilter = hiFilter.clone( nSigmaTipMaxTolerance = 0, lipMax = 1.0, tipMax = 1.0, ptMin = 0.95, #seeding region is 0.3 ) hiDetachedQuadStepPixelTracks = cms.EDProducer("PixelTrackProducer",
fitFastCircleChi2Cut = True, SeedComparitorPSet = initialStepHitTripletsPreSplitting.SeedComparitorPSet ) from RecoTracker.TkSeedGenerator.seedCreatorFromRegionConsecutiveHitsEDProducer_cff import seedCreatorFromRegionConsecutiveHitsEDProducer as _seedCreatorFromRegionConsecutiveHitsEDProducer initialStepSeedsPreSplitting = _seedCreatorFromRegionConsecutiveHitsEDProducer.clone( seedingHitSets = "initialStepHitTripletsPreSplitting", ) from RecoPixelVertexing.PixelTriplets.caHitQuadrupletEDProducer_cfi import caHitQuadrupletEDProducer as _caHitQuadrupletEDProducer trackingPhase1.toReplaceWith(initialStepHitQuadrupletsPreSplitting, _caHitQuadrupletEDProducer.clone( doublets = "initialStepHitDoubletsPreSplitting", extraHitRPhitolerance = initialStepHitTripletsPreSplitting.extraHitRPhitolerance, SeedComparitorPSet = initialStepHitTripletsPreSplitting.SeedComparitorPSet, maxChi2 = dict( pt1 = 0.7, pt2 = 2, value1 = 200, value2 = 50, ), useBendingCorrection = True, fitFastCircle = True, fitFastCircleChi2Cut = True, CAThetaCut = 0.0012, CAPhiCut = 0.2, )) trackingPhase1QuadProp.toModify(initialStepHitTripletsPreSplitting, produceSeedingHitSets = False, produceIntermediateHitTriplets = True, ) trackingPhase1.toModify(initialStepSeedsPreSplitting, seedingHitSets = "initialStepHitQuadrupletsPreSplitting") trackingPhase1QuadProp.toModify(initialStepSeedsPreSplitting, seedingHitSets = "initialStepHitQuadrupletsPreSplitting")
1000000, # increase threshold for triplets in generation step (default: 100000) produceSeedingHitSets=True, produceIntermediateHitTriplets=True, ) from RecoPixelVertexing.PixelTriplets.caHitQuadrupletEDProducer_cfi import caHitQuadrupletEDProducer as _caHitQuadrupletEDProducer hiPixel3PrimTracksHitDoubletsCA = hiPixel3PrimTracksHitDoublets.clone( layerPairs=[0, 1, 2]) hiPixel3PrimTracksHitQuadrupletsCA = _caHitQuadrupletEDProducer.clone( doublets="hiPixel3PrimTracksHitDoubletsCA", extraHitRPhitolerance=hiPixel3PrimTracksHitTriplets.extraHitRPhitolerance, SeedComparitorPSet=hiPixel3PrimTracksHitTriplets.SeedComparitorPSet, maxChi2=dict( pt1=0.7, pt2=2, value1=200, value2=50, ), useBendingCorrection=True, fitFastCircle=True, fitFastCircleChi2Cut=True, CAThetaCut=0.0012, CAPhiCut=0.2, ) # Pixel tracks hiPixel3PrimTracks = cms.EDProducer( "PixelTrackProducer", passLabel=cms.string( 'Pixel triplet primary tracks with vertex constraint'), # Ordered Hits
def customizeHLTForPFTrackingPhaseI2017(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.9), 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.0012), CAPhiCut=cms.double(0.2), CAHardPtCut=cms.double(0), SeedComparitorPSet=cms.PSet( ComponentName=cms.string("LowPtClusterShapeSeedComparitor"), clusterShapeCacheSrc=cms.InputTag("hltSiPixelClustersCache"), clusterShapeHitFilter=cms.string('ClusterShapeHitFilter'))) process.hltPixelTracks.SeedingHitSets = "hltPixelTracksHitQuadruplets" process.HLTDoRecoPixelTracksSequence = cms.Sequence( process.hltPixelLayerQuadruplets + process.hltPixelTracksTrackingRegions + process.hltPixelTracksHitDoublets + process.hltPixelTracksHitQuadruplets + process.hltPixelTracks) 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.hltIter1PixelLayerTriplets = cms.EDProducer( "SeedingLayersEDProducer", layerList=cms.vstring('BPix1+BPix2+BPix3', 'BPix1+BPix2+FPix1_pos', 'BPix1+BPix2+FPix1_neg', 'BPix1+FPix1_pos+FPix2_pos', 'BPix1+FPix1_neg+FPix2_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("hltIter1ClustersRefRemoval"), 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("hltIter1ClustersRefRemoval"), hitErrorRPhi=cms.double(0.0027)), TIB=cms.PSet()) process.HLTIter1PSetTrajectoryFilterIT = cms.PSet( ComponentType=cms.string('CkfBaseTrajectoryFilter'), chargeSignificance=cms.double(-1.0), constantValueForLostHitsFractionFilter=cms.double(2.0), extraNumberOfHitsBeforeTheFirstLoop=cms.int32(4), maxCCCLostHits=cms.int32(0), # offline (2), maxConsecLostHits=cms.int32(1), maxLostHits=cms.int32(1), # offline (999), maxLostHitsFraction=cms.double(0.1), maxNumberOfHits=cms.int32(100), minGoodStripCharge=cms.PSet( refToPSet_=cms.string("HLTSiStripClusterChargeCutNone")), minHitsMinPt=cms.int32(3), minNumberOfHitsForLoopers=cms.int32(13), minNumberOfHitsPerLoop=cms.int32(4), minPt=cms.double(0.2), minimumNumberOfHits=cms.int32(4), # 3 online nSigmaMinPt=cms.double(5.0), pixelSeedExtension=cms.bool(True), seedExtension=cms.int32(1), seedPairPenalty=cms.int32(0), strictSeedExtension=cms.bool(True)) process.HLTIter1PSetTrajectoryFilterInOutIT = cms.PSet( ComponentType=cms.string('CkfBaseTrajectoryFilter'), chargeSignificance=cms.double(-1.0), constantValueForLostHitsFractionFilter=cms.double(2.0), extraNumberOfHitsBeforeTheFirstLoop=cms.int32(4), maxCCCLostHits=cms.int32(0), # offline (2), maxConsecLostHits=cms.int32(1), maxLostHits=cms.int32(1), # offline (999), maxLostHitsFraction=cms.double(0.1), maxNumberOfHits=cms.int32(100), minGoodStripCharge=cms.PSet( refToPSet_=cms.string("HLTSiStripClusterChargeCutNone")), minHitsMinPt=cms.int32(3), minNumberOfHitsForLoopers=cms.int32(13), minNumberOfHitsPerLoop=cms.int32(4), minPt=cms.double(0.2), minimumNumberOfHits=cms.int32(4), # 3 online nSigmaMinPt=cms.double(5.0), pixelSeedExtension=cms.bool(True), seedExtension=cms.int32(1), seedPairPenalty=cms.int32(0), strictSeedExtension=cms.bool(True)) process.HLTIter1PSetTrajectoryBuilderIT = cms.PSet( inOutTrajectoryFilter=cms.PSet( refToPSet_=cms.string('HLTIter1PSetTrajectoryFilterInOutIT')), 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( False) # new ! other iteration should have it set to True ) process.HLTIterativeTrackingIteration1 = cms.Sequence( process.hltIter1ClustersRefRemoval + process.hltIter1MaskedMeasurementTrackerEvent + process.hltIter1PixelLayerTriplets + process.hltIter1PFlowPixelTrackingRegions + process.hltIter1PFlowPixelClusterCheck + process.hltIter1PFlowPixelHitDoublets + process.hltIter1PFlowPixelHitTriplets + 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', 'BPix1+BPix2+FPix1_pos', 'BPix1+BPix2+FPix1_neg', 'BPix1+FPix1_pos+FPix2_pos', 'BPix1+FPix1_neg+FPix2_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()) from RecoPixelVertexing.PixelTriplets.pixelTripletHLTEDProducer_cfi import pixelTripletHLTEDProducer as _pixelTripletHLTEDProducer process.hltIter2PFlowPixelHitDoublets.seedingLayers = "hltIter2PixelLayerTriplets" process.hltIter2PFlowPixelHitDoublets.produceIntermediateHitDoublets = True process.hltIter2PFlowPixelHitDoublets.produceSeedingHitSets = False process.hltIter2PFlowPixelHitDoublets.seedingLayers = "hltIter2PixelLayerTriplets" process.hltIter2PFlowPixelHitTriplets = _pixelTripletHLTEDProducer.clone( doublets="hltIter2PFlowPixelHitDoublets", useBending=cms.bool(True), useFixedPreFiltering=cms.bool(False), maxElement=cms.uint32(100000), phiPreFiltering=cms.double(0.3), extraHitRPhitolerance=cms.double(0.032), useMultScattering=cms.bool(True), extraHitRZtolerance=cms.double(0.037), SeedComparitorPSet=cms.PSet(ComponentName=cms.string("none")), produceSeedingHitSets=True, ) 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 process.hltIter2PFlowPixelSeeds = _seedCreatorFromRegionConsecutiveHitsTripletOnlyEDProducer.clone( seedingHitSets="hltIter2PFlowPixelHitTriplets") _copy(process.HLTSeedFromConsecutiveHitsTripletOnlyCreator, process.hltIter2PFlowPixelSeeds, skip=["ComponentName"]) 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) # Need to operate on Paths as well... for seqs in [process.sequences_(), process.paths_()]: for seqName, seq in seqs.iteritems(): from FWCore.ParameterSet.SequenceTypes import ModuleNodeVisitor l = list() v = ModuleNodeVisitor(l) seq.visit(v) if process.hltPixelTracks in l and not process.hltPixelLayerQuadruplets in l: seq.remove( process.hltPixelLayerTriplets ) # note that this module does not necessarily exist in sequence 'seq', if it doesn't, it does not get removed index = seq.index(process.hltPixelTracksHitDoublets) seq.insert(index, process.hltPixelLayerQuadruplets) index = seq.index(process.hltPixelTracksHitTriplets) seq.remove(process.hltPixelTracksHitTriplets) seq.insert(index, process.hltPixelTracksHitQuadruplets) # Remove entirely to avoid warning from the early deleter del process.hltPixelTracksHitTriplets return process
maxElement = 1000000, # increase threshold for triplets in generation step (default: 100000) produceSeedingHitSets = True, produceIntermediateHitTriplets = True, ) from RecoPixelVertexing.PixelTriplets.caHitQuadrupletEDProducer_cfi import caHitQuadrupletEDProducer as _caHitQuadrupletEDProducer hiPixel3PrimTracksHitDoubletsCA = hiPixel3PrimTracksHitDoublets.clone() hiPixel3PrimTracksHitDoubletsCA.layerPairs = [0,1,2] hiPixel3PrimTracksHitQuadrupletsCA = _caHitQuadrupletEDProducer.clone( doublets = "hiPixel3PrimTracksHitDoubletsCA", extraHitRPhitolerance = hiPixel3PrimTracksHitTriplets.extraHitRPhitolerance, SeedComparitorPSet = hiPixel3PrimTracksHitTriplets.SeedComparitorPSet, maxChi2 = dict( pt1 = 0.7, pt2 = 2, value1 = 200, value2 = 50, ), useBendingCorrection = True, fitFastCircle = True, fitFastCircleChi2Cut = True, CAThetaCut = 0.0012, CAPhiCut = 0.2, ) # Pixel tracks hiPixel3PrimTracks = cms.EDProducer("PixelTrackProducer", passLabel = cms.string('Pixel triplet primary tracks with vertex constraint'), # Ordered Hits SeedingHitSets = cms.InputTag("hiPixel3PrimTracksHitTriplets"),
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
enabled = True, ), useBendingCorrection = True, fitFastCircle = True, fitFastCircleChi2Cut = True, SeedComparitorPSet = lowPtQuadStepHitTriplets.SeedComparitorPSet, ) from RecoPixelVertexing.PixelTriplets.caHitQuadrupletEDProducer_cfi import caHitQuadrupletEDProducer as _caHitQuadrupletEDProducer trackingPhase1.toModify(lowPtQuadStepHitDoublets, layerPairs = [0,1,2]) # layer pairs (0,1), (1,2), (2,3) trackingPhase1.toReplaceWith(lowPtQuadStepHitQuadruplets, _caHitQuadrupletEDProducer.clone( doublets = "lowPtQuadStepHitDoublets", extraHitRPhitolerance = lowPtQuadStepHitTriplets.extraHitRPhitolerance, SeedComparitorPSet = lowPtQuadStepHitTriplets.SeedComparitorPSet, maxChi2 = dict( pt1 = 0.7, pt2 = 2, value1 = 1000, value2 = 150, ), useBendingCorrection = True, fitFastCircle = True, fitFastCircleChi2Cut = True, CAThetaCut = 0.0017, CAPhiCut = 0.3, )) from RecoPixelVertexing.PixelTriplets.pixelQuadrupletMergerEDProducer_cfi import pixelQuadrupletMergerEDProducer as _pixelQuadrupletMergerEDProducer from RecoPixelVertexing.PixelTriplets.quadrupletseedmerging_cff import * _lowPtQuadStepHitQuadrupletsMerging = _pixelQuadrupletMergerEDProducer.clone( triplets = "lowPtQuadStepHitTriplets", layerList = dict(refToPSet_ = cms.string("PixelSeedMergerQuadruplets")), ) from RecoTracker.TkSeedGenerator.seedCreatorFromRegionConsecutiveHitsEDProducer_cff import seedCreatorFromRegionConsecutiveHitsEDProducer as _seedCreatorFromRegionConsecutiveHitsEDProducer lowPtQuadStepSeeds = _seedCreatorFromRegionConsecutiveHitsEDProducer.clone(
maxElement=50000000, produceIntermediateHitDoublets=True, layerPairs=[0, 1, 2]) import RecoPixelVertexing.PixelLowPtUtilities.LowPtClusterShapeSeedComparitor_cfi from RecoPixelVertexing.PixelTriplets.caHitQuadrupletEDProducer_cfi import caHitQuadrupletEDProducer as _caHitQuadrupletEDProducer hiLowPtQuadStepTracksHitQuadrupletsCA = _caHitQuadrupletEDProducer.clone( doublets="hiLowPtQuadStepTracksHitDoubletsCA", extraHitRPhitolerance=0.0, SeedComparitorPSet=RecoPixelVertexing.PixelLowPtUtilities. LowPtClusterShapeSeedComparitor_cfi.LowPtClusterShapeSeedComparitor.clone( ), maxChi2=dict( pt1=0.7, pt2=2, value1=1000, value2=150, ), useBendingCorrection=True, fitFastCircle=True, fitFastCircleChi2Cut=True, CAThetaCut=0.0017, CAPhiCut=0.3, ) hiLowPtQuadStepPixelTracksFilter = hiFilter.clone( nSigmaTipMaxTolerance=0, lipMax=1.0, tipMax=1.0, ptMin=0.4, #seeding region is 0.3 )
enabled = True, ), useBendingCorrection = True, fitFastCircle = True, fitFastCircleChi2Cut = True, SeedComparitorPSet = lowPtQuadStepHitTriplets.SeedComparitorPSet, ) from RecoPixelVertexing.PixelTriplets.caHitQuadrupletEDProducer_cfi import caHitQuadrupletEDProducer as _caHitQuadrupletEDProducer trackingPhase1.toModify(lowPtQuadStepHitDoublets, layerPairs = [0,1,2]) # layer pairs (0,1), (1,2), (2,3) trackingPhase1.toReplaceWith(lowPtQuadStepHitQuadruplets, _caHitQuadrupletEDProducer.clone( doublets = "lowPtQuadStepHitDoublets", extraHitRPhitolerance = lowPtQuadStepHitTriplets.extraHitRPhitolerance, SeedComparitorPSet = lowPtQuadStepHitTriplets.SeedComparitorPSet, maxChi2 = dict( pt1 = 0.7, pt2 = 2, value1 = 1000, value2 = 150, ), useBendingCorrection = True, fitFastCircle = True, fitFastCircleChi2Cut = True, CAThetaCut = 0.0017, CAPhiCut = 0.3, )) from RecoPixelVertexing.PixelTriplets.pixelQuadrupletMergerEDProducer_cfi import pixelQuadrupletMergerEDProducer as _pixelQuadrupletMergerEDProducer from RecoPixelVertexing.PixelTriplets.quadrupletseedmerging_cff import * _lowPtQuadStepHitQuadrupletsMerging = _pixelQuadrupletMergerEDProducer.clone( triplets = "lowPtQuadStepHitTriplets", layerList = dict(refToPSet_ = cms.string("PixelSeedMergerQuadruplets")), ) from RecoTracker.TkSeedGenerator.seedCreatorFromRegionConsecutiveHitsEDProducer_cff import seedCreatorFromRegionConsecutiveHitsEDProducer as _seedCreatorFromRegionConsecutiveHitsEDProducer lowPtQuadStepSeeds = _seedCreatorFromRegionConsecutiveHitsEDProducer.clone(
trackingRegions="detachedQuadStepTrackingRegions", layerPairs=[0, 1, 2], # layer pairs (0,1), (1,2), (2,3), maxElement=0, produceIntermediateHitDoublets=True, ) from RecoPixelVertexing.PixelTriplets.caHitQuadrupletEDProducer_cfi import caHitQuadrupletEDProducer as _caHitQuadrupletEDProducer from RecoPixelVertexing.PixelTriplets.pixelTripletLargeTipEDProducer_cfi import pixelTripletLargeTipEDProducer as _pixelTripletLargeTipEDProducer from RecoPixelVertexing.PixelLowPtUtilities.ClusterShapeHitFilterESProducer_cfi import * detachedQuadStepHitQuadruplets = _caHitQuadrupletEDProducer.clone( doublets="detachedQuadStepHitDoublets", extraHitRPhitolerance=_pixelTripletLargeTipEDProducer. extraHitRPhitolerance, maxChi2=dict( pt1=0.8, pt2=2, value1=500, value2=100, ), useBendingCorrection=True, fitFastCircle=True, fitFastCircleChi2Cut=True, CAThetaCut=0.0011, CAPhiCut=0, ) highBetaStar_2018.toModify(detachedQuadStepHitQuadruplets, CAThetaCut=0.0022, CAPhiCut=0.1) from RecoTracker.TkSeedGenerator.seedCreatorFromRegionConsecutiveHitsTripletOnlyEDProducer_cff import seedCreatorFromRegionConsecutiveHitsTripletOnlyEDProducer as _seedCreatorFromRegionConsecutiveHitsTripletOnlyEDProducer detachedQuadStepSeeds = _seedCreatorFromRegionConsecutiveHitsTripletOnlyEDProducer.clone( seedingHitSets="detachedQuadStepHitQuadruplets", SeedComparitorPSet=
doublets = "initialStepHitDoublets", produceSeedingHitSets = True, SeedComparitorPSet = RecoPixelVertexing.PixelLowPtUtilities.LowPtClusterShapeSeedComparitor_cfi.LowPtClusterShapeSeedComparitor.clone() ) from RecoTracker.TkSeedGenerator.seedCreatorFromRegionConsecutiveHitsEDProducer_cff import seedCreatorFromRegionConsecutiveHitsEDProducer as _seedCreatorFromRegionConsecutiveHitsEDProducer initialStepSeeds = _seedCreatorFromRegionConsecutiveHitsEDProducer.clone( seedingHitSets = "initialStepHitTriplets", ) from RecoPixelVertexing.PixelTriplets.caHitQuadrupletEDProducer_cfi import caHitQuadrupletEDProducer as _caHitQuadrupletEDProducer _initialStepCAHitQuadruplets = _caHitQuadrupletEDProducer.clone( doublets = "initialStepHitDoublets", extraHitRPhitolerance = initialStepHitTriplets.extraHitRPhitolerance, SeedComparitorPSet = initialStepHitTriplets.SeedComparitorPSet, maxChi2 = dict( pt1 = 0.7, pt2 = 2, value1 = 200, value2 = 50, ), useBendingCorrection = True, fitFastCircle = True, fitFastCircleChi2Cut = True, CAThetaCut = 0.0012, CAPhiCut = 0.2, ) highBetaStar_2018.toModify(_initialStepCAHitQuadruplets, CAThetaCut = 0.0024, CAPhiCut = 0.4 ) initialStepHitQuadruplets = _initialStepCAHitQuadruplets.clone() trackingPhase1.toModify(initialStepHitDoublets, layerPairs = [0,1,2]) # layer pairs (0,1), (1,2), (2,3) trackingPhase2PU140.toModify(initialStepHitDoublets, layerPairs = [0,1,2]) # layer pairs (0,1), (1,2), (2,3)
produceSeedingHitSets=True, SeedComparitorPSet=RecoPixelVertexing.PixelLowPtUtilities. LowPtClusterShapeSeedComparitor_cfi.LowPtClusterShapeSeedComparitor.clone( )) from RecoTracker.TkSeedGenerator.seedCreatorFromRegionConsecutiveHitsEDProducer_cff import seedCreatorFromRegionConsecutiveHitsEDProducer as _seedCreatorFromRegionConsecutiveHitsEDProducer initialStepSeeds = _seedCreatorFromRegionConsecutiveHitsEDProducer.clone( seedingHitSets="initialStepHitTriplets", ) from RecoPixelVertexing.PixelTriplets.caHitQuadrupletEDProducer_cfi import caHitQuadrupletEDProducer as _caHitQuadrupletEDProducer _initialStepCAHitQuadruplets = _caHitQuadrupletEDProducer.clone( doublets="initialStepHitDoublets", extraHitRPhitolerance=initialStepHitTriplets.extraHitRPhitolerance, SeedComparitorPSet=initialStepHitTriplets.SeedComparitorPSet, maxChi2=dict( pt1=0.7, pt2=2, value1=200, value2=50, ), useBendingCorrection=True, fitFastCircle=True, fitFastCircleChi2Cut=True, CAThetaCut=0.0012, CAPhiCut=0.2, ) highBetaStar_2018.toModify(_initialStepCAHitQuadruplets, CAThetaCut=0.0024, CAPhiCut=0.4) initialStepHitQuadruplets = _initialStepCAHitQuadruplets.clone() trackingPhase1.toModify(initialStepHitDoublets, layerPairs=[0, 1, 2]) # layer pairs (0,1), (1,2), (2,3)
fitFastCircleChi2Cut = True, SeedComparitorPSet = initialStepHitTripletsPreSplitting.SeedComparitorPSet ) from RecoTracker.TkSeedGenerator.seedCreatorFromRegionConsecutiveHitsEDProducer_cff import seedCreatorFromRegionConsecutiveHitsEDProducer as _seedCreatorFromRegionConsecutiveHitsEDProducer initialStepSeedsPreSplitting = _seedCreatorFromRegionConsecutiveHitsEDProducer.clone( seedingHitSets = "initialStepHitTripletsPreSplitting", ) from RecoPixelVertexing.PixelTriplets.caHitQuadrupletEDProducer_cfi import caHitQuadrupletEDProducer as _caHitQuadrupletEDProducer trackingPhase1.toReplaceWith(initialStepHitQuadrupletsPreSplitting, _caHitQuadrupletEDProducer.clone( doublets = "initialStepHitDoubletsPreSplitting", extraHitRPhitolerance = initialStepHitTripletsPreSplitting.extraHitRPhitolerance, SeedComparitorPSet = initialStepHitTripletsPreSplitting.SeedComparitorPSet, maxChi2 = dict( pt1 = 0.7, pt2 = 2, value1 = 200, value2 = 50, ), useBendingCorrection = True, fitFastCircle = True, fitFastCircleChi2Cut = True, CAThetaCut = 0.0012, CAPhiCut = 0.2, )) trackingPhase1QuadProp.toModify(initialStepHitTripletsPreSplitting, produceSeedingHitSets = False, produceIntermediateHitTriplets = True, ) trackingPhase1.toModify(initialStepSeedsPreSplitting, seedingHitSets = "initialStepHitQuadrupletsPreSplitting") trackingPhase1QuadProp.toModify(initialStepSeedsPreSplitting, seedingHitSets = "initialStepHitQuadrupletsPreSplitting")