Stand-alone binary for the reconstruction from timeslice (using FairRun)

external/.gitignore

@@ -8,4 +8,4 @@ flib_dpb/flib_dpb
 ipc/ipc
 jsroot
 googletest
-
+yaml-cpp/

external/CMakeLists.txt

@@ -43,6 +43,8 @@ if(DOWNLOAD_EXTERNALS)
   Include(InstallParameter.cmake)
   Include(InstallInput.cmake)
   Include(InstallGeometry.cmake)
+
+  Include(InstallYamlCpp.cmake)
 else()
   # Define targets which are needed by CbmRoot but are not available
   # whithout the external packages

external/InstallYamlCpp.cmake

+set(YAMLCPP_VERSION 0579ae3d976091d7d664aa9d2527e0d0cff25763) # version 0.7.0
+
+set(YAMLCPP_SRC_URL "https://github.com/jbeder/yaml-cpp")
+set(YAMLCPP_DESTDIR "${CMAKE_BINARY_DIR}/external/YAMLCPP-prefix")
+
+#set(YAMLCPP_BYPRODUCT "${PROJECT_BINARY_DIR}/lib/${CMAKE_STATIC_LIBRARY_PREFIX}yaml-cpp${CMAKE_SHARED_LIBRARY_SUFFIX}")
+
+download_project_if_needed(PROJECT  yaml-cpp
+        GIT_REPOSITORY  ${YAMLCPP_SRC_URL}
+        GIT_TAG         ${YAMLCPP_VERSION}
+        SOURCE_DIR      ${CMAKE_CURRENT_SOURCE_DIR}/yaml-cpp
+        TEST_FILE       CMakeLists.txt
+        )
+
+If(ProjectUpdated)
+    File(REMOVE_RECURSE ${YAMLCPP_DESTDIR})
+    Message("yaml-cpp source directory was changed so build directory was deleted")
+EndIf()
+
+ExternalProject_Add(
+  yaml-cpp
+  SOURCE_DIR ${CMAKE_CURRENT_SOURCE_DIR}/yaml-cpp
+  GIT_CONFIG advice.detachedHead=false
+  BUILD_IN_SOURCE 0
+  LOG_DOWNLOAD 1 LOG_CONFIGURE 1 LOG_BUILD 1 LOG_INSTALL 1
+  CMAKE_ARGS -DYAML_CPP_BUILD_CONTRIB=OFF
+             -DYAML_CPP_BUILD_TOOLS=OFF
+             -DYAML_CPP_BUILD_TESTS=OFF
+             -DYAML_BUILD_SHARED_LIBS=OFF
+             -DCMAKE_POSITION_INDEPENDENT_CODE=ON
+  BUILD_COMMAND ${CMAKE_COMMAND} --build . --target yaml-cpp --parallel 1
+  BUILD_BYPRODUCTS ${PROJECT_BINARY_DIR}/external/yaml-cpp-prefix/src/yaml-cpp-build/${CMAKE_STATIC_LIBRARY_PREFIX}yaml-cpp${CMAKE_STATIC_LIBRARY_SUFFIX}
+  INSTALL_COMMAND ""
+)
+
+# pre-create empty directory to make INTERFACE_INCLUDE_DIRECTORIES happy
+file(MAKE_DIRECTORY ${CMAKE_SOURCE_DIR}/external/yaml-cpp/include)
+
+add_library(external::yaml-cpp STATIC IMPORTED GLOBAL)
+add_dependencies(external::yaml-cpp yaml-cpp)
+set_target_properties(external::yaml-cpp PROPERTIES
+  IMPORTED_LOCATION ${PROJECT_BINARY_DIR}/external/yaml-cpp-prefix/src/yaml-cpp-build/${CMAKE_STATIC_LIBRARY_PREFIX}yaml-cpp${CMAKE_STATIC_LIBRARY_SUFFIX}
+  INTERFACE_INCLUDE_DIRECTORIES ${CMAKE_SOURCE_DIR}/external/yaml-cpp/include
+)

reco/CMakeLists.txt

