CaConfigReader.cxx

Go to the documentation of this file.

/* Copyright (C) 2022-2023 GSI Helmholtzzentrum fuer Schwerionenforschung, Darmstadt
   SPDX-License-Identifier: GPL-3.0-only
   Authors: Sergei Zharko [committer] */

 
#include "CaConfigReader.h"
 
#include "CaDefs.h"
 
#include <boost/algorithm/string.hpp>
 
#include <iostream>
#include <numeric>
#include <sstream>
#include <unordered_map>
 
#include <yaml-cpp/yaml.h>
 
using cbm::algo::ca::Config;
using cbm::algo::ca::ConfigReader;
using cbm::algo::ca::EDetectorID;
using cbm::algo::ca::Iteration;
 
// ---------------------------------------------------------------------------------------------------------------------
//
ConfigReader::ConfigReader(int verbose) : fVerbose(verbose) {}
 
// ---------------------------------------------------------------------------------------------------------------------
//
// TODO: switch to the Yaml library by Felix
YAML::Node ConfigReader::GetNode(std::function<YAML::Node(YAML::Node)> fn, bool optional) const
{
  auto node = YAML::Node(YAML::NodeType::Undefined);
  if (fUserConfigNode) {
    node = fn(fUserConfigNode);
  }
  if (!node) {
    node = fn(fMainConfigNode);
  }
  if (!node && !optional) {
    std::stringstream msg;
    msg << "requested node was not found ";
    if (fUserConfigNode) {
      msg << "either in user config (path: " << fsUserConfigPath << ") or ";
    }
    msg << "in main config (path: " << fsMainConfigPath << ")";
    throw std::runtime_error(msg.str());
  }
  return node;
}
 
// ---------------------------------------------------------------------------------------------------------------------
//
std::vector<std::string> ConfigReader::GetNodeKeys(const YAML::Node& node) const
{
  std::vector<std::string> res;
  res.reserve(node.size());
  try {
    for (const auto& item : node) {
      res.push_back(item.first.as<std::string>());
    }
  }
  catch (const YAML::InvalidNode& exc) {
    LOG(warn)
      << "L1 config: attempt to call ConfigReader::GetNodeKeys for node, keys of which could not be represented "
      << "with strings. An empty vector will be returned";
    std::vector<std::string>().swap(res);
  }
  return res;
}
 
