IterativeTracking/python/PixelPairStep_cff.py

0001 import FWCore.ParameterSet.Config as cms
0002 from Configuration.Eras.Modifier_tracker_apv_vfp30_2016_cff import tracker_apv_vfp30_2016 as _tracker_apv_vfp30_2016
0003 import RecoTracker.IterativeTracking.iterativeTkConfig as _cfg
0004 from Configuration.Eras.Modifier_fastSim_cff import fastSim
0005
0006 # for dnn classifier
0007 from Configuration.ProcessModifiers.trackdnn_cff import trackdnn
0008 from RecoTracker.IterativeTracking.dnnQualityCuts import qualityCutDictionary
0009
0010 # for no-loopers
0011 from Configuration.ProcessModifiers.trackingNoLoopers_cff import trackingNoLoopers
0012
0013 # NEW CLUSTERS (remove previously used clusters)
0014 pixelPairStepClusters = _cfg.clusterRemoverForIter('PixelPairStep')
0015 for _eraName, _postfix, _era in _cfg.nonDefaultEras():
0016     _era.toReplaceWith(pixelPairStepClusters, _cfg.clusterRemoverForIter('PixelPairStep', _eraName, _postfix))
0017
0018 import RecoTracker.TkSeedingLayers.seedingLayersEDProducer_cfi as _mod
0019
0020 # SEEDING LAYERS
0021 pixelPairStepSeedLayers = _mod.seedingLayersEDProducer.clone(
0022     layerList = ['BPix1+BPix2', 'BPix1+BPix3', 'BPix2+BPix3',
0023                  'BPix1+FPix1_pos', 'BPix1+FPix1_neg',
0024                  'BPix2+FPix1_pos', 'BPix2+FPix1_neg',
0025                  'FPix1_pos+FPix2_pos', 'FPix1_neg+FPix2_neg'],
0026     BPix = dict(
0027         TTRHBuilder = cms.string('WithTrackAngle'),
0028         HitProducer = cms.string('siPixelRecHits'),
0029         skipClusters = cms.InputTag('pixelPairStepClusters')
0030     ),
0031     FPix = dict(
0032         TTRHBuilder = cms.string('WithTrackAngle'),
0033         HitProducer = cms.string('siPixelRecHits'),
0034         skipClusters = cms.InputTag('pixelPairStepClusters')
0035     )
0036 )
0037 # layers covering the region not covered by quadruplets (so it is
0038 # just acting as backup of triplets)
0039 _layerListForPhase1 = [
0040     'BPix1+BPix2', 'BPix1+BPix3', 'BPix2+BPix3',
0041     'BPix1+FPix1_pos', 'BPix1+FPix1_neg',
0042     'BPix2+FPix1_pos', 'BPix2+FPix1_neg',
0043 ]
0044 from Configuration.Eras.Modifier_trackingPhase1_cff import trackingPhase1
0045 trackingPhase1.toModify(pixelPairStepSeedLayers, layerList = _layerListForPhase1)
0046
0047 # only layers covering the region not covered by quadruplets
0048 # (so it is just acting as backup of triplets)
0049 _layerListForPhase2 = [
0050         'BPix1+BPix2', 'BPix1+BPix3', 'BPix2+BPix3',
0051         'BPix1+FPix1_pos', 'BPix1+FPix1_neg',
0052         'BPix2+FPix1_pos', 'BPix2+FPix1_neg'
0053 ]
0054 # modifing these errors seems to make no difference
0055 from Configuration.Eras.Modifier_trackingPhase2PU140_cff import trackingPhase2PU140
0056 trackingPhase2PU140.toModify(pixelPairStepSeedLayers,
0057     layerList = _layerListForPhase2,
0058     BPix = dict(
0059         useErrorsFromParam = cms.bool(True),
0060         hitErrorRPhi = cms.double(0.0016),
0061         hitErrorRZ   = cms.double(0.0035),
0062         TTRHBuilder  = 'TTRHBuilderWithoutAngle4PixelPairs',
0063     ),
0064     FPix = dict(
0065         useErrorsFromParam = cms.bool(True),
0066         hitErrorRPhi = cms.double(0.0030),
0067         hitErrorRZ   = cms.double(0.0020),
0068         TTRHBuilder  = 'TTRHBuilderWithoutAngle4PixelPairs',
0069     )
0070 )
0071
0072 # TrackingRegion
0073 from RecoTracker.TkTrackingRegions.globalTrackingRegionWithVertices_cff import globalTrackingRegionWithVertices as _globalTrackingRegionWithVertices
0074 pixelPairStepTrackingRegions = _globalTrackingRegionWithVertices.clone(
0075     RegionPSet = dict(
0076         ptMin        = 0.6,
0077         originRadius = 0.015,
0078         fixedError   = 0.03,
0079         useMultipleScattering = True)
0080 )
0081 from Configuration.Eras.Modifier_trackingLowPU_cff import trackingLowPU
0082 trackingLowPU.toModify(pixelPairStepTrackingRegions, RegionPSet=dict(useMultipleScattering=False))
0083 _region_Phase1 = dict(
0084     useMultipleScattering = False,
0085     maxNVertices = 5,
0086 )
0087 trackingPhase1.toModify(pixelPairStepTrackingRegions, RegionPSet=_region_Phase1)
0088 trackingPhase2PU140.toModify(pixelPairStepTrackingRegions, RegionPSet=_region_Phase1)
0089 from Configuration.Eras.Modifier_highBetaStar_cff import highBetaStar
0090 highBetaStar.toModify(pixelPairStepTrackingRegions,RegionPSet = dict(
0091      ptMin        = 0.05,
0092      originRadius = 0.2,
0093      fixedError   = 4.
0094 ))
0095 from Configuration.Eras.Modifier_run3_upc_cff import run3_upc
0096 (highBetaStar & run3_upc).toModify(pixelPairStepTrackingRegions,RegionPSet = dict(originRadius = 0.015))
0097 fastSim.toModify(pixelPairStepTrackingRegions, RegionPSet=dict(VertexCollection = 'firstStepPrimaryVerticesBeforeMixing'))
0098
0099 # SEEDS
0100 from RecoTracker.TkHitPairs.hitPairEDProducer_cfi import hitPairEDProducer as _hitPairEDProducer
0101 pixelPairStepHitDoublets = _hitPairEDProducer.clone(
0102     seedingLayers         = 'pixelPairStepSeedLayers',
0103     trackingRegions       = 'pixelPairStepTrackingRegions',
0104     produceSeedingHitSets = True,
0105     maxElementTotal       = 12000000,
0106 )
0107 from RecoTracker.TkSeedGenerator.seedCreatorFromRegionConsecutiveHitsEDProducer_cff import seedCreatorFromRegionConsecutiveHitsEDProducer as _seedCreatorFromRegionConsecutiveHitsEDProducer
0108 pixelPairStepSeeds = _seedCreatorFromRegionConsecutiveHitsEDProducer.clone(
0109     seedingHitSets = 'pixelPairStepHitDoublets',
0110     SeedComparitorPSet = dict(# FIXME: is this defined in any cfi that could be imported instead of copy-paste?
0111         ComponentName      = 'PixelClusterShapeSeedComparitor',
0112         FilterAtHelixStage = cms.bool(True),
0113         FilterPixelHits    = cms.bool(True),
0114         FilterStripHits    = cms.bool(False),
0115         ClusterShapeHitFilterName = cms.string('ClusterShapeHitFilter'),
0116         ClusterShapeCacheSrc = cms.InputTag('siPixelClusterShapeCache'),
0117     )
0118 )
0119
0120 # Clone for the phase1 recovery mode
0121 pixelPairStepSeedsA = pixelPairStepSeeds.clone()
0122
0123 #have to do it after making pixelPairStepSeedsA since pixelPairStepSeedsB clones A
0124 # and then modifies it
0125 import FastSimulation.Tracking.TrajectorySeedProducer_cfi
0126 fastSim.toReplaceWith(pixelPairStepSeeds,
0127                       FastSimulation.Tracking.TrajectorySeedProducer_cfi.trajectorySeedProducer.clone(
0128         trackingRegions    = 'pixelPairStepTrackingRegions',
0129         hitMasks           = cms.InputTag('pixelPairStepMasks'),
0130         seedFinderSelector = dict(layerList = pixelPairStepSeedLayers.layerList.value())
0131         )
0132 )
0133
0134 # Recovery for regions with 2 inactive layers
0135 from RecoTracker.TkTrackingRegions.pixelInactiveAreaTrackingRegionsAndSeedingLayers_cfi import pixelInactiveAreaTrackingRegionsAndSeedingLayers as _pixelInactiveAreaTrackingRegionsAndSeedingLayers
0136 pixelPairStepTrackingRegionsSeedLayersB = _pixelInactiveAreaTrackingRegionsAndSeedingLayers.clone(
0137     layerList = [
0138 # Commented ones are already included in the global seeds (A), but are
0139 # included below for completenees
0140 #
0141 #        'BPix1+BPix2',
0142 #        'BPix1+BPix3',
0143         'BPix1+BPix4',
0144 #        'BPix2+BPix3',
0145         'BPix2+BPix4',
0146         'BPix3+BPix4',
0147 #        'BPix1+FPix1_pos'    , 'BPix1+FPix1_neg',
0148         'BPix1+FPix2_pos'    , 'BPix1+FPix2_neg',
0149         'BPix1+FPix3_pos'    , 'BPix1+FPix3_neg',
0150 #        'BPix2+FPix1_pos'    , 'BPix2+FPix1_neg',
0151         'BPix2+FPix2_pos'    , 'BPix2+FPix2_neg',
0152         'BPix3+FPix1_pos'    , 'BPix3+FPix1_neg',
0153         'FPix1_pos+FPix2_pos', 'FPix1_neg+FPix2_neg',
0154         'FPix1_pos+FPix3_pos', 'FPix1_neg+FPix3_neg',
0155         'FPix2_pos+FPix3_pos', 'FPix2_neg+FPix3_neg',
0156     ],
0157     BPix = dict(
0158         TTRHBuilder  = cms.string('WithTrackAngle'),
0159         HitProducer  = cms.string('siPixelRecHits'),
0160         skipClusters = cms.InputTag('pixelPairStepClusters')
0161     ),
0162     FPix = dict(
0163         TTRHBuilder  = cms.string('WithTrackAngle'),
0164         HitProducer  = cms.string('siPixelRecHits'),
0165         skipClusters = cms.InputTag('pixelPairStepClusters')
0166     ),
0167     RegionPSet = dict(
0168         ptMin         = 0.6,
0169         originRadius  = 0.015,
0170         operationMode = 'VerticesFixed',
0171         zErrorVertex  = 0.03,
0172         maxNVertices  = 5,
0173     ),
0174     ignoreSingleFPixPanelModules = True,
0175 )
0176 highBetaStar.toModify(pixelPairStepTrackingRegionsSeedLayersB,RegionPSet = dict(
0177      ptMin        = 0.05,
0178      originRadius = 0.2,
0179 ))
0180 #include commented lines from above in pp_on_XY eras; global seeds (A) are not used in this era b/c timing
0181 from Configuration.Eras.Modifier_pp_on_XeXe_2017_cff import pp_on_XeXe_2017
0182 from Configuration.ProcessModifiers.pp_on_AA_cff import pp_on_AA
0183 (pp_on_XeXe_2017 | pp_on_AA).toModify(pixelPairStepTrackingRegionsSeedLayersB, layerList = [
0184       'BPix1+BPix2', 'BPix1+BPix3', 'BPix1+BPix4', 'BPix2+BPix3', 'BPix2+BPix4','BPix3+BPix4',
0185       'BPix1+FPix1_pos'    , 'BPix1+FPix1_neg',
0186       'BPix1+FPix2_pos'    , 'BPix1+FPix2_neg',
0187       'BPix1+FPix3_pos'    , 'BPix1+FPix3_neg',
0188       'BPix2+FPix1_pos'    , 'BPix2+FPix1_neg',
0189       'BPix2+FPix2_pos'    , 'BPix2+FPix2_neg',
0190       'BPix3+FPix1_pos'    , 'BPix3+FPix1_neg',
0191       'FPix1_pos+FPix2_pos', 'FPix1_neg+FPix2_neg',
0192       'FPix1_pos+FPix3_pos', 'FPix1_neg+FPix3_neg',
0193       'FPix2_pos+FPix3_pos', 'FPix2_neg+FPix3_neg'
0194    ])
0195
0196 pixelPairStepHitDoubletsB = pixelPairStepHitDoublets.clone(
0197     seedingLayers   = '',
0198     trackingRegions = '',
0199     trackingRegionsSeedingLayers = 'pixelPairStepTrackingRegionsSeedLayersB',
0200 )
0201 pixelPairStepSeedsB = pixelPairStepSeedsA.clone(seedingHitSets = 'pixelPairStepHitDoubletsB')
0202
0203
0204 # Merge
0205 from RecoTracker.TkSeedGenerator.GlobalCombinedSeeds_cfi import globalCombinedSeeds as _globalCombinedSeeds
0206 _pixelPairStepSeedsMerged = _globalCombinedSeeds.clone(
0207     seedCollections = ['pixelPairStepSeedsA', 'pixelPairStepSeedsB'],
0208 )
0209 (trackingPhase1 & ~fastSim).toReplaceWith(pixelPairStepSeeds, _pixelPairStepSeedsMerged)
0210
0211 #only use region B for pp_on_XY era for timing reasons
0212 (pp_on_XeXe_2017 | pp_on_AA).toReplaceWith(pixelPairStepSeeds, pixelPairStepSeedsB)
0213
0214 # QUALITY CUTS DURING TRACK BUILDING
0215 import TrackingTools.TrajectoryFiltering.TrajectoryFilter_cff
0216 _pixelPairStepTrajectoryFilterBase = TrackingTools.TrajectoryFiltering.TrajectoryFilter_cff.CkfBaseTrajectoryFilter_block.clone(
0217     minimumNumberOfHits = 3,
0218     minPt               = 0.1,
0219 )
0220 pixelPairStepTrajectoryFilterBase = _pixelPairStepTrajectoryFilterBase.clone(
0221     seedPairPenalty = 0,
0222     maxCCCLostHits  = 0,
0223     minGoodStripCharge = dict(refToPSet_ = 'SiStripClusterChargeCutLoose')
0224 )
0225 from Configuration.Eras.Modifier_tracker_apv_vfp30_2016_cff import tracker_apv_vfp30_2016
0226 _tracker_apv_vfp30_2016.toModify(pixelPairStepTrajectoryFilterBase, maxCCCLostHits = 2)
0227 trackingLowPU.toReplaceWith(pixelPairStepTrajectoryFilterBase, _pixelPairStepTrajectoryFilterBase)
0228 trackingPhase1.toModify(pixelPairStepTrajectoryFilterBase, minimumNumberOfHits = 4)
0229 trackingPhase2PU140.toReplaceWith(pixelPairStepTrajectoryFilterBase, _pixelPairStepTrajectoryFilterBase.clone(
0230     minimumNumberOfHits = 4,
0231     maxLostHitsFraction = 1./10.,
0232     constantValueForLostHitsFractionFilter = 0.701,
0233 ))
0234 highBetaStar.toModify(pixelPairStepTrajectoryFilterBase, minPt = 0.05)
0235
0236 import RecoTracker.PixelLowPtUtilities.StripSubClusterShapeTrajectoryFilter_cfi
0237 pixelPairStepTrajectoryFilterShape = RecoTracker.PixelLowPtUtilities.StripSubClusterShapeTrajectoryFilter_cfi.StripSubClusterShapeTrajectoryFilterTIX12.clone()
0238 pixelPairStepTrajectoryFilter = cms.PSet(
0239     ComponentType = cms.string('CompositeTrajectoryFilter'),
0240     filters = cms.VPSet(
0241         cms.PSet( refToPSet_ = cms.string('pixelPairStepTrajectoryFilterBase')),
0242     #    cms.PSet( refToPSet_ = cms.string('pixelPairStepTrajectoryFilterShape'))
0243     ),
0244 )
0245 from RecoTracker.PixelLowPtUtilities.ClusterShapeTrajectoryFilter_cfi import *
0246 trackingPhase2PU140.toModify(pixelPairStepTrajectoryFilter,
0247     filters = pixelPairStepTrajectoryFilter.filters + [cms.PSet(refToPSet_ = cms.string('ClusterShapeTrajectoryFilter'))]
0248 )
0249
0250
0251
0252 pixelPairStepTrajectoryFilterInOut = pixelPairStepTrajectoryFilterBase.clone(
0253     minimumNumberOfHits = 4,
0254     seedExtension       = 1,
0255     strictSeedExtension = False, # allow inactive
0256     pixelSeedExtension  = False,
0257 )
0258
0259
0260
0261 import RecoTracker.MeasurementDet.Chi2ChargeMeasurementEstimator_cfi
0262 pixelPairStepChi2Est = RecoTracker.MeasurementDet.Chi2ChargeMeasurementEstimator_cfi.Chi2ChargeMeasurementEstimator.clone(
0263     ComponentName    = 'pixelPairStepChi2Est',
0264     nSigma           = 3.0,
0265     MaxChi2          = 9.0,
0266     clusterChargeCut = dict(refToPSet_ = 'SiStripClusterChargeCutLoose'),
0267     pTChargeCutThreshold = 15.
0268 )
0269 _tracker_apv_vfp30_2016.toModify(pixelPairStepChi2Est,
0270     clusterChargeCut = dict(refToPSet_ = 'SiStripClusterChargeCutTiny')
0271 )
0272 trackingLowPU.toModify(pixelPairStepChi2Est,
0273     clusterChargeCut = dict(refToPSet_ = 'SiStripClusterChargeCutTiny'),
0274 )
0275 highBetaStar.toModify(pixelPairStepChi2Est, MaxChi2 = 30)
0276
0277 # TRACK BUILDING
0278 import RecoTracker.CkfPattern.GroupedCkfTrajectoryBuilder_cfi
0279 pixelPairStepTrajectoryBuilder = RecoTracker.CkfPattern.GroupedCkfTrajectoryBuilder_cfi.GroupedCkfTrajectoryBuilderIterativeDefault.clone(
0280     trajectoryFilter       = dict(refToPSet_ = 'pixelPairStepTrajectoryFilter'),
0281     maxCand                = 3,
0282     estimator              = 'pixelPairStepChi2Est',
0283     maxDPhiForLooperReconstruction = 2.0,
0284     maxPtForLooperReconstruction = 0.7,
0285 )
0286 trackingNoLoopers.toModify(pixelPairStepTrajectoryBuilder,
0287                            maxPtForLooperReconstruction = 0.0)
0288 trackingLowPU.toModify(pixelPairStepTrajectoryBuilder, maxCand = 2)
0289 _seedExtension = dict(
0290     inOutTrajectoryFilter = dict(refToPSet_ = 'pixelPairStepTrajectoryFilterInOut'),
0291     useSameTrajFilter     = False,
0292 )
0293 trackingPhase1.toModify(pixelPairStepTrajectoryBuilder, **_seedExtension)
0294 trackingPhase2PU140.toModify(pixelPairStepTrajectoryBuilder, **_seedExtension)
0295
0296
0297
0298
0299 # MAKING OF TRACK CANDIDATES
0300 import RecoTracker.CkfPattern.CkfTrackCandidates_cfi
0301 # Give handle for CKF for HI
0302 _pixelPairStepTrackCandidatesCkf = RecoTracker.CkfPattern.CkfTrackCandidates_cfi.ckfTrackCandidatesIterativeDefault.clone(
0303     src = 'pixelPairStepSeeds',
0304     clustersToSkip = 'pixelPairStepClusters',
0305     TrajectoryBuilderPSet = dict(refToPSet_ = 'pixelPairStepTrajectoryBuilder'),
0306     ### these two parameters are relevant only for the CachingSeedCleanerBySharedInput
0307     numHitsForSeedCleaner = 50,
0308     onlyPixelHitsForSeedCleaner = True,
0309 )
0310 pixelPairStepTrackCandidates = _pixelPairStepTrackCandidatesCkf.clone()
0311
0312 from Configuration.ProcessModifiers.trackingMkFitPixelPairStep_cff import trackingMkFitPixelPairStep
0313 import RecoTracker.MkFit.mkFitSeedConverter_cfi as _mkFitSeedConverter_cfi
0314 import RecoTracker.MkFit.mkFitIterationConfigESProducer_cfi as _mkFitIterationConfigESProducer_cfi
0315 import RecoTracker.MkFit.mkFitProducer_cfi as _mkFitProducer_cfi
0316 import RecoTracker.MkFit.mkFitOutputConverter_cfi as _mkFitOutputConverter_cfi
0317 pixelPairStepTrackCandidatesMkFitSeeds = _mkFitSeedConverter_cfi.mkFitSeedConverter.clone(
0318     seeds = 'pixelPairStepSeeds',
0319 )
0320 pixelPairStepTrackCandidatesMkFitConfig = _mkFitIterationConfigESProducer_cfi.mkFitIterationConfigESProducer.clone(
0321     ComponentName = 'pixelPairStepTrackCandidatesMkFitConfig',
0322     config = 'RecoTracker/MkFit/data/mkfit-phase1-pixelPairStep.json',
0323 )
0324 pixelPairStepTrackCandidatesMkFit = _mkFitProducer_cfi.mkFitProducer.clone(
0325     seeds = 'pixelPairStepTrackCandidatesMkFitSeeds',
0326     config = ('', 'pixelPairStepTrackCandidatesMkFitConfig'),
0327     clustersToSkip = 'pixelPairStepClusters',
0328 )
0329 trackingMkFitPixelPairStep.toReplaceWith(pixelPairStepTrackCandidates, _mkFitOutputConverter_cfi.mkFitOutputConverter.clone(
0330     seeds = 'pixelPairStepSeeds',
0331     mkFitSeeds = 'pixelPairStepTrackCandidatesMkFitSeeds',
0332     tracks = 'pixelPairStepTrackCandidatesMkFit',
0333 ))
0334
0335 trackingPhase2PU140.toModify(pixelPairStepTrackCandidates,
0336     clustersToSkip = '',
0337     phase2clustersToSkip = 'pixelPairStepClusters',
0338     TrajectoryCleaner = 'pixelPairStepTrajectoryCleanerBySharedHits'
0339 )
0340 import FastSimulation.Tracking.TrackCandidateProducer_cfi
0341 fastSim.toReplaceWith(pixelPairStepTrackCandidates,
0342                       FastSimulation.Tracking.TrackCandidateProducer_cfi.trackCandidateProducer.clone(
0343         src = 'pixelPairStepSeeds',
0344         MinNumberOfCrossedLayers = 2, # ?
0345         hitMasks = cms.InputTag('pixelPairStepMasks')
0346         )
0347 )
0348
0349 from TrackingTools.TrajectoryCleaning.TrajectoryCleanerBySharedHits_cfi import trajectoryCleanerBySharedHits as _trajectoryCleanerBySharedHits
0350 pixelPairStepTrajectoryCleanerBySharedHits = _trajectoryCleanerBySharedHits.clone(
0351     ComponentName       = 'pixelPairStepTrajectoryCleanerBySharedHits',
0352     fractionShared      = 0.095,
0353     allowSharedFirstHit = True
0354 )
0355 trackingPhase2PU140.toModify(pixelPairStepTrajectoryCleanerBySharedHits, fractionShared = 0.09)
0356
0357 # TRACK FITTING
0358 import RecoTracker.TrackProducer.TrackProducerIterativeDefault_cfi
0359 pixelPairStepTracks = RecoTracker.TrackProducer.TrackProducerIterativeDefault_cfi.TrackProducerIterativeDefault.clone(
0360     AlgorithmName = 'pixelPairStep',
0361     src           = 'pixelPairStepTrackCandidates',
0362     Fitter        = 'FlexibleKFFittingSmoother'
0363 )
0364 fastSim.toModify(pixelPairStepTracks, TTRHBuilder = 'WithoutRefit')
0365
0366 from Configuration.Eras.Modifier_phase2_timing_layer_cff import phase2_timing_layer
0367 phase2_timing_layer.toModify(pixelPairStepTracks, TrajectoryInEvent = True)
0368
0369 # Final selection
0370 from RecoTracker.FinalTrackSelectors.TrackMVAClassifierPrompt_cfi import *
0371 pixelPairStep =  TrackMVAClassifierPrompt.clone(
0372     src         = 'pixelPairStepTracks',
0373     mva         = dict(GBRForestLabel = 'MVASelectorIter2_13TeV'),
0374     qualityCuts = [-0.2,0.0,0.3]
0375 )
0376 trackingPhase1.toModify(pixelPairStep, mva=dict(GBRForestLabel = 'MVASelectorPixelPairStep_Phase1'))
0377
0378 from RecoTracker.FinalTrackSelectors.trackTfClassifier_cfi import *
0379 from RecoTracker.FinalTrackSelectors.trackSelectionTf_cfi import *
0380 from RecoTracker.FinalTrackSelectors.trackSelectionTf_CKF_cfi import *
0381 trackdnn.toReplaceWith(pixelPairStep, trackTfClassifier.clone(
0382     src='pixelPairStepTracks',
0383     qualityCuts=qualityCutDictionary.PixelPairStep.value()
0384 ))
0385
0386 highBetaStar.toModify(pixelPairStep,qualityCuts = [-0.95,0.0,0.3])
0387 pp_on_AA.toModify(pixelPairStep, qualityCuts = [0.85, 0.95, 0.98])
0388 fastSim.toModify(pixelPairStep, vertices = 'firstStepPrimaryVerticesBeforeMixing')
0389
0390 # For LowPU and Phase2PU140
0391 import RecoTracker.IterativeTracking.LowPtTripletStep_cff
0392 import RecoTracker.FinalTrackSelectors.multiTrackSelector_cfi
0393 pixelPairStepSelector = RecoTracker.FinalTrackSelectors.multiTrackSelector_cfi.multiTrackSelector.clone(
0394     src            = 'pixelPairStepTracks',
0395     useAnyMVA      = cms.bool(True),
0396     GBRForestLabel = cms.string('MVASelectorIter2'),
0397     trackSelectors = cms.VPSet(
0398         RecoTracker.FinalTrackSelectors.multiTrackSelector_cfi.looseMTS.clone(
0399             name = 'pixelPairStepLoose',
0400         ), #end of pset
0401         RecoTracker.FinalTrackSelectors.multiTrackSelector_cfi.tightMTS.clone(
0402             name = 'pixelPairStepTight',
0403             preFilterName = 'pixelPairStepLoose',
0404         ),
0405         RecoTracker.FinalTrackSelectors.multiTrackSelector_cfi.highpurityMTS.clone(
0406             name = 'QualityMasks',
0407             preFilterName = 'pixelPairStepTight',
0408         ),
0409     ),
0410     vertices = 'pixelVertices' #end of vpset
0411 ) #end of clone
0412 trackingPhase2PU140.toModify(pixelPairStepSelector,
0413     useAnyMVA      = None,
0414     GBRForestLabel = None,
0415     trackSelectors = cms.VPSet(
0416         RecoTracker.FinalTrackSelectors.multiTrackSelector_cfi.looseMTS.clone(
0417             name = 'pixelPairStepLoose',
0418             chi2n_par = 0.7,
0419             res_par = ( 0.003, 0.002 ),
0420             minNumberLayers = 3,
0421             maxNumberLostLayers = 2,
0422             minNumber3DLayers = 3,
0423             d0_par1 = ( 0.4, 4.0 ),
0424             dz_par1 = ( 0.4, 4.0 ),
0425             d0_par2 = ( 0.6, 4.0 ),
0426             dz_par2 = ( 0.45, 4.0 )
0427             ), #end of pset
0428         RecoTracker.FinalTrackSelectors.multiTrackSelector_cfi.tightMTS.clone(
0429             name = 'pixelPairStepTight',
0430             preFilterName = 'pixelPairStepLoose',
0431             chi2n_par = 0.6,
0432             res_par = ( 0.003, 0.002 ),
0433             minNumberLayers = 4,
0434             maxNumberLostLayers = 2,
0435             minNumber3DLayers = 3,
0436             d0_par1 = ( 0.35, 4.0 ),
0437             dz_par1 = ( 0.35, 4.0 ),
0438             d0_par2 = ( 0.5, 4.0 ),
0439             dz_par2 = ( 0.4, 4.0 )
0440             ),
0441         RecoTracker.FinalTrackSelectors.multiTrackSelector_cfi.highpurityMTS.clone(
0442             name = 'pixelPairStep',
0443             preFilterName = 'pixelPairStepTight',
0444 #            min_eta = -4.0, # useless, the eta distribution does not even reach |eta| = 3 (!)
0445 #            max_eta = 4.0,
0446             chi2n_par = 0.5,
0447             res_par = ( 0.003, 0.001 ),
0448             minNumberLayers = 5,
0449             maxNumberLostLayers = 2,
0450             minNumber3DLayers = 4,
0451             d0_par1 = ( 0.3, 4.0 ),
0452             dz_par1 = ( 0.3, 4.0 ),
0453             d0_par2 = ( 0.45, 4.0 ),
0454             dz_par2 = ( 0.35, 4.0 )
0455             ),
0456         ), #end of vpset
0457     vertices = 'firstStepPrimaryVertices'
0458 ) #end of clone
0459
0460 from Configuration.ProcessModifiers.vectorHits_cff import vectorHits
0461 vectorHits.toModify(pixelPairStepSelector.trackSelectors[2], minNumberLayers = 3, minNumber3DLayers = 3)
0462
0463 # Final sequence
0464 PixelPairStepTask = cms.Task(pixelPairStepClusters,
0465                          pixelPairStepSeedLayers,
0466                          pixelPairStepTrackingRegions,
0467                          pixelPairStepHitDoublets,
0468                          pixelPairStepSeeds,
0469                          pixelPairStepTrackCandidates,
0470                          pixelPairStepTracks,
0471                          pixelPairStep)
0472 PixelPairStep = cms.Sequence(PixelPairStepTask)
0473
0474 _PixelPairStepTask_trackingMkFit = PixelPairStepTask.copy()
0475 _PixelPairStepTask_trackingMkFit.add(pixelPairStepTrackCandidatesMkFitSeeds, pixelPairStepTrackCandidatesMkFit, pixelPairStepTrackCandidatesMkFit)
0476 trackingMkFitPixelPairStep.toReplaceWith(PixelPairStepTask, _PixelPairStepTask_trackingMkFit)
0477
0478 _PixelPairStepTask_LowPU_Phase2PU140 = PixelPairStepTask.copy()
0479 _PixelPairStepTask_LowPU_Phase2PU140.replace(pixelPairStep, pixelPairStepSelector)
0480 trackingLowPU.toReplaceWith(PixelPairStepTask, _PixelPairStepTask_LowPU_Phase2PU140)
0481 trackingPhase2PU140.toReplaceWith(PixelPairStepTask, _PixelPairStepTask_LowPU_Phase2PU140)
0482
0483 _PixelPairStepTask_Phase1 = PixelPairStepTask.copy()
0484 _PixelPairStepTask_pp_on_AA = PixelPairStepTask.copy()
0485 _PixelPairStepTask_Phase1.replace(pixelPairStepSeeds,cms.Task(
0486                               pixelPairStepSeedsA ,
0487                               pixelPairStepTrackingRegionsSeedLayersB,pixelPairStepHitDoubletsB,pixelPairStepSeedsB,
0488                               pixelPairStepSeeds))
0489 trackingPhase1.toReplaceWith(PixelPairStepTask, _PixelPairStepTask_Phase1)
0490
0491 _PixelPairStepTask_pp_on_AA.replace(pixelPairStepHitDoublets, cms.Task(pixelPairStepTrackingRegionsSeedLayersB,pixelPairStepHitDoubletsB))
0492 (pp_on_XeXe_2017 | pp_on_AA).toReplaceWith(PixelPairStepTask, _PixelPairStepTask_pp_on_AA)
0493
0494 #fastSim
0495 import FastSimulation.Tracking.FastTrackerRecHitMaskProducer_cfi
0496 pixelPairStepMasks = FastSimulation.Tracking.FastTrackerRecHitMaskProducer_cfi.maskProducerFromClusterRemover(pixelPairStepClusters)
0497 fastSim.toReplaceWith(PixelPairStepTask,
0498                       cms.Task(pixelPairStepMasks
0499                                    ,pixelPairStepTrackingRegions
0500                                    ,pixelPairStepSeeds
0501                                    ,pixelPairStepTrackCandidates
0502                                    ,pixelPairStepTracks
0503                                    ,pixelPairStep
0504                                    )
0505 )