@@ -14,4 +14,5 @@ add_subdirectory(tracking)
 add_subdirectory(qa)
 if (${CMAKE_CXX_STANDARD} EQUAL 17)
   add_subdirectory (tasks)
+  add_subdirectory (app)
 endif()

reco/app/CMakeLists.txt

+add_subdirectory(cbmreco_fairrun)

reco/app/cbmreco_fairrun/Application.cxx

+/* Copyright (C) 2022 Johann Wolfgang Goethe-Universitaet Frankfurt, Frankfurt am Main
+   SPDX-License-Identifier: GPL-3.0-only
+   Authors: Jan de Cuveland [committer] */
+
+#include "Application.h"
+
+Application::Application(ProgramOptions const& opt) : fOpt(opt)
+{
+  CbmRecoConfig config;
+  config.LoadYaml(fOpt.ConfigYamlFile());
+  if (!fOpt.SaveConfigYamlFile().empty()) { config.SaveYaml(fOpt.SaveConfigYamlFile()); }
+
+  fCbmReco = std::make_unique<CbmReco>(fOpt.InputUri(), fOpt.OutputRootFile(), fOpt.MaxNumTs(), config);
+}
+
+void Application::Run() { fCbmReco->Run(); }

reco/app/cbmreco_fairrun/Application.h

+/* Copyright (C) 2022 Johann Wolfgang Goethe-Universitaet Frankfurt, Frankfurt am Main
+   SPDX-License-Identifier: GPL-3.0-only
+   Authors: Jan de Cuveland [committer] */
+
+#ifndef APP_CBMRECO_APPLICATION_H
+#define APP_CBMRECO_APPLICATION_H
+
+#include "CbmReco.h"
+
+#include <memory>
+
+#include "ProgramOptions.h"
+#include "log.hpp"
+
+/** @class Application
+ ** @brief Main class of the "cbmreco_fairrun" application
+ ** @author Jan de Cuveland <cuveland@compeng.uni-frankfurt.de>
+ ** @since 16 March 2022
+ **
+ ** This class implements a stand-alone command-line application.
+ ** It instantiatates and configures a CbmReco object, which executes
+ ** the CBM reconstruction steps using FairTasks and FairRunOnline.
+ **/
+class Application {
+public:
+  /** @brief Standard constructor, initialize the application **/
+  explicit Application(ProgramOptions const& opt);
+
+  /** @brief Copy constructor forbidden **/
+  Application(const Application&) = delete;
+
+  /** @brief Assignment operator forbidden **/
+  void operator=(const Application&) = delete;
+
+  /** @brief Run the application **/
+  void Run();
+
+private:
+  ProgramOptions const& fOpt;         ///< Program options object
+  std::unique_ptr<CbmReco> fCbmReco;  ///< CBM reconstruction steering class instance
+};
+
+#endif

reco/app/cbmreco_fairrun/CMakeLists.txt

+# Copyright (C) 2022 Johann Wolfgang Goethe-Universitaet Frankfurt, Frankfurt am Main
+# SPDX-License-Identifier: GPL-3.0-only
+# Authors: Jan de Cuveland [committer]
+
+file(GLOB APP_SOURCES *.cxx)
+file(GLOB APP_HEADERS *.h)
+
+add_executable(cbmreco_fairrun ${APP_SOURCES} ${APP_HEADERS})
+
+target_include_directories(cbmreco_fairrun SYSTEM PUBLIC ${Boost_INCLUDE_DIRS})
+
+# This will no longer be necessary when the CbmRecoTasks library is set up to include this property
+target_include_directories(cbmreco_fairrun
+  PUBLIC ${CMAKE_SOURCE_DIR}/reco/tasks
+)
+
+# This will no longer be necessary when the Fairroot libraries are set up to include this property
+target_link_directories(cbmreco_fairrun
+  PUBLIC ${FAIRROOT_LIBRARY_DIR}
+)
+
+target_link_libraries(cbmreco_fairrun
+  fles_logging
+  CbmRecoTasks
+  Core
+  ${Boost_LIBRARIES}
+)
+
+install(TARGETS cbmreco_fairrun DESTINATION bin)

