QC-686 Allow apply Reductors to CCDB data in TrendingTasks and alike

Framework/CMakeLists.txt

@@ -97,7 +97,8 @@ add_library(O2QualityControl
   src/TimekeeperAsynchronous.cxx
   src/WorkflowType.cxx
   src/TimekeeperFactory.cxx
-  src/RootFileStorage.cxx)
+  src/RootFileStorage.cxx
+  src/ReductorHelpers.cxx)
 
 target_include_directories(
   O2QualityControl

Framework/include/QualityControl/ConditionAccess.h

@@ -0,0 +1,53 @@
+// 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.
+
+#ifndef QUALITYCONTROL_CONDITIONACCESS_H
+#define QUALITYCONTROL_CONDITIONACCESS_H
+
+#include <string>
+#include <map>
+#include <CCDB/BasicCCDBManager.h>
+
+namespace o2::quality_control::core
+{
+
+class ConditionAccess
+{
+ public:
+  /// Default constructor
+  ConditionAccess() = default;
+  /// Destructor
+  virtual ~ConditionAccess() = default;
+
+  void setCcdbUrl(const std::string& url)
+  {
+    o2::ccdb::BasicCCDBManager::instance().setURL(url);
+  }
+
+  /**
+   * Get an object from the CCDB. The object is owned by the CCDBManager, don't delete it !
+   */
+  template <typename T>
+  T* retrieveConditionAny(std::string const& path, std::map<std::string, std::string> const& metadata = {}, long timestamp = -1);
+};
+
+template <typename T>
+T* ConditionAccess::retrieveConditionAny(std::string const& path, std::map<std::string, std::string> const& metadata, long timestamp)
+{
+  auto& mgr = o2::ccdb::BasicCCDBManager::instance();
+  mgr.setFatalWhenNull(false);
+  mgr.setTimestamp(timestamp);
+  return mgr.getSpecific<T>(path, mgr.getTimestamp(), metadata);
+}
+
+} // namespace o2::quality_control::core
+
+#endif // QUALITYCONTROL_CONDITIONACCESS_H

Framework/include/QualityControl/Reductor.h

@@ -16,12 +16,10 @@
 #ifndef QUALITYCONTROL_REDUCTOR_H
 #define QUALITYCONTROL_REDUCTOR_H
 
-#include <TObject.h>
-
 namespace o2::quality_control::postprocessing
 {
 
-/// \brief An interface for storing data derived from QC objects into a TTree
+/// \brief An interface for storing columnar data into a TTree
 class Reductor
 {
  public:
@@ -36,9 +34,6 @@ class Reductor
   /// \brief Branch leaf list getter
   /// \return A C string with a description of a branch format, formatted accordingly to the TTree interface
   virtual const char* getBranchLeafList() = 0;
-  /// \brief Fill the data structure with new data
-  /// \param An object to be reduced
-  virtual void update(TObject* obj) = 0;
 };
 
 } // namespace o2::quality_control::postprocessing

Framework/include/QualityControl/ReductorConditionAny.h

@@ -0,0 +1,73 @@
+// 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   ReductorConditionAny.h
+/// \author Piotr Konopka
+///
+#ifndef QUALITYCONTROL_REDUCTORCONDITIONANY_H
+#define QUALITYCONTROL_REDUCTORCONDITIONANY_H
+
+#include "QualityControl/Reductor.h"
+#include <QualityControl/ConditionAccess.h>
+
+namespace o2::quality_control::postprocessing
+{
+
+/// \brief An interface for storing data derived from any object into a TTree
+class ReductorConditionAny : public Reductor
+{
+ public:
+  class ConditionRetriever;
+
+  /// \brief Constructor
+  ReductorConditionAny() = default;
+  /// \brief Destructor
+  virtual ~ReductorConditionAny() = default;
+
+  /// \brief A helper for the caller to have the ConditionRetriever created
+  virtual bool update(core::ConditionAccess& conditionAccess, uint64_t timestamp, const std::string& path) final
+  {
+    ConditionRetriever retriever{ conditionAccess, timestamp, path };
+    return update(retriever);
+  }
+
+  /// \brief Fill the data structure with new data
+  /// \param An object getter, object presence is not guaranteed
+  /// \return false if failed, true if success
+  virtual bool update(ConditionRetriever& retriever) = 0;
+
+  /// \brief A wrapper class to allow implementations of ReductorConditionAny to state the expected type of the reduced object.
+  ///
+  /// A wrapper class to allow implementations of ReductorConditionAny to state the expected type of the reduced object.
+  /// It is declared within ReductorConditionAny, as it is intended to be used only in this context.
+  struct ConditionRetriever {
+   public:
+    ConditionRetriever(core::ConditionAccess& conditionAccess, uint64_t timestamp, const std::string& path)
+      : conditionAccess(conditionAccess), timestamp(timestamp), path(path){};
+    ~ConditionRetriever() = default;
+
+    /// \brief Gets the object with a specified type. The result can be nullptr, the pointer should not be deleted!
+    template <typename T>
+    T* retrieve()
+    {
+      return conditionAccess.retrieveConditionAny<T>(path, {}, timestamp);
+    }
+
+   private:
+    core::ConditionAccess& conditionAccess;
+    uint64_t timestamp;
+    const std::string& path;
+  };
+};
+
+} // namespace o2::quality_control::postprocessing
+#endif // QUALITYCONTROL_REDUCTORCONDITIONANY_H

Framework/include/QualityControl/ReductorHelpers.h

@@ -0,0 +1,71 @@
+// 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    ReductorHelpers.h
+/// \author  Piotr Konopka
+///
+
+#ifndef QUALITYCONTROL_REDUCTORHELPERS_H
+#define QUALITYCONTROL_REDUCTORHELPERS_H
+
+#include <string>
+
+namespace o2::quality_control
+{
+namespace postprocessing
+{
+class Reductor;
+struct Trigger;
+} // namespace postprocessing
+namespace core
+{
+class ConditionAccess;
+}
+namespace repository
+{
+class DatabaseInterface;
+}
+} // namespace o2::quality_control
+
+namespace o2::quality_control::postprocessing::reductor_helpers
+{
+
+namespace implementation
+{
+
+/// \brief implementation details of updateReductor, hiding some header inclusions
+bool updateReductorImpl(Reductor* r, const Trigger& t, const std::string& path, const std::string& name, const std::string& type,
+                        repository::DatabaseInterface& qcdb, core::ConditionAccess& ccdbAccess);
+
+} // namespace implementation
+
+/// \brief Updates the provided Reductor with implementation-specific procedures
+///
+/// \tparam DataSourceT data source structure type to be accessed. path, name and type string members are required.
+/// \param r reductor which is going to be type-checked
+/// \param t trigger
+/// \param ds data source
+/// \param qcdb QCDB interface
+/// \param ccdbAccess a class which has access to conditions
+/// \return bool value indicating the success or failure in reducing an object
+template <typename DataSourceT>
+bool updateReductor(Reductor* r, const Trigger& t, const DataSourceT& ds, repository::DatabaseInterface& qcdb, core::ConditionAccess& ccdbAccess)
+{
+  const std::string& path = ds.path;
+  const std::string& name = ds.name;
+  const std::string& type = ds.type;
+
+  return implementation::updateReductorImpl(r, t, path, name, type, qcdb, ccdbAccess);
+}
+
+} // namespace o2::quality_control::postprocessing::reductor_helpers
+#endif // QUALITYCONTROL_REDUCTORHELPERS_H

Framework/include/QualityControl/ReductorTObject.h

@@ -0,0 +1,42 @@
+// 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   ReductorTObject.h
+/// \author Piotr Konopka
+///
+#ifndef QUALITYCONTROL_REDUCTORTOBJECT_H
+#define QUALITYCONTROL_REDUCTORTOBJECT_H
+
+#include "QualityControl/Reductor.h"
+#include <RtypesCore.h>
+
+class TObject;
+
+namespace o2::quality_control::postprocessing
+{
+
+/// \brief An interface for storing data derived from TObjects into a TTree
+class ReductorTObject : public Reductor
+{
+ public:
+  /// \brief Constructor
+  ReductorTObject() = default;
+  /// \brief Destructor
+  virtual ~ReductorTObject() = default;
+
+  /// \brief Fill the data structure with new data
+  /// \param An object to be reduced into a limited set of observables
+  virtual void update(TObject* obj) = 0;
+};
+
+} // namespace o2::quality_control::postprocessing
+#endif // QUALITYCONTROL_REDUCTORTOBJECT_H

Framework/include/QualityControl/UserCodeInterface.h

@@ -20,8 +20,8 @@
 #include <string>
 #include <map>
 #include <Rtypes.h>
-#include <CCDB/BasicCCDBManager.h>
 
+#include "QualityControl/ConditionAccess.h"
 #include "QualityControl/CustomParameters.h"
 
 namespace o2::quality_control::core
@@ -30,7 +30,7 @@ namespace o2::quality_control::core
 /// \brief  Common interface for Check and Task Interfaces.
 ///
 /// \author Barthelemy von Haller
-class UserCodeInterface
+class UserCodeInterface : public ConditionAccess
 {
  public:
   /// Default constructor
@@ -46,32 +46,16 @@ class UserCodeInterface
   /// It is called each time mCustomParameters is updated, including the first time it is read.
   virtual void configure() = 0;
 
-  void setCcdbUrl(const std::string& url);
   const std::string& getName() const;
   void setName(const std::string& name);
 
-  /**
-   * Get an object from the CCDB. The object is owned by the CCDBManager, don't delete it !
-   */
-  template <typename T>
-  T* retrieveConditionAny(std::string const& path, std::map<std::string, std::string> const& metadata = {}, long timestamp = -1);
-
  protected:
   CustomParameters mCustomParameters;
   std::string mName;
 
   ClassDef(UserCodeInterface, 3)
 };
 
-template <typename T>
-T* UserCodeInterface::retrieveConditionAny(std::string const& path, std::map<std::string, std::string> const& metadata, long timestamp)
-{
-  auto& mgr = o2::ccdb::BasicCCDBManager::instance();
-  mgr.setFatalWhenNull(false);
-  mgr.setTimestamp(timestamp);
-  return mgr.getSpecific<T>(path, mgr.getTimestamp(), metadata);
-}
-
 } // namespace o2::quality_control::core
 
 #endif // QUALITYCONTROL_USERCODEINTERFACE_H

