[QC-1298] first version of Data

Author: Michal Tichák

Framework/CMakeLists.txt

@@ -136,7 +136,9 @@ add_library(O2QualityControl
   src/ReductorHelpers.cxx
   src/KafkaPoller.cxx
   src/FlagHelpers.cxx
-  src/ObjectMetadataHelpers.cxx)
+  src/ObjectMetadataHelpers.cxx
+  src/Data.cxx
+)
 
 target_include_directories(
   O2QualityControl
@@ -289,6 +291,7 @@ add_executable(o2-qc-test-core
                test/testKafkaTests.cxx
                test/testFlagHelpers.cxx
                test/testQualitiesToFlagCollectionConverter.cxx
+               test/testData.cxx
 )
 set_property(TARGET o2-qc-test-core
              PROPERTY RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/tests)

Framework/include/QualityControl/CheckInterface.h

@@ -26,7 +26,9 @@ namespace o2::quality_control::core
 {
 class Activity;
 class MonitorObject;
-}
+class Data;
+
+} // namespace o2::quality_control::core
 
 using namespace o2::quality_control::core;
 
@@ -48,7 +50,13 @@ class CheckInterface : public core::UserCodeInterface
   ///
   /// @param moMap A map of the the MonitorObjects to check and their full names (i.e. <task_name>/<mo name>) as keys.
   /// @return The quality associated with these objects.
-  virtual core::Quality check(std::map<std::string, std::shared_ptr<core::MonitorObject>>* moMap) = 0;
+  virtual core::Quality check(std::map<std::string, std::shared_ptr<core::MonitorObject>>* moMap);
+
+  /// \brief Returns the quality associated with these objects.
+  ///
+  /// @param data An object with any type of data possible accesible via full names (i.e. <task_name>/<mo name> in case of MOs) as keys.
+  /// @return The quality associated with these objects.
+  virtual core::Quality check(const core::Data& data);
 
   /// \brief Modify the aspect of the plot.
   ///

Framework/include/QualityControl/Data.h

@@ -0,0 +1,86 @@
+// Copyright 2025 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   Data.h
+/// \author Michal Tichak
+///
+
+#include <any>
+#include <concepts>
+#include <iostream>
+#include <map>
+#include <memory>
+#include <optional>
+#include <string>
+#include <vector>
+#include <typeinfo>
+
+namespace o2::quality_control::core
+{
+
+class MonitorObject;
+
+class Data
+{
+ public:
+  Data() = default;
+  Data(const std::map<std::string, std::shared_ptr<MonitorObject>>& moMap);
+
+  template <typename Result>
+  std::optional<Result> get(std::string_view key)
+  {
+    if (const auto foundIt = mObjects.find(key); foundIt != mObjects.end()) {
+      if (auto* casted = std::any_cast<Result>(&foundIt->second); casted != nullptr) {
+        return { *casted };
+      }
+    }
+    return std::nullopt;
+  }
+
+  template <typename StoreType>
+  void insert(std::string_view key, const StoreType& value)
+  {
+    // std::cout << "inserting value: " << value << ", of type: " << typeid(StoreType).name() << "\n";
+    mObjects.insert({ std::string{ key }, value });
+  }
+
+  template <typename Type>
+  std::vector<Type> getAllOfType() const
+  {
+    std::vector<Type> result;
+    for (const auto& [_, object] : mObjects) {
+      if (auto* casted = std::any_cast<Type>(&object); casted != nullptr) {
+        result.push_back(*casted);
+      }
+    }
+    return result;
+  }
+
+  template <typename Type, std::predicate<Type> Pred>
+  std::vector<Type> getAllOfTypeIf(Pred filter) const
+  {
+    std::vector<Type> result;
+    for (const auto& [_, object] : mObjects) {
+      if (auto* casted = std::any_cast<Type>(&object); casted != nullptr) {
+        if (filter(*casted)) {
+          result.push_back(*casted);
+        }
+      }
+    }
+    return result;
+  }
+
+ private:
+  std::map<std::string, std::any, std::less<>> mObjects;
+};
+
+} // namespace o2::quality_control::core

Framework/src/CheckInterface.cxx

@@ -17,6 +17,7 @@
 #include "QualityControl/CheckInterface.h"
 #include "QualityControl/ReferenceUtils.h"
 #include "QualityControl/MonitorObject.h"
