[QC-885] Modify reference check to also accept a TH1 …

Framework/include/QualityControl/Check.h

@@ -19,8 +19,10 @@
 // O2
 #include <Framework/DataProcessorSpec.h>
 // QC
+#include "QualityControl/DatabaseInterface.h"
 #include "QualityControl/QualityObject.h"
 #include "QualityControl/CheckConfig.h"
+#include "QualityControl/CheckInterface.h"
 
 namespace o2::quality_control::core
 {
@@ -92,6 +94,11 @@ class Check
   static CheckConfig extractConfig(const core::CommonSpec&, const CheckSpec&);
   static framework::OutputSpec createOutputSpec(const std::string& detector, const std::string& checkName);
 
+  void setDatabase(std::shared_ptr<o2::quality_control::repository::DatabaseInterface> database)
+  {
+    mCheckInterface->setDatabase(database);
+  }
+
  private:
   void beautify(std::map<std::string, std::shared_ptr<core::MonitorObject>>& moMap, const core::Quality& quality);
 

Framework/include/QualityControl/CheckInterface.h

@@ -17,6 +17,7 @@
 #ifndef QC_CHECKER_CHECKINTERFACE_H
 #define QC_CHECKER_CHECKINTERFACE_H
 
+#include "QualityControl/DatabaseInterface.h"
 #include "QualityControl/Quality.h"
 #include "QualityControl/UserCodeInterface.h"
 #include "QualityControl/Activity.h"
@@ -82,10 +83,22 @@ class CheckInterface : public core::UserCodeInterface
   virtual void startOfActivity(const core::Activity& activity); // not fully abstract because we don't want to change all the existing subclasses
   virtual void endOfActivity(const core::Activity& activity);   // not fully abstract because we don't want to change all the existing subclasses
 
+  void setDatabase(std::shared_ptr<o2::quality_control::repository::DatabaseInterface> database)
+  {
+    mDatabase = database;
+  }
+
  protected:
   /// \brief Called each time mCustomParameters is updated.
   virtual void configure() override;
 
+  /// \brief Retrieve a reference plot at the provided path, matching the give activity and for the provided run.
+  /// the activity is the current one, while the run number is the reference run.
+  std::shared_ptr<MonitorObject> retrieveReference(std::string path, int referenceRun, Activity activity);
+
+ private:
+  std::shared_ptr<o2::quality_control::repository::DatabaseInterface> mDatabase;
+
   ClassDef(CheckInterface, 6)
 };
 

Framework/include/QualityControl/ReferenceUtils.h

@@ -0,0 +1,58 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+///
+/// \file   ReferenceComparatorUtils.h
+/// \author Andrea Ferrero and Barthelemy von Haller
+///
+
+#ifndef QUALITYCONTROL_ReferenceComparatorUtils_H
+#define QUALITYCONTROL_ReferenceComparatorUtils_H
+
+#include <memory>
+#include "QualityControl/MonitorObject.h"
+#include "QualityControl/DatabaseInterface.h"
+#include "QualityControl/Activity.h"
+#include "QualityControl/ActivityHelpers.h"
+#include "QualityControl/QcInfoLogger.h"
+#include "QualityControl/RepoPathUtils.h"
+
+namespace o2::quality_control_modules::common
+{
+
+//_________________________________________________________________________________________
+//
+// Get the reference plot for a given MonitorObject path
+
+static std::shared_ptr<quality_control::core::MonitorObject> getReferencePlot(quality_control::repository::DatabaseInterface* qcdb, std::string& fullPath, uint32_t referenceRun, quality_control::core::Activity activity)
+{
+  uint64_t timeStamp = 0;
+  activity.mId = referenceRun;
+  const auto filterMetadata = quality_control::core::activity_helpers::asDatabaseMetadata(activity, false);
+  const auto objectValidity = qcdb->getLatestObjectValidity(activity.mProvenance + "/" + fullPath, filterMetadata);
+  if (objectValidity.isValid()) {
+    timeStamp = objectValidity.getMax() - 1;
+  } else {
+    ILOG(Warning, Devel) << "Could not find the object '" << fullPath << "' for run " << activity.mId << ENDM;
+    return nullptr;
+  }
+
+  std::string path;
+  std::string name;
+  if (!o2::quality_control::core::RepoPathUtils::splitObjectPath(fullPath, path, name)) {
+    return nullptr;
+  }
+  return qcdb->retrieveMO(path, name, timeStamp, activity);
+}
+
+} // namespace o2::quality_control_modules::common
+
+#endif // QUALITYCONTROL_ReferenceComparatorUtils_H

Framework/include/QualityControl/RepoPathUtils.h

@@ -128,6 +128,19 @@ class RepoPathUtils
 
   static constexpr auto allowedProvenancesMessage = R"(Allowed provenances are "qc" (real data processed synchronously), "qc_async" (real data processed asynchronously) and "qc_mc" (simulated data).)";
   static bool isProvenanceAllowed(const std::string& provenance);