reco/app/cbmreco_fairrun/ProgramOptions.cxx

+/* Copyright (C) 2022 Johann Wolfgang Goethe-Universitaet Frankfurt, Frankfurt am Main
+   SPDX-License-Identifier: GPL-3.0-only
+   Authors: Jan de Cuveland [committer] */
+
+#include "ProgramOptions.h"
+
+#include <boost/program_options.hpp>
+
+#include <fstream>
+#include <iostream>
+
+#include "log.hpp"
+
+namespace po = boost::program_options;
+
+void ProgramOptions::ParseOptions(int argc, char* argv[])
+{
+  unsigned log_level  = 2;
+  unsigned log_syslog = 2;
+  std::string log_file;
+  std::string options_file;
+
+  // --- Define generic options
+  po::options_description generic("Generic options");
+  auto generic_add = generic.add_options();
+  generic_add("options-file,f", po::value<std::string>(&options_file)->value_name("<filename>"),
+              "read program options from file");
+  generic_add("log-level,l", po::value<unsigned>(&log_level)->default_value(log_level)->value_name("<n>"),
+              "set the file log level (all:0)");
+  generic_add("log-file,L", po::value<std::string>(&log_file)->value_name("<filename>"), "write log output to file");
+  generic_add("log-syslog,S", po::value<unsigned>(&log_syslog)->implicit_value(log_syslog)->value_name("<n>"),
+              "enable logging to syslog at given log level");
+  generic_add("help,h", "display this help and exit");
+  generic_add("version,V", "output version information and exit");
+
+  // --- Define configuration options
+  po::options_description config("Configuration");
+  auto config_add = config.add_options();
+  config_add(
+    "input,i",
+    po::value<std::vector<std::string>>()->multitoken()->value_name("scheme://host/path?param=value ... | <filename>"),
+    "uri of a timeslice source");
+  config_add("output-root,o",
+             po::value<std::string>(&fOutputRootFile)->default_value(fOutputRootFile)->value_name("<filename>"),
+             "name of an output root file to write");
+  config_add("config,c", po::value<std::string>(&fConfigYamlFile)->value_name("<filename>"),
+             "name of a yaml config file containing the reconstruction chain configuration");
+  config_add("save-config", po::value<std::string>(&fSaveConfigYamlFile)->value_name("<filename>"),
+             "save configuration to yaml file (mostly for debugging)");
+  config_add("max-timeslice-number,n", po::value<int32_t>(&fMaxNumTs)->value_name("<n>"),
+             "quit after processing given number of timeslices (default: unlimited)");
+
+  po::options_description cmdline_options("Allowed options");
+  cmdline_options.add(generic).add(config);
+
+  po::variables_map vm;
+  po::store(po::parse_command_line(argc, argv, cmdline_options), vm);
+  po::notify(vm);
+
+  // --- Read program options from file if requested
+  if (!options_file.empty()) {
+    std::ifstream ifs(options_file.c_str());
+    if (!ifs) { throw ProgramOptionsException("cannot open options file: " + options_file); }
+    po::store(po::parse_config_file(ifs, config), vm);
+    notify(vm);
+  }
+
+  if (vm.count("help") != 0u) {
+    std::cout << cmdline_options << std::endl;
+    exit(EXIT_SUCCESS);
+  }
+
+  if (vm.count("version") != 0u) {
+    std::cout << "cbmreco, version (unspecified)" << std::endl;
+    exit(EXIT_SUCCESS);
+  }
+
+  // --- Set up logging
+  logging::add_console(static_cast<severity_level>(log_level));
+  if (vm.count("log-file") != 0u) {
+    L_(info) << "Logging output to " << log_file;
+    logging::add_file(log_file, static_cast<severity_level>(log_level));
+  }
+  if (vm.count("log-syslog") != 0u) {
+    logging::add_syslog(logging::syslog::local0, static_cast<severity_level>(log_syslog));
+  }
+
+  if (vm.count("input") == 0u) { throw ProgramOptionsException("no input source specified"); }
+  fInputUri = vm["input"].as<std::vector<std::string>>();
+
+  if (vm.count("config") == 0u) { throw ProgramOptionsException("no configuration file specified"); }
+
+  L_(debug) << "input sources (" << fInputUri.size() << "):";
+  for (auto& inputUri : fInputUri) {
+    L_(debug) << "  " << inputUri;
+  }
+}

