示例#1
0
                             conversionOpenTrackSequence*
                             gsfTracksOpenConversionSequence 
                             )

# AA data with pp reco
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
from RecoHI.HiTracking.HILowPtConformalPixelTracks_cfi import *
from RecoHI.HiCentralityAlgos.HiCentrality_cfi import hiCentrality
from RecoHI.HiCentralityAlgos.HiClusterCompatibility_cfi import hiClusterCompatibility
_highlevelreco_HI = highlevelreco.copy()
_highlevelreco_HI += hiConformalPixelTracksSequencePhase1
_highlevelreco_HI += hiCentrality
_highlevelreco_HI += hiClusterCompatibility
(pp_on_XeXe_2017 | pp_on_AA_2018).toReplaceWith(highlevelreco, _highlevelreco_HI)
pp_on_AA_2018.toReplaceWith(highlevelreco,highlevelreco.copyAndExclude([PFTau]))

# not commisoned and not relevant in FastSim (?):
_fastSim_highlevelreco = highlevelreco.copyAndExclude([cosmicDCTracksSeq,muoncosmichighlevelreco])
fastSim.toReplaceWith(highlevelreco,_fastSim_highlevelreco)


from FWCore.Modules.logErrorHarvester_cfi import *

# "Export" Section
reconstruction         = cms.Sequence(localreco*globalreco*highlevelreco*logErrorHarvester)

#logErrorHarvester should only wait for items produced in the reconstruction sequence
_modulesInReconstruction = list()
reconstruction.visit(cms.ModuleNamesFromGlobalsVisitor(globals(),_modulesInReconstruction))
logErrorHarvester.includeModules = cms.untracked.vstring(set(_modulesInReconstruction))
interestingOotEgammaIsoESDetId.eeClusToESMapLabel=cms.InputTag("particleFlowClusterOOTECAL")
interestingOotEgammaIsoESDetId.ecalPFClustersLabel=cms.InputTag("particleFlowClusterOOTECAL")
interestingOotEgammaIsoESDetId.phosLabel=cms.InputTag("ootPhotons")
interestingOotEgammaIsoESDetId.elesLabel=cms.InputTag("")
interestingOotEgammaIsoESDetId.superClustersLabel=cms.InputTag("")

interestingEgammaIsoDetIdsTask = cms.Task(
    interestingGedEleIsoDetIdEB ,
    interestingGedEleIsoDetIdEE , 
    interestingGedGamIsoDetIdEB , 
    interestingGedGamIsoDetIdEE ,   
    interestingOotGamIsoDetIdEB , 
    interestingOotGamIsoDetIdEE ,   
    interestingGamIsoDetIdEB , 
    interestingGamIsoDetIdEE ,
    interestingGedEgammaIsoHCALDetId,
    interestingOotEgammaIsoHCALDetId,
    interestingGedEgammaIsoESDetId,
    interestingOotEgammaIsoESDetId
)
interestingEgammaIsoDetIds = cms.Sequence(interestingEgammaIsoDetIdsTask)

_pp_on_AA_interestingEgammaIsoDetIdsTask = interestingEgammaIsoDetIdsTask.copy()
_pp_on_AA_interestingEgammaIsoDetIdsTask.remove(interestingOotGamIsoDetIdEB)
_pp_on_AA_interestingEgammaIsoDetIdsTask.remove(interestingOotGamIsoDetIdEE)
_pp_on_AA_interestingEgammaIsoDetIdsTask.remove(interestingOotEgammaIsoHCALDetId)
_pp_on_AA_interestingEgammaIsoDetIdsTask.remove(interestingOotEgammaIsoESDetId)

from Configuration.Eras.Modifier_pp_on_AA_2018_cff import pp_on_AA_2018
pp_on_AA_2018.toReplaceWith(interestingEgammaIsoDetIdsTask, _pp_on_AA_interestingEgammaIsoDetIdsTask)
示例#3
0
    BPix = dict(skipClusters = 'pixelPairStepSeedClusterMask'),
    FPix = dict(skipClusters = 'pixelPairStepSeedClusterMask')
)

from RecoTracker.TkTrackingRegions.globalTrackingRegionFromBeamSpot_cfi import globalTrackingRegionFromBeamSpot as _globalTrackingRegionFromBeamSpot
tripletElectronTrackingRegions = _globalTrackingRegionFromBeamSpot.clone(RegionPSet = dict(
    ptMin = 1.0,
    originRadius = 0.02,
    nSigmaZ = 4.0
))

from Configuration.Eras.Modifier_pp_on_AA_2018_cff import pp_on_AA_2018
from RecoTracker.TkTrackingRegions.globalTrackingRegionWithVertices_cff import globalTrackingRegionWithVertices as _globalTrackingRegionWithVertices
pp_on_AA_2018.toReplaceWith(tripletElectronTrackingRegions,
    _globalTrackingRegionWithVertices.clone(
        RegionPSet = dict(
            fixedError = 0.5,
            ptMin = 8.0,
            originRadius = 0.02)))