+#include "QualityControl/Data.h"
 
 #include <TClass.h>
 
@@ -26,6 +27,17 @@ using namespace o2::quality_control::core;
 namespace o2::quality_control::checker
 {
 
+core::Quality CheckInterface::check(std::map<std::string, std::shared_ptr<core::MonitorObject>>* moMap)
+{
+  Data data(*moMap);
+  return check(data);
+};
+
+core::Quality CheckInterface::check(const core::Data& data)
+{
+  return core::Quality{};
+};
+
 std::string CheckInterface::getAcceptedType() { return "TObject"; }
 
 bool CheckInterface::isObjectCheckable(const std::shared_ptr<MonitorObject> mo)

Framework/src/Data.cxx

@@ -0,0 +1,27 @@
+// Copyright 2025 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   Data.h
+/// \author Michal Tichak
+///
+
+#include "QualityControl/Data.h"
+
+namespace o2::quality_control::core
+{
+Data::Data(const std::map<std::string, std::shared_ptr<MonitorObject>>& moMap)
+{
+  for (const auto& [key, mo] : moMap) {
+    insert(key, mo);
+  }
+}
+} // namespace o2::quality_control::core

Framework/test/testData.cxx

@@ -0,0 +1,79 @@
+// Copyright 2025 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    testData.cxx
+/// \author  Michal Tichak
+///
+
+#include <catch_amalgamated.hpp>
+#include "QualityControl/Data.h"
+
+using namespace o2::quality_control::core;
+
+TEST_CASE("Data constructor", "[Data]")
+{
+  REQUIRE_NOTHROW([]() { Data data{}; });
+}
+
+TEST_CASE("Data insert and get", "[Data]")
+{
+  Data data;
+  data.insert("test", 1);
+  auto valueStr = data.get<std::string>("test");
+  REQUIRE(!valueStr.has_value());
+  auto valueInt = data.get<int>("test");
+  REQUIRE(valueInt.has_value());
+  REQUIRE(valueInt.value() == 1);
+}
+
+TEST_CASE("Data getAllOfType", "[Data]")
+{
+  Data data;
+  data.insert("int1", 1);
+  data.insert("string", std::string{ "1" });
+  data.insert("int2", 1);
+  data.insert("long", 1l);
+
+  const auto ints = data.getAllOfType<int>();
+  REQUIRE(ints.size() == 2);
+  REQUIRE(ints[0] == 1);
+  REQUIRE(ints[1] == 1);
+
+  const auto strings = data.getAllOfType<std::string>();
+  REQUIRE(strings.size() == 1);
+  REQUIRE(strings[0] == "1");
+
+  const auto longs = data.getAllOfType<long>();
+  REQUIRE(longs.size() == 1);
+  REQUIRE(longs[0] == 1u);
+
+  struct nonexistent {
+  };
+
+  const auto nonexistens = data.getAllOfType<nonexistent>();
+  REQUIRE(nonexistens.empty());
+}
+
+template <typename T>
+struct named {
+  std::string name;
+  T val;
+};
+
+TEST_CASE("Data getAllOfTypeIf", "[Data]")
+{
+  Data data;
+  data.insert("1", named{ "1", 4 });
+  data.insert("1", named{ "1", 4l });
+  auto filtered = data.getAllOfTypeIf<named<int>>([](const auto& val) { return val.name == "1"; });
+  REQUIRE(filtered.size() == 1);
+}

Modules/Skeleton/include/Skeleton/SkeletonCheck.h

@@ -35,6 +35,7 @@ class SkeletonCheck : public o2::quality_control::checker::CheckInterface
   // Override interface
   void configure() override;
   Quality check(std::map<std::string, std::shared_ptr<MonitorObject>>* moMap) override;
+  Quality check(const quality_control::core::Data& data) override;
   void beautify(std::shared_ptr<MonitorObject> mo, Quality checkResult = Quality::Null) override;
   std::string getAcceptedType() override;
   void reset() override;

Modules/Skeleton/src/SkeletonCheck.cxx

@@ -18,11 +18,14 @@
 #include "QualityControl/MonitorObject.h"
 #include "QualityControl/Quality.h"
 #include "QualityControl/QcInfoLogger.h"
+#include "Skeleton/SkeletonTask.h"
+#include "QualityControl/Data.h"
 // ROOT
 #include <TH1.h>
 
 #include <DataFormatsQualityControl/FlagType.h>
 #include <DataFormatsQualityControl/FlagTypeFactory.h>
+#include <memory>
 
 using namespace std;
 using namespace o2::quality_control;
@@ -40,6 +43,12 @@ void SkeletonCheck::configure()
 }
 
 Quality SkeletonCheck::check(std::map<std::string, std::shared_ptr<MonitorObject>>* moMap)