reco/app/cbmreco_fairrun/ProgramOptions.h

+/* Copyright (C) 2022 Johann Wolfgang Goethe-Universitaet Frankfurt, Frankfurt am Main
+   SPDX-License-Identifier: GPL-3.0-only
+   Authors: Jan de Cuveland [committer] */
+
+#ifndef APP_CBMRECO_PROGRAMOPTIONS_H
+#define APP_CBMRECO_PROGRAMOPTIONS_H
+
+#include <cstdint>
+#include <stdexcept>
+#include <string>
+#include <vector>
+
+/** @class ProgramOptionsException
+ ** @brief Program options exception class
+ ** @author Jan de Cuveland <cuveland@compeng.uni-frankfurt.de>
+ ** @since 16 March 2022
+ **/
+class ProgramOptionsException : public std::runtime_error {
+public:
+  explicit ProgramOptionsException(const std::string& what_arg = "") : std::runtime_error(what_arg) {}
+};
+
+/** @class ProgramOptions
+ ** @brief Program options class for the "cbmreco_fairrun" application
+ ** @author Jan de Cuveland <cuveland@compeng.uni-frankfurt.de>
+ ** @since 16 March 2022
+ **/
+class ProgramOptions {
+public:
+  /** @brief Standard constructor with command line arguments **/
+  ProgramOptions(int argc, char* argv[]) { ParseOptions(argc, argv); }
+
+  /** @brief Copy constructor forbidden **/
+  ProgramOptions(const ProgramOptions&) = delete;
+
+  /** @brief Assignment operator forbidden **/
+  void operator=(const ProgramOptions&) = delete;
+
+  /** @brief Get URI specifying input timeslice stream source(s) **/
+  [[nodiscard]] const std::vector<std::string>& InputUri() const { return fInputUri; }
+
+  /** @brief Get output file name (.root format) **/
+  [[nodiscard]] const std::string& OutputRootFile() const { return fOutputRootFile; }
+
+  /** @brief Get configuration file name (.yaml format) **/
+  [[nodiscard]] const std::string& ConfigYamlFile() const { return fConfigYamlFile; }
+
+  /** @brief Get save configuration file name (.yaml format) **/
+  [[nodiscard]] const std::string& SaveConfigYamlFile() const { return fSaveConfigYamlFile; }
+
+  /** @brief Get maximum number of timeslices to process **/
+  [[nodiscard]] int32_t MaxNumTs() const { return fMaxNumTs; }
+
+private:
+  /** @brief Parse command line arguments using boost program_options **/
+  void ParseOptions(int argc, char* argv[]);
+
+  std::vector<std::string> fInputUri;         ///< URI(s) specifying input timeslice stream source(s)
+  std::string fOutputRootFile = "/dev/null";  ///< Output file name (.root format)
+  std::string fConfigYamlFile;                ///< Configuration file name (.yaml format)
+  std::string fSaveConfigYamlFile;            ///< Save configuration file name (.yaml format)
+  int32_t fMaxNumTs = INT32_MAX;              ///< Maximum number of timeslices to process
+};
+
+#endif /* APP_CBMRECO_PROGRAMOPTIONS_H */

reco/app/cbmreco_fairrun/main.cxx

+/* Copyright (C) 2022 Johann Wolfgang Goethe-Universitaet Frankfurt, Frankfurt am Main
+   SPDX-License-Identifier: GPL-3.0-only
+   Authors: Jan de Cuveland [committer] */
+
+#include "Application.h"
+#include "ProgramOptions.h"
+#include "log.hpp"
+
+int main(int argc, char* argv[])
+{
+  try {
+    ProgramOptions opt(argc, argv);
+    Application app(opt);
+    app.Run();
+  }
+  catch (std::exception const& e) {
+    L_(fatal) << e.what();
+    return EXIT_FAILURE;
+  }
+
+  L_(info) << "exiting";
+  return EXIT_SUCCESS;
+}

