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