ROOT IO for ConfigurableParameters

Adding possibility to stream ConfigurableParameters
and deserialize therefrom.
This enables writing/retrieving the Parameters from/to CCDB.

Author: sawenzel

Common/SimConfig/include/SimConfig/ConfigurableParam.h

@@ -18,6 +18,9 @@
 #include <boost/property_tree/ptree.hpp>
 #include <typeinfo>
 
+class TFile;
+class TRootIOCtor;
+
 namespace o2
 {
 namespace conf
@@ -77,7 +80,7 @@ class ConfigurableParam
 {
  public:
   //
-  virtual std::string getName() = 0; // print the name of the configurable Parameter
+  virtual std::string getName() const = 0; // print the name of the configurable Parameter
 
   // print the current keys and values to screen
   virtual void printKeyValues() = 0;
@@ -120,6 +123,11 @@ class ConfigurableParam
 
   static void initialize();
 
+  static void toCCDB(std::string filename);
+  static void fromCCDB(std::string filename);
+  virtual void serializeTo(TFile*) const = 0;
+  virtual void initFrom(TFile*) = 0;
+
   // allows to provide a file from which to update
   // (certain) key-values
   // propagates changes down to each registered configuration
@@ -149,19 +157,24 @@ class ConfigurableParam
   // (internal use to easily sync updates, this is ok since parameter classes are singletons)
   static std::map<std::string, std::pair<int, void*>>* sKeyToStorageMap;
 
+  void setRegisterMode(bool b) { sRegisterMode = b; }
+
  private:
   // static registry for implementations of this type
   static std::vector<ConfigurableParam*>* sRegisteredParamClasses; //!
   // static property tree (stocking all key - value pairs from instances of type ConfigurableParam)
   static boost::property_tree::ptree* sPtree; //!
   static bool sIsFullyInitialized;            //!
+  static bool sRegisterMode;                  //! (flag to enable/disable autoregistering of child classes)
 };
 
 } // end namespace conf
 } // end namespace o2
 
 // a helper macro for boilerplate code in parameter classes
 #define O2ParamDef(classname, key)               \
+ public:                                         \
+  classname(TRootIOCtor *) {}                    \
  private:                                        \
   static constexpr char const* const sKey = key; \
   static classname sInstance;                    \

Common/SimConfig/include/SimConfig/ConfigurableParamHelper.h

@@ -17,6 +17,7 @@
 #include "TClass.h"
 #include <type_traits>
 #include <typeinfo>
+#include "TFile.h"
 
 namespace o2
 {
@@ -50,7 +51,7 @@ class ConfigurableParamHelper : virtual public ConfigurableParam
     return P::sInstance;
   }
 
-  std::string getName() final
+  std::string getName() const final
   {
     return P::sKey;
   }
@@ -82,6 +83,27 @@ class ConfigurableParamHelper : virtual public ConfigurableParam
     }
     _ParamHelper::fillKeyValuesImpl(getName(), cl, (void*)this, tree, sKeyToStorageMap);
   }
+
+  void initFrom(TFile* file) final
+  {
+    // switch off auto registering since the readback object is
+    // only a "temporary" singleton
+    setRegisterMode(false);
+    P* readback = nullptr;
+    file->GetObject(getName().c_str(), readback);
+    if (readback != nullptr) {
+      // ATTENTION: override existing singleton object
+      // It would be better to have a way of reading INTO an existing object
+      std::memcpy((void*)this, readback, sizeof(P));
+      delete readback;
+    }
+    setRegisterMode(true);
+  }
+
+  void serializeTo(TFile* file) const final
+  {
+    file->WriteObjectAny((void*)this, TClass::GetClass(typeid(P)), getName().c_str());
+  }
 };
 } // namespace conf
 } // namespace o2

Common/SimConfig/src/ConfigurableParam.cxx

@@ -21,6 +21,7 @@
 #include <typeinfo>
 #include <cassert>
 #include "TDataType.h"
