import FWCore.ParameterSet.Config as cms
from DQM.SiPixelPhase1Heterogeneous.siPixelPhase1MonitorTrackSoA_cfi import *
from DQM.SiPixelPhase1Heterogeneous.siPixelPhase1MonitorVertexSoA_cfi import *
from DQM.SiPixelPhase1Heterogeneous.siPixelPhase1MonitorRecHitsSoA_cfi import *

from Configuration.ProcessModifiers.gpu_cff import gpu

gpu.toModify(siPixelPhase1MonitorRecHitsSoA,
             pixelHitsSrc="siPixelRecHitsPreSplittingSoA")

monitorpixelSoASource = cms.Sequence(siPixelPhase1MonitorRecHitsSoA *
                                     siPixelPhase1MonitorTrackSoA *
                                     siPixelPhase1MonitorVertexSoA)
Esempio n. 2
0
ecalUncalibRecHitPhase2GPU = _ecalUncalibRecHitPhase2GPU.clone(
    digisLabelEB=('ecalPhase2DigiToGPUProducer', 'ebDigis'))

# copy the uncalibrated rechits from GPU to CPU
from RecoLocalCalo.EcalRecProducers.ecalCPUUncalibRecHitProducer_cfi import ecalCPUUncalibRecHitProducer as _ecalCPUUncalibRecHitProducer
ecalUncalibRecHitSoA = _ecalCPUUncalibRecHitProducer.clone(
    recHitsInLabelEB=('ecalUncalibRecHitPhase2GPU', 'EcalUncalibRecHitsEB'),
    isPhase2=True,
    recHitsInLabelEE=None,  # remove unneeded Phase1 parameters
    recHitsOutLabelEE=None)

from RecoLocalCalo.EcalRecProducers.ecalUncalibRecHitConvertGPU2CPUFormat_cfi import ecalUncalibRecHitConvertGPU2CPUFormat as _ecalUncalibRecHitConvertGPU2CPUFormat
gpu.toModify(
    ecalUncalibRecHitPhase2,
    cuda=_ecalUncalibRecHitConvertGPU2CPUFormat.clone(
        isPhase2=cms.bool(True),
        recHitsLabelGPUEB=cms.InputTag('ecalUncalibRecHitSoA',
                                       'EcalUncalibRecHitsEB'),
        recHitsLabelGPUEE=None,  # remove unneeded Phase1 parameters
        recHitsLabelCPUEE=None))

