示例#1
0
from Configuration.Eras.Modifier_run2_HCAL_2018_cff import run2_HCAL_2018
run2_HCAL_2018.toModify(hcalGPUComparisonTask,
                        tagHBHE_ref="hbheprereco@cpu",
                        tagHBHE_target="hbheprereco@cuda")
run2_HCAL_2018.toModify(recHitTask, tagHBHE="hbheprereco")

from Configuration.Eras.Modifier_run3_HB_cff import run3_HB
### reverting the reco tag setting that inherited from run2
run3_HB.toModify(hcalGPUComparisonTask,
                 tagHBHE_ref="hbhereco@cpu",
                 tagHBHE_target="hbhereco@cuda")
run3_HB.toModify(recHitTask, tagHBHE="hbhereco")
_phase1_hcalOnlyOfflineSourceSequence = hcalOnlyOfflineSourceSequence.copy()
_phase1_hcalOnlyOfflineSourceSequence.replace(recHitPreRecoTask, recHitTask)
run3_HB.toReplaceWith(hcalOnlyOfflineSourceSequence,
                      _phase1_hcalOnlyOfflineSourceSequence)

from Configuration.Eras.Modifier_phase2_hcal_cff import phase2_hcal
_phase2_hcalOfflineSourceSequence = hcalOfflineSourceSequence.copyAndExclude(
    [tpTask, rawTask])
phase2_hcal.toReplaceWith(hcalOfflineSourceSequence,
                          _phase2_hcalOfflineSourceSequence)
phase2_hcal.toModify(digiTask,
                     tagHBHE="simHcalDigis:HBHEQIE11DigiCollection",
                     tagHO="simHcalDigis",
                     tagHF="simHcalDigis:HFQIE10DigiCollection")

