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
