DD4hepConversionHelpers.hpp

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

// This file is part of the Acts project.
//
// Copyright (C) 2017-2018 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/.

#pragma once

#include "Acts/Definitions/Algebra.hpp"
#include "Acts/Definitions/Common.hpp"

#include <DD4hep/DetElement.h>
#include <DD4hep/DetFactoryHelper.h>
#include <DD4hep/Objects.h>
#include <DDRec/DetectorData.h>

namespace Acts {

template <typename T>
T getParam(const std::string& key, dd4hep::DetElement& elt) {
  auto* params = elt.extension<dd4hep::rec::VariantParameters>(false);
  if (params == nullptr) {
    throw std::runtime_error{"Detector Element has no VariantParameters"};
  }
  return params->get<T>(key);
}

inline dd4hep::rec::VariantParameters& getParams(dd4hep::DetElement& elt) {
  auto* params = elt.extension<dd4hep::rec::VariantParameters>(false);
  if (params == nullptr) {
    throw std::runtime_error{"Detector Element has no VariantParameters"};
  }
  return *params;
}

inline const dd4hep::rec::VariantParameters& getParams(
    const dd4hep::DetElement& elt) {
  const auto* params = elt.extension<dd4hep::rec::VariantParameters>(false);
  if (params == nullptr) {
    throw std::runtime_error{"Detector Element has no VariantParameters"};
  }
  return *params;
}

template <typename T>
T getParamOr(const std::string& key, const dd4hep::DetElement& elt,
             T alternative) {
  auto* params = elt.extension<dd4hep::rec::VariantParameters>(false);
  if (params == nullptr) {
    return alternative;
  }
  return params->value_or<T>(key, alternative);
}

inline bool hasParam(const std::string& key, dd4hep::DetElement& elt) {
  auto* params = elt.extension<dd4hep::rec::VariantParameters>(false);
  if (params == nullptr) {
    return false;
  }
  return params->contains(key);
}

inline bool hasParams(dd4hep::DetElement& elt) {
  return elt.extension<dd4hep::rec::VariantParameters>(false) != nullptr;
}

template <typename value_type>
value_type getAttrValueOr(const dd4hep::xml::Component& node,
                          const std::string& attrName,
                          const value_type& fallbackValue) {
  if (node.hasAttr(dd4hep::xml::Strng_t(attrName.c_str()))) {
    return node.attr<value_type>(attrName.c_str());
  } else {
    return fallbackValue;
  }
}

template <typename value_type>
std::vector<value_type> extractSeries(const dd4hep::DetElement& dd4hepElement,
                                      const std::string& bname,
                                      const value_type& unitConversion = 1) {
  std::vector<value_type> series = {};

  int fallBack = 0;
  int nVals = getParamOr<int>(bname + "_n", dd4hepElement, fallBack);
  series.reserve(nVals);
  for (auto ib = 0; ib < nVals; ++ib) {
    auto val = unitConversion *
               getParamOr<value_type>(bname + "_" + std::to_string(ib),
                                      dd4hepElement, 0.);
    series.push_back(val);
  }
  return series;
}

inline Transform3 extractTransform(const dd4hep::DetElement& dd4hepElement,
                                   const std::string& bname,
                                   const ActsScalar unitConversion = 1.) {
  Transform3 transform = Transform3::Identity();
  ActsScalar x =
      unitConversion * getParamOr<ActsScalar>(bname + "_x", dd4hepElement, 0.);
  ActsScalar y =
      unitConversion * getParamOr<ActsScalar>(bname + "_y", dd4hepElement, 0.);
  ActsScalar z =
      unitConversion * getParamOr<ActsScalar>(bname + "_z", dd4hepElement, 0.);
  transform.pretranslate(Vector3(x, y, z));
  return transform;
}

}  // namespace Acts