def customize_mix_nocalo(process):
process.mix.digitizers = digitizers = cms.PSet(
pixel = cms.PSet(
pixelDigitizer
),
strip = cms.PSet(
stripDigitizer
),
)
process.mix.theDigitizersValid = cms.PSet(
pixel = cms.PSet(
pixelDigitizer
),
strip = cms.PSet(
stripDigitizer
)
)
# delete some contents of SimGeneral/MixingModule/python/aliases_cfi.py
# i was not able to delete these processes in a different way
process.simCastorDigis = cms.EDAlias()
process.simEcalUnsuppressedDigis = cms.EDAlias()
process.simHcalUnsuppressedDigis = cms.EDAlias()
# delete all digitizer aliasses apart of pixel and strip aliases
digi_aliases = filter(lambda n: 'Digi' in n, process.aliases.keys())
print("digi aliases before clean up: ")
for a in digi_aliases:
print(a)
if ('Strip' not in a) and ('Pixel' not in a):
process.__delattr__(a)
process.mix.mixObjects = mixObjects_dt_csc_rpc_trk
return process
def loadTriggerDigiAliases():
global gtDigis, gmtDigis
gtDigis = cms.EDAlias(simGtDigis=cms.VPSet(
cms.PSet(type=cms.string("L1GlobalTriggerReadoutRecord")),
cms.PSet(type=cms.string("L1GlobalTriggerObjectMapRecord"))))
gmtDigis = cms.EDAlias(simGmtDigis=cms.VPSet(
cms.PSet(type=cms.string("L1MuGMTReadoutCollection"))))
def loadTriggerDigiAliases(process):
process.caloStage1LegacyFormatDigis = cms.EDAlias(
**{ "simCaloStage1LegacyFormatDigis" :
cms.VPSet(
cms.PSet(type = cms.string("L1GctEmCands")),
cms.PSet(type = cms.string("L1GctEtHads")),
cms.PSet(type = cms.string("L1GctEtMisss")),
cms.PSet(type = cms.string("L1GctEtTotals")),
cms.PSet(type = cms.string("L1GctHFBitCountss")),
cms.PSet(type = cms.string("L1GctHFRingEtSumss")),
cms.PSet(type = cms.string("L1GctHtMisss")),
cms.PSet(type = cms.string("L1GctInternEtSums")),
cms.PSet(type = cms.string("L1GctInternHtMisss")),
cms.PSet(type = cms.string("L1GctInternJetDatas")),
cms.PSet(type = cms.string("L1GctJetCands")))})
process.gctDigis = cms.EDAlias(
**{ "simGctDigis" :
cms.VPSet(
cms.PSet(type = cms.string("L1GctEmCands")),
cms.PSet(type = cms.string("L1GctEtHads")),
cms.PSet(type = cms.string("L1GctEtMisss")),
cms.PSet(type = cms.string("L1GctEtTotals")),
cms.PSet(type = cms.string("L1GctHFBitCountss")),
cms.PSet(type = cms.string("L1GctHFRingEtSumss")),
cms.PSet(type = cms.string("L1GctHtMisss")),
cms.PSet(type = cms.string("L1GctInternEtSums")),
cms.PSet(type = cms.string("L1GctInternHtMisss")),
cms.PSet(type = cms.string("L1GctInternJetDatas")),
cms.PSet(type = cms.string("L1GctJetCands")))})
process.gtDigis = cms.EDAlias(
**{ "simGtDigis" :
cms.VPSet(
cms.PSet(type = cms.string("L1GlobalTriggerEvmReadoutRecord")),
cms.PSet(type = cms.string("L1GlobalTriggerObjectMapRecord")),
cms.PSet(type = cms.string("L1GlobalTriggerReadoutRecord"))),
"simGmtDigis" :
cms.VPSet(
cms.PSet(type = cms.string("L1MuGMTReadoutCollection")),
cms.PSet(type = cms.string("L1MuGMTCands")))
})
process.gmtDigis = cms.EDAlias (
simGmtDigis =
cms.VPSet(
cms.PSet(type = cms.string("L1MuGMTReadoutCollection")),
cms.PSet(type = cms.string("L1MuGMTCands"))
)
)
def loadGeneralTracksAlias(process):
if _loadDigiAliasesWasCalledPremix is None:
raise Exception("This function may be called only after loadDigiAliases() has been called")
nopremix = not _loadDigiAliasesWasCalledPremix
process.generalTracks = cms.EDAlias(
**{"mix" if nopremix else "mixData" :
cms.VPSet(
cms.PSet(
fromProductInstance = cms.string('generalTracks'),
toProductInstance = cms.string(''),
type = cms.string('recoTracks')
),
cms.PSet(
fromProductInstance = cms.string('generalTracks'),
toProductInstance = cms.string(''),
type = cms.string('recoTrackExtras')
),
cms.PSet(
fromProductInstance = cms.string('generalTracks'),
toProductInstance = cms.string(''),
type = cms.string('TrackingRecHitsOwned')
)
)
}
)
process.thinningThingProducerFTEST = cms.EDProducer(
"ThinningThingProducer",
inputTag=cms.InputTag('thinningThingProducerD'),
trackTag=cms.InputTag('trackOfThingsProducerF'),
offsetToThinnedKey=cms.uint32(10),
expectedCollectionSize=cms.uint32(9))
process.thinningThingProducerD2 = cms.EDProducer(
"ThinningThingProducer",
inputTag=cms.InputTag('thingProducer2alias'),
trackTag=cms.InputTag('trackOfThingsProducerD2'),
offsetToThinnedKey=cms.uint32(0),
expectedCollectionSize=cms.uint32(50))
process.thinningThingProducerD2alias = cms.EDAlias(
thinningThingProducerD2=cms.VPSet(
cms.PSet(type=cms.string('edmtestThings'))))
process.testA = cms.EDAnalyzer(
"ThinningTestAnalyzer",
parentTag=cms.InputTag('thingProducer', '', 'PROD'),
thinnedTag=cms.InputTag('thinningThingProducerA'),
associationTag=cms.InputTag('thinningThingProducerA'),
trackTag=cms.InputTag('trackOfThingsProducerA'),
expectedParentContent=cms.vint32(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12,
13, 14, 15, 16, 17, 18, 19, 20, 21, 22,
23, 24, 25, 26, 27, 28, 29, 30, 31, 32,
33, 34, 35, 36, 37, 38, 39, 40, 41, 42,
43, 44, 45, 46, 47, 48, 49),
expectedThinnedContent=cms.vint32(0, 1, 2, 3, 4, 5, 6, 7, 8),
expectedIndexesIntoParent=cms.vuint32(0, 1, 2, 3, 4, 5, 6, 7, 8),
process.prodC = cms.EDProducer("AddIntsProducer",
labels=cms.vstring("prodB"),
onlyGetOnEvent=cms.untracked.uint32(2))
process.prodF = cms.EDProducer("AddIntsProducer", labels=cms.vstring())
process.prodG = cms.EDProducer("AddIntsProducer",
labels=cms.vstring("prodF"),
onlyGetOnEvent=cms.untracked.uint32(2))
process.K100 = cms.EDProducer("AddIntsProducer", labels=cms.vstring())
process.NK101 = cms.EDProducer("AddIntsProducer", labels=cms.vstring("K100"))
process.A101 = cms.EDAlias(
NK101=cms.VPSet(cms.PSet(type=cms.string('edmtestIntProduct'))))
process.K102 = cms.EDProducer("AddIntsProducer", labels=cms.vstring("NK101"))
process.K104 = cms.EDProducer("AddIntsProducer", labels=cms.vstring("A101"))
process.K200 = cms.EDProducer("AddIntsProducer", labels=cms.vstring())
process.K201 = cms.EDProducer("AddIntsProducer", labels=cms.vstring("K200"))
process.A201 = cms.EDAlias(
K201=cms.VPSet(cms.PSet(type=cms.string('edmtestIntProduct'))))
process.K202 = cms.EDProducer("AddIntsProducer", labels=cms.vstring("K201"))
process.K204 = cms.EDProducer("AddIntsProducer", labels=cms.vstring("A201"))
import FWCore.ParameterSet.Config as cms
simCastorDigis = cms.EDAlias(
mix=cms.VPSet(cms.PSet(type=cms.string('CastorDataFramesSorted'))))
simEcalUnsuppressedDigis = cms.EDAlias(
mix=cms.VPSet(cms.PSet(type=cms.string('EBDigiCollection')),
cms.PSet(type=cms.string('EEDigiCollection')),
cms.PSet(type=cms.string('ESDigiCollection'))))
from Configuration.Eras.Modifier_phase2_ecal_devel_cff import phase2_ecal_devel
phase2_ecal_devel.toModify(
simEcalUnsuppressedDigis,
mix=cms.VPSet(cms.PSet(type=cms.string('EBDigiCollectionPh2'))))
simHcalUnsuppressedDigis = cms.EDAlias(mix=cms.VPSet(
cms.PSet(type=cms.string('HBHEDataFramesSorted')),
cms.PSet(type=cms.string('HFDataFramesSorted')),
cms.PSet(type=cms.string('HODataFramesSorted')),
cms.PSet(type=cms.string('ZDCDataFramesSorted')),
cms.PSet(type=cms.string('QIE10DataFrameHcalDataFrameContainer')),
cms.PSet(type=cms.string('QIE11DataFrameHcalDataFrameContainer'))))
_pixelCommon = cms.VPSet(
cms.PSet(type=cms.string('PixelDigiedmDetSetVector')),
cms.PSet(type=cms.string('PixelDigiSimLinkedmDetSetVector')))
simSiPixelDigis = cms.EDAlias(mix=_pixelCommon)
simSiStripDigis = cms.EDAlias(
mix=cms.VPSet(cms.PSet(type=cms.string('SiStripDigiedmDetSetVector')),
cms.PSet(type=cms.string('SiStripRawDigiedmDetSetVector')),
cms.PSet(
type=cms.string('StripDigiSimLinkedmDetSetVector'))))
def customiseHcalLocalReconstruction(process):
if not 'HLTDoLocalHcalSequence' in process.__dict__:
return process
# FIXME replace the Sequences with empty ones to avoid exanding them during the (re)definition of Modules and EDAliases
process.HLTDoLocalHcalSequence = cms.Sequence()
process.HLTStoppedHSCPLocalHcalReco = cms.Sequence()
# Event Setup
process.load(
"EventFilter.HcalRawToDigi.hcalElectronicsMappingGPUESProducer_cfi")
process.load("RecoLocalCalo.HcalRecProducers.hcalGainsGPUESProducer_cfi")
process.load(
"RecoLocalCalo.HcalRecProducers.hcalGainWidthsGPUESProducer_cfi")
process.load(
"RecoLocalCalo.HcalRecProducers.hcalLUTCorrsGPUESProducer_cfi")
process.load(
"RecoLocalCalo.HcalRecProducers.hcalConvertedPedestalsGPUESProducer_cfi"
)
process.load(
"RecoLocalCalo.HcalRecProducers.hcalConvertedEffectivePedestalsGPUESProducer_cfi"
)
process.hcalConvertedEffectivePedestalsGPUESProducer.label0 = "withTopoEff"
process.load(
"RecoLocalCalo.HcalRecProducers.hcalConvertedPedestalWidthsGPUESProducer_cfi"
)
process.load(
"RecoLocalCalo.HcalRecProducers.hcalConvertedEffectivePedestalWidthsGPUESProducer_cfi"
)
process.hcalConvertedEffectivePedestalWidthsGPUESProducer.label0 = "withTopoEff"
process.hcalConvertedEffectivePedestalWidthsGPUESProducer.label1 = "withTopoEff"
process.load(
"RecoLocalCalo.HcalRecProducers.hcalQIECodersGPUESProducer_cfi")
process.load(
"RecoLocalCalo.HcalRecProducers.hcalRecoParamsWithPulseShapesGPUESProducer_cfi"
)
process.load(
"RecoLocalCalo.HcalRecProducers.hcalRespCorrsGPUESProducer_cfi")
process.load(
"RecoLocalCalo.HcalRecProducers.hcalTimeCorrsGPUESProducer_cfi")
process.load(
"RecoLocalCalo.HcalRecProducers.hcalQIETypesGPUESProducer_cfi")
process.load(
"RecoLocalCalo.HcalRecProducers.hcalSiPMParametersGPUESProducer_cfi")
process.load(
"RecoLocalCalo.HcalRecProducers.hcalSiPMCharacteristicsGPUESProducer_cfi"
)
process.load(
"RecoLocalCalo.HcalRecProducers.hcalMahiPulseOffsetsGPUESProducer_cfi")
# Modules and EDAliases
# The HCAL unpacker running on the gpu supports only the HB and HE digis.
# So, run the legacy unacker on the cpu, then convert the HB and HE digis
# to SoA format and copy them to the gpu.
process.hltHcalDigisGPU = cms.EDProducer(
"HcalDigisProducerGPU",
hbheDigisLabel=cms.InputTag("hltHcalDigis"),
qie11DigiLabel=cms.InputTag("hltHcalDigis"),
digisLabelF01HE=cms.string(""),
digisLabelF5HB=cms.string(""),
digisLabelF3HB=cms.string(""),
maxChannelsF01HE=cms.uint32(10000),
maxChannelsF5HB=cms.uint32(10000),
maxChannelsF3HB=cms.uint32(10000))
# run the HCAL local reconstruction (including Method 0 and MAHI) on gpu
from RecoLocalCalo.HcalRecProducers.hbheRecHitProducerGPU_cfi import hbheRecHitProducerGPU as _hbheRecHitProducerGPU
process.hltHbherecoGPU = _hbheRecHitProducerGPU.clone(
digisLabelF01HE="hltHcalDigisGPU",
digisLabelF5HB="hltHcalDigisGPU",
digisLabelF3HB="hltHcalDigisGPU",
recHitsLabelM0HBHE="")
# transfer the HCAL rechits to the cpu, and convert them to the legacy format
from RecoLocalCalo.HcalRecProducers.hcalCPURecHitsProducer_cfi import hcalCPURecHitsProducer as _hcalCPURecHitsProducer
process.hltHbherecoFromGPU = _hcalCPURecHitsProducer.clone(
recHitsM0LabelIn="hltHbherecoGPU",
recHitsM0LabelOut="",
recHitsLegacyLabelOut="")
# SwitchProducer between the legacy producer and the copy from gpu with conversion
process.hltHbhereco = SwitchProducerCUDA(
# legacy producer
cpu=process.hltHbhereco.clone(),
# alias to the rechits converted to legacy format
cuda=cms.EDAlias(hltHbherecoFromGPU=cms.VPSet(
cms.PSet(type=cms.string("HBHERecHitsSorted")))))
# Tasks and Sequences
process.HLTDoLocalHcalTask = cms.Task(
process.hltHcalDigis, # legacy producer, unpack HCAL digis on cpu
process.hltHcalDigisGPU, # copy to gpu and convert to SoA format
process.
hltHbherecoGPU, # run the HCAL local reconstruction (including Method 0 and MAHI) on gpu
process.
hltHbherecoFromGPU, # transfer the HCAL rechits to the cpu, and convert them to the legacy format
process.
hltHbhereco, # SwitchProducer between the legacy producer and the copy from gpu with conversion
process.hltHfprereco, # legacy producer
process.hltHfreco, # legacy producer
process.hltHoreco) # legacy producer
process.HLTDoLocalHcalSequence = cms.Sequence(process.HLTDoLocalHcalTask)
process.HLTStoppedHSCPLocalHcalRecoTask = cms.Task(
process.hltHcalDigis, # legacy producer, unpack HCAL digis on cpu
process.hltHcalDigisGPU, # copy to gpu and convert to SoA format
process.
hltHbherecoGPU, # run the HCAL local reconstruction (including Method 0 and MAHI) on gpu
process.
hltHbherecoFromGPU, # transfer the HCAL rechits to the cpu, and convert them to the legacy format
process.hltHbhereco
) # SwitchProducer between the legacy producer and the copy from gpu with conversion
process.HLTStoppedHSCPLocalHcalReco = cms.Sequence(
process.HLTStoppedHSCPLocalHcalRecoTask)
# done
return process
import FWCore.ParameterSet.Config as cms
process = cms.Process("TEST")
process.load("FWCore.Framework.test.cmsExceptionsFatal_cff")
process.maxEvents = cms.untracked.PSet(input=cms.untracked.int32(2))
process.source = cms.Source("ThingSource")
process.thing = cms.EDAlias(
source=cms.VPSet(cms.PSet(type=cms.string("edmtestThings"))))
process.OtherThing = cms.EDProducer("OtherThingProducer",
thingTag=cms.InputTag('thing'))
process.Analysis = cms.EDAnalyzer("OtherThingAnalyzer")
process.p = cms.Path(process.OtherThing * process.Analysis)
values=cms.VPSet(
cms.PSet(instance=cms.string("foo"),
value=cms.int32(31))),
throw=cms.untracked.bool(True))
process.intProducer = SwitchProducerTest(
test1=cms.EDProducer("AddIntsProducer",
labels=cms.vstring("intProducer1")),
test2=cms.EDProducer("AddIntsProducer",
labels=cms.vstring("intProducer2")))
# SwitchProducer with an alias
process.intProducerAlias = SwitchProducerTest(
test1=cms.EDProducer("AddIntsProducer",
labels=cms.vstring("intProducer1")),
test2=cms.EDAlias(intProducer3=cms.VPSet(
cms.PSet(type=cms.string("edmtestIntProduct"),
fromProductInstance=cms.string(""),
toProductInstance=cms.string("")),
cms.PSet(type=cms.string("edmtestIntProduct"),
fromProductInstance=cms.string("foo"),
toProductInstance=cms.string("other")))))
process.f = cms.EDFilter("TestFilterModule",
acceptValue=cms.untracked.int32(-1))
process.t = cms.Task(process.intProducer1, process.intProducer2,
process.intProducer3)
process.p = cms.Path(process.f + process.intProducer, process.t)
process.e = cms.EndPath(process.out)
def customiseEcalLocalReconstruction(process):
hasHLTEcalPreshowerSeq = any(seq in process.__dict__ for seq in ['HLTDoFullUnpackingEgammaEcalMFSequence', 'HLTDoFullUnpackingEgammaEcalSequence'])
if not (hasHLTEcalPreshowerSeq or 'HLTDoFullUnpackingEgammaEcalWithoutPreshowerSequence' in process.__dict__):
return process
# FIXME replace the Sequences with empty ones to avoid expanding them during the (re)definition of Modules and EDAliases
process.HLTDoFullUnpackingEgammaEcalWithoutPreshowerSequence = cms.Sequence()
if hasHLTEcalPreshowerSeq:
process.HLTDoFullUnpackingEgammaEcalMFSequence = cms.Sequence()
process.HLTDoFullUnpackingEgammaEcalSequence = cms.Sequence()
# Event Setup
_load_if_missing(process, 'ecalElectronicsMappingGPUESProducer', 'EventFilter.EcalRawToDigi.ecalElectronicsMappingGPUESProducer_cfi')
_load_if_missing(process, 'ecalGainRatiosGPUESProducer', 'RecoLocalCalo.EcalRecProducers.ecalGainRatiosGPUESProducer_cfi')
_load_if_missing(process, 'ecalPedestalsGPUESProducer', 'RecoLocalCalo.EcalRecProducers.ecalPedestalsGPUESProducer_cfi')
_load_if_missing(process, 'ecalPulseCovariancesGPUESProducer', 'RecoLocalCalo.EcalRecProducers.ecalPulseCovariancesGPUESProducer_cfi')
_load_if_missing(process, 'ecalPulseShapesGPUESProducer', 'RecoLocalCalo.EcalRecProducers.ecalPulseShapesGPUESProducer_cfi')
_load_if_missing(process, 'ecalSamplesCorrelationGPUESProducer', 'RecoLocalCalo.EcalRecProducers.ecalSamplesCorrelationGPUESProducer_cfi')
_load_if_missing(process, 'ecalTimeBiasCorrectionsGPUESProducer', 'RecoLocalCalo.EcalRecProducers.ecalTimeBiasCorrectionsGPUESProducer_cfi')
_load_if_missing(process, 'ecalTimeCalibConstantsGPUESProducer', 'RecoLocalCalo.EcalRecProducers.ecalTimeCalibConstantsGPUESProducer_cfi')
_load_if_missing(process, 'ecalMultifitParametersGPUESProducer', 'RecoLocalCalo.EcalRecProducers.ecalMultifitParametersGPUESProducer_cfi')
_load_if_missing(process, 'ecalRechitADCToGeVConstantGPUESProducer', 'RecoLocalCalo.EcalRecProducers.ecalRechitADCToGeVConstantGPUESProducer_cfi')
_load_if_missing(process, 'ecalRechitChannelStatusGPUESProducer', 'RecoLocalCalo.EcalRecProducers.ecalRechitChannelStatusGPUESProducer_cfi')
_load_if_missing(process, 'ecalIntercalibConstantsGPUESProducer', 'RecoLocalCalo.EcalRecProducers.ecalIntercalibConstantsGPUESProducer_cfi')
_load_if_missing(process, 'ecalLaserAPDPNRatiosGPUESProducer', 'RecoLocalCalo.EcalRecProducers.ecalLaserAPDPNRatiosGPUESProducer_cfi')
_load_if_missing(process, 'ecalLaserAPDPNRatiosRefGPUESProducer', 'RecoLocalCalo.EcalRecProducers.ecalLaserAPDPNRatiosRefGPUESProducer_cfi')
_load_if_missing(process, 'ecalLaserAlphasGPUESProducer', 'RecoLocalCalo.EcalRecProducers.ecalLaserAlphasGPUESProducer_cfi')
_load_if_missing(process, 'ecalLinearCorrectionsGPUESProducer', 'RecoLocalCalo.EcalRecProducers.ecalLinearCorrectionsGPUESProducer_cfi')
_load_if_missing(process, 'ecalRecHitParametersGPUESProducer', 'RecoLocalCalo.EcalRecProducers.ecalRecHitParametersGPUESProducer_cfi')
# Modules and EDAliases
# ECAL unpacker running on gpu
_clone_if_missing(process, 'hltEcalDigisGPU', 'EventFilter.EcalRawToDigi.ecalRawToDigiGPU_cfi', 'ecalRawToDigiGPU')
# SwitchProducer: hltEcalDigis
if not isinstance(process.hltEcalDigis, SwitchProducerCUDA):
if 'hltEcalDigisLegacy' not in process.__dict__:
process.hltEcalDigisLegacy = process.hltEcalDigis.clone()
else:
raise Exception('unsupported configuration: "process.hltEcalDigis" is not a SwitchProducerCUDA, but "process.hltEcalDigisLegacy" already exists')
# SwitchProducer wrapping the legacy ECAL unpacker or the ECAL digi converter from SoA format on gpu to legacy format on cpu
process.hltEcalDigis = SwitchProducerCUDA(
# legacy producer
cpu = cms.EDAlias(
hltEcalDigisLegacy = cms.VPSet(
cms.PSet(type = cms.string("EBDigiCollection")),
cms.PSet(type = cms.string("EEDigiCollection")),
cms.PSet(type = cms.string("EBDetIdedmEDCollection")),
cms.PSet(type = cms.string("EEDetIdedmEDCollection")),
cms.PSet(type = cms.string("EBSrFlagsSorted")),
cms.PSet(type = cms.string("EESrFlagsSorted")),
cms.PSet(type = cms.string("EcalElectronicsIdedmEDCollection"), fromProductInstance = cms.string("EcalIntegrityBlockSizeErrors")),
cms.PSet(type = cms.string("EcalElectronicsIdedmEDCollection"), fromProductInstance = cms.string("EcalIntegrityTTIdErrors")),
cms.PSet(type = cms.string("EcalElectronicsIdedmEDCollection"), fromProductInstance = cms.string("EcalIntegrityZSXtalIdErrors")),
cms.PSet(type = cms.string("EcalPnDiodeDigisSorted")),
cms.PSet(type = cms.string("EcalPseudoStripInputDigisSorted"), fromProductInstance = cms.string("EcalPseudoStripInputs")),
cms.PSet(type = cms.string("EcalTriggerPrimitiveDigisSorted"), fromProductInstance = cms.string("EcalTriggerPrimitives")),
)
)
)
# convert ECAL digis from SoA format on gpu to legacy format on cpu
_clone_if_missing(process.hltEcalDigis, 'cuda', 'EventFilter.EcalRawToDigi.ecalCPUDigisProducer_cfi', 'ecalCPUDigisProducer',
digisInLabelEB = ('hltEcalDigisGPU', 'ebDigis'),
digisInLabelEE = ('hltEcalDigisGPU', 'eeDigis'),
produceDummyIntegrityCollections = True
)
# ECAL multifit running on gpu
_clone_if_missing(process, 'hltEcalUncalibRecHitGPU', 'RecoLocalCalo.EcalRecProducers.ecalUncalibRecHitProducerGPU_cfi', 'ecalUncalibRecHitProducerGPU',
digisLabelEB = ('hltEcalDigisGPU', 'ebDigis'),
digisLabelEE = ('hltEcalDigisGPU', 'eeDigis'),
shouldRunTimingComputation = False
)
# copy the ECAL uncalibrated rechits from gpu to cpu in SoA format
_clone_if_missing(process, 'hltEcalUncalibRecHitSoA', 'RecoLocalCalo.EcalRecProducers.ecalCPUUncalibRecHitProducer_cfi', 'ecalCPUUncalibRecHitProducer',
recHitsInLabelEB = ('hltEcalUncalibRecHitGPU', 'EcalUncalibRecHitsEB'),
recHitsInLabelEE = ('hltEcalUncalibRecHitGPU', 'EcalUncalibRecHitsEE'),
)
# SwitchProducer: hltEcalUncalibRecHit
if not isinstance(process.hltEcalUncalibRecHit, SwitchProducerCUDA):
# SwitchProducer wrapping the legacy ECAL uncalibrated rechits producer or a converter from SoA to legacy format
process.hltEcalUncalibRecHit = SwitchProducerCUDA(
# legacy producer
cpu = process.hltEcalUncalibRecHit
)
# convert the ECAL uncalibrated rechits from SoA to legacy format
_clone_if_missing(process.hltEcalUncalibRecHit, 'cuda', 'RecoLocalCalo.EcalRecProducers.ecalUncalibRecHitConvertGPU2CPUFormat_cfi', 'ecalUncalibRecHitConvertGPU2CPUFormat',
recHitsLabelGPUEB = ('hltEcalUncalibRecHitSoA', 'EcalUncalibRecHitsEB'),
recHitsLabelGPUEE = ('hltEcalUncalibRecHitSoA', 'EcalUncalibRecHitsEE'),
)
# Reconstructing the ECAL calibrated rechits on gpu works, but is extremely slow.
# Disable it for the time being, until the performance has been addressed.
"""
_clone_if_missing(process, 'hltEcalRecHitGPU', 'RecoLocalCalo.EcalRecProducers.ecalRecHitGPU_cfi', 'ecalRecHitGPU',
uncalibrecHitsInLabelEB = ("hltEcalUncalibRecHitGPU","EcalUncalibRecHitsEB"),
uncalibrecHitsInLabelEE = ("hltEcalUncalibRecHitGPU","EcalUncalibRecHitsEE"),
)
_clone_if_missing(process, 'hltEcalRecHitSoA', 'RecoLocalCalo.EcalRecProducers.ecalCPURecHitProducer_cfi', 'ecalCPURecHitProducer',
recHitsInLabelEB = ("hltEcalRecHitGPU", "EcalRecHitsEB"),
recHitsInLabelEE = ("hltEcalRecHitGPU", "EcalRecHitsEE"),
)
# SwitchProducer wrapping the legacy ECAL calibrated rechits producer or a converter from SoA to legacy format
if not isinstance(process.hltEcalRecHit, SwitchProducerCUDA):
process.hltEcalRecHit = SwitchProducerCUDA(
# legacy producer
cpu = process.hltEcalRecHit,
)
# convert the ECAL calibrated rechits from SoA to legacy format
_clone_if_missing(process.hltEcalRecHit, 'cuda', 'RecoLocalCalo.EcalRecProducers.ecalRecHitConvertGPU2CPUFormat_cfi', 'ecalRecHitConvertGPU2CPUFormat',
recHitsLabelGPUEB = ("hltEcalRecHitSoA", "EcalRecHitsEB"),
recHitsLabelGPUEE = ("hltEcalRecHitSoA", "EcalRecHitsEE"),
)
"""
# SwitchProducer wrapping the legacy ECAL rechits producer
# the gpu unpacker does not produce the TPs used for the recovery, so the SwitchProducer alias does not provide them:
# - the cpu uncalibrated rechit producer may mark them for recovery, read the TPs explicitly from the legacy unpacker
# - the gpu uncalibrated rechit producer does not flag them for recovery, so the TPs are not necessary
if not isinstance(process.hltEcalRecHit, SwitchProducerCUDA):
process.hltEcalRecHit = SwitchProducerCUDA(
cpu = process.hltEcalRecHit.clone(
triggerPrimitiveDigiCollection = ('hltEcalDigisLegacy', 'EcalTriggerPrimitives')
)
)
elif not hasattr(process.hltEcalRecHit, 'cpu'):
raise Exception('unsupported configuration: "process.hltEcalRecHit" is a SwitchProducerCUDA, but does not have a "cpu" branch')
if not hasattr(process.hltEcalRecHit, 'cuda'):
process.hltEcalRecHit.cuda = process.hltEcalRecHit.cpu.clone(
triggerPrimitiveDigiCollection = 'unused'
)
# enforce consistent configuration of CPU and GPU modules for timing of ECAL RecHits
if process.hltEcalUncalibRecHit.cpu.algoPSet.timealgo == 'RatioMethod':
process.hltEcalUncalibRecHitGPU.shouldRunTimingComputation = True
process.hltEcalUncalibRecHitSoA.containsTimingInformation = True
for _parName in [
'EBtimeFitLimits_Lower',
'EBtimeFitLimits_Upper',
'EEtimeFitLimits_Lower',
'EEtimeFitLimits_Upper',
'EBtimeConstantTerm',
'EEtimeConstantTerm',
'EBtimeNconst',
'EEtimeNconst',
'outOfTimeThresholdGain12pEB',
'outOfTimeThresholdGain12pEE',
'outOfTimeThresholdGain12mEB',
'outOfTimeThresholdGain12mEE',
'outOfTimeThresholdGain61pEB',
'outOfTimeThresholdGain61pEE',
'outOfTimeThresholdGain61mEB',
'outOfTimeThresholdGain61mEE',
]:
setattr(process.hltEcalUncalibRecHitGPU, _parName, getattr(process.hltEcalUncalibRecHit.cpu.algoPSet, _parName))
# note: the "RatioMethod" is the only one available in the GPU implementation
elif process.hltEcalUncalibRecHit.cpu.algoPSet.timealgo != 'None':
_logMsg = '"process.hltEcalUncalibRecHit.cpu.algoPSet.timealgo = \''+process.hltEcalUncalibRecHit.cpu.algoPSet.timealgo+'\'"'
_logMsg += ' has no counterpart in the GPU implementation of the ECAL local reconstruction (use "None" or "RatioMethod")'
raise Exception('unsupported configuration: '+_logMsg)
# Tasks and Sequences
if 'HLTDoFullUnpackingEgammaEcalWithoutPreshowerTask' not in process.__dict__:
process.HLTDoFullUnpackingEgammaEcalWithoutPreshowerTask = cms.Task(
process.hltEcalDigisGPU, # unpack ECAL digis on gpu
process.hltEcalDigisLegacy, # legacy producer, referenced in the SwitchProducer
process.hltEcalDigis, # SwitchProducer
process.hltEcalUncalibRecHitGPU, # run ECAL local reconstruction and multifit on gpu
process.hltEcalUncalibRecHitSoA, # needed by hltEcalPhiSymFilter - copy to host
process.hltEcalUncalibRecHit, # needed by hltEcalPhiSymFilter - convert to legacy format
# process.hltEcalRecHitGPU, # make ECAL calibrated rechits on gpu
# process.hltEcalRecHitSoA, # copy to host
process.hltEcalDetIdToBeRecovered, # legacy producer
process.hltEcalRecHit, # legacy producer
)
elif not isinstance(process.HLTDoFullUnpackingEgammaEcalWithoutPreshowerTask, cms.Task):
raise Exception('unsupported configuration: "process.HLTDoFullUnpackingEgammaEcalWithoutPreshowerTask" already exists, but it is not a Task')
# redefine HLTDoFullUnpackingEgammaEcalWithoutPreshowerSequence (it was emptied at the start of this function)
process.HLTDoFullUnpackingEgammaEcalWithoutPreshowerSequence = cms.Sequence(
process.HLTDoFullUnpackingEgammaEcalWithoutPreshowerTask
)
if hasHLTEcalPreshowerSeq:
if 'HLTPreshowerTask' not in process.__dict__:
process.HLTPreshowerTask = cms.Task(
process.hltEcalPreshowerDigis, # unpack ECAL preshower digis on the host
process.hltEcalPreshowerRecHit, # build ECAL preshower rechits on the host
)
elif not isinstance(process.HLTPreshowerTask, cms.Task):
raise Exception('unsupported configuration: "process.HLTPreshowerTask" already exists, but it is not a Task')
# redefine HLTPreshowerSequence (it was emptied at the start of this function)
process.HLTPreshowerSequence = cms.Sequence(process.HLTPreshowerTask)
if 'HLTDoFullUnpackingEgammaEcalTask' not in process.__dict__:
process.HLTDoFullUnpackingEgammaEcalTask = cms.Task(
process.HLTDoFullUnpackingEgammaEcalWithoutPreshowerTask,
process.HLTPreshowerTask,
)
elif not isinstance(process.HLTDoFullUnpackingEgammaEcalTask, cms.Task):
raise Exception('unsupported configuration: "process.HLTDoFullUnpackingEgammaEcalTask" already exists, but it is not a Task')
# redefine sequences (they were emptied at the start of this function)
process.HLTDoFullUnpackingEgammaEcalSequence = cms.Sequence(process.HLTDoFullUnpackingEgammaEcalTask)
process.HLTDoFullUnpackingEgammaEcalMFSequence = cms.Sequence(process.HLTDoFullUnpackingEgammaEcalTask)
# done
return process
def customisePixelLocalReconstruction(process):
if not 'HLTDoLocalPixelSequence' in process.__dict__:
return process
# FIXME replace the Sequences with empty ones to avoid expanding them during the (re)definition of Modules and EDAliases
process.HLTDoLocalPixelSequence = cms.Sequence()
# Event Setup
_load_if_missing(process, 'PixelCPEFastESProducer', 'RecoLocalTracker.SiPixelRecHits.PixelCPEFastESProducer_cfi')
# these 2 modules should be used only on GPUs, will crash otherwise
_load_if_missing(process, 'siPixelGainCalibrationForHLTGPU', 'CalibTracker.SiPixelESProducers.siPixelGainCalibrationForHLTGPU_cfi')
_load_if_missing(process, 'siPixelROCsStatusAndMappingWrapperESProducer', 'CalibTracker.SiPixelESProducers.siPixelROCsStatusAndMappingWrapperESProducer_cfi')
# Modules and EDAliases
# referenced in HLTDoLocalPixelTask
# transfer the beamspot to the gpu
_clone_if_missing(process, 'hltOnlineBeamSpotToCUDA', 'RecoVertex.BeamSpotProducer.offlineBeamSpotToCUDA_cfi', 'offlineBeamSpotToCUDA',
src = 'hltOnlineBeamSpot'
)
if 'hltSiPixelClustersCUDA' not in process.__dict__:
# reconstruct the pixel digis and clusters on the gpu
_hltSiPixelClustersLegacyLabel = 'hltSiPixelClustersLegacy' if 'hltSiPixelClustersLegacy' in process.__dict__ else 'hltSiPixelClusters'
_clone(process, 'hltSiPixelClustersCUDA', 'RecoLocalTracker.SiPixelClusterizer.siPixelRawToClusterCUDA_cfi', 'siPixelRawToClusterCUDA',
# use the same thresholds as the legacy module
clusterThreshold_layer1 = getattr(process, _hltSiPixelClustersLegacyLabel).ClusterThreshold_L1,
clusterThreshold_otherLayers = getattr(process, _hltSiPixelClustersLegacyLabel).ClusterThreshold,
)
# use the pixel channel calibrations scheme for Run 3
run3_common.toModify(process.hltSiPixelClustersCUDA, isRun2 = False)
# copy the pixel digis errors to the host
_clone_if_missing(process, 'hltSiPixelDigiErrorsSoA', 'EventFilter.SiPixelRawToDigi.siPixelDigiErrorsSoAFromCUDA_cfi', 'siPixelDigiErrorsSoAFromCUDA',
src = 'hltSiPixelClustersCUDA'
)
# copy the pixel digis (except errors) and clusters to the host
_clone_if_missing(process, 'hltSiPixelDigisSoA', 'EventFilter.SiPixelRawToDigi.siPixelDigisSoAFromCUDA_cfi', 'siPixelDigisSoAFromCUDA',
src = 'hltSiPixelClustersCUDA'
)
# SwitchProducer: hltSiPixelDigis
if not isinstance(process.hltSiPixelDigis, SwitchProducerCUDA):
if 'hltSiPixelDigisLegacy' not in process.__dict__:
# reconstruct the pixel digis on the cpu
process.hltSiPixelDigisLegacy = process.hltSiPixelDigis.clone()
# SwitchProducer wrapping a subset of the legacy pixel digis producer, or the conversion of the pixel digis errors to the legacy format
process.hltSiPixelDigis = SwitchProducerCUDA(
# legacy producer
cpu = cms.EDAlias(
hltSiPixelDigisLegacy = cms.VPSet(
cms.PSet(type = cms.string("DetIdedmEDCollection")),
cms.PSet(type = cms.string("SiPixelRawDataErroredmDetSetVector")),
cms.PSet(type = cms.string("PixelFEDChanneledmNewDetSetVector"))
)
)
)
elif not hasattr(process.hltSiPixelDigis, 'cpu'):
raise Exception('unsupported configuration: "process.hltSiPixelDigis" is a SwitchProducerCUDA, but does not have a "cpu" branch')
# conversion from SoA to legacy format
_clone_if_missing(process.hltSiPixelDigis, 'cuda', 'EventFilter.SiPixelRawToDigi.siPixelDigiErrorsFromSoA_cfi', 'siPixelDigiErrorsFromSoA',
digiErrorSoASrc = "hltSiPixelDigiErrorsSoA",
UsePhase1 = True
)
# SwitchProducer: hltSiPixelClusters
if not isinstance(process.hltSiPixelClusters, SwitchProducerCUDA):
if 'hltSiPixelClustersLegacy' not in process.__dict__:
# reconstruct the pixel clusters on the cpu
process.hltSiPixelClustersLegacy = process.hltSiPixelClusters.clone(
src = "hltSiPixelDigisLegacy"
)
# SwitchProducer wrapping a subset of the legacy pixel cluster producer, or the conversion of the pixel digis (except errors) and clusters to the legacy format
process.hltSiPixelClusters = SwitchProducerCUDA(
# legacy producer
cpu = cms.EDAlias(
hltSiPixelClustersLegacy = cms.VPSet(
cms.PSet(type = cms.string("SiPixelClusteredmNewDetSetVector"))
)
)
)
elif not hasattr(process.hltSiPixelClusters, 'cpu'):
raise Exception('unsupported configuration: "process.hltSiPixelClusters" is a SwitchProducerCUDA, but does not have a "cpu" branch')
# conversion from SoA to legacy format
_clone_if_missing(process.hltSiPixelClusters, 'cuda', 'RecoLocalTracker.SiPixelClusterizer.siPixelDigisClustersFromSoA_cfi', 'siPixelDigisClustersFromSoA',
src = 'hltSiPixelDigisSoA',
produceDigis = False,
storeDigis = False,
# use the same thresholds as the legacy module
clusterThreshold_layer1 = process.hltSiPixelClustersLegacy.ClusterThreshold_L1,
clusterThreshold_otherLayers = process.hltSiPixelClustersLegacy.ClusterThreshold
)
# reconstruct the pixel rechits on the gpu
_clone_if_missing(process, 'hltSiPixelRecHitsCUDA', 'RecoLocalTracker.SiPixelRecHits.siPixelRecHitCUDA_cfi', 'siPixelRecHitCUDA',
src = 'hltSiPixelClustersCUDA',
beamSpot = 'hltOnlineBeamSpotToCUDA'
)
# cpu only: produce the pixel rechits in SoA and legacy format, from the legacy clusters
_clone_if_missing(process, 'hltSiPixelRecHitSoA', 'RecoLocalTracker.SiPixelRecHits.siPixelRecHitSoAFromLegacy_cfi', 'siPixelRecHitSoAFromLegacy',
src = 'hltSiPixelClusters',
beamSpot = 'hltOnlineBeamSpot',
convertToLegacy = True
)
# SwitchProducer: hltSiPixelRecHits
if not isinstance(process.hltSiPixelRecHits, SwitchProducerCUDA):
# SwitchProducer wrapping the legacy pixel rechit producer or the transfer of the pixel rechits to the host and the conversion from SoA
process.hltSiPixelRecHits = SwitchProducerCUDA(
# legacy producer
cpu = cms.EDAlias(
hltSiPixelRecHitSoA = cms.VPSet(
cms.PSet(type = cms.string("SiPixelRecHitedmNewDetSetVector")),
cms.PSet(type = cms.string("uintAsHostProduct"))
)
)
)
elif not hasattr(process.hltSiPixelRecHits, 'cpu'):
raise Exception('unsupported configuration: "process.hltSiPixelRecHits" is a SwitchProducerCUDA, but does not have a "cpu" branch')
# conversion from SoA to legacy format
_clone_if_missing(process.hltSiPixelRecHits, 'cuda', 'RecoLocalTracker.SiPixelRecHits.siPixelRecHitFromCUDA_cfi', 'siPixelRecHitFromCUDA',
pixelRecHitSrc = 'hltSiPixelRecHitsCUDA',
src = 'hltSiPixelClusters'
)
# Tasks and Sequences
if 'HLTDoLocalPixelTask' not in process.__dict__:
process.HLTDoLocalPixelTask = cms.Task(
process.hltOnlineBeamSpotToCUDA, # transfer the beamspot to the gpu
process.hltSiPixelClustersCUDA, # reconstruct the pixel digis and clusters on the gpu
process.hltSiPixelRecHitsCUDA, # reconstruct the pixel rechits on the gpu
process.hltSiPixelDigisSoA, # copy the pixel digis (except errors) and clusters to the host
process.hltSiPixelDigiErrorsSoA, # copy the pixel digis errors to the host
process.hltSiPixelDigisLegacy, # legacy pixel digis producer
process.hltSiPixelDigis, # SwitchProducer wrapping a subset of the legacy pixel digis producer, or the conversion of the pixel digis errors from SoA
process.hltSiPixelClustersLegacy, # legacy pixel cluster producer
process.hltSiPixelClusters, # SwitchProducer wrapping a subset of the legacy pixel cluster producer, or the conversion of the pixel digis (except errors) and clusters from SoA
process.hltSiPixelClustersCache, # legacy module, used by the legacy pixel quadruplet producer
process.hltSiPixelRecHitSoA, # pixel rechits on cpu, in SoA & legacy format
process.hltSiPixelRecHits, # SwitchProducer wrapping the legacy pixel rechit producer or the transfer of the pixel rechits to the host and the conversion from SoA
)
elif not isinstance(process.HLTDoLocalPixelTask, cms.Task):
raise Exception('unsupported configuration: "process.HLTDoLocalPixelTask" already exists, but it is not a Task')
# redefine HLTDoLocalPixelSequence (it was emptied at the start of this function)
process.HLTDoLocalPixelSequence = cms.Sequence(process.HLTDoLocalPixelTask)
# workaround for old version of AlCa_LumiPixelsCounts paths
for AlCaPathName in ['AlCa_LumiPixelsCounts_Random_v1', 'AlCa_LumiPixelsCounts_ZeroBias_v1']:
if AlCaPathName in process.__dict__:
AlCaPath = getattr(process, AlCaPathName)
# replace hltSiPixelDigis+hltSiPixelClusters with HLTDoLocalPixelSequence
hasSiPixelDigis, hasSiPixelClusters = False, False
for (itemLabel, itemName) in AlCaPath.directDependencies():
if itemLabel != 'modules': continue
if itemName == 'hltSiPixelDigis': hasSiPixelDigis = True
elif itemName == 'hltSiPixelClusters': hasSiPixelClusters = True
if hasSiPixelDigis and hasSiPixelClusters:
AlCaPath.remove(process.hltSiPixelClusters)
AlCaPath.replace(process.hltSiPixelDigis, process.HLTDoLocalPixelSequence)
# done
return process
def customiseEcalLocalReconstruction(process):
hasHLTEcalPreshowerSeq = any(seq in process.__dict__ for seq in [
'HLTDoFullUnpackingEgammaEcalMFSequence',
'HLTDoFullUnpackingEgammaEcalSequence'
])
if not (hasHLTEcalPreshowerSeq
or 'HLTDoFullUnpackingEgammaEcalWithoutPreshowerSequence'
in process.__dict__):
return process
# FIXME replace the Sequences with empty ones to avoid expanding them during the (re)definition of Modules and EDAliases
process.HLTDoFullUnpackingEgammaEcalWithoutPreshowerSequence = cms.Sequence(
)
if hasHLTEcalPreshowerSeq:
process.HLTDoFullUnpackingEgammaEcalMFSequence = cms.Sequence()
process.HLTDoFullUnpackingEgammaEcalSequence = cms.Sequence()
# Event Setup
process.load(
"EventFilter.EcalRawToDigi.ecalElectronicsMappingGPUESProducer_cfi")
process.load(
"RecoLocalCalo.EcalRecProducers.ecalGainRatiosGPUESProducer_cfi")
process.load(
"RecoLocalCalo.EcalRecProducers.ecalPedestalsGPUESProducer_cfi")
process.load(
"RecoLocalCalo.EcalRecProducers.ecalPulseCovariancesGPUESProducer_cfi")
process.load(
"RecoLocalCalo.EcalRecProducers.ecalPulseShapesGPUESProducer_cfi")
process.load(
"RecoLocalCalo.EcalRecProducers.ecalSamplesCorrelationGPUESProducer_cfi"
)
process.load(
"RecoLocalCalo.EcalRecProducers.ecalTimeBiasCorrectionsGPUESProducer_cfi"
)
process.load(
"RecoLocalCalo.EcalRecProducers.ecalTimeCalibConstantsGPUESProducer_cfi"
)
process.load(
"RecoLocalCalo.EcalRecProducers.ecalMultifitParametersGPUESProducer_cfi"
)
process.load(
"RecoLocalCalo.EcalRecProducers.ecalRechitADCToGeVConstantGPUESProducer_cfi"
)
process.load(
"RecoLocalCalo.EcalRecProducers.ecalRechitChannelStatusGPUESProducer_cfi"
)
process.load(
"RecoLocalCalo.EcalRecProducers.ecalIntercalibConstantsGPUESProducer_cfi"
)
process.load(
"RecoLocalCalo.EcalRecProducers.ecalLaserAPDPNRatiosGPUESProducer_cfi")
process.load(
"RecoLocalCalo.EcalRecProducers.ecalLaserAPDPNRatiosRefGPUESProducer_cfi"
)
process.load(
"RecoLocalCalo.EcalRecProducers.ecalLaserAlphasGPUESProducer_cfi")
process.load(
"RecoLocalCalo.EcalRecProducers.ecalLinearCorrectionsGPUESProducer_cfi"
)
process.load(
"RecoLocalCalo.EcalRecProducers.ecalRecHitParametersGPUESProducer_cfi")
# Modules and EDAliases
# ECAL unpacker running on gpu
from EventFilter.EcalRawToDigi.ecalRawToDigiGPU_cfi import ecalRawToDigiGPU as _ecalRawToDigiGPU
process.hltEcalDigisGPU = _ecalRawToDigiGPU.clone()
# SwitchProducer wrapping the legacy ECAL unpacker or the ECAL digi converter from SoA format on gpu to legacy format on cpu
process.hltEcalDigisLegacy = process.hltEcalDigis.clone()
from EventFilter.EcalRawToDigi.ecalCPUDigisProducer_cfi import ecalCPUDigisProducer as _ecalCPUDigisProducer
process.hltEcalDigis = SwitchProducerCUDA(
# legacy producer
cpu=cms.EDAlias(hltEcalDigisLegacy=cms.VPSet(
cms.PSet(type=cms.string("EBDigiCollection")),
cms.PSet(type=cms.string("EEDigiCollection")),
cms.PSet(type=cms.string("EBDetIdedmEDCollection")),
cms.PSet(type=cms.string("EEDetIdedmEDCollection")),
cms.PSet(type=cms.string("EBSrFlagsSorted")),
cms.PSet(type=cms.string("EESrFlagsSorted")),
cms.PSet(type=cms.string("EcalElectronicsIdedmEDCollection"),
fromProductInstance=cms.string(
"EcalIntegrityBlockSizeErrors")),
cms.PSet(type=cms.string("EcalElectronicsIdedmEDCollection"),
fromProductInstance=cms.string(
"EcalIntegrityTTIdErrors")),
cms.PSet(type=cms.string("EcalElectronicsIdedmEDCollection"),
fromProductInstance=cms.string(
"EcalIntegrityZSXtalIdErrors")),
cms.PSet(type=cms.string("EcalPnDiodeDigisSorted")),
cms.PSet(type=cms.string("EcalPseudoStripInputDigisSorted"),
fromProductInstance=cms.string("EcalPseudoStripInputs")),
cms.PSet(type=cms.string("EcalTriggerPrimitiveDigisSorted"),
fromProductInstance=cms.string("EcalTriggerPrimitives")),
)),
# convert ECAL digis from SoA format on gpu to legacy format on cpu
cuda=_ecalCPUDigisProducer.clone(
digisInLabelEB=("hltEcalDigisGPU", "ebDigis"),
digisInLabelEE=("hltEcalDigisGPU", "eeDigis"),
produceDummyIntegrityCollections=cms.bool(True)))
# ECAL multifit running on gpu
from RecoLocalCalo.EcalRecProducers.ecalUncalibRecHitProducerGPU_cfi import ecalUncalibRecHitProducerGPU as _ecalUncalibRecHitProducerGPU
process.hltEcalUncalibRecHitGPU = _ecalUncalibRecHitProducerGPU.clone(
digisLabelEB=("hltEcalDigisGPU", "ebDigis"),
digisLabelEE=("hltEcalDigisGPU", "eeDigis"),
shouldRunTimingComputation=False)
# copy the ECAL uncalibrated rechits from gpu to cpu in SoA format
from RecoLocalCalo.EcalRecProducers.ecalCPUUncalibRecHitProducer_cfi import ecalCPUUncalibRecHitProducer as _ecalCPUUncalibRecHitProducer
process.hltEcalUncalibRecHitSoA = _ecalCPUUncalibRecHitProducer.clone(
recHitsInLabelEB=("hltEcalUncalibRecHitGPU", "EcalUncalibRecHitsEB"),
recHitsInLabelEE=("hltEcalUncalibRecHitGPU", "EcalUncalibRecHitsEE"),
)
# SwitchProducer wrapping the legacy ECAL uncalibrated rechits producer or a converter from SoA to legacy format
from RecoLocalCalo.EcalRecProducers.ecalUncalibRecHitConvertGPU2CPUFormat_cfi import ecalUncalibRecHitConvertGPU2CPUFormat as _ecalUncalibRecHitConvertGPU2CPUFormat
process.hltEcalUncalibRecHit = SwitchProducerCUDA(
# legacy producer
cpu=process.hltEcalUncalibRecHit,
# convert the ECAL uncalibrated rechits from SoA to legacy format
cuda=_ecalUncalibRecHitConvertGPU2CPUFormat.clone(
recHitsLabelGPUEB=("hltEcalUncalibRecHitSoA",
"EcalUncalibRecHitsEB"),
recHitsLabelGPUEE=("hltEcalUncalibRecHitSoA",
"EcalUncalibRecHitsEE"),
))
# Reconstructing the ECAL calibrated rechits on gpu works, but is extremely slow.
# Disable it for the time being, until the performance has been addressed.
"""
from RecoLocalCalo.EcalRecProducers.ecalRecHitGPU_cfi import ecalRecHitGPU as _ecalRecHitGPU
process.hltEcalRecHitGPU = _ecalRecHitGPU.clone(
uncalibrecHitsInLabelEB = ("hltEcalUncalibRecHitGPU","EcalUncalibRecHitsEB"),
uncalibrecHitsInLabelEE = ("hltEcalUncalibRecHitGPU","EcalUncalibRecHitsEE"),
)
from RecoLocalCalo.EcalRecProducers.ecalCPURecHitProducer_cfi import ecalCPURecHitProducer as _ecalCPURecHitProducer
process.hltEcalRecHitSoA = _ecalCPURecHitProducer.clone(
recHitsInLabelEB = ("hltEcalRecHitGPU", "EcalRecHitsEB"),
recHitsInLabelEE = ("hltEcalRecHitGPU", "EcalRecHitsEE"),
)
# SwitchProducer wrapping the legacy ECAL calibrated rechits producer or a converter from SoA to legacy format
from RecoLocalCalo.EcalRecProducers.ecalRecHitConvertGPU2CPUFormat_cfi import ecalRecHitConvertGPU2CPUFormat as _ecalRecHitConvertGPU2CPUFormat
process.hltEcalRecHit = SwitchProducerCUDA(
# legacy producer
cpu = process.hltEcalRecHit,
# convert the ECAL calibrated rechits from SoA to legacy format
cuda = _ecalRecHitConvertGPU2CPUFormat.clone(
recHitsLabelGPUEB = ("hltEcalRecHitSoA", "EcalRecHitsEB"),
recHitsLabelGPUEE = ("hltEcalRecHitSoA", "EcalRecHitsEE"),
)
)
"""
# SwitchProducer wrapping the legacy ECAL rechits producer
# the gpu unpacker does not produce the TPs used for the recovery, so the SwitchProducer alias does not provide them:
# - the cpu uncalibrated rechit producer may mark them for recovery, read the TPs explicitly from the legacy unpacker
# - the gpu uncalibrated rechit producer does not flag them for recovery, so the TPs are not necessary
process.hltEcalRecHit = SwitchProducerCUDA(
cpu=process.hltEcalRecHit.clone(
triggerPrimitiveDigiCollection=('hltEcalDigisLegacy',
'EcalTriggerPrimitives')),
cuda=process.hltEcalRecHit.clone(
triggerPrimitiveDigiCollection='unused'))
# Tasks and Sequences
process.HLTDoFullUnpackingEgammaEcalWithoutPreshowerTask = cms.Task(
process.hltEcalDigisGPU, # unpack ECAL digis on gpu
process.
hltEcalDigisLegacy, # legacy producer, referenced in the SwitchProducer
process.hltEcalDigis, # SwitchProducer
process.
hltEcalUncalibRecHitGPU, # run ECAL local reconstruction and multifit on gpu
process.
hltEcalUncalibRecHitSoA, # needed by hltEcalPhiSymFilter - copy to host
process.
hltEcalUncalibRecHit, # needed by hltEcalPhiSymFilter - convert to legacy format
# process.hltEcalRecHitGPU, # make ECAL calibrated rechits on gpu
# process.hltEcalRecHitSoA, # copy to host
process.hltEcalDetIdToBeRecovered, # legacy producer
process.hltEcalRecHit) # legacy producer
process.HLTDoFullUnpackingEgammaEcalWithoutPreshowerSequence = cms.Sequence(
process.HLTDoFullUnpackingEgammaEcalWithoutPreshowerTask)
if hasHLTEcalPreshowerSeq:
process.HLTPreshowerTask = cms.Task(
process.
hltEcalPreshowerDigis, # unpack ECAL preshower digis on the host
process.hltEcalPreshowerRecHit
) # build ECAL preshower rechits on the host
process.HLTPreshowerSequence = cms.Sequence(process.HLTPreshowerTask)
process.HLTDoFullUnpackingEgammaEcalTask = cms.Task(
process.HLTDoFullUnpackingEgammaEcalWithoutPreshowerTask,
process.HLTPreshowerTask)
process.HLTDoFullUnpackingEgammaEcalSequence = cms.Sequence(
process.HLTDoFullUnpackingEgammaEcalTask)
process.HLTDoFullUnpackingEgammaEcalMFSequence = cms.Sequence(
process.HLTDoFullUnpackingEgammaEcalTask)
# done
return process
cpu=siPixelRecHitsPreSplittingSoA.clone())
siPixelRecHitsPreSplittingTask = cms.Task(
# SwitchProducer wrapping the legacy pixel rechit producer or the cpu SoA producer
siPixelRecHitsPreSplitting)
# reconstruct the pixel rechits on the gpu
from RecoLocalTracker.SiPixelRecHits.siPixelRecHitCUDA_cfi import siPixelRecHitCUDA as _siPixelRecHitCUDA
siPixelRecHitsPreSplittingCUDA = _siPixelRecHitCUDA.clone(
beamSpot="offlineBeamSpotToCUDA")
# transfer the pixel rechits to the host and convert them from SoA
from RecoLocalTracker.SiPixelRecHits.siPixelRecHitFromCUDA_cfi import siPixelRecHitFromCUDA as _siPixelRecHitFromCUDA
(gpu & pixelNtupletFit).toModify(
siPixelRecHitsPreSplitting,
cpu=cms.EDAlias(siPixelRecHitsPreSplittingSoA=cms.VPSet(
cms.PSet(type=cms.string("SiPixelRecHitedmNewDetSetVector")),
cms.PSet(type=cms.string("uintAsHostProduct")))),
cuda=_siPixelRecHitFromCUDA.clone())
(gpu & pixelNtupletFit).toReplaceWith(
siPixelRecHitsPreSplittingTask,
cms.Task(
# reconstruct the pixel rechits on the gpu
siPixelRecHitsPreSplittingCUDA,
# producing and converting on cpu
siPixelRecHitsPreSplittingSoA,
# SwitchProducer wrapping an EDAlias on cpu or the converter from SoA to legacy on gpu
siPixelRecHitsPreSplittingTask.copy()))
verifyChecksum=cms.untracked.bool(False),
useL1EventID=cms.untracked.bool(False),
firstLuminosityBlockForEachRun=cms.untracked.VLuminosityBlockID(
*[cms.LuminosityBlockID(options.firstRun, 0)]),
)
## otherwise, just use an empty source
## reading the CSC data is done with a the CSCFileReader producer
else:
process.source = cms.Source(
"EmptySource",
firstRun=cms.untracked.uint32(options.firstRun),
numberEventsInLuminosityBlock=cms.untracked.uint32(200),
numberEventsInRun=cms.untracked.uint32(0))
## this block ensures that the GEM output collection is named rawDataCollectorGEM, not source
process.rawDataCollectorGEM = cms.EDAlias(
source=cms.VPSet(cms.PSet(type=cms.string('FEDRawDataCollection'))))
# Note by Sven Dildick: I had to change the CSC producer module name to process.rawDataCollectorCSC so
# that the name would not conflict with the GEM source.
# For B904 setup ME11 chamber, which corresponds to ME+1/1/02 in the production system mapping
# changing to FED837 and RUI16 could let to pass data without disabling mapping consistency check unpacking flags
process.rawDataCollectorCSC = cms.EDProducer(
'CSCFileReader',
firstEvent=cms.untracked.int32(0),
FED846=cms.untracked.vstring('RUI01'),
RUI01=cms.untracked.vstring(options.inputFiles[0])
# FED837 = cms.untracked.vstring('RUI16'),
# RUI16 = cms.untracked.vstring('/afs/cern.ch/user/b/barvic/public/cscgem_tests/csc_00000001_EmuRUI01_Local_000_210519_162820_UTC.raw')
)
def infoToAlias(info):
_dict = dict()
for entry in info:
_dict[entry.key.value()] = entry.value
return cms.EDAlias(**_dict)
process.testTranscriberFromCuda = cms.EDProducer(
'alpaka_cuda_async::TestAlpakaTranscriber',
source=cms.InputTag('testProducerCuda'))
# run the producer on the cpu
process.testProducerCpu = cms.EDProducer(
'alpaka_serial_sync::TestAlpakaProducer', size=cms.int32(42))
# extract the cpu product from the heterogeneous wrapper
process.testTranscriberFromCpu = cms.EDProducer(
'alpaka_serial_sync::TestAlpakaTranscriber',
source=cms.InputTag('testProducerCpu'))
# either run the producer on a CUDA gpu (if available) and copy the product to the cpu, or run the producer directly on the cpu
process.testProducer = SwitchProducerCUDA(
cpu=cms.EDAlias(
testTranscriberFromCpu=cms.VPSet(cms.PSet(type=cms.string('*')))),
cuda=cms.EDAlias(
testTranscriberFromCuda=cms.VPSet(cms.PSet(type=cms.string('*')))))
# analyse the product
process.testAnalyzer = cms.EDAnalyzer('TestAlpakaAnalyzer',
source=cms.InputTag('testProducer'))
# run a second producer explicitly on the cpu
process.testProducerSerial = cms.EDProducer(
'alpaka_serial_sync::TestAlpakaProducer', size=cms.int32(99))
# extract the cpu product from the heterogeneous wrapper
process.testTranscriberSerial = cms.EDProducer(
'alpaka_serial_sync::TestAlpakaTranscriber',
source=cms.InputTag('testProducerSerial'))
def customiseHcalLocalReconstruction(process):
hasHLTDoLocalHcalSeq = 'HLTDoLocalHcalSequence' in process.__dict__
if not (hasHLTDoLocalHcalSeq or 'HLTStoppedHSCPLocalHcalReco' in process.__dict__):
return process
# FIXME replace the Sequences with empty ones to avoid expanding them during the (re)definition of Modules and EDAliases
if hasHLTDoLocalHcalSeq:
process.HLTDoLocalHcalSequence = cms.Sequence()
process.HLTStoppedHSCPLocalHcalReco = cms.Sequence()
# Event Setup
_load_if_missing(process, 'hcalElectronicsMappingGPUESProducer', 'EventFilter.HcalRawToDigi.hcalElectronicsMappingGPUESProducer_cfi')
_load_if_missing(process, 'hcalChannelQualityGPUESProducer', 'RecoLocalCalo.HcalRecProducers.hcalChannelQualityGPUESProducer_cfi')
_load_if_missing(process, 'hcalGainsGPUESProducer', 'RecoLocalCalo.HcalRecProducers.hcalGainsGPUESProducer_cfi')
_load_if_missing(process, 'hcalGainWidthsGPUESProducer', 'RecoLocalCalo.HcalRecProducers.hcalGainWidthsGPUESProducer_cfi')
_load_if_missing(process, 'hcalLUTCorrsGPUESProducer', 'RecoLocalCalo.HcalRecProducers.hcalLUTCorrsGPUESProducer_cfi')
_load_if_missing(process, 'hcalConvertedPedestalsGPUESProducer', 'RecoLocalCalo.HcalRecProducers.hcalConvertedPedestalsGPUESProducer_cfi')
_load_if_missing(process, 'hcalConvertedPedestalWidthsGPUESProducer', 'RecoLocalCalo.HcalRecProducers.hcalConvertedPedestalWidthsGPUESProducer_cfi')
_load_if_missing(process, 'hcalQIECodersGPUESProducer', 'RecoLocalCalo.HcalRecProducers.hcalQIECodersGPUESProducer_cfi')
_load_if_missing(process, 'hcalRecoParamsWithPulseShapesGPUESProducer', 'RecoLocalCalo.HcalRecProducers.hcalRecoParamsWithPulseShapesGPUESProducer_cfi')
_load_if_missing(process, 'hcalRespCorrsGPUESProducer', 'RecoLocalCalo.HcalRecProducers.hcalRespCorrsGPUESProducer_cfi')
_load_if_missing(process, 'hcalTimeCorrsGPUESProducer', 'RecoLocalCalo.HcalRecProducers.hcalTimeCorrsGPUESProducer_cfi')
_load_if_missing(process, 'hcalQIETypesGPUESProducer', 'RecoLocalCalo.HcalRecProducers.hcalQIETypesGPUESProducer_cfi')
_load_if_missing(process, 'hcalSiPMParametersGPUESProducer', 'RecoLocalCalo.HcalRecProducers.hcalSiPMParametersGPUESProducer_cfi')
_load_if_missing(process, 'hcalSiPMCharacteristicsGPUESProducer', 'RecoLocalCalo.HcalRecProducers.hcalSiPMCharacteristicsGPUESProducer_cfi')
_load_if_missing(process, 'hcalMahiPulseOffsetsGPUESProducer', 'RecoLocalCalo.HcalRecProducers.hcalMahiPulseOffsetsGPUESProducer_cfi')
_clone_if_missing(process, 'hcalConvertedEffectivePedestalsGPUESProducer', 'RecoLocalCalo.HcalRecProducers.hcalConvertedEffectivePedestalsGPUESProducer_cfi',
label0 = 'withTopoEff'
)
_clone_if_missing(process, 'hcalConvertedEffectivePedestalWidthsGPUESProducer', 'RecoLocalCalo.HcalRecProducers.hcalConvertedEffectivePedestalWidthsGPUESProducer_cfi',
label0 = 'withTopoEff',
label1 = 'withTopoEff'
)
# Modules and EDAliases
# The HCAL unpacker running on the gpu supports only the HB and HE digis.
# So, run the legacy unacker on the cpu, then convert the HB and HE digis
# to SoA format and copy them to the gpu.
_clone_if_missing(process, 'hltHcalDigisGPU', 'EventFilter.HcalRawToDigi.hcalDigisProducerGPU_cfi', 'hcalDigisProducerGPU',
hbheDigisLabel = 'hltHcalDigis',
qie11DigiLabel = 'hltHcalDigis',
digisLabelF01HE = '',
digisLabelF5HB = '',
digisLabelF3HB = ''
)
# run the HCAL local reconstruction (including Method 0 and MAHI) on gpu
_clone_if_missing(process, 'hltHbherecoGPU', 'RecoLocalCalo.HcalRecProducers.hbheRecHitProducerGPU_cfi', 'hbheRecHitProducerGPU',
digisLabelF01HE = 'hltHcalDigisGPU',
digisLabelF5HB = 'hltHcalDigisGPU',
digisLabelF3HB = 'hltHcalDigisGPU',
recHitsLabelM0HBHE = ''
)
# transfer the HCAL rechits to the cpu, and convert them to the legacy format
_clone_if_missing(process, 'hltHbherecoFromGPU', 'RecoLocalCalo.HcalRecProducers.hcalCPURecHitsProducer_cfi', 'hcalCPURecHitsProducer',
recHitsM0LabelIn = 'hltHbherecoGPU',
recHitsM0LabelOut = '',
recHitsLegacyLabelOut = ''
)
# SwitchProducer between the legacy producer and the copy from gpu with conversion
if not isinstance(process.hltHbhereco, SwitchProducerCUDA):
process.hltHbhereco = SwitchProducerCUDA(
# legacy producer
cpu = process.hltHbhereco.clone()
)
elif not hasattr(process.hltHbhereco, 'cpu'):
raise Exception('unsupported configuration: "process.hltHbhereco" is a SwitchProducerCUDA, but does not have a "cpu" branch')
if not hasattr(process.hltHbhereco, 'cuda'):
# alias to the rechits converted to legacy format
process.hltHbhereco.cuda = cms.EDAlias(
hltHbherecoFromGPU = cms.VPSet(
cms.PSet(type = cms.string('HBHERecHitsSorted'))
)
)
# Tasks and Sequences
if hasHLTDoLocalHcalSeq:
if 'HLTDoLocalHcalTask' not in process.__dict__:
process.HLTDoLocalHcalTask = cms.Task(
process.hltHcalDigis, # legacy producer, unpack HCAL digis on cpu
process.hltHcalDigisGPU, # copy to gpu and convert to SoA format
process.hltHbherecoGPU, # run the HCAL local reconstruction (including Method 0 and MAHI) on gpu
process.hltHbherecoFromGPU, # transfer the HCAL rechits to the cpu, and convert them to the legacy format
process.hltHbhereco, # SwitchProducer between the legacy producer and the copy from gpu with conversion
process.hltHfprereco, # legacy producer
process.hltHfreco, # legacy producer
process.hltHoreco # legacy producer
)
elif not isinstance(process.HLTDoLocalHcalTask, cms.Task):
raise Exception('unsupported configuration: "process.HLTDoLocalHcalTask" already exists, but it is not a Task')
# redefine HLTDoLocalHcalSequence (it was emptied at the start of this function)
process.HLTDoLocalHcalSequence = cms.Sequence(process.HLTDoLocalHcalTask)
if 'HLTStoppedHSCPLocalHcalRecoTask' not in process.__dict__:
process.HLTStoppedHSCPLocalHcalRecoTask = cms.Task(
process.hltHcalDigis, # legacy producer, unpack HCAL digis on cpu
process.hltHcalDigisGPU, # copy to gpu and convert to SoA format
process.hltHbherecoGPU, # run the HCAL local reconstruction (including Method 0 and MAHI) on gpu
process.hltHbherecoFromGPU, # transfer the HCAL rechits to the cpu, and convert them to the legacy format
process.hltHbhereco # SwitchProducer between the legacy producer and the copy from gpu with conversion
)
elif not isinstance(process.HLTStoppedHSCPLocalHcalRecoTask, cms.Task):
raise Exception('unsupported configuration: "process.HLTStoppedHSCPLocalHcalRecoTask" already exists, but it is not a Task')
# redefine HLTStoppedHSCPLocalHcalReco (it was emptied at the start of this function)
process.HLTStoppedHSCPLocalHcalReco = cms.Sequence(process.HLTStoppedHSCPLocalHcalRecoTask)
# done
return process
process.tryNoPut = cms.EDProducer("ThingWithMergeProducer",
noPut=cms.untracked.bool(True))
# This one tests products dropped and then restored by secondary file
# input
process.makeThingToBeDropped = cms.EDProducer("ThingWithMergeProducer")
process.makeThingToBeDropped2 = cms.EDProducer("ThingWithMergeProducer")
process.aliasForThingToBeDropped2 = cms.EDAlias(
makeThingToBeDropped2=cms.VPSet(
cms.PSet(type=cms.string('edmtestThing'),
fromProductInstance=cms.string('event'),
toProductInstance=cms.string('instance2')),
cms.PSet(type=cms.string('edmtestThing'),
fromProductInstance=cms.string('endLumi'),
toProductInstance=cms.string('endLumi2')),
cms.PSet(type=cms.string('edmtestThing'),
fromProductInstance=cms.string('endRun'),
toProductInstance=cms.string('endRun2'))))
# This product will be produced in configuration PROD1 and PROD5
# In PROD2 it will be produced and dropped and there will be another
# product whose provenance includes it as a parent. In PROD3 it will
# be produced and dropped and there will not be a product that includes
# it as a parent. In PROD4 it will never be produced at all.
process.makeThingToBeDropped1 = cms.EDProducer("ThingWithMergeProducer")
process.dependsOnThingToBeDropped1 = cms.EDProducer(
"ThingWithMergeProducer",
labelsToGet=cms.untracked.vstring('makeThingToBeDropped1'))
process.out = cms.OutputModule(
"PoolOutputModule",
fileName=cms.untracked.string('testProcessBlock2.root'),
outputCommands=cms.untracked.vstring("keep *",
"drop *_testEDAliasOriginal_*_*"))
process.intProducerBeginProcessBlock = cms.EDProducer(
"IntProducerBeginProcessBlock", ivalue=cms.int32(2))
process.intProducerEndProcessBlock = cms.EDProducer(
"IntProducerEndProcessBlock", ivalue=cms.int32(20))
process.intProducerBeginProcessBlockB = cms.EDProducer(
"IntProducerBeginProcessBlock", ivalue=cms.int32(7))
process.intProducerEndProcessBlockB = cms.EDProducer(
"IntProducerEndProcessBlock", ivalue=cms.int32(70))
process.testEDAliasOriginal = cms.EDProducer("IntProducerBeginProcessBlock",
ivalue=cms.int32(111))
process.testEDAliasAlias = cms.EDAlias(testEDAliasOriginal=cms.VPSet(
cms.PSet(type=cms.string('edmtestIntProduct'))))
process.p = cms.Path(
process.intProducerBeginProcessBlock * process.intProducerEndProcessBlock *
process.intProducerBeginProcessBlockB *
process.intProducerEndProcessBlockB * process.testEDAliasOriginal)
process.e = cms.EndPath(process.out)
def customiseEcalLocalReconstruction(process):
if not 'HLTDoFullUnpackingEgammaEcalSequence' in process.__dict__:
return process
# FIXME replace the Sequences with empty ones to avoid exanding them during the (re)definition of Modules and EDAliases
process.HLTDoFullUnpackingEgammaEcalMFSequence = cms.Sequence()
process.HLTDoFullUnpackingEgammaEcalWithoutPreshowerSequence = cms.Sequence(
)
process.HLTDoFullUnpackingEgammaEcalSequence = cms.Sequence()
# Event Setup
process.load(
"EventFilter.EcalRawToDigi.ecalElectronicsMappingGPUESProducer_cfi")
process.load(
"RecoLocalCalo.EcalRecProducers.ecalGainRatiosGPUESProducer_cfi")
process.load(
"RecoLocalCalo.EcalRecProducers.ecalPedestalsGPUESProducer_cfi")
process.load(
"RecoLocalCalo.EcalRecProducers.ecalPulseCovariancesGPUESProducer_cfi")
process.load(
"RecoLocalCalo.EcalRecProducers.ecalPulseShapesGPUESProducer_cfi")
process.load(
"RecoLocalCalo.EcalRecProducers.ecalSamplesCorrelationGPUESProducer_cfi"
)
process.load(
"RecoLocalCalo.EcalRecProducers.ecalTimeBiasCorrectionsGPUESProducer_cfi"
)
process.load(
"RecoLocalCalo.EcalRecProducers.ecalTimeCalibConstantsGPUESProducer_cfi"
)
process.load(
"RecoLocalCalo.EcalRecProducers.ecalMultifitParametersGPUESProducer_cfi"
)
process.load(
"RecoLocalCalo.EcalRecProducers.ecalRechitADCToGeVConstantGPUESProducer_cfi"
)
process.load(
"RecoLocalCalo.EcalRecProducers.ecalRechitChannelStatusGPUESProducer_cfi"
)
process.load(
"RecoLocalCalo.EcalRecProducers.ecalIntercalibConstantsGPUESProducer_cfi"
)
process.load(
"RecoLocalCalo.EcalRecProducers.ecalLaserAPDPNRatiosGPUESProducer_cfi")
process.load(
"RecoLocalCalo.EcalRecProducers.ecalLaserAPDPNRatiosRefGPUESProducer_cfi"
)
process.load(
"RecoLocalCalo.EcalRecProducers.ecalLaserAlphasGPUESProducer_cfi")
process.load(
"RecoLocalCalo.EcalRecProducers.ecalLinearCorrectionsGPUESProducer_cfi"
)
process.load(
"RecoLocalCalo.EcalRecProducers.ecalRecHitParametersGPUESProducer_cfi")
# Modules and EDAliases
# ECAL unpacker running on gpu
process.hltEcalDigisGPU = cms.EDProducer(
"EcalRawToDigiGPU",
InputLabel=cms.InputTag("rawDataCollector"),
FEDs=cms.vint32(601, 602, 603, 604, 605, 606, 607, 608, 609, 610, 611,
612, 613, 614, 615, 616, 617, 618, 619, 620, 621, 622,
623, 624, 625, 626, 627, 628, 629, 630, 631, 632, 633,
634, 635, 636, 637, 638, 639, 640, 641, 642, 643, 644,
645, 646, 647, 648, 649, 650, 651, 652, 653, 654),
digisLabelEB=cms.string("ebDigis"),
digisLabelEE=cms.string("eeDigis"),
maxChannelsEB=cms.uint32(61200),
maxChannelsEE=cms.uint32(14648),
)
# SwitchProducer wrapping the legacy ECAL unpacker or the ECAL digi converter from SoA format on gpu to legacy format on cpu
process.hltEcalDigisLegacy = process.hltEcalDigis.clone()
process.hltEcalDigis = SwitchProducerCUDA(
# legacy producer
cpu=cms.EDAlias(hltEcalDigisLegacy=cms.VPSet(
cms.PSet(type=cms.string("EBDigiCollection")),
cms.PSet(type=cms.string("EEDigiCollection")),
cms.PSet(type=cms.string("EBDetIdedmEDCollection")),
cms.PSet(type=cms.string("EEDetIdedmEDCollection")),
cms.PSet(type=cms.string("EBSrFlagsSorted")),
cms.PSet(type=cms.string("EESrFlagsSorted")),
cms.PSet(type=cms.string("EcalElectronicsIdedmEDCollection"),
fromProductInstance=cms.string(
"EcalIntegrityBlockSizeErrors")),
cms.PSet(type=cms.string("EcalElectronicsIdedmEDCollection"),
fromProductInstance=cms.string(
"EcalIntegrityTTIdErrors")))),
# convert ECAL digis from SoA format on gpu to legacy format on cpu
cuda=cms.EDProducer(
"EcalCPUDigisProducer",
digisInLabelEB=cms.InputTag("hltEcalDigisGPU", "ebDigis"),
digisInLabelEE=cms.InputTag("hltEcalDigisGPU", "eeDigis"),
digisOutLabelEB=cms.string("ebDigis"),
digisOutLabelEE=cms.string("eeDigis"),
produceDummyIntegrityCollections=cms.bool(True)))
# ECAL multifit running on gpu
from RecoLocalCalo.EcalRecProducers.ecalUncalibRecHitProducerGPU_cfi import ecalUncalibRecHitProducerGPU as _ecalUncalibRecHitProducerGPU
process.hltEcalUncalibRecHitGPU = _ecalUncalibRecHitProducerGPU.clone(
digisLabelEB=("hltEcalDigisGPU", "ebDigis"),
digisLabelEE=("hltEcalDigisGPU", "eeDigis"),
shouldRunTimingComputation=False)
# copy the ECAL uncalibrated rechits from gpu to cpu in SoA format
process.hltEcalUncalibRecHitSoA = cms.EDProducer(
"EcalCPUUncalibRecHitProducer",
containsTimingInformation=cms.bool(False),
recHitsInLabelEB=cms.InputTag("hltEcalUncalibRecHitGPU",
"EcalUncalibRecHitsEB"),
recHitsInLabelEE=cms.InputTag("hltEcalUncalibRecHitGPU",
"EcalUncalibRecHitsEE"),
recHitsOutLabelEB=cms.string("EcalUncalibRecHitsEB"),
recHitsOutLabelEE=cms.string("EcalUncalibRecHitsEE"))
# SwitchProducer wrapping the legacy ECAL uncalibrated rechits producer or a converter from SoA to legacy format
process.hltEcalUncalibRecHit = SwitchProducerCUDA(
# legacy producer
cpu=process.hltEcalUncalibRecHit,
# convert the ECAL uncalibrated rechits from SoA to legacy format
cuda=cms.EDProducer(
"EcalUncalibRecHitConvertGPU2CPUFormat",
recHitsLabelGPUEB=cms.InputTag("hltEcalUncalibRecHitSoA",
"EcalUncalibRecHitsEB"),
recHitsLabelGPUEE=cms.InputTag("hltEcalUncalibRecHitSoA",
"EcalUncalibRecHitsEE"),
recHitsLabelCPUEB=cms.string("EcalUncalibRecHitsEB"),
recHitsLabelCPUEE=cms.string("EcalUncalibRecHitsEE")))
# Reconstructing the ECAL calibrated rechits on gpu works, but is extremely slow.
# Disable it for the time being, until the performance has been addressed.
"""
process.hltEcalRecHitGPU = cms.EDProducer("EcalRecHitProducerGPU",
uncalibrecHitsInLabelEB = cms.InputTag("hltEcalUncalibRecHitGPU","EcalUncalibRecHitsEB"),
uncalibrecHitsInLabelEE = cms.InputTag("hltEcalUncalibRecHitGPU","EcalUncalibRecHitsEE"),
recHitsLabelEB = cms.string("EcalRecHitsEB"),
recHitsLabelEE = cms.string("EcalRecHitsEE"),
maxNumberHitsEB = cms.uint32(61200),
maxNumberHitsEE = cms.uint32(14648),
ChannelStatusToBeExcluded = cms.vstring(
"kDAC",
"kNoisy",
"kNNoisy",
"kFixedG6",
"kFixedG1",
"kFixedG0",
"kNonRespondingIsolated",
"kDeadVFE",
"kDeadFE",
"kNoDataNoTP"),
killDeadChannels = cms.bool(True),
EBLaserMIN = cms.double(0.01),
EELaserMIN = cms.double(0.01),
EBLaserMAX = cms.double(30.0),
EELaserMAX = cms.double(30.0),
flagsMapDBReco = cms.PSet(
kGood = cms.vstring("kOk","kDAC","kNoLaser","kNoisy"),
kNoisy = cms.vstring("kNNoisy","kFixedG6","kFixedG1"),
kNeighboursRecovered = cms.vstring("kFixedG0", "kNonRespondingIsolated", "kDeadVFE"),
kTowerRecovered = cms.vstring("kDeadFE"),
kDead = cms.vstring("kNoDataNoTP")
),
recoverEBIsolatedChannels = cms.bool(False),
recoverEEIsolatedChannels = cms.bool(False),
recoverEBVFE = cms.bool(False),
recoverEEVFE = cms.bool(False),
recoverEBFE = cms.bool(True),
recoverEEFE = cms.bool(True),
)
process.hltEcalRecHitSoA = cms.EDProducer("EcalCPURecHitProducer",
recHitsInLabelEB = cms.InputTag("hltEcalRecHitGPU", "EcalRecHitsEB"),
recHitsInLabelEE = cms.InputTag("hltEcalRecHitGPU", "EcalRecHitsEE"),
recHitsOutLabelEB = cms.string("EcalRecHitsEB"),
recHitsOutLabelEE = cms.string("EcalRecHitsEE"),
containsTimingInformation = cms.bool(False),
)
# SwitchProducer wrapping the legacy ECAL calibrated rechits producer or a converter from SoA to legacy format
process.hltEcalRecHit = SwitchProducerCUDA(
# legacy producer
cpu = process.hltEcalRecHit,
# convert the ECAL calibrated rechits from SoA to legacy format
cuda = cms.EDProducer("EcalRecHitConvertGPU2CPUFormat",
recHitsLabelGPUEB = cms.InputTag("hltEcalRecHitSoA", "EcalRecHitsEB"),
recHitsLabelGPUEE = cms.InputTag("hltEcalRecHitSoA", "EcalRecHitsEE"),
recHitsLabelCPUEB = cms.string("EcalRecHitsEB"),
recHitsLabelCPUEE = cms.string("EcalRecHitsEE"),
)
"""
# SwitchProducer wrapping the legacy ECAL rechits producer
# the gpu unpacker does not produce the TPs used for the recovery, so the SwitchProducer alias does not provide them:
# - the cpu uncalibrated rechit producer may mark them for recovery, read the TPs explicitly from the legacy unpacker
# - the gpu uncalibrated rechit producer does not flag them for recovery, so the TPs are not necessary
process.hltEcalRecHit = SwitchProducerCUDA(
cpu=process.hltEcalRecHit.clone(
triggerPrimitiveDigiCollection=cms.InputTag(
'hltEcalDigisLegacy', 'EcalTriggerPrimitives')),
cuda=process.hltEcalRecHit.clone(
triggerPrimitiveDigiCollection=cms.InputTag('unused')))
# Tasks and Sequences
process.HLTDoFullUnpackingEgammaEcalWithoutPreshowerTask = cms.Task(
process.hltEcalDigisGPU, # unpack ECAL digis on gpu
process.
hltEcalDigisLegacy, # legacy producer, referenced in the SwitchProducer
process.hltEcalDigis, # SwitchProducer
process.
hltEcalUncalibRecHitGPU, # run ECAL local reconstruction and multifit on gpu
process.
hltEcalUncalibRecHitSoA, # needed by hltEcalPhiSymFilter - copy to host
process.
hltEcalUncalibRecHit, # needed by hltEcalPhiSymFilter - convert to legacy format
# process.hltEcalRecHitGPU, # make ECAL calibrated rechits on gpu
# process.hltEcalRecHitSoA, # copy to host
process.hltEcalDetIdToBeRecovered, # legacy producer
process.hltEcalRecHit) # legacy producer
process.HLTDoFullUnpackingEgammaEcalWithoutPreshowerSequence = cms.Sequence(
process.HLTDoFullUnpackingEgammaEcalWithoutPreshowerTask)
process.HLTPreshowerTask = cms.Task(
process.
hltEcalPreshowerDigis, # unpack ECAL preshower digis on the host
process.hltEcalPreshowerRecHit
) # build ECAL preshower rechits on the host
process.HLTPreshowerSequence = cms.Sequence(process.HLTPreshowerTask)
process.HLTDoFullUnpackingEgammaEcalTask = cms.Task(
process.HLTDoFullUnpackingEgammaEcalWithoutPreshowerTask,
process.HLTPreshowerTask)
process.HLTDoFullUnpackingEgammaEcalSequence = cms.Sequence(
process.HLTDoFullUnpackingEgammaEcalTask)
process.HLTDoFullUnpackingEgammaEcalMFSequence = cms.Sequence(
process.HLTDoFullUnpackingEgammaEcalTask)
# done
return process
from RecoLocalTracker.SiPixelRecHits.siPixelRecHitSoAFromLegacy_cfi import siPixelRecHitSoAFromLegacy as _siPixelRecHitsPreSplittingSoA
from RecoLocalTracker.SiPixelRecHits.siPixelRecHitSoAFromCUDA_cfi import siPixelRecHitSoAFromCUDA as _siPixelRecHitSoAFromCUDA
siPixelRecHitsPreSplittingCPU = _siPixelRecHitsPreSplittingSoA.clone(
convertToLegacy=True)
# phase 2 tracker modifier
from Configuration.Eras.Modifier_phase2_tracker_cff import phase2_tracker
phase2_tracker.toModify(siPixelRecHitsPreSplittingCPU, isPhase2=True)
# modifier used to prompt patatrack pixel tracks reconstruction on cpu
from Configuration.ProcessModifiers.pixelNtupletFit_cff import pixelNtupletFit
pixelNtupletFit.toModify(
siPixelRecHitsPreSplitting,
cpu=cms.EDAlias(siPixelRecHitsPreSplittingCPU=cms.VPSet(
cms.PSet(type=cms.string("SiPixelRecHitedmNewDetSetVector")),
cms.PSet(type=cms.string("uintAsHostProduct")))))
siPixelRecHitsPreSplittingTask = cms.Task(
# SwitchProducer wrapping the legacy pixel rechit producer or the cpu SoA producer
siPixelRecHitsPreSplitting)
# reconstruct the pixel rechits on the gpu
from RecoLocalTracker.SiPixelRecHits.siPixelRecHitCUDA_cfi import siPixelRecHitCUDA as _siPixelRecHitCUDA
siPixelRecHitsPreSplittingCUDA = _siPixelRecHitCUDA.clone(
beamSpot="offlineBeamSpotToCUDA")
# transfer the pixel rechits to the host and convert them from SoA
from RecoLocalTracker.SiPixelRecHits.siPixelRecHitFromCUDA_cfi import siPixelRecHitFromCUDA as _siPixelRecHitFromCUDA
#this is an alias for the SoA on GPU or CPU to be used for DQM
def customisePixelLocalReconstruction(process):
if not 'HLTDoLocalPixelSequence' in process.__dict__:
return process
# FIXME replace the Sequences with empty ones to avoid exanding them during the (re)definition of Modules and EDAliases
process.HLTDoLocalPixelSequence = cms.Sequence()
# Event Setup
process.load(
"CalibTracker.SiPixelESProducers.siPixelGainCalibrationForHLTGPU_cfi"
) # this should be used only on GPUs, will crash otherwise
process.load(
"CalibTracker.SiPixelESProducers.siPixelROCsStatusAndMappingWrapperESProducer_cfi"
) # this should be used only on GPUs, will crash otherwise
process.load("RecoLocalTracker.SiPixelRecHits.PixelCPEFastESProducer_cfi")
# Modules and EDAliases
# referenced in HLTDoLocalPixelTask
# transfer the beamspot to the gpu
from RecoVertex.BeamSpotProducer.offlineBeamSpotToCUDA_cfi import offlineBeamSpotToCUDA as _offlineBeamSpotToCUDA
process.hltOnlineBeamSpotToCUDA = _offlineBeamSpotToCUDA.clone(
src="hltOnlineBeamSpot")
# reconstruct the pixel digis and clusters on the gpu
from RecoLocalTracker.SiPixelClusterizer.siPixelRawToClusterCUDA_cfi import siPixelRawToClusterCUDA as _siPixelRawToClusterCUDA
process.hltSiPixelClustersCUDA = _siPixelRawToClusterCUDA.clone()
# use the pixel channel calibrations scheme for Run 3
run3_common.toModify(process.hltSiPixelClustersCUDA, isRun2=False)
# copy the pixel digis errors to the host
from EventFilter.SiPixelRawToDigi.siPixelDigiErrorsSoAFromCUDA_cfi import siPixelDigiErrorsSoAFromCUDA as _siPixelDigiErrorsSoAFromCUDA
process.hltSiPixelDigiErrorsSoA = _siPixelDigiErrorsSoAFromCUDA.clone(
src="hltSiPixelClustersCUDA")
# convert the pixel digis errors to the legacy format
from EventFilter.SiPixelRawToDigi.siPixelDigiErrorsFromSoA_cfi import siPixelDigiErrorsFromSoA as _siPixelDigiErrorsFromSoA
process.hltSiPixelDigiErrors = _siPixelDigiErrorsFromSoA.clone(
digiErrorSoASrc="hltSiPixelDigiErrorsSoA", UsePhase1=True)
# copy the pixel digis (except errors) and clusters to the host
from EventFilter.SiPixelRawToDigi.siPixelDigisSoAFromCUDA_cfi import siPixelDigisSoAFromCUDA as _siPixelDigisSoAFromCUDA
process.hltSiPixelDigisSoA = _siPixelDigisSoAFromCUDA.clone(
src="hltSiPixelClustersCUDA")
# convert the pixel digis (except errors) and clusters to the legacy format
from RecoLocalTracker.SiPixelClusterizer.siPixelDigisClustersFromSoA_cfi import siPixelDigisClustersFromSoA as _siPixelDigisClustersFromSoA
process.hltSiPixelDigisClusters = _siPixelDigisClustersFromSoA.clone(
src="hltSiPixelDigisSoA")
# SwitchProducer wrapping the legacy pixel digis producer or an alias combining the pixel digis information converted from SoA
process.hltSiPixelDigis = SwitchProducerCUDA(
# legacy producer
cpu=process.hltSiPixelDigis,
# alias used to access products from multiple conversion modules
cuda=cms.EDAlias(
hltSiPixelDigisClusters=cms.VPSet(
cms.PSet(type=cms.string("PixelDigiedmDetSetVector"))),
hltSiPixelDigiErrors=cms.VPSet(
cms.PSet(type=cms.string("DetIdedmEDCollection")),
cms.PSet(
type=cms.string("SiPixelRawDataErroredmDetSetVector")),
cms.PSet(
type=cms.string("PixelFEDChanneledmNewDetSetVector")))))
# SwitchProducer wrapping the legacy pixel cluster producer or an alias for the pixel clusters information converted from SoA
process.hltSiPixelClusters = SwitchProducerCUDA(
# legacy producer
cpu=process.hltSiPixelClusters,
# alias used to access products from multiple conversion modules
cuda=cms.EDAlias(hltSiPixelDigisClusters=cms.VPSet(
cms.PSet(type=cms.string("SiPixelClusteredmNewDetSetVector")))))
# reconstruct the pixel rechits on the gpu
from RecoLocalTracker.SiPixelRecHits.siPixelRecHitCUDA_cfi import siPixelRecHitCUDA as _siPixelRecHitCUDA
process.hltSiPixelRecHitsCUDA = _siPixelRecHitCUDA.clone(
src="hltSiPixelClustersCUDA", beamSpot="hltOnlineBeamSpotToCUDA")
# SwitchProducer wrapping the legacy pixel rechit producer or the transfer of the pixel rechits to the host and the conversion from SoA
from RecoLocalTracker.SiPixelRecHits.siPixelRecHitFromCUDA_cfi import siPixelRecHitFromCUDA as _siPixelRecHitFromCUDA
process.hltSiPixelRecHits = SwitchProducerCUDA(
# legacy producer
cpu=process.hltSiPixelRecHits,
# converter to legacy format
cuda=_siPixelRecHitFromCUDA.clone(
pixelRecHitSrc="hltSiPixelRecHitsCUDA", src="hltSiPixelClusters"))
# Tasks and Sequences
process.HLTDoLocalPixelTask = cms.Task(
process.hltOnlineBeamSpotToCUDA, # transfer the beamspot to the gpu
process.
hltSiPixelClustersCUDA, # reconstruct the pixel digis and clusters on the gpu
process.
hltSiPixelRecHitsCUDA, # reconstruct the pixel rechits on the gpu
process.
hltSiPixelDigisSoA, # copy the pixel digis (except errors) and clusters to the host
process.
hltSiPixelDigisClusters, # convert the pixel digis (except errors) and clusters to the legacy format
process.
hltSiPixelDigiErrorsSoA, # copy the pixel digis errors to the host
process.
hltSiPixelDigiErrors, # convert the pixel digis errors to the legacy format
process.
hltSiPixelDigis, # SwitchProducer wrapping the legacy pixel digis producer or an alias combining the pixel digis information converted from SoA
process.
hltSiPixelClusters, # SwitchProducer wrapping the legacy pixel cluster producer or an alias for the pixel clusters information converted from SoA
process.
hltSiPixelClustersCache, # legacy module, used by the legacy pixel quadruplet producer
process.hltSiPixelRecHits
) # SwitchProducer wrapping the legacy pixel rechit producer or the transfer of the pixel rechits to the host and the conversion from SoA
process.HLTDoLocalPixelSequence = cms.Sequence(process.HLTDoLocalPixelTask)
# done
return process
process.source = cms.Source("EmptySource",
firstLuminosityBlock = cms.untracked.uint32(6),
numberEventsInLuminosityBlock = cms.untracked.uint32(3),
firstRun = cms.untracked.uint32(561),
numberEventsInRun = cms.untracked.uint32(7)
)
process.OtherThing = cms.EDProducer("OtherThingProducer",
thingTag = cms.InputTag("AltThing"))
process.AltThing = cms.EDAlias(
Thing = cms.VPSet(
cms.PSet(type = cms.string('edmtestThings'),
fromProductInstance = cms.string('*'),
toProductInstance = cms.string('*'))
)
)
process.output = cms.OutputModule("PoolOutputModule",
outputCommands = cms.untracked.vstring("keep *", "drop *_Thing_*_TESTPROD"),
fileName = cms.untracked.string('step1.root')
)
process.p = cms.Path(process.Thing*process.OtherThing)
process.ep = cms.EndPath(process.output)
analysisProcess = cms.Process("TESTANALYSIS")
process.thinningThingProducerL = cms.EDProducer(
"ThinningThingProducer",
inputTag=cms.InputTag('thinningThingProducerJ'),
trackTag=cms.InputTag('trackOfThingsProducerL'),
offsetToThinnedKey=cms.uint32(30),
expectedCollectionSize=cms.uint32(9))
process.thinningThingProducerM = cms.EDProducer(
"ThinningThingProducer",
inputTag=cms.InputTag('thingProducer'),
trackTag=cms.InputTag('trackOfThingsProducerM'),
offsetToThinnedKey=cms.uint32(0),
expectedCollectionSize=cms.uint32(50))
process.aliasM = cms.EDAlias(thinningThingProducerM=cms.VPSet(
cms.PSet(type=cms.string('edmtestThings')),
# the next one should get ignored
cms.PSet(type=cms.string('edmThinnedAssociation'))))
process.thinningThingProducerN = cms.EDProducer(
"ThinningThingProducer",
inputTag=cms.InputTag('thinningThingProducerM'),
trackTag=cms.InputTag('trackOfThingsProducerN'),
offsetToThinnedKey=cms.uint32(40),
expectedCollectionSize=cms.uint32(9))
process.aliasN = cms.EDAlias(thinningThingProducerN=cms.VPSet(
cms.PSet(type=cms.string('edmtestThings')),
# the next one should get ignored
cms.PSet(type=cms.string('edmThinnedAssociation'))))
process.thinningThingProducerO = cms.EDProducer(
import FWCore.ParameterSet.Config as cms
simCastorDigis = cms.EDAlias(
mix=cms.VPSet(cms.PSet(type=cms.string('CastorDataFramesSorted'))))
simEcalUnsuppressedDigis = cms.EDAlias()
# mix = cms.VPSet(
# cms.PSet(type = cms.string('EBDigiCollection')),
# cms.PSet(type = cms.string('EEDigiCollection')),
# cms.PSet(type = cms.string('ESDigiCollection'))
# )
#)
simHcalUnsuppressedDigis = cms.EDAlias()
# mix = cms.VPSet(
# cms.PSet(type = cms.string('HBHEDataFramesSorted')),
# cms.PSet(type = cms.string('HFDataFramesSorted')),
# cms.PSet(type = cms.string('HODataFramesSorted')),
# cms.PSet(type = cms.string('ZDCDataFramesSorted'))
# )
#)
simHGCalUnsuppressedDigis = cms.EDAlias()
simHFNoseUnsuppressedDigis = cms.EDAlias()
_pixelCommon = cms.VPSet(
cms.PSet(type=cms.string('PixelDigiedmDetSetVector')),
cms.PSet(type=cms.string('PixelDigiSimLinkedmDetSetVector')))
simSiPixelDigis = cms.EDAlias(
mix=_pixelCommon +
[cms.PSet(type=cms.string('PixelFEDChanneledmNewDetSetVector'))])
simSiStripDigis = cms.EDAlias(
mix=cms.VPSet(cms.PSet(type=cms.string('SiStripDigiedmDetSetVector')),
cms.PSet(type=cms.string('SiStripRawDigiedmDetSetVector')),
cms.PSet(
mixSH = cms.PSet(
crossingFrames = cms.untracked.vstring('MuonGEMHits'),
input = cms.VInputTag(cms.InputTag("g4SimHits","MuonGEMHits")),
type = cms.string('PSimHit'),
subdets = cms.vstring('MuonGEMHits'),
)
),
mixTracks = cms.PSet(
input = cms.VInputTag(cms.InputTag("g4SimHits")),
makeCrossingFrame = cms.untracked.bool(True),
type = cms.string('SimTrack')
),
)
process.g4SimHits.UseMagneticField = cms.bool(False)
process.simCastorDigis = cms.EDAlias()
process.simEcalUnsuppressedDigis = cms.EDAlias()
process.simHcalUnsuppressedDigis = cms.EDAlias()
process.simSiPixelDigis = cms.EDAlias()
process.simSiStripDigis = cms.EDAlias()
process.load('RecoMuon.TrackingTools.MuonServiceProxy_cff')
process.MuonServiceProxy.ServiceParameters.Propagators.append('StraightLinePropagator')
process.GEMCosmicMuonForQC8 = cms.EDProducer("GEMCosmicMuonForQC8",
process.MuonServiceProxy,
gemRecHitLabel = cms.InputTag("gemRecHits"),
maxClusterSize = cms.double(runConfig.maxClusterSize),
minClusterSize = cms.double(runConfig.minClusterSize),
trackChi2 = cms.double(runConfig.trackChi2),
trackResX = cms.double(runConfig.trackResX),
import FWCore.ParameterSet.Config as cms
simEcalUnsuppressedDigis = cms.EDAlias(
mixSimCaloHits=cms.VPSet(cms.PSet(type=cms.string('EBDigiCollection')),
cms.PSet(type=cms.string('EEDigiCollection')),
cms.PSet(type=cms.string('ESDigiCollection'))))
simHcalUnsuppressedDigis = cms.EDAlias(
mixSimCaloHits=cms.VPSet(cms.PSet(type=cms.string('HBHEDataFramesSorted')),
cms.PSet(type=cms.string('HFDataFramesSorted')),
cms.PSet(type=cms.string('HODataFramesSorted')),
cms.PSet(type=cms.string('ZDCDataFramesSorted'))))
g4SimHits = cms.EDAlias(
famosSimHits=cms.VPSet(cms.PSet(type=cms.string('PCaloHits'))),
MuonSimHits=cms.VPSet(cms.PSet(type=cms.string('PSimHits'))),
g4SimHits=cms.VPSet(
cms.PSet(type=cms.string('PCaloHits'),
fromProductInstance=cms.string(''),
toProductInstance=cms.string('refined'))))
from SimGeneral.MixingModule.ecalDigitizer_cfi import *
from SimCalorimetry.EcalSimProducers.ecalDigiParameters_cff import *
#simEcalUnsuppressedDigis.hitsProducer = cms.string('g4SimHits')
#ecal_digi_parameters.hitsProducer = cms.string('g4SimHits')
#ecalDigitizer.hitsProducer = cms.string('g4SimHits')
import SimCalorimetry.HcalSimProducers.hcalUnsuppressedDigis_cfi
hcalSimBlockFastSim = SimCalorimetry.HcalSimProducers.hcalUnsuppressedDigis_cfi.hcalSimBlock.clone(
)
#hcalSimBlockFastSim.hitsProducer = cms.string('g4SimHits')
hcalDigitizer = cms.PSet(hcalSimBlockFastSim,
inputTags=cms.untracked.VInputTag(
cms.InputTag("intProducerA")),
expectedSum=cms.untracked.int32(300))
process.a3 = cms.EDAnalyzer("TestFindProduct",
inputTags=cms.untracked.VInputTag(
cms.InputTag("aliasForInt")),
expectedSum=cms.untracked.int32(300))
process.intProducer = cms.EDProducer("IntProducer", ivalue=cms.int32(1))
process.intProducerU = cms.EDProducer("IntProducer", ivalue=cms.int32(10))
process.intProducerA = cms.EDProducer("IntProducer", ivalue=cms.int32(100))
process.aliasForInt = cms.EDAlias(
intProducerA=cms.VPSet(cms.PSet(type=cms.string('edmtestIntProduct'))))
process.intVectorProducer = cms.EDProducer("IntVectorProducer",
count=cms.int32(9),
ivalue=cms.int32(11))
process.p = cms.Path(process.intProducer * process.a1 * process.a2 *
process.a3)
process.e = cms.EndPath(process.out)
copyProcess = cms.Process("COPY")
process.subProcess = cms.SubProcess(copyProcess,
outputCommands=cms.untracked.vstring(
"keep *", "drop *_intProducerA_*_*"))
import FWCore.ParameterSet.Config as cms
simCastorDigis = cms.EDAlias(
mix=cms.VPSet(cms.PSet(type=cms.string('CastorDataFramesSorted'))))
simEcalUnsuppressedDigis = cms.EDAlias(
mix=cms.VPSet(cms.PSet(type=cms.string('EBDigiCollection')),
cms.PSet(type=cms.string('EEDigiCollection')),
cms.PSet(type=cms.string('ESDigiCollection'))))
simHcalUnsuppressedDigis = cms.EDAlias(mix=cms.VPSet(
cms.PSet(type=cms.string('HBHEDataFramesSorted')),
cms.PSet(type=cms.string('HcalUpgradeDataFramesSorted')),
cms.PSet(type=cms.string('HFDataFramesSorted')),
cms.PSet(type=cms.string('HODataFramesSorted')),
cms.PSet(type=cms.string('ZDCDataFramesSorted')),
cms.PSet(type=cms.string('QIE10DataFrameHcalDataFrameContainer'))))
simSiPixelDigis = cms.EDAlias(
mix=cms.VPSet(cms.PSet(type=cms.string('PixelDigiedmDetSetVector')),
cms.PSet(
type=cms.string('PixelDigiSimLinkedmDetSetVector'))))
simSiStripDigis = cms.EDAlias(
mix=cms.VPSet(cms.PSet(type=cms.string('SiStripDigiedmDetSetVector')),
cms.PSet(type=cms.string('SiStripRawDigiedmDetSetVector')),
cms.PSet(
type=cms.string('StripDigiSimLinkedmDetSetVector'))))
# no castor,pixel,strip digis in fastsim
from Configuration.StandardSequences.Eras import eras
if eras.fastSim.isChosen():
del simCastorDigis
del simSiPixelDigis
del simSiStripDigis