from RecoTracker.TkHitPairs.hitPairEDProducer_cfi import hitPairEDProducer as _hitPairEDProducer
tripletElectronHitDoublets = _hitPairEDProducer.clone(
    seedingLayers = "tripletElectronSeedLayers",
    trackingRegions = "tripletElectronTrackingRegions",
    maxElement = 0,
    produceIntermediateHitDoublets = True,
)
from RecoPixelVertexing.PixelTriplets.pixelTripletHLTEDProducer_cfi import pixelTripletHLTEDProducer as _pixelTripletHLTEDProducer
import RecoPixelVertexing.PixelLowPtUtilities.LowPtClusterShapeSeedComparitor_cfi
tripletElectronHitTriplets = _pixelTripletHLTEDProducer.clone(
    doublets = "tripletElectronHitDoublets",
    maxElement = 1000000,
hfrecoMBNZS.firstSample = 2   # Run 2 default before 2017
hfrecoMBNZS.samplesToAdd = 2
hfrecoMBNZS.digiLabel = 'hcalDigiAlCaMB'
hfrecoMBNZS.tsFromDB = cms.bool(False)
hfrecoMBNZS.dropZSmarkedPassed = cms.bool(False)

seqALCARECOHcalCalMinBiasDigi = cms.Sequence(hcalminbiasHLT*hcalDigiAlCaMB*gtDigisAlCaMB)
seqALCARECOHcalCalMinBiasDigiNoHLT = cms.Sequence(hcalDigiAlCaMB*gtDigisAlCaMB)

seqALCARECOHcalCalMinBias = cms.Sequence(hbherecoMBNZS*horecoMBNZS*hbherecoNoise*hfrecoNoise*hfrecoMBNZS*horecoNoise)

#Specify to use HI output for the pp_on_AA_2018 eras
seqALCARECOHcalCalMinBiasHI = cms.Sequence(hbherecoNoise*hfrecoNoise*hfrecoMBNZS*horecoNoise)
pp_on_AA_2018.toReplaceWith(seqALCARECOHcalCalMinBias,
                            seqALCARECOHcalCalMinBiasHI
)

import RecoLocalCalo.HcalRecProducers.hfprereco_cfi
hfprerecoNoise = RecoLocalCalo.HcalRecProducers.hfprereco_cfi.hfprereco.clone(
    digiLabel = cms.InputTag("hcalDigiAlCaMB"),
    dropZSmarkedPassed = cms.bool(False),
    tsFromDB = cms.bool(False),
    sumAllTimeSlices = cms.bool(False),
    forceSOI = cms.int32(0)
)
hfprerecoMBNZS = RecoLocalCalo.HcalRecProducers.hfprereco_cfi.hfprereco.clone(
    digiLabel = cms.InputTag("hcalDigiAlCaMB"),
    dropZSmarkedPassed = cms.bool(False),
    tsFromDB = cms.bool(False),
    sumAllTimeSlices = cms.bool(True),
示例#5
0
PostDQMOfflineMiniAOD = cms.Sequence(
    miniAODDQMSequence * jetMETDQMOfflineSourceMiniAOD * tracksDQMMiniAOD *
    topPhysicsminiAOD)
PostDQMOffline = cms.Sequence()

from Configuration.Eras.Modifier_phase2_hcal_cff import phase2_hcal
phase2_hcal.toReplaceWith(
    PostDQMOfflineMiniAOD,
    PostDQMOfflineMiniAOD.copyAndExclude([
        pfMetDQMAnalyzerMiniAOD,
        pfPuppiMetDQMAnalyzerMiniAOD  # No hcalnoise yet
    ]))

from Configuration.Eras.Modifier_pp_on_AA_2018_cff import pp_on_AA_2018
_pfTauRunDQMValidation = cms.Sequence()
pp_on_AA_2018.toReplaceWith(pfTauRunDQMValidation, _pfTauRunDQMValidation)

from PhysicsTools.NanoAOD.nanoDQM_cff import nanoDQM
DQMOfflineNanoAOD = cms.Sequence(nanoDQM)
#PostDQMOfflineNanoAOD = cms.Sequence(nanoDQM)

# L1 trigger sequences
DQMOfflineL1TMonitoring = cms.Sequence(
    l1TriggerDqmOffline
)  # L1 emulator is run within this sequence for real data

DQMOfflineL1TEgamma = cms.Sequence(l1TriggerEgDqmOffline)

DQMOfflineL1TMuon = cms.Sequence(l1TriggerMuonDqmOffline)
示例#6
0
DQMOfflineCommonSiStripZeroBiasFakeHLT = cms.Sequence(
    DQMOfflineCommonSiStripZeroBias)
DQMOfflineCommonSiStripZeroBiasFakeHLT.remove(DQMOfflineTrigger)

#Other definitons
from DQMOffline.Lumi.ZCounting_cff import *

DQMOfflineLumi = cms.Sequence(zcounting)

DQMOfflineMuon = cms.Sequence(dtSources * rpcTier0Source * cscSources *
                              muonMonitors)

#Taus not created in pp conditions for HI
from Configuration.Eras.Modifier_pp_on_AA_2018_cff import pp_on_AA_2018
_DQMOfflineTAU = cms.Sequence()
pp_on_AA_2018.toReplaceWith(DQMOfflineTAU, _DQMOfflineTAU)

# miniAOD DQM validation
from Validation.RecoParticleFlow.miniAODDQM_cff import *  # On MiniAOD vs RECO
from Validation.RecoParticleFlow.DQMForPF_MiniAOD_cff import *  # MiniAOD PF variables
from DQM.TrackingMonitor.tracksDQMMiniAOD_cff import *
from DQMOffline.Muon.miniAOD_cff import *
from DQM.Physics.DQMTopMiniAOD_cff import *

DQMOfflineMiniAOD = cms.Sequence(jetMETDQMOfflineRedoProductsMiniAOD *
                                 muonMonitors_miniAOD * MuonMiniAOD *
                                 DQMOfflinePF)

#Post sequences are automatically placed in the EndPath by ConfigBuilder if PAT is run.
#miniAOD DQM sequences need to access the filter results.
示例#7
0
import FWCore.ParameterSet.Config as cms

from RecoJets.JetProducers.ak4CaloJets_cfi import ak4CaloJets as _ak4CaloJets
from RecoHI.HiJetAlgos.HiRecoJets_cff import akPu4CaloJets as _akPu4CaloJets
from RecoLocalCalo.CaloTowersCreator.calotowermaker_cfi import calotowermaker
caloTowerForTrk = calotowermaker.clone(hbheInput=cms.InputTag('hbheprereco'))
ak4CaloJetsForTrk = _ak4CaloJets.clone(srcPVs = cms.InputTag('firstStepPrimaryVerticesUnsorted'), src= cms.InputTag('caloTowerForTrk'))
from Configuration.Eras.Modifier_pp_on_AA_2018_cff import pp_on_AA_2018
pp_on_AA_2018.toReplaceWith(ak4CaloJetsForTrk, _akPu4CaloJets.clone(srcPVs = cms.InputTag('firstStepPrimaryVerticesUnsorted'), src= cms.InputTag('caloTowerForTrk')))
from Configuration.Eras.Modifier_trackingLowPU_cff import trackingLowPU
trackingLowPU.toModify(ak4CaloJetsForTrk,
    srcPVs = "pixelVertices"
)

caloJetsForTrkTask = cms.Task(caloTowerForTrk,ak4CaloJetsForTrk)
caloJetsForTrk = cms.Sequence(caloJetsForTrkTask)

from Configuration.Eras.Modifier_phase2_hcal_cff import phase2_hcal
phase2_hcal.toModify( caloTowerForTrk, hbheInput = cms.InputTag("hbhereco") )

示例#8
0
from DQMOffline.Muon.miniAOD_cff import *

DQMOfflineMiniAOD = cms.Sequence(jetMETDQMOfflineRedoProductsMiniAOD*muonMonitors_miniAOD*MuonMiniAOD)

#Post sequences are automatically placed in the EndPath by ConfigBuilder if PAT is run.
#miniAOD DQM sequences need to access the filter results.


PostDQMOfflineMiniAOD = cms.Sequence(miniAODDQMSequence*jetMETDQMOfflineSourceMiniAOD*tracksDQMMiniAOD*topPhysicsminiAOD)
PostDQMOffline = cms.Sequence()

from Configuration.Eras.Modifier_phase2_hcal_cff import phase2_hcal
phase2_hcal.toReplaceWith( PostDQMOfflineMiniAOD, PostDQMOfflineMiniAOD.copyAndExclude([
    pfMetDQMAnalyzerMiniAOD, pfPuppiMetDQMAnalyzerMiniAOD # No hcalnoise yet
]))

from Configuration.Eras.Modifier_pp_on_AA_2018_cff import pp_on_AA_2018
_pfTauRunDQMValidation = cms.Sequence()
pp_on_AA_2018.toReplaceWith(pfTauRunDQMValidation, _pfTauRunDQMValidation)

from PhysicsTools.NanoAOD.nanoDQM_cff import nanoDQM
DQMOfflineNanoAOD = cms.Sequence(nanoDQM)
#PostDQMOfflineNanoAOD = cms.Sequence(nanoDQM)

# L1 trigger sequences
DQMOfflineL1TMonitoring = cms.Sequence( l1TriggerDqmOffline ) # L1 emulator is run within this sequence for real data

DQMOfflineL1TEgamma = cms.Sequence( l1TriggerEgDqmOffline )

DQMOfflineL1TMuon = cms.Sequence( l1TriggerMuonDqmOffline )
示例#9
0
import FWCore.ParameterSet.Config as cms

from RecoParticleFlow.PFTracking.trackerDrivenElectronSeeds_cff import *
from RecoEgamma.EgammaElectronProducers.ecalDrivenElectronSeeds_cfi import *
from RecoParticleFlow.PFTracking.mergedElectronSeeds_cfi import *

electronSeedsTask = cms.Task(trackerDrivenElectronSeeds,ecalDrivenElectronSeeds,electronMergedSeeds) 
electronSeeds = cms.Sequence(electronSeedsTask)
_electronSeedsTaskFromMultiCl = electronSeedsTask.copy()
_electronSeedsTaskFromMultiCl.add(cms.Task(ecalDrivenElectronSeedsFromMultiCl,electronMergedSeedsFromMultiCl))
_electronSeedsFromMultiCl = cms.Sequence(_electronSeedsTaskFromMultiCl)

from Configuration.Eras.Modifier_pp_on_AA_2018_cff import pp_on_AA_2018
pp_on_AA_2018.toReplaceWith(electronSeedsTask, electronSeedsTask.copyAndExclude([trackerDrivenElectronSeeds]))

from Configuration.Eras.Modifier_phase2_hgcal_cff import phase2_hgcal
phase2_hgcal.toReplaceWith(
  electronSeedsTask, _electronSeedsTaskFromMultiCl )

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)
#  module alcastreamHcalMinbiasOutput = PoolOutputModule

OutALCARECOHcalCalMinBias_noDrop = cms.PSet(
    SelectEvents = cms.untracked.PSet(
        SelectEvents = cms.vstring('pathALCARECOHcalCalMinBias')
    ),
    outputCommands = cms.untracked.vstring(
        'keep *_hltTriggerSummaryAOD_*_*',
        'keep *_TriggerResults_*_*',
        'keep HcalNoiseSummary_hcalnoise_*_*',
        'keep HBHERecHitsSorted_hbherecoMBNZS_*_*',
        'keep HORecHitsSorted_horecoMBNZS_*_*',
        'keep HFRecHitsSorted_hfrecoMBNZS_*_*',
        'keep HBHERecHitsSorted_hbherecoNoise_*_*',
        'keep HORecHitsSorted_horecoNoise_*_*',
        'keep HFRecHitsSorted_hfrecoNoise_*_*')
)

import copy
OutALCARECOHcalCalMinBias=copy.deepcopy(OutALCARECOHcalCalMinBias_noDrop)
OutALCARECOHcalCalMinBias.outputCommands.insert(0, "drop *")

## customizations for the pp_on_AA_2018 eras
from Configuration.Eras.Modifier_pp_on_AA_2018_cff import pp_on_AA_2018
OutALCARECOHcalCalMinBiasHI = copy.deepcopy(OutALCARECOHcalCalMinBias_noDrop)
OutALCARECOHcalCalMinBiasHI.outputCommands.insert(0, "drop *")
OutALCARECOHcalCalMinBiasHI.outputCommands.insert(6, "keep HFRecHitsSorted_hfreco_*_*")

#Specify to use HI output for the pp_on_AA_2018 eras
pp_on_AA_2018.toReplaceWith(OutALCARECOHcalCalMinBias,OutALCARECOHcalCalMinBiasHI)
示例#11
0
from CalibMuon.DTCalibration.DTCalibMuonSelection_cfi import *

# AlCaReco for DT calibration
ALCARECODtCalibHLTFilter = copy.deepcopy(hltHighLevel)
#ALCARECODtCalibHLTFilter.andOr = True ## choose logical OR between Triggerbits
#ALCARECODtCalibHLTFilter.HLTPaths = ['HLT_L1MuOpen*', 'HLT_L1Mu*']
ALCARECODtCalibHLTFilter.throw = False ## dont throw on unknown path names
ALCARECODtCalibHLTFilter.eventSetupPathsKey = 'DtCalib'

import RecoLocalMuon.DTSegment.dt4DSegments_CombPatternReco4D_LinearDriftFromDB_cfi as dt4DSegmentsCfiRef
dt4DSegmentsNoWire = dt4DSegmentsCfiRef.dt4DSegments.clone()
dt4DSegmentsNoWire.Reco4DAlgoConfig.recAlgoConfig.tTrigModeConfig.doWirePropCorrection = False
dt4DSegmentsNoWire.Reco4DAlgoConfig.Reco2DAlgoConfig.recAlgoConfig.tTrigModeConfig.doWirePropCorrection = False

#this is to select collisions
from RecoMET.METFilters.metFilters_cff import primaryVertexFilter, noscraping

seqALCARECODtCalib = cms.Sequence(primaryVertexFilter * noscraping * ALCARECODtCalibHLTFilter * DTCalibMuonSelection * dt4DSegmentsNoWire) 

## customizations for the pp_on_AA_2018 eras
from Configuration.Eras.Modifier_pp_on_AA_2018_cff import pp_on_AA_2018
pp_on_AA_2018.toModify(ALCARECODtCalibHLTFilter,
                       eventSetupPathsKey='DtCalibHI'
)

seqALCARECODtCalibHI = cms.Sequence(ALCARECODtCalibHLTFilter * dt4DSegmentsNoWire)

#Specify to use HI sequence for the pp_on_AA_2018 eras
pp_on_AA_2018.toReplaceWith(seqALCARECODtCalib,seqALCARECODtCalibHI)
示例#12
0
			   *ElecMuonDQM
                           *susyDQM
                           *HiggsDQM
                           *ExoticaDQM
                           *B2GDQM
                           *FSQDQM
                           )

from Configuration.Eras.Modifier_phase1Pixel_cff import phase1Pixel
phase1Pixel.toReplaceWith(dqmPhysics, dqmPhysics.copyAndExclude([ # FIXME
    ewkMuDQM,            # Excessive printouts because 2017 doesn't have HLT yet
    ewkElecDQM,          # Excessive printouts because 2017 doesn't have HLT yet
    ewkMuLumiMonitorDQM, # Excessive printouts because 2017 doesn't have HLT yet
]))
from Configuration.Eras.Modifier_pA_2016_cff import pA_2016
dqmPhysicspA  =  dqmPhysics.copy()
dqmPhysicspA += CentralitypADQM
pA_2016.toReplaceWith(dqmPhysics, dqmPhysicspA)
from Configuration.Eras.Modifier_pp_on_AA_2018_cff import pp_on_AA_2018
_dqmPhysics  =  dqmPhysics.copy()
_dqmPhysics += CentralityDQM
pp_on_AA_2018.toModify(CentralityDQM, vertexcollection=cms.InputTag("offlinePrimaryVertices"))
pp_on_AA_2018.toReplaceWith(dqmPhysics, _dqmPhysics)

