ParameterSet.hpp

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

// This file is part of the Acts project.
//
// Copyright (C) 2016-2020 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/EventData/detail/DifferenceCalculator.hpp"
#include "Acts/EventData/detail/ValueCorrector.hpp"
#include "Acts/EventData/detail/full_parameter_set.hpp"
#include "Acts/EventData/detail/initialize_parameter_set.hpp"
#include "Acts/EventData/detail/make_projection_matrix.hpp"
#include "Acts/Utilities/Definitions.hpp"
#include "Acts/Utilities/ParameterDefinitions.hpp"
#include "Acts/Utilities/detail/MPL/are_sorted.hpp"
#include "Acts/Utilities/detail/MPL/are_within.hpp"
#include "Acts/Utilities/detail/MPL/at_index.hpp"
#include "Acts/Utilities/detail/MPL/get_position.hpp"
#include "Acts/Utilities/detail/MPL/is_contained.hpp"

#include <optional>
#include <type_traits>

namespace Acts {

// Parameter sets corresponding to the full parameters vector
using FullBoundParameterSet = typename detail::full_parset<BoundIndices>::type;
using FullFreeParameterSet = typename detail::full_parset<FreeIndices>::type;

template <typename parameter_indices_t, parameter_indices_t... params>
class ParameterSet {
 private:
  static constexpr unsigned int kNumberOfParameters = sizeof...(params);
  static constexpr unsigned int kSizeMax =
      detail::kParametersSize<parameter_indices_t>;

  // static assert to check that the template parameters are consistent
  static_assert(
      detail::are_sorted<true, true, parameter_indices_t, params...>::value,
      "parameter identifiers are not sorted");
  static_assert(
      detail::are_within<unsigned int, 0, kSizeMax,
                         static_cast<unsigned int>(params)...>::value,
      "parameter identifiers must be greater or "
      "equal to zero and smaller than the total number of parameters");
  static_assert(kNumberOfParameters > 0,
                "number of stored parameters can not be zero");
  static_assert(
      kNumberOfParameters <= kSizeMax,
      "number of stored parameters can not exceed number of total parameters");

 public:
  using Scalar = detail::ParametersScalar<parameter_indices_t>;
  using ParametersVector = ActsVector<Scalar, kNumberOfParameters>;
  using FullParametersVector = ActsVector<Scalar, kSizeMax>;
  using CovarianceMatrix = ActsSymMatrix<Scalar, kNumberOfParameters>;
  using ProjectionMatrix = ActsMatrix<Scalar, kNumberOfParameters, kSizeMax>;

  template <typename... Tail>
  ParameterSet(
      std::optional<CovarianceMatrix> cov,
      std::enable_if_t<sizeof...(Tail) + 1 == kNumberOfParameters, Scalar> head,
      Tail... values)
      : m_vValues(kNumberOfParameters) {
    if (cov) {
      m_optCovariance = std::move(*cov);
    }
    detail::initialize_parset<parameter_indices_t, params...>::init_vals(
        *this, head, values...);
  }

  ParameterSet(std::optional<CovarianceMatrix> cov,
               const ParametersVector& values)
      : m_vValues(kNumberOfParameters) {
    if (cov) {
      m_optCovariance = std::move(*cov);
    }
    detail::initialize_parset<parameter_indices_t, params...>::init_vec(*this,
                                                                        values);
  }

  // this class does not have a custom default constructor and thus should not
  // provide any custom default cstors, dstor, or assignment. see ISOCPP C.20.

  template <parameter_indices_t parameter>
  static constexpr size_t getIndex() {
    return detail::get_position<parameter_indices_t, parameter,
                                params...>::value;
  }

  template <size_t index>
  static constexpr parameter_indices_t getParameterIndex() {
    return detail::at_index<parameter_indices_t, index, params...>::value;
  }

  template <parameter_indices_t parameter>
  Scalar getParameter() const {
    return m_vValues(getIndex<parameter>());
  }

  const ParametersVector& getParameters() const { return m_vValues; }

  template <parameter_indices_t parameter>
  void setParameter(Scalar value) {
    m_vValues(getIndex<parameter>()) =
        detail::ParameterTraits<parameter_indices_t, parameter>::getValue(
            value);
  }

  void setParameters(const ParametersVector& values) {
    detail::initialize_parset<parameter_indices_t, params...>::init_vec(*this,
                                                                        values);
  }

  template <parameter_indices_t parameter>
  bool contains() const {
    return detail::is_contained<parameter_indices_t, parameter,
                                params...>::value;
  }

  const std::optional<CovarianceMatrix>& getCovariance() const {
    return m_optCovariance;
  }

  template <parameter_indices_t parameter>
  Scalar getUncertainty() const {
    if (m_optCovariance) {
      size_t index = getIndex<parameter>();
      return sqrt((*m_optCovariance)(index, index));
    } else {
      return -1;
    }
  }

  void setCovariance(const CovarianceMatrix& cov) { m_optCovariance = cov; }

  ParametersVector residual(const FullParametersVector& other) const {
    return detail::DifferenceCalculator<parameter_indices_t, params...>::run(
        m_vValues, projector() * other);
  }

  ParametersVector residual(const ParameterSet& otherParSet) const {
    return detail::DifferenceCalculator<parameter_indices_t, params...>::run(
        m_vValues, otherParSet.m_vValues);
  }

  static const ProjectionMatrix& projector() { return sProjector; }

  static constexpr unsigned int size() { return kNumberOfParameters; }

  static void correctValues(ParametersVector& values) {
    detail::ValueCorrector<parameter_indices_t, params...>::run(values);
  }

  bool operator==(const ParameterSet& other) const {
    return (this == &other) or ((m_vValues == other.m_vValues) and
                                (m_optCovariance == other.m_optCovariance));
  }
  bool operator!=(const ParameterSet& other) const { return !(*this == other); }

 private:
  ParametersVector m_vValues{ParametersVector::Zero()};
  std::optional<CovarianceMatrix> m_optCovariance{std::nullopt};

  static const ProjectionMatrix sProjector;
};

template <typename parameter_indices_t, parameter_indices_t... kParameters>
const typename ParameterSet<parameter_indices_t,
                            kParameters...>::ProjectionMatrix
    ParameterSet<parameter_indices_t, kParameters...>::sProjector =
        detail::make_projection_matrix<
            kSizeMax, static_cast<unsigned int>(kParameters)...>::init();

}  // namespace Acts