Measurement.hpp

Go to the documentation of this file. Or view the newest version in sPHENIX GitHub for file Measurement.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/Definitions/TrackParametrization.hpp"
#include "Acts/EventData/SourceLink.hpp"
#include "Acts/EventData/detail/CalculateResiduals.hpp"
#include "Acts/EventData/detail/ParameterTraits.hpp"
#include "Acts/EventData/detail/PrintParameters.hpp"
#include "Acts/Utilities/detail/Subspace.hpp"

#include <array>
#include <cstddef>
#include <iosfwd>
#include <variant>

namespace Acts {

template <typename indices_t, size_t kSize>
class Measurement {
  static constexpr size_t kFullSize = detail::kParametersSize<indices_t>;

  using Subspace = detail::FixedSizeSubspace<kFullSize, kSize>;

 public:
  using Scalar = ActsScalar;
  using ParametersVector = ActsVector<kSize>;
  using CovarianceMatrix = ActsSquareMatrix<kSize>;
  using FullParametersVector = ActsVector<kFullSize>;
  using ProjectionMatrix = ActsMatrix<kSize, kFullSize>;
  using ExpansionMatrix = ActsMatrix<kFullSize, kSize>;

  template <typename parameters_t, typename covariance_t>
  Measurement(SourceLink source, const std::array<indices_t, kSize>& indices,
              const Eigen::MatrixBase<parameters_t>& params,
              const Eigen::MatrixBase<covariance_t>& cov)
      : m_source(std::move(source)),
        m_subspace(indices),
        m_params(params),
        m_cov(cov) {
    // TODO we should be able to support arbitrary ordering, by sorting the
    //   indices and reordering parameters/covariance. since the parameter order
    //   can be modified by the user, the user can not always know what the
    //   right order is. another option is too remove the requirement for index
    //   ordering from the subspace types, but that will make it harder to
    //   refactor their implementation later on.
  }
  Measurement() = delete;
  Measurement(const Measurement&) = default;
  Measurement(Measurement&&) = default;
  ~Measurement() = default;
  Measurement& operator=(const Measurement&) = default;
  Measurement& operator=(Measurement&&) = default;

  const SourceLink& sourceLink() const { return m_source; }

  static constexpr size_t size() { return kSize; }

  bool contains(indices_t i) const { return m_subspace.contains(i); }

  constexpr std::array<indices_t, kSize> indices() const {
    std::array<uint8_t, kSize> subInds = m_subspace.indices();
    std::array<indices_t, kSize> inds{};
    for (size_t i = 0; i < kSize; i++) {
      inds[i] = static_cast<indices_t>(subInds[i]);
    }
    return inds;
  }

  const ParametersVector& parameters() const { return m_params; }

  const CovarianceMatrix& covariance() const { return m_cov; }

  ProjectionMatrix projector() const {
    return m_subspace.template projector<Scalar>();
  }

  ExpansionMatrix expander() const {
    return m_subspace.template expander<Scalar>();
  }

  ParametersVector residuals(const FullParametersVector& reference) const {
    ParametersVector res = ParametersVector::Zero();
    detail::calculateResiduals(static_cast<indices_t>(kSize),
                               m_subspace.indices(), reference, m_params, res);
    return res;
  }

  std::ostream& operator<<(std::ostream& os) const {
    detail::printMeasurement(os, static_cast<indices_t>(kSize),
                             m_subspace.indices().data(), m_params.data(),
                             m_cov.data());
    return os;
  }

 private:
  SourceLink m_source;
  Subspace m_subspace;
  ParametersVector m_params;
  CovarianceMatrix m_cov;
};

template <typename parameters_t, typename covariance_t, typename indices_t,
          typename... tail_indices_t>
auto makeMeasurement(SourceLink source,
                     const Eigen::MatrixBase<parameters_t>& params,
                     const Eigen::MatrixBase<covariance_t>& cov,
                     indices_t index0, tail_indices_t... tailIndices)
    -> Measurement<indices_t, 1u + sizeof...(tail_indices_t)> {
  using IndexContainer = std::array<indices_t, 1u + sizeof...(tail_indices_t)>;
  return {std::move(source), IndexContainer{index0, tailIndices...}, params,
          cov};
}

namespace detail {

// Recursive construction of the measurement variant. `kN` is counted down until
// zero while the sizes are accumulated in the parameter pack.
//
// Example:
//
//        VariantMeasurementGenerator<..., 4>
//     -> VariantMeasurementGenerator<..., 3, 4>
//     -> VariantMeasurementGenerator<..., 2, 3, 4>
//     -> VariantMeasurementGenerator<..., 1, 2, 3, 4>
//     -> VariantMeasurementGenerator<..., 0, 1, 2, 3, 4>
//
template <typename indices_t, size_t kN, size_t... kSizes>
struct VariantMeasurementGenerator
    : VariantMeasurementGenerator<indices_t, kN - 1u, kN, kSizes...> {};
template <typename indices_t, size_t... kSizes>
struct VariantMeasurementGenerator<indices_t, 0u, kSizes...> {
  using Type = std::variant<Measurement<indices_t, kSizes>...>;
};

}  // namespace detail

template <typename indices_t>
using VariantMeasurement = typename detail::VariantMeasurementGenerator<
    indices_t, detail::kParametersSize<indices_t>>::Type;

using BoundVariantMeasurement = VariantMeasurement<BoundIndices>;

using FreeVariantMeasurement = VariantMeasurement<FreeIndices>;

template <typename indices_t>
std::ostream& operator<<(std::ostream& os,
                         const VariantMeasurement<indices_t>& vm) {
  return std::visit([&](const auto& m) { return (os << m); }, vm);
}

}  // namespace Acts