bphysicsOniaDQMHI = bphysicsOniaDQM.clone(vertex=cms.InputTag("hiSelectedVertex"))
dqmPhysicsHI = cms.Sequence(bphysicsOniaDQMHI+CentralityDQM)

from DQM.Physics.qcdPhotonsCosmicDQM_cff import *
dqmPhysicsCosmics = cms.Sequence(dqmPhysics)
dqmPhysicsCosmics.replace(qcdPhotonsDQM, qcdPhotonsCosmicDQM)
示例#13
0
from RecoJets.Configuration.JetIDProducers_cff import *
from RecoJets.Configuration.RecoTrackJets_cff import *
from RecoJets.Configuration.RecoJetAssociations_cff import *
from RecoJets.Configuration.RecoPFJets_cff import *
from RecoJets.Configuration.RecoJPTJets_cff import *
from JetMETCorrections.Configuration.JetCorrectorsForReco_cff import *

jetGlobalReco = cms.Sequence(recoJets*recoJetIds*recoTrackJets)
jetHighLevelReco = cms.Sequence(recoPFJets*jetCorrectorsForReco*recoJetAssociations*recoJetAssociationsExplicit*recoJPTJets)

from RecoHI.HiJetAlgos.hiFJGridEmptyAreaCalculator_cff import hiFJGridEmptyAreaCalculator
from RecoHI.HiJetAlgos.hiFJRhoProducer import hiFJRhoProducer
from RecoHI.HiJetAlgos.HiRecoPFJets_cff import kt4PFJetsForRho
from Configuration.Eras.Modifier_pA_2016_cff import pA_2016
from Configuration.Eras.Modifier_pp_on_AA_2018_cff import pp_on_AA_2018
from RecoHI.HiCentralityAlgos.pACentrality_cfi import pACentrality
pA_2016.toModify(pACentrality, producePixelTracks = False)

_jetHighLevelReco_pA = jetHighLevelReco.copy()
_jetHighLevelReco_pA += kt4PFJetsForRho
_jetHighLevelReco_pA += hiFJRhoProducer
_jetHighLevelReco_pA += hiFJGridEmptyAreaCalculator
_jetHighLevelReco_pA += pACentrality
pA_2016.toReplaceWith(jetHighLevelReco, _jetHighLevelReco_pA)

_jetGlobalReco_HI = cms.Sequence(recoJetsHI*recoJetIds)
_jetHighLevelReco_HI = cms.Sequence(recoPFJetsHI*jetCorrectorsForReco*recoJetAssociations)

pp_on_AA_2018.toReplaceWith(jetGlobalReco,_jetGlobalReco_HI)
pp_on_AA_2018.toReplaceWith(jetHighLevelReco,_jetHighLevelReco_HI)
示例#14
0
                             recoPFMET*
                             PFTau*
                             reducedRecHits*
                             cosmicDCTracksSeq
                             )

# AA data with pp reco
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
from RecoHI.HiCentralityAlgos.HiCentrality_cfi import hiCentrality
from RecoHI.HiCentralityAlgos.HiClusterCompatibility_cfi import hiClusterCompatibility
_highlevelreco_HI = highlevelreco.copy()
_highlevelreco_HI += hiCentrality
_highlevelreco_HI += hiClusterCompatibility
(pp_on_XeXe_2017 | pp_on_AA_2018).toReplaceWith(highlevelreco, _highlevelreco_HI)
pp_on_AA_2018.toReplaceWith(highlevelreco,highlevelreco.copyAndExclude([PFTau]))

from Configuration.Eras.Modifier_pp_on_AA_2018_cff import pp_on_AA_2018
from RecoHI.HiTracking.HILowPtConformalPixelTracks_cfi import *
_highlevelreco_HI_wPixTracks = highlevelreco.copy()
pp_on_AA_2018.toReplaceWith(highlevelreco, cms.Sequence(_highlevelreco_HI_wPixTracks* hiConformalPixelTracksSequencePhase1))

# not commisoned and not relevant in FastSim (?):
_fastSim_highlevelreco = highlevelreco.copyAndExclude([cosmicDCTracksSeq,muoncosmichighlevelreco])
fastSim.toReplaceWith(highlevelreco,_fastSim_highlevelreco)


from FWCore.Modules.logErrorHarvester_cfi import *

# "Export" Section
reconstruction         = cms.Sequence(localreco*globalreco*highlevelreco*logErrorHarvester)
示例#15
0
trackingPhase2PU140.toModify(
    tripletElectronSeedLayers,
    layerList=_layerListForPhase1,
    BPix=dict(skipClusters='pixelPairStepSeedClusterMask'),
    FPix=dict(skipClusters='pixelPairStepSeedClusterMask'))

from RecoTracker.TkTrackingRegions.globalTrackingRegionFromBeamSpot_cfi import globalTrackingRegionFromBeamSpot as _globalTrackingRegionFromBeamSpot

tripletElectronTrackingRegions = _globalTrackingRegionFromBeamSpot.clone(
    RegionPSet=dict(ptMin=1.0, originRadius=0.02, nSigmaZ=4.0))

from Configuration.Eras.Modifier_pp_on_AA_2018_cff import pp_on_AA_2018
from RecoTracker.TkTrackingRegions.globalTrackingRegionWithVertices_cff import globalTrackingRegionWithVertices as _globalTrackingRegionWithVertices

pp_on_AA_2018.toReplaceWith(
    tripletElectronTrackingRegions,
    _globalTrackingRegionWithVertices.clone(
        RegionPSet=dict(fixedError=0.5, ptMin=8.0, originRadius=0.02)))

from RecoTracker.TkHitPairs.hitPairEDProducer_cfi import hitPairEDProducer as _hitPairEDProducer

tripletElectronHitDoublets = _hitPairEDProducer.clone(
    seedingLayers='tripletElectronSeedLayers',
    trackingRegions='tripletElectronTrackingRegions',
    maxElement=50000000,
    produceIntermediateHitDoublets=True,
)
from RecoPixelVertexing.PixelTriplets.pixelTripletHLTEDProducer_cfi import pixelTripletHLTEDProducer as _pixelTripletHLTEDProducer
import RecoPixelVertexing.PixelLowPtUtilities.LowPtClusterShapeSeedComparitor_cfi

