Create new ECAL DQM GpuTask to monitor and compare CPU and GPU generated ECAL RECO objects

Configuration/ProcessModifiers/python/gpuValidationEcal_cff.py

@@ -0,0 +1,5 @@
+import FWCore.ParameterSet.Config as cms
+
+# This modifier is for turning on gpu validation modules for ECAL DQM
+
+gpuValidationEcal =  cms.Modifier()

Configuration/ProcessModifiers/python/gpuValidation_cff.py

@@ -0,0 +1,11 @@
+import FWCore.ParameterSet.Config as cms
+
+from Configuration.ProcessModifiers.gpu_cff import *
+from Configuration.ProcessModifiers.gpuValidationEcal_cff import *
+
+# This modifier chain is for turning on DQM modules used for gpu validation
+
+gpuValidation =  cms.ModifierChain(
+    gpu,
+    gpuValidationEcal
+)

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
 

DQM/EcalMonitorTasks/interface/GpuTask.h

@@ -0,0 +1,104 @@
+#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 = default;
+
+    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 <typename DigiCollection>
+    void runOnCpuDigis(DigiCollection const&, Collections);
+    template <typename DigiCollection>
+    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<int> uncalibOOTAmps_;
+
+    EBDigiCollection const* EBCpuDigis_;
+    EEDigiCollection const* EECpuDigis_;
+
+    EcalUncalibratedRecHitCollection const* EBCpuUncalibRecHits_;
+    EcalUncalibratedRecHitCollection const* EECpuUncalibRecHits_;
+
+    EcalRecHitCollection const* EBCpuRecHits_;
+    EcalRecHitCollection const* EECpuRecHits_;
+  };
+
+  inline bool GpuTask::analyze(void const* collection_data, Collections collection) {
+    switch (collection) {
+      case kEBCpuDigi:
+        if (collection_data && runGpuTask_)
+          runOnCpuDigis(*static_cast<EBDigiCollection const*>(collection_data), collection);
+        return runGpuTask_;
+        break;
+      case kEECpuDigi:
+        if (collection_data && runGpuTask_)
+          runOnCpuDigis(*static_cast<EEDigiCollection const*>(collection_data), collection);
+        return runGpuTask_;
+        break;
+      case kEBGpuDigi:
+        if (collection_data && runGpuTask_)
+          runOnGpuDigis(*static_cast<EBDigiCollection const*>(collection_data), collection);
+        return runGpuTask_;
+        break;
+      case kEEGpuDigi:
+        if (collection_data && runGpuTask_)
+          runOnGpuDigis(*static_cast<EEDigiCollection const*>(collection_data), collection);
+        return runGpuTask_;
+        break;
+      case kEBCpuUncalibRecHit:
+      case kEECpuUncalibRecHit:
+        if (collection_data && runGpuTask_)
+          runOnCpuUncalibRecHits(*static_cast<EcalUncalibratedRecHitCollection const*>(collection_data), collection);
+        return runGpuTask_;
+        break;
+      case kEBGpuUncalibRecHit:
+      case kEEGpuUncalibRecHit:
+        if (collection_data && runGpuTask_)
+          runOnGpuUncalibRecHits(*static_cast<EcalUncalibratedRecHitCollection const*>(collection_data), collection);
+        return runGpuTask_;
+        break;
+      case kEBCpuRecHit:
+      case kEECpuRecHit:
+        if (collection_data && runGpuTask_)
+          runOnCpuRecHits(*static_cast<EcalRecHitCollection const*>(collection_data), collection);
+        return runGpuTask_;
+        break;
+      case kEBGpuRecHit:
+      case kEEGpuRecHit:
+        if (collection_data && runGpuTask_)
+          runOnGpuRecHits(*static_cast<EcalRecHitCollection const*>(collection_data), collection);
+        return runGpuTask_;
+        break;
+      default:
+        break;
+    }
+
+    return false;
+  }
+
+}  // namespace ecaldqm
+
+#endif

DQM/EcalMonitorTasks/plugins/EcalDQMonitorTask2.cc

@@ -90,10 +90,14 @@ void EcalDQMonitorTask::formSchedule(std::vector<ecaldqm::Collections> const& _p
         sch.first = &EcalDQMonitorTask::runOnCollection<EESrFlagCollection>;
         break;
       case ecaldqm::kEBDigi:
+      case ecaldqm::kEBCpuDigi:
+      case ecaldqm::kEBGpuDigi:
         collectionTokens_[*colItr] = edm::EDGetToken(consumes<EBDigiCollection>(tag));
         sch.first = &EcalDQMonitorTask::runOnCollection<EBDigiCollection>;
         break;
       case ecaldqm::kEEDigi:
+      case ecaldqm::kEECpuDigi:
+      case ecaldqm::kEEGpuDigi:
         collectionTokens_[*colItr] = edm::EDGetToken(consumes<EEDigiCollection>(tag));
         sch.first = &EcalDQMonitorTask::runOnCollection<EEDigiCollection>;
         break;
@@ -112,13 +116,21 @@ void EcalDQMonitorTask::formSchedule(std::vector<ecaldqm::Collections> 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<EcalUncalibratedRecHitCollection>(tag));
         sch.first = &EcalDQMonitorTask::runOnCollection<EcalUncalibratedRecHitCollection>;
         break;
       case ecaldqm::kEBRecHit:
       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<EcalRecHitCollection>(tag));
         sch.first = &EcalDQMonitorTask::runOnCollection<EcalRecHitCollection>;
         break;

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")
 )

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.gpuValidationEcal_cff import gpuValidationEcal
+from DQM.EcalMonitorTasks.ecalGpuTask_cfi import ecalGpuTask
+
+gpuValidationEcal.toModify(ecalGpuTask.params, runGpuTask = cms.untracked.bool(True))
+gpuValidationEcal.toModify(ecalMonitorTask.workers, func = lambda workers: workers.append("GpuTask"))
+gpuValidationEcal.toModify(ecalMonitorTask, workerParameters = dict(GpuTask = ecalGpuTask))