// ---------------------------------------------------------------------------------------------------------------------
//
std::vector<Iteration> ConfigReader::ReadCAIterationVector() const
{
  std::vector<Iteration> res;
 
  // Read iterations store
  std::unordered_map<std::string, Iteration> mPossibleIterations;
  {
    auto currentNode = fMainConfigNode["possible_iterations"];
    assert(currentNode);
    for (const auto& iterNode : currentNode) {
      std::string thisIterName = iterNode["name"].as<std::string>("");
      std::string baseIterName = iterNode["base_iteration"].as<std::string>("");
 
      if (baseIterName.size()) {  // Create iteration from previously defined one
        if (mPossibleIterations.find(baseIterName) == mPossibleIterations.end()) {
          std::stringstream msg;
          msg << "A CA iteration \"" << thisIterName << "\" requires a base iteration with name \"" << baseIterName
              << "\", which was not registered yet. Please, place an entry with the requested base iteration above "
              << "in the possible_iterations node";
          throw std::runtime_error(std::move(msg.str()));
        }
        mPossibleIterations[thisIterName] = ReadSingleCAIteration(iterNode, mPossibleIterations.at(baseIterName));
      }
      else {
        mPossibleIterations[thisIterName] = ReadSingleCAIteration(iterNode, Iteration());
      }
    }
  }
 
  // Read actual iteration sequence
  //
  if (fUserConfigNode) {
    if (fVerbose >= 1) {
      LOG(info) << "- Reading user iterations ";
    }
 
    auto currentNode = fUserConfigNode["core"]["track_finder"]["iterations"];
    if (currentNode) {
      for (const auto& iterNode : currentNode) {
        std::string thisIterName = iterNode["name"].as<std::string>("");
        std::string baseIterName = iterNode["base_iteration"].as<std::string>("");
        if (fVerbose >= 2) {
          LOG(info) << "- Reading user iteration " << thisIterName << "(" << baseIterName << ")";
        }
        if (mPossibleIterations.find(thisIterName) != mPossibleIterations.end()) {
          // This is an update of existing possible iteration
          res.push_back(ReadSingleCAIteration(iterNode, mPossibleIterations.at(thisIterName)));
        }
        else if (mPossibleIterations.find(baseIterName) != mPossibleIterations.end()) {
          // This is a user iteration based on the existing possible iteration
          res.push_back(ReadSingleCAIteration(iterNode, mPossibleIterations.at(baseIterName)));
        }
        else {
          // Try to find a base iteration from user-defined
          auto itFound = std::find_if(res.begin(), res.end(), [&](auto& i) { return i.GetName() == baseIterName; });
          if (itFound != res.end()) {
            res.push_back(ReadSingleCAIteration(iterNode, *itFound));
          }
          else {
            res.push_back(ReadSingleCAIteration(iterNode, Iteration()));
          }
        }
      }
    }
  }
 
  if (res.size() == 0) {
    auto currentNode = fMainConfigNode["core"]["track_finder"]["iteration_sequence"];
    assert(currentNode);
    assert(currentNode.size());
    for (const auto& iterNode : currentNode) {
      std::string thisIterName = iterNode.as<std::string>();
      if (mPossibleIterations.find(thisIterName) == mPossibleIterations.end()) {
        std::stringstream msg;
        msg << "Unknow iteration in the iteration sequence, defined in main config file: " << thisIterName;
        throw std::runtime_error(std::move(msg.str()));
      }
      res.push_back(mPossibleIterations.at(thisIterName));
    }
  }
 
  return res;
}
 
// ---------------------------------------------------------------------------------------------------------------------
//
std::vector<std::pair<EDetectorID, int>> ConfigReader::ReadInactiveStationMap() const
{
  std::vector<std::pair<EDetectorID, int>> res;
 
  // Check, if the "skip_stations" branch exists either in the user config or in the main config
  std::string sNodePath = "ca/core/common/inactive_stations";
  auto node             = GetNode([](YAML::Node n) { return n["core"]["common"]["inactive_stations"]; }, true);
  if (!node || node.size() == 0) {
    return res;
  }
 
  // Fill map of inactive stations
  res.reserve(node.size());
  for (const auto& item : node) {
    std::string nodeVal = item.as<std::string>();
 
    // Check contents
    if (nodeVal.empty()) {
      continue;
    }
 
    // Check for spaces, tabs and new line characters
    if (std::any_of(nodeVal.begin(), nodeVal.end(), [](auto c) { return c == ' ' || c == '\t' || c == '\n'; })) {
      throw std::runtime_error(
        fmt::format("Station name passed in YAML branch {} contains illegal characters: {}", sNodePath, nodeVal));
    }
 
    // Parse the {detId, locId} from the node value
    std::vector<std::string> nodeValParts;
    boost::algorithm::split(nodeValParts, nodeVal, boost::is_any_of(":"));
    if (nodeValParts.size() > 2) {
      throw std::runtime_error(
        fmt::format("Station name passed in YAML branch {} contains to many colon characters (max 2 allowed): {}",
                    sNodePath, nodeVal));
    }
 
    //auto detIdOpt = cbm::util::FromString<EDetectorID>(nodeValParts[0]);
 
    auto itDetName = fDetNameMap.find(boost::algorithm::to_lower_copy(nodeValParts[0]));
    if (itDetName == fDetNameMap.end()) {
      throw std::runtime_error(
        fmt::format("Detector name {} passed in YAML branch {} is not supported by CA. Please ensure, that "
                    "the detector is registered in enum class EDetectorID",
                    nodeValParts[0], sNodePath));
    }
 
    EDetectorID detId = itDetName->second;
    if (nodeValParts.size() == 1) {
      res.emplace_back(detId, -1);  // Disable all stations for this det. ID
      continue;
    }
 
    int locId{-1};  // All stations for this detId will be disabled, if nodeValParts.size() != 2
    // Try to parse the locId
    try {
      locId = std::stoi(nodeValParts[1]);
    }
    catch (const std::exception& err) {
      throw std::runtime_error(fmt::format("Could not convert the {} to integral locId value (node {}, branch {})",
                                           nodeValParts[1], nodeVal, sNodePath));
    }
 
    if (locId < -1) {
      throw std::runtime_error(
        fmt::format("Illegal station locId passed in the node {} in YAML branch {}. The possible values are: "
                    "-1 to disable all stations, non-negative integer to disable a single station",
                    locId, sNodePath));
    }
    res.emplace_back(detId, locId);
  }
  return res;
}
 
