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")