tripletElectronHitTriplets = _pixelTripletHLTEDProducer.clone(
    doublets='tripletElectronHitDoublets',
示例#16
0
from PhysicsTools.PatAlgos.producersLayer1.metProducer_cff import *

## module to count objects
patCandidateSummary = cms.EDAnalyzer("CandidateSummaryTable",
    logName = cms.untracked.string("patCandidates|PATSummaryTables"),
    candidates = cms.VInputTag(
        cms.InputTag("patElectrons"),
        cms.InputTag("patMuons"),
        cms.InputTag("patTaus"),
        cms.InputTag("patPhotons"),
        cms.InputTag("patOOTPhotons"),
        cms.InputTag("patJets"),
        cms.InputTag("patMETs"),
    )
)

patCandidatesTask = cms.Task(
    makePatElectronsTask,
    makePatMuonsTask,
    makePatTausTask,
    makePatPhotonsTask,
    makePatOOTPhotonsTask,
    makePatJetsTask,
    makePatMETsTask
)
patCandidates = cms.Sequence(patCandidateSummary, patCandidatesTask)

from Configuration.Eras.Modifier_pp_on_AA_2018_cff import pp_on_AA_2018
pp_on_AA_2018.toReplaceWith(patCandidatesTask, patCandidatesTask.copyAndExclude([makePatOOTPhotonsTask]))
pp_on_AA_2018.toModify(patCandidateSummary.candidates, func = lambda list: list.remove(cms.InputTag("patOOTPhotons")) )
示例#17
0
#LWTNN selector
from RecoTracker.FinalTrackSelectors.TrackLwtnnClassifier_cfi import *
from RecoTracker.FinalTrackSelectors.trackSelectionLwtnn_cfi import *
trackingPhase1.toReplaceWith(
    initialStep,
    TrackLwtnnClassifier.clone(
        src='initialStepTracks',
        qualityCuts=[0.0, 0.3, 0.6],
    ))
(trackingPhase1 & fastSim).toModify(
    initialStep, vertices="firstStepPrimaryVerticesBeforeMixing")

pp_on_AA_2018.toReplaceWith(
    initialStep,
    initialStepClassifier1.clone(
        qualityCuts=[-0.9, -0.5, 0.2],
        mva=dict(GBRForestLabel='HIMVASelectorInitialStep_Phase1')))

# For LowPU and Phase2PU140
import RecoTracker.FinalTrackSelectors.multiTrackSelector_cfi
initialStepSelector = RecoTracker.FinalTrackSelectors.multiTrackSelector_cfi.multiTrackSelector.clone(
    src='initialStepTracks',
    useAnyMVA=cms.bool(False),
    GBRForestLabel=cms.string('MVASelectorIter0'),
    trackSelectors=[
        RecoTracker.FinalTrackSelectors.multiTrackSelector_cfi.looseMTS.clone(
            name='initialStepLoose', ),  #end of pset
        RecoTracker.FinalTrackSelectors.multiTrackSelector_cfi.tightMTS.clone(
            name='initialStepTight',
            preFilterName='initialStepLoose',
示例#18
0
    src = 'lowPtQuadStepTracks',
    qualityCuts = [0.2, 0.425, 0.75],
)
fastSim.toModify(lowPtQuadStep,vertices = "firstStepPrimaryVerticesBeforeMixing")

from RecoTracker.FinalTrackSelectors.TrackMVAClassifierPrompt_cfi import *

highBetaStar_2018.toReplaceWith(lowPtQuadStep, TrackMVAClassifierPrompt.clone(
    src = 'lowPtQuadStepTracks',
    qualityCuts = [-0.9,-0.35,-0.15],
    mva = dict(GBRForestLabel = 'MVASelectorDetachedTripletStep_Phase1') 
))

pp_on_AA_2018.toReplaceWith(lowPtQuadStep, TrackMVAClassifierPrompt.clone(
    src = 'lowPtQuadStepTracks',
    qualityCuts = [-0.9, -0.4, 0.3],
    mva = dict(GBRForestLabel = 'HIMVASelectorLowPtQuadStep_Phase1')
))

# For Phase2PU140
import RecoTracker.FinalTrackSelectors.multiTrackSelector_cfi
lowPtQuadStepSelector = RecoTracker.FinalTrackSelectors.multiTrackSelector_cfi.multiTrackSelector.clone(
    src = 'lowPtQuadStepTracks',
    trackSelectors = [
        RecoTracker.FinalTrackSelectors.multiTrackSelector_cfi.looseMTS.clone(
            name = 'lowPtQuadStepLoose',
            chi2n_par = 2.0,
            res_par = ( 0.003, 0.002 ),
            minNumberLayers = 3,
            maxNumberLostLayers = 2,
            minNumber3DLayers = 3,
示例#19
0
    jetHighLevelReco * metrecoPlusHCALNoise * btagging * recoPFMET * PFTau *
    reducedRecHits * cosmicDCTracksSeq * lowPtGsfElectronSequence)

# AA data with pp reco
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
from RecoHI.HiTracking.HILowPtConformalPixelTracks_cfi import *
from RecoHI.HiCentralityAlgos.HiCentrality_cfi import hiCentrality
from RecoHI.HiCentralityAlgos.HiClusterCompatibility_cfi import hiClusterCompatibility
_highlevelreco_HI = highlevelreco.copy()
_highlevelreco_HI += hiConformalPixelTracksSequencePhase1
_highlevelreco_HI += hiCentrality
_highlevelreco_HI += hiClusterCompatibility
(pp_on_XeXe_2017 | pp_on_AA_2018).toReplaceWith(highlevelreco,
                                                _highlevelreco_HI)
pp_on_AA_2018.toReplaceWith(highlevelreco,
                            highlevelreco.copyAndExclude([PFTau]))

# not commisoned and not relevant in FastSim (?):
_fastSim_highlevelreco = highlevelreco.copyAndExclude(
    [cosmicDCTracksSeq, muoncosmichighlevelreco])
fastSim.toReplaceWith(highlevelreco, _fastSim_highlevelreco)

from FWCore.Modules.logErrorHarvester_cfi import *

# "Export" Section
reconstruction = cms.Sequence(localreco * globalreco * highlevelreco *
                              logErrorHarvester)

#logErrorHarvester should only wait for items produced in the reconstruction sequence
_modulesInReconstruction = list()
reconstruction.visit(
示例#20
0
from PhysicsTools.PatAlgos.selectionLayer1.jetSelector_cfi import *
#from PhysicsTools.PatAlgos.producersLayer1.hemisphereProducer_cfi import *

# One module to count objects
selectedPatCandidateSummary = cms.EDAnalyzer("CandidateSummaryTable",
    logName = cms.untracked.string("selectedPatCanddiates|PATSummaryTables"),
    candidates = cms.VInputTag(
        cms.InputTag("selectedPatElectrons"),
        cms.InputTag("selectedPatMuons"),
        cms.InputTag("selectedPatTaus"),
        cms.InputTag("selectedPatPhotons"),
        cms.InputTag("selectedPatOOTPhotons"),
        cms.InputTag("selectedPatJets"),
    )
)

selectedPatCandidatesTask = cms.Task(
    selectedPatElectrons,
    selectedPatMuons,
    selectedPatTaus,
    selectedPatPhotons,
    selectedPatOOTPhotons,
    selectedPatJets
)

selectedPatCandidates = cms.Sequence(selectedPatCandidateSummary, selectedPatCandidatesTask)

from Configuration.Eras.Modifier_pp_on_AA_2018_cff import pp_on_AA_2018
pp_on_AA_2018.toReplaceWith(selectedPatCandidatesTask, selectedPatCandidatesTask.copyAndExclude([selectedPatOOTPhotons]))
pp_on_AA_2018.toModify(selectedPatCandidateSummary.candidates, func = lambda list: list.remove(cms.InputTag("selectedPatOOTPhotons")) )
示例#21
0
    slimmingTask,
    cms.Task(slimmingTask.copy(), hiPixelTracks, hiEvtPlane, hiEvtPlaneFlat))

from Configuration.Eras.Modifier_pp_on_PbPb_run3_cff import pp_on_PbPb_run3
from PhysicsTools.PatAlgos.packedCandidateMuonID_cfi import packedCandidateMuonID
from PhysicsTools.PatAlgos.packedPFCandidateTrackChi2_cfi import packedPFCandidateTrackChi2
from RecoHI.HiCentralityAlgos.CentralityBin_cfi import centralityBin
from RecoHI.HiCentralityAlgos.hiHFfilters_cfi import hiHFfilters
lostTrackChi2 = packedPFCandidateTrackChi2.clone(candidates="lostTracks",
                                                 doLostTracks=True)
(pp_on_AA_2018 | pp_on_PbPb_run3).toReplaceWith(
    slimmingTask,
    cms.Task(slimmingTask.copy(), packedCandidateMuonID,
             packedPFCandidateTrackChi2, lostTrackChi2, centralityBin,
             hiHFfilters))
from Configuration.ProcessModifiers.run2_miniAOD_pp_on_AA_103X_cff import run2_miniAOD_pp_on_AA_103X
run2_miniAOD_pp_on_AA_103X.toReplaceWith(
    slimmingTask, cms.Task(primaryVertexAssociationCleaned,
                           slimmingTask.copy()))

from RecoHI.HiTracking.miniAODVertexRecovery_cff import offlinePrimaryVerticesRecovery, offlineSlimmedPrimaryVerticesRecovery
pp_on_AA_2018.toReplaceWith(
    slimmingTask,
    cms.Task(slimmingTask.copy(), offlinePrimaryVerticesRecovery,
             offlineSlimmedPrimaryVerticesRecovery))

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)
示例#22
0
from PhysicsTools.PatAlgos.producersLayer1.metProducer_cff import *

## module to count objects
patCandidateSummary = cms.EDAnalyzer(
    "CandidateSummaryTable",
    logName=cms.untracked.string("patCandidates|PATSummaryTables"),
    candidates=cms.VInputTag(
        cms.InputTag("patElectrons"),
        cms.InputTag("patLowPtElectrons"),
        cms.InputTag("patMuons"),
        cms.InputTag("patTaus"),
        cms.InputTag("patPhotons"),
        cms.InputTag("patOOTPhotons"),
        cms.InputTag("patJets"),
        cms.InputTag("patMETs"),
    ))

patCandidatesTask = cms.Task(makePatElectronsTask, makePatLowPtElectronsTask,
                             makePatMuonsTask, makePatTausTask,
                             makePatPhotonsTask, makePatOOTPhotonsTask,
                             makePatJetsTask, makePatMETsTask)
patCandidates = cms.Sequence(patCandidateSummary, patCandidatesTask)

from Configuration.Eras.Modifier_pp_on_AA_2018_cff import pp_on_AA_2018
pp_on_AA_2018.toReplaceWith(
    patCandidatesTask,
    patCandidatesTask.copyAndExclude([makePatOOTPhotonsTask]))
pp_on_AA_2018.toModify(
    patCandidateSummary.candidates,
    func=lambda list: list.remove(cms.InputTag("patOOTPhotons")))
示例#23
0
from RecoTracker.FinalTrackSelectors.TrackLwtnnClassifier_cfi import *
from RecoTracker.FinalTrackSelectors.trackSelectionLwtnn_cfi import *
trackingPhase1.toReplaceWith(pixelPairStep, TrackLwtnnClassifier.clone(
    src='pixelPairStepTracks',
    qualityCuts=[-0.6, -0.1, 0.4],
))

highBetaStar_2018.toReplaceWith(pixelPairStep, TrackMVAClassifierPrompt.clone(
    src='pixelPairStepTracks',
    qualityCuts = [-0.95,0.0,0.3],
    mva=dict(GBRForestLabel = 'MVASelectorPixelPairStep_Phase1')
))

pp_on_AA_2018.toReplaceWith(pixelPairStep, TrackMVAClassifierPrompt.clone( 
    src='pixelPairStepTracks',
    qualityCuts = [-0.2, 0.0, 0.98],
    mva=dict(GBRForestLabel = 'MVASelectorPixelPairStep_Phase1') 
))

fastSim.toModify(pixelPairStep, vertices = "firstStepPrimaryVerticesBeforeMixing")



# For LowPU and Phase2PU140
import RecoTracker.IterativeTracking.LowPtTripletStep_cff
import RecoTracker.FinalTrackSelectors.multiTrackSelector_cfi
pixelPairStepSelector = RecoTracker.FinalTrackSelectors.multiTrackSelector_cfi.multiTrackSelector.clone(
    src='pixelPairStepTracks',
    useAnyMVA = cms.bool(True),
    GBRForestLabel = cms.string('MVASelectorIter2'),
    trackSelectors= cms.VPSet(
示例#24
0
    patJetFlavourIdTask,
    patJets
    )

from PhysicsTools.PatAlgos.producersHeavyIons.heavyIonJets_cff import *
_makePatJetsTaskHI2018 = cms.Task(
    recoPFJetsHIpostAODTask,
    recoGenJetsHIpostAODTask,
    makePatJetsTask.copy()
)
_makePatJetsTaskHI = cms.Task(
    recoGenJetsHIpostAODTask,
    makePatJetsTask.copy()
)
from Configuration.Eras.Modifier_pp_on_AA_2018_cff import pp_on_AA_2018
pp_on_AA_2018.toReplaceWith(makePatJetsTask, _makePatJetsTaskHI2018)
from Configuration.Eras.Modifier_pp_on_PbPb_run3_cff import pp_on_PbPb_run3
pp_on_PbPb_run3.toReplaceWith(makePatJetsTask, _makePatJetsTaskHI)

makePatJets = cms.Sequence(makePatJetsTask)

from RecoBTag.ImpactParameter.pfImpactParameterTagInfos_cfi import * #pfImpactParameterTagInfos
from RecoBTag.SecondaryVertex.pfSecondaryVertexTagInfos_cfi import * #pfSecondaryVertexTagInfos
from RecoBTag.SecondaryVertex.pfInclusiveSecondaryVertexFinderTagInfos_cfi import * #pfInclusiveSecondaryVertexFinderTagInfos
from RecoBTag.Combined.deepFlavour_cff import * #pfDeepCSVTask

#make a copy to avoid labels and substitution problems
_makePatJetsWithDeepFlavorTask = makePatJetsTask.copy()
_makePatJetsWithDeepFlavorTask.add(
    pfImpactParameterTagInfos, 
    pfSecondaryVertexTagInfos,
示例#25
0
    + cscDigiValidation
    + validationMuonRPCDigis
    + recoMuonValidation
    + rpcRecHitValidation_step
    + dtLocalRecoValidation_no2D
    + muonIdValDQMSeq
)

globalValidationMuons = cms.Sequence()

_phase_1_globalValidation = globalValidation.copy()
_phase_1_globalValidation += siPixelPhase1OfflineDQM_sourceV
from Configuration.Eras.Modifier_phase1Pixel_cff import phase1Pixel
(phase1Pixel & ~fastSim).toReplaceWith( globalValidation, _phase_1_globalValidation ) #module siPixelPhase1OfflineDQM_sourceV can't run in FastSim since siPixelClusters of type edmNew::DetSetVector are not produced

_run3_globalValidation = globalValidation.copy()
_run3_globalValidation += gemSimValid

_phase2_globalValidation = _run3_globalValidation.copy()
_phase2_globalValidation += me0SimValid


from Configuration.Eras.Modifier_run2_GEM_2017_cff import run2_GEM_2017
run2_GEM_2017.toReplaceWith( globalValidation, _run3_globalValidation )
from Configuration.Eras.Modifier_run3_GEM_cff import run3_GEM
run3_GEM.toReplaceWith( globalValidation, _run3_globalValidation )
from Configuration.Eras.Modifier_phase2_muon_cff import phase2_muon
phase2_muon.toReplaceWith( globalValidation, _phase2_globalValidation )
from Configuration.Eras.Modifier_pp_on_AA_2018_cff import pp_on_AA_2018
pp_on_AA_2018.toReplaceWith(globalValidation, globalValidation.copyAndExclude([pfTauRunDQMValidation]))
示例#26
0
from Configuration.Eras.Modifier_phase2_common_cff import phase2_common
phase2_common.toReplaceWith(reducedEcalRecHitsTask,
                            _phase2_reducedEcalRecHitsTask)

_fastSim_reducedEcalRecHitsTask = reducedEcalRecHitsTask.copyAndExclude(
    seldigisTask)
from Configuration.Eras.Modifier_fastSim_cff import fastSim
fastSim.toReplaceWith(reducedEcalRecHitsTask, _fastSim_reducedEcalRecHitsTask)

_pp_on_AA_reducedEcalRecHitsTask = reducedEcalRecHitsTask.copy()
_pp_on_AA_reducedEcalRecHitsTask.remove(interestingEcalDetIdOOTPFEB)
_pp_on_AA_reducedEcalRecHitsTask.remove(interestingEcalDetIdOOTPFEE)
_pp_on_AA_reducedEcalRecHitsTask.remove(interestingEcalDetIdOOTPFES)

from Configuration.Eras.Modifier_pp_on_AA_2018_cff import pp_on_AA_2018
pp_on_AA_2018.toReplaceWith(reducedEcalRecHitsTask,
                            _pp_on_AA_reducedEcalRecHitsTask)

pp_on_AA_2018.toModify(
    reducedEcalRecHitsEB.interestingDetIdCollections,
    func=lambda list: list.remove(cms.InputTag("interestingEcalDetIdOOTPFEB")))
pp_on_AA_2018.toModify(
    reducedEcalRecHitsEB.interestingDetIdCollections,
    func=lambda list: list.remove(cms.InputTag("interestingOotGamIsoDetIdEB")))
pp_on_AA_2018.toModify(
    reducedEcalRecHitsEE.interestingDetIdCollections,
    func=lambda list: list.remove(cms.InputTag("interestingEcalDetIdOOTPFEE")))
pp_on_AA_2018.toModify(
    reducedEcalRecHitsEE.interestingDetIdCollections,
    func=lambda list: list.remove(cms.InputTag("interestingOotGamIsoDetIdEE")))
pp_on_AA_2018.toModify(
    reducedEcalRecHitsES.interestingDetIds,
示例#27
0
    singleTopMuonMediumDQM * singleTopElectronMediumDQM * DiMuonDQM *
    DiElectronDQM * ElecMuonDQM * susyDQM * HiggsDQM * ExoticaDQM * B2GDQM *
    FSQDQM)

from Configuration.Eras.Modifier_phase1Pixel_cff import phase1Pixel
phase1Pixel.toReplaceWith(
    dqmPhysics,
    dqmPhysics.copyAndExclude([  # FIXME
        ewkMuDQM,  # Excessive printouts because 2017 doesn't have HLT yet
        ewkElecDQM,  # Excessive printouts because 2017 doesn't have HLT yet
        ewkMuLumiMonitorDQM,  # Excessive printouts because 2017 doesn't have HLT yet
    ]))
from Configuration.Eras.Modifier_pA_2016_cff import pA_2016
dqmPhysicspA = dqmPhysics.copy()
dqmPhysicspA += CentralitypADQM
pA_2016.toReplaceWith(dqmPhysics, dqmPhysicspA)
from Configuration.Eras.Modifier_pp_on_AA_2018_cff import pp_on_AA_2018
_dqmPhysics = dqmPhysics.copy()
_dqmPhysics += CentralityDQM
pp_on_AA_2018.toModify(CentralityDQM,
                       vertexcollection=cms.InputTag("offlinePrimaryVertices"))
pp_on_AA_2018.toReplaceWith(dqmPhysics, _dqmPhysics)

bphysicsOniaDQMHI = bphysicsOniaDQM.clone(
    vertex=cms.InputTag("hiSelectedVertex"))
dqmPhysicsHI = cms.Sequence(bphysicsOniaDQMHI + CentralityDQM)

from DQM.Physics.qcdPhotonsCosmicDQM_cff import *
dqmPhysicsCosmics = cms.Sequence(dqmPhysics)
dqmPhysicsCosmics.replace(qcdPhotonsDQM, qcdPhotonsCosmicDQM)
示例#28
0
#ALCARECODtCalibHLTFilter.andOr = True ## choose logical OR between Triggerbits
#ALCARECODtCalibHLTFilter.HLTPaths = ['HLT_L1MuOpen*', 'HLT_L1Mu*']
ALCARECODtCalibHLTFilter.throw = False  ## dont throw on unknown path names
ALCARECODtCalibHLTFilter.eventSetupPathsKey = 'DtCalib'

import RecoLocalMuon.DTSegment.dt4DSegments_CombPatternReco4D_LinearDriftFromDB_cfi as dt4DSegmentsCfiRef
dt4DSegmentsNoWire = dt4DSegmentsCfiRef.dt4DSegments.clone()
dt4DSegmentsNoWire.Reco4DAlgoConfig.recAlgoConfig.tTrigModeConfig.doWirePropCorrection = False
dt4DSegmentsNoWire.Reco4DAlgoConfig.Reco2DAlgoConfig.recAlgoConfig.tTrigModeConfig.doWirePropCorrection = False

#this is to select collisions
from RecoMET.METFilters.metFilters_cff import primaryVertexFilter, noscraping

# Short-term workaround to preserve the "run for every event" while removing the use of convertToUnscheduled()
# To be reverted in a subsequent PR
seqALCARECODtCalibTask = cms.Task(dt4DSegmentsNoWire)
seqALCARECODtCalib = cms.Sequence(
    primaryVertexFilter * noscraping * ALCARECODtCalibHLTFilter *
    DTCalibMuonSelection, seqALCARECODtCalibTask)

## customizations for the pp_on_AA_2018 eras
from Configuration.Eras.Modifier_pp_on_AA_2018_cff import pp_on_AA_2018
pp_on_AA_2018.toModify(ALCARECODtCalibHLTFilter,
                       eventSetupPathsKey='DtCalibHI')

seqALCARECODtCalibHI = cms.Sequence(ALCARECODtCalibHLTFilter,
                                    seqALCARECODtCalibTask)

#Specify to use HI sequence for the pp_on_AA_2018 eras
pp_on_AA_2018.toReplaceWith(seqALCARECODtCalib, seqALCARECODtCalibHI)
示例#29
0
    iPSet.particleBasedIsolation = "particleBasedIsolationTmp:gedGsfElectronsTmp"

photonIDValueMaps = cms.EDProducer(
    "PhotonIDValueMapProducer",
    ebReducedRecHitCollection=cms.InputTag("ecalRecHit", "EcalRecHitsEB"),
    eeReducedRecHitCollection=cms.InputTag("ecalRecHit", "EcalRecHitsEE"),
    esReducedRecHitCollection=cms.InputTag("ecalPreshowerRecHit",
                                           "EcalRecHitsES"),
    particleBasedIsolation=cms.InputTag("particleBasedIsolationTmp",
                                        "gedPhotonsTmp"),
    pfCandidates=cms.InputTag("particleFlowTmp"),
    src=cms.InputTag("gedPhotonsTmp"),
    vertices=cms.InputTag("offlinePrimaryVertices"),
    isAOD=cms.bool(True))

particleFlowEGammaFullTask = cms.Task(particleFlowEGamma,
                                      gedGsfElectronTaskTmp, gedPhotonTaskTmp,
                                      ootPhotonTask)
particleFlowEGammaFull = cms.Sequence(particleFlowEGammaFullTask)
particleFlowEGammaFinalTask = cms.Task(
    particleBasedIsolationTmp, pfNoPileUpIsoTask, pfNoPileUpCandidates,
    pfPileUpAllChargedParticles, egmPhotonIsolationCITK,
    egmElectronIsolationCITK, egmElectronIsolationPileUpCITK,
    photonIDValueMaps, gedPhotonTask, gedElectronPFIsoTask)
particleFlowEGammaFinal = cms.Sequence(particleFlowEGammaFinalTask)

from Configuration.Eras.Modifier_pp_on_AA_2018_cff import pp_on_AA_2018
pp_on_AA_2018.toReplaceWith(
    particleFlowEGammaFullTask,
    particleFlowEGammaFullTask.copyAndExclude([ootPhotonTask]))
hfrecoMBNZS.tsFromDB = cms.bool(False)
hfrecoMBNZS.dropZSmarkedPassed = cms.bool(False)

seqALCARECOHcalCalMinBiasDigi = cms.Sequence(hcalminbiasHLT * hcalDigiAlCaMB *
                                             gtDigisAlCaMB)
seqALCARECOHcalCalMinBiasDigiNoHLT = cms.Sequence(hcalDigiAlCaMB *
                                                  gtDigisAlCaMB)

seqALCARECOHcalCalMinBias = cms.Sequence(
    hbherecoMBNZS * horecoMBNZS * hbherecoNoise * hfrecoNoise * hfrecoMBNZS *
    horecoNoise)

#Specify to use HI output for the pp_on_AA_2018 eras
seqALCARECOHcalCalMinBiasHI = cms.Sequence(hbherecoNoise * hfrecoNoise *
                                           hfrecoMBNZS * horecoNoise)
pp_on_AA_2018.toReplaceWith(seqALCARECOHcalCalMinBias,
                            seqALCARECOHcalCalMinBiasHI)

import RecoLocalCalo.HcalRecProducers.hfprereco_cfi
hfprerecoNoise = RecoLocalCalo.HcalRecProducers.hfprereco_cfi.hfprereco.clone(
    digiLabel=cms.InputTag("hcalDigiAlCaMB"),
    dropZSmarkedPassed=cms.bool(False),
    tsFromDB=cms.bool(False),
    sumAllTimeSlices=cms.bool(False),
    forceSOI=cms.int32(0))
hfprerecoMBNZS = RecoLocalCalo.HcalRecProducers.hfprereco_cfi.hfprereco.clone(
    digiLabel=cms.InputTag("hcalDigiAlCaMB"),
    dropZSmarkedPassed=cms.bool(False),
    tsFromDB=cms.bool(False),
    sumAllTimeSlices=cms.bool(True),
    forceSOI=cms.int32(1))
示例#31
0
    jetDQMAnalyzerAk4PFCleaned * jetDQMAnalyzerAk4PFCHSCleaned)

jetDQMAnalyzerSequenceCosmics = cms.Sequence(jetDQMAnalyzerAk4CaloUncleaned)

jetDQMAnalyzerSequenceMiniAOD = cms.Sequence(
    jetDQMAnalyzerAk4PFCHSUncleanedMiniAOD *
    jetDQMAnalyzerAk4PFCHSCleanedMiniAOD *
    jetDQMAnalyzerAk8PFPUPPICleanedMiniAOD *
    jetDQMAnalyzerAk4PFCHSPuppiCleanedMiniAOD)

jetDQMAnalyzerSequenceHI = cms.Sequence(
    jetDQMAnalyzerIC5CaloHIUncleaned * jetDQMMatchAkPu3CaloAkPu3PF *
    jetDQMMatchAkPu4CaloAkPu4PF * jetDQMMatchAkPu5CaloAkPu5PF *
    jetDQMAnalyzerAkPU3Calo * jetDQMAnalyzerAkPU4Calo *
    jetDQMAnalyzerAkPU5Calo * jetDQMAnalyzerAkPU3PF * jetDQMAnalyzerAkPU4PF *
    jetDQMAnalyzerAkPU5PF * jetDQMAnalyzerAkCs3PF * jetDQMAnalyzerAkCs4PF)

_jetDQMAnalyzerSequenceHI = cms.Sequence(
    jetDQMMatchAkPu4CaloAkPu4PF * jetDQMAnalyzerAkPU4Calo *
    jetDQMAnalyzerAkPU3PF * jetDQMAnalyzerAkPU4PF * jetDQMAnalyzerAkCs4PF)
from Configuration.Eras.Modifier_pp_on_AA_2018_cff import pp_on_AA_2018
pp_on_AA_2018.toReplaceWith(jetDQMAnalyzerSequence, _jetDQMAnalyzerSequenceHI)
pp_on_AA_2018.toModify(jetDQMAnalyzerAkPU4Calo,
                       srcVtx=cms.untracked.InputTag("offlinePrimaryVertices"))
pp_on_AA_2018.toModify(jetDQMAnalyzerAkPU3PF,
                       srcVtx=cms.untracked.InputTag("offlinePrimaryVertices"))
pp_on_AA_2018.toModify(jetDQMAnalyzerAkPU4PF,
                       srcVtx=cms.untracked.InputTag("offlinePrimaryVertices"))
pp_on_AA_2018.toModify(jetDQMAnalyzerAkCs4PF,
                       srcVtx=cms.untracked.InputTag("offlinePrimaryVertices"))
示例#32
0
from RecoParticleFlow.PFTracking.trackerDrivenElectronSeeds_cff import *
from RecoEgamma.EgammaElectronProducers.ecalDrivenElectronSeeds_cfi import *
from RecoParticleFlow.PFTracking.mergedElectronSeeds_cfi import *

electronSeedsTask = cms.Task(trackerDrivenElectronSeeds,
                             ecalDrivenElectronSeeds, electronMergedSeeds)
electronSeeds = cms.Sequence(electronSeedsTask)
_electronSeedsTaskFromMultiCl = electronSeedsTask.copy()
_electronSeedsTaskFromMultiCl.add(
    cms.Task(ecalDrivenElectronSeedsFromMultiCl,
             electronMergedSeedsFromMultiCl))
_electronSeedsFromMultiCl = cms.Sequence(_electronSeedsTaskFromMultiCl)

from Configuration.Eras.Modifier_pp_on_AA_2018_cff import pp_on_AA_2018
pp_on_AA_2018.toReplaceWith(
    electronSeedsTask,
    electronSeedsTask.copyAndExclude([trackerDrivenElectronSeeds]))

from Configuration.Eras.Modifier_phase2_hgcal_cff import phase2_hgcal
phase2_hgcal.toReplaceWith(electronSeedsTask, _electronSeedsTaskFromMultiCl)

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(
)
示例#33
0
import FWCore.ParameterSet.Config as cms

from RecoJets.JetProducers.ak4CaloJets_cfi import ak4CaloJets as _ak4CaloJets
from RecoHI.HiJetAlgos.HiRecoJets_cff import akPu4CaloJets as _akPu4CaloJets
from RecoLocalCalo.CaloTowersCreator.calotowermaker_cfi import calotowermaker

caloTowerForTrk = calotowermaker.clone(hbheInput=cms.InputTag('hbheprereco'))
ak4CaloJetsForTrk = _ak4CaloJets.clone(
    srcPVs=cms.InputTag('firstStepPrimaryVerticesUnsorted'),
    src=cms.InputTag('caloTowerForTrk'))
from Configuration.Eras.Modifier_pp_on_AA_2018_cff import pp_on_AA_2018

pp_on_AA_2018.toReplaceWith(
    ak4CaloJetsForTrk,
    _akPu4CaloJets.clone(
        srcPVs=cms.InputTag('firstStepPrimaryVerticesUnsorted'),
        src=cms.InputTag('caloTowerForTrk')))
from Configuration.Eras.Modifier_trackingLowPU_cff import trackingLowPU

trackingLowPU.toModify(ak4CaloJetsForTrk, srcPVs="pixelVertices")

caloJetsForTrkTask = cms.Task(caloTowerForTrk, ak4CaloJetsForTrk)
caloJetsForTrk = cms.Sequence(caloJetsForTrkTask)

from Configuration.Eras.Modifier_phase2_hcal_cff import phase2_hcal

phase2_hcal.toModify(caloTowerForTrk, hbheInput=cms.InputTag("hbhereco"))
示例#34
0
#LWTNN selector
from RecoTracker.FinalTrackSelectors.TrackLwtnnClassifier_cfi import *
from RecoTracker.FinalTrackSelectors.trackSelectionLwtnn_cfi import *

trackingPhase1.toReplaceWith(
    pixelLessStep,
    TrackLwtnnClassifier.clone(
        src='pixelLessStepTracks',
        qualityCuts=[-0.6, -0.05, 0.5],
    ))
(trackingPhase1 & fastSim).toModify(
    pixelLessStep, vertices="firstStepPrimaryVerticesBeforeMixing")

pp_on_AA_2018.toReplaceWith(
    pixelLessStep,
    pixelLessStepClassifier1.clone(
        qualityCuts=[-0.4, 0.0, 0.8],
        mva=dict(GBRForestLabel='MVASelectorPixelLessStep_Phase1')))

# For LowPU
import RecoTracker.FinalTrackSelectors.multiTrackSelector_cfi

pixelLessStepSelector = RecoTracker.FinalTrackSelectors.multiTrackSelector_cfi.multiTrackSelector.clone(
    src='pixelLessStepTracks',
    useAnyMVA=cms.bool(False),
    GBRForestLabel=cms.string('MVASelectorIter5'),
    trackSelectors=cms.VPSet(
        RecoTracker.FinalTrackSelectors.multiTrackSelector_cfi.looseMTS.clone(
            name='pixelLessStepLoose',
            chi2n_par=0.5,
            res_par=(0.003, 0.001),
示例#35
0
from DQMOffline.Muon.miniAOD_cff import *

DQMOfflineMiniAOD = cms.Sequence(jetMETDQMOfflineRedoProductsMiniAOD*muonMonitors_miniAOD*MuonMiniAOD)

#Post sequences are automatically placed in the EndPath by ConfigBuilder if PAT is run.
#miniAOD DQM sequences need to access the filter results.


PostDQMOfflineMiniAOD = cms.Sequence(miniAODDQMSequence*jetMETDQMOfflineSourceMiniAOD*tracksDQMMiniAOD*topPhysicsminiAOD)
PostDQMOffline = cms.Sequence()

from Configuration.Eras.Modifier_phase2_hcal_cff import phase2_hcal
phase2_hcal.toReplaceWith( PostDQMOfflineMiniAOD, PostDQMOfflineMiniAOD.copyAndExclude([
    pfMetDQMAnalyzerMiniAOD, pfPuppiMetDQMAnalyzerMiniAOD # No hcalnoise yet
]))

from Configuration.Eras.Modifier_pp_on_AA_2018_cff import pp_on_AA_2018
pp_on_AA_2018.toReplaceWith(DQMOffline, DQMOffline.copyAndExclude([pfTauRunDQMValidation]))

from PhysicsTools.NanoAOD.nanoDQM_cff import nanoDQM
DQMOfflineNanoAOD = cms.Sequence(nanoDQM)
#PostDQMOfflineNanoAOD = cms.Sequence(nanoDQM)

# L1 trigger sequences
DQMOfflineL1TMonitoring = cms.Sequence( l1TriggerDqmOffline ) # L1 emulator is run within this sequence for real data

DQMOfflineL1TEgamma = cms.Sequence( l1TriggerEgDqmOffline )

DQMOfflineL1TMuon = cms.Sequence( l1TriggerMuonDqmOffline )
示例#36
0
from PhysicsTools.PatAlgos.slimming.slimmedOOTPhotons_cff import *
from PhysicsTools.PatAlgos.slimming.slimmedTaus_cfi import *
from PhysicsTools.PatAlgos.slimming.slimmedSecondaryVertices_cfi import *
from PhysicsTools.PatAlgos.slimming.slimmedMETs_cfi import *
from PhysicsTools.PatAlgos.slimming.slimmedV0s_cff import *
from PhysicsTools.PatAlgos.slimming.metFilterPaths_cff import *
from PhysicsTools.PatAlgos.slimming.MicroEventContent_cff import *
from RecoEgamma.EgammaPhotonProducers.reducedEgamma_cfi import *
from RecoLuminosity.LumiProducer.bunchSpacingProducer_cfi import bunchSpacingProducer
from HeavyFlavorAnalysis.Onia2MuMu.OniaPhotonConversionProducer_cfi import PhotonCandidates as oniaPhotonCandidates

slimmingTask = cms.Task(
    packedPFCandidatesTask, lostTracks, isolatedTracks,
    offlineSlimmedPrimaryVertices, primaryVertexAssociation, genParticlesTask,
    selectedPatTrigger, slimmedPatTrigger, slimmedCaloJets, slimmedJets,
    slimmedJetsAK8, slimmedGenJets, slimmedGenJetsAK8, slimmedElectrons,
    slimmedLowPtElectrons, lowPtGsfLinks, slimmedMuons, slimmedPhotons,
    slimmedOOTPhotons, slimmedTaus, slimmedSecondaryVertices,
    slimmedKshortVertices, slimmedLambdaVertices, slimmedMETs,
    metFilterPathsTask, reducedEgamma, bunchSpacingProducer,
    oniaPhotonCandidates)

from Configuration.Eras.Modifier_pp_on_AA_2018_cff import pp_on_AA_2018
pp_on_AA_2018.toReplaceWith(slimmingTask,
                            slimmingTask.copyAndExclude([slimmedOOTPhotons]))

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)
示例#37
0
    selectedPatTrigger,
    slimmedPatTrigger,
    slimmedCaloJets,
    slimmedJets,
    slimmedJetsAK8,
    slimmedGenJets,
    slimmedGenJetsAK8,
    slimmedElectrons,
    slimmedLowPtElectrons,
    slimmedMuons,
    slimmedPhotons,
    slimmedOOTPhotons,
    slimmedTaus,
    slimmedSecondaryVertices,
    slimmedKshortVertices,
    slimmedLambdaVertices,
    slimmedMETs,
    metFilterPathsTask,
    reducedEgamma,
    bunchSpacingProducer,
    oniaPhotonCandidates
)

from Configuration.Eras.Modifier_pp_on_AA_2018_cff import pp_on_AA_2018
pp_on_AA_2018.toReplaceWith(slimmingTask, slimmingTask.copyAndExclude([slimmedOOTPhotons]))

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)
示例#38
0
)
fastSim.toModify(highPtTripletStep,
                 vertices="firstStepPrimaryVerticesBeforeMixing")

from RecoTracker.FinalTrackSelectors.TrackMVAClassifierPrompt_cfi import *

highBetaStar_2018.toReplaceWith(
    highPtTripletStep,
    TrackMVAClassifierPrompt.clone(
        qualityCuts=[-0.2, 0.3, 0.4],
        src='highPtTripletStepTracks',
        mva=dict(GBRForestLabel='MVASelectorDetachedTripletStep_Phase1')))

pp_on_AA_2018.toReplaceWith(
    highPtTripletStep,
    TrackMVAClassifierPrompt.clone(
        qualityCuts=[-0.9, -0.3, 0.85],
        src='highPtTripletStepTracks',
        mva=dict(GBRForestLabel='HIMVASelectorHighPtTripletStep_Phase1')))

# For Phase2PU140
import RecoTracker.FinalTrackSelectors.multiTrackSelector_cfi
highPtTripletStepSelector = RecoTracker.FinalTrackSelectors.multiTrackSelector_cfi.multiTrackSelector.clone(
    src='highPtTripletStepTracks',
    trackSelectors=[
        RecoTracker.FinalTrackSelectors.multiTrackSelector_cfi.looseMTS.clone(
            name='highPtTripletStepLoose',
            chi2n_par=2.0,
            res_par=(0.003, 0.002),
            minNumberLayers=3,
            maxNumberLostLayers=3,
            minNumber3DLayers=3,
示例#39
0
jetGlobalRecoTask = cms.Task(recoJetsTask, recoJetIdsTask, recoTrackJetsTask)
jetGlobalReco = cms.Sequence(jetGlobalRecoTask)
jetHighLevelRecoTask = cms.Task(recoPFJetsTask, jetCorrectorsForRecoTask,
                                recoJetAssociationsTask,
                                recoJetAssociationsExplicitTask,
                                recoJPTJetsTask)
jetHighLevelReco = cms.Sequence(jetHighLevelRecoTask)

from RecoHI.HiJetAlgos.hiFJGridEmptyAreaCalculator_cff import hiFJGridEmptyAreaCalculator
from RecoHI.HiJetAlgos.hiFJRhoProducer import hiFJRhoProducer
from RecoHI.HiJetAlgos.HiRecoPFJets_cff import kt4PFJetsForRho
from Configuration.Eras.Modifier_pA_2016_cff import pA_2016
from Configuration.Eras.Modifier_pp_on_AA_2018_cff import pp_on_AA_2018
from RecoHI.HiCentralityAlgos.pACentrality_cfi import pACentrality
pA_2016.toModify(pACentrality, producePixelTracks=False)

_jetHighLevelReco_pATask = jetHighLevelRecoTask.copy()
_jetHighLevelReco_pATask.add(kt4PFJetsForRho)
_jetHighLevelReco_pATask.add(hiFJRhoProducer)
_jetHighLevelReco_pATask.add(hiFJGridEmptyAreaCalculator)
_jetHighLevelReco_pATask.add(pACentrality)
pA_2016.toReplaceWith(jetHighLevelRecoTask, _jetHighLevelReco_pATask)

_jetGlobalReco_HI = cms.Sequence(recoJetsHI * recoJetIds)
_jetHighLevelReco_HI = cms.Sequence(recoPFJetsHI * jetCorrectorsForReco *
                                    recoJetAssociations)

pp_on_AA_2018.toReplaceWith(jetGlobalReco, _jetGlobalReco_HI)
pp_on_AA_2018.toReplaceWith(jetHighLevelReco, _jetHighLevelReco_HI)
示例#40
0
    conversionOpenTrackTask, gsfTracksOpenConversions)
highlevelreco = cms.Sequence(highlevelrecoTask)

# AA data with pp reco
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
from RecoHI.HiTracking.HILowPtConformalPixelTracks_cfi import *
from RecoHI.HiCentralityAlgos.HiCentrality_cfi import hiCentrality
from RecoHI.HiCentralityAlgos.HiClusterCompatibility_cfi import hiClusterCompatibility
_highlevelreco_HITask = highlevelrecoTask.copy()
_highlevelreco_HITask.add(hiConformalPixelTracksTaskPhase1)
_highlevelreco_HITask.add(hiCentrality)
_highlevelreco_HITask.add(hiClusterCompatibility)
(pp_on_XeXe_2017 | pp_on_AA_2018).toReplaceWith(highlevelrecoTask,
                                                _highlevelreco_HITask)
pp_on_AA_2018.toReplaceWith(highlevelrecoTask,
                            highlevelrecoTask.copyAndExclude([PFTauTask]))

# not commisoned and not relevant in FastSim (?):
_fastSim_highlevelrecoTask = highlevelrecoTask.copyAndExclude(
    [cosmicDCTracksSeqTask, muoncosmichighlevelrecoTask])
fastSim.toReplaceWith(highlevelrecoTask, _fastSim_highlevelrecoTask)

from FWCore.Modules.logErrorHarvester_cfi import *

# "Export" Section
reconstructionTask = cms.Task(localrecoTask, globalrecoTask, highlevelrecoTask,
                              logErrorHarvester)
reconstruction = cms.Sequence(reconstructionTask)

#logErrorHarvester should only wait for items produced in the reconstruction sequence
_modulesInReconstruction = list()
示例#41
0
from PhysicsTools.PatAlgos.slimming.MicroEventContent_cff import *
from RecoEgamma.EgammaPhotonProducers.reducedEgamma_cfi import *
from RecoLuminosity.LumiProducer.bunchSpacingProducer_cfi import bunchSpacingProducer
from HeavyFlavorAnalysis.Onia2MuMu.OniaPhotonConversionProducer_cfi import PhotonCandidates as oniaPhotonCandidates

slimmingTask = cms.Task(
    packedPFCandidatesTask, lostTracks, isolatedTracks,
    offlineSlimmedPrimaryVertices, primaryVertexAssociation, genParticlesTask,
    selectedPatTrigger, slimmedPatTrigger, slimmedCaloJets, slimmedJets,
    slimmedJetsAK8, slimmedGenJets, slimmedGenJetsAK8, slimmedElectrons,
    slimmedMuons, slimmedPhotons, slimmedOOTPhotons, slimmedTaus,
    slimmedSecondaryVertices, slimmedKshortVertices, slimmedLambdaVertices,
    slimmedMETs, metFilterPathsTask, reducedEgamma, bunchSpacingProducer,
    oniaPhotonCandidates)

from Configuration.Eras.Modifier_pp_on_AA_2018_cff import pp_on_AA_2018
pp_on_AA_2018.toReplaceWith(slimmingTask,
                            slimmingTask.copyAndExclude([slimmedOOTPhotons]))

from PhysicsTools.PatAlgos.packedPFCandidateMuonID_cfi import packedPFCandidateMuonID
from RecoHI.HiTracking.hipixeltracks_miniAOD_cfi import hipixeltracks
pp_on_AA_2018.toModify(packedPFCandidateMuonID,
                       muonSelectors=cms.vstring(
                           ["AllTrackerMuons", "TMOneStationTight"]))
lostTrackMuonID = packedPFCandidateMuonID.clone(
    candidates=cms.InputTag("lostTracks"))
pp_on_AA_2018.toReplaceWith(
    slimmingTask,
    cms.Task(slimmingTask.copy(), packedPFCandidateMuonID, lostTrackMuonID,
             hipixeltracks))
示例#42
0
import FWCore.ParameterSet.Config as cms

from DQMOffline.JetMET.dataCertificationJetMET_cfi import *

dataCertificationJetMETSequence = cms.Sequence(qTesterJet + qTesterMET + dataCertificationJetMET)

dataCertificationJetMETSequenceHI = cms.Sequence(qTesterJet + qTesterMET + dataCertificationJetMETHI)

from Configuration.Eras.Modifier_pp_on_AA_2018_cff import pp_on_AA_2018

pp_on_AA_2018.toReplaceWith( dataCertificationJetMETSequence, dataCertificationJetMETSequenceHI )
示例#43
0
from PhysicsTools.PatAlgos.selectionLayer1.jetSelector_cfi import *
#from PhysicsTools.PatAlgos.producersLayer1.hemisphereProducer_cfi import *

# One module to count objects
selectedPatCandidateSummary = cms.EDAnalyzer(
    "CandidateSummaryTable",
    logName=cms.untracked.string("selectedPatCanddiates|PATSummaryTables"),
    candidates=cms.VInputTag(
        cms.InputTag("selectedPatElectrons"),
        cms.InputTag("selectedPatMuons"),
        cms.InputTag("selectedPatTaus"),
        cms.InputTag("selectedPatPhotons"),
        cms.InputTag("selectedPatOOTPhotons"),
        cms.InputTag("selectedPatJets"),
    ))

selectedPatCandidatesTask = cms.Task(selectedPatElectrons, selectedPatMuons,
                                     selectedPatTaus, selectedPatPhotons,
                                     selectedPatOOTPhotons, selectedPatJets)

selectedPatCandidates = cms.Sequence(selectedPatCandidateSummary,
                                     selectedPatCandidatesTask)

from Configuration.Eras.Modifier_pp_on_AA_2018_cff import pp_on_AA_2018
pp_on_AA_2018.toReplaceWith(
    selectedPatCandidatesTask,
    selectedPatCandidatesTask.copyAndExclude([selectedPatOOTPhotons]))
pp_on_AA_2018.toModify(
    selectedPatCandidateSummary.candidates,
    func=lambda list: list.remove(cms.InputTag("selectedPatOOTPhotons")))
示例#44
0
from Configuration.Eras.Modifier_phase1Pixel_cff import phase1Pixel
(phase1Pixel & ~fastSim).toReplaceWith(
    globalValidation, _phase_1_globalValidation
)  #module siPixelPhase1OfflineDQM_sourceV can't run in FastSim since siPixelClusters of type edmNew::DetSetVector are not produced
(phase1Pixel & ~fastSim).toReplaceWith(
    globalValidationPixelTrackingOnly,
    _phase_1_globalValidationPixelTrackingOnly
)  #module siPixelPhase1OfflineDQM_sourceV can't run in FastSim since siPixelClusters of type edmNew::DetSetVector are not produced

_run3_globalValidation = globalValidation.copy()
_run3_globalValidation += gemSimValid

_phase2_globalValidation = _run3_globalValidation.copy()
_phase2_globalValidation += trackerphase2ValidationSource
_phase2_globalValidation += me0SimValid

from Configuration.Eras.Modifier_run2_GEM_2017_cff import run2_GEM_2017
run2_GEM_2017.toReplaceWith(globalValidation, _run3_globalValidation)
from Configuration.Eras.Modifier_run3_GEM_cff import run3_GEM
run3_GEM.toReplaceWith(globalValidation, _run3_globalValidation)
from Configuration.Eras.Modifier_phase2_muon_cff import phase2_muon
phase2_muon.toReplaceWith(globalValidation, _phase2_globalValidation)
from Configuration.Eras.Modifier_pp_on_AA_2018_cff import pp_on_AA_2018
pp_on_AA_2018.toReplaceWith(
    globalValidation, globalValidation.copyAndExclude([pfTauRunDQMValidation]))
from Configuration.Eras.Modifier_phase2_timing_layer_cff import phase2_timing_layer
phase2_timing_layer.toReplaceWith(
    globalValidationMTD,
    cms.Sequence(mtdSimValid + mtdDigiValid + mtdRecoValid))
示例#45
0
#change particleBasedIsolation object to tmp
IsoConeDefinitionsPhotonsTmp = copy.deepcopy(IsoConeDefinitions)
for iPSet in IsoConeDefinitionsPhotonsTmp:
  iPSet.particleBasedIsolation = cms.InputTag("particleBasedIsolationTmp", "gedPhotonsTmp")

for iPSet in egmElectronIsolationCITK.isolationConeDefinitions:
  iPSet.particleBasedIsolation = cms.InputTag("particleBasedIsolationTmp", "gedGsfElectronsTmp")

for iPSet in egmElectronIsolationPileUpCITK.isolationConeDefinitions:
  iPSet.particleBasedIsolation = cms.InputTag("particleBasedIsolationTmp", "gedGsfElectronsTmp")

#photon isolation sums
egmPhotonIsolationCITK.srcToIsolate = cms.InputTag("gedPhotonsTmp")
egmPhotonIsolationCITK.srcForIsolationCone = cms.InputTag("pfNoPileUpCandidates")
egmPhotonIsolationCITK.isolationConeDefinitions = IsoConeDefinitionsPhotonsTmp
#electrons isolation sums
egmElectronIsolationCITK.srcToIsolate = cms.InputTag("gedGsfElectronsTmp")
egmElectronIsolationCITK.srcForIsolationCone = cms.InputTag("pfNoPileUpCandidates")
#electrons pileup isolation sum
egmElectronIsolationPileUpCITK.srcToIsolate = cms.InputTag("gedGsfElectronsTmp")
egmElectronIsolationPileUpCITK.srcForIsolationCone = cms.InputTag("pfPileUpAllChargedParticles")

particleFlowEGammaFull = cms.Sequence(particleFlowEGamma*gedGsfElectronSequenceTmp*gedPhotonSequenceTmp*ootPhotonSequence)
particleFlowEGammaFinal = cms.Sequence(particleBasedIsolationTmp*\
pfNoPileUpIsoSequence*cms.ignore(pfNoPileUpCandidates)*cms.ignore(pfPileUpAllChargedParticles)*\
egmPhotonIsolationCITK*egmElectronIsolationCITK*egmElectronIsolationPileUpCITK*gedPhotonSequence*gedElectronPFIsoSequence)

from Configuration.Eras.Modifier_pp_on_AA_2018_cff import pp_on_AA_2018
pp_on_AA_2018.toReplaceWith(particleFlowEGammaFull, particleFlowEGammaFull.copyAndExclude([ootPhotonSequence]))
        'keep booledmValueMap_muidTM2DCompatibilityTight_*_*',
        'keep booledmValueMap_muidTMLastStationAngLoose_*_*',
        'keep booledmValueMap_muidTMLastStationAngTight_*_*',
        'keep booledmValueMap_muidTMLastStationLoose_*_*',
        'keep booledmValueMap_muidTMLastStationOptimizedLowPtLoose_*_*',
        'keep booledmValueMap_muidTMLastStationOptimizedLowPtTight_*_*',
        'keep booledmValueMap_muidTMLastStationTight_*_*',
        'keep booledmValueMap_muidTMOneStationAngLoose_*_*',
        'keep booledmValueMap_muidTMOneStationAngTight_*_*',
        'keep booledmValueMap_muidTMOneStationLoose_*_*',
        'keep booledmValueMap_muidTMOneStationTight_*_*',
        'keep booledmValueMap_muidTrackerMuonArbitrated_*_*')
)


import copy
OutALCARECODtCalib = copy.deepcopy(OutALCARECODtCalib_noDrop)
OutALCARECODtCalib.outputCommands.insert(0, "drop *")

## customizations for the pp_on_AA_2018 eras
from Configuration.Eras.Modifier_pp_on_AA_2018_cff import pp_on_AA_2018

OutALCARECODtCalibHI = copy.deepcopy(OutALCARECODtCalib_noDrop)
OutALCARECODtCalibHI.outputCommands.insert(0, "drop *")
OutALCARECODtCalibHI.outputCommands.append("keep *_offlinePrimaryVertices__*")
OutALCARECODtCalibHI.outputCommands.append("keep *_offlinePrimaryVerticesWithBS_*_*")
OutALCARECODtCalibHI.outputCommands.append("keep *_offlinePrimaryVerticesFromCosmicTracks_*_*")

#Specify to use HI output for the pp_on_AA_2018 eras
pp_on_AA_2018.toReplaceWith(OutALCARECODtCalib,OutALCARECODtCalibHI)
示例#47
0
                                          reducedEcalRecHitsEB,
                                          reducedEcalRecHitsEE,
                                          seldigisTask)
reducedEcalRecHitsSequenceEcalOnly = cms.Sequence(reducedEcalRecHitsSequenceEcalOnlyTask)

_phase2_reducedEcalRecHitsTask = reducedEcalRecHitsTask.copy()
_phase2_reducedEcalRecHitsTask.remove(reducedEcalRecHitsES)

from Configuration.Eras.Modifier_phase2_common_cff import phase2_common
phase2_common.toReplaceWith( reducedEcalRecHitsTask , _phase2_reducedEcalRecHitsTask )


_fastSim_reducedEcalRecHitsTask = reducedEcalRecHitsTask.copyAndExclude(seldigisTask)
from Configuration.Eras.Modifier_fastSim_cff import fastSim
fastSim.toReplaceWith( reducedEcalRecHitsTask, _fastSim_reducedEcalRecHitsTask)

_pp_on_AA_reducedEcalRecHitsTask = reducedEcalRecHitsTask.copy()
_pp_on_AA_reducedEcalRecHitsTask.remove(interestingEcalDetIdOOTPFEB)
_pp_on_AA_reducedEcalRecHitsTask.remove(interestingEcalDetIdOOTPFEE)
_pp_on_AA_reducedEcalRecHitsTask.remove(interestingEcalDetIdOOTPFES)

from Configuration.Eras.Modifier_pp_on_AA_2018_cff import pp_on_AA_2018
pp_on_AA_2018.toReplaceWith(reducedEcalRecHitsTask, _pp_on_AA_reducedEcalRecHitsTask)

pp_on_AA_2018.toModify(reducedEcalRecHitsEB.interestingDetIdCollections, func = lambda list: list.remove(cms.InputTag("interestingEcalDetIdOOTPFEB")) )
pp_on_AA_2018.toModify(reducedEcalRecHitsEB.interestingDetIdCollections, func = lambda list: list.remove(cms.InputTag("interestingOotGamIsoDetIdEB")) )
pp_on_AA_2018.toModify(reducedEcalRecHitsEE.interestingDetIdCollections, func = lambda list: list.remove(cms.InputTag("interestingEcalDetIdOOTPFEE")) )
pp_on_AA_2018.toModify(reducedEcalRecHitsEE.interestingDetIdCollections, func = lambda list: list.remove(cms.InputTag("interestingOotGamIsoDetIdEE")) )
pp_on_AA_2018.toModify(reducedEcalRecHitsES.interestingDetIds, func = lambda list: list.remove(cms.InputTag("interestingEcalDetIdOOTPFES")) )
pp_on_AA_2018.toModify(reducedEcalRecHitsES.interestingDetIdsNotToClean, func = lambda list: list.remove(cms.InputTag("interestingOotEgammaIsoESDetId")) )