+
+  static bool splitObjectPath(const std::string& fullPath, std::string& path, std::string& name)
+  {
+    std::string delimiter = "/";
+    std::string det;
+    size_t pos = fullPath.rfind(delimiter);
+    if (pos == std::string::npos) {
+      return false;
+    }
+    path = fullPath.substr(0, pos);
+    name = fullPath.substr(pos + 1);
+    return true;
+  }
 };
 } // namespace o2::quality_control::core
 

Framework/src/CheckInterface.cxx

@@ -15,6 +15,7 @@
 ///
 
 #include "QualityControl/CheckInterface.h"
+#include "QualityControl/ReferenceUtils.h"
 #include "QualityControl/MonitorObject.h"
 
 #include <TClass.h>
@@ -59,4 +60,9 @@ void CheckInterface::endOfActivity(const Activity& activity)
   // noop, override it if you want.
 }
 
+shared_ptr<MonitorObject> CheckInterface::retrieveReference(std::string path, int referenceRun, Activity activity)
+{
+  return quality_control_modules::common::getReferencePlot(mDatabase.get(), path, referenceRun, activity);
+}
+
 } // namespace o2::quality_control::checker

Framework/src/CheckRunner.cxx

@@ -231,6 +231,7 @@ void CheckRunner::init(framework::InitContext& iCtx)
     updatePolicyManager.reset();
     for (auto& [checkName, check] : mChecks) {
       check.init();
+      check.setDatabase(mDatabase);
       updatePolicyManager.addPolicy(check.getName(), check.getUpdatePolicyType(), check.getObjectsNames(), check.getAllObjectsOption(), false);
     }
   } catch (...) {

Modules/Common/include/Common/ReferenceComparatorCheck.h

@@ -49,9 +49,12 @@ class ReferenceComparatorCheck : public o2::quality_control::checker::CheckInter
   void endOfActivity(const Activity& activity) override;
 
  private:
+  Quality getSinglePlotQuality(std::shared_ptr<MonitorObject> mo, std::string& message);
+
   std::unique_ptr<ObjectComparatorInterface> mComparator;
   std::map<std::string, Quality> mQualityFlags;
   std::map<std::string, std::shared_ptr<TPaveText>> mQualityLabels;
+  quality_control::core::Activity mActivity;
 };
 
 } // namespace o2::quality_control_modules::common

Modules/Common/include/Common/ReferenceComparatorTask.h

@@ -19,14 +19,11 @@
 #define QUALITYCONTROL_REFERENCECOMPARATORTASK_H
 
 #include "Common/ReferenceComparatorTaskConfig.h"
-#include "Common/BigScreenCanvas.h"
 #include "QualityControl/PostProcessingInterface.h"
 #include "QualityControl/DatabaseInterface.h"
-#include "QualityControl/Quality.h"
 #include <TH1.h>
 #include <TPad.h>
 #include <TCanvas.h>
-#include <TPaveText.h>
 #include <TText.h>
 #include <string>
 #include <map>
@@ -63,8 +60,6 @@ class ReferenceComparatorTask : public quality_control::postprocessing::PostProc
   };
 
  private:
-  std::shared_ptr<o2::quality_control::core::MonitorObject> getReferencePlot(o2::quality_control::repository::DatabaseInterface& qcdb, std::string fullPath, o2::quality_control::core::Activity activity);
-
   int mReferenceRun{ 0 };
   int mNotOlderThan{ 120 };
 

Modules/Common/src/ReferenceComparatorCheck.cxx

@@ -15,8 +15,8 @@
 ///
 
 #include "Common/ReferenceComparatorCheck.h"
+#include "QualityControl/ReferenceUtils.h"
 #include "Common/TH1Ratio.h"
-#include "Common/TH2Ratio.h"
 #include "QualityControl/MonitorObject.h"
 #include "QualityControl/Quality.h"
 #include "QualityControl/QcInfoLogger.h"
@@ -25,6 +25,8 @@
 #include <DataFormatsQualityControl/FlagType.h>
 #include <DataFormatsQualityControl/FlagTypeFactory.h>
 
+#include <Framework/ServiceRegistryRef.h>
+
 // ROOT
 #include <TH1.h>
 #include <TCanvas.h>
@@ -54,6 +56,8 @@ void ReferenceComparatorCheck::startOfActivity(const Activity& activity)
   if (mComparator) {
     mComparator->setThreshold(threshold);
   }
+
+  mActivity = activity;
 }
 
 void ReferenceComparatorCheck::endOfActivity(const Activity& activity)
@@ -129,6 +133,32 @@ static Quality compare(TCanvas* canvas, ObjectComparatorInterface* comparator, s
   return comparator->compare(plots.first, plots.second, message);
 }
 
