ActsExtension.hpp

Go to the documentation of this file. Or view the newest version in sPHENIX GitHub for file ActsExtension.hpp

// This file is part of the Acts project.
//
// Copyright (C) 2017-2019 CERN for the benefit of the Acts project
//
// This Source Code Form is subject to the terms of the Mozilla Public
// License, v. 2.0. If a copy of the MPL was not distributed with this
// file, You can obtain one at http://mozilla.org/MPL/2.0/.

// ActsExtension.hpp, Acts project, DD4hepDetector plugin

#pragma once

#include <string>
#include <utility>

#include "DD4hep/Detector.h"

namespace Acts {

class ActsExtension {
 public:
  // @param axes is the definition of the TGeo axes system w.r.t Acts
  ActsExtension(const std::string& axes = "XYZ");

  ActsExtension(const ActsExtension& ext) = default;

  ActsExtension(const ActsExtension& ext, const dd4hep::DetElement& elem);

  ~ActsExtension() = default;

  double getValue(const std::string& tag,
                  const std::string& category = "") const noexcept(false);

  void addValue(double value, const std::string& tag,
                const std::string& category = "");

  bool hasValue(const std::string& tag, const std::string& category = "") const;

  bool hasType(const std::string& type, const std::string& category = "") const;

  void addType(const std::string& type, const std::string& category = "",
               const std::string& word = "");

  const std::string getType(const std::string& type,
                            const std::string& category = "") const
      noexcept(false);

  std::string toString() const;

 private:
  template <typename T>
  void addT(std::map<std::string, T>& map, const T& val, const std::string& tag,
            const std::string& category, const T& catDeco);

  template <typename T>
  const T getT(const std::map<std::string, T>& map, const std::string& tag,
               const std::string& category = "") const noexcept(false);

  template <typename T>
  bool hasT(const std::map<std::string, T>& map, const std::string& tag,
            const std::string& category = "") const;

  std::map<std::string, std::string> m_flagStore;

  std::map<std::string, double> m_values;
};

// Templated helper method to get from the value/type store
template <typename T>
const T ActsExtension::getT(const std::map<std::string, T>& map,
                            const std::string& tag,
                            const std::string& category) const noexcept(false) {
  std::string ctag = "/";
  if (!category.empty()) {
    ctag += category;
    ctag += "/";
  }
  ctag += tag;
  auto search = map.find(ctag);
  if (search == map.end()) {
    std::string error_message = "Acts::ActsExtension does not contain: ";
    error_message += ctag;
    error_message += '\n';
    error_message += toString();
    throw std::runtime_error(error_message.c_str());
  }
  return search->second;
}

// Templated helper method to set from the value/type store
template <typename T>
void ActsExtension::addT(std::map<std::string, T>& map, const T& val,
                         const std::string& tag, const std::string& category,
                         const T& catDeco) {
  std::string ctag = "/";
  if (!category.empty()) {
    ctag += category;
    map[ctag] = catDeco;
    ctag += "/";
  }
  ctag += tag;
  map[ctag] = val;
}

// Templated helper method to get from the value/type store
template <typename T>
bool ActsExtension::hasT(const std::map<std::string, T>& map,
                         const std::string& tag,
                         const std::string& category) const {
  std::string ctag = "/";
  if (!category.empty()) {
    ctag += category;
    ctag += "/";
  }
  ctag += tag;
  auto search = map.find(ctag);
  return (search != map.end());
}

}  // namespace Acts