) #fastsim import FastSimulation.Tracking.TrajectorySeedProducer_cfi _fastSim_tobTecStepSeedsTripl = FastSimulation.Tracking.TrajectorySeedProducer_cfi.trajectorySeedProducer.clone( trackingRegions="tobTecStepTrackingRegionsTripl", hitMasks=cms.InputTag("tobTecStepMasks"), ) from FastSimulation.Tracking.SeedingMigration import _hitSetProducerToFactoryPSet _fastSim_tobTecStepSeedsTripl.seedFinderSelector.MultiHitGeneratorFactory = _hitSetProducerToFactoryPSet( tobTecStepHitTripletsTripl) _fastSim_tobTecStepSeedsTripl.seedFinderSelector.MultiHitGeneratorFactory.SeedComparitorPSet = cms.PSet( ComponentName=cms.string("none")) _fastSim_tobTecStepSeedsTripl.seedFinderSelector.MultiHitGeneratorFactory.refitHits = False _fastSim_tobTecStepSeedsTripl.seedFinderSelector.layerList = tobTecStepSeedLayersTripl.layerList.value( ) fastSim.toReplaceWith(tobTecStepSeedsTripl, _fastSim_tobTecStepSeedsTripl) # PAIR SEEDING LAYERS tobTecStepSeedLayersPair = cms.EDProducer( "SeedingLayersEDProducer", layerList=cms.vstring('TOB1+TEC1_pos', 'TOB1+TEC1_neg', 'TEC1_pos+TEC2_pos', 'TEC1_neg+TEC2_neg', 'TEC2_pos+TEC3_pos', 'TEC2_neg+TEC3_neg', 'TEC3_pos+TEC4_pos', 'TEC3_neg+TEC4_neg', 'TEC4_pos+TEC5_pos', 'TEC4_neg+TEC5_neg', 'TEC5_pos+TEC6_pos', 'TEC5_neg+TEC6_neg', 'TEC6_pos+TEC7_pos', 'TEC6_neg+TEC7_neg'), TOB=cms.PSet(TTRHBuilder=cms.string('WithTrackAngle'), clusterChargeCut=cms.PSet( refToPSet_=cms.string('SiStripClusterChargeCutTight')), matchedRecHits=cms.InputTag("siStripMatchedRecHits",
# miniAOD from Validation.RecoParticleFlow.miniAODValidation_cff import * from Validation.RecoEgamma.photonMiniAODValidationSequence_cff import * from Validation.RecoEgamma.egammaValidationMiniAOD_cff import * prevalidationNoHLT = cms.Sequence( cms.SequencePlaceholder("mix") * globalPrevalidation * metPreValidSeq * jetPreValidSeq ) prevalidation = cms.Sequence( cms.SequencePlaceholder("mix") * globalPrevalidation * hltassociation * metPreValidSeq * jetPreValidSeq ) prevalidationLiteTracking = cms.Sequence( prevalidation ) prevalidationLiteTracking.replace(globalPrevalidation,globalPrevalidationLiteTracking) prevalidationMiniAOD = cms.Sequence( genParticles1 * miniAODValidationSequence * photonMiniAODValidationSequence * egammaValidationMiniAOD) _prevalidation_fastsim = prevalidation.copy() for _entry in [hltassociation]: _prevalidation_fastsim.remove(_entry) from Configuration.Eras.Modifier_fastSim_cff import fastSim fastSim.toReplaceWith(prevalidation,_prevalidation_fastsim) validationNoHLT = cms.Sequence( genvalid_all *globaldigisanalyze *globalhitsanalyze *globalrechitsanalyze *globalValidation) validationNoHLT.remove(condDataValidation) # foca d'ovatta ! validation = cms.Sequence(validationNoHLT *hltvalidation) _validation_fastsim = validation.copy() for _entry in [globaldigisanalyze,globalhitsanalyze,globalrechitsanalyze,hltvalidation]: _validation_fastsim.remove(_entry) from Configuration.Eras.Modifier_fastSim_cff import fastSim
PtThresholdSavePreId=cms.untracked.double(1.0), Min_dr=cms.double(0.2)) # This customization will be removed once we get the templates for # phase2 pixel from Configuration.Eras.Modifier_phase2_tracker_cff import phase2_tracker phase2_tracker.toModify(trackerDrivenElectronSeeds, TTRHBuilder='WithTrackAngle') # FIXME from Configuration.Eras.Modifier_pp_on_XeXe_2017_cff import pp_on_XeXe_2017 from Configuration.Eras.Modifier_pp_on_AA_2018_cff import pp_on_AA_2018 for e in [pp_on_XeXe_2017, pp_on_AA_2018]: e.toModify(trackerDrivenElectronSeeds, MinPt=5.0) # tracker driven electron seeds depend on the generalTracks trajectory collection # However, in FastSim jobs, trajectories are only available for the 'before mixing' track collections # Therefore we let the seeds depend on the 'before mixing' generalTracks collection # TODO: investigate whether the dependence on trajectories can be avoided from Configuration.Eras.Modifier_fastSim_cff import fastSim trackerDrivenElectronSeedsTmp = trackerDrivenElectronSeeds.clone( TkColList=cms.VInputTag(cms.InputTag("generalTracksBeforeMixing"))) import FastSimulation.Tracking.ElectronSeedTrackRefFix_cfi _fastSim_trackerDrivenElectronSeeds = FastSimulation.Tracking.ElectronSeedTrackRefFix_cfi.fixedTrackerDrivenElectronSeeds.clone( ) _fastSim_trackerDrivenElectronSeeds.seedCollection.setModuleLabel( "trackerDrivenElectronSeedsTmp"), _fastSim_trackerDrivenElectronSeeds.idCollection = cms.VInputTag( "trackerDrivenElectronSeedsTmp:preid", ) fastSim.toReplaceWith(trackerDrivenElectronSeeds, _fastSim_trackerDrivenElectronSeeds)
# Muon Isolation sequence from RecoMuon.MuonIsolationProducers.muIsolation_cff import * # ---------------------------------------------------- # ################## Make the sequences ################## # ---------------------------------------------------- # from Configuration.Eras.Modifier_fastSim_cff import fastSim # Muon Tracking sequence standalonemuontracking = cms.Sequence( standAloneMuonSeeds * standAloneMuons * refittedStandAloneMuons * displacedMuonSeeds * displacedStandAloneMuons) # not commisoned and not relevant in FastSim (?): fastSim.toReplaceWith( standalonemuontracking, standalonemuontracking.copyAndExclude( [displacedMuonSeeds, displacedStandAloneMuons])) displacedGlobalMuonTracking = cms.Sequence(iterDisplcedTracking * displacedGlobalMuons) globalmuontracking = cms.Sequence(globalMuons * tevMuons * displacedGlobalMuonTracking) # not commisoned and not relevant in FastSim (?): fastSim.toReplaceWith( globalmuontracking, globalmuontracking.copyAndExclude([displacedGlobalMuonTracking])) muontracking = cms.Sequence(standalonemuontracking * globalmuontracking) # Muon Reconstruction muonreco = cms.Sequence(muontracking * muonIdProducerSequence) # Muon Reconstruction plus Isolation
tobTecStepSeedsTripl = _seedCreatorFromRegionConsecutiveHitsTripletOnlyEDProducer.clone(#empirically better than 'SeedFromConsecutiveHitsTripletOnlyCreator' seedingHitSets = "tobTecStepHitTripletsTripl", SeedComparitorPSet = _tobTecStepSeedComparitorPSet, ) #fastsim import FastSimulation.Tracking.TrajectorySeedProducer_cfi _fastSim_tobTecStepSeedsTripl = FastSimulation.Tracking.TrajectorySeedProducer_cfi.trajectorySeedProducer.clone( trackingRegions = "tobTecStepTrackingRegionsTripl", hitMasks = cms.InputTag("tobTecStepMasks"), ) from FastSimulation.Tracking.SeedingMigration import _hitSetProducerToFactoryPSet _fastSim_tobTecStepSeedsTripl.seedFinderSelector.MultiHitGeneratorFactory = _hitSetProducerToFactoryPSet(tobTecStepHitTripletsTripl) _fastSim_tobTecStepSeedsTripl.seedFinderSelector.MultiHitGeneratorFactory.SeedComparitorPSet=cms.PSet( ComponentName = cms.string( "none" ) ) _fastSim_tobTecStepSeedsTripl.seedFinderSelector.MultiHitGeneratorFactory.refitHits = False _fastSim_tobTecStepSeedsTripl.seedFinderSelector.layerList = tobTecStepSeedLayersTripl.layerList.value() fastSim.toReplaceWith(tobTecStepSeedsTripl,_fastSim_tobTecStepSeedsTripl) # PAIR SEEDING LAYERS tobTecStepSeedLayersPair = cms.EDProducer("SeedingLayersEDProducer", layerList = cms.vstring('TOB1+TEC1_pos','TOB1+TEC1_neg', 'TEC1_pos+TEC2_pos','TEC1_neg+TEC2_neg', 'TEC2_pos+TEC3_pos','TEC2_neg+TEC3_neg', 'TEC3_pos+TEC4_pos','TEC3_neg+TEC4_neg', 'TEC4_pos+TEC5_pos','TEC4_neg+TEC5_neg', 'TEC5_pos+TEC6_pos','TEC5_neg+TEC6_neg', 'TEC6_pos+TEC7_pos','TEC6_neg+TEC7_neg'), TOB = cms.PSet( TTRHBuilder = cms.string('WithTrackAngle'), clusterChargeCut = cms.PSet(refToPSet_ = cms.string('SiStripClusterChargeCutTight')), matchedRecHits = cms.InputTag("siStripMatchedRecHits","matchedRecHit"), skipClusters = cms.InputTag('tobTecStepClusters') ),
mixCollectionValidation + JetValidation + METValidation + egammaValidation + pfJetValidationSequence + pfMETValidationSequence + pfElectronValidationSequence + pfJetResValidationSequence + pfMuonValidationSequence + pfClusterValidationSequence + rpcRecHitValidation_step + dtLocalRecoValidation_no2D + pfTauRunDQMValidation + bTagPlotsMCbcl + L1Validator + bdHadronTrackValidationSeq) from Configuration.Eras.Modifier_fastSim_cff import fastSim fastSim.toReplaceWith( globalValidation, globalValidation.copyAndExclude([ # fastsim has no tracker digis and different tracker rechit and simhit structure => skipp trackerHitsValidation, trackerDigisValidation, trackerRecHitsValidation, trackingRecHitsValid, # the following depends on crossing frame of ecal simhits, which is a bit hard to implement in the fastsim workflow # besides: is this cross frame doing something, or is it a relic from the past? ecalDigisValidationSequence, ecalRecHitsValidationSequence ])) #lite tracking validator to be used in the Validation matrix #lite validation globalValidationLiteTracking = cms.Sequence(globalValidation) #lite pre-validation globalPrevalidationLiteTracking = cms.Sequence(globalPrevalidation) globalPrevalidationLiteTracking.replace(tracksValidation, tracksValidationLite)
_run3_muonlocalreco += gemLocalReco _phase2_muonlocalreco = _run3_muonlocalreco.copy() _phase2_muonlocalreco += me0LocalReco from Configuration.Eras.Modifier_run2_GEM_2017_cff import run2_GEM_2017 run2_GEM_2017.toReplaceWith( muonlocalreco , _run2_GEM_2017_muonlocalreco ) from Configuration.Eras.Modifier_run3_GEM_cff import run3_GEM run3_GEM.toReplaceWith( muonlocalreco , _run3_muonlocalreco ) from Configuration.Eras.Modifier_phase2_muon_cff import phase2_muon phase2_muon.toReplaceWith( muonlocalreco , _phase2_muonlocalreco ) # RPC New Readout Validation from Configuration.Eras.Modifier_stage2L1Trigger_2017_cff import stage2L1Trigger_2017 _rpc_NewReadoutVal_muonlocalreco_with_2DSegments = muonlocalreco_with_2DSegments.copy() _rpc_NewReadoutVal_muonlocalreco = muonlocalreco.copy() _rpc_NewReadoutVal_muonlocalrecoT0Seg = muonlocalrecoT0Seg.copy() _rpc_NewReadoutVal_muonlocalreco_with_2DSegments += rpcNewRecHits _rpc_NewReadoutVal_muonlocalreco += rpcNewRecHits _rpc_NewReadoutVal_muonlocalrecoT0Seg += rpcNewRecHits stage2L1Trigger_2017.toReplaceWith(muonlocalreco_with_2DSegments, _rpc_NewReadoutVal_muonlocalreco_with_2DSegments) stage2L1Trigger_2017.toReplaceWith(muonlocalreco, _rpc_NewReadoutVal_muonlocalreco) stage2L1Trigger_2017.toReplaceWith(muonlocalrecoT0Seg, _rpc_NewReadoutVal_muonlocalrecoT0Seg) from Configuration.Eras.Modifier_fastSim_cff import fastSim fastSim.toReplaceWith(muonlocalreco_with_2DSegments, muonlocalreco_with_2DSegments.copyAndExclude([rpcNewRecHits])) fastSim.toReplaceWith(muonlocalreco, muonlocalreco.copyAndExclude([rpcNewRecHits])) fastSim.toReplaceWith(muonlocalrecoT0Seg, muonlocalrecoT0Seg.copyAndExclude([rpcNewRecHits]))
"Accumulation" ), #used only for discriminators : estimators='productDiscrim' or 'btagDiscrim' or 'smirnovDiscrim' or 'asmirnovDiscrim' UseCalibration=cms.bool(False), calibrationPath=cms.string(""), ) from Configuration.Eras.Modifier_fastSim_cff import fastSim # explicit python dependency import FastSimulation.SimplifiedGeometryPropagator.FastTrackDeDxProducer_cfi # do this before defining dedxPixelHarmonic2 so it automatically comes out right fastSim.toReplaceWith( dedxHarmonic2, FastSimulation.SimplifiedGeometryPropagator.FastTrackDeDxProducer_cfi. FastTrackDeDxProducer.clone( ShapeTest=False, simHit2RecHitMap="fastMatchedTrackerRecHits:simHit2RecHitMap", simHits="fastSimProducer:TrackerHits", )) dedxPixelHarmonic2 = dedxHarmonic2.clone(UseStrip=False, UsePixel=True) dedxPixelAndStripHarmonic2T085 = dedxHarmonic2.clone( UseStrip=True, UsePixel=True, estimator='genericTruncated', fraction=-0.15, # Drop the lowest 15% of hits exponent=-2.0, # Harmonic02 ) dedxTruncated40 = dedxHarmonic2.clone(estimator='truncated')
+ pfJetResValidationSequence + pfMuonValidationSequence + rpcRecHitValidation_step + dtLocalRecoValidation_no2D + pfTauRunDQMValidation + bTagPlotsMCbcl + L1Validator + bdHadronTrackValidationSeq ) from Configuration.Eras.Modifier_fastSim_cff import fastSim fastSim.toReplaceWith(globalValidation, globalValidation.copyAndExclude([ # fastsim has no tracker digis and different tracker rechit and simhit structure => skipp trackerHitsValidation, trackerDigisValidation, trackerRecHitsValidation, trackingRecHitsValid, # the following depends on crossing frame of ecal simhits, which is a bit hard to implement in the fastsim workflow # besides: is this cross frame doing something, or is it a relic from the past? ecalDigisValidationSequence, ecalRecHitsValidationSequence ])) #lite tracking validator to be used in the Validation matrix #lite validation globalValidationLiteTracking = cms.Sequence(globalValidation) #lite pre-validation globalPrevalidationLiteTracking = cms.Sequence(globalPrevalidation) globalPrevalidationLiteTracking.replace(tracksValidation, tracksValidationLite) from Validation.Configuration.gemSimValid_cff import * from Validation.Configuration.me0SimValid_cff import *
SeedComparitorPSet = RecoPixelVertexing.PixelLowPtUtilities.LowPtClusterShapeSeedComparitor_cfi.LowPtClusterShapeSeedComparitor.clone() ) from RecoTracker.TkSeedGenerator.seedCreatorFromRegionConsecutiveHitsEDProducer_cff import seedCreatorFromRegionConsecutiveHitsEDProducer as _seedCreatorFromRegionConsecutiveHitsEDProducer lowPtTripletStepSeeds = _seedCreatorFromRegionConsecutiveHitsEDProducer.clone( seedingHitSets = "lowPtTripletStepHitTriplets", ) import FastSimulation.Tracking.TrajectorySeedProducer_cfi _fastSim_lowPtTripletStepSeeds = FastSimulation.Tracking.TrajectorySeedProducer_cfi.trajectorySeedProducer.clone( layerList = lowPtTripletStepSeedLayers.layerList.value(), trackingRegions = "lowPtTripletStepTrackingRegions", hitMasks = cms.InputTag("lowPtTripletStepMasks"), ) from FastSimulation.Tracking.SeedingMigration import _hitSetProducerToFactoryPSet _fastSim_lowPtTripletStepSeeds.seedFinderSelector.pixelTripletGeneratorFactory = _hitSetProducerToFactoryPSet(lowPtTripletStepHitTriplets) _fastSim_lowPtTripletStepSeeds.seedFinderSelector.pixelTripletGeneratorFactory.SeedComparitorPSet.ComponentName = "none" fastSim.toReplaceWith(lowPtTripletStepSeeds,_fastSim_lowPtTripletStepSeeds) from RecoPixelVertexing.PixelTriplets.caHitTripletEDProducer_cfi import caHitTripletEDProducer as _caHitTripletEDProducer trackingPhase1.toModify(lowPtTripletStepHitDoublets, layerPairs = [0,1]) # layer pairs (0,1), (1,2) trackingPhase1.toReplaceWith(lowPtTripletStepHitTriplets, _caHitTripletEDProducer.clone( doublets = "lowPtTripletStepHitDoublets", extraHitRPhitolerance = lowPtTripletStepHitTriplets.extraHitRPhitolerance, SeedComparitorPSet = lowPtTripletStepHitTriplets.SeedComparitorPSet, maxChi2 = dict( pt1 = 0.8, pt2 = 2, value1 = 70 , value2 = 8, ), useBendingCorrection = True, CAThetaCut = 0.002, CAPhiCut = 0.05, ))
prevalidationMiniAOD = cms.Sequence( genParticles1 * miniAODValidationSequence * photonMiniAODValidationSequence * egammaValidationMiniAOD) validation = cms.Sequence(cms.SequencePlaceholder("mix") +genvalid_all *globaldigisanalyze *globalhitsanalyze *globalrechitsanalyze *globalValidation *hltvalidation) _validation_fastsim = validation.copy() for _entry in [globaldigisanalyze,globalhitsanalyze,globalrechitsanalyze]: _validation_fastsim.remove(_entry) from Configuration.Eras.Modifier_fastSim_cff import fastSim fastSim.toReplaceWith(validation,_validation_fastsim) validationLiteTracking = cms.Sequence( validation ) validationLiteTracking.replace(globalValidation,globalValidationLiteTracking) validationLiteTracking.remove(condDataValidation) validationMiniAOD = cms.Sequence(type0PFMEtCorrectionPFCandToVertexAssociationForValidationMiniAOD * JetValidationMiniAOD * METValidationMiniAOD) prevalidation_preprod = cms.Sequence( preprodPrevalidation ) validation_preprod = cms.Sequence( genvalid_all +trackingTruthValid +tracksValidation +METRelValSequence +recoMuonValidation
import FWCore.ParameterSet.Config as cms # Name : RecoMET_BeamHaloId_cff.py # Original Author : R. Remington, UF # Date : 11.11.2009 # Notes : Information to Id/reconstruct any halo that may be in the event from RecoMET.METProducers.CSCHaloData_cfi import * from RecoMET.METProducers.EcalHaloData_cfi import * from RecoMET.METProducers.HcalHaloData_cfi import * from RecoMET.METProducers.GlobalHaloData_cfi import * from RecoMET.METProducers.BeamHaloSummary_cfi import * #from L1Trigger.Configuration.L1RawToDigi_cff import * BeamHaloIdTask = cms.Task(CSCHaloData,EcalHaloData,HcalHaloData,GlobalHaloData,BeamHaloSummary) BeamHaloId = cms.Sequence(BeamHaloIdTask) from Configuration.Eras.Modifier_fastSim_cff import fastSim # CSCHaloData depends on cosmic muons, not available in fastsim # GlobalHaloData and BeamHaloSummary depend on CSCHaloData fastSim.toReplaceWith(BeamHaloIdTask, BeamHaloIdTask.copyAndExclude([CSCHaloData,GlobalHaloData,BeamHaloSummary])) # Needs FEVT content #BeamHaloIdWithGtRecord = cms.Sequence(gtDigis*l1GtRecord*CSCHaloData*EcalHaloData*HcalHaloData*GlobalHaloData*BeamHaloSummary)
from TrackingTools.GsfTracking.GsfElectronGsfFit_cff import * lowPtGsfEleGsfTracks = electronGsfTracks.clone() lowPtGsfEleGsfTracks.Fitter = 'lowPtGsfEleFittingSmoother' lowPtGsfEleGsfTracks.src = 'lowPtGsfEleCkfTrackCandidates' # GsfPFRecTracks from RecoParticleFlow.PFTracking.pfTrackElec_cfi import * lowPtGsfElePfGsfTracks = pfTrackElec.clone() lowPtGsfElePfGsfTracks.GsfTrackModuleLabel = 'lowPtGsfEleGsfTracks' lowPtGsfElePfGsfTracks.PFRecTrackLabel = 'lowPtGsfElePfTracks' lowPtGsfElePfGsfTracks.applyGsfTrackCleaning = False lowPtGsfElePfGsfTracks.useFifthStepForTrackerDrivenGsf = True # Full sequence lowPtGsfElectronTask = cms.Task(lowPtGsfElePfTracks, lowPtGsfElectronSeeds, lowPtGsfEleCkfTrackCandidates, lowPtGsfEleGsfTracks, lowPtGsfElePfGsfTracks) lowPtGsfElectronSequence = cms.Sequence(lowPtGsfElectronTask) # Modifiers for FastSim from Configuration.Eras.Modifier_fastSim_cff import fastSim _fastSim_lowPtGsfElectronTask = lowPtGsfElectronTask.copy() _fastSim_lowPtGsfElectronTask.replace(lowPtGsfElectronSeeds, cms.Task(lowPtGsfElectronSeedsTmp,lowPtGsfElectronSeeds)) _fastSim_lowPtGsfElectronTask.replace(lowPtGsfEleCkfTrackCandidates, fastLowPtGsfTkfTrackCandidates) fastSim.toReplaceWith(lowPtGsfElectronTask, _fastSim_lowPtGsfElectronTask) fastSim.toModify(lowPtGsfElePfTracks,TkColList = ['generalTracksBeforeMixing']) fastSim.toModify(lowPtGsfEleGsfTracks,src = cms.InputTag("fastLowPtGsfTkfTrackCandidates"))
ClusterThreshold = cms.double(0.5), UsePreShower =cms.bool(False), PreIdLabel = cms.string('preid'), ProducePreId = cms.untracked.bool(True), PtThresholdSavePreId = cms.untracked.double(1.0), Min_dr = cms.double(0.2) ) # This customization will be removed once we get the templates for # phase2 pixel from Configuration.Eras.Modifier_phase2_tracker_cff import phase2_tracker phase2_tracker.toModify(trackerDrivenElectronSeeds, TTRHBuilder = 'WithTrackAngle') # FIXME from Configuration.Eras.Modifier_pp_on_XeXe_2017_cff import pp_on_XeXe_2017 from Configuration.Eras.Modifier_pp_on_AA_2018_cff import pp_on_AA_2018 for e in [pp_on_XeXe_2017, pp_on_AA_2018]: e.toModify(trackerDrivenElectronSeeds, MinPt = 5.0) # tracker driven electron seeds depend on the generalTracks trajectory collection # However, in FastSim jobs, trajectories are only available for the 'before mixing' track collections # Therefore we let the seeds depend on the 'before mixing' generalTracks collection # TODO: investigate whether the dependence on trajectories can be avoided from Configuration.Eras.Modifier_fastSim_cff import fastSim trackerDrivenElectronSeedsTmp = trackerDrivenElectronSeeds.clone(TkColList = cms.VInputTag(cms.InputTag("generalTracksBeforeMixing"))) import FastSimulation.Tracking.ElectronSeedTrackRefFix_cfi _fastSim_trackerDrivenElectronSeeds = FastSimulation.Tracking.ElectronSeedTrackRefFix_cfi.fixedTrackerDrivenElectronSeeds.clone() _fastSim_trackerDrivenElectronSeeds.seedCollection.setModuleLabel("trackerDrivenElectronSeedsTmp"), _fastSim_trackerDrivenElectronSeeds.idCollection = cms.VInputTag("trackerDrivenElectronSeedsTmp:preid",) fastSim.toReplaceWith(trackerDrivenElectronSeeds,_fastSim_trackerDrivenElectronSeeds)
#For FastSim phase1 tracking import FastSimulation.Tracking.TrajectorySeedProducer_cfi from FastSimulation.Tracking.SeedingMigration import _hitSetProducerToFactoryPSet _fastSim_highPtTripletStepSeeds = FastSimulation.Tracking.TrajectorySeedProducer_cfi.trajectorySeedProducer.clone( trackingRegions = "highPtTripletStepTrackingRegions", hitMasks = cms.InputTag("highPtTripletStepMasks"), seedFinderSelector = dict( CAHitTripletGeneratorFactory = _hitSetProducerToFactoryPSet(highPtTripletStepHitTriplets), layerList = highPtTripletStepSeedLayers.layerList.value(), #new parameters required for phase1 seeding BPix = dict(TTRHBuilder = 'WithoutRefit', HitProducer = 'TrackingRecHitProducer',), FPix = dict(TTRHBuilder = 'WithoutRefit', HitProducer = 'TrackingRecHitProducer',), layerPairs = highPtTripletStepHitDoublets.layerPairs.value() )) _fastSim_highPtTripletStepSeeds.seedFinderSelector.CAHitTripletGeneratorFactory.SeedComparitorPSet.ComponentName = "none" fastSim.toReplaceWith(highPtTripletStepSeeds,_fastSim_highPtTripletStepSeeds) # QUALITY CUTS DURING TRACK BUILDING import TrackingTools.TrajectoryFiltering.TrajectoryFilter_cff as _TrajectoryFilter_cff _highPtTripletStepTrajectoryFilterBase = _TrajectoryFilter_cff.CkfBaseTrajectoryFilter_block.clone( minimumNumberOfHits = 3, minPt = 0.2, ) highPtTripletStepTrajectoryFilterBase = _highPtTripletStepTrajectoryFilterBase.clone( maxCCCLostHits = 0, minGoodStripCharge = dict(refToPSet_ = 'SiStripClusterChargeCutLoose') ) trackingPhase2PU140.toReplaceWith(highPtTripletStepTrajectoryFilterBase, _highPtTripletStepTrajectoryFilterBase) for e in [pp_on_XeXe_2017, pp_on_AA_2018]: e.toModify(highPtTripletStepTrajectoryFilterBase, minPt=0.7)
cms.Task(primaryVertexWithBSAssociationCleaned, slimmingTask.copy())) run2_miniAOD_pp_on_AA_103X.toReplaceWith( slimmingTask, cms.Task(pfEGammaToCandidateRemapperCleaned, slimmingTask.copy())) from RecoHI.HiTracking.miniAODVertexRecovery_cff import offlinePrimaryVerticesRecovery, offlineSlimmedPrimaryVerticesRecovery pp_on_AA.toReplaceWith( slimmingTask, cms.Task(slimmingTask.copy(), offlinePrimaryVerticesRecovery, offlineSlimmedPrimaryVerticesRecovery)) from Configuration.Eras.Modifier_fastSim_cff import fastSim fastSim.toReplaceWith( slimmingTask, slimmingTask.copyAndExclude( [slimmedDisplacedMuons, slimmedDisplacedMuonTrackExtras])) from Configuration.Eras.Modifier_phase2_timing_cff import phase2_timing _phase2_timing_slimmingTask = cms.Task(slimmingTask.copy(), offlineSlimmedPrimaryVertices4D) phase2_timing.toReplaceWith(slimmingTask, _phase2_timing_slimmingTask) from PhysicsTools.PatAlgos.slimming.patPhotonDRNCorrector_cfi import patPhotonsDRN from Configuration.ProcessModifiers.photonDRN_cff import _photonDRN _photonDRN.toReplaceWith(slimmingTask, cms.Task(slimmingTask.copy(), patPhotonsDRN))
import FastSimulation.Tracking.TrajectorySeedProducer_cfi from FastSimulation.Tracking.SeedingMigration import _hitSetProducerToFactoryPSet _fastSim_lowPtQuadStepSeeds = FastSimulation.Tracking.TrajectorySeedProducer_cfi.trajectorySeedProducer.clone( trackingRegions = "lowPtQuadStepTrackingRegions", hitMasks = cms.InputTag("lowPtQuadStepMasks"), seedFinderSelector = dict( CAHitQuadrupletGeneratorFactory = _hitSetProducerToFactoryPSet(lowPtQuadStepHitQuadruplets).clone( SeedComparitorPSet = dict(ComponentName = "none")), layerList = lowPtQuadStepSeedLayers.layerList.value(), #new parameters required for phase1 seeding BPix = dict(TTRHBuilder = 'WithoutRefit', HitProducer = 'TrackingRecHitProducer',), FPix = dict(TTRHBuilder = 'WithoutRefit', HitProducer = 'TrackingRecHitProducer',), layerPairs = lowPtQuadStepHitDoublets.layerPairs.value() )) _fastSim_lowPtQuadStepSeeds.seedFinderSelector.CAHitQuadrupletGeneratorFactory.SeedComparitorPSet.ComponentName = "none" fastSim.toReplaceWith(lowPtQuadStepSeeds,_fastSim_lowPtQuadStepSeeds) # QUALITY CUTS DURING TRACK BUILDING import TrackingTools.TrajectoryFiltering.TrajectoryFilter_cff as _TrajectoryFilter_cff _lowPtQuadStepTrajectoryFilterBase = _TrajectoryFilter_cff.CkfBaseTrajectoryFilter_block.clone( minimumNumberOfHits = 3, minPt = 0.075, ) lowPtQuadStepTrajectoryFilterBase = _lowPtQuadStepTrajectoryFilterBase.clone( maxCCCLostHits = 0, minGoodStripCharge = dict(refToPSet_ = 'SiStripClusterChargeCutLoose') ) trackingPhase2PU140.toReplaceWith(lowPtQuadStepTrajectoryFilterBase, _lowPtQuadStepTrajectoryFilterBase) for e in [pp_on_XeXe_2017, pp_on_AA_2018]: e.toModify(lowPtQuadStepTrajectoryFilterBase, minPt=0.3)
), ) trackingLowPU.toModify(_mixedTripletStepSeedsACommon, SeedComparitorPSet = dict(ClusterShapeHitFilterName = 'ClusterShapeHitFilter') ) mixedTripletStepSeedsA = _mixedTripletStepSeedsACommon.clone() import FastSimulation.Tracking.TrajectorySeedProducer_cfi from FastSimulation.Tracking.SeedingMigration import _hitSetProducerToFactoryPSet _fastSim_mixedTripletStepSeedsA = FastSimulation.Tracking.TrajectorySeedProducer_cfi.trajectorySeedProducer.clone( layerList = mixedTripletStepSeedLayersA.layerList.value(), trackingRegions = "mixedTripletStepTrackingRegionsA", hitMasks = cms.InputTag("mixedTripletStepMasks"), seedFinderSelector = dict(pixelTripletGeneratorFactory = _hitSetProducerToFactoryPSet(mixedTripletStepHitTripletsA)) ) fastSim.toReplaceWith(mixedTripletStepSeedsA,_fastSim_mixedTripletStepSeedsA) # SEEDING LAYERS mixedTripletStepSeedLayersB = cms.EDProducer("SeedingLayersEDProducer", layerList = cms.vstring('BPix2+BPix3+TIB1'), BPix = cms.PSet( TTRHBuilder = cms.string('WithTrackAngle'), HitProducer = cms.string('siPixelRecHits'), skipClusters = cms.InputTag('mixedTripletStepClusters') ), TIB = cms.PSet( matchedRecHits = cms.InputTag("siStripMatchedRecHits","matchedRecHit"), TTRHBuilder = cms.string('WithTrackAngle'), clusterChargeCut = cms.PSet(refToPSet_ = cms.string('SiStripClusterChargeCutTight')), skipClusters = cms.InputTag('mixedTripletStepClusters') )
ecalPacker.labelEBSRFlags = "simEcalDigis:ebSrFlags" ecalPacker.labelEESRFlags = "simEcalDigis:eeSrFlags" premix_stage1.toModify(hcalRawDatauHTR, premix = True) from Configuration.Eras.Modifier_run3_common_cff import run3_common run3_common.toReplaceWith(DigiToRaw, DigiToRaw.copyAndExclude([castorRawData])) #if we don't have hcal raw data from Configuration.Eras.Modifier_hcalSkipPacker_cff import hcalSkipPacker hcalSkipPacker.toReplaceWith(DigiToRaw, DigiToRaw.copyAndExclude([hcalRawData])) # Remove siPixelRawData until we have phase1 pixel digis from Configuration.Eras.Modifier_phase2_tracker_cff import phase2_tracker phase2_tracker.toReplaceWith(DigiToRaw, DigiToRaw.copyAndExclude([siPixelRawData])) # FIXME # GEM settings _gem_DigiToRaw = DigiToRaw.copy() _gem_DigiToRaw.insert(-2,gemPacker) from Configuration.Eras.Modifier_run2_GEM_2017_cff import run2_GEM_2017 run2_GEM_2017.toReplaceWith(DigiToRaw, _gem_DigiToRaw) from Configuration.Eras.Modifier_run3_GEM_cff import run3_GEM run3_GEM.toReplaceWith(DigiToRaw, _gem_DigiToRaw) from Configuration.Eras.Modifier_phase2_muon_cff import phase2_muon phase2_muon.toReplaceWith(DigiToRaw, DigiToRaw.copyAndExclude([rpcpacker])) from Configuration.Eras.Modifier_fastSim_cff import fastSim fastSim.toReplaceWith(DigiToRaw, DigiToRaw.copyAndExclude([siPixelRawData,SiStripDigiToRaw,castorRawData]))
) trackingLowPU.toModify( _mixedTripletStepSeedsACommon, SeedComparitorPSet=dict(ClusterShapeHitFilterName='ClusterShapeHitFilter')) mixedTripletStepSeedsA = _mixedTripletStepSeedsACommon.clone() import FastSimulation.Tracking.TrajectorySeedProducer_cfi from FastSimulation.Tracking.SeedingMigration import _hitSetProducerToFactoryPSet _fastSim_mixedTripletStepSeedsA = FastSimulation.Tracking.TrajectorySeedProducer_cfi.trajectorySeedProducer.clone( layerList=mixedTripletStepSeedLayersA.layerList.value(), trackingRegions="mixedTripletStepTrackingRegionsA", hitMasks=cms.InputTag("mixedTripletStepMasks"), seedFinderSelector=dict( pixelTripletGeneratorFactory=_hitSetProducerToFactoryPSet( mixedTripletStepHitTripletsA))) fastSim.toReplaceWith(mixedTripletStepSeedsA, _fastSim_mixedTripletStepSeedsA) # SEEDING LAYERS mixedTripletStepSeedLayersB = cms.EDProducer( "SeedingLayersEDProducer", layerList=cms.vstring('BPix2+BPix3+TIB1'), BPix=cms.PSet(TTRHBuilder=cms.string('WithTrackAngle'), HitProducer=cms.string('siPixelRecHits'), skipClusters=cms.InputTag('mixedTripletStepClusters')), TIB=cms.PSet(matchedRecHits=cms.InputTag("siStripMatchedRecHits", "matchedRecHit"), TTRHBuilder=cms.string('WithTrackAngle'), clusterChargeCut=cms.PSet( refToPSet_=cms.string('SiStripClusterChargeCutTight')), skipClusters=cms.InputTag('mixedTripletStepClusters'))) trackingLowPU.toModify(
+NEWtpToGlbCosmic1LegSelMuonAssociation + NEWglbCosmic1LegMuonTrackVSelMuonAssoc ) NEWgemMuonValidation = cms.Sequence(NEWextractGemMuonsTracks_seq + NEWtpToGEMMuonMuonAssociation + NEWgemMuonTrackVMuonAssoc) NEWme0MuonValidation = cms.Sequence(NEWextractMe0MuonsTracks_seq + NEWtpToME0MuonMuonAssociation + NEWme0MuonTrackVMuonAssoc) ########################################################################## # The full offline muon validation sequence # NEWrecoMuonValidation = cms.Sequence( NEWmuonValidation_seq + NEWmuonValidationTEV_seq + NEWmuonValidationRefit_seq + NEWmuonValidationDisplaced_seq + NEWmuonValidationRMV_seq ) # no displaced muons in fastsim from Configuration.Eras.Modifier_fastSim_cff import fastSim fastSim.toReplaceWith(NEWrecoMuonValidation, cms.Sequence(NEWmuonValidation_seq + NEWmuonValidationTEV_seq + NEWmuonValidationRefit_seq)) # sequence for cosmic muons NEWrecoCosmicMuonValidation = cms.Sequence( NEWmuonValidationCosmic_seq ) # sequences for muon upgrades # NEW_run3_muonValidation = NEWmuonValidation_seq.copy() #For full validation NEW_run3_muonValidation = NEWmuonValidation_reduced_seq.copy() NEW_run3_muonValidation += NEWgemMuonValidation NEW_phase2_muonValidation = NEW_run3_muonValidation.copy() NEW_phase2_muonValidation += NEWme0MuonValidation
seedFinderSelector=dict( CAHitQuadrupletGeneratorFactory=_hitSetProducerToFactoryPSet( detachedQuadStepHitQuadruplets).clone(SeedComparitorPSet=dict( ComponentName="none")), layerList=detachedQuadStepSeedLayers.layerList.value(), #new parameters required for phase1 seeding BPix=dict( TTRHBuilder='WithoutRefit', HitProducer='TrackingRecHitProducer', ), FPix=dict( TTRHBuilder='WithoutRefit', HitProducer='TrackingRecHitProducer', ), layerPairs=detachedQuadStepHitDoublets.layerPairs.value())) fastSim.toReplaceWith(detachedQuadStepSeeds, _fastSim_detachedQuadStepSeeds) # QUALITY CUTS DURING TRACK BUILDING import TrackingTools.TrajectoryFiltering.TrajectoryFilter_cff as _TrajectoryFilter_cff _detachedQuadStepTrajectoryFilterBase = _TrajectoryFilter_cff.CkfBaseTrajectoryFilter_block.clone( minimumNumberOfHits=3, minPt=0.075, ) detachedQuadStepTrajectoryFilterBase = _detachedQuadStepTrajectoryFilterBase.clone( maxCCCLostHits=0, minGoodStripCharge=dict(refToPSet_='SiStripClusterChargeCutLoose')) trackingPhase2PU140.toReplaceWith( detachedQuadStepTrajectoryFilterBase, _detachedQuadStepTrajectoryFilterBase.clone( maxLostHitsFraction=1. / 10., constantValueForLostHitsFractionFilter=0.301,
from Configuration.Eras.Modifier_ctpps_2016_cff import ctpps_2016 ctpps_2016.toReplaceWith(localreco, _ctpps_2016_localreco) _ctpps_2016_localreco_HcalNZS = localreco_HcalNZS.copy() _ctpps_2016_localreco_HcalNZS += recoCTPPS ctpps_2016.toReplaceWith(localreco_HcalNZS, _ctpps_2016_localreco_HcalNZS) ########################################### # no castor, zdc, Totem/CTPPS RP in FastSim ########################################### _fastSim_localreco = localreco.copyAndExclude([ castorreco, totemRPLocalReconstruction,totemTimingLocalReconstruction,ctppsDiamondLocalReconstruction,ctppsLocalTrackLiteProducer,ctppsPixelLocalReconstruction, trackerlocalreco ]) fastSim.toReplaceWith(localreco, _fastSim_localreco) # # temporarily switching off recoGenJets; since this are MC and wil be moved to a proper sequence # from RecoLocalCalo.Castor.Castor_cff import * from RecoLocalCalo.Configuration.hcalGlobalReco_cff import * globalreco_tracking = cms.Sequence(offlineBeamSpot* MeasurementTrackerEventPreSplitting* # unclear where to put this siPixelClusterShapeCachePreSplitting* # unclear where to put this standalonemuontracking* trackingGlobalReco* hcalGlobalRecoSequence* vertexreco)
ComponentName='PixelClusterShapeSeedComparitor', FilterAtHelixStage=cms.bool(False), FilterPixelHits=cms.bool(True), FilterStripHits=cms.bool(False), ClusterShapeHitFilterName=cms.string('ClusterShapeHitFilter'), ClusterShapeCacheSrc=cms.InputTag('siPixelClusterShapeCache')), ) import FastSimulation.Tracking.TrajectorySeedProducer_cfi _fastSim_detachedTripletStepSeeds = FastSimulation.Tracking.TrajectorySeedProducer_cfi.trajectorySeedProducer.clone( layerList=detachedTripletStepSeedLayers.layerList.value(), trackingRegions="detachedTripletStepTrackingRegions", hitMasks=cms.InputTag("detachedTripletStepMasks"), seedFinderSelector=dict( pixelTripletGeneratorFactory=_hitSetProducerToFactoryPSet( detachedTripletStepHitTriplets))) fastSim.toReplaceWith(detachedTripletStepSeeds, _fastSim_detachedTripletStepSeeds) from RecoPixelVertexing.PixelTriplets.caHitTripletEDProducer_cfi import caHitTripletEDProducer as _caHitTripletEDProducer trackingPhase1.toModify(detachedTripletStepHitDoublets, layerPairs=[0, 1]) # layer pairs (0,1), (1,2) trackingPhase1.toReplaceWith( detachedTripletStepHitTriplets, _caHitTripletEDProducer.clone( doublets="detachedTripletStepHitDoublets", extraHitRPhitolerance=detachedTripletStepHitTriplets. extraHitRPhitolerance, maxChi2=dict( pt1=0.8, pt2=2, value1=300, value2=10,
#For FastSim phase1 tracking import FastSimulation.Tracking.TrajectorySeedProducer_cfi from FastSimulation.Tracking.SeedingMigration import _hitSetProducerToFactoryPSet _fastSim_detachedQuadStepSeeds = FastSimulation.Tracking.TrajectorySeedProducer_cfi.trajectorySeedProducer.clone( trackingRegions = "detachedQuadStepTrackingRegions", hitMasks = cms.InputTag("detachedQuadStepMasks"), seedFinderSelector = dict( CAHitQuadrupletGeneratorFactory = _hitSetProducerToFactoryPSet(detachedQuadStepHitQuadruplets).clone( SeedComparitorPSet = dict(ComponentName = "none")), layerList = detachedQuadStepSeedLayers.layerList.value(), #new parameters required for phase1 seeding BPix = dict(TTRHBuilder = 'WithoutRefit', HitProducer = 'TrackingRecHitProducer',), FPix = dict(TTRHBuilder = 'WithoutRefit', HitProducer = 'TrackingRecHitProducer',), layerPairs = detachedQuadStepHitDoublets.layerPairs.value() )) fastSim.toReplaceWith(detachedQuadStepSeeds,_fastSim_detachedQuadStepSeeds) # QUALITY CUTS DURING TRACK BUILDING import TrackingTools.TrajectoryFiltering.TrajectoryFilter_cff as _TrajectoryFilter_cff _detachedQuadStepTrajectoryFilterBase = _TrajectoryFilter_cff.CkfBaseTrajectoryFilter_block.clone( minimumNumberOfHits = 3, minPt = 0.075, ) detachedQuadStepTrajectoryFilterBase = _detachedQuadStepTrajectoryFilterBase.clone( maxCCCLostHits = 0, minGoodStripCharge = dict(refToPSet_ = 'SiStripClusterChargeCutLoose') ) trackingPhase2PU140.toReplaceWith(detachedQuadStepTrajectoryFilterBase, _detachedQuadStepTrajectoryFilterBase.clone( maxLostHitsFraction = 1./10., constantValueForLostHitsFractionFilter = 0.301,
ctpps_2016.toReplaceWith(localreco, _ctpps_2016_localreco) _ctpps_2016_localreco_HcalNZS = localreco_HcalNZS.copy() _ctpps_2016_localreco_HcalNZS += recoCTPPS ctpps_2016.toReplaceWith(localreco_HcalNZS, _ctpps_2016_localreco_HcalNZS) ########################################### # no castor, zdc, Totem/CTPPS RP in FastSim ########################################### _fastSim_localreco = localreco.copyAndExclude([ castorreco, totemRPLocalReconstruction, totemTimingLocalReconstruction, ctppsDiamondLocalReconstruction, ctppsLocalTrackLiteProducer, ctppsPixelLocalReconstruction, trackerlocalreco ]) fastSim.toReplaceWith(localreco, _fastSim_localreco) # # temporarily switching off recoGenJets; since this are MC and wil be moved to a proper sequence # from RecoLocalCalo.Castor.Castor_cff import * from RecoLocalCalo.Configuration.hcalGlobalReco_cff import * globalreco_tracking = cms.Sequence( offlineBeamSpot * MeasurementTrackerEventPreSplitting * # unclear where to put this siPixelClusterShapeCachePreSplitting * # unclear where to put this standalonemuontracking * trackingGlobalReco * hcalGlobalRecoSequence * vertexreco) _globalreco_tracking_LowPU = globalreco_tracking.copy()
run2_GEM_2017.toReplaceWith(RawToDigi, _gem_RawToDigi) from Configuration.Eras.Modifier_run3_GEM_cff import run3_GEM run3_GEM.toReplaceWith(RawToDigi, _gem_RawToDigi) from EventFilter.HGCalRawToDigi.HGCalRawToDigi_cfi import * _hgcal_RawToDigi = RawToDigi.copy() _hgcal_RawToDigi += hgcalDigis from Configuration.Eras.Modifier_phase2_hgcal_cff import phase2_hgcal phase2_hgcal.toReplaceWith(RawToDigi,_hgcal_RawToDigi) # RPC New Readout Validation from Configuration.Eras.Modifier_stage2L1Trigger_2017_cff import stage2L1Trigger_2017 _rpc_NewReadoutVal_RawToDigi = RawToDigi.copy() _rpc_NewReadoutVal_RawToDigi_noTk = RawToDigi_noTk.copy() _rpc_NewReadoutVal_RawToDigi += muonRPCNewDigis _rpc_NewReadoutVal_RawToDigi_noTk += muonRPCNewDigis stage2L1Trigger_2017.toReplaceWith(RawToDigi, _rpc_NewReadoutVal_RawToDigi) stage2L1Trigger_2017.toReplaceWith(RawToDigi_noTk, _rpc_NewReadoutVal_RawToDigi) from Configuration.Eras.Modifier_fastSim_cff import fastSim fastSim.toReplaceWith(RawToDigi, RawToDigi.copyAndExclude([muonRPCNewDigis])) fastSim.toReplaceWith(RawToDigi_noTk, RawToDigi_noTk.copyAndExclude([muonRPCNewDigis])) _hfnose_RawToDigi = RawToDigi.copy() _hfnose_RawToDigi += hfnoseDigis from Configuration.Eras.Modifier_phase2_hfnose_cff import phase2_hfnose phase2_hfnose.toReplaceWith(RawToDigi,_hfnose_RawToDigi)
# TRACK FITTING import RecoTracker.TrackProducer.TrackProducer_cfi jetCoreRegionalStepTracks = RecoTracker.TrackProducer.TrackProducer_cfi.TrackProducer.clone( AlgorithmName='jetCoreRegionalStep', src='jetCoreRegionalStepTrackCandidates', Fitter='FlexibleKFFittingSmoother') jetCoreRegionalStepBarrelTracks = jetCoreRegionalStepTracks.clone( src='jetCoreRegionalStepBarrelTrackCandidates', ) jetCoreRegionalStepEndcapTracks = jetCoreRegionalStepTracks.clone( src='jetCoreRegionalStepEndcapTrackCandidates', ) from Configuration.Eras.Modifier_fastSim_cff import fastSim import RecoTracker.FinalTrackSelectors.trackListMerger_cfi _fastSim_jetCoreRegionalStepTracks = RecoTracker.FinalTrackSelectors.trackListMerger_cfi.trackListMerger.clone( TrackProducers=[], hasSelector=[], selectedTrackQuals=[], copyExtras=True) fastSim.toReplaceWith(jetCoreRegionalStepTracks, _fastSim_jetCoreRegionalStepTracks) # Final selection from RecoTracker.FinalTrackSelectors.TrackCutClassifier_cff import * jetCoreRegionalStep = TrackCutClassifier.clone( src='jetCoreRegionalStepTracks', mva=dict(minPixelHits=[1, 1, 1], maxChi2=[9999., 9999., 9999.], maxChi2n=[1.6, 1.0, 0.7], minLayers=[3, 5, 5], min3DLayers=[1, 2, 3], maxLostLayers=[4, 3, 2], maxDz=[0.5, 0.35, 0.2], maxDr=[0.3, 0.2, 0.1]), vertices='firstStepGoodPrimaryVertices') jetCoreRegionalStepBarrel = jetCoreRegionalStep.clone(
dqmHarvestingPOG = cms.Sequence(DQMOffline_SecondStep_PrePOG) dqmHarvestingPOGMC = cms.Path( DQMOffline_SecondStep_PrePOGMC ) #dqmHarvestingPOGMC = cms.Sequence( DQMOffline_SecondStep_PrePOGMC ) validationHarvestingNoHLT = cms.Path(postValidation*postValidation_gen) validationHarvesting = cms.Path(postValidation*hltpostvalidation*postValidation_gen) #validationHarvestingNoHLT = cms.Sequence(postValidation*postValidation_gen) #validationHarvesting = cms.Sequence(postValidation*hltpostvalidation*postValidation_gen) _validationHarvesting_fastsim = validationHarvesting.copy() for _entry in [hltpostvalidation]: print 'dropping hltpostvalidation' _validationHarvesting_fastsim.remove(_entry) from Configuration.Eras.Modifier_fastSim_cff import fastSim fastSim.toReplaceWith(validationHarvesting,_validationHarvesting_fastsim) validationpreprodHarvestingNoHLT = cms.Path(postValidation_preprod*postValidation_gen) validationpreprodHarvesting = cms.Path(postValidation_preprod*hltpostvalidation_preprod*postValidation_gen) #validationpreprodHarvestingNoHLT = cms.Sequence(postValidation_preprod*postValidation_gen) #validationpreprodHarvesting = cms.Sequence(postValidation_preprod*hltpostvalidation_preprod*postValidation_gen) _validationpreprodHarvesting_fastsim = validationpreprodHarvesting.copy() for _entry in [hltpostvalidation_preprod]: print 'dropping hltpostvalidation_preprod' _validationpreprodHarvesting_fastsim.remove(_entry) from Configuration.Eras.Modifier_fastSim_cff import fastSim fastSim.toReplaceWith(validationpreprodHarvesting,_validationpreprodHarvesting_fastsim) # empty (non-hlt) postvalidation sequence here yet
from RecoEgamma.PhotonIdentification.photonId_cff import * from RecoEgamma.ElectronIdentification.electronIdSequence_cff import * from RecoEgamma.EgammaHFProducers.hfEMClusteringSequence_cff import * from TrackingTools.Configuration.TrackingTools_cff import * from RecoEgamma.EgammaIsolationAlgos.egmIsolationDefinitions_cff import * egammaGlobalRecoTask = cms.Task(electronGsfTrackingTask, conversionTrackTask, allConversionTask) egammaGlobalReco = cms.Sequence(egammaGlobalRecoTask) # this might be historical: not sure why we do this from Configuration.Eras.Modifier_fastSim_cff import fastSim _fastSim_egammaGlobalRecoTask = egammaGlobalRecoTask.copy() _fastSim_egammaGlobalRecoTask.replace(conversionTrackTask, conversionTrackTaskNoEcalSeeded) fastSim.toReplaceWith(egammaGlobalRecoTask, _fastSim_egammaGlobalRecoTask) egammaHighLevelRecoPrePFTask = cms.Task(gsfEcalDrivenElectronTask, uncleanedOnlyElectronTask, conversionTask, photonTask) egammaHighLevelRecoPrePF = cms.Sequence(egammaHighLevelRecoPrePFTask) fastSim.toReplaceWith( egammaHighLevelRecoPrePFTask, egammaHighLevelRecoPrePFTask.copyAndExclude( [uncleanedOnlyElectronTask, conversionTask])) egammaHighLevelRecoPostPFTask = cms.Task(interestingEgammaIsoDetIdsTask, egmIsolationTask, photonIDTask, photonIDTaskGED, eIdTask, hfEMClusteringTask) egammaHighLevelRecoPostPF = cms.Sequence(egammaHighLevelRecoPostPFTask)
import RecoTracker.TrackProducer.TrackProducer_cfi jetCoreRegionalStepTracks = RecoTracker.TrackProducer.TrackProducer_cfi.TrackProducer.clone( AlgorithmName = cms.string('jetCoreRegionalStep'), src = 'jetCoreRegionalStepTrackCandidates', Fitter = cms.string('FlexibleKFFittingSmoother') ) from Configuration.Eras.Modifier_fastSim_cff import fastSim import RecoTracker.FinalTrackSelectors.trackListMerger_cfi _fastSim_jetCoreRegionalStepTracks = RecoTracker.FinalTrackSelectors.trackListMerger_cfi.trackListMerger.clone( TrackProducers = (), hasSelector=cms.vint32(), selectedTrackQuals = cms.VInputTag(), copyExtras = True ) fastSim.toReplaceWith(jetCoreRegionalStepTracks,_fastSim_jetCoreRegionalStepTracks) # Final selection from RecoTracker.IterativeTracking.InitialStep_cff import initialStepClassifier1 #from RecoTracker.IterativeTracking.DetachedTripletStep_cff import detachedTripletStepClassifier1 #jetCoreRegionalStep = initialStepClassifier1.clone() #jetCoreRegionalStep.src='jetCoreRegionalStepTracks' #jetCoreRegionalStep.qualityCuts = [-0.3,0.0,0.2] #jetCoreRegionalStep.vertices = 'firstStepGoodPrimaryVertices' #jetCoreRegionalStepClassifier1 = initialStepClassifier1.clone() #jetCoreRegionalStepClassifier1.src = 'jetCoreRegionalStepTracks' #jetCoreRegionalStepClassifier1.qualityCuts = [-0.2,0.0,0.4] #jetCoreRegionalStepClassifier2 = detachedTripletStepClassifier1.clone()
#### High level sequence (i.e., post PF reconstruction) ### from RecoMuon.MuonIdentification.muons_cfi import * from RecoMuon.MuonIdentification.displacedMuons_cfi import * from RecoMuon.MuonIsolation.muonPFIsolation_cff import * from RecoMuon.MuonIdentification.muonReducedTrackExtras_cfi import * from RecoMuon.MuonIdentification.displacedMuonReducedTrackExtras_cfi import * # clusters are not present in fastsim from Configuration.Eras.Modifier_fastSim_cff import fastSim fastSim.toModify(muonReducedTrackExtras, outputClusters=False) # cluster collections are different in phase 2 from Configuration.Eras.Modifier_phase2_tracker_cff import phase2_tracker phase2_tracker.toModify(muonReducedTrackExtras, outputClusters=False) phase2_tracker.toModify(displacedMuonReducedTrackExtras, outputClusters=False) muonshighlevelrecoTask = cms.Task(muonPFIsolationTask, displacedMuonPFIsolationTask, muons, displacedMuons, muonReducedTrackExtras, displacedMuonReducedTrackExtras) muonshighlevelreco = cms.Sequence(muonshighlevelrecoTask) # displaced sequences do not run in fastsim fastSim.toReplaceWith( muonshighlevelrecoTask, muonshighlevelrecoTask.copyAndExclude([ displacedMuonPFIsolationTask, displacedMuons, displacedMuonReducedTrackExtras ]))
pixelTripletGeneratorFactory = None, CAHitQuadrupletGeneratorFactory = _hitSetProducerToFactoryPSet(initialStepHitQuadruplets).clone(SeedComparitorPSet = dict(ComponentName = "none")), #new parameters required for phase1 seeding BPix = dict( TTRHBuilder = 'WithoutRefit', HitProducer = 'TrackingRecHitProducer', ), FPix = dict( TTRHBuilder = 'WithoutRefit', HitProducer = 'TrackingRecHitProducer', ), layerPairs = initialStepHitDoublets.layerPairs.value() ) ) fastSim.toReplaceWith(initialStepSeeds,_fastSim_initialStepSeeds) # building import TrackingTools.TrajectoryFiltering.TrajectoryFilter_cff _initialStepTrajectoryFilterBase = TrackingTools.TrajectoryFiltering.TrajectoryFilter_cff.CkfBaseTrajectoryFilter_block.clone( minimumNumberOfHits = 3, minPt = 0.2, ) initialStepTrajectoryFilterBase = _initialStepTrajectoryFilterBase.clone( maxCCCLostHits = 0, minGoodStripCharge = cms.PSet(refToPSet_ = cms.string('SiStripClusterChargeCutLoose')) ) from Configuration.Eras.Modifier_tracker_apv_vfp30_2016_cff import tracker_apv_vfp30_2016 _tracker_apv_vfp30_2016.toModify(initialStepTrajectoryFilterBase, maxCCCLostHits = 2)
import FWCore.ParameterSet.Config as cms from RecoParticleFlow.PFTracking.trackerDrivenElectronSeeds_cff import * from RecoEgamma.EgammaElectronProducers.ecalDrivenElectronSeeds_cff import * from RecoParticleFlow.PFTracking.mergedElectronSeeds_cfi import * electronSeedsTask = cms.Task(trackerDrivenElectronSeeds,ecalDrivenElectronSeeds,electronMergedSeeds) electronSeeds = cms.Sequence(electronSeedsTask) from Configuration.ProcessModifiers.pp_on_AA_cff import pp_on_AA pp_on_AA.toReplaceWith(electronSeedsTask, electronSeedsTask.copyAndExclude([trackerDrivenElectronSeeds])) from Configuration.Eras.Modifier_fastSim_cff import fastSim _fastSim_electronSeedsTask = electronSeedsTask.copy() _fastSim_electronSeedsTask.replace(trackerDrivenElectronSeeds, cms.Task(trackerDrivenElectronSeedsTmp,trackerDrivenElectronSeeds)) fastSim.toReplaceWith(electronSeedsTask, _fastSim_electronSeedsTask) # replace the ECAL driven electron track candidates with the FastSim emulated ones import FastSimulation.Tracking.electronCkfTrackCandidates_cff fastElectronCkfTrackCandidates = FastSimulation.Tracking.electronCkfTrackCandidates_cff.electronCkfTrackCandidates.clone() from TrackingTools.GsfTracking.CkfElectronCandidateMaker_cff import * from TrackingTools.GsfTracking.GsfElectronGsfFit_cff import * electronGsfTrackingTask = cms.Task(electronSeedsTask,electronCkfTrackCandidates,electronGsfTracks) electronGsfTracking = cms.Sequence(electronGsfTrackingTask) _electronGsfTrackingTask = electronGsfTrackingTask.copy() _fastSim_electronGsfTrackingTask = electronGsfTrackingTask.copy() _fastSim_electronGsfTrackingTask.replace(electronCkfTrackCandidates,fastElectronCkfTrackCandidates) fastSim.toReplaceWith(electronGsfTrackingTask,_fastSim_electronGsfTrackingTask) from Configuration.Eras.Modifier_phase2_hgcal_cff import phase2_hgcal
trackingPhase1.toModify(_fastSim_detachedTripletStepSeeds, seedFinderSelector = dict( pixelTripletGeneratorFactory = None, CAHitTripletGeneratorFactory = _hitSetProducerToFactoryPSet(detachedTripletStepHitTriplets), #new parameters required for phase1 seeding BPix = dict( TTRHBuilder = 'WithoutRefit', HitProducer = 'TrackingRecHitProducer', ), FPix = dict( TTRHBuilder = 'WithoutRefit', HitProducer = 'TrackingRecHitProducer', ), layerPairs = detachedTripletStepHitDoublets.layerPairs.value() ) ) fastSim.toReplaceWith(detachedTripletStepSeeds,_fastSim_detachedTripletStepSeeds) # QUALITY CUTS DURING TRACK BUILDING import TrackingTools.TrajectoryFiltering.TrajectoryFilter_cff _detachedTripletStepTrajectoryFilterBase = TrackingTools.TrajectoryFiltering.TrajectoryFilter_cff.CkfBaseTrajectoryFilter_block.clone( # maxLostHitsFraction = cms.double(1./10.), # constantValueForLostHitsFractionFilter = cms.double(0.701), minimumNumberOfHits = 3, minPt = 0.075, ) detachedTripletStepTrajectoryFilterBase = _detachedTripletStepTrajectoryFilterBase.clone( maxCCCLostHits = 0, minGoodStripCharge = cms.PSet(refToPSet_ = cms.string('SiStripClusterChargeCutLoose')) ) from Configuration.Eras.Modifier_tracker_apv_vfp30_2016_cff import tracker_apv_vfp30_2016 _tracker_apv_vfp30_2016.toModify(detachedTripletStepTrajectoryFilterBase, maxCCCLostHits = 2)
_ctpps_2016_localreco_HcalNZSTask = localreco_HcalNZSTask.copy() _ctpps_2016_localreco_HcalNZSTask.add(recoCTPPSTask) ctpps_2016.toReplaceWith(localreco_HcalNZSTask, _ctpps_2016_localreco_HcalNZSTask) ########################################### # no castor, zdc, Totem/CTPPS RP in FastSim ########################################### _fastSim_localrecoTask = localrecoTask.copyAndExclude([ castorreco, totemRPLocalReconstructionTask, totemTimingLocalReconstructionTask, ctppsDiamondLocalReconstructionTask, ctppsLocalTrackLiteProducer, ctppsPixelLocalReconstructionTask, ctppsProtons, trackerlocalrecoTask ]) fastSim.toReplaceWith(localrecoTask, _fastSim_localrecoTask) # # temporarily switching off recoGenJets; since this are MC and wil be moved to a proper sequence # from RecoLocalCalo.Castor.Castor_cff import * from RecoLocalCalo.Configuration.hcalGlobalReco_cff import * globalreco_trackingTask = cms.Task( offlineBeamSpot, MeasurementTrackerEventPreSplitting, # unclear where to put this siPixelClusterShapeCachePreSplitting, # unclear where to put this standalonemuontrackingTask, trackingGlobalRecoTask, hcalGlobalRecoTask,
cms.InputTag('g4SimHits','HGCHitsEE'), cms.InputTag('g4SimHits','HGCHitsHEfront'), cms.InputTag('g4SimHits','HcalHits') ), # hcal = cms.VInputTag(cms.InputTag('g4SimHits','HcalHits')), # ecal = cms.VInputTag( # cms.InputTag('g4SimHits','EcalHitsEE'), # cms.InputTag('g4SimHits','EcalHitsEB'), # cms.InputTag('g4SimHits','EcalHitsES') # ) ), simTrackCollection = cms.InputTag('g4SimHits'), simVertexCollection = cms.InputTag('g4SimHits'), genParticleCollection = cms.InputTag('genParticles'), allowDifferentSimHitProcesses = cms.bool(False), # should be True for FastSim, False for FullSim HepMCProductLabel = cms.InputTag('generatorSmeared'), ) from Configuration.ProcessModifiers.premix_stage1_cff import premix_stage1 premix_stage1.toModify(caloParticles, premixStage1 = True) from Configuration.Eras.Modifier_phase2_hgcalV9_cff import phase2_hgcalV9 phase2_hgcalV9.toModify( caloParticles, simHitCollections = dict(hgc = {2 : cms.InputTag('g4SimHits','HGCHitsHEback')} ), ) from Configuration.Eras.Modifier_fastSim_cff import fastSim fastSim.toReplaceWith(caloParticles, cms.PSet()) # don't allow this to run in fastsim
muonValidationRefit_seq + muonValidationDisplaced_seq + muonValidationRMV_seq) # ... and also displaced muons recoMuonValidation_noTABH_noDisplaced = cms.Sequence( TPtrack_seq + TPmu_seq + TPpfmu_seq + muonValidation_noTABH_seq + muonValidationTEV_seq + muonValidationRefit_seq + muonValidationRMV_seq) # no displaced muons in fastsim from Configuration.Eras.Modifier_fastSim_cff import fastSim fastSim.toReplaceWith( recoMuonValidation, cms.Sequence( cms.SequencePlaceholder("TPtrack") + cms.SequencePlaceholder("TPmu") + cms.SequencePlaceholder("TPpfmu") + muonValidation_seq + muonValidationTEV_seq + muonValidationRefit_seq + muonValidationRMV_seq)) # sequence for cosmic muons recoCosmicMuonValidation = cms.Sequence(muonValidationCosmic_seq) # sequences for muon upgrades # _run3_muonValidation = recoMuonValidation.copy() _run3_muonValidation += gemMuonValidation _phase2_muonValidation = cms.Sequence(TPtrack_seq + TPmu_seq + TPpfmu_seq + recoMuonValidation_reduced_seq) _phase2_muonValidation += gemMuonValidation_phase2
) fastSim.toModify(tracksValidationTruth, lambda x: x.remove(tpClusterProducer)) tracksPreValidation = cms.Task( highPtJetsForTrk, tracksValidationSelectors, tracksValidationSelectorsPt09, tracksValidationSelectorsFromPV, tracksValidationSelectorsFromPVPt09, tracksValidationTruth, trackingParticlesSignal, trackingParticlesElectron, trackingParticlesConversion ) fastSim.toReplaceWith(tracksPreValidation, tracksPreValidation.copyAndExclude([ trackingParticlesElectron, trackingParticlesConversion, ])) tracksValidation = cms.Sequence( trackValidator + trackValidatorTPPtLess09 + trackValidatorFromPV + trackValidatorFromPVAllTP + trackValidatorAllTPEffic + trackValidatorBuilding + trackValidatorBuildingPreSplitting + trackValidatorConversion + trackValidatorGsfTracks, tracksPreValidation ) fastSim.toReplaceWith(tracksValidation, tracksValidation.copyAndExclude([
phase2_tracker.toReplaceWith(DigiToRawTask, DigiToRawTask.copyAndExclude([siPixelRawData ])) # FIXME # GEM settings _gem_DigiToRawTask = DigiToRawTask.copy() _gem_DigiToRawTask.add(gemPacker) from Configuration.Eras.Modifier_run2_GEM_2017_cff import run2_GEM_2017 run2_GEM_2017.toReplaceWith(DigiToRawTask, _gem_DigiToRawTask) from Configuration.Eras.Modifier_run3_GEM_cff import run3_GEM from Configuration.Eras.Modifier_phase2_GEM_cff import phase2_GEM (run3_GEM & ~phase2_GEM).toReplaceWith(DigiToRawTask, _gem_DigiToRawTask) from Configuration.Eras.Modifier_phase2_muon_cff import phase2_muon phase2_muon.toReplaceWith(DigiToRawTask, DigiToRawTask.copyAndExclude([rpcpacker])) from Configuration.Eras.Modifier_fastSim_cff import fastSim fastSim.toReplaceWith( DigiToRawTask, DigiToRawTask.copyAndExclude( [siPixelRawData, SiStripDigiToRaw, castorRawData, ctppsRawData])) from Configuration.Eras.Modifier_phase2_ecal_devel_cff import phase2_ecal_devel phase2_ecal_devel.toReplaceWith( DigiToRawTask, DigiToRawTask.copyAndExclude( [L1TDigiToRawTask, ecalPacker, esDigiToRaw, cscpacker]))
FilterStripHits = cms.bool(True), ClusterShapeHitFilterName = cms.string('ClusterShapeHitFilter'), ClusterShapeCacheSrc = cms.InputTag("siPixelClusterShapeCache") # not really needed here since FilterPixelHits=False ) ) #fastsim import FastSimulation.Tracking.TrajectorySeedProducer_cfi _fastSim_pixelLessStepSeeds = FastSimulation.Tracking.TrajectorySeedProducer_cfi.trajectorySeedProducer.clone( layerList = pixelLessStepSeedLayers.layerList.value(), trackingRegions = "pixelLessStepTrackingRegions", hitMasks = cms.InputTag("pixelLessStepMasks"), ) from FastSimulation.Tracking.SeedingMigration import _hitSetProducerToFactoryPSet _fastSim_pixelLessStepSeeds.seedFinderSelector.MultiHitGeneratorFactory = _hitSetProducerToFactoryPSet(pixelLessStepHitTriplets) _fastSim_pixelLessStepSeeds.seedFinderSelector.MultiHitGeneratorFactory.refitHits = False fastSim.toReplaceWith(pixelLessStepSeeds,_fastSim_pixelLessStepSeeds) # QUALITY CUTS DURING TRACK BUILDING import TrackingTools.TrajectoryFiltering.TrajectoryFilter_cff _pixelLessStepTrajectoryFilterBase = TrackingTools.TrajectoryFiltering.TrajectoryFilter_cff.CkfBaseTrajectoryFilter_block.clone( maxLostHits = 0, minimumNumberOfHits = 4, minPt = 0.1 ) pixelLessStepTrajectoryFilter = _pixelLessStepTrajectoryFilterBase.clone( seedPairPenalty = 1, ) trackingLowPU.toReplaceWith(pixelLessStepTrajectoryFilter, _pixelLessStepTrajectoryFilterBase) for e in [pp_on_XeXe_2017, pp_on_AA_2018]: e.toModify(pixelLessStepTrajectoryFilter, minPt=2.0)
trackingParticleNumberOfLayersProducer ) fastSim.toModify(tracksValidationTruth, lambda x: x.remove(tpClusterProducer)) tracksPreValidation = cms.Sequence( tracksValidationSelectors + tracksValidationSelectorsPt09 + tracksValidationSelectorsFromPV + tracksValidationSelectorsFromPVPt09 + tracksValidationTruth + cms.ignore(trackingParticlesSignal) + cms.ignore(trackingParticlesElectron) + trackingParticlesConversion ) fastSim.toReplaceWith(tracksPreValidation, tracksPreValidation.copyAndExclude([ trackingParticlesElectron, trackingParticlesConversion, ])) tracksValidation = cms.Sequence( tracksPreValidation + trackValidator + trackValidatorTPPtLess09 + trackValidatorFromPV + trackValidatorFromPVAllTP + trackValidatorAllTPEffic + trackValidatorBuilding + trackValidatorConversion + trackValidatorGsfTracks ) fastSim.toReplaceWith(tracksValidation, tracksValidation.copyAndExclude([ trackValidatorConversion,
FilterStripHits = cms.bool(False), ClusterShapeHitFilterName = cms.string('ClusterShapeHitFilter'), ClusterShapeCacheSrc = cms.InputTag('siPixelClusterShapeCache'), ) ) # Clone for the phase1 recovery mode pixelPairStepSeedsA = pixelPairStepSeeds.clone() #have to do it after making pixelPairStepSeedsA since pixelPairStepSeedsB clones A # and then modifies it import FastSimulation.Tracking.TrajectorySeedProducer_cfi fastSim.toReplaceWith(pixelPairStepSeeds, FastSimulation.Tracking.TrajectorySeedProducer_cfi.trajectorySeedProducer.clone( layerList = pixelPairStepSeedLayers.layerList.value(), trackingRegions = "pixelPairStepTrackingRegions", hitMasks = cms.InputTag("pixelPairStepMasks"), ) ) # Recovery for regions with 2 inactive layers from RecoTracker.TkTrackingRegions.pixelInactiveAreaTrackingRegionsAndSeedingLayers_cfi import pixelInactiveAreaTrackingRegionsAndSeedingLayers as _pixelInactiveAreaTrackingRegionsAndSeedingLayers pixelPairStepTrackingRegionsSeedLayersB = _pixelInactiveAreaTrackingRegionsAndSeedingLayers.clone( layerList = [ # Commented ones are already included in the global seeds (A), but are # included below for completenees # # "BPix1+BPix2", # "BPix1+BPix3", "BPix1+BPix4", # "BPix2+BPix3",
'stripPairElectronSeeds', 'lowPtTripletStepSeeds', 'lowPtQuadStepSeeds', 'detachedTripletStepSeeds', 'detachedQuadStepSeeds', 'pixelPairStepSeeds' ] trackingPhase1.toModify(newCombinedSeeds, seedCollections = _seedCollections_Phase1) trackingPhase2PU140.toModify(newCombinedSeeds, seedCollections = ['initialStepSeeds', 'highPtTripletStepSeeds', 'tripletElectronSeeds'] ) from Configuration.Eras.Modifier_fastSim_cff import fastSim from FastSimulation.Tracking.ElectronSeeds_cff import _newCombinedSeeds fastSim.toReplaceWith(newCombinedSeeds,_newCombinedSeeds.clone()) electronSeedsSeqTask = cms.Task( initialStepSeedClusterMask, pixelPairStepSeedClusterMask, mixedTripletStepSeedClusterMask, pixelLessStepSeedClusterMask, tripletElectronSeedLayers, tripletElectronTrackingRegions, tripletElectronHitDoublets, tripletElectronHitTriplets, tripletElectronSeeds, tripletElectronClusterMask, pixelPairElectronSeedLayers, pixelPairElectronTrackingRegions, pixelPairElectronHitDoublets, pixelPairElectronSeeds,
FilterPixelHits=cms.bool(True), FilterStripHits=cms.bool(False), ClusterShapeHitFilterName=cms.string('ClusterShapeHitFilter'), ClusterShapeCacheSrc=cms.InputTag('siPixelClusterShapeCache'), )) # Clone for the phase1 recovery mode pixelPairStepSeedsA = pixelPairStepSeeds.clone() #have to do it after making pixelPairStepSeedsA since pixelPairStepSeedsB clones A # and then modifies it import FastSimulation.Tracking.TrajectorySeedProducer_cfi fastSim.toReplaceWith( pixelPairStepSeeds, FastSimulation.Tracking.TrajectorySeedProducer_cfi.trajectorySeedProducer. clone(trackingRegions='pixelPairStepTrackingRegions', hitMasks=cms.InputTag('pixelPairStepMasks'), seedFinderSelector=dict( layerList=pixelPairStepSeedLayers.layerList.value()))) # Recovery for regions with 2 inactive layers from RecoTracker.TkTrackingRegions.pixelInactiveAreaTrackingRegionsAndSeedingLayers_cfi import pixelInactiveAreaTrackingRegionsAndSeedingLayers as _pixelInactiveAreaTrackingRegionsAndSeedingLayers pixelPairStepTrackingRegionsSeedLayersB = _pixelInactiveAreaTrackingRegionsAndSeedingLayers.clone( layerList=[ # Commented ones are already included in the global seeds (A), but are # included below for completenees # # 'BPix1+BPix2', # 'BPix1+BPix3', 'BPix1+BPix4', # 'BPix2+BPix3',
# (particleFlowClusterECAL_cfi is generated automatically) from RecoEgamma.EgammaElectronProducers.lowPtGsfElectronSuperClusters_cff import lowPtGsfElectronSuperClusters # Low pT electron cores from RecoEgamma.EgammaElectronProducers.lowPtGsfElectronCores_cff import * # Low pT electrons from RecoEgamma.EgammaElectronProducers.lowPtGsfElectrons_cfi import * # Low pT Electron value maps from RecoEgamma.EgammaElectronProducers.lowPtGsfElectronSeedValueMaps_cff import lowPtGsfElectronSeedValueMaps # Low pT Electron ID from RecoEgamma.EgammaElectronProducers.lowPtGsfElectronID_cff import lowPtGsfElectronID # Full sequence lowPtGsfElectronTask = cms.Task( lowPtGsfElePfTracks, lowPtGsfElectronSeeds, lowPtGsfEleCkfTrackCandidates, lowPtGsfEleGsfTracks, lowPtGsfElePfGsfTracks, lowPtGsfElectronSuperClusters, lowPtGsfElectronCores, lowPtGsfElectrons, lowPtGsfElectronSeedValueMaps, lowPtGsfElectronID) lowPtGsfElectronSequence = cms.Sequence(lowPtGsfElectronTask) _fastSim_lowPtGsfElectronTask = lowPtGsfElectronTask.copy() _fastSim_lowPtGsfElectronTask.replace( lowPtGsfElectronSeeds, cms.Task(lowPtGsfElectronSeedsTmp, lowPtGsfElectronSeeds)) _fastSim_lowPtGsfElectronTask.replace(lowPtGsfEleCkfTrackCandidates, fastLowPtGsfTkfTrackCandidates) fastSim.toReplaceWith(lowPtGsfElectronTask, _fastSim_lowPtGsfElectronTask)
# # from PhysicsTools.NanoAOD.NanoAODEDMEventContent_cff import * # # # FastSim # # from FastSimulation.Configuration.EventContent_cff import FASTPUEventContent import FastSimulation.Configuration.EventContent_cff as fastSimEC from Configuration.Eras.Modifier_fastSim_cff import fastSim fastSim.toModify(RecoLocalTrackerRECO, outputCommands = fastSimEC.RecoLocalTracker.outputCommands) fastSim.toModify(RecoLocalTrackerFEVT, outputCommands = fastSimEC.RecoLocalTracker.outputCommands) fastSim.toReplaceWith(SimG4CoreRAW, fastSimEC.SimRAW) fastSim.toReplaceWith(SimG4CoreRECO, fastSimEC.SimRECO) # # # Top level additional keep statements # # CommonEventContent = cms.PSet( outputCommands = cms.untracked.vstring('keep *_logErrorHarvester_*_*') ) # # # LHE Data Tier definition #
import FWCore.ParameterSet.Config as cms from SimCalorimetry.Configuration.ecalDigiSequence_cff import * from SimCalorimetry.Configuration.hcalDigiSequence_cff import * from SimCalorimetry.Configuration.castorDigiSequence_cff import * calDigiTask = cms.Task(ecalDigiTask, hcalDigiTask, castorDigiTask) calDigi = cms.Sequence(calDigiTask) # fastsim has no castor model from Configuration.Eras.Modifier_fastSim_cff import fastSim fastSim.toReplaceWith(calDigiTask, calDigiTask.copyAndExclude([castorDigiTask]))
lowPtQuadStepHitQuadruplets).clone(SeedComparitorPSet=dict( ComponentName="none")), layerList=lowPtQuadStepSeedLayers.layerList.value(), #new parameters required for phase1 seeding BPix=dict( TTRHBuilder='WithoutRefit', HitProducer='TrackingRecHitProducer', ), FPix=dict( TTRHBuilder='WithoutRefit', HitProducer='TrackingRecHitProducer', ), layerPairs=lowPtQuadStepHitDoublets.layerPairs.value())) _fastSim_lowPtQuadStepSeeds.seedFinderSelector.CAHitQuadrupletGeneratorFactory.SeedComparitorPSet.ComponentName = "none" fastSim.toReplaceWith(lowPtQuadStepSeeds, _fastSim_lowPtQuadStepSeeds) # QUALITY CUTS DURING TRACK BUILDING import TrackingTools.TrajectoryFiltering.TrajectoryFilter_cff as _TrajectoryFilter_cff _lowPtQuadStepTrajectoryFilterBase = _TrajectoryFilter_cff.CkfBaseTrajectoryFilter_block.clone( minimumNumberOfHits=3, minPt=0.075, ) lowPtQuadStepTrajectoryFilterBase = _lowPtQuadStepTrajectoryFilterBase.clone( maxCCCLostHits=0, minGoodStripCharge=dict(refToPSet_='SiStripClusterChargeCutLoose')) trackingPhase2PU140.toReplaceWith(lowPtQuadStepTrajectoryFilterBase, _lowPtQuadStepTrajectoryFilterBase) for e in [pp_on_XeXe_2017, pp_on_AA_2018]: e.toModify(lowPtQuadStepTrajectoryFilterBase, minPt=0.49)
CAHitTripletGeneratorFactory=_hitSetProducerToFactoryPSet( highPtTripletStepHitTriplets), layerList=highPtTripletStepSeedLayers.layerList.value(), #new parameters required for phase1 seeding BPix=dict( TTRHBuilder='WithoutRefit', HitProducer='TrackingRecHitProducer', ), FPix=dict( TTRHBuilder='WithoutRefit', HitProducer='TrackingRecHitProducer', ), layerPairs=highPtTripletStepHitDoublets.layerPairs.value())) _fastSim_highPtTripletStepSeeds.seedFinderSelector.CAHitTripletGeneratorFactory.SeedComparitorPSet.ComponentName = 'none' fastSim.toReplaceWith(highPtTripletStepSeeds, _fastSim_highPtTripletStepSeeds) # QUALITY CUTS DURING TRACK BUILDING import TrackingTools.TrajectoryFiltering.TrajectoryFilter_cff as _TrajectoryFilter_cff _highPtTripletStepTrajectoryFilterBase = _TrajectoryFilter_cff.CkfBaseTrajectoryFilter_block.clone( minimumNumberOfHits=3, minPt=0.2, ) highPtTripletStepTrajectoryFilterBase = _highPtTripletStepTrajectoryFilterBase.clone( maxCCCLostHits=0, minGoodStripCharge=dict(refToPSet_='SiStripClusterChargeCutLoose')) trackingPhase2PU140.toReplaceWith(highPtTripletStepTrajectoryFilterBase, _highPtTripletStepTrajectoryFilterBase) (pp_on_XeXe_2017 | pp_on_AA).toModify(highPtTripletStepTrajectoryFilterBase, minPt=0.7)
'RecoEgamma/ElectronIdentification/data/LowPtElectrons/RunII_Autumn18_LowPtElectrons_displaced_pt_eta_biased.root', ]), ModelThresholds=thresholds("T"), PassThrough=cms.bool(False), UsePfTracks=cms.bool(True), MinPtThreshold=cms.double(1.0), MaxPtThreshold=cms.double(15.), ) # Modifiers for FastSim from Configuration.Eras.Modifier_fastSim_cff import fastSim lowPtGsfElectronSeedsTmp = lowPtGsfElectronSeeds.clone( tracks="generalTracksBeforeMixing") import FastSimulation.Tracking.ElectronSeedTrackRefFix_cfi _fastSim_lowPtGsfElectronSeeds = FastSimulation.Tracking.ElectronSeedTrackRefFix_cfi.fixedTrackerDrivenElectronSeeds.clone( seedCollection="lowPtGsfElectronSeedsTmp:", idCollection=["lowPtGsfElectronSeedsTmp", "lowPtGsfElectronSeedsTmp:HCAL"], PreIdLabel=["", "HCAL"], PreGsfLabel="") fastSim.toReplaceWith(lowPtGsfElectronSeeds, _fastSim_lowPtGsfElectronSeeds) # Modifiers for BParking from Configuration.Eras.Modifier_bParking_cff import bParking bParking.toModify( lowPtGsfElectronSeeds, ModelThresholds=thresholds("VL"), )
FilterStripHits = cms.bool(True), ClusterShapeHitFilterName = cms.string('ClusterShapeHitFilter'), ClusterShapeCacheSrc = cms.InputTag("siPixelClusterShapeCache") # not really needed here since FilterPixelHits=False ) ) #fastsim import FastSimulation.Tracking.TrajectorySeedProducer_cfi _fastSim_pixelLessStepSeeds = FastSimulation.Tracking.TrajectorySeedProducer_cfi.trajectorySeedProducer.clone( trackingRegions = "pixelLessStepTrackingRegions", hitMasks = cms.InputTag("pixelLessStepMasks"), ) from FastSimulation.Tracking.SeedingMigration import _hitSetProducerToFactoryPSet _fastSim_pixelLessStepSeeds.seedFinderSelector.MultiHitGeneratorFactory = _hitSetProducerToFactoryPSet(pixelLessStepHitTriplets) _fastSim_pixelLessStepSeeds.seedFinderSelector.MultiHitGeneratorFactory.refitHits = False _fastSim_pixelLessStepSeeds.seedFinderSelector.layerList = pixelLessStepSeedLayers.layerList.value() fastSim.toReplaceWith(pixelLessStepSeeds,_fastSim_pixelLessStepSeeds) # QUALITY CUTS DURING TRACK BUILDING import TrackingTools.TrajectoryFiltering.TrajectoryFilter_cff _pixelLessStepTrajectoryFilterBase = TrackingTools.TrajectoryFiltering.TrajectoryFilter_cff.CkfBaseTrajectoryFilter_block.clone( maxLostHits = 0, minimumNumberOfHits = 4, minPt = 0.1 ) pixelLessStepTrajectoryFilter = _pixelLessStepTrajectoryFilterBase.clone( seedPairPenalty = 1, ) trackingLowPU.toReplaceWith(pixelLessStepTrajectoryFilter, _pixelLessStepTrajectoryFilterBase) for e in [pp_on_XeXe_2017, pp_on_AA_2018]: e.toModify(pixelLessStepTrajectoryFilter, minPt=2.0)
ecalDrivenElectronSeeds * electronMergedSeeds) _electronSeedsFromMultiCl = electronSeeds.copy() _electronSeedsFromMultiCl += cms.Sequence(ecalDrivenElectronSeedsFromMultiCl * electronMergedSeedsFromMultiCl) from Configuration.Eras.Modifier_phase2_hgcal_cff import phase2_hgcal phase2_hgcal.toReplaceWith(electronSeeds, _electronSeedsFromMultiCl) from Configuration.Eras.Modifier_fastSim_cff import fastSim _fastSim_electronSeeds = electronSeeds.copy() _fastSim_electronSeeds.replace( trackerDrivenElectronSeeds, trackerDrivenElectronSeedsTmp + trackerDrivenElectronSeeds) fastSim.toReplaceWith(electronSeeds, _fastSim_electronSeeds) # replace the ECAL driven electron track candidates with the FastSim emulated ones import FastSimulation.Tracking.electronCkfTrackCandidates_cff fastElectronCkfTrackCandidates = FastSimulation.Tracking.electronCkfTrackCandidates_cff.electronCkfTrackCandidates.clone( ) from TrackingTools.GsfTracking.CkfElectronCandidateMaker_cff import * from TrackingTools.GsfTracking.GsfElectronGsfFit_cff import * electronGsfTracking = cms.Sequence(electronSeeds * electronCkfTrackCandidates * electronGsfTracks) _electronGsfTracking = electronGsfTracking.copy() _electronGsfTracking += cms.Sequence(electronCkfTrackCandidatesFromMultiCl * electronGsfTracksFromMultiCl) _fastSim_electronGsfTracking = electronGsfTracking.copy()
ModelWeights = cms.vstring([ 'RecoEgamma/ElectronIdentification/data/LowPtElectrons/RunII_Fall17_LowPtElectrons_unbiased.xml.gz', 'RecoEgamma/ElectronIdentification/data/LowPtElectrons/RunII_Fall17_LowPtElectrons_displaced_pt_eta_biased.xml.gz', ]), ModelThresholds = thresholds("T"), PassThrough = cms.bool(False), UsePfTracks = cms.bool(True), MinPtThreshold = cms.double(1.0), MaxPtThreshold = cms.double(15.), ) # Modifiers for FastSim from Configuration.Eras.Modifier_fastSim_cff import fastSim lowPtGsfElectronSeedsTmp = lowPtGsfElectronSeeds.clone(tracks = cms.InputTag("generalTracksBeforeMixing")) import FastSimulation.Tracking.ElectronSeedTrackRefFix_cfi _fastSim_lowPtGsfElectronSeeds = FastSimulation.Tracking.ElectronSeedTrackRefFix_cfi.fixedTrackerDrivenElectronSeeds.clone() _fastSim_lowPtGsfElectronSeeds.seedCollection = cms.InputTag("lowPtGsfElectronSeedsTmp","") _fastSim_lowPtGsfElectronSeeds.idCollection = cms.VInputTag("lowPtGsfElectronSeedsTmp","lowPtGsfElectronSeedsTmp:HCAL") _fastSim_lowPtGsfElectronSeeds.PreIdLabel = cms.vstring("","HCAL") _fastSim_lowPtGsfElectronSeeds.PreGsfLabel = cms.string("") fastSim.toReplaceWith(lowPtGsfElectronSeeds,_fastSim_lowPtGsfElectronSeeds) # Modifiers for Phase2 from Configuration.Eras.Modifier_phase2_tracker_cff import phase2_tracker phase2_tracker.toModify(lowPtGsfElectronSeeds, TTRHBuilder = 'WithTrackAngle') # Modifiers for BParking from Configuration.Eras.Modifier_bParking_cff import bParking bParking.toModify(lowPtGsfElectronSeeds, ModelThresholds = thresholds("L") ) bParking.toModify(lowPtGsfElectronSeeds, MinPtThreshold = 0.5)
lowPtTripletStepSeeds = _seedCreatorFromRegionConsecutiveHitsEDProducer.clone( seedingHitSets="lowPtTripletStepHitTriplets", ) import FastSimulation.Tracking.TrajectorySeedProducer_cfi _fastSim_lowPtTripletStepSeeds = FastSimulation.Tracking.TrajectorySeedProducer_cfi.trajectorySeedProducer.clone( layerList=lowPtTripletStepSeedLayers.layerList.value(), trackingRegions="lowPtTripletStepTrackingRegions", hitMasks=cms.InputTag("lowPtTripletStepMasks"), ) from FastSimulation.Tracking.SeedingMigration import _hitSetProducerToFactoryPSet _fastSim_lowPtTripletStepSeeds.seedFinderSelector.pixelTripletGeneratorFactory = _hitSetProducerToFactoryPSet( lowPtTripletStepHitTriplets) _fastSim_lowPtTripletStepSeeds.seedFinderSelector.pixelTripletGeneratorFactory.SeedComparitorPSet.ComponentName = "none" fastSim.toReplaceWith(lowPtTripletStepSeeds, _fastSim_lowPtTripletStepSeeds) from RecoPixelVertexing.PixelTriplets.caHitTripletEDProducer_cfi import caHitTripletEDProducer as _caHitTripletEDProducer trackingPhase1.toModify(lowPtTripletStepHitDoublets, layerPairs=[0, 1]) # layer pairs (0,1), (1,2) trackingPhase1.toReplaceWith( lowPtTripletStepHitTriplets, _caHitTripletEDProducer.clone( doublets="lowPtTripletStepHitDoublets", extraHitRPhitolerance=lowPtTripletStepHitTriplets. extraHitRPhitolerance, SeedComparitorPSet=lowPtTripletStepHitTriplets.SeedComparitorPSet, maxChi2=dict( pt1=0.8, pt2=2,
gemMuonValidation_phase2 = cms.Sequence(extractGemMuonsTracks_seq + tpToGEMMuonMuonAssociation + gemMuonTrackVMuonAssoc_phase2) ########################################################################## # The full offline muon validation sequence # recoMuonValidation = cms.Sequence(muonValidation_seq + muonValidationTEV_seq + muonValidationRefit_seq + muonValidationDisplaced_seq + muonValidationRMV_seq) # no displaced muons in fastsim from Configuration.Eras.Modifier_fastSim_cff import fastSim fastSim.toReplaceWith( recoMuonValidation, cms.Sequence(muonValidation_seq + muonValidationTEV_seq + muonValidationRefit_seq + muonValidationRMV_seq)) # sequence for cosmic muons recoCosmicMuonValidation = cms.Sequence(muonValidationCosmic_seq) # sequences for muon upgrades # _run3_muonValidation = recoMuonValidation.copy() #For full validation #_run3_muonValidation = recoMuonValidation_reduced_seq.copy() _run3_muonValidation += gemMuonValidation #_phase2_muonValidation = recoMuonValidation.copy() #For full validation _phase2_muonValidation = recoMuonValidation_reduced_seq.copy() _phase2_muonValidation += gemMuonValidation_phase2 _phase2_muonValidation += me0MuonValidation
setTrackerOnly = True, setArbitratedMergedEcalGeneral = True, ) #fastSim from Configuration.Eras.Modifier_fastSim_cff import fastSim # the conversion producer depends on trajectories # so we feed it with the 'before mixing' track collection generalConversionTrackProducerTmp = generalConversionTrackProducer.clone( TrackProducer = 'generalTracksBeforeMixing') # then we need to fix the track references, so that they point to the final track collection, after mixing import FastSimulation.Tracking.ConversionTrackRefFix_cfi _fastSim_conversionTrackRefFix = FastSimulation.Tracking.ConversionTrackRefFix_cfi.fixedConversionTracks.clone( src = "generalConversionTrackProducerTmp") fastSim.toReplaceWith(generalConversionTrackProducer, _fastSim_conversionTrackRefFix) #producer from conversionStep tracks collection, set tracker only, merged arbitrated, merged arbitrated ecal/general flags conversionStepConversionTrackProducer = RecoEgamma.EgammaPhotonProducers.conversionTrackProducer_cfi.conversionTrackProducer.clone( TrackProducer = 'conversionStepTracks', setTrackerOnly = True, setArbitratedMergedEcalGeneral = True, ) #producer from inout ecal seeded tracks, set arbitratedecalseeded, mergedarbitratedecalgeneral and mergedarbitrated flags inOutConversionTrackProducer = RecoEgamma.EgammaPhotonProducers.conversionTrackProducer_cfi.conversionTrackProducer.clone( TrackProducer = 'ckfInOutTracksFromConversions', setArbitratedEcalSeeded = True, setArbitratedMergedEcalGeneral = True,
pixelTripletGeneratorFactory=None, CAHitQuadrupletGeneratorFactory=_hitSetProducerToFactoryPSet( initialStepHitQuadruplets).clone(SeedComparitorPSet=dict( ComponentName="none")), #new parameters required for phase1 seeding BPix=dict( TTRHBuilder='WithoutRefit', HitProducer='TrackingRecHitProducer', ), FPix=dict( TTRHBuilder='WithoutRefit', HitProducer='TrackingRecHitProducer', ), layerPairs=initialStepHitDoublets.layerPairs.value())) fastSim.toReplaceWith(initialStepSeeds, _fastSim_initialStepSeeds) # building import TrackingTools.TrajectoryFiltering.TrajectoryFilter_cff _initialStepTrajectoryFilterBase = TrackingTools.TrajectoryFiltering.TrajectoryFilter_cff.CkfBaseTrajectoryFilter_block.clone( minimumNumberOfHits=3, minPt=0.2, ) initialStepTrajectoryFilterBase = _initialStepTrajectoryFilterBase.clone( maxCCCLostHits=0, minGoodStripCharge=cms.PSet( refToPSet_=cms.string('SiStripClusterChargeCutLoose'))) from Configuration.Eras.Modifier_tracker_apv_vfp30_2016_cff import tracker_apv_vfp30_2016 _tracker_apv_vfp30_2016.toModify(initialStepTrajectoryFilterBase, maxCCCLostHits=2)
import EventFilter.L1GlobalTriggerRawToDigi.conditionDumperInEdm_cfi conditionsInEdm = EventFilter.L1GlobalTriggerRawToDigi.conditionDumperInEdm_cfi.conditionDumperInEdm.clone() import L1Trigger.GlobalTrigger.convertObjectMapRecord_cfi as _converterModule l1L1GtObjectMap = _converterModule.convertObjectMapRecord.clone() L1Reco_L1Extra = cms.Sequence(l1extraParticles) L1Reco_L1Extra_L1GtRecord = cms.Sequence(l1extraParticles+l1GtRecord) L1Reco = cms.Sequence(l1extraParticles+l1GtTriggerMenuLite+conditionsInEdm+l1L1GtObjectMap) # # Stage-1 Trigger # from Configuration.Eras.Modifier_stage1L1Trigger_cff import stage1L1Trigger stage1L1Trigger.toReplaceWith(L1Reco_L1Extra,cms.Sequence()) stage1L1Trigger.toReplaceWith(L1Reco_L1Extra_L1GtRecord,cms.Sequence()) stage1L1Trigger.toReplaceWith(L1Reco, cms.Sequence(l1extraParticles)) # # Stage-2 Trigger: fow now, reco Stage-1 as before: # from Configuration.Eras.Modifier_stage2L1Trigger_cff import stage2L1Trigger stage2L1Trigger.toReplaceWith(L1Reco_L1Extra,cms.Sequence()) stage2L1Trigger.toReplaceWith(L1Reco_L1Extra_L1GtRecord,cms.Sequence()) stage2L1Trigger.toReplaceWith(L1Reco, cms.Sequence(l1extraParticles)) # # l1L1GtObjectMap does not work properly with fastsim # from Configuration.Eras.Modifier_fastSim_cff import fastSim _L1Reco_modified = L1Reco.copyAndExclude([l1L1GtObjectMap]) fastSim.toReplaceWith(L1Reco, _L1Reco_modified)