muonEcalDetIds.inputCollection = "hiMuons1stStep" muIsoDepositTk.inputTags = cms.VInputTag( cms.InputTag("hiMuons1stStep:tracker")) muIsoDepositJets.inputTags = cms.VInputTag(cms.InputTag("hiMuons1stStep:jets")) muIsoDepositCalByAssociatorTowers.inputTags = cms.VInputTag( cms.InputTag("hiMuons1stStep:ecal"), cms.InputTag("hiMuons1stStep:hcal"), cms.InputTag("hiMuons1stStep:ho")) muonShowerInformation.muonCollection = "hiMuons1stStep" #don't modify somebody else's sequence, create a new one if needed #standalone muon tracking is already done... so remove standalonemuontracking from muontracking from FWCore.ParameterSet.SequenceTypes import ModuleNodeVisitor _excludes = [] _visitor = ModuleNodeVisitor(_excludes) standalonemuontracking.visit(_visitor) displacedGlobalMuonTracking.visit(_visitor) muonreco_plus_isolation_PbPbTask = muonreco_plus_isolationTask.copyAndExclude( _excludes) muonreco_plus_isolation_PbPbTask.replace(muons1stStep, hiMuons1stStep) #iso deposits are not used in HI muonreco_plus_isolation_PbPbTask.remove(muIsoDeposits_muonsTask) muonreco_plus_isolation_PbPb = cms.Sequence(muonreco_plus_isolation_PbPbTask) globalMuons.TrackerCollectionLabel = hiTracks # replace with heavy ion jet label hiMuons1stStep.JetExtractorPSet.JetCollectionLabel = cms.InputTag( "iterativeConePu5CaloJets")
def modulesInSequences(*sequences): from FWCore.ParameterSet.SequenceTypes import ModuleNodeVisitor modules = [] for sequence in sequences: sequence.visit(ModuleNodeVisitor(modules)) return modules
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
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
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')) process.hltPixelTracks.OrderedHitsFactoryPSet = cms.PSet( ComponentName=cms.string('CombinedHitQuadrupletGenerator'), GeneratorPSet=cms.PSet( extraHitRPhitolerance=cms.double(0.032), extraHitRZtolerance=cms.double(0.037), extraPhiTolerance=cms.PSet(enabled=cms.bool(True), pt1=cms.double(0.6), pt2=cms.double(1), value1=cms.double(0.15), value2=cms.double(0.1)), fitFastCircle=cms.bool(True), fitFastCircleChi2Cut=cms.bool(True), maxChi2=cms.PSet(enabled=cms.bool(True), pt1=cms.double(0.8), pt2=cms.double(2), value1=cms.double(200), value2=cms.double(100)), useBendingCorrection=cms.bool(True), SeedComparitorPSet=cms.PSet( ComponentName=cms.string("LowPtClusterShapeSeedComparitor"), clusterShapeCacheSrc=cms.InputTag("hltSiPixelClustersCache")), ComponentName=cms.string('PixelQuadrupletGenerator'), ), SeedingLayers=cms.InputTag("hltPixelLayerQuadruplets"), TripletGeneratorPSet=cms.PSet( ComponentName=cms.string('PixelTripletHLTGenerator'), SeedComparitorPSet=cms.PSet( ComponentName=cms.string('LowPtClusterShapeSeedComparitor'), clusterShapeCacheSrc=cms.InputTag("hltSiPixelClustersCache")), extraHitRPhitolerance=cms.double(0.032), extraHitRZtolerance=cms.double(0.037), maxElement=cms.uint32(1000000), phiPreFiltering=cms.double(0.3), useBending=cms.bool(True), useFixedPreFiltering=cms.bool(False), useMultScattering=cms.bool(True))) process.hltPixelTracks.RegionFactoryPSet.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.HLTDoRecoPixelTracksSequence = cms.Sequence( process.hltPixelLayerQuadruplets + 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.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()) process.hltIter2PFlowPixelSeeds.OrderedHitsFactoryPSet = cms.PSet( maxElement=cms.uint32(0), ComponentName=cms.string("StandardHitTripletGenerator"), GeneratorPSet=cms.PSet( 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), ComponentName=cms.string("PixelTripletHLTGenerator"), extraHitRZtolerance=cms.double(0.037), SeedComparitorPSet=cms.PSet(ComponentName=cms.string("none"))), SeedingLayers=cms.InputTag("hltIter2PixelLayerTriplets")) process.hltIter2PFlowPixelSeeds.SeedCreatorPSet = cms.PSet( refToPSet_=cms.string("HLTSeedFromConsecutiveHitsTripletOnlyCreator")) process.HLTIterativeTrackingIteration2 = cms.Sequence( process.hltIter2ClustersRefRemoval + process.hltIter2MaskedMeasurementTrackerEvent + process.hltIter2PixelLayerTriplets + process.hltIter2PFlowPixelSeeds + process.hltIter2PFlowCkfTrackCandidates + process.hltIter2PFlowCtfWithMaterialTracks + process.hltIter2PFlowTrackCutClassifier + process.hltIter2PFlowTrackSelectionHighPurity) for seqName in process.sequences: seq = getattr(process, seqName) 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) index = seq.index(process.hltPixelTracks) seq.insert(index, process.hltPixelLayerQuadruplets) from RecoTracker.Configuration.customiseForQuadrupletsHLTPixelTracksByCellularAutomaton import customiseForQuadrupletsHLTPixelTracksByCellularAutomaton process = customiseForQuadrupletsHLTPixelTracksByCellularAutomaton(process) return process