gpu.toReplaceWith(
    ecalUncalibRecHitPhase2Task,
    cms.Task(
        # convert phase2 digis to GPU SoA
        ecalPhase2DigiToGPUProducer,
        # ECAL weights running on GPU
        ecalUncalibRecHitPhase2GPU,
        # copy the uncalibrated rechits from GPU to CPU
        ecalUncalibRecHitSoA,
        # ECAL multifit running on CPU, or convert the uncalibrated rechits from SoA to legacy format
        ecalUncalibRecHitPhase2,
Esempio n. 3
0
ecalDigisTask = cms.Task(
    # ECAL unpacker running on CPU
    ecalDigis)

# process modifier to run on GPUs
from Configuration.ProcessModifiers.gpu_cff import gpu

# ECAL conditions used by the unpacker running on GPU
from EventFilter.EcalRawToDigi.ecalElectronicsMappingGPUESProducer_cfi import ecalElectronicsMappingGPUESProducer

# ECAL unpacker running on GPU
from EventFilter.EcalRawToDigi.ecalRawToDigiGPU_cfi import ecalRawToDigiGPU as _ecalRawToDigiGPU
ecalDigisGPU = _ecalRawToDigiGPU.clone()

# disable the ECAL unpacker collections that are not available in the GPU unpacker
gpu.toModify(ecalDigis.cpu, headerUnpacking=False, memUnpacking=False)

# extend the SwitchProducer to add a case to copy the ECAL digis from GPU to CPU and covert them from SoA to legacy format
from EventFilter.EcalRawToDigi.ecalCPUDigisProducer_cfi import ecalCPUDigisProducer as _ecalCPUDigisProducer
gpu.toModify(
    ecalDigis,
    # copy the ECAL digis from GPU to CPU and covert them from SoA to legacy format
    cuda=_ecalCPUDigisProducer.clone(digisInLabelEB=('ecalDigisGPU',
                                                     'ebDigis'),
                                     digisInLabelEE=('ecalDigisGPU',
                                                     'eeDigis'),
                                     produceDummyIntegrityCollections=True))

gpu.toReplaceWith(
    ecalDigisTask,
    cms.Task(
Esempio n. 4
0
    src = 'siPixelClustersPreSplitting'
)

from HeterogeneousCore.CUDACore.SwitchProducerCUDA import SwitchProducerCUDA
siPixelRecHitsPreSplitting = SwitchProducerCUDA(
    cpu = _siPixelRecHitsPreSplitting.clone()
)



from Configuration.ProcessModifiers.gpu_cff import gpu
from RecoLocalTracker.SiPixelRecHits.siPixelRecHitCUDA_cfi import siPixelRecHitCUDA as _siPixelRecHitCUDA
from RecoLocalTracker.SiPixelRecHits.siPixelRecHitFromSOA_cfi import siPixelRecHitFromSOA as _siPixelRecHitFromSOA

gpu.toModify(siPixelRecHitsPreSplitting, 
    cuda = _siPixelRecHitFromSOA.clone()
)


siPixelRecHitsPreSplittingTask = cms.Task(siPixelRecHitsPreSplitting)

siPixelRecHitsCUDAPreSplitting = _siPixelRecHitCUDA.clone(
    beamSpot = "offlineBeamSpotToCUDA"
)

siPixelRecHitsLegacyPreSplitting = _siPixelRecHitFromSOA.clone()
siPixelRecHitsPreSplittingTaskCUDA = cms.Task(
    siPixelRecHitsCUDAPreSplitting,
    siPixelRecHitsLegacyPreSplitting,
)
Esempio n. 5
0
        # build the pixel vertices in SoA format on the CPU
        pixelVerticesSoA,
        # convert the pixel vertices from SoA to legacy format
        pixelVertices))

# "Patatrack" sequence running on the GPU
from Configuration.ProcessModifiers.gpu_cff import gpu

# build pixel vertices in SoA format on the GPU
pixelVerticesCUDA = _pixelVerticesCUDA.clone(pixelTrackSrc="pixelTracksCUDA",
                                             onGPU=True)

# transfer the pixel vertices in SoA format to the CPU
from RecoPixelVertexing.PixelVertexFinding.pixelVerticesSoA_cfi import pixelVerticesSoA as _pixelVerticesSoA
gpu.toModify(
    pixelVerticesSoA,
    cuda=_pixelVerticesSoA.clone(src=cms.InputTag("pixelVerticesCUDA")))

## GPU vs CPU validation
# force CPU vertexing to use track SoA from CPU chain and not the converted one from GPU chain
from Configuration.ProcessModifiers.gpuValidationPixel_cff import gpuValidationPixel
(pixelNtupletFit & gpu & gpuValidationPixel).toModify(
    pixelVerticesSoA.cpu, pixelTrackSrc="pixelTracksSoA@cpu")

(pixelNtupletFit & gpu).toReplaceWith(
    pixelVerticesTask,
    cms.Task(
        # build pixel vertices in SoA format on the GPU
        pixelVerticesCUDA,
        # transfer the pixel vertices in SoA format to the CPU and convert them to legacy format
        pixelVerticesTask.copy()))
Esempio n. 6
0
import FWCore.ParameterSet.Config as cms
from HeterogeneousCore.CUDACore.SwitchProducerCUDA import SwitchProducerCUDA

# SiPixelGainCalibrationServiceParameters
from CondTools.SiPixel.SiPixelGainCalibrationService_cfi import *

# legacy pixel cluster producer
from RecoLocalTracker.SiPixelClusterizer.SiPixelClusterizer_cfi import siPixelClusters as _siPixelClusters
siPixelClustersPreSplitting = SwitchProducerCUDA(cpu=_siPixelClusters.clone())

from Configuration.ProcessModifiers.gpu_cff import gpu
# SwitchProducer wrapping the legacy pixel cluster producer or an alias for the pixel clusters information converted from SoA
gpu.toModify(
    siPixelClustersPreSplitting,
    # ensure the same results when running on GPU (which supports only the 'HLT' payload) and CPU
    cpu=dict(payloadType='HLT'),
    cuda=cms.EDAlias(siPixelDigisClustersPreSplitting=cms.VPSet(
        cms.PSet(type=cms.string("SiPixelClusteredmNewDetSetVector")))))

from Configuration.ProcessModifiers.siPixelDigiMorphing_cff import siPixelDigiMorphing
siPixelDigiMorphing.toModify(siPixelClustersPreSplitting,
                             cpu=dict(src='siPixelDigisMorphed'))
Esempio n. 7
0
        # build the pixel ntuplets and the pixel tracks in SoA format on the GPU
        pixelTracksSoA,
        # convert the pixel tracks from SoA to legacy format
        pixelTracks))

# "Patatrack" sequence running on GPU
from Configuration.ProcessModifiers.gpu_cff import gpu

# build the pixel ntuplets and pixel tracks in SoA format on the GPU
pixelTracksCUDA = _pixelTracksCUDA.clone(
    pixelRecHitSrc="siPixelRecHitsPreSplittingCUDA",
    idealConditions=False,
    onGPU=True)
# use quality cuts tuned for Run 2 ideal conditions for all Run 3 workflows
run3_common.toModify(pixelTracksCUDA, idealConditions=True)

# SwitchProducer providing the pixel tracks in SoA format on the CPU
from RecoPixelVertexing.PixelTrackFitting.pixelTracksSoA_cfi import pixelTracksSoA as _pixelTracksSoA
gpu.toModify(
    pixelTracksSoA,
    # transfer the pixel tracks in SoA format to the host
    cuda=_pixelTracksSoA.clone())

(pixelNtupletFit & gpu).toReplaceWith(
    pixelTracksTask,
    cms.Task(
        # build the pixel ntuplets and pixel tracks in SoA format on the GPU
        pixelTracksCUDA,
        # transfer the pixel tracks in SoA format to the CPU, and convert them to legacy format
        pixelTracksTask.copy()))
Esempio n. 8
0
import FWCore.ParameterSet.Config as cms

from CondTools.SiPixel.SiPixelGainCalibrationService_cfi import *
from RecoLocalTracker.SiPixelClusterizer.SiPixelClusterizer_cfi import siPixelClusters as _siPixelClusters
from HeterogeneousCore.CUDACore.SwitchProducerCUDA import SwitchProducerCUDA
siPixelClustersPreSplitting = SwitchProducerCUDA(cpu=_siPixelClusters.clone())

from Configuration.ProcessModifiers.gpu_cff import gpu
gpu.toModify(
    siPixelClustersPreSplitting,
    cuda=cms.EDAlias(siPixelDigisClustersPreSplitting=cms.VPSet(
        cms.PSet(type=cms.string("SiPixelClusteredmNewDetSetVector")))))
Esempio n. 9
0
import FWCore.ParameterSet.Config as cms
from EventFilter.SiPixelRawToDigi.siPixelRawToDigi_cfi import siPixelRawToDigi as _siPixelRawToDigi

from HeterogeneousCore.CUDACore.SwitchProducerCUDA import SwitchProducerCUDA
siPixelDigis = SwitchProducerCUDA(cpu=_siPixelRawToDigi.clone())

from Configuration.Eras.Modifier_phase1Pixel_cff import phase1Pixel
phase1Pixel.toModify(siPixelDigis.cpu, UsePhase1=True)

from Configuration.ProcessModifiers.gpu_cff import gpu
gpu.toModify(
    siPixelDigis,
    cuda=cms.EDAlias(
        siPixelDigiErrors=cms.VPSet(
            cms.PSet(type=cms.string("DetIdedmEDCollection")),
            cms.PSet(type=cms.string("SiPixelRawDataErroredmDetSetVector")),
            cms.PSet(type=cms.string("PixelFEDChanneledmNewDetSetVector"))),
        siPixelDigisClustersPreSplitting=cms.VPSet(
            cms.PSet(type=cms.string("PixelDigiedmDetSetVector")))))
Esempio n. 10
0
  digisLabelEB = cms.InputTag('ecalDigisGPU', 'ebDigis'),
  digisLabelEE = cms.InputTag('ecalDigisGPU', 'eeDigis'),
)

# copy the uncalibrated rechits from GPU to CPU
from RecoLocalCalo.EcalRecProducers.ecalCPUUncalibRecHitProducer_cfi import ecalCPUUncalibRecHitProducer as _ecalCPUUncalibRecHitProducer
ecalMultiFitUncalibRecHitSoA = _ecalCPUUncalibRecHitProducer.clone(
  recHitsInLabelEB = cms.InputTag('ecalMultiFitUncalibRecHitGPU', 'EcalUncalibRecHitsEB'),
  recHitsInLabelEE = cms.InputTag('ecalMultiFitUncalibRecHitGPU', 'EcalUncalibRecHitsEE'),
)

# convert the uncalibrated rechits from SoA to legacy format
from RecoLocalCalo.EcalRecProducers.ecalUncalibRecHitConvertGPU2CPUFormat_cfi import ecalUncalibRecHitConvertGPU2CPUFormat as _ecalUncalibRecHitConvertGPU2CPUFormat
gpu.toModify(ecalMultiFitUncalibRecHit,
  cuda = _ecalUncalibRecHitConvertGPU2CPUFormat.clone(
    recHitsLabelGPUEB = cms.InputTag('ecalMultiFitUncalibRecHitSoA', 'EcalUncalibRecHitsEB'),
    recHitsLabelGPUEE = cms.InputTag('ecalMultiFitUncalibRecHitSoA', 'EcalUncalibRecHitsEE'),
  )
)

gpu.toReplaceWith(ecalMultiFitUncalibRecHitTask, cms.Task(
  # ECAL conditions used by the multifit running on GPU
  ecalPedestalsGPUESProducer,
  ecalGainRatiosGPUESProducer,
  ecalPulseShapesGPUESProducer,
  ecalPulseCovariancesGPUESProducer,
  ecalSamplesCorrelationGPUESProducer,
  ecalTimeBiasCorrectionsGPUESProducer,
  ecalTimeCalibConstantsGPUESProducer,
  ecalMultifitParametersGPUESProducer,
  # ECAL multifit running on GPU
  ecalMultiFitUncalibRecHitGPU,