reco/tasks/CMakeLists.txt

@@ -68,6 +68,7 @@ Base
 CbmBase
 CbmData
 Algo
+external::yaml-cpp
 )
 # ---------------------------------------------------------
 

reco/tasks/CbmReco.cxx

@@ -22,12 +22,68 @@
 #include <memory>
 #include <string>
 
+#include <yaml-cpp/yaml.h>
+
 using std::cout;
 using std::endl;
 using std::make_unique;
 using std::string;
 
 
+// -----   Load configuration from YAML file   --------------------------------
+void CbmRecoConfig::LoadYaml(const std::string& filename)
+{
+  YAML::Node config = YAML::LoadFile(filename);
+  // --- Digi trigger
+  fTriggerDet       = ToCbmModuleIdCaseInsensitive(config["trigger"]["detector"].as<std::string>());
+  fTriggerWin       = config["trigger"]["window"].as<double>();
+  fTriggerThreshold = config["trigger"]["threshold"].as<size_t>();
+  fTriggerDeadTime  = config["trigger"]["deadtime"].as<double>();
+  // --- Event builder: (detector -> (tMin, tMax))
+  if (auto eventbuilder = config["eventbuilder"]) {
+    if (auto windows = eventbuilder["windows"]) {
+      for (YAML::const_iterator it = windows.begin(); it != windows.end(); ++it) {
+        auto det              = ToCbmModuleIdCaseInsensitive(it->first.as<std::string>());
+        auto lower            = it->second[0].as<double>();
+        auto upper            = it->second[1].as<double>();
+        fEvtbuildWindows[det] = std::make_pair(lower, upper);
+      }
+    }
+  }
+  // --- Branch persistence in output file
+  fStoreTimeslice = config["store"]["timeslice"].as<bool>();
+  fStoreTrigger   = config["store"]["triggers"].as<bool>();
+  fStoreEvents    = config["store"]["events"].as<bool>();
+}
+// ----------------------------------------------------------------------------
+
+
+// -----   Save configuration to YAML file   ----------------------------------
+void CbmRecoConfig::SaveYaml(const std::string& filename)
+{
+  YAML::Node config;
+  // --- Digi trigger
+  config["trigger"]["detector"]  = ToString(fTriggerDet);
+  config["trigger"]["window"]    = fTriggerWin;
+  config["trigger"]["threshold"] = fTriggerThreshold;
+  config["trigger"]["deadtime"]  = fTriggerDeadTime;
+  // --- Event builder: (detector -> (tMin, tMax))
+  for (const auto& [key, value] : fEvtbuildWindows) {
+    auto det = ToString(key);
+    config["eventbuilder"]["windows"][det].push_back(value.first);
+    config["eventbuilder"]["windows"][det].push_back(value.second);
+  };
+  // --- Branch persistence in output file
+  config["store"]["timeslice"] = fStoreTimeslice;
+  config["store"]["triggers"]  = fStoreTrigger;
+  config["store"]["events"]    = fStoreEvents;
+  // ---
+  std::ofstream fout(filename);
+  fout << config;
+}
+// ----------------------------------------------------------------------------
+
+
 // -----   Constructor from single source   -----------------------------------
 CbmReco::CbmReco(string source, TString outFile, int32_t numTs, const CbmRecoConfig& config, uint16_t port)
   : fSourceNames {source}

reco/tasks/CbmReco.h

@@ -32,6 +32,9 @@ public:
   bool fStoreTimeslice = false;
   bool fStoreTrigger   = false;
   bool fStoreEvents    = false;
+  // --- Load/save using yaml-cpp
+  void LoadYaml(const std::string& filename);
+  void SaveYaml(const std::string& filename);
   // --- Destructor
   virtual ~CbmRecoConfig() {};
 

reco/tasks/CbmRecoConfigExample.yaml

+trigger:
+  detector: STS
+  window: 10
+  threshold: 100
+  deadtime: 50
+eventbuilder:
+  windows:
+    STS: [-20, 30]
+store:
+  timeslice: false
+  triggers: false
+  events: true