// ---------------------------------------------------------------------------------------------------------------------
//
Config::MisalignmentTolArray_t ConfigReader::ReadMisalignmentTolerances() const
{
  Config::MisalignmentTolArray_t res;
  std::string sNodePath = "ca/core/common/misalignment_tolerance";
  auto node             = GetNode([](YAML::Node n) { return n["core"]["common"]["misalignment_tolerance"]; }, true);
  if (!node || node.size() == 0) {
    return res;
  }
 
  for (const auto& item : node) {
    std::string detName = boost::algorithm::to_lower_copy(item.first.as<std::string>());
    auto it             = fDetNameMap.find(detName);
    if (it == fDetNameMap.end()) {
      throw std::runtime_error(
        fmt::format("Detector name {} passed in YAML branch {} is not supported by CA. Please ensure, that "
                    "the detector is registered in enum class EDetectorID",
                    item.first.as<std::string>(), sNodePath));
    }
 
    auto detId = it->second;
    auto v     = item.second.as<std::vector<float>>();
    if (v.size() != 3) {
      throw std::runtime_error(fmt::format("Illegal number of elements, provided to initialize misalignment "
                                           "tolerances ({} != 3)",
                                           v.size()));
    }
    res[static_cast<int>(detId)] = MisalignmentTolerance{v[0], v[1], v[2]};
  }
 
  return res;
}
 
