def setCrossingFrameOn(process):
process.mix.mixObjects.mixCH.crossingFrames = cms.untracked.vstring(
'CaloHitsTk', 'CastorBU', 'CastorFI', 'CastorPL', 'CastorTU',
'EcalHitsEB', 'EcalHitsEE', 'EcalHitsES', 'EcalTBH4BeamHits',
'HcalHits', 'HcalTB06BeamHits', 'ZDCHITS')
process.mix.mixObjects.mixTracks.makeCrossingFrame = cms.untracked.bool(
True)
process.mix.mixObjects.mixVertices.makeCrossingFrame = cms.untracked.bool(
True)
process.mix.mixObjects.mixHepMC.makeCrossingFrame = cms.untracked.bool(
True)
process.mix.mixObjects.mixSH.crossingFrames = cms.untracked.vstring(
'BSCHits', 'FP420SI', 'MuonCSCHits', 'MuonDTHits', 'MuonRPCHits',
'TotemHitsRP', 'TotemHitsT1', 'TotemHitsT2Gem',
'TrackerHitsPixelBarrelHighTof', 'TrackerHitsPixelBarrelLowTof',
'TrackerHitsPixelEndcapHighTof', 'TrackerHitsPixelEndcapLowTof',
'TrackerHitsTECHighTof', 'TrackerHitsTECLowTof',
'TrackerHitsTIBHighTof', 'TrackerHitsTIBLowTof',
'TrackerHitsTIDHighTof', 'TrackerHitsTIDLowTof',
'TrackerHitsTOBHighTof', 'TrackerHitsTOBLowTof')
from Configuration.Eras.Modifier_run2_GEM_2017_cff import run2_GEM_2017
run2_GEM_2017.toModify(
process.mix.mixObjects,
mixSH=dict(crossingFrames=process.mix.mixObjects.mixSH.crossingFrames +
['MuonGEMHits']))
from Configuration.Eras.Modifier_run3_GEM_cff import run3_GEM
run3_GEM.toModify(
process.mix.mixObjects,
mixSH=dict(crossingFrames=process.mix.mixObjects.mixSH.crossingFrames +
['MuonGEMHits']))
from Configuration.Eras.Modifier_phase2_muon_cff import phase2_muon
phase2_muon.toModify(
process.mix.mixObjects,
mixSH=dict(crossingFrames=process.mix.mixObjects.mixSH.crossingFrames +
['MuonME0Hits']))
from Configuration.Eras.Modifier_phase2_timing_layer_cff import phase2_timing_layer
phase2_timing_layer.toModify(
process.mix.mixObjects,
mixSH=dict(crossingFrames=process.mix.mixObjects.mixSH.crossingFrames +
['FastTimerHitsBarrel', 'FastTimerHitsEndcap']))
return (process)
)
### Lite mode (only generalTracks and HP)
trackValidatorLite = trackValidator.clone(
label = ["generalTracks", "cutsRecoTracksHp"]
)
tracksValidationLite = cms.Sequence(
cutsRecoTracksHp +
tracksValidationTruth +
trackValidatorLite
)
## customization for timing
from Configuration.Eras.Modifier_phase2_timing_layer_cff import phase2_timing_layer
phase2_timing_layer.toModify( generalTracksFromPV,
vertexTag = cms.InputTag('offlinePrimaryVertices4D'),
timesTag = cms.InputTag('trackTimeValueMapProducer:generalTracksConfigurableFlatResolutionModel'),
timeResosTag = cms.InputTag('trackTimeValueMapProducer:generalTracksConfigurableFlatResolutionModelResolution'),
nSigmaDtVertex = cms.double(3) )
phase2_timing_layer.toModify( trackValidatorStandalone,
label_vertex = cms.untracked.InputTag('offlinePrimaryVertices4D') )
phase2_timing_layer.toModify( trackValidatorFromPVStandalone,
label_vertex = cms.untracked.InputTag('offlinePrimaryVertices4D') )
phase2_timing_layer.toModify( trackValidatorFromPVAllTPStandalone,
label_vertex = cms.untracked.InputTag('offlinePrimaryVertices4D') )
phase2_timing_layer.toModify( trackValidatorConversionStandalone,
label_vertex = cms.untracked.InputTag('offlinePrimaryVertices4D') )
phase2_timing_layer.toModify( trackValidatorGsfTracks,
label_vertex = cms.untracked.InputTag('offlinePrimaryVertices4D') )
def _addOutputCommands(mod, newCommands):
phase2_timing_layer.toModify(mod, outputCommands = mod.outputCommands + newCommands.outputCommands)
def _addOutputCommands(mod, newCommands):
phase2_timing_layer.toModify(mod, outputCommands = mod.outputCommands + newCommands.outputCommands)
outputCommands = cms.untracked.vstring('drop *'),
splitLevel = cms.untracked.int32(0),
)
RECOSIMEventContent.outputCommands.extend(RECOEventContent.outputCommands)
RECOSIMEventContent.outputCommands.extend(GeneratorInterfaceRECO.outputCommands)
RECOSIMEventContent.outputCommands.extend(RecoGenMETRECO.outputCommands)
RECOSIMEventContent.outputCommands.extend(RecoGenJetsRECO.outputCommands)
RECOSIMEventContent.outputCommands.extend(SimG4CoreRECO.outputCommands)
RECOSIMEventContent.outputCommands.extend(SimTrackerRECO.outputCommands)
RECOSIMEventContent.outputCommands.extend(SimMuonRECO.outputCommands)
RECOSIMEventContent.outputCommands.extend(SimCalorimetryRECO.outputCommands)
RECOSIMEventContent.outputCommands.extend(SimFastTimingRECO.outputCommands)
RECOSIMEventContent.outputCommands.extend(SimGeneralRECO.outputCommands)
RECOSIMEventContent.outputCommands.extend(MEtoEDMConverterRECO.outputCommands)
phase2_timing_layer.toModify(RECOSIMEventContent,
outputCommands = RECOSIMEventContent.outputCommands + RecoLocalFastTimeRECO.outputCommands)
phase2_timing_layer.toModify(RECOSIMEventContent,
outputCommands = RECOSIMEventContent.outputCommands + RecoMTDRECO.outputCommands)
#
#
# GENRAW Data Tier definition
#
#
GENRAWEventContent = cms.PSet(
outputCommands = cms.untracked.vstring('drop *'),
splitLevel = cms.untracked.int32(0),
)
GENRAWEventContent.outputCommands.extend(RAWEventContent.outputCommands)
GENRAWEventContent.outputCommands.extend(GeneratorInterfaceRECO.outputCommands)
GENRAWEventContent.outputCommands.extend(SimG4CoreRECO.outputCommands)
GENRAWEventContent.outputCommands.extend(SimTrackerRAW.outputCommands)
VertexAssociatorByPositionAndTracks,
PixelVertexAssociatorByPositionAndTracks)
tracksValidationPixelTrackingOnly = cms.Sequence(
trackValidatorPixelTrackingOnly, tracksValidationTruthPixelTrackingOnly)
### Lite mode (only generalTracks and HP)
trackValidatorLite = trackValidator.clone(
label=["generalTracks", "cutsRecoTracksHp"])
tracksValidationLite = cms.Sequence(cutsRecoTracksHp + trackValidatorLite,
tracksValidationTruth)
## customization for timing
from Configuration.Eras.Modifier_phase2_timing_layer_cff import phase2_timing_layer
phase2_timing_layer.toModify(generalTracksFromPV,
timesTag=cms.InputTag('tofPID:t0'),
timeResosTag=cms.InputTag('tofPID:sigmat0'),
nSigmaDtVertex=cms.double(3))
phase2_timing_layer.toModify(
trackValidatorStandalone,
label_vertex=cms.untracked.InputTag('offlinePrimaryVertices4D'))
phase2_timing_layer.toModify(
trackValidatorFromPVStandalone,
label_vertex=cms.untracked.InputTag('offlinePrimaryVertices4D'))
phase2_timing_layer.toModify(
trackValidatorFromPVAllTPStandalone,
label_vertex=cms.untracked.InputTag('offlinePrimaryVertices4D'))
phase2_timing_layer.toModify(
trackValidatorConversionStandalone,
label_vertex=cms.untracked.InputTag('offlinePrimaryVertices4D'))
phase2_timing_layer.toModify(
trackValidatorGsfTracks,
from Configuration.Eras.Modifier_phase2_hfnose_cff import phase2_hfnose
phase2_hfnose.toModify( theDigitizers,
hfnoseDigitizer = cms.PSet(hfnoseDigitizer),
)
from Configuration.Eras.Modifier_run3_common_cff import run3_common
run3_common.toModify( theDigitizers, castor = None )
from SimGeneral.MixingModule.ecalTimeDigitizer_cfi import ecalTimeDigitizer
from Configuration.Eras.Modifier_phase2_timing_cff import phase2_timing
from Configuration.Eras.Modifier_phase2_timing_layer_cff import phase2_timing_layer
phase2_timing.toModify( theDigitizers,
ecalTime = ecalTimeDigitizer.clone() )
from SimFastTiming.Configuration.SimFastTiming_cff import fastTimeDigitizer
phase2_timing_layer.toModify( theDigitizers,
fastTimingLayer = fastTimeDigitizer.clone() )
from SimFastTiming.Configuration.SimFastTiming_cff import mtdDigitizer
from Configuration.Eras.Modifier_phase2_timing_layer_tile_cff import phase2_timing_layer_tile
from Configuration.Eras.Modifier_phase2_timing_layer_bar_cff import phase2_timing_layer_bar
(phase2_timing_layer_tile | phase2_timing_layer_bar).toModify( theDigitizers,
fastTimingLayer = mtdDigitizer.clone() )
premix_stage2.toModify(theDigitizers,
ecal = None,
hcal = None,
)
(premix_stage2 & phase2_hgcal).toModify(theDigitizers,
hgceeDigitizer = dict(premixStage1 = True),
hgchebackDigitizer = dict(premixStage1 = True),
hgchefrontDigitizer = dict(premixStage1 = True),
from Configuration.Eras.Modifier_fastSim_cff import fastSim
fastSim.toReplaceWith(
generalTracksTask,
cms.Task(duplicateTrackCandidates, mergedDuplicateTracks,
duplicateTrackClassifier))
def _fastSimGeneralTracks(process):
from FastSimulation.Configuration.DigiAliases_cff import loadGeneralTracksAlias
loadGeneralTracksAlias(process)
modifyMergeTrackCollections_fastSimGeneralTracks = fastSim.makeProcessModifier(
_fastSimGeneralTracks)
import RecoTracker.FinalTrackSelectors.trackListMerger_cfi
conversionStepTracks = RecoTracker.FinalTrackSelectors.trackListMerger_cfi.trackListMerger.clone(
TrackProducers=['convStepTracks'],
hasSelector=[1],
selectedTrackQuals=['convStepSelector:convStep'],
setsToMerge=cms.VPSet(cms.PSet(tLists=cms.vint32(1),
pQual=cms.bool(True))),
copyExtras=True,
makeReKeyedSeeds=cms.untracked.bool(False),
)
from Configuration.Eras.Modifier_phase2_timing_layer_cff import phase2_timing_layer
phase2_timing_layer.toModify(mergedDuplicateTracks, TrajectoryInEvent=True)
phase2_timing_layer.toModify(generalTracks, copyTrajectories=True)
trackWithVertexRefSelectorBeforeSorting4D ,
trackRefsForJetsBeforeSorting4D,
offlinePrimaryVertices4D,
offlinePrimaryVertices4DWithBS,
)
_phase2_tktiming_layer_vertexrecoTask = cms.Task( _phase2_tktiming_vertexrecoTask.copy() ,
unsortedOfflinePrimaryVertices4DnoPID ,
trackWithVertexRefSelectorBeforeSorting4DnoPID ,
trackRefsForJetsBeforeSorting4DnoPID ,
offlinePrimaryVertices4DnoPID ,
offlinePrimaryVertices4DnoPIDWithBS,
tofPID,
unsortedOfflinePrimaryVertices4Dfastsim,
trackWithVertexRefSelectorBeforeSorting4Dfastsim ,
trackRefsForJetsBeforeSorting4Dfastsim ,
offlinePrimaryVertices4Dfastsim,
offlinePrimaryVertices4DfastsimWithBS,
)
from Configuration.Eras.Modifier_phase2_timing_cff import phase2_timing
phase2_timing.toReplaceWith(vertexrecoTask, _phase2_tktiming_vertexrecoTask)
from Configuration.Eras.Modifier_phase2_timing_layer_cff import phase2_timing_layer
phase2_timing_layer.toReplaceWith(vertexrecoTask, _phase2_tktiming_layer_vertexrecoTask)
phase2_timing_layer.toReplaceWith(unsortedOfflinePrimaryVertices4D, unsortedOfflinePrimaryVertices4DwithPID.clone())
phase2_timing_layer.toReplaceWith(offlinePrimaryVertices4D, offlinePrimaryVertices4DwithPID.clone())
phase2_timing_layer.toReplaceWith(offlinePrimaryVertices4DWithBS, offlinePrimaryVertices4DwithPIDWithBS.clone())
phase2_timing_layer.toModify(offlinePrimaryVertices4D, vertices = "unsortedOfflinePrimaryVertices4D", particles = "trackRefsForJetsBeforeSorting4D")
phase2_timing_layer.toModify(offlinePrimaryVertices4DWithBS, vertices = "unsortedOfflinePrimaryVertices4D:WithBS", particles = "trackRefsForJetsBeforeSorting4D")
fastSim.toReplaceWith(detachedQuadStepTrackCandidates,
_fastSim_detachedQuadStepTrackCandidates)
# TRACK FITTING
import RecoTracker.TrackProducer.TrackProducer_cfi
detachedQuadStepTracks = RecoTracker.TrackProducer.TrackProducer_cfi.TrackProducer.clone(
AlgorithmName='detachedQuadStep',
src='detachedQuadStepTrackCandidates',
Fitter='FlexibleKFFittingSmoother',
)
fastSim.toModify(detachedQuadStepTracks, TTRHBuilder='WithoutRefit')
from Configuration.Eras.Modifier_phase2_timing_layer_cff import phase2_timing_layer
phase2_timing_layer.toModify(detachedQuadStepTracks, TrajectoryInEvent=True)
# TRACK SELECTION AND QUALITY FLAG SETTING.
from RecoTracker.FinalTrackSelectors.TrackMVAClassifierDetached_cfi import *
detachedQuadStep = TrackMVAClassifierDetached.clone(
mva=dict(GBRForestLabel='MVASelectorDetachedQuadStep_Phase1'),
src='detachedQuadStepTracks',
qualityCuts=[-0.5, 0.0, 0.5])
from RecoTracker.FinalTrackSelectors.trackTfClassifier_cfi import *
from RecoTracker.FinalTrackSelectors.trackSelectionTf_cfi import *
from RecoTracker.FinalTrackSelectors.trackSelectionTf_CKF_cfi import *
trackdnn.toReplaceWith(
detachedQuadStep,
_addTiming.append( cms.PSet( importerName = cms.string("TrackTimingImporter"),
timeValueMap = cms.InputTag("trackTimeValueMapProducer:generalTracksConfigurableFlatResolutionModel"),
timeErrorMap = cms.InputTag("trackTimeValueMapProducer:generalTracksConfigurableFlatResolutionModelResolution"),
timeValueMapGsf = cms.InputTag("gsfTrackTimeValueMapProducer:electronGsfTracksConfigurableFlatResolutionModel"),
timeErrorMapGsf = cms.InputTag("gsfTrackTimeValueMapProducer:electronGsfTracksConfigurableFlatResolutionModelResolution")
)
)
from Configuration.Eras.Modifier_phase2_timing_layer_cff import phase2_timing_layer
_addTimingLayer = particleFlowBlock.elementImporters.copy()
_addTimingLayer.append( cms.PSet( importerName = cms.string("TrackTimingImporter"),
timeValueMap = cms.InputTag("tofPID:t0"),
timeErrorMap = cms.InputTag("tofPID:sigmat0"),
#this will cause no time to be set for gsf tracks
#(since this is not available for the fullsim/reconstruction yet)
#*TODO* update when gsf times are available
timeValueMapGsf = cms.InputTag("tofPID:t0"),
timeErrorMapGsf = cms.InputTag("tofPID:sigmat0")
)
)
phase2_timing.toModify(
particleFlowBlock,
elementImporters = _addTiming
)
phase2_timing_layer.toModify(
particleFlowBlock,
elementImporters = _addTimingLayer
)
unsortedOfflinePrimaryVertices4DwithPID = unsortedOfflinePrimaryVertices4D.clone(
TrackTimesLabel="tofPID4DnoPID:t0safe",
TrackTimeResosLabel="tofPID4DnoPID:sigmat0safe",
)
trackWithVertexRefSelectorBeforeSorting4DwithPID = trackWithVertexRefSelector.clone(
vertexTag="unsortedOfflinePrimaryVertices4DwithPID",
ptMax=9e99,
ptErrorCut=9e99)
trackRefsForJetsBeforeSorting4DwithPID = trackRefsForJets.clone(
src="trackWithVertexRefSelectorBeforeSorting4DwithPID")
offlinePrimaryVertices4DwithPID = offlinePrimaryVertices4D.clone(
vertices="unsortedOfflinePrimaryVertices4DwithPID",
particles="trackRefsForJetsBeforeSorting4DwithPID",
trackTimeTag="tofPID4DnoPID:t0safe",
trackTimeResoTag="tofPID4DnoPID:sigmat0safe")
offlinePrimaryVertices4DwithPIDWithBS = offlinePrimaryVertices4DwithPID.clone(
vertices="unsortedOfflinePrimaryVertices4DwithPID:WithBS")
from SimTracker.TrackerHitAssociation.tpClusterProducer_cfi import tpClusterProducer
from SimTracker.TrackAssociatorProducers.quickTrackAssociatorByHits_cfi import quickTrackAssociatorByHits
from SimTracker.TrackAssociation.trackTimeValueMapProducer_cfi import trackTimeValueMapProducer
from RecoMTD.TimingIDTools.tofPIDProducer_cfi import tofPIDProducer
tofPID4DnoPID = tofPIDProducer.clone(
vtxsSrc='unsortedOfflinePrimaryVertices4DnoPID')
tofPID = tofPIDProducer.clone()
from Configuration.Eras.Modifier_phase2_timing_layer_cff import phase2_timing_layer
phase2_timing_layer.toModify(tofPID,
vtxsSrc='unsortedOfflinePrimaryVertices4D')
muonSeededTracksInOut)
muonSeededStepCoreInOut = cms.Sequence(muonSeededStepCoreInOutTask)
muonSeededStepCoreOutInTask = cms.Task(muonSeededSeedsOutIn,
muonSeededTrackCandidatesOutIn,
muonSeededTracksOutIn)
muonSeededStepCoreOutIn = cms.Sequence(muonSeededStepCoreOutInTask)
muonSeededStepCoreTask = cms.Task(muonSeededStepCoreInOutTask,
muonSeededStepCoreOutInTask)
muonSeededStepCore = cms.Sequence(muonSeededStepCoreTask)
#Phase2 : just muon Seed InOut is used in this moment
#trackingPhase2PU140.toReplaceWith(muonSeededStepCore, muonSeededStepCoreInOut)
from Configuration.Eras.Modifier_phase2_timing_layer_cff import phase2_timing_layer
phase2_timing_layer.toModify(muonSeededTracksInOut, TrajectoryInEvent=True)
phase2_timing_layer.toModify(muonSeededTracksOutIn, TrajectoryInEvent=True)
muonSeededStepExtraInOutTask = cms.Task(muonSeededTracksInOutClassifier)
muonSeededStepExtraInOut = cms.Sequence(muonSeededStepExtraInOutTask)
trackingPhase2PU140.toReplaceWith(muonSeededStepExtraInOutTask,
cms.Task(muonSeededTracksInOutSelector))
muonSeededStepExtraTask = cms.Task(muonSeededStepExtraInOutTask,
muonSeededTracksOutInClassifier)
muonSeededStepExtra = cms.Sequence(muonSeededStepExtraTask)
trackingPhase2PU140.toReplaceWith(
muonSeededStepExtraTask,
cms.Task(muonSeededStepExtraInOutTask, muonSeededTracksOutInSelector))
trackTimeErrorMap=cms.InputTag(
"trackTimeValueMapProducer:generalTracksConfigurableFlatResolutionModelResolution"
),
gsfTrackTimeValueMap=cms.InputTag(
"gsfTrackTimeValueMapProducer:electronGsfTracksConfigurableFlatResolutionModel"
),
gsfTrackTimeErrorMap=cms.InputTag(
"gsfTrackTimeValueMapProducer:electronGsfTracksConfigurableFlatResolutionModelResolution"
),
)
from Configuration.Eras.Modifier_phase2_timing_layer_cff import phase2_timing_layer
phase2_timing_layer.toModify(
simPFProducer,
trackTimeValueMap=cms.InputTag("tofPID:t0"),
trackTimeErrorMap=cms.InputTag("tofPID:sigmat0"),
#this will cause no time to be set for gsf tracks
#(since this is not available for the fullsim/reconstruction yet)
#*TODO* update when gsf times are available
gsfTrackTimeValueMap=cms.InputTag("tofPID:t0"),
gsfTrackTimeErrorMap=cms.InputTag("tofPID:sigmat0"),
)
from Configuration.ProcessModifiers.premix_stage2_cff import premix_stage2
premix_stage2.toModify(
simPFProducer,
trackingParticleSrc="mixData:MergedTrackTruth",
caloParticlesSrc="mixData:MergedCaloTruth",
simClusterTruthSrc="mixData:MergedCaloTruth",
)
MinNumberOfCrossedLayers=3,
hitMasks=cms.InputTag('highPtTripletStepMasks'))
fastSim.toReplaceWith(highPtTripletStepTrackCandidates,
_fastSim_highPtTripletStepTrackCandidates)
# TRACK FITTING
import RecoTracker.TrackProducer.TrackProducer_cfi
highPtTripletStepTracks = RecoTracker.TrackProducer.TrackProducer_cfi.TrackProducer.clone(
src='highPtTripletStepTrackCandidates',
AlgorithmName='highPtTripletStep',
Fitter='FlexibleKFFittingSmoother',
)
fastSim.toModify(highPtTripletStepTracks, TTRHBuilder='WithoutRefit')
from Configuration.Eras.Modifier_phase2_timing_layer_cff import phase2_timing_layer
phase2_timing_layer.toModify(highPtTripletStepTracks, TrajectoryInEvent=True)
# Final selection
from RecoTracker.FinalTrackSelectors.TrackMVAClassifierPrompt_cfi import *
highPtTripletStep = TrackMVAClassifierPrompt.clone(
mva=dict(GBRForestLabel='MVASelectorHighPtTripletStep_Phase1'),
src='highPtTripletStepTracks',
qualityCuts=[0.2, 0.3, 0.4])
from RecoTracker.FinalTrackSelectors.trackTfClassifier_cfi import *
from RecoTracker.FinalTrackSelectors.trackSelectionTf_cfi import *
from RecoTracker.FinalTrackSelectors.trackSelectionTf_CKF_cfi import *
trackdnn.toReplaceWith(
highPtTripletStep,
trackTfClassifier.clone(
src='highPtTripletStepTracks',
import FWCore.ParameterSet.Config as cms
from RecoLocalFastTime.FTLRecProducers.ftlUncalibratedRecHits_cfi import ftlUncalibratedRecHits
from RecoLocalFastTime.FTLRecProducers.ftlRecHits_cfi import ftlRecHits
fastTimingLocalReco = cms.Sequence(ftlUncalibratedRecHits * ftlRecHits)
from RecoLocalFastTime.FTLRecProducers.mtdUncalibratedRecHits_cfi import mtdUncalibratedRecHits
from RecoLocalFastTime.FTLRecProducers.mtdRecHits_cfi import mtdRecHits
from RecoLocalFastTime.FTLRecProducers.mtdTrackingRecHits_cfi import mtdTrackingRecHits
from RecoLocalFastTime.FTLClusterizer.mtdClusters_cfi import mtdClusters
from RecoLocalFastTime.FTLClusterizer.MTDCPEESProducers_cff import *
from RecoLocalFastTime.FTLRecProducers.MTDTimeCalibESProducers_cff import *
_phase2_timing_layer_fastTimingLocalReco = cms.Sequence(
mtdUncalibratedRecHits * mtdRecHits * mtdClusters * mtdTrackingRecHits)
from Configuration.Eras.Modifier_phase2_timing_layer_cff import phase2_timing_layer
phase2_timing_layer.toReplaceWith(fastTimingLocalReco,
_phase2_timing_layer_fastTimingLocalReco)
phase2_timing_layer.toModify(
mtdRecHits,
barrelUncalibratedRecHits='mtdUncalibratedRecHits:FTLBarrel',
endcapUncalibratedRecHits='mtdUncalibratedRecHits:FTLEndcap')
associators = cms.VInputTag(cms.InputTag('quickTrackAssociatorByHits') )
)
from Configuration.Eras.Modifier_phase2_timing_cff import phase2_timing
phase2_timing.toModify(
simPFProducer,
trackTimeValueMap = cms.InputTag("trackTimeValueMapProducer:generalTracksConfigurableFlatResolutionModel"),
trackTimeErrorMap = cms.InputTag("trackTimeValueMapProducer:generalTracksConfigurableFlatResolutionModelResolution"),
gsfTrackTimeValueMap = cms.InputTag("gsfTrackTimeValueMapProducer:electronGsfTracksConfigurableFlatResolutionModel"),
gsfTrackTimeErrorMap = cms.InputTag("gsfTrackTimeValueMapProducer:electronGsfTracksConfigurableFlatResolutionModelResolution"),
)
from Configuration.Eras.Modifier_phase2_timing_layer_cff import phase2_timing_layer
phase2_timing_layer.toModify(
simPFProducer,
trackTimeValueMap = cms.InputTag("tofPID:t0"),
trackTimeErrorMap = cms.InputTag("tofPID:sigmat0"),
#this will cause no time to be set for gsf tracks
#(since this is not available for the fullsim/reconstruction yet)
#*TODO* update when gsf times are available
gsfTrackTimeValueMap = cms.InputTag("tofPID:t0"),
gsfTrackTimeErrorMap = cms.InputTag("tofPID:sigmat0"),
)
from Configuration.ProcessModifiers.premix_stage2_cff import premix_stage2
premix_stage2.toModify(simPFProducer,
trackingParticleSrc = "mixData:MergedTrackTruth",
caloParticlesSrc = "mixData:MergedCaloTruth",
simClusterTruthSrc = "mixData:MergedCaloTruth",
)
def _phase2_tktiming_layer_AddNewContent(mod):
temp = mod.outputCommands + _phase2_tktiming_layer_RecoVertexEventContent
phase2_timing_layer.toModify(mod, outputCommands=temp)
(premix_stage1 & phase2_muon).toModify(theMixObjects,
mixSH = dict(
pcrossingFrames = theMixObjects.mixSH.pcrossingFrames + [ 'MuonME0Hits' ]
)
)
from Configuration.Eras.Modifier_phase2_hgcal_cff import phase2_hgcal
phase2_hgcal.toModify( theMixObjects,
mixCH = dict(
input = theMixObjects.mixCH.input + [ cms.InputTag("g4SimHits",hgceeDigitizer.hitCollection.value()),
cms.InputTag("g4SimHits",hgchefrontDigitizer.hitCollection.value()) ],
subdets = theMixObjects.mixCH.subdets + [ hgceeDigitizer.hitCollection.value(),
hgchefrontDigitizer.hitCollection.value() ],
)
)
from Configuration.Eras.Modifier_phase2_hfnose_cff import phase2_hfnose
phase2_hfnose.toModify( theMixObjects,
mixCH = dict(
input = theMixObjects.mixCH.input + [ cms.InputTag("g4SimHits",hfnoseDigitizer.hitCollection.value()) ],
subdets = theMixObjects.mixCH.subdets + [ hfnoseDigitizer.hitCollection.value() ],
)
)
from Configuration.Eras.Modifier_phase2_timing_layer_cff import phase2_timing_layer
phase2_timing_layer.toModify( theMixObjects,
mixSH = dict(
input = theMixObjects.mixSH.input + [ cms.InputTag("g4SimHits","FastTimerHitsBarrel"), cms.InputTag("g4SimHits","FastTimerHitsEndcap") ],
subdets = theMixObjects.mixSH.subdets + [ 'FastTimerHitsBarrel','FastTimerHitsEndcap' ],
crossingFrames = theMixObjects.mixSH.crossingFrames + [ 'FastTimerHitsBarrel','FastTimerHitsEndcap' ]
)
)
)
### Lite mode (only generalTracks and HP)
trackValidatorLite = trackValidator.clone(
label = ["generalTracks", "cutsRecoTracksHp"]
)
tracksValidationLite = cms.Sequence(
cutsRecoTracksHp +
trackValidatorLite,
tracksValidationTruth
)
## customization for timing
from Configuration.Eras.Modifier_phase2_timing_layer_cff import phase2_timing_layer
phase2_timing_layer.toModify( generalTracksFromPV,
vertexTag = cms.InputTag('offlinePrimaryVertices4D'),
timesTag = cms.InputTag('trackTimeValueMapProducer:generalTracksConfigurableFlatResolutionModel'),
timeResosTag = cms.InputTag('trackTimeValueMapProducer:generalTracksConfigurableFlatResolutionModelResolution'),
nSigmaDtVertex = cms.double(3) )
phase2_timing_layer.toModify( trackValidatorStandalone,
label_vertex = cms.untracked.InputTag('offlinePrimaryVertices4D') )
phase2_timing_layer.toModify( trackValidatorFromPVStandalone,
label_vertex = cms.untracked.InputTag('offlinePrimaryVertices4D') )
phase2_timing_layer.toModify( trackValidatorFromPVAllTPStandalone,
label_vertex = cms.untracked.InputTag('offlinePrimaryVertices4D') )
phase2_timing_layer.toModify( trackValidatorConversionStandalone,
label_vertex = cms.untracked.InputTag('offlinePrimaryVertices4D') )
phase2_timing_layer.toModify( trackValidatorGsfTracks,
label_vertex = cms.untracked.InputTag('offlinePrimaryVertices4D') )
'keep *_generalV0Candidates_*_*',
'keep *_inclusiveSecondaryVertices_*_*')
)
from Configuration.Eras.Modifier_phase2_timing_cff import phase2_timing
from Configuration.Eras.Modifier_phase2_timing_layer_cff import phase2_timing_layer
_phase2_tktiming_RecoVertexEventContent = [ 'keep *_offlinePrimaryVertices4D__*',
'keep *_offlinePrimaryVertices4DWithBS__*',
'keep *_trackTimeValueMapProducer_*_*' ]
_phase2_tktiming_layer_RecoVertexEventContent = [ 'keep *_offlinePrimaryVertices4DnoPID__*',
'keep *_offlinePrimaryVertices4DnoPIDWithBS__*',
'keep *_tofPID_*_*']
phase2_timing.toModify( RecoVertexAOD,
outputCommands = RecoVertexAOD.outputCommands + _phase2_tktiming_RecoVertexEventContent)
phase2_timing_layer.toModify( RecoVertexAOD,
outputCommands = RecoVertexAOD.outputCommands + _phase2_tktiming_layer_RecoVertexEventContent)
#RECO content
RecoVertexRECO = cms.PSet(
outputCommands = cms.untracked.vstring()
)
RecoVertexRECO.outputCommands.extend(RecoVertexAOD.outputCommands)
#FEVT content
RecoVertexFEVT = cms.PSet(
outputCommands = cms.untracked.vstring()
)
RecoVertexFEVT.outputCommands.extend(RecoVertexRECO.outputCommands)
subdets = theMixObjects.mixSH.subdets + [ 'MuonGEMHits' ],
crossingFrames = theMixObjects.mixSH.crossingFrames + [ 'MuonGEMHits' ]
)
)
from Configuration.Eras.Modifier_phase2_muon_cff import phase2_muon
phase2_muon.toModify( theMixObjects,
mixSH = dict(
input = theMixObjects.mixSH.input + [ cms.InputTag("g4SimHits","MuonME0Hits") ],
subdets = theMixObjects.mixSH.subdets + [ 'MuonME0Hits' ],
crossingFrames = theMixObjects.mixSH.crossingFrames + [ 'MuonME0Hits' ]
)
)
from Configuration.Eras.Modifier_phase2_hgcal_cff import phase2_hgcal
phase2_hgcal.toModify( theMixObjects,
mixCH = dict(
input = theMixObjects.mixCH.input + [ cms.InputTag("g4SimHits",hgceeDigitizer.hitCollection.value()),
cms.InputTag("g4SimHits",hgchefrontDigitizer.hitCollection.value()) ],
subdets = theMixObjects.mixCH.subdets + [ hgceeDigitizer.hitCollection.value(),
hgchefrontDigitizer.hitCollection.value() ]
)
)
from Configuration.Eras.Modifier_phase2_timing_layer_cff import phase2_timing_layer
phase2_timing_layer.toModify( theMixObjects,
mixSH = dict(
input = theMixObjects.mixSH.input + [ cms.InputTag("g4SimHits","FastTimerHitsBarrel"), cms.InputTag("g4SimHits","FastTimerHitsEndcap") ],
subdets = theMixObjects.mixSH.subdets + [ 'FastTimerHitsBarrel','FastTimerHitsEndcap' ],
crossingFrames = theMixObjects.mixSH.crossingFrames + [ 'FastTimerHitsBarrel','FastTimerHitsEndcap' ]
)
)
labelSig=cms.InputTag("simSiPixelDigis:Tracker"),
pileInputTag=cms.InputTag("simSiPixelDigis:Tracker"),
collectionDM=cms.string("Phase2OTDigiSimLink"),
),
),
)
# MTD
phase2_timing_layer.toModify(
mixData,
workers=dict(
mtdBarrel=cms.PSet(
mtdDigitizer.barrelDigitizer,
workerType=cms.string("PreMixingMTDWorker"),
digiTagSig=cms.InputTag("mix", "FTLBarrel"),
pileInputTag=cms.InputTag("mix", "FTLBarrel"),
),
mtdEndcap=cms.PSet(
mtdDigitizer.endcapDigitizer,
workerType=cms.string("PreMixingMTDWorker"),
digiTagSig=cms.InputTag("mix", "FTLEndcap"),
pileInputTag=cms.InputTag("mix", "FTLEndcap"),
),
))
# ECAL
phase2_common.toModify(mixData, workers=dict(ecal=dict(doES=False)))
phase2_hgcal.toModify(mixData, workers=dict(ecal=dict(doEE=False)))
# HGCAL
phase2_hgcal.toModify(
mixData,
workers=dict(hgcee=cms.PSet(
maxDzpvsigCumulative = cms.double(10),
nintDzpvsigCumulative = cms.int32(200),
seedingLayerSets = cms.vstring(),
doMTDPlots = cms.untracked.bool(False), # meant to be switch on in Phase2 workflows
)
def _modifyForPhase1(pset):
pset.minEta = -3
pset.maxEta = 3
pset.nintEta = 60
from Configuration.Eras.Modifier_phase1Pixel_cff import phase1Pixel
#phase1Pixel.toModify(MTVHistoProducerAlgoForTrackerBlock, dict(minEta = -3, maxEta = 3, nintEta = 60) )
phase1Pixel.toModify(MTVHistoProducerAlgoForTrackerBlock, _modifyForPhase1)
def _modifyForPhase2(pset):
pset.minEta = -4.5
pset.maxEta = 4.5
pset.nintEta = 90
from Configuration.Eras.Modifier_phase2_tracker_cff import phase2_tracker
#phase2_tracker.toModify(MTVHistoProducerAlgoForTrackerBlock, dict(minEta = -4.5, maxEta = 4.5, nintEta = 90) )
phase2_tracker.toModify(MTVHistoProducerAlgoForTrackerBlock, _modifyForPhase2)
def _modifyForPhase2wMTD(pset):
pset.doMTDPlots = True
from Configuration.Eras.Modifier_phase2_timing_layer_cff import phase2_timing_layer
#phase2_timing_layer.toModify(MTVHistoProducerAlgoForTrackerBlock, dict(doMTDPlots = True) )
phase2_timing_layer.toModify(MTVHistoProducerAlgoForTrackerBlock, _modifyForPhase2wMTD)
ComponentName='pixelLessStepTrajectoryCleanerBySharedHits',
fractionShared=0.11,
allowSharedFirstHit=True)
trackingLowPU.toModify(pixelLessStepTrajectoryCleanerBySharedHits,
fractionShared=0.19)
# TRACK FITTING
import RecoTracker.TrackProducer.TrackProducer_cfi
pixelLessStepTracks = RecoTracker.TrackProducer.TrackProducer_cfi.TrackProducer.clone(
src='pixelLessStepTrackCandidates',
AlgorithmName='pixelLessStep',
Fitter='FlexibleKFFittingSmoother')
fastSim.toModify(pixelLessStepTracks, TTRHBuilder='WithoutRefit')
from Configuration.Eras.Modifier_phase2_timing_layer_cff import phase2_timing_layer
phase2_timing_layer.toModify(pixelLessStepTracks, TrajectoryInEvent=True)
# TRACK SELECTION AND QUALITY FLAG SETTING.
from RecoTracker.FinalTrackSelectors.TrackMVAClassifierPrompt_cfi import *
from RecoTracker.FinalTrackSelectors.TrackMVAClassifierDetached_cfi import *
pixelLessStepClassifier1 = TrackMVAClassifierPrompt.clone(
src='pixelLessStepTracks',
mva=dict(GBRForestLabel='MVASelectorIter5_13TeV'),
qualityCuts=[-0.4, 0.0, 0.4])
fastSim.toModify(pixelLessStepClassifier1,
vertices='firstStepPrimaryVerticesBeforeMixing')
pixelLessStepClassifier2 = TrackMVAClassifierPrompt.clone(
src='pixelLessStepTracks',
mva=dict(GBRForestLabel='MVASelectorIter0_13TeV'),
qualityCuts=[-0.0, 0.0, 0.0])
_vertexAnalysisSequenceTrackingOnly_trackingLowPU += (
selectedPixelVertices
+ pixelVertexAnalysisTrackingOnly
)
trackingLowPU.toReplaceWith(vertexAnalysisSequenceTrackingOnly, _vertexAnalysisSequenceTrackingOnly_trackingLowPU)
vertexAnalysisSequencePixelTrackingOnly = cms.Sequence(
selectedPixelVertices
+ pixelVertexAnalysisPixelTrackingOnly
)
from Configuration.Eras.Modifier_phase2_timing_layer_cff import phase2_timing_layer
_vertexRecoCollectionsTiming = cms.VInputTag("offlinePrimaryVertices",
"offlinePrimaryVerticesWithBS",
"selectedOfflinePrimaryVertices",
"selectedOfflinePrimaryVerticesWithBS",
"offlinePrimaryVertices4D",
"selectedOfflinePrimaryVertices4D",
)
selectedOfflinePrimaryVertices4D = selectedOfflinePrimaryVertices.clone(src = cms.InputTag("offlinePrimaryVertices4D"))
_vertexAnalysisSelectionTiming = vertexAnalysisSelection.copy()
_vertexAnalysisSelectionTiming += selectedOfflinePrimaryVertices4D
phase2_timing_layer.toModify( vertexAnalysis,
vertexRecoCollections = _vertexRecoCollectionsTiming
)
phase2_timing_layer.toReplaceWith( vertexAnalysisSelection,
_vertexAnalysisSelectionTiming )
timeValueMapGsf = cms.InputTag("gsfTrackTimeValueMapProducer:electronGsfTracksConfigurableFlatResolutionModel"),
timeErrorMapGsf = cms.InputTag("gsfTrackTimeValueMapProducer:electronGsfTracksConfigurableFlatResolutionModelResolution")
)
)
from Configuration.Eras.Modifier_phase2_timing_layer_cff import phase2_timing_layer
_addTimingLayer = particleFlowBlock.elementImporters.copy()
_addTimingLayer.append( cms.PSet( importerName = cms.string("TrackTimingImporter"),
timeValueMap = cms.InputTag("tofPID:t0"),
timeErrorMap = cms.InputTag("tofPID:sigmat0"),
timeQualityMap = cms.InputTag("mtdTrackQualityMVA:mtdQualMVA"),
timeQualityThreshold = cms.double(0.5),
#this will cause no time to be set for gsf tracks
#(since this is not available for the fullsim/reconstruction yet)
#*TODO* update when gsf times are available
timeValueMapGsf = cms.InputTag("tofPID:t0"),
timeErrorMapGsf = cms.InputTag("tofPID:sigmat0"),
timeQualityMapGsf = cms.InputTag("mtdTrackQualityMVA:mtdQualMVA"),
)
)
phase2_timing.toModify(
particleFlowBlock,
elementImporters = _addTiming
)
phase2_timing_layer.toModify(
particleFlowBlock,
elementImporters = _addTimingLayer
)
phase2_hgcal.toModify(
theDigitizers,
hgceeDigitizer=cms.PSet(hgceeDigitizer),
hgchebackDigitizer=cms.PSet(hgchebackDigitizer),
hgchefrontDigitizer=cms.PSet(hgchefrontDigitizer),
)
from Configuration.Eras.Modifier_run3_common_cff import run3_common
run3_common.toModify(theDigitizers, castor=None)
from SimGeneral.MixingModule.ecalTimeDigitizer_cfi import ecalTimeDigitizer
from Configuration.Eras.Modifier_phase2_timing_cff import phase2_timing
from Configuration.Eras.Modifier_phase2_timing_layer_cff import phase2_timing_layer
phase2_timing.toModify(theDigitizers, ecalTime=ecalTimeDigitizer.clone())
from SimFastTiming.Configuration.SimFastTiming_cff import fastTimeDigitizer
phase2_timing_layer.toModify(theDigitizers,
fastTimingLayer=fastTimeDigitizer.clone())
theDigitizersValid = cms.PSet(theDigitizers)
theDigitizers.mergedtruth.select.signalOnlyTP = cms.bool(True)
phase2_hgcal.toModify(theDigitizersValid, calotruth=cms.PSet(caloParticles))
phase2_timing.toModify(theDigitizersValid.mergedtruth,
createInitialVertexCollection=cms.bool(True))
import FastSimulation.Tracking.TrackCandidateProducer_cfi
fastSim.toReplaceWith(
initialStepTrackCandidates,
FastSimulation.Tracking.TrackCandidateProducer_cfi.trackCandidateProducer.
clone(src='initialStepSeeds', MinNumberOfCrossedLayers=3))
# fitting
import RecoTracker.TrackProducer.TrackProducer_cfi
initialStepTracks = RecoTracker.TrackProducer.TrackProducer_cfi.TrackProducer.clone(
src='initialStepTrackCandidates',
AlgorithmName='initialStep',
Fitter='FlexibleKFFittingSmoother')
fastSim.toModify(initialStepTracks, TTRHBuilder='WithoutRefit')
from Configuration.Eras.Modifier_phase2_timing_layer_cff import phase2_timing_layer
phase2_timing_layer.toModify(initialStepTracks, TrajectoryInEvent=True)
#vertices
from RecoVertex.PrimaryVertexProducer.OfflinePrimaryVertices_cfi import offlinePrimaryVertices as _offlinePrimaryVertices
firstStepPrimaryVerticesUnsorted = _offlinePrimaryVertices.clone(
TrackLabel='initialStepTracks',
vertexCollections=[_offlinePrimaryVertices.vertexCollections[0].clone()])
(pp_on_XeXe_2017 | pp_on_AA).toModify(
firstStepPrimaryVerticesUnsorted,
TkFilterParameters=dict(trackQuality='any'))
# we need a replacment for the firstStepPrimaryVerticesUnsorted
# that includes tracker information of signal and pile up
# after mixing there is no such thing as initialStepTracks,
# so we replace the input collection for firstStepPrimaryVerticesUnsorted with generalTracks
firstStepPrimaryVerticesBeforeMixing = firstStepPrimaryVerticesUnsorted.clone()
unsortedOfflinePrimaryVertices4DnoPID,
trackWithVertexRefSelectorBeforeSorting4DnoPID,
trackRefsForJetsBeforeSorting4DnoPID,
offlinePrimaryVertices4DnoPID,
offlinePrimaryVertices4DnoPIDWithBS,
tofPID,
tofPID4DnoPID,
)
from Configuration.Eras.Modifier_phase2_timing_cff import phase2_timing
phase2_timing.toReplaceWith(vertexrecoTask, _phase2_tktiming_vertexrecoTask)
from Configuration.Eras.Modifier_phase2_timing_layer_cff import phase2_timing_layer
phase2_timing_layer.toReplaceWith(vertexrecoTask,
_phase2_tktiming_layer_vertexrecoTask)
phase2_timing_layer.toReplaceWith(
unsortedOfflinePrimaryVertices4D,
unsortedOfflinePrimaryVertices4DwithPID.clone())
phase2_timing_layer.toReplaceWith(offlinePrimaryVertices4D,
offlinePrimaryVertices4DwithPID.clone())
phase2_timing_layer.toReplaceWith(
offlinePrimaryVertices4DWithBS,
offlinePrimaryVertices4DwithPIDWithBS.clone())
phase2_timing_layer.toModify(offlinePrimaryVertices4D,
vertices="unsortedOfflinePrimaryVertices4D",
particles="trackRefsForJetsBeforeSorting4D")
phase2_timing_layer.toModify(
offlinePrimaryVertices4DWithBS,
vertices="unsortedOfflinePrimaryVertices4D:WithBS",
particles="trackRefsForJetsBeforeSorting4D")
MinNumberOfCrossedLayers=3,
hitMasks=cms.InputTag('lowPtQuadStepMasks'))
fastSim.toReplaceWith(lowPtQuadStepTrackCandidates,
_fastSim_lowPtQuadStepTrackCandidates)
# TRACK FITTING
import RecoTracker.TrackProducer.TrackProducer_cfi
lowPtQuadStepTracks = RecoTracker.TrackProducer.TrackProducer_cfi.TrackProducer.clone(
src='lowPtQuadStepTrackCandidates',
AlgorithmName='lowPtQuadStep',
Fitter='FlexibleKFFittingSmoother',
)
fastSim.toModify(lowPtQuadStepTracks, TTRHBuilder='WithoutRefit')
from Configuration.Eras.Modifier_phase2_timing_layer_cff import phase2_timing_layer
phase2_timing_layer.toModify(lowPtQuadStepTracks, TrajectoryInEvent=True)
# Final selection
from RecoTracker.FinalTrackSelectors.TrackMVAClassifierPrompt_cfi import *
lowPtQuadStep = TrackMVAClassifierPrompt.clone(
mva=dict(GBRForestLabel='MVASelectorLowPtQuadStep_Phase1'),
src='lowPtQuadStepTracks',
qualityCuts=[-0.7, -0.35, -0.15])
from RecoTracker.FinalTrackSelectors.trackTfClassifier_cfi import *
from RecoTracker.FinalTrackSelectors.trackSelectionTf_cfi import *
from RecoTracker.FinalTrackSelectors.trackSelectionTf_CKF_cfi import *
trackdnn.toReplaceWith(
lowPtQuadStep,
trackTfClassifier.clone(
src='lowPtQuadStepTracks',
_vertexAnalysisSequenceTrackingOnly_trackingLowPU += (
selectedPixelVertices
+ pixelVertexAnalysisTrackingOnly
)
trackingLowPU.toReplaceWith(vertexAnalysisSequenceTrackingOnly, _vertexAnalysisSequenceTrackingOnly_trackingLowPU)
vertexAnalysisSequencePixelTrackingOnly = cms.Sequence(
selectedPixelVertices
+ pixelVertexAnalysisPixelTrackingOnly
)
from Configuration.Eras.Modifier_phase2_timing_layer_cff import phase2_timing_layer
_vertexRecoCollectionsTiming = cms.VInputTag("offlinePrimaryVertices",
"offlinePrimaryVerticesWithBS",
"selectedOfflinePrimaryVertices",
"selectedOfflinePrimaryVerticesWithBS",
"offlinePrimaryVertices4D",
"selectedOfflinePrimaryVertices4D",
)
selectedOfflinePrimaryVertices4D = selectedOfflinePrimaryVertices.clone(src = cms.InputTag("offlinePrimaryVertices4D"))
_vertexAnalysisSelectionTiming = vertexAnalysisSelection.copy()
_vertexAnalysisSelectionTiming += selectedOfflinePrimaryVertices4D
phase2_timing_layer.toModify( vertexAnalysis,
vertexRecoCollections = _vertexRecoCollectionsTiming
)
phase2_timing_layer.toReplaceWith( vertexAnalysisSelection,
_vertexAnalysisSelectionTiming )
def _phase2_tktiming_layer_AddNewContent(mod):
temp = mod.outputCommands + _phase2_tktiming_layer_RecoVertexEventContent
phase2_timing_layer.toModify( mod, outputCommands = temp )