SingleFreeParameters.hpp

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

// This file is part of the Acts project.
//
// Copyright (C) 2019 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 <iomanip>
#include <ostream>

#include "Acts/EventData/detail/coordinate_transformations.hpp"
#include "Acts/Utilities/Definitions.hpp"

namespace Acts {

template <class ChargePolicy>
class SingleFreeParameters {
  static_assert(std::is_same<ChargePolicy, ChargedPolicy>::value or
                    std::is_same<ChargePolicy, NeutralPolicy>::value,
                "ChargePolicy must either be 'Acts::ChargedPolicy' or "
                "'Acts::NeutralPolicy");

 public:
  using CovMatrix_t = FreeSymMatrix;

  ~SingleFreeParameters() = default;

  template <typename T = ChargePolicy,
            std::enable_if_t<std::is_same<T, ChargedPolicy>::value, int> = 0>
  SingleFreeParameters(std::optional<CovMatrix_t> cov,
                       const FreeVector& parValues)
      : m_parameters(parValues),
        m_oChargePolicy((0 < parValues(eFreeQOverP)) ? 1. : -1.),
        m_covariance(std::move(cov)) {}

  template <typename T = ChargePolicy,
            std::enable_if_t<std::is_same<T, NeutralPolicy>::value, int> = 0>
  SingleFreeParameters(std::optional<CovMatrix_t> cov,
                       const FreeVector& parValues)
      : m_parameters(parValues),
        m_oChargePolicy(),
        m_covariance(std::move(cov)) {}

  SingleFreeParameters<ChargePolicy>& operator=(
      const SingleFreeParameters<ChargePolicy>& rhs) {
    // Check for self-assignment
    if (this != &rhs) {
      m_oChargePolicy = rhs.m_oChargePolicy;
      m_parameters = rhs.m_parameters;
      m_covariance = rhs.m_covariance;
    }
    return *this;
  }

  SingleFreeParameters<ChargePolicy>& operator=(
      SingleFreeParameters<ChargePolicy>&& rhs) {
    // Check for self-assignment
    if (this != &rhs) {
      m_oChargePolicy = std::move(rhs.m_oChargePolicy);
      m_parameters = std::move(rhs.m_parameters);
      m_covariance = std::move(rhs.m_covariance);
    }
    return *this;
  }

  SingleFreeParameters(const SingleFreeParameters<ChargePolicy>& copy)
      : m_parameters(copy.m_parameters),
        m_oChargePolicy(copy.m_oChargePolicy),
        m_covariance(copy.m_covariance) {}

  SingleFreeParameters(SingleFreeParameters<ChargePolicy>&& copy) {
    this->operator=(
        std::forward<const SingleFreeParameters<ChargePolicy>>(copy));
  }

  FreeVector parameters() const { return m_parameters; }

  template <unsigned int par,
            std::enable_if_t<par<eFreeParametersSize, int> = 0> ParValue_t get()
                const {
    return m_parameters(par);
  }

  template <unsigned int par,
            std::enable_if_t<par<eFreeParametersSize, int> = 0> ParValue_t
                uncertainty() const {
    return std::sqrt(m_covariance->coeff(par, par));
  }

  const std::optional<CovMatrix_t>& covariance() const { return m_covariance; }

  Vector3D position() const { return m_parameters.template head<3>(); }

  Vector3D momentum() const {
    return m_parameters.template segment<3>(4) / std::abs(get<7>());
  }

  double charge() const { return m_oChargePolicy.getCharge(); }

  double time() const { return m_parameters(3); }

  bool operator==(const SingleFreeParameters& rhs) const {
    auto casted = dynamic_cast<decltype(this)>(&rhs);
    if (!casted) {
      return false;
    }

    // Both have covariance matrices set
    if ((m_covariance.has_value() && casted->m_covariance.has_value()) &&
        (*m_covariance != *casted->m_covariance)) {
      return false;
    }
    // Only one has a covariance matrix set
    if ((m_covariance.has_value() && !casted->m_covariance.has_value()) ||
        (!m_covariance.has_value() && casted->m_covariance.has_value())) {
      return false;
    }

    return (m_oChargePolicy == casted->m_oChargePolicy &&
            m_parameters == casted->m_parameters);
  }

  bool operator!=(const SingleFreeParameters& rhs) const {
    return !(*this == rhs);
  }

  template <unsigned int par,
            std::enable_if_t<par<eFreeParametersSize, int> = 0> void set(
                const GeometryContext& /*gctx*/, ParValue_t newValue) {
    m_parameters(par) = newValue;
  }

  std::ostream& print(std::ostream& sl) const {
    // Set stream output format
    auto old_precision = sl.precision(7);
    auto old_flags = sl.setf(std::ios::fixed);

    // Fill stream with content
    sl << " * FreeTrackParameters: ";
    sl << parameters().transpose() << std::endl;
    sl << " * charge: " << charge() << std::endl;
    if (covariance().has_value()) {
      sl << " * covariance matrix:\n" << *covariance() << std::endl;
    } else {
      sl << " * no covariance matrix stored" << std::endl;
    }

    // Reset stream format
    sl.precision(old_precision);
    sl.setf(old_flags);

    return sl;
  }

  friend std::ostream& operator<<(std::ostream& out,
                                  const SingleFreeParameters& sfp) {
    sfp.print(out);
    return out;
  }

 private:
  FreeVector m_parameters;       
  ChargePolicy m_oChargePolicy;  

  std::optional<CovMatrix_t> m_covariance;  
};

}  // namespace Acts