Remove noisy missing collection warnings coming from EcalDQMonitorTask

DQM/EcalMonitorTasks/interface/EcalDQMonitorTask.h

@@ -46,7 +46,16 @@ class EcalDQMonitorTask : public DQMOneEDAnalyzer<edm::LuminosityBlockCache<ecal
 
   edm::EDGetToken collectionTokens_[ecaldqm::nCollections];           // list of EDGetTokens
   std::vector<std::pair<Processor, ecaldqm::Collections>> schedule_;  // schedule of collections to run
-  bool allowMissingCollections_;                                      // when true, skip missing collections silently
+
+  std::vector<std::string> skipCollections_;  // list of collections to explicitly remove from schedule
+                                              // note: skipping a collection here will result in
+                                              // EcalDQMonitorTask not consuming it, which may lead the
+                                              // module producing the collection to not run at all
+
+  bool allowMissingCollections_;  // when true (default), skip missing collections and log as warning
+                                  // note: collections skipped by the parameter skipCollections will
+                                  // bypass this check and not issue warnings
+
   int processedEvents_;
 
   /* TASK TIME PROFILING */

DQM/EcalMonitorTasks/interface/GpuTask.h

@@ -61,46 +61,46 @@ namespace ecaldqm {
       case kEBCpuDigi:
         if (collection_data && runGpuTask_ && enableDigi_)
           runOnCpuDigis(*static_cast<EBDigiCollection const*>(collection_data), collection);
-        return runGpuTask_;
+        return enableDigi_;
         break;
       case kEECpuDigi:
         if (collection_data && runGpuTask_ && enableDigi_)
           runOnCpuDigis(*static_cast<EEDigiCollection const*>(collection_data), collection);
-        return runGpuTask_;
+        return enableDigi_;
         break;
       case kEBGpuDigi:
         if (collection_data && runGpuTask_ && enableDigi_)
           runOnGpuDigis(*static_cast<EBDigiCollection const*>(collection_data), collection);
-        return runGpuTask_;
+        return enableDigi_;
         break;
       case kEEGpuDigi:
         if (collection_data && runGpuTask_ && enableDigi_)
           runOnGpuDigis(*static_cast<EEDigiCollection const*>(collection_data), collection);
-        return runGpuTask_;
+        return enableDigi_;
         break;
       case kEBCpuUncalibRecHit:
       case kEECpuUncalibRecHit:
         if (collection_data && runGpuTask_ && enableUncalib_)
           runOnCpuUncalibRecHits(*static_cast<EcalUncalibratedRecHitCollection const*>(collection_data), collection);
-        return runGpuTask_;
+        return enableUncalib_;
         break;
       case kEBGpuUncalibRecHit:
       case kEEGpuUncalibRecHit:
         if (collection_data && runGpuTask_ && enableUncalib_)
           runOnGpuUncalibRecHits(*static_cast<EcalUncalibratedRecHitCollection const*>(collection_data), collection);
-        return runGpuTask_;
+        return enableUncalib_;
         break;
       case kEBCpuRecHit:
       case kEECpuRecHit:
         if (collection_data && runGpuTask_ && enableRecHit_)
           runOnCpuRecHits(*static_cast<EcalRecHitCollection const*>(collection_data), collection);
-        return runGpuTask_;
+        return enableRecHit_;
         break;
       case kEBGpuRecHit:
       case kEEGpuRecHit:
         if (collection_data && runGpuTask_ && enableRecHit_)
           runOnGpuRecHits(*static_cast<EcalRecHitCollection const*>(collection_data), collection);
-        return runGpuTask_;
+        return enableRecHit_;
         break;
       default:
         break;

DQM/EcalMonitorTasks/plugins/EcalDQMonitorTask.cc

@@ -28,6 +28,7 @@ EcalDQMonitorTask::EcalDQMonitorTask(edm::ParameterSet const& _ps)
     : DQMOneEDAnalyzer<edm::LuminosityBlockCache<ecaldqm::EcalLSCache>>(),
       ecaldqm::EcalDQMonitor(_ps),
       schedule_(),
+      skipCollections_(_ps.getUntrackedParameter<std::vector<std::string>>("skipCollections")),
       allowMissingCollections_(_ps.getUntrackedParameter<bool>("allowMissingCollections")),
       processedEvents_(0),
       lastResetTime_(0),
@@ -92,6 +93,7 @@ void EcalDQMonitorTask::fillDescriptions(edm::ConfigurationDescriptions& _descs)
   collectionTags.addWildcardUntracked<edm::InputTag>("*");
   desc.add("collectionTags", collectionTags);
 
+  desc.addUntracked<std::vector<std::string>>("skipCollections", std::vector<std::string>());
   desc.addUntracked<bool>("allowMissingCollections", true);
   desc.addUntracked<double>("resetInterval", 0.);
 
@@ -158,8 +160,15 @@ void EcalDQMonitorTask::analyze(edm::Event const& _evt, edm::EventSetup const& _
 
   std::set<ecaldqm::DQWorker*> enabledTasks;
 
+  bool eventTypeFiltering(false);
   edm::Handle<EcalRawDataCollection> dcchsHndl;
-  if (_evt.getByToken(collectionTokens_[ecaldqm::kEcalRawData], dcchsHndl)) {
+
+  if (std::find(skipCollections_.begin(), skipCollections_.end(), "EcalRawData") != skipCollections_.end()) {
+    if (verbosity_ > 2)
+      edm::LogInfo("EcalDQM") << "EcalRawDataCollection is being skipped. No event-type filtering will be applied";
+
+  } else if (_evt.getByToken(collectionTokens_[ecaldqm::kEcalRawData], dcchsHndl)) {
+    eventTypeFiltering = true;
     // determine event type (called run type in DCCHeader for some reason) for each FED
     std::stringstream ss;
     if (verbosity_ > 2)
@@ -192,9 +201,11 @@ void EcalDQMonitorTask::analyze(edm::Event const& _evt, edm::EventSetup const& _
       return;
   } else {
     edm::LogWarning("EcalDQM") << "EcalRawDataCollection does not exist. No event-type filtering will be applied";
-    executeOnWorkers_([&enabledTasks](ecaldqm::DQWorker* worker) { enabledTasks.insert(worker); }, "");
   }
 
+  if (!eventTypeFiltering)
+    executeOnWorkers_([&enabledTasks](ecaldqm::DQWorker* worker) { enabledTasks.insert(worker); }, "");
+
   ++processedEvents_;
 
   // start event processing

DQM/EcalMonitorTasks/plugins/EcalDQMonitorTask2.cc

@@ -45,12 +45,34 @@ void EcalDQMonitorTask::runOnCollection(edm::Event const& _evt,
 
 void EcalDQMonitorTask::formSchedule(std::vector<ecaldqm::Collections> const& _preSchedule,
                                      edm::ParameterSet const& _tagPSet) {
+  std::vector<ecaldqm::Collections> collectionsToSkip;
+  for (const auto& skipColName : skipCollections_) {
+    for (unsigned iCol = 0; iCol <= ecaldqm::nCollections; iCol++) {
+      if (iCol == ecaldqm::nCollections)
+        throw cms::Exception("InvalidConfiguration")
+            << moduleName_ << "::formSchedule: Collection name " << skipColName << " in skipCollections does not exist";
+      if (skipColName == ecaldqm::collectionName[iCol]) {
+        collectionsToSkip.push_back(ecaldqm::Collections(iCol));
+        break;
+      }
+    }
+  }
+
   for (std::vector<ecaldqm::Collections>::const_iterator colItr(_preSchedule.begin()); colItr != _preSchedule.end();
        ++colItr) {
     std::pair<Processor, ecaldqm::Collections> sch;
 
     edm::InputTag tag(_tagPSet.getUntrackedParameter<edm::InputTag>(ecaldqm::collectionName[*colItr]));
 
+    auto skipItr = std::find(collectionsToSkip.begin(), collectionsToSkip.end(), *colItr);
+    if (skipItr != collectionsToSkip.end()) {
+      if (verbosity_ > 0)
+        edm::LogInfo("EcalDQM") << moduleName_ << ": Skipping collection " << ecaldqm::collectionName[*colItr]
+                                << " and removing from schedule";
+      collectionsToSkip.erase(skipItr);
+      continue;
+    }
+
     switch (*colItr) {
       case ecaldqm::kSource:
         collectionTokens_[*colItr] = edm::EDGetToken(consumes<FEDRawDataCollection>(tag));
@@ -152,4 +174,8 @@ void EcalDQMonitorTask::formSchedule(std::vector<ecaldqm::Collections> const& _p
 
     schedule_.push_back(sch);
   }
+  for (const auto& colNotSkipped : collectionsToSkip)
+    edm::LogWarning("EcalDQM") << moduleName_
+                               << "::formSchedule: Collection: " << ecaldqm::collectionName[colNotSkipped]
+                               << " is not in the schedule but was listed to be skipped";
 }

DQM/EcalMonitorTasks/python/EcalMonitorTask_cfi.py

@@ -48,6 +48,7 @@
     ),
     commonParameters = ecalCommonParams,
     collectionTags = ecalDQMCollectionTags,
+    skipCollections = cms.untracked.vstring(),
     allowMissingCollections = cms.untracked.bool(True),
     verbosity = cms.untracked.int32(0),
     resetInterval = cms.untracked.double(2.)

DQM/EcalMonitorTasks/python/ecalGpuTask_cfi.py

@@ -5,12 +5,13 @@
 
 ecalGpuTask = cms.untracked.PSet(
     params = cms.untracked.PSet(
+        # ecalGpuTask must be explicitly turned on when using
         runGpuTask = cms.untracked.bool(False),
-
-        # Default plots for each object are 1D CPU distributions and 1D GPU-CPU diff
         enableDigi = cms.untracked.bool(True),
         enableUncalib = cms.untracked.bool(True),
-        enableRecHit = cms.untracked.bool(True),
+
+        # GPU rechits currently unavailable; last edited Sep 2023
+        enableRecHit = cms.untracked.bool(False),
 
         # 1D flags enable distributions of GPU values
         # 2D flags enable 2D comparison maps

DQM/EcalMonitorTasks/src/GpuTask.cc

@@ -31,13 +31,17 @@ namespace ecaldqm {
 
   void GpuTask::addDependencies(DependencySet& dependencies) {
     // Ensure we run on CPU objects before GPU objects
-    if (runGpuTask_) {
+    if (enableDigi_) {
       dependencies.push_back(Dependency(kEBGpuDigi, kEBCpuDigi));
       dependencies.push_back(Dependency(kEEGpuDigi, kEECpuDigi));
+    }
 
+    if (enableUncalib_) {
       dependencies.push_back(Dependency(kEBGpuUncalibRecHit, kEBCpuUncalibRecHit));
       dependencies.push_back(Dependency(kEEGpuUncalibRecHit, kEECpuUncalibRecHit));
+    }
 
+    if (enableRecHit_) {
       dependencies.push_back(Dependency(kEBGpuRecHit, kEBCpuRecHit));
       dependencies.push_back(Dependency(kEEGpuRecHit, kEECpuRecHit));
     }

DQMOffline/Ecal/python/ecal_dqm_source_offline_cff.py

@@ -31,3 +31,5 @@
 )
 
 ecalMonitorTask.workerParameters.TrigPrimTask.params.runOnEmul = False
+ecalMonitorTaskEcalOnly.workerParameters.TrigPrimTask.params.runOnEmul = False
+ecalMonitorTaskEcalOnly.workerParameters.RecoSummaryTask.params.fillRecoFlagReduced = False