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/EventData/ParameterSet.hpp"
#include "Acts/EventData/SourceLinkConcept.hpp"
#include "Acts/EventData/TrackParameters.hpp"
#include "Acts/EventData/detail/fittable_type_generator.hpp"
#include "Acts/Geometry/Volume.hpp"
#include "Acts/Surfaces/Surface.hpp"
#include "Acts/Utilities/ParameterDefinitions.hpp"

#include <memory>
#include <ostream>
#include <type_traits>
#include <utility>

namespace Acts {

// forward declarations
class Surface;

namespace detail {
template <typename T>
struct ReferenceObject {};
template <>
struct ReferenceObject<BoundIndices> {
  using type = Surface;
};
template <>
struct ReferenceObject<FreeIndices> {
  using type = Volume;
};
}  // namespace detail

template <typename source_link_t, typename parameter_indices_t,
          parameter_indices_t... params>
class Measurement {
  // check type conditions
  static_assert(SourceLinkConcept<source_link_t>,
                "Source link does not fulfill SourceLinkConcept");

  // type of the underlying ParameterSet object
  using ParamSet = ParameterSet<parameter_indices_t, params...>;

 public:
  using Scalar = typename ParamSet::Scalar;
  using ParametersVector = typename ParamSet::ParametersVector;
  using FullParametersVector = typename ParamSet::FullParametersVector;
  using CovarianceMatrix = typename ParamSet::CovarianceMatrix;
  using ProjectionMatrix = typename ParamSet::ProjectionMatrix;
  using RefObject = typename detail::ReferenceObject<parameter_indices_t>::type;

  Measurement() = delete;

  template <typename... Tail>
  Measurement(std::shared_ptr<const RefObject> referenceObject,
              const source_link_t& source, CovarianceMatrix cov,
              typename std::enable_if<sizeof...(Tail) + 1 == sizeof...(params),
                                      Scalar>::type head,
              Tail... values)
      : m_oParameters(std::move(cov), head, values...),
        m_pReferenceObject(std::move(referenceObject)),
        m_sourceLink(source) {
    assert(m_pReferenceObject);
  }

  Measurement(std::shared_ptr<const RefObject> referenceObject,
              const source_link_t& source, CovarianceMatrix cov,
              ParametersVector vec)
      : m_oParameters(std::move(cov), std::move(vec)),
        m_pReferenceObject(std::move(referenceObject)),
        m_sourceLink(source) {
    assert(m_pReferenceObject);
  }

  virtual ~Measurement() = default;

  Measurement(
      const Measurement<source_link_t, parameter_indices_t, params...>& copy)
      : m_oParameters(copy.m_oParameters),
        m_pReferenceObject(copy.m_pReferenceObject),
        m_sourceLink(copy.m_sourceLink) {}

  Measurement(
      Measurement<source_link_t, parameter_indices_t, params...>&& other)
      : m_oParameters(std::move(other.m_oParameters)),
        m_pReferenceObject(std::move(other.m_pReferenceObject)),
        m_sourceLink(std::move(other.m_sourceLink)) {}

  Measurement<source_link_t, parameter_indices_t, params...>& operator=(
      const Measurement<source_link_t, parameter_indices_t, params...>& rhs) {
    // check for self-assignment
    if (&rhs != this) {
      m_oParameters = rhs.m_oParameters;
      m_pReferenceObject = rhs.m_pReferenceObject;
      m_sourceLink = rhs.m_sourceLink;
    }
    return *this;
  }

  Measurement<source_link_t, parameter_indices_t, params...>& operator=(
      Measurement<source_link_t, parameter_indices_t, params...>&& rhs) {
    m_oParameters = std::move(rhs.m_oParameters);
    m_pReferenceObject = std::move(rhs.m_pReferenceObject);
    m_sourceLink = std::move(rhs.m_sourceLink);
    return *this;
  }

  template <parameter_indices_t parameter>
  Scalar get() const {
    return m_oParameters.template getParameter<parameter>();
  }

  const ParametersVector& parameters() const {
    return m_oParameters.getParameters();
  }

  const CovarianceMatrix& covariance() const {
    return *m_oParameters.getCovariance();
  }

  template <parameter_indices_t parameter>
  Scalar uncertainty() const {
    return m_oParameters.template getUncertainty<parameter>();
  }

  static constexpr unsigned int size() { return ParamSet::size(); }

  const RefObject& referenceObject() const { return *m_pReferenceObject; }

  const source_link_t& sourceLink() const { return m_sourceLink; }

  ParametersVector residual(const FullParametersVector& trackPars) const {
    return m_oParameters.residual(trackPars);
  }

  virtual bool operator==(const Measurement<source_link_t, parameter_indices_t,
                                            params...>& rhs) const {
    return ((m_oParameters == rhs.m_oParameters) &&
            (m_pReferenceObject == rhs.m_pReferenceObject) &&
            (m_sourceLink == rhs.m_sourceLink));
  }

  bool operator!=(const Measurement<source_link_t, parameter_indices_t,
                                    params...>& rhs) const {
    return !(*this == rhs);
  }

  static const ProjectionMatrix& projector() { return ParamSet::projector(); }

  friend std::ostream& operator<<(
      std::ostream& out,
      const Measurement<source_link_t, parameter_indices_t, params...>& m) {
    m.print(out);
    return out;
  }

 protected:
  virtual std::ostream& print(std::ostream& out) const {
    out << sizeof...(params) << "D measurement: ";
    int dummy[sizeof...(params)] = {(out << params << ", ", 0)...};
    dummy[0] = dummy[0];
    out << std::endl;
    out << "measured values:" << std::endl;
    out << parameters() << std::endl;
    out << "covariance matrix:" << std::endl;
    out << covariance() << std::endl;
    return out;
  }

 private:
  ParamSet m_oParameters;  
  std::shared_ptr<const RefObject> m_pReferenceObject =
      nullptr;                 
  source_link_t m_sourceLink;  
};

template <typename source_link_t>
struct fittable_measurement_helper {
  template <BoundIndices... pars>
  struct meas_factory {
    using type = Measurement<source_link_t, BoundIndices, pars...>;
  };

  using type = typename detail::type_generator_t<BoundIndices, meas_factory>;
};

template <typename source_link_t>
struct fittable_volume_measurement_helper {
  template <FreeIndices... pars>
  struct meas_factory {
    using type = Measurement<source_link_t, FreeIndices, pars...>;
  };

  using type = typename detail::type_generator_t<FreeIndices, meas_factory>;
};

template <typename source_link_t>
using FittableMeasurement =
    typename fittable_measurement_helper<source_link_t>::type;

template <typename source_link_t>
using FittableVolumeMeasurement =
    typename fittable_volume_measurement_helper<source_link_t>::type;
}  // namespace Acts