+Quality ReferenceComparatorCheck::getSinglePlotQuality(std::shared_ptr<MonitorObject> mo, std::string& message)
+{
+  // retrieve the reference plot and compare
+  auto* th1 = dynamic_cast<TH1*>(mo->getObject());
+  auto referenceRun = std::stoi(mCustomParameters.atOptional("referenceRun").value_or("0"));
+
+  // get path of mo and ref (we have to remove the provenance)
+  string path = mo->getPath();
+  size_t pos = path.find('/');
+  if (pos != std::string::npos) {
+    path = path.substr(pos + 1);
+  }
+
+  auto referencePlot = retrieveReference(path, referenceRun, mActivity);
+  if (!referencePlot) {
+    message = "The reference plot is empty";
+    return Quality::Null;
+  }
+  auto* ref = dynamic_cast<TH1*>(referencePlot->getObject());
+  if (!ref) {
+    message = "The reference plot is not a TH1";
+    return Quality::Null;
+  }
+  return mComparator.get()->compare(th1, ref, message);
+}
+
 //_________________________________________________________________________________________
 //
 // Loop over all the input MOs and compare each of them with the corresponding MO from the reference run
@@ -139,17 +169,22 @@ Quality ReferenceComparatorCheck::check(std::map<std::string, std::shared_ptr<Mo
   Quality result = Quality::Good;
   for (auto& [key, mo] : *moMap) {
     auto moName = mo->getName();
+    Quality quality;
+    std::string message;
 
-    auto* canvas = dynamic_cast<TCanvas*>(mo->getObject());
-    if (!canvas) {
+    // run the comparison algorithm
+    if (mo->getObject()->IsA() == TClass::GetClass<TCanvas>()) {
+      // We got a canvas. It contains the plot and its reference.
+      auto* canvas = dynamic_cast<TCanvas*>(mo->getObject());
+      quality = compare(canvas, mComparator.get(), message);
+    } else if (mo->getObject()->InheritsFrom(TH1::Class())) {
+      // We got a plot, we have to find the reference before calling the comparator
+      quality = getSinglePlotQuality(mo, message);
+    } else {
+      ILOG(Warning, Ops) << "mo is not a TCanvas or a TH1" << ENDM;
       continue;
     }
 
-    // run the comparison algorithm
-    Quality quality;
-    std::string message;
-    quality = compare(canvas, mComparator.get(), message);
-
     // update the overall quality
     if (quality.isWorseThan(result)) {
       result.set(quality);
@@ -191,6 +226,23 @@ static int getQualityColor(const Quality& q)
   return 0;
 }
 
+static void updateQualityLabel(TPaveText* label, const Quality& quality)
+{
+  // draw the quality label with the text color corresponding to the quality level
+  label->SetTextColor(getQualityColor(quality));
+  label->AddText(quality.getName().c_str());
+
+  // add the first flag below the quality label, or an empty line if no flags are set
+  auto flags = quality.getFlags();
+  std::string message = flags.empty() ? "" : flags.front().second;
+  auto pos = message.find(" ");
+  if (pos != std::string::npos) {
+    message.erase(0, pos + 1);
+  }
+  auto* text = label->AddText(message.c_str());
+  text->SetTextColor(kGray + 1);
+}
+
 // Write the quality level and flags in the existing PaveText inside the canvas
 static void setQualityLabel(TCanvas* canvas, const Quality& quality)
 {
@@ -209,43 +261,34 @@ static void setQualityLabel(TCanvas* canvas, const Quality& quality)
       continue;
     }
 
-    // draw the quality label with the text color corresponding to the quality level
-    label->SetTextColor(getQualityColor(quality));
-    label->AddText(quality.getName().c_str());
-
-    // add the first flag below the quality label, or an empty line if no flags are set
-    auto flags = quality.getFlags();
-    std::string message = flags.empty() ? "" : flags.front().second;
-    auto pos = message.find(" ");
-    if (pos != std::string::npos) {
-      message.erase(0, pos + 1);
-    }
-    auto* text = label->AddText(message.c_str());
-    text->SetTextColor(kGray + 1);
-
+    updateQualityLabel(label, quality);
     break;
   }
 }
 
 void ReferenceComparatorCheck::beautify(std::shared_ptr<MonitorObject> mo, Quality checkResult)
 {
-  auto* canvas = dynamic_cast<TCanvas*>(mo->getObject());
-  if (!canvas) {
-    return;
-  }
-
   // get the quality associated to the current MO
   auto moName = mo->getName();
   auto quality = mQualityFlags[moName];
 
-  // retrieve the reference plot from the canvas and set the line color according to the quality
-  auto plots = getPlotsFromCanvas(canvas);
-  if (plots.second) {
-    plots.second->SetLineColor(getQualityColor(quality));
-  }
+  auto* canvas = dynamic_cast<TCanvas*>(mo->getObject());
+  if (canvas) {
+    // retrieve the reference plot from the canvas and set the line color according to the quality
+    auto plots = getPlotsFromCanvas(canvas);
+    if (plots.second) {
+      plots.second->SetLineColor(getQualityColor(quality));
+    }
 
-  // draw the quality label on the plot
-  setQualityLabel(canvas, quality);
+    // draw the quality label on the plot
+    setQualityLabel(canvas, quality);
+  }
+  auto* th1 = dynamic_cast<TH1*>(mo->getObject());
+  if (th1) {
+    auto* qualityLabel = new TPaveText(0.75, 0.65, 0.98, 0.75, "brNDC");
+    updateQualityLabel(qualityLabel, quality);
+    th1->GetListOfFunctions()->Add(qualityLabel);
+  }
 }
 
 } // namespace o2::quality_control_modules::common