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-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 <memory>
#include <ostream>
#include <type_traits>
#include <utility>
#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/Surfaces/Surface.hpp"
#include "Acts/Utilities/ParameterDefinitions.hpp"

namespace Acts {

// forward declarations
class Surface;

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

 private:
  // private typedefs

  using ParSet_t = ParameterSet<params...>;

 public:
  using ParVector_t = typename ParSet_t::ParVector_t;
  using CovMatrix_t = typename ParSet_t::CovMatrix_t;
  using Projection_t = typename ParSet_t::Projection_t;

  Measurement() = delete;

  template <typename... Tail>
  Measurement(std::shared_ptr<const Surface> surface,
              const source_link_t& source, CovMatrix_t cov,
              typename std::enable_if<sizeof...(Tail) + 1 == sizeof...(params),
                                      ParValue_t>::type head,
              Tail... values)
      : m_oParameters(std::move(cov), head, values...),
        m_pSurface(std::move(surface)),
        m_sourceLink(source) {
    assert(m_pSurface);
  }

  virtual ~Measurement() = default;

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

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

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

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

  template <ParID_t parameter>
  ParValue_t get() const {
    return m_oParameters.template getParameter<parameter>();
  }

  ParVector_t parameters() const { return m_oParameters.getParameters(); }

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

  template <ParID_t parameter>
  ParValue_t uncertainty() const {
    return m_oParameters.template getUncertainty<parameter>();
  }

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

  const Acts::Surface& referenceSurface() const { return *m_pSurface; }

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

  ParVector_t residual(const TrackParameters& trackPars) const {
    return m_oParameters.residual(trackPars.getParameterSet());
  }

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

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

  static Projection_t projector() { return ParSet_t::projector(); }

  friend std::ostream& operator<<(
      std::ostream& out, const Measurement<source_link_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:
  ParSet_t m_oParameters;  
  std::shared_ptr<const Surface>
      m_pSurface;  

  source_link_t m_sourceLink;  
};

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

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

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

}  // namespace Acts