+{
+  Data data{ *moMap };
+  return check(data);
+}
+
+Quality SkeletonCheck::check(const quality_control::core::Data& data)
 {
   // THUS FUNCTION BODY IS AN EXAMPLE. PLEASE REMOVE EVERYTHING YOU DO NOT NEED.
   Quality result = Quality::Null;
@@ -49,35 +58,35 @@ Quality SkeletonCheck::check(std::map<std::string, std::shared_ptr<MonitorObject
   // and you can get your custom parameters:
   ILOG(Debug, Devel) << "custom param physics.pp.myOwnKey1 : " << mCustomParameters.atOrDefaultValue("myOwnKey1", "default_value", "physics", "pp") << ENDM;
 
-  // This is an example of accessing the histogram 'example' created by SkeletonTask
-  for (auto& [moName, mo] : *moMap) {
-    if (mo->getName() == "example") {
-      auto* h = dynamic_cast<TH1*>(mo->getObject());
-      if (h == nullptr) {
-        ILOG(Error, Support) << "Could not cast `example` to TH1*, skipping" << ENDM;
-        continue;
-      }
-      // unless we find issues, we assume the quality is good
-      result = Quality::Good;
-
-      // an example of a naive quality check: we want bins 1-7 to be non-empty and bins 0 and >7 to be empty.
-      for (int i = 0; i < h->GetNbinsX(); i++) {
-        if (i > 0 && i < 8 && h->GetBinContent(i) == 0) {
-          result = Quality::Bad;
-          // optionally, we can add flags indicating the effect on data and a comment explaining why it was assigned.
-          result.addFlag(FlagTypeFactory::BadPID(), "It is bad because there is nothing in bin " + std::to_string(i));
-          break;
-        } else if ((i == 0 || i > 7) && h->GetBinContent(i) > 0) {
-          result = Quality::Medium;
-          // optionally, we can add flags indicating the effect on data and a comment explaining why it was assigned.
-          result.addFlag(FlagTypeFactory::Unknown(), "It is medium because bin " + std::to_string(i) + " is not empty");
-          result.addFlag(FlagTypeFactory::BadTracking(), "We can assign more than one Flag to a Quality");
-        }
+  auto MOs = data.getAllOfTypeIf<std::shared_ptr<MonitorObject>>([](const auto& mo) { return mo->getName() == "example"; });
+
+  for (const auto& mo : MOs) {
+    auto* h = dynamic_cast<TH1*>(mo->getObject());
+    if (h == nullptr) {
+      ILOG(Error, Support) << "Could not cast `example` to TH1*, skipping" << ENDM;
+      continue;
+    }
+    // unless we find issues, we assume the quality is good
+    result = Quality::Good;
+
+    // an example of a naive quality check: we want bins 1-7 to be non-empty and bins 0 and >7 to be empty.
+    for (int i = 0; i < h->GetNbinsX(); i++) {
+      if (i > 0 && i < 8 && h->GetBinContent(i) == 0) {
+        result = Quality::Bad;
+        // optionally, we can add flags indicating the effect on data and a comment explaining why it was assigned.
+        result.addFlag(FlagTypeFactory::BadPID(), "It is bad because there is nothing in bin " + std::to_string(i));
+        break;
+      } else if ((i == 0 || i > 7) && h->GetBinContent(i) > 0) {
+        result = Quality::Medium;
+        // optionally, we can add flags indicating the effect on data and a comment explaining why it was assigned.
+        result.addFlag(FlagTypeFactory::Unknown(), "It is medium because bin " + std::to_string(i) + " is not empty");
+        result.addFlag(FlagTypeFactory::BadTracking(), "We can assign more than one Flag to a Quality");
       }
-      // optionally, we can associate some custom metadata to a Quality
-      result.addMetadata("mykey", "myvalue");
     }
+    // optionally, we can associate some custom metadata to a Quality
+    result.addMetadata("mykey", "myvalue");
   }
+
   return result;
 }