+#include "TFile.h"
 
 namespace o2
 {
@@ -31,6 +32,7 @@ std::vector<ConfigurableParam*>* ConfigurableParam::sRegisteredParamClasses = nu
 boost::property_tree::ptree* ConfigurableParam::sPtree = nullptr;
 std::map<std::string, std::pair<int, void*>>* ConfigurableParam::sKeyToStorageMap = nullptr;
 bool ConfigurableParam::sIsFullyInitialized = false;
+bool ConfigurableParam::sRegisterMode = true;
 
 void ConfigurableParam::writeINI(std::string filename)
 {
@@ -54,9 +56,31 @@ void ConfigurableParam::updatePropertyTree()
 
 void ConfigurableParam::printAllKeyValuePairs()
 {
+  std::cout << "####\n";
   for (auto p : *sRegisteredParamClasses) {
     p->printKeyValues();
   }
+  std::cout << "----\n";
+}
+
+// evidently this could be a local file or an OCDB server
+// ... we need to generalize this ... but ok for demonstration purpose
+void ConfigurableParam::toCCDB(std::string filename)
+{
+  TFile file(filename.c_str(), "RECREATE");
+  for (auto p : *sRegisteredParamClasses) {
+    p->serializeTo(&file);
+  }
+  file.Close();
+}
+
+void ConfigurableParam::fromCCDB(std::string filename)
+{
+  TFile file(filename.c_str(), "READ");
+  for (auto p : *sRegisteredParamClasses) {
+    p->initFrom(&file);
+  }
+  file.Close();
 }
 
 ConfigurableParam::ConfigurableParam()
@@ -70,7 +94,9 @@ ConfigurableParam::ConfigurableParam()
   if (sKeyToStorageMap == nullptr) {
     sKeyToStorageMap = new std::map<std::string, std::pair<int, void*>>;
   }
-  sRegisteredParamClasses->push_back(this);
+  if (sRegisterMode == true) {
+    sRegisteredParamClasses->push_back(this);
+  }
 }
 
 void ConfigurableParam::initialize()

Common/SimConfig/src/ConfigurableParamHelper.cxx

@@ -74,7 +74,7 @@ void _ParamHelper::printParametersImpl(TClass* cl, void* obj)
     // pointer to object
     auto dt = dm->GetDataType();
     char* pointer = ((char*)obj) + dm->GetOffset() + index * dt->Size();
-    std::cout << getName(dm, index, size) << " : " << dt->AsString(pointer);
+    std::cout << getName(dm, index, size) << " : " << dt->AsString(pointer) << "\n";
   };
   loopOverMembers(cl, obj, printMembers);
 }

Detectors/Passive/src/PassiveLinkDef.h

@@ -36,7 +36,8 @@
 #pragma link C++ class  o2::passive::FrameStructure+;
 #pragma link C++ class  o2::passive::Shil+;
 #pragma link C++ class  o2::passive::Hall+;
+#pragma link C++ class  o2::conf::ConfigurableParam+;
 #pragma link C++ class  o2::passive::HallSimParam+;
-
+#pragma link C++ class  o2::conf::ConfigurableParamHelper<o2::passive::HallSimParam>+;
 #endif
 

macro/o2sim.C

@@ -29,13 +29,17 @@
 FairRunSim* o2sim_init(bool asservice)
 {
   auto& confref = o2::conf::SimConfig::Instance();
-  // update the parameters from local configuration file (TODO)
+  // we can read from CCDB (for the moment faking with a TFile)
+  // o2::conf::ConfigurableParam::fromCCDB("params_ccdb.root", runid);
 
   // update the parameters from stuff given at command line
   o2::conf::ConfigurableParam::updateFromString(confref.getKeyValueString());
   // write the configuration file
   o2::conf::ConfigurableParam::writeINI("o2sim_configuration.ini");
 
+  // we can update the binary CCDB entry something like this ( + timestamp key )
+  // o2::conf::ConfigurableParam::toCCDB("params_ccdb.root");
+
   auto genconfig = confref.getGenerator();
 
   FairRunSim* run;