Framework/src/ReductorHelpers.cxx

@@ -0,0 +1,62 @@
+// 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   ReductorHelpers.cxx
+/// \author Piotr Konopka
+///
+
+#include "QualityControl/ReductorHelpers.h"
+
+#include "QualityControl/Reductor.h"
+#include "QualityControl/ReductorTObject.h"
+#include "QualityControl/ReductorConditionAny.h"
+#include "QualityControl/Triggers.h"
+#include "QualityControl/DatabaseInterface.h"
+#include "QualityControl/ConditionAccess.h"
+
+namespace o2::quality_control::postprocessing::reductor_helpers::implementation
+{
+
+bool updateReductorImpl(Reductor* r, const Trigger& t, const std::string& path, const std::string& name, const std::string& type,
+                        repository::DatabaseInterface& qcdb, core::ConditionAccess& ccdbAccess)
+{
+  if (r == nullptr) {
+    return false;
+  }
+
+  if (type == "repository") {
+    auto mo = qcdb.retrieveMO(path, name, t.timestamp, t.activity);
+    TObject* obj = mo ? mo->getObject() : nullptr;
+    auto reductorTObject = dynamic_cast<ReductorTObject*>(r);
+    if (obj && reductorTObject) {
+      reductorTObject->update(obj);
+      return true;
+    }
+  } else if (type == "repository-quality") {
+    auto qo = qcdb.retrieveQO(path + "/" + name, t.timestamp, t.activity);
+    auto reductorTObject = dynamic_cast<ReductorTObject*>(r);
+    if (qo && reductorTObject) {
+      reductorTObject->update(qo.get());
+      return true;
+    }
+  } else if (type == "condition") {
+    auto reductorConditionAny = dynamic_cast<ReductorConditionAny*>(r);
+    if (reductorConditionAny) {
+      auto conditionPath = name.empty() || path.empty() ? path + name : path + "/" + name;
+      reductorConditionAny->update(ccdbAccess, t.timestamp, conditionPath);
+      return true;
+    }
+  }
+  return false;
+}
+
+} // namespace o2::quality_control::postprocessing::reductor_helpers::implementation