// ---------------------------------------------------------------------------------------------------------------------
//
Iteration ConfigReader::ReadSingleCAIteration(const YAML::Node& node, const Iteration& defaultIter) const
{
  auto iter = Iteration();
  try {
    iter.SetName(node["name"].as<std::string>());
    iter.SetTrackChi2Cut(node["track_chi2_cut"].as<float>(defaultIter.GetTrackChi2Cut()));
    iter.SetTripletChi2Cut(node["triplet_chi2_cut"].as<float>(defaultIter.GetTripletChi2Cut()));
    iter.SetTripletFinalChi2Cut(node["triplet_final_chi2_cut"].as<float>(defaultIter.GetTripletFinalChi2Cut()));
    iter.SetDoubletChi2Cut(node["doublet_chi2_cut"].as<float>(defaultIter.GetDoubletChi2Cut()));
    iter.SetPickGather(node["pick_gather"].as<float>(defaultIter.GetPickGather()));
    iter.SetTripletLinkChi2(node["triplet_link_chi2"].as<float>(defaultIter.GetTripletLinkChi2()));
    iter.SetMaxQp(node["max_qp"].as<float>(defaultIter.GetMaxQp()));
    iter.SetMaxSlopePV(node["max_slope_pv"].as<float>(defaultIter.GetMaxSlopePV()));
    iter.SetMaxSlope(node["max_slope"].as<float>(defaultIter.GetMaxSlope()));
    iter.SetMaxDZ(node["max_dz"].as<float>(defaultIter.GetMaxDZ()));
    iter.SetTargetPosSigmaXY(node["target_pos_sigma_x"].as<float>(defaultIter.GetTargetPosSigmaX()),
                             node["target_pos_sigma_y"].as<float>(defaultIter.GetTargetPosSigmaY()));
    iter.SetFirstStationIndex(node["first_station_index"].as<int>(defaultIter.GetFirstStationIndex()));
    iter.SetPrimaryFlag(node["is_primary"].as<bool>(defaultIter.GetPrimaryFlag()));
    iter.SetElectronFlag(node["is_electron"].as<bool>(defaultIter.GetElectronFlag()));
    iter.SetTrackFromTripletsFlag(node["is_track_from_triplets"].as<bool>(defaultIter.GetTrackFromTripletsFlag()));
    iter.SetExtendTracksFlag(node["is_extend_tracks"].as<bool>(defaultIter.GetExtendTracksFlag()));
    iter.SetMaxStationGap(node["max_station_gap"].as<int>(defaultIter.GetMaxStationGap()));
    iter.SetMinNhits(node["min_n_hits"].as<int>(defaultIter.GetMinNhits()));
    iter.SetMinNhitsStation0(node["min_n_hits_station_0"].as<int>(defaultIter.GetMinNhitsStation0()));
  }
  catch (const YAML::InvalidNode& exc) {
    const auto nodeKeys = this->GetNodeKeys(node);
    const auto nodeKeysStr =
      std::accumulate(nodeKeys.cbegin(), nodeKeys.cend(), std::string(""),
                      [](std::string lhs, std::string rhs) { return std::move(lhs) + "\n\t" + std::move(rhs); });
    LOG(fatal) << "L1 config: attempt to access key which does not exist in the configuration file (message from "
               << "YAML exception: " << exc.what() << "). Defined keys: " << nodeKeysStr;
  }
  return iter;
}
 
// ---------------------------------------------------------------------------------------------------------------------
//
Config ConfigReader::CreateConfig() const
{
  return Config{std::move(ReadCAIterationVector()),
                std::move(yaml::Read<Config::Control>(GetNode([](YAML::Node n) { return n["core"]["track_finder"]; }))),
                std::move(yaml::Read<Config::Dev>(GetNode([](YAML::Node n) { return n["core"]["dev"]; }))),
                std::move(ReadMisalignmentTolerances())};
}
 
// ---------------------------------------------------------------------------------------------------------------------
//
void ConfigReader::SetDetectorNames(const std::array<std::string, constants::size::MaxNdetectors>& input)
{
  for (int iDet = 0; iDet < static_cast<int>(input.size()); ++iDet) {
    std::string detName = boost::algorithm::to_lower_copy(input[iDet]);
    if (!detName.empty()) {
      fDetNameMap[detName] = static_cast<EDetectorID>(iDet);
    }
  }
}
 
// ---------------------------------------------------------------------------------------------------------------------
//
void ConfigReader::SetMainConfigPath(const std::string& path)
{
  if (path.size()) {
    try {
      fsMainConfigPath = path;
      fMainConfigNode  = YAML::LoadFile(fsMainConfigPath)["ca"];
      if (fVerbose >= 1) {
        LOG(info) << "ConfigReader: Registering main configuraiton file: \"\033[1;32m" << path << "\033[0m\"";
      }
    }
    catch (const std::exception& err) {
      LOG(error) << "ERROR: " << err.what();
    }
  }
}
 
// ---------------------------------------------------------------------------------------------------------------------
//
void ConfigReader::SetUserConfigPath(const std::string& path)
{
  if (path.size()) {
    try {
      fsUserConfigPath = path;
      fUserConfigNode  = YAML::LoadFile(fsUserConfigPath)["ca"];
      if (fVerbose >= 1) {
        LOG(info) << "ConfigReader: Registering user configuraiton file: \"\033[1;32m" << path << "\033[0m\"";
      }
    }
    catch (const std::exception& err) {
      LOG(error) << "ERROR: " << err.what();
    }
  }
}