[QC-977] Select automatically the correct params (#1865)

* [QC-977] Select automatically the correct params based on the current activity.

* test

* doc

* Update Framework/src/CustomParameters.cxx

Co-authored-by: Piotr Konopka <piotr.jan.konopka@cern.ch>

* Update Framework/src/CustomParameters.cxx

Co-authored-by: Piotr Konopka <piotr.jan.konopka@cern.ch>

---------

Co-authored-by: Piotr Konopka <piotr.jan.konopka@cern.ch>

Author: Barthelemy

Framework/include/QualityControl/CustomParameters.h

@@ -17,6 +17,8 @@
 #ifndef QC_CUSTOM_PARAMETERS_H
 #define QC_CUSTOM_PARAMETERS_H
 
+#include "QualityControl/Activity.h"
+
 #include <string>
 #include <unordered_map>
 #include <optional>
@@ -84,6 +86,14 @@ class CustomParameters
    */
   std::optional<std::string> atOptional(const std::string& key, const std::string& runType = "default", const std::string& beamType = "default") const;
 
+  /**
+   * Return the optional value for the given key in the specified activity.
+   * @param key
+   * @param activity
+   * @return an optional with the value for the given key and for the given activity.
+   */
+  std::optional<std::string> atOptional(const std::string& key, const Activity& activity) const;
+
   /**
    * Return the value for the given key, runType and beamType (the two latter optional). If it does not exist, returns the default value if provided or an empty string.
    * @param key

Framework/src/CustomParameters.cxx

@@ -10,7 +10,7 @@
 // or submit itself to any jurisdiction.
 
 #include "QualityControl/CustomParameters.h"
-
+#include <DataFormatsParameters/ECSDataAdapters.h>
 #include <iostream>
 
 namespace o2::quality_control::core
@@ -66,6 +66,17 @@ std::optional<std::string> CustomParameters::atOptional(const std::string& key,
   }
 }
 
+std::optional<std::string> CustomParameters::atOptional(const std::string& key, const Activity& activity) const
+{
+  // Get the proper parameter for the given activity
+  const int runType = activity.mType; // get the type for this run
+  // convert it to a string (via a string_view as this is what we get from O2)
+  const std::string_view runTypeStringView = o2::parameters::GRPECS::RunTypeNames[runType];
+  const std::string runTypeString{ runTypeStringView };
+  // get the param
+  return atOptional(key, runTypeString, activity.mBeamType);
+}
+
 std::string CustomParameters::atOrDefaultValue(const std::string& key, std::string defaultValue, const std::string& runType, const std::string& beamType)
 {
   try {

Framework/test/testCustomParameters.cxx

@@ -136,6 +136,30 @@ BOOST_AUTO_TEST_CASE(test_at_optional)
   BOOST_CHECK_EQUAL(cp.atOptional("abc").value_or("bla"), "bla");
 }
 
+BOOST_AUTO_TEST_CASE(test_at_optional_activity)
+{
+  Activity activity;
+  activity.mBeamType = "PROTON-PROTON";
+  activity.mType = 1;
+
+  CustomParameters cp;
+  cp.set("aaa", "AAA");
+  cp.set("bbb", "BBB");
+  cp.set("aaa", "asdf", "PHYSICS");
+  cp.set("aaa", "CCC", "PHYSICS", "PROTON-PROTON");
+  cp.set("aaa", "DDD", "PHYSICS", "Pb-Pb");
+  cp.set("aaa", "AAA", "TECHNICAL", "PROTON-PROTON");
+
+  BOOST_CHECK_EQUAL(cp.atOptional("aaa", activity).value(), "CCC");
+  BOOST_CHECK_EQUAL(cp.atOptional("abc", activity).has_value(), false);
+  BOOST_CHECK_EQUAL(cp.atOptional("abc", activity).value_or("bla"), "bla");
+
+  Activity activity2;
+  activity.mBeamType = "Pb-Pb";
+  activity.mType = 1;
+  BOOST_CHECK_EQUAL(cp.atOptional("aaa", activity).value(), "DDD");
+}
+
 BOOST_AUTO_TEST_CASE(test_cp_new_access_pattern)
 {
   CustomParameters cp;

Modules/Skeleton/src/SkeletonTask.cxx

@@ -19,10 +19,8 @@
 
 #include "QualityControl/QcInfoLogger.h"
 #include "Skeleton/SkeletonTask.h"
-#include <Framework/InputRecord.h>
 #include <Framework/InputRecordWalker.h>
 #include <Framework/DataRefUtils.h>
-#include "DataFormatsParameters/ECSDataAdapters.h"
 
 namespace o2::quality_control_modules::skeleton
 {
@@ -64,14 +62,14 @@ void SkeletonTask::startOfActivity(const Activity& activity)
   ILOG(Debug, Devel) << "startOfActivity " << activity.mId << ENDM;
   mHistogram->Reset();
 
-  // Get the proper parameter for the given activity
-  int runType = activity.mType; // get the type for this run
-  // convert it to a string (via a string_view as this is what we get from O2)
-  string_view runTypeStringView = o2::parameters::GRPECS::RunTypeNames[runType];
-  string runTypeString = { runTypeStringView.begin(), runTypeStringView.end() };
-  // get the param
-  if (auto param = mCustomParameters.atOptional("myOwnKey", runTypeString)) {
-    ILOG(Debug, Devel) << "Custom parameter - myOwnKey: " << param.value() << ENDM;
+  // Example: retrieve custom parameters
+  std::string parameter;
+  // first we try for the current activity. It returns an optional.
+  if (auto param = mCustomParameters.atOptional("myOwnKey", activity)) {
+    parameter = param.value(); // we got a value
+  } else {
+    // we did not get a value. We ask for the "default" runtype and beamtype and we specify a default return value.
+    parameter = mCustomParameters.atOrDefaultValue("myOwnKey", "some default");
   }
 }
 

doc/Advanced.md

@@ -48,7 +48,8 @@ Advanced topics
    * [Enable the repo cleaner](#enable-the-repo-cleaner)
 * [Configuration](#configuration-1)
    * [Merging multiple configuration files into one](#merging-multiple-configuration-files-into-one)
-   * [Definition and access of task-specific configuration](#definition-and-access-of-task-specific-configuration)
+   * [Definition and access of user-specific configuration](#definition-and-access-of-user-specific-configuration)
+   * [Definition of new arguments](#definition-of-new-arguments)
    * [Configuration files details](#configuration-files-details)
       * [Global configuration structure](#global-configuration-structure)
       * [Common configuration](#common-configuration)
@@ -995,7 +996,7 @@ The following tasks will be merged correctly:
 ```
 The same approach can be applied to other actors in the QC framework, like Checks (`checkName`), Aggregators(`aggregatorName`), External Tasks (`taskName`) and Postprocessing Tasks (`taskName`).
 
-## Definition and access of task-specific configuration
+## Definition and access of user-specific configuration
 
 A task can access custom parameters declared in the configuration file at `qc.tasks.<task_id>.extendedTaskParameters` or `qc.tasks.<task_id>.taskParameters`. They are stored inside an object of type `CustomParameters` named `mCustomParameters`, which is a protected member of `TaskInterface`.
 
@@ -1026,10 +1027,10 @@ The new syntax is
               "myOwnKey1": "myOwnValue1b",
               "myOwnKey2": "myOwnValue2b"
             },
-            "pp": {
+            "PROTON-PROTON": {
               "myOwnKey1": "myOwnValue1c"
             },
-            "PbPb": {
+            "Pb-Pb": {
               "myOwnKey1": "myOwnValue1d"
             }
           },
@@ -1043,7 +1044,21 @@ It allows to have variations of the parameters depending on the run and beam typ
 to ignore the run or the beam type. 
 The beam type is one of the following: `PROTON-PROTON`, `Pb-Pb`, `Pb-PROTON`
 
-The values can be accessed this way: 
+The values can be accessed in various ways.
+
+### Access optional values with or without activity
+
+```c++
+// returns an Optional<string> if it finds the key `myOwnKey` for the runType and beamType of the provided activity. 
+auto param = mCustomParameters.atOptional("myOwnKey", activity); // activity is "PHYSICS", "Pb-Pb" , returns "myOwnValue1d"
+// same but passing directly the run and beam types
+auto param = mCustomParameters.atOptional("myOwnKey", "PHYSICS", "Pb-Pb"); // returns "myOwnValue1d"
+// or with only the run type
+auto param = mCustomParameters.atOptional("myOwnKey", "PHYSICS"); // returns "myOwnValue1b"
+```
+
+### Access values directly specifying the run and beam type
+
 ```c++
 mCustomParameters["myOwnKey"]; // considering that run and beam type are `default` --> returns `myOwnValue`
 mCustomParameters.at("myOwnKey"); // returns `myOwnValue`
@@ -1054,22 +1069,25 @@ mCustomParameters.at("myOwnKey1", "PHYSICS", "PROTON-PROTON"); // returns `myOwn
 mCustomParameters.at("myOwnKey1", "PHYSICS", "Pb-Pb"); // returns `myOwnValue1d`
 mCustomParameters.at("myOwnKey2", "COSMICS"); // returns `myOwnValue2e`
 ```
+
+### Access values and return default if not found
+
 The correct way of accessing a parameter and to default to a value if it is not there, is the following:
 ```c++
   std::string param = mCustomParameters.atOrDefaultValue("myOwnKey1", "physics", "pp", "1");
   int casted = std::stoi(param);
 ```
+
+### Find a value 
+
 Finally the way to search for a value and only act if it is there is the following: 
 ```c++
   if (auto param2 = mCustomParameters.find("myOwnKey1", "physics", "pp"); param2 != cp.end()) {
     int casted = std::stoi(param);
   }
 ```
 
-
-A task can access custom parameters declared in the configuration file at `qc.tasks.<task_id>.taskParameters`. They are stored inside a key-value map named mCustomParameters, which is a protected member of `TaskInterface`.
-
-
+## Definition of new arguments
 
 One can also tell the DPL driver to accept new arguments. This is done using the `customize` method at the top of your workflow definition (usually called "runXXX" in the QC).