from Configuration.ProcessModifiers.premix_stage2_cff import premix_stage2
(premix_stage2 & phase2_hcal).toModify(
    digiTask,
    tagHBHE="DMHcalDigis:HBHEQIE11DigiCollection",
示例#2
0
import FWCore.ParameterSet.Config as cms

from RecoLocalCalo.HcalRecProducers.HBHEIsolatedNoiseReflagger_cfi import *
hcalGlobalRecoTask = cms.Task(hbhereco)
hcalGlobalRecoSequence = cms.Sequence(hcalGlobalRecoTask)

from RecoLocalCalo.HcalRecProducers.HBHEPhase1Reconstructor_cfi import hbheprereco as _phase1_hbheprereco

from Configuration.Eras.Modifier_run3_HB_cff import run3_HB
run3_HB.toReplaceWith( hbhereco, _phase1_hbheprereco ) # >=Run3
示例#3
0
import FWCore.ParameterSet.Config as cms

from DQMOffline.Hcal.CaloTowersParam_cfi import *
import DQMOffline.Hcal.CaloTowersParam_cfi

from DQMOffline.Hcal.HcalRecHitParam_cfi import *
import DQMOffline.Hcal.HcalRecHitParam_cfi

from DQMOffline.Hcal.HcalNoiseRatesParam_cfi import *
import DQMOffline.Hcal.HcalNoiseRatesParam_cfi

AllCaloTowersDQMOffline = DQMOffline.Hcal.CaloTowersParam_cfi.calotowersAnalyzer.clone(
)
RecHitsDQMOffline = DQMOffline.Hcal.HcalRecHitParam_cfi.hcalRecHitsAnalyzer.clone(
)
NoiseRatesDQMOffline = DQMOffline.Hcal.HcalNoiseRatesParam_cfi.hcalNoiseRates.clone(
)

HcalDQMOfflineSequence = cms.Sequence(
    NoiseRatesDQMOffline * RecHitsDQMOffline * AllCaloTowersDQMOffline)
#HcalDQMOfflineSequence = cms.Sequence(NoiseRatesDQMOffline*AllCaloTowersDQMOffline)

_run3_HcalDQMOfflineSequence = HcalDQMOfflineSequence.copyAndExclude(
    [NoiseRatesDQMOffline])
from Configuration.Eras.Modifier_run3_HB_cff import run3_HB
run3_HB.toReplaceWith(HcalDQMOfflineSequence, _run3_HcalDQMOfflineSequence)
示例#4
0
import FWCore.ParameterSet.Config as cms

from Validation.HcalRecHits.HcalRecHitParam_cfi import *

import Validation.HcalRecHits.HcalRecHitParam_cfi

RecHitsValidation = Validation.HcalRecHits.HcalRecHitParam_cfi.hcalRecoAnalyzer.clone()
NoiseRatesValidation = Validation.HcalRecHits.HcalRecHitParam_cfi.hcalNoiseRates.clone()

hcalRecHitsValidationSequence = cms.Sequence(NoiseRatesValidation*RecHitsValidation)

# fastsim hasn't got the right noise collection for the moment => no noise validation
from Configuration.Eras.Modifier_fastSim_cff import fastSim
fastSim.toReplaceWith(hcalRecHitsValidationSequence, hcalRecHitsValidationSequence.copyAndExclude([NoiseRatesValidation]))

_run3_hcalRecHitsValidationSequence = hcalRecHitsValidationSequence.copyAndExclude([NoiseRatesValidation])
from Configuration.Eras.Modifier_run3_HB_cff import run3_HB
run3_HB.toReplaceWith(hcalRecHitsValidationSequence, _run3_hcalRecHitsValidationSequence)
示例#5
0
from Configuration.ProcessModifiers.pp_on_AA_cff import pp_on_AA
_DQMOfflineTAU = cms.Sequence()
pp_on_AA.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.

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

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

from PhysicsTools.NanoAOD.nanoDQM_cff import nanoDQM
DQMOfflineNanoAOD = cms.Sequence(nanoDQM)
#PostDQMOfflineNanoAOD = cms.Sequence(nanoDQM)
from PhysicsTools.NanoAOD.nanogenDQM_cff import nanogenDQM
DQMOfflineNanoGen = cms.Sequence(nanogenDQM)
示例#6
0
_plan1_hcalLocalRecoTask = _phase1_hcalLocalRecoTask.copy()
_plan1_hcalLocalRecoTask.add(hbheplan1)
from Configuration.Eras.Modifier_run2_HEPlan1_2017_cff import run2_HEPlan1_2017
run2_HEPlan1_2017.toReplaceWith(hcalLocalRecoTask, _plan1_hcalLocalRecoTask)

hbhecollapse = hbheplan1.clone()
_collapse_hcalLocalRecoTask = _phase1_hcalLocalRecoTask.copy()
_collapse_hcalLocalRecoTask.add(hbhecollapse)
from Configuration.ProcessModifiers.run2_HECollapse_2018_cff import run2_HECollapse_2018
run2_HECollapse_2018.toReplaceWith(hcalLocalRecoTask, _collapse_hcalLocalRecoTask)

#--- for Run 3 and later
_run3_hcalLocalRecoTask = _phase1_hcalLocalRecoTask.copy()
_run3_hcalLocalRecoTask.remove(hbheprereco)
from Configuration.Eras.Modifier_run3_HB_cff import run3_HB
run3_HB.toReplaceWith(hcalLocalRecoTask, _run3_hcalLocalRecoTask)

#--- for Run 3 on GPU
from Configuration.ProcessModifiers.gpu_cff import gpu

from RecoLocalCalo.HcalRecProducers.hbheRecHitProducerGPUTask_cff import *
_run3_hcalLocalRecoGPUTask = _run3_hcalLocalRecoTask.copy()
_run3_hcalLocalRecoGPUTask.add(hbheRecHitProducerGPUTask)
gpu.toReplaceWith(hcalLocalRecoTask, _run3_hcalLocalRecoGPUTask)

#--- HCAL-only workflow for Run 3
# FIXME rename `hbheprereco` to `hbhereco` and use it from hcalGlobalRecoTask
hcalOnlyLocalRecoTask = cms.Task(hbheprereco, hfprereco, hfreco, horeco)

#--- HCAL-only workflow for Run 3 on GPU
from Configuration.ProcessModifiers.gpu_cff import gpu
示例#7
0
import FWCore.ParameterSet.Config as cms
from HeterogeneousCore.CUDACore.SwitchProducerCUDA import SwitchProducerCUDA

#--- for Run 1 and Run 2
from RecoLocalCalo.HcalRecProducers.HBHEIsolatedNoiseReflagger_cfi import hbhereco as _phase0_hbhereco
hbhereco = SwitchProducerCUDA(
    cpu = _phase0_hbhereco.clone()
)
hcalGlobalRecoTask = cms.Task(hbhereco)
hcalGlobalRecoSequence = cms.Sequence(hcalGlobalRecoTask)

hcalOnlyGlobalRecoTask = cms.Task()
hcalOnlyGlobalRecoSequence = cms.Sequence(hcalOnlyGlobalRecoTask)

#--- for Run 3 and later
from Configuration.Eras.Modifier_run3_HB_cff import run3_HB

from RecoLocalCalo.HcalRecProducers.HBHEPhase1Reconstructor_cfi import hbheprereco as _phase1_hbheprereco
run3_HB.toReplaceWith(hbhereco.cpu, _phase1_hbheprereco)
run3_HB.toReplaceWith(hcalOnlyGlobalRecoTask, cms.Task(hbhereco))

#--- for Run 3 on GPU
from Configuration.ProcessModifiers.gpu_cff import gpu

from RecoLocalCalo.HcalRecProducers.hcalCPURecHitsProducer_cfi import hcalCPURecHitsProducer as _hbherecoFromCUDA
(run3_HB & gpu).toModify(hbhereco,
    cuda = _hbherecoFromCUDA.clone(
        produceSoA = False
    )
)