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