From c26b2fcd7b0f061bc73147b51aad9465d503d282 Mon Sep 17 00:00:00 2001 From: Alejandro Sanchez Date: Tue, 18 Jan 2022 21:20:32 +0100 Subject: [PATCH] Create new GpuTask module to monitor and compare CPU and GPU generated Ecal reco objects --- DQM/EcalMonitorTasks/interface/Collections.h | 26 +- DQM/EcalMonitorTasks/interface/GpuTask.h | 106 +++ .../plugins/EcalDQMonitorTask2.cc | 12 + .../python/CollectionTags_cfi.py | 14 +- .../python/EcalMonitorTask_cff.py | 11 + DQM/EcalMonitorTasks/python/GpuTask_cfi.py | 626 ++++++++++++++++++ DQM/EcalMonitorTasks/src/GpuTask.cc | 455 +++++++++++++ .../python/ecal_dqm_source_offline_cff.py | 2 +- 8 files changed, 1249 insertions(+), 3 deletions(-) create mode 100644 DQM/EcalMonitorTasks/interface/GpuTask.h create mode 100644 DQM/EcalMonitorTasks/python/EcalMonitorTask_cff.py create mode 100644 DQM/EcalMonitorTasks/python/GpuTask_cfi.py create mode 100644 DQM/EcalMonitorTasks/src/GpuTask.cc diff --git a/DQM/EcalMonitorTasks/interface/Collections.h b/DQM/EcalMonitorTasks/interface/Collections.h index d4549389131c4..9d885c37a04cb 100644 --- a/DQM/EcalMonitorTasks/interface/Collections.h +++ b/DQM/EcalMonitorTasks/interface/Collections.h @@ -41,6 +41,18 @@ namespace ecaldqm { kEEBasicCluster, kEBSuperCluster, kEESuperCluster, + kEBCpuDigi, + kEECpuDigi, + kEBGpuDigi, + kEEGpuDigi, + kEBCpuUncalibRecHit, + kEECpuUncalibRecHit, + kEBGpuUncalibRecHit, + kEEGpuUncalibRecHit, + kEBCpuRecHit, + kEECpuRecHit, + kEBGpuRecHit, + kEEGpuRecHit, nCollections }; @@ -78,7 +90,19 @@ namespace ecaldqm { "EBBasicCluster", "EEBasicCluster", "EBSuperCluster", - "EESuperCluster"}; + "EESuperCluster", + "EBCpuDigi", + "EECpuDigi", + "EBGpuDigi", + "EEGpuDigi", + "EBCpuUncalibRecHit", + "EECpuUncalibRecHit", + "EBGpuUncalibRecHit", + "EEGpuUncalibRecHit", + "EBCpuRecHit", + "EECpuRecHit", + "EBGpuRecHit", + "EEGpuRecHit"}; } // namespace ecaldqm diff --git a/DQM/EcalMonitorTasks/interface/GpuTask.h b/DQM/EcalMonitorTasks/interface/GpuTask.h new file mode 100644 index 0000000000000..dc568cf84e622 --- /dev/null +++ b/DQM/EcalMonitorTasks/interface/GpuTask.h @@ -0,0 +1,106 @@ +#ifndef DQM_EcalMonitorTasks_GpuTask_H +#define DQM_EcalMonitorTasks_GpuTask_H + +#include "DQWorkerTask.h" + +#include "DataFormats/EcalRecHit/interface/EcalRecHitCollections.h" +#include "DataFormats/EcalDigi/interface/EcalDigiCollections.h" + +namespace ecaldqm { + + class GpuTask : public DQWorkerTask { + public: + GpuTask(); + ~GpuTask() override {} + + void addDependencies(DependencySet&) override; + + bool filterRunType(short const*) override; + + void beginEvent(edm::Event const&, edm::EventSetup const&, bool const&, bool&) override; + bool analyze(void const*, Collections) override; + + template + void runOnCpuDigis(DigiCollection const&, Collections); + template + void runOnGpuDigis(DigiCollection const&, Collections); + void runOnCpuUncalibRecHits(EcalUncalibratedRecHitCollection const&, Collections); + void runOnGpuUncalibRecHits(EcalUncalibratedRecHitCollection const&, Collections); + void runOnCpuRecHits(EcalRecHitCollection const&, Collections); + void runOnGpuRecHits(EcalRecHitCollection const&, Collections); + + private: + void setParams(edm::ParameterSet const&) override; + + bool runGpuTask_; + bool gpuOnlyPlots_; + std::vector uncalibOOTAmps_; + + // Static cast to EB/EEDigiCollection when using + // Defined as void pointers to make compiler happy + void const* EBCpuDigis_; + void const* EECpuDigis_; + + EcalUncalibratedRecHitCollection const* EBCpuUncalibRecHits_; + EcalUncalibratedRecHitCollection const* EECpuUncalibRecHits_; + + EcalRecHitCollection const* EBCpuRecHits_; + EcalRecHitCollection const* EECpuRecHits_; + }; + + inline bool GpuTask::analyze(void const* _p, Collections _collection) { + switch (_collection) { + case kEBCpuDigi: + if (_p && runGpuTask_) + runOnCpuDigis(*static_cast(_p), _collection); + return runGpuTask_; + break; + case kEECpuDigi: + if (_p && runGpuTask_) + runOnCpuDigis(*static_cast(_p), _collection); + return runGpuTask_; + break; + case kEBGpuDigi: + if (_p && runGpuTask_) + runOnGpuDigis(*static_cast(_p), _collection); + return runGpuTask_; + break; + case kEEGpuDigi: + if (_p && runGpuTask_) + runOnGpuDigis(*static_cast(_p), _collection); + return runGpuTask_; + break; + case kEBCpuUncalibRecHit: + case kEECpuUncalibRecHit: + if (_p && runGpuTask_) + runOnCpuUncalibRecHits(*static_cast(_p), _collection); + return runGpuTask_; + break; + case kEBGpuUncalibRecHit: + case kEEGpuUncalibRecHit: + if (_p && runGpuTask_) + runOnGpuUncalibRecHits(*static_cast(_p), _collection); + return runGpuTask_; + break; + case kEBCpuRecHit: + case kEECpuRecHit: + if (_p && runGpuTask_) + runOnCpuRecHits(*static_cast(_p), _collection); + return runGpuTask_; + break; + case kEBGpuRecHit: + case kEEGpuRecHit: + if (_p && runGpuTask_) + runOnGpuRecHits(*static_cast(_p), _collection); + return runGpuTask_; + break; + default: + break; + } + + return false; + } + +} // namespace ecaldqm + +#endif diff --git a/DQM/EcalMonitorTasks/plugins/EcalDQMonitorTask2.cc b/DQM/EcalMonitorTasks/plugins/EcalDQMonitorTask2.cc index 460df62ae446c..161e060c22efb 100644 --- a/DQM/EcalMonitorTasks/plugins/EcalDQMonitorTask2.cc +++ b/DQM/EcalMonitorTasks/plugins/EcalDQMonitorTask2.cc @@ -90,10 +90,14 @@ void EcalDQMonitorTask::formSchedule(std::vector const& _p sch.first = &EcalDQMonitorTask::runOnCollection; break; case ecaldqm::kEBDigi: + case ecaldqm::kEBCpuDigi: + case ecaldqm::kEBGpuDigi: collectionTokens_[*colItr] = edm::EDGetToken(consumes(tag)); sch.first = &EcalDQMonitorTask::runOnCollection; break; case ecaldqm::kEEDigi: + case ecaldqm::kEECpuDigi: + case ecaldqm::kEEGpuDigi: collectionTokens_[*colItr] = edm::EDGetToken(consumes(tag)); sch.first = &EcalDQMonitorTask::runOnCollection; break; @@ -112,6 +116,10 @@ void EcalDQMonitorTask::formSchedule(std::vector const& _p case ecaldqm::kEELaserLedUncalibRecHit: case ecaldqm::kEBTestPulseUncalibRecHit: case ecaldqm::kEETestPulseUncalibRecHit: + case ecaldqm::kEBCpuUncalibRecHit: + case ecaldqm::kEECpuUncalibRecHit: + case ecaldqm::kEBGpuUncalibRecHit: + case ecaldqm::kEEGpuUncalibRecHit: collectionTokens_[*colItr] = edm::EDGetToken(consumes(tag)); sch.first = &EcalDQMonitorTask::runOnCollection; break; @@ -119,6 +127,10 @@ void EcalDQMonitorTask::formSchedule(std::vector const& _p case ecaldqm::kEBReducedRecHit: case ecaldqm::kEERecHit: case ecaldqm::kEEReducedRecHit: + case ecaldqm::kEBCpuRecHit: + case ecaldqm::kEECpuRecHit: + case ecaldqm::kEBGpuRecHit: + case ecaldqm::kEEGpuRecHit: collectionTokens_[*colItr] = edm::EDGetToken(consumes(tag)); sch.first = &EcalDQMonitorTask::runOnCollection; break; diff --git a/DQM/EcalMonitorTasks/python/CollectionTags_cfi.py b/DQM/EcalMonitorTasks/python/CollectionTags_cfi.py index ffb63bec0415b..d74cc11fae1f8 100644 --- a/DQM/EcalMonitorTasks/python/CollectionTags_cfi.py +++ b/DQM/EcalMonitorTasks/python/CollectionTags_cfi.py @@ -44,5 +44,17 @@ EBBasicCluster = cms.untracked.InputTag("particleFlowClusterECAL"), EEBasicCluster = cms.untracked.InputTag("particleFlowClusterECAL"), EBSuperCluster = cms.untracked.InputTag("particleFlowSuperClusterECAL", "particleFlowSuperClusterECALBarrel"), - EESuperCluster = cms.untracked.InputTag("particleFlowSuperClusterECAL", "particleFlowSuperClusterECALEndcapWithPreshower") + EESuperCluster = cms.untracked.InputTag("particleFlowSuperClusterECAL", "particleFlowSuperClusterECALEndcapWithPreshower"), + EBCpuDigi = cms.untracked.InputTag("ecalDigis@cpu", "ebDigis"), + EECpuDigi = cms.untracked.InputTag("ecalDigis@cpu", "eeDigis"), + EBGpuDigi = cms.untracked.InputTag("ecalDigis@cuda", "ebDigis"), + EEGpuDigi = cms.untracked.InputTag("ecalDigis@cuda", "eeDigis"), + EBCpuUncalibRecHit = cms.untracked.InputTag("ecalMultiFitUncalibRecHit@cpu", "EcalUncalibRecHitsEB"), + EECpuUncalibRecHit = cms.untracked.InputTag("ecalMultiFitUncalibRecHit@cpu", "EcalUncalibRecHitsEE"), + EBGpuUncalibRecHit = cms.untracked.InputTag("ecalMultiFitUncalibRecHit@cuda", "EcalUncalibRecHitsEB"), + EEGpuUncalibRecHit = cms.untracked.InputTag("ecalMultiFitUncalibRecHit@cuda", "EcalUncalibRecHitsEE"), + EBCpuRecHit = cms.untracked.InputTag("ecalRecHit@cpu", "EcalRecHitsEB"), + EECpuRecHit = cms.untracked.InputTag("ecalRecHit@cpu", "EcalRecHitsEE"), + EBGpuRecHit = cms.untracked.InputTag("ecalRecHit@cuda", "EcalRecHitsEB"), + EEGpuRecHit = cms.untracked.InputTag("ecalRecHit@cuda", "EcalRecHitsEE") ) diff --git a/DQM/EcalMonitorTasks/python/EcalMonitorTask_cff.py b/DQM/EcalMonitorTasks/python/EcalMonitorTask_cff.py new file mode 100644 index 0000000000000..4132370c3e677 --- /dev/null +++ b/DQM/EcalMonitorTasks/python/EcalMonitorTask_cff.py @@ -0,0 +1,11 @@ +import FWCore.ParameterSet.Config as cms + +from DQM.EcalMonitorTasks.EcalMonitorTask_cfi import * + +# Customization to run the CPU vs GPU comparison task if the job runs on a GPU enabled machine +from Configuration.ProcessModifiers.gpu_cff import gpu +from DQM.EcalMonitorTasks.GpuTask_cfi import ecalGpuTask + +gpu.toModify(ecalGpuTask.params, runGpuTask = cms.untracked.bool(True)) +gpu.toModify(ecalMonitorTask.workers, func = lambda workers: workers.append("GpuTask")) +gpu.toModify(ecalMonitorTask, workerParameters = dict(GpuTask = ecalGpuTask)) diff --git a/DQM/EcalMonitorTasks/python/GpuTask_cfi.py b/DQM/EcalMonitorTasks/python/GpuTask_cfi.py new file mode 100644 index 0000000000000..9d49ad59ea76a --- /dev/null +++ b/DQM/EcalMonitorTasks/python/GpuTask_cfi.py @@ -0,0 +1,626 @@ +import FWCore.ParameterSet.Config as cms + +digiSamples_ = [1,2,3,4,5,6,7,8,9,10] +uncalibOOTAmps_ = [4,6] + +ecalGpuTask = cms.untracked.PSet( + params = cms.untracked.PSet( + runGpuTask = cms.untracked.bool(False), + gpuOnlyPlots = cms.untracked.bool(True), + uncalibOOTAmps = cms.untracked.vint32(uncalibOOTAmps_) + ), + MEs = cms.untracked.PSet( + # CPU Digi + DigiCpu = cms.untracked.PSet( + path = cms.untracked.string('%(subdet)s/%(prefix)sGpuTask/%(prefix)sGT digi nDigis cpu'), + kind = cms.untracked.string('TH1F'), + otype = cms.untracked.string('Ecal2P'), + btype = cms.untracked.string('User'), + xaxis = cms.untracked.PSet( + nbins = cms.untracked.int32(100), + low = cms.untracked.double(0), + high = cms.untracked.double(5000), + title = cms.untracked.string('Digis per Event') + ), + description = cms.untracked.string('Number of CPU Digis per Event') + ), + DigiCpuAmplitude = cms.untracked.PSet( + path = cms.untracked.string('%(subdet)s/%(prefix)sGpuTask/%(prefix)sGT digi amplitude sample %(sample)s cpu'), + kind = cms.untracked.string('TH1F'), + otype = cms.untracked.string('Ecal2P'), + btype = cms.untracked.string('User'), + multi = cms.untracked.PSet( + sample = cms.untracked.vint32(digiSamples_) + ), + xaxis = cms.untracked.PSet( + nbins = cms.untracked.int32(100), + low = cms.untracked.double(0), + high = cms.untracked.double(4096), + title = cms.untracked.string('ADC Counts') + ), + description = cms.untracked.string('CPU digi amplitudes for individual digi samples (1-10)') + ), + # GPU Digi (optional) + DigiGpu = cms.untracked.PSet( + path = cms.untracked.string('%(subdet)s/%(prefix)sGpuTask/%(prefix)sGT digi nDigis gpu'), + kind = cms.untracked.string('TH1F'), + otype = cms.untracked.string('Ecal2P'), + btype = cms.untracked.string('User'), + xaxis = cms.untracked.PSet( + nbins = cms.untracked.int32(100), + low = cms.untracked.double(0), + high = cms.untracked.double(5000), + title = cms.untracked.string('Digis per Event') + ), + description = cms.untracked.string('Number of GPU Digis per Event') + ), + DigiGpuAmplitude = cms.untracked.PSet( + path = cms.untracked.string('%(subdet)s/%(prefix)sGpuTask/%(prefix)sGT digi amplitude sample %(sample)s gpu'), + kind = cms.untracked.string('TH1F'), + otype = cms.untracked.string('Ecal2P'), + btype = cms.untracked.string('User'), + multi = cms.untracked.PSet( + sample = cms.untracked.vint32(digiSamples_) + ), + xaxis = cms.untracked.PSet( + nbins = cms.untracked.int32(100), + low = cms.untracked.double(0), + high = cms.untracked.double(4096), + title = cms.untracked.string('ADC Counts') + ), + description = cms.untracked.string('GPU digi amplitudes for individual digi samples (1-10)') + ), + # Digi GPU-CPU Difference + DigiGpuCpu = cms.untracked.PSet( + path = cms.untracked.string('%(subdet)s/%(prefix)sGpuTask/%(prefix)sGT digi nDigis gpu-cpu diff'), + kind = cms.untracked.string('TH1F'), + otype = cms.untracked.string('Ecal2P'), + btype = cms.untracked.string('User'), + xaxis = cms.untracked.PSet( + nbins = cms.untracked.int32(100), + low = cms.untracked.double(-500), + high = cms.untracked.double(500), + title = cms.untracked.string('GPU-CPU Digis per Event') + ), + description = cms.untracked.string('GPU-CPU difference of number of Digis per Event') + ), + DigiGpuCpuAmplitude = cms.untracked.PSet( + path = cms.untracked.string('%(subdet)s/%(prefix)sGpuTask/%(prefix)sGT digi amplitude sample %(sample)s gpu-cpu diff'), + kind = cms.untracked.string('TH1F'), + otype = cms.untracked.string('Ecal2P'), + btype = cms.untracked.string('User'), + multi = cms.untracked.PSet( + sample = cms.untracked.vint32(digiSamples_) + ), + xaxis = cms.untracked.PSet( + nbins = cms.untracked.int32(100), + low = cms.untracked.double(-100), + high = cms.untracked.double(100), + title = cms.untracked.string('ADC Counts') + ), + description = cms.untracked.string('GPU-CPU difference of digi amplitude for individual digi samples (1-10)') + ), + # CPU UncalibRecHit + UncalibCpu = cms.untracked.PSet( + path = cms.untracked.string('%(subdet)s/%(prefix)sGpuTask/%(prefix)sGT uncalib rec hit nHits cpu'), + kind = cms.untracked.string('TH1F'), + otype = cms.untracked.string('Ecal2P'), + btype = cms.untracked.string('User'), + xaxis = cms.untracked.PSet( + nbins = cms.untracked.int32(100), + low = cms.untracked.double(0), + high = cms.untracked.double(5000), + title = cms.untracked.string('Uncalibrated Rec Hits per Event') + ), + description = cms.untracked.string('Number of CPU Uncalibrated Rec Hits per Event') + ), + UncalibCpuAmp = cms.untracked.PSet( + path = cms.untracked.string('%(subdet)s/%(prefix)sGpuTask/%(prefix)sGT uncalib rec hit amplitude cpu'), + kind = cms.untracked.string('TH1F'), + otype = cms.untracked.string('Ecal2P'), + btype = cms.untracked.string('User'), + xaxis = cms.untracked.PSet( + nbins = cms.untracked.int32(100), + low = cms.untracked.double(0), + high = cms.untracked.double(5000), + title = cms.untracked.string('Amplitude') + ), + description = cms.untracked.string('CPU Uncalibrated Rec Hit reconstructed amplitude') + ), + UncalibCpuAmpError = cms.untracked.PSet( + path = cms.untracked.string('%(subdet)s/%(prefix)sGpuTask/%(prefix)sGT uncalib rec hit amplitude error cpu'), + kind = cms.untracked.string('TH1F'), + otype = cms.untracked.string('Ecal2P'), + btype = cms.untracked.string('User'), + xaxis = cms.untracked.PSet( + nbins = cms.untracked.int32(100), + low = cms.untracked.double(0), + high = cms.untracked.double(200), + title = cms.untracked.string('Amplitude Error') + ), + description = cms.untracked.string('CPU Uncalibrated Rec Hit reconstructed amplitude uncertainty') + ), + UncalibCpuPedestal = cms.untracked.PSet( + path = cms.untracked.string('%(subdet)s/%(prefix)sGpuTask/%(prefix)sGT uncalib rec hit pedestal cpu'), + kind = cms.untracked.string('TH1F'), + otype = cms.untracked.string('Ecal2P'), + btype = cms.untracked.string('User'), + xaxis = cms.untracked.PSet( + nbins = cms.untracked.int32(100), + low = cms.untracked.double(0), + high = cms.untracked.double(1000), + title = cms.untracked.string('Pedestal') + ), + description = cms.untracked.string('CPU Uncalibrated Rec Hit reconstructed pedestal') + ), + UncalibCpuJitter = cms.untracked.PSet( + path = cms.untracked.string('%(subdet)s/%(prefix)sGpuTask/%(prefix)sGT uncalib rec hit jitter cpu'), + kind = cms.untracked.string('TH1F'), + otype = cms.untracked.string('Ecal2P'), + btype = cms.untracked.string('User'), + xaxis = cms.untracked.PSet( + nbins = cms.untracked.int32(100), + low = cms.untracked.double(-5), + high = cms.untracked.double(5), + title = cms.untracked.string('Jitter') + ), + description = cms.untracked.string('CPU Uncalibrated Rec Hit reconstructed time jitter') + ), + UncalibCpuJitterError = cms.untracked.PSet( + path = cms.untracked.string('%(subdet)s/%(prefix)sGpuTask/%(prefix)sGT uncalib rec hit jitter error cpu'), + kind = cms.untracked.string('TH1F'), + otype = cms.untracked.string('Ecal2P'), + btype = cms.untracked.string('User'), + xaxis = cms.untracked.PSet( + nbins = cms.untracked.int32(25), + low = cms.untracked.double(0), + high = cms.untracked.double(0.25), # If you edit this, also change 10k bin in GpuTask.cc + title = cms.untracked.string('Jitter Error') + ), + description = cms.untracked.string('CPU Uncalibrated Rec Hit reconstructed time jitter uncertainty. 10000 is special value, shown in last bin') + ), + UncalibCpuChi2 = cms.untracked.PSet( + path = cms.untracked.string('%(subdet)s/%(prefix)sGpuTask/%(prefix)sGT uncalib rec hit chi2 cpu'), + kind = cms.untracked.string('TH1F'), + otype = cms.untracked.string('Ecal2P'), + btype = cms.untracked.string('User'), + xaxis = cms.untracked.PSet( + nbins = cms.untracked.int32(100), + low = cms.untracked.double(0), + high = cms.untracked.double(200), + title = cms.untracked.string('Chi2') + ), + description = cms.untracked.string('CPU Uncalibrated Rec Hit chi2 of the pulse') + ), + UncalibCpuOOTAmp = cms.untracked.PSet( + path = cms.untracked.string('%(subdet)s/%(prefix)sGpuTask/%(prefix)sGT uncalib rec hit OOT amplitude %(OOTAmp)s cpu'), + kind = cms.untracked.string('TH1F'), + otype = cms.untracked.string('Ecal2P'), + btype = cms.untracked.string('User'), + multi = cms.untracked.PSet( + OOTAmp = cms.untracked.vint32(uncalibOOTAmps_) + ), + xaxis = cms.untracked.PSet( + nbins = cms.untracked.int32(100), + low = cms.untracked.double(0), + high = cms.untracked.double(500), + title = cms.untracked.string('OOT Amplitude') + ), + description = cms.untracked.string('CPU Uncalibrated Rec Hit out-of-time reconstructed amplitude. Indicies go from 0 to 9, with event BX at index 5. Index 4 == BX-1, index 6 == BX+1, etc.') + ), + UncalibCpuFlags = cms.untracked.PSet( + path = cms.untracked.string('%(subdet)s/%(prefix)sGpuTask/%(prefix)sGT uncalib rec hit flags cpu'), + kind = cms.untracked.string('TH1F'), + otype = cms.untracked.string('Ecal2P'), + btype = cms.untracked.string('User'), + xaxis = cms.untracked.PSet( + nbins = cms.untracked.int32(64), + low = cms.untracked.double(0), + high = cms.untracked.double(64), + title = cms.untracked.string('Flags') + ), + description = cms.untracked.string('CPU Uncalibrated Rec Hit flag to be propagated to RecHit') + ), + # GPU UncalibRecHit (optional) + UncalibGpu = cms.untracked.PSet( + path = cms.untracked.string('%(subdet)s/%(prefix)sGpuTask/%(prefix)sGT uncalib rec hit nHits gpu'), + kind = cms.untracked.string('TH1F'), + otype = cms.untracked.string('Ecal2P'), + btype = cms.untracked.string('User'), + xaxis = cms.untracked.PSet( + nbins = cms.untracked.int32(100), + low = cms.untracked.double(0), + high = cms.untracked.double(5000), + title = cms.untracked.string('Uncalibrated Rec Hits per Event') + ), + description = cms.untracked.string('Number of GPU Uncalibrated Rec Hits per Event') + ), + UncalibGpuAmp = cms.untracked.PSet( + path = cms.untracked.string('%(subdet)s/%(prefix)sGpuTask/%(prefix)sGT uncalib rec hit amplitude gpu'), + kind = cms.untracked.string('TH1F'), + otype = cms.untracked.string('Ecal2P'), + btype = cms.untracked.string('User'), + xaxis = cms.untracked.PSet( + nbins = cms.untracked.int32(100), + low = cms.untracked.double(0), + high = cms.untracked.double(5000), + title = cms.untracked.string('Amplitude') + ), + description = cms.untracked.string('GPU Uncalibrated Rec Hit reconstructed amplitude') + ), + UncalibGpuAmpError = cms.untracked.PSet( + path = cms.untracked.string('%(subdet)s/%(prefix)sGpuTask/%(prefix)sGT uncalib rec hit amplitude error gpu'), + kind = cms.untracked.string('TH1F'), + otype = cms.untracked.string('Ecal2P'), + btype = cms.untracked.string('User'), + xaxis = cms.untracked.PSet( + nbins = cms.untracked.int32(100), + low = cms.untracked.double(0), + high = cms.untracked.double(200), + title = cms.untracked.string('Amplitude Error') + ), + description = cms.untracked.string('GPU Uncalibrated Rec Hit reconstructed amplitude uncertainty') + ), + UncalibGpuPedestal = cms.untracked.PSet( + path = cms.untracked.string('%(subdet)s/%(prefix)sGpuTask/%(prefix)sGT uncalib rec hit pedestal gpu'), + kind = cms.untracked.string('TH1F'), + otype = cms.untracked.string('Ecal2P'), + btype = cms.untracked.string('User'), + xaxis = cms.untracked.PSet( + nbins = cms.untracked.int32(100), + low = cms.untracked.double(0), + high = cms.untracked.double(1000), + title = cms.untracked.string('Pedestal') + ), + description = cms.untracked.string('GPU Uncalibrated Rec Hit reconstructed pedestal') + ), + UncalibGpuJitter = cms.untracked.PSet( + path = cms.untracked.string('%(subdet)s/%(prefix)sGpuTask/%(prefix)sGT uncalib rec hit jitter gpu'), + kind = cms.untracked.string('TH1F'), + otype = cms.untracked.string('Ecal2P'), + btype = cms.untracked.string('User'), + xaxis = cms.untracked.PSet( + nbins = cms.untracked.int32(100), + low = cms.untracked.double(-5), + high = cms.untracked.double(5), + title = cms.untracked.string('Jitter') + ), + description = cms.untracked.string('GPU Uncalibrated Rec Hit reconstructed time jitter') + ), + UncalibGpuJitterError = cms.untracked.PSet( + path = cms.untracked.string('%(subdet)s/%(prefix)sGpuTask/%(prefix)sGT uncalib rec hit jitter error gpu'), + kind = cms.untracked.string('TH1F'), + otype = cms.untracked.string('Ecal2P'), + btype = cms.untracked.string('User'), + xaxis = cms.untracked.PSet( + nbins = cms.untracked.int32(25), + low = cms.untracked.double(0), + high = cms.untracked.double(0.25), # If you edit this, also change 10k bin in GpuTask.cc + title = cms.untracked.string('Jitter Error') + ), + description = cms.untracked.string('GPU Uncalibrated Rec Hit reconstructed time jitter uncertainty. 10000 is special value, shown in last bin') + ), + UncalibGpuChi2 = cms.untracked.PSet( + path = cms.untracked.string('%(subdet)s/%(prefix)sGpuTask/%(prefix)sGT uncalib rec hit chi2 gpu'), + kind = cms.untracked.string('TH1F'), + otype = cms.untracked.string('Ecal2P'), + btype = cms.untracked.string('User'), + xaxis = cms.untracked.PSet( + nbins = cms.untracked.int32(100), + low = cms.untracked.double(0), + high = cms.untracked.double(200), + title = cms.untracked.string('Chi2') + ), + description = cms.untracked.string('GPU Uncalibrated Rec Hit chi2 of the pulse') + ), + UncalibGpuOOTAmp = cms.untracked.PSet( + path = cms.untracked.string('%(subdet)s/%(prefix)sGpuTask/%(prefix)sGT uncalib rec hit OOT amplitude %(OOTAmp)s gpu'), + kind = cms.untracked.string('TH1F'), + otype = cms.untracked.string('Ecal2P'), + btype = cms.untracked.string('User'), + multi = cms.untracked.PSet( + OOTAmp = cms.untracked.vint32(uncalibOOTAmps_) + ), + xaxis = cms.untracked.PSet( + nbins = cms.untracked.int32(100), + low = cms.untracked.double(0), + high = cms.untracked.double(500), + title = cms.untracked.string('OOT Amplitude') + ), + description = cms.untracked.string('GPU Uncalibrated Rec Hit out-of-time reconstructed amplitude. Indicies go from 0 to 9, with event BX at index 5. Index 4 == BX-1, index 6 == BX+1, etc.') + ), + UncalibGpuFlags = cms.untracked.PSet( + path = cms.untracked.string('%(subdet)s/%(prefix)sGpuTask/%(prefix)sGT uncalib rec hit flags gpu'), + kind = cms.untracked.string('TH1F'), + otype = cms.untracked.string('Ecal2P'), + btype = cms.untracked.string('User'), + xaxis = cms.untracked.PSet( + nbins = cms.untracked.int32(64), + low = cms.untracked.double(0), + high = cms.untracked.double(64), + title = cms.untracked.string('Flags') + ), + description = cms.untracked.string('GPU Uncalibrated Rec Hit flag to be propagated to RecHit') + ), + # UncalibRecHit GPU-CPU Difference + UncalibGpuCpu = cms.untracked.PSet( + path = cms.untracked.string('%(subdet)s/%(prefix)sGpuTask/%(prefix)sGT uncalib rec hit nHits gpu-cpu diff'), + kind = cms.untracked.string('TH1F'), + otype = cms.untracked.string('Ecal2P'), + btype = cms.untracked.string('User'), + xaxis = cms.untracked.PSet( + nbins = cms.untracked.int32(100), + low = cms.untracked.double(-500), + high = cms.untracked.double(500), + title = cms.untracked.string('GPU-CPU Uncalibrated Rec Hits per Event') + ), + description = cms.untracked.string('GPU-CPU difference of number of Uncalibrated Rec Hits per Event') + ), + UncalibGpuCpuAmp = cms.untracked.PSet( + path = cms.untracked.string('%(subdet)s/%(prefix)sGpuTask/%(prefix)sGT uncalib rec hit amplitude gpu-cpu diff'), + kind = cms.untracked.string('TH1F'), + otype = cms.untracked.string('Ecal2P'), + btype = cms.untracked.string('User'), + xaxis = cms.untracked.PSet( + nbins = cms.untracked.int32(100), + low = cms.untracked.double(-100), + high = cms.untracked.double(100), + title = cms.untracked.string('GPU-CPU Amplitude') + ), + description = cms.untracked.string('GPU-CPU difference of Uncalibrated Rec Hit reconstructed amplitude') + ), + UncalibGpuCpuAmpError = cms.untracked.PSet( + path = cms.untracked.string('%(subdet)s/%(prefix)sGpuTask/%(prefix)sGT uncalib rec hit amplitude error gpu-cpu diff'), + kind = cms.untracked.string('TH1F'), + otype = cms.untracked.string('Ecal2P'), + btype = cms.untracked.string('User'), + xaxis = cms.untracked.PSet( + nbins = cms.untracked.int32(100), + low = cms.untracked.double(-50), + high = cms.untracked.double(50), + title = cms.untracked.string('GPU-CPU Amplitude Error') + ), + description = cms.untracked.string('GPU-CPU difference of Uncalibrated Rec Hit reconstructed amplitude uncertainty') + ), + UncalibGpuCpuPedestal = cms.untracked.PSet( + path = cms.untracked.string('%(subdet)s/%(prefix)sGpuTask/%(prefix)sGT uncalib rec hit pedestal gpu-cpu diff'), + kind = cms.untracked.string('TH1F'), + otype = cms.untracked.string('Ecal2P'), + btype = cms.untracked.string('User'), + xaxis = cms.untracked.PSet( + nbins = cms.untracked.int32(100), + low = cms.untracked.double(-50), + high = cms.untracked.double(50), + title = cms.untracked.string('GPU-CPU Pedestal') + ), + description = cms.untracked.string('GPU-CPU difference of Uncalibrated Rec Hit reconstructed pedestal') + ), + UncalibGpuCpuJitter = cms.untracked.PSet( + path = cms.untracked.string('%(subdet)s/%(prefix)sGpuTask/%(prefix)sGT uncalib rec hit jitter gpu-cpu diff'), + kind = cms.untracked.string('TH1F'), + otype = cms.untracked.string('Ecal2P'), + btype = cms.untracked.string('User'), + xaxis = cms.untracked.PSet( + nbins = cms.untracked.int32(100), + low = cms.untracked.double(-1), + high = cms.untracked.double(1), + title = cms.untracked.string('GPU-CPU Jitter') + ), + description = cms.untracked.string('GPU-CPU difference of Uncalibrated Rec Hit reconstructed time jitter') + ), + UncalibGpuCpuJitterError = cms.untracked.PSet( + path = cms.untracked.string('%(subdet)s/%(prefix)sGpuTask/%(prefix)sGT uncalib rec hit jitter error gpu-cpu diff'), + kind = cms.untracked.string('TH1F'), + otype = cms.untracked.string('Ecal2P'), + btype = cms.untracked.string('User'), + xaxis = cms.untracked.PSet( + nbins = cms.untracked.int32(100), + low = cms.untracked.double(-0.03), + high = cms.untracked.double(0.03), + title = cms.untracked.string('GPU-CPU Jitter Error') + ), + description = cms.untracked.string('GPU-CPU difference of Uncalibrated Rec Hit reconstructed time jitter uncertainty. 10000 is special value, shown in last bin') + ), + UncalibGpuCpuChi2 = cms.untracked.PSet( + path = cms.untracked.string('%(subdet)s/%(prefix)sGpuTask/%(prefix)sGT uncalib rec hit chi2 gpu-cpu diff'), + kind = cms.untracked.string('TH1F'), + otype = cms.untracked.string('Ecal2P'), + btype = cms.untracked.string('User'), + xaxis = cms.untracked.PSet( + nbins = cms.untracked.int32(100), + low = cms.untracked.double(-20), + high = cms.untracked.double(20), + title = cms.untracked.string('GPU-CPU Chi2') + ), + description = cms.untracked.string('GPU-CPU difference of Uncalibrated Rec Hit chi2 of the pulse') + ), + UncalibGpuCpuOOTAmp = cms.untracked.PSet( + path = cms.untracked.string('%(subdet)s/%(prefix)sGpuTask/%(prefix)sGT uncalib rec hit OOT amplitude %(OOTAmp)s gpu-cpu diff'), + kind = cms.untracked.string('TH1F'), + otype = cms.untracked.string('Ecal2P'), + btype = cms.untracked.string('User'), + multi = cms.untracked.PSet( + OOTAmp = cms.untracked.vint32(uncalibOOTAmps_) + ), + xaxis = cms.untracked.PSet( + nbins = cms.untracked.int32(100), + low = cms.untracked.double(-50), + high = cms.untracked.double(50), + title = cms.untracked.string('GPU-CPU OOT Amplitude') + ), + description = cms.untracked.string('GPU-CPU difference of Uncalibrated Rec Hit out-of-time reconstructed amplitude. Indicies go from 0 to 9, with event BX at index 5. Index 4 == BX-1, index 6 == BX+1, etc.') + ), + UncalibGpuCpuFlags = cms.untracked.PSet( + path = cms.untracked.string('%(subdet)s/%(prefix)sGpuTask/%(prefix)sGT uncalib rec hit flags gpu-cpu diff'), + kind = cms.untracked.string('TH1F'), + otype = cms.untracked.string('Ecal2P'), + btype = cms.untracked.string('User'), + xaxis = cms.untracked.PSet( + nbins = cms.untracked.int32(128), + low = cms.untracked.double(-64), + high = cms.untracked.double(64), + title = cms.untracked.string('GPU-CPU Flags') + ), + description = cms.untracked.string('GPU-CPU difference of Uncalibrated Rec Hit flag to be propagated to RecHit') + ), + # CPU RecHit + RecHitCpu = cms.untracked.PSet( + path = cms.untracked.string('%(subdet)s/%(prefix)sGpuTask/%(prefix)sGT rec hit nHits cpu'), + kind = cms.untracked.string('TH1F'), + otype = cms.untracked.string('Ecal2P'), + btype = cms.untracked.string('User'), + xaxis = cms.untracked.PSet( + nbins = cms.untracked.int32(100), + low = cms.untracked.double(0), + high = cms.untracked.double(5000), + title = cms.untracked.string('Rec Hits per Event') + ), + description = cms.untracked.string('Number of CPU Rec Hits per Event') + ), + RecHitCpuEnergy = cms.untracked.PSet( + path = cms.untracked.string('%(subdet)s/%(prefix)sGpuTask/%(prefix)sGT rec hit energy cpu'), + kind = cms.untracked.string('TH1F'), + otype = cms.untracked.string('Ecal2P'), + btype = cms.untracked.string('User'), + xaxis = cms.untracked.PSet( + nbins = cms.untracked.int32(100), + low = cms.untracked.double(0), + high = cms.untracked.double(5.0), + title = cms.untracked.string('Energy (Gev)') + ), + description = cms.untracked.string('CPU Rec Hit Energy (GeV)') + ), + RecHitCpuTime = cms.untracked.PSet( + path = cms.untracked.string('%(subdet)s/%(prefix)sGpuTask/%(prefix)sGT rec hit time cpu'), + kind = cms.untracked.string('TH1F'), + otype = cms.untracked.string('Ecal2P'), + btype = cms.untracked.string('User'), + xaxis = cms.untracked.PSet( + nbins = cms.untracked.int32(100), + low = cms.untracked.double(-25.0), + high = cms.untracked.double(25.0), + title = cms.untracked.string('Time (ns)') + ), + description = cms.untracked.string('CPU Rec Hit Time') + ), + RecHitCpuFlags = cms.untracked.PSet( + path = cms.untracked.string('%(subdet)s/%(prefix)sGpuTask/%(prefix)sGT rec hit flags cpu'), + kind = cms.untracked.string('TH1F'), + otype = cms.untracked.string('Ecal2P'), + btype = cms.untracked.string('User'), + xaxis = cms.untracked.PSet( + nbins = cms.untracked.int32(100), + low = cms.untracked.double(0), + high = cms.untracked.double(1024), + title = cms.untracked.string('Flags') + ), + description = cms.untracked.string('CPU Rec Hit Flags') + ), + # GPU RecHit (optional) + RecHitGpu = cms.untracked.PSet( + path = cms.untracked.string('%(subdet)s/%(prefix)sGpuTask/%(prefix)sGT rec hit nHits gpu'), + kind = cms.untracked.string('TH1F'), + otype = cms.untracked.string('Ecal2P'), + btype = cms.untracked.string('User'), + xaxis = cms.untracked.PSet( + nbins = cms.untracked.int32(100), + low = cms.untracked.double(0), + high = cms.untracked.double(5000), + title = cms.untracked.string('Rec Hits per Event') + ), + description = cms.untracked.string('Number of GPU Rec Hits per Event') + ), + RecHitGpuEnergy = cms.untracked.PSet( + path = cms.untracked.string('%(subdet)s/%(prefix)sGpuTask/%(prefix)sGT rec hit energy gpu'), + kind = cms.untracked.string('TH1F'), + otype = cms.untracked.string('Ecal2P'), + btype = cms.untracked.string('User'), + xaxis = cms.untracked.PSet( + nbins = cms.untracked.int32(100), + low = cms.untracked.double(0), + high = cms.untracked.double(5.0), + title = cms.untracked.string('Energy (Gev)') + ), + description = cms.untracked.string('GPU Rec Hit Energy (GeV)') + ), + RecHitGpuTime = cms.untracked.PSet( + path = cms.untracked.string('%(subdet)s/%(prefix)sGpuTask/%(prefix)sGT rec hit time gpu'), + kind = cms.untracked.string('TH1F'), + otype = cms.untracked.string('Ecal2P'), + btype = cms.untracked.string('User'), + xaxis = cms.untracked.PSet( + nbins = cms.untracked.int32(100), + low = cms.untracked.double(-25.0), + high = cms.untracked.double(25.0), + title = cms.untracked.string('Time (ns)') + ), + description = cms.untracked.string('GPU Rec Hit Time') + ), + RecHitGpuFlags = cms.untracked.PSet( + path = cms.untracked.string('%(subdet)s/%(prefix)sGpuTask/%(prefix)sGT rec hit flags gpu'), + kind = cms.untracked.string('TH1F'), + otype = cms.untracked.string('Ecal2P'), + btype = cms.untracked.string('User'), + xaxis = cms.untracked.PSet( + nbins = cms.untracked.int32(100), + low = cms.untracked.double(0), + high = cms.untracked.double(1024), + title = cms.untracked.string('Flags') + ), + description = cms.untracked.string('GPU Rec Hit Flags') + ), + # RecHit GPU-CPU Difference + RecHitGpuCpu = cms.untracked.PSet( + path = cms.untracked.string('%(subdet)s/%(prefix)sGpuTask/%(prefix)sGT rec hit nHits gpu-cpu diff'), + kind = cms.untracked.string('TH1F'), + otype = cms.untracked.string('Ecal2P'), + btype = cms.untracked.string('User'), + xaxis = cms.untracked.PSet( + nbins = cms.untracked.int32(100), + low = cms.untracked.double(-500), + high = cms.untracked.double(500), + title = cms.untracked.string('GPU-CPU Rec Hits per Event') + ), + description = cms.untracked.string('GPU-CPU difference of number of total Rec Hits per Event') + ), + RecHitGpuCpuEnergy = cms.untracked.PSet( + path = cms.untracked.string('%(subdet)s/%(prefix)sGpuTask/%(prefix)sGT rec hit energy gpu-cpu diff'), + kind = cms.untracked.string('TH1F'), + otype = cms.untracked.string('Ecal2P'), + btype = cms.untracked.string('User'), + xaxis = cms.untracked.PSet( + nbins = cms.untracked.int32(100), + low = cms.untracked.double(-1.0), + high = cms.untracked.double(1.0), + title = cms.untracked.string('GPU-CPU Energy (GeV)') + ), + description = cms.untracked.string('GPU-CPU difference of Rec Hit Energy (GeV)') + ), + RecHitGpuCpuTime = cms.untracked.PSet( + path = cms.untracked.string('%(subdet)s/%(prefix)sGpuTask/%(prefix)sGT rec hit time gpu-cpu diff'), + kind = cms.untracked.string('TH1F'), + otype = cms.untracked.string('Ecal2P'), + btype = cms.untracked.string('User'), + xaxis = cms.untracked.PSet( + nbins = cms.untracked.int32(100), + low = cms.untracked.double(-2.5), + high = cms.untracked.double(2.5), + title = cms.untracked.string('GPU-CPU Time (ns)') + ), + description = cms.untracked.string('GPU-CPU difference of Rec Hit Time') + ), + RecHitGpuCpuFlags = cms.untracked.PSet( + path = cms.untracked.string('%(subdet)s/%(prefix)sGpuTask/%(prefix)sGT rec hit flags gpu-cpu diff'), + kind = cms.untracked.string('TH1F'), + otype = cms.untracked.string('Ecal2P'), + btype = cms.untracked.string('User'), + xaxis = cms.untracked.PSet( + nbins = cms.untracked.int32(100), + low = cms.untracked.double(-1024), + high = cms.untracked.double(1024), + title = cms.untracked.string('GPU-CPU Flags') + ), + description = cms.untracked.string('GPU-CPU differnece of Rec Hit Flags') + ) + ) +) diff --git a/DQM/EcalMonitorTasks/src/GpuTask.cc b/DQM/EcalMonitorTasks/src/GpuTask.cc new file mode 100644 index 0000000000000..678cf6ddde26c --- /dev/null +++ b/DQM/EcalMonitorTasks/src/GpuTask.cc @@ -0,0 +1,455 @@ +#include "DQM/EcalMonitorTasks/interface/GpuTask.h" + +#include "DQM/EcalCommon/interface/EcalDQMCommonUtils.h" +#include "DQM/EcalCommon/interface/MESetMulti.h" + +#include "FWCore/ParameterSet/interface/ParameterSet.h" +#include "FWCore/MessageLogger/interface/MessageLogger.h" + +#include "DataFormats/EcalRawData/interface/EcalDCCHeaderBlock.h" + +namespace ecaldqm { + GpuTask::GpuTask() + : DQWorkerTask(), + runGpuTask_(false), + gpuOnlyPlots_(false), + EBCpuDigis_(nullptr), + EECpuDigis_(nullptr), + EBCpuUncalibRecHits_(nullptr), + EECpuUncalibRecHits_(nullptr), + EBCpuRecHits_(nullptr), + EECpuRecHits_(nullptr) {} + + void GpuTask::addDependencies(DependencySet& _dependencies) { + // Ensure we run on CPU objects before GPU objects + if (runGpuTask_) { + _dependencies.push_back(Dependency(kEBGpuDigi, kEBCpuDigi)); + _dependencies.push_back(Dependency(kEEGpuDigi, kEECpuDigi)); + + _dependencies.push_back(Dependency(kEBGpuUncalibRecHit, kEBCpuUncalibRecHit)); + _dependencies.push_back(Dependency(kEEGpuUncalibRecHit, kEECpuUncalibRecHit)); + + _dependencies.push_back(Dependency(kEBGpuRecHit, kEBCpuRecHit)); + _dependencies.push_back(Dependency(kEEGpuRecHit, kEECpuRecHit)); + } + } + + void GpuTask::setParams(edm::ParameterSet const& _params) { + runGpuTask_ = _params.getUntrackedParameter("runGpuTask"); + // Only makes sense to run GPU-only plots if we're running at all... + gpuOnlyPlots_ = runGpuTask_ && _params.getUntrackedParameter("gpuOnlyPlots"); + uncalibOOTAmps_ = _params.getUntrackedParameter >("uncalibOOTAmps"); + + if (!runGpuTask_) { + MEs_.erase(std::string("DigiCpuAmplitude")); + MEs_.erase(std::string("DigiGpuCpuAmplitude")); + MEs_.erase(std::string("UncalibCpu")); + MEs_.erase(std::string("UncalibCpuAmp")); + MEs_.erase(std::string("UncalibCpuAmpError")); + MEs_.erase(std::string("UncalibCpuPedestal")); + MEs_.erase(std::string("UncalibCpuJitter")); + MEs_.erase(std::string("UncalibCpuJitterError")); + MEs_.erase(std::string("UncalibCpuChi2")); + MEs_.erase(std::string("UncalibCpuOOTAmp")); + MEs_.erase(std::string("UncalibCpuFlags")); + MEs_.erase(std::string("UncalibGpuCpu")); + MEs_.erase(std::string("UncalibGpuCpuAmp")); + MEs_.erase(std::string("UncalibGpuCpuAmpError")); + MEs_.erase(std::string("UncalibGpuCpuPedestal")); + MEs_.erase(std::string("UncalibGpuCpuJitter")); + MEs_.erase(std::string("UncalibGpuCpuJitterError")); + MEs_.erase(std::string("UncalibGpuCpuChi2")); + MEs_.erase(std::string("UncalibGpuCpuOOTAmp")); + MEs_.erase(std::string("UncalibGpuCpuFlags")); + MEs_.erase(std::string("RecHitCpu")); + MEs_.erase(std::string("RecHitCpuEnergy")); + MEs_.erase(std::string("RecHitCpuTime")); + MEs_.erase(std::string("RecHitCpuFlags")); + MEs_.erase(std::string("RecHitGpuCpu")); + MEs_.erase(std::string("RecHitGpuCpuEnergy")); + MEs_.erase(std::string("RecHitGpuCpuTime")); + MEs_.erase(std::string("RecHitGpuCpuFlags")); + } + if (!gpuOnlyPlots_) { + MEs_.erase(std::string("DigiGpuAmplitude")); + MEs_.erase(std::string("RecHitGpu")); + MEs_.erase(std::string("RecHitGpuEnergy")); + MEs_.erase(std::string("RecHitGpuTime")); + MEs_.erase(std::string("RecHitGpuFlags")); + MEs_.erase(std::string("UncalibGpu")); + MEs_.erase(std::string("UncalibGpuAmp")); + MEs_.erase(std::string("UncalibGpuAmpError")); + MEs_.erase(std::string("UncalibGpuPedestal")); + MEs_.erase(std::string("UncalibGpuJitter")); + MEs_.erase(std::string("UncalibGpuJitterError")); + MEs_.erase(std::string("UncalibGpuChi2")); + MEs_.erase(std::string("UncalibGpuOOTAmp")); + MEs_.erase(std::string("UncalibGpuFlags")); + } + } + + bool GpuTask::filterRunType(short const* _runType) { + for (unsigned iFED(0); iFED != ecaldqm::nDCC; iFED++) { + if (_runType[iFED] == EcalDCCHeaderBlock::COSMIC || _runType[iFED] == EcalDCCHeaderBlock::MTCC || + _runType[iFED] == EcalDCCHeaderBlock::COSMICS_GLOBAL || + _runType[iFED] == EcalDCCHeaderBlock::PHYSICS_GLOBAL || _runType[iFED] == EcalDCCHeaderBlock::COSMICS_LOCAL || + _runType[iFED] == EcalDCCHeaderBlock::PHYSICS_LOCAL) + return true; + } + + return false; + } + + void GpuTask::beginEvent(edm::Event const&, edm::EventSetup const&, bool const&, bool&) { + EBCpuDigis_ = nullptr; + EECpuDigis_ = nullptr; + EBCpuUncalibRecHits_ = nullptr; + EECpuUncalibRecHits_ = nullptr; + EBCpuRecHits_ = nullptr; + EECpuRecHits_ = nullptr; + } + + template + void GpuTask::runOnCpuDigis(DigiCollection const& _cpuDigis, Collections _collection) { + MESet& meDigiCpu(MEs_.at("DigiCpu")); + MESet& meDigiCpuAmplitude(MEs_.at("DigiCpuAmplitude")); + + int iSubdet(_collection == kEBCpuDigi ? EcalBarrel : EcalEndcap); + + // Save CpuDigis for comparison with GpuDigis + // Static cast to EB/EEDigiCollection during use + // Stored as void pointers to make compiler happy + if (iSubdet == EcalBarrel) + EBCpuDigis_ = &_cpuDigis; + else + EECpuDigis_ = &_cpuDigis; + + unsigned nCpuDigis(_cpuDigis.size()); + meDigiCpu.fill(getEcalDQMSetupObjects(), iSubdet, nCpuDigis); + + for (typename DigiCollection::const_iterator cpuItr(_cpuDigis.begin()); cpuItr != _cpuDigis.end(); ++cpuItr) { + // EcalDataFrame is not a derived class of edm::DataFrame, but can take edm::DataFrame (digis) in the constructor + EcalDataFrame cpuDataFrame(*cpuItr); + + for (int iSample = 0; iSample < 10; iSample++) { + static_cast(meDigiCpuAmplitude).use(iSample); + + int cpuAmp(cpuDataFrame.sample(iSample).adc()); + meDigiCpuAmplitude.fill(getEcalDQMSetupObjects(), iSubdet, cpuAmp); + } + } + } + + template + void GpuTask::runOnGpuDigis(DigiCollection const& _gpuDigis, Collections _collection) { + MESet& meDigiGpuCpu(MEs_.at("DigiGpuCpu")); + MESet& meDigiGpuCpuAmplitude(MEs_.at("DigiGpuCpuAmplitude")); + + int iSubdet(_collection == kEBGpuDigi ? EcalBarrel : EcalEndcap); + + // Get CpuDigis saved from GpuTask::runOnCpuDigis() for this event + // Note: _gpuDigis is a collection and cpuDigis is a pointer to a collection (for historical reasons) + // Note 2: EB/EECpuDigis_ are void pointers to make compiler happy + DigiCollection const* cpuDigis = (iSubdet == EcalBarrel) ? static_cast(EBCpuDigis_) + : static_cast(EECpuDigis_); + + if (!cpuDigis) { + edm::LogWarning("EcalDQM") << "GpuTask: Did not find " << ((iSubdet == EcalBarrel) ? "EB" : "EE") + << "CpuDigis Collection. Aborting runOnGpuDigis\n"; + return; + } + + unsigned nGpuDigis(_gpuDigis.size()); + unsigned nCpuDigis(cpuDigis->size()); + + meDigiGpuCpu.fill(getEcalDQMSetupObjects(), iSubdet, nGpuDigis - nCpuDigis); + + if (gpuOnlyPlots_) { + MESet& meDigiGpu(MEs_.at("DigiGpu")); + meDigiGpu.fill(getEcalDQMSetupObjects(), iSubdet, nGpuDigis); + } + + for (typename DigiCollection::const_iterator gpuItr(_gpuDigis.begin()); gpuItr != _gpuDigis.end(); ++gpuItr) { + // Find CpuDigi with matching DetId + DetId gpuId(gpuItr->id()); + typename DigiCollection::const_iterator cpuItr(cpuDigis->find(gpuId)); + if (cpuItr == cpuDigis->end()) { + edm::LogWarning("EcalDQM") << "GpuTask: Did not find CpuDigi DetId " << gpuId.rawId() << " in CPU collection\n"; + continue; + } + + // EcalDataFrame is not a derived class of edm::DataFrame, but can take edm::DataFrame (digis) in the constructor + EcalDataFrame gpuDataFrame(*gpuItr); + EcalDataFrame cpuDataFrame(*cpuItr); + + for (int iSample = 0; iSample < 10; iSample++) { + static_cast(meDigiGpuCpuAmplitude).use(iSample); + + int gpuAmp(gpuDataFrame.sample(iSample).adc()); + int cpuAmp(cpuDataFrame.sample(iSample).adc()); + + meDigiGpuCpuAmplitude.fill(getEcalDQMSetupObjects(), iSubdet, gpuAmp - cpuAmp); + + if (gpuOnlyPlots_) { + MESet& meDigiGpuAmplitude(MEs_.at("DigiGpuAmplitude")); + static_cast(meDigiGpuAmplitude).use(iSample); + meDigiGpuAmplitude.fill(getEcalDQMSetupObjects(), iSubdet, gpuAmp); + } + } + } + } + + void GpuTask::runOnCpuUncalibRecHits(EcalUncalibratedRecHitCollection const& _cpuHits, Collections _collection) { + MESet& meUncalibCpu(MEs_.at("UncalibCpu")); + MESet& meUncalibCpuAmp(MEs_.at("UncalibCpuAmp")); + MESet& meUncalibCpuAmpError(MEs_.at("UncalibCpuAmpError")); + MESet& meUncalibCpuPedestal(MEs_.at("UncalibCpuPedestal")); + MESet& meUncalibCpuJitter(MEs_.at("UncalibCpuJitter")); + MESet& meUncalibCpuJitterError(MEs_.at("UncalibCpuJitterError")); + MESet& meUncalibCpuChi2(MEs_.at("UncalibCpuChi2")); + MESet& meUncalibCpuOOTAmp(MEs_.at("UncalibCpuOOTAmp")); + MESet& meUncalibCpuFlags(MEs_.at("UncalibCpuFlags")); + + int iSubdet(_collection == kEBCpuUncalibRecHit ? EcalBarrel : EcalEndcap); + + // Save CpuUncalibRecHits for comparison with GpuUncalibRecHits + if (iSubdet == EcalBarrel) + EBCpuUncalibRecHits_ = &_cpuHits; + else + EECpuUncalibRecHits_ = &_cpuHits; + + unsigned nCpuHits(_cpuHits.size()); + meUncalibCpu.fill(getEcalDQMSetupObjects(), iSubdet, nCpuHits); + + for (EcalUncalibratedRecHitCollection::const_iterator cpuItr(_cpuHits.begin()); cpuItr != _cpuHits.end(); + ++cpuItr) { + float cpuAmp(cpuItr->amplitude()); + float cpuAmpError(cpuItr->amplitudeError()); + float cpuPedestal(cpuItr->pedestal()); + float cpuJitter(cpuItr->jitter()); + float cpuJitterError(cpuItr->jitterError()); + float cpuChi2(cpuItr->chi2()); + uint32_t cpuFlags(cpuItr->flags()); + + if (cpuJitterError == 10000) // Set this so 10000 (special value) shows up in last bin + cpuJitterError = 0.249999; + + meUncalibCpuAmp.fill(getEcalDQMSetupObjects(), iSubdet, cpuAmp); + meUncalibCpuAmpError.fill(getEcalDQMSetupObjects(), iSubdet, cpuAmpError); + meUncalibCpuPedestal.fill(getEcalDQMSetupObjects(), iSubdet, cpuPedestal); + meUncalibCpuJitter.fill(getEcalDQMSetupObjects(), iSubdet, cpuJitter); + meUncalibCpuJitterError.fill(getEcalDQMSetupObjects(), iSubdet, cpuJitterError); + meUncalibCpuChi2.fill(getEcalDQMSetupObjects(), iSubdet, cpuChi2); + meUncalibCpuFlags.fill(getEcalDQMSetupObjects(), iSubdet, cpuFlags); + + for (unsigned iAmp = 0; iAmp < uncalibOOTAmps_.size(); iAmp++) { + static_cast(meUncalibCpuOOTAmp).use(iAmp); + + // Get corresponding OOT Amplitude + int cpuOOTAmp(cpuItr->outOfTimeAmplitude(uncalibOOTAmps_[iAmp])); + meUncalibCpuOOTAmp.fill(getEcalDQMSetupObjects(), iSubdet, cpuOOTAmp); + } + } + } + + void GpuTask::runOnGpuUncalibRecHits(EcalUncalibratedRecHitCollection const& _gpuHits, Collections _collection) { + MESet& meUncalibGpuCpu(MEs_.at("UncalibGpuCpu")); + MESet& meUncalibGpuCpuAmp(MEs_.at("UncalibGpuCpuAmp")); + MESet& meUncalibGpuCpuAmpError(MEs_.at("UncalibGpuCpuAmpError")); + MESet& meUncalibGpuCpuPedestal(MEs_.at("UncalibGpuCpuPedestal")); + MESet& meUncalibGpuCpuJitter(MEs_.at("UncalibGpuCpuJitter")); + MESet& meUncalibGpuCpuJitterError(MEs_.at("UncalibGpuCpuJitterError")); + MESet& meUncalibGpuCpuChi2(MEs_.at("UncalibGpuCpuChi2")); + MESet& meUncalibGpuCpuOOTAmp(MEs_.at("UncalibGpuCpuOOTAmp")); + MESet& meUncalibGpuCpuFlags(MEs_.at("UncalibGpuCpuFlags")); + + int iSubdet(_collection == kEBGpuUncalibRecHit ? EcalBarrel : EcalEndcap); + + // Get CpuUncalibRecHits saved from GpuTask::runOnCpuUncalibRecHits() for this event + // Note: _gpuHits is a collection and cpuHits is a pointer to a collection (for historical reasons) + EcalUncalibratedRecHitCollection const* cpuHits = + (iSubdet == EcalBarrel) ? EBCpuUncalibRecHits_ : EECpuUncalibRecHits_; + if (!cpuHits) { + edm::LogWarning("EcalDQM") << "GpuTask: Did not find " << ((iSubdet == EcalBarrel) ? "EB" : "EE") + << "CpuUncalibRecHits Collection. Aborting runOnGpuUncalibRecHits\n"; + return; + } + + unsigned nGpuHits(_gpuHits.size()); + unsigned nCpuHits(cpuHits->size()); + + meUncalibGpuCpu.fill(getEcalDQMSetupObjects(), iSubdet, nGpuHits - nCpuHits); + + if (gpuOnlyPlots_) { + MESet& meUncalibGpu(MEs_.at("UncalibGpu")); + meUncalibGpu.fill(getEcalDQMSetupObjects(), iSubdet, nGpuHits); + } + + for (EcalUncalibratedRecHitCollection::const_iterator gpuItr(_gpuHits.begin()); gpuItr != _gpuHits.end(); + ++gpuItr) { + // Find CpuUncalibRecHit with matching DetId + DetId gpuId(gpuItr->id()); + EcalUncalibratedRecHitCollection::const_iterator cpuItr(cpuHits->find(gpuId)); + if (cpuItr == cpuHits->end()) { + edm::LogWarning("EcalDQM") << "GpuTask: Did not find GpuUncalibRecHit DetId " << gpuId.rawId() + << " in CPU collection\n"; + continue; + } + + float gpuAmp(gpuItr->amplitude()); + float gpuAmpError(gpuItr->amplitudeError()); + float gpuPedestal(gpuItr->pedestal()); + float gpuJitter(gpuItr->jitter()); + float gpuJitterError(gpuItr->jitterError()); + float gpuChi2(gpuItr->chi2()); + uint32_t gpuFlags(gpuItr->flags()); + + if (gpuJitterError == 10000) // Set this so 10000 (special value) shows up in last bin + gpuJitterError = 0.249999; + + float cpuAmp(cpuItr->amplitude()); + float cpuAmpError(cpuItr->amplitudeError()); + float cpuPedestal(cpuItr->pedestal()); + float cpuJitter(cpuItr->jitter()); + float cpuJitterError(cpuItr->jitterError()); + float cpuChi2(cpuItr->chi2()); + uint32_t cpuFlags(cpuItr->flags()); + + if (cpuJitterError == 10000) // Set this so 10000 (special value) shows up in last bin + cpuJitterError = 0.249999; + + meUncalibGpuCpuAmp.fill(getEcalDQMSetupObjects(), iSubdet, gpuAmp - cpuAmp); + meUncalibGpuCpuAmpError.fill(getEcalDQMSetupObjects(), iSubdet, gpuAmpError - cpuAmpError); + meUncalibGpuCpuPedestal.fill(getEcalDQMSetupObjects(), iSubdet, gpuPedestal - cpuPedestal); + meUncalibGpuCpuJitter.fill(getEcalDQMSetupObjects(), iSubdet, gpuJitter - cpuJitter); + meUncalibGpuCpuJitterError.fill(getEcalDQMSetupObjects(), iSubdet, gpuJitterError - cpuJitterError); + meUncalibGpuCpuChi2.fill(getEcalDQMSetupObjects(), iSubdet, gpuChi2 - cpuChi2); + meUncalibGpuCpuFlags.fill(getEcalDQMSetupObjects(), iSubdet, gpuFlags - cpuFlags); + + if (gpuOnlyPlots_) { + MESet& meUncalibGpuAmp(MEs_.at("UncalibGpuAmp")); + MESet& meUncalibGpuAmpError(MEs_.at("UncalibGpuAmpError")); + MESet& meUncalibGpuPedestal(MEs_.at("UncalibGpuPedestal")); + MESet& meUncalibGpuJitter(MEs_.at("UncalibGpuJitter")); + MESet& meUncalibGpuJitterError(MEs_.at("UncalibGpuJitterError")); + MESet& meUncalibGpuChi2(MEs_.at("UncalibGpuChi2")); + MESet& meUncalibGpuFlags(MEs_.at("UncalibGpuFlags")); + + meUncalibGpuAmp.fill(getEcalDQMSetupObjects(), iSubdet, gpuAmp); + meUncalibGpuAmpError.fill(getEcalDQMSetupObjects(), iSubdet, gpuAmpError); + meUncalibGpuPedestal.fill(getEcalDQMSetupObjects(), iSubdet, gpuPedestal); + meUncalibGpuJitter.fill(getEcalDQMSetupObjects(), iSubdet, gpuJitter); + meUncalibGpuJitterError.fill(getEcalDQMSetupObjects(), iSubdet, gpuJitterError); + meUncalibGpuChi2.fill(getEcalDQMSetupObjects(), iSubdet, gpuChi2); + meUncalibGpuFlags.fill(getEcalDQMSetupObjects(), iSubdet, gpuFlags); + } + + for (unsigned iAmp = 0; iAmp < uncalibOOTAmps_.size(); iAmp++) { + static_cast(meUncalibGpuCpuOOTAmp).use(iAmp); + + // Get corresponding OOT Amplitude + int gpuOOTAmp(gpuItr->outOfTimeAmplitude(uncalibOOTAmps_[iAmp])); + int cpuOOTAmp(cpuItr->outOfTimeAmplitude(uncalibOOTAmps_[iAmp])); + + meUncalibGpuCpuOOTAmp.fill(getEcalDQMSetupObjects(), iSubdet, gpuOOTAmp - cpuOOTAmp); + + if (gpuOnlyPlots_) { + MESet& meUncalibGpuOOTAmp(MEs_.at("UncalibGpuOOTAmp")); + static_cast(meUncalibGpuOOTAmp).use(iAmp); + meUncalibGpuOOTAmp.fill(getEcalDQMSetupObjects(), iSubdet, gpuOOTAmp); + } + } + } + } + + void GpuTask::runOnCpuRecHits(EcalRecHitCollection const& _cpuHits, Collections _collection) { + MESet& meRecHitCpu(MEs_.at("RecHitCpu")); + MESet& meRecHitCpuEnergy(MEs_.at("RecHitCpuEnergy")); + MESet& meRecHitCpuTime(MEs_.at("RecHitCpuTime")); + MESet& meRecHitCpuFlags(MEs_.at("RecHitCpuFlags")); + + int iSubdet(_collection == kEBCpuRecHit ? EcalBarrel : EcalEndcap); + + // Save CpuRecHits for comparison with GpuRecHits + if (iSubdet == EcalBarrel) + EBCpuRecHits_ = &_cpuHits; + else + EECpuRecHits_ = &_cpuHits; + + unsigned nCpuHits(_cpuHits.size()); + meRecHitCpu.fill(getEcalDQMSetupObjects(), iSubdet, nCpuHits); + + for (EcalRecHitCollection::const_iterator cpuItr(_cpuHits.begin()); cpuItr != _cpuHits.end(); ++cpuItr) { + float cpuEnergy(cpuItr->energy()); + float cpuTime(cpuItr->time()); + uint32_t cpuFlags(cpuItr->flagsBits()); + + meRecHitCpuEnergy.fill(getEcalDQMSetupObjects(), iSubdet, cpuEnergy); + meRecHitCpuTime.fill(getEcalDQMSetupObjects(), iSubdet, cpuTime); + meRecHitCpuFlags.fill(getEcalDQMSetupObjects(), iSubdet, cpuFlags); + } + } + + void GpuTask::runOnGpuRecHits(EcalRecHitCollection const& _gpuHits, Collections _collection) { + MESet& meRecHitGpuCpu(MEs_.at("RecHitGpuCpu")); + MESet& meRecHitGpuCpuEnergy(MEs_.at("RecHitGpuCpuEnergy")); + MESet& meRecHitGpuCpuTime(MEs_.at("RecHitGpuCpuTime")); + MESet& meRecHitGpuCpuFlags(MEs_.at("RecHitGpuCpuFlags")); + + int iSubdet(_collection == kEBGpuRecHit ? EcalBarrel : EcalEndcap); + + // Get CpuRecHits saved from GpuTask::runOnCpuRecHits() for this event + // Note: _gpuHits is a collection and cpuHits is a pointer to a collection (for historical reasons) + EcalRecHitCollection const* cpuHits = (iSubdet == EcalBarrel) ? EBCpuRecHits_ : EECpuRecHits_; + if (!cpuHits) { + edm::LogWarning("EcalDQM") << "GpuTask: Did not find " << ((iSubdet == EcalBarrel) ? "EB" : "EE") + << "CpuRecHits Collection. Aborting runOnGpuRecHits\n"; + return; + } + + unsigned nGpuHits(_gpuHits.size()); + unsigned nCpuHits(cpuHits->size()); + + meRecHitGpuCpu.fill(getEcalDQMSetupObjects(), iSubdet, nGpuHits - nCpuHits); + + if (gpuOnlyPlots_) { + MESet& meRecHitGpu(MEs_.at("RecHitGpu")); + meRecHitGpu.fill(getEcalDQMSetupObjects(), iSubdet, nGpuHits); + } + + for (EcalRecHitCollection::const_iterator gpuItr(_gpuHits.begin()); gpuItr != _gpuHits.end(); ++gpuItr) { + // Find CpuRecHit with matching DetId + DetId gpuId(gpuItr->detid()); + EcalRecHitCollection::const_iterator cpuItr(cpuHits->find(gpuId)); + if (cpuItr == cpuHits->end()) { + edm::LogWarning("EcalDQM") << "GpuTask: Did not find GpuRecHit DetId " << gpuId.rawId() + << " in CPU collection\n"; + continue; + } + + float gpuEnergy(gpuItr->energy()); + float gpuTime(gpuItr->time()); + uint32_t gpuFlags(gpuItr->flagsBits()); + + float cpuEnergy(cpuItr->energy()); + float cpuTime(cpuItr->time()); + uint32_t cpuFlags(cpuItr->flagsBits()); + + meRecHitGpuCpuEnergy.fill(getEcalDQMSetupObjects(), iSubdet, gpuEnergy - cpuEnergy); + meRecHitGpuCpuTime.fill(getEcalDQMSetupObjects(), iSubdet, gpuTime - cpuTime); + meRecHitGpuCpuFlags.fill(getEcalDQMSetupObjects(), iSubdet, gpuFlags - cpuFlags); + + if (gpuOnlyPlots_) { + MESet& meRecHitGpuEnergy(MEs_.at("RecHitGpuEnergy")); + MESet& meRecHitGpuTime(MEs_.at("RecHitGpuTime")); + MESet& meRecHitGpuFlags(MEs_.at("RecHitGpuFlags")); + + meRecHitGpuEnergy.fill(getEcalDQMSetupObjects(), iSubdet, gpuEnergy); + meRecHitGpuTime.fill(getEcalDQMSetupObjects(), iSubdet, gpuTime); + meRecHitGpuFlags.fill(getEcalDQMSetupObjects(), iSubdet, gpuFlags); + } + } + } + + DEFINE_ECALDQM_WORKER(GpuTask); +} // namespace ecaldqm diff --git a/DQMOffline/Ecal/python/ecal_dqm_source_offline_cff.py b/DQMOffline/Ecal/python/ecal_dqm_source_offline_cff.py index ab077b460464c..9980f5d4b8a4c 100644 --- a/DQMOffline/Ecal/python/ecal_dqm_source_offline_cff.py +++ b/DQMOffline/Ecal/python/ecal_dqm_source_offline_cff.py @@ -1,6 +1,6 @@ import FWCore.ParameterSet.Config as cms -from DQM.EcalMonitorTasks.EcalMonitorTask_cfi import * +from DQM.EcalMonitorTasks.EcalMonitorTask_cff import * from DQM.EcalMonitorTasks.EcalMonitorTaskEcalOnly_cfi import * from DQM.EcalMonitorTasks.EcalFEDMonitor_cfi import * from DQMOffline.Ecal.ESRecoSummary_cfi import *