SingleTrackParameters.hpp

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

// This file is part of the Acts project.
//
// Copyright (C) 2016-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 <type_traits>
#include "Acts/EventData/ChargePolicy.hpp"
#include "Acts/EventData/ParameterSet.hpp"
#include "Acts/EventData/detail/coordinate_transformations.hpp"
#include "Acts/Geometry/GeometryContext.hpp"
#include "Acts/Utilities/Definitions.hpp"

namespace Acts {

template <class ChargePolicy>
class SingleTrackParameters {
  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:
  // public typedef's

  using ParVector_t = BoundVector;

  using CovMatrix_t = BoundSymMatrix;

  virtual ~SingleTrackParameters() = default;

  Vector3D position() const { return m_vPosition; }

  Vector3D momentum() const { return m_vMomentum; }

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

    return (m_oChargePolicy == casted->m_oChargePolicy &&
            m_oParameters == casted->m_oParameters &&
            m_vPosition == casted->m_vPosition &&
            m_vMomentum == casted->m_vMomentum);
  }

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

  double time() const { return get<ParDef::eT>(); }

  const FullParameterSet& getParameterSet() const { return m_oParameters; }

  virtual const Surface& referenceSurface() const = 0;

  const std::optional<CovMatrix_t>& covariance() const {
    return getParameterSet().getCovariance();
  }

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

  template <ParID_t par>
  ParValue_t get() const {
    return getParameterSet().template getParameter<par>();
  }

  template <ParID_t par>
  ParValue_t uncertainty() const {
    return getParameterSet().template getUncertainty<par>();
  }

  double pT() const { return VectorHelpers::perp(momentum()); }

  double eta() const { return VectorHelpers::eta(momentum()); }

  FullParameterSet& getParameterSet() { return m_oParameters; }

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

 protected:
  template <typename T = ChargePolicy,
            std::enable_if_t<std::is_same<T, ChargedPolicy>::value, int> = 0>
  SingleTrackParameters(std::optional<CovMatrix_t> cov,
                        const ParVector_t& parValues, const Vector3D& position,
                        const Vector3D& momentum)
      : m_oChargePolicy(
            detail::coordinate_transformation::parameters2charge(parValues)),
        m_oParameters(std::move(cov), parValues),
        m_vPosition(position),
        m_vMomentum(momentum) {}

  template <typename T = ChargePolicy,
            std::enable_if_t<std::is_same<T, NeutralPolicy>::value, int> = 0>
  SingleTrackParameters(std::optional<CovMatrix_t> cov,
                        const ParVector_t& parValues, const Vector3D& position,
                        const Vector3D& momentum)
      : m_oChargePolicy(),
        m_oParameters(std::move(cov), parValues),
        m_vPosition(position),
        m_vMomentum(momentum) {}

  SingleTrackParameters(const SingleTrackParameters<ChargePolicy>& copy) =
      default;

  SingleTrackParameters(SingleTrackParameters<ChargePolicy>&& copy) = default;

  SingleTrackParameters<ChargePolicy>& operator=(
      const SingleTrackParameters<ChargePolicy>& rhs) {
    // check for self-assignment
    if (this != &rhs) {
      m_oChargePolicy = rhs.m_oChargePolicy;
      m_oParameters = rhs.m_oParameters;
      m_vPosition = rhs.m_vPosition;
      m_vMomentum = rhs.m_vMomentum;
    }

    return *this;
  }

  SingleTrackParameters<ChargePolicy>& operator=(
      SingleTrackParameters<ChargePolicy>&& rhs) {
    // check for self-assignment
    if (this != &rhs) {
      m_oChargePolicy = std::move(rhs.m_oChargePolicy);
      m_oParameters = std::move(rhs.m_oParameters);
      m_vPosition = std::move(rhs.m_vPosition);
      m_vMomentum = std::move(rhs.m_vMomentum);
    }

    return *this;
  }

  template <typename T>
  void updateGlobalCoordinates(const GeometryContext& /*gctx*/,
                               const T& /*unused*/) {
    m_vMomentum = detail::coordinate_transformation::parameters2globalMomentum(
        getParameterSet().getParameters());
  }

  void updateGlobalCoordinates(const GeometryContext& gctx,
                               const local_parameter& /*unused*/) {
    m_vPosition = detail::coordinate_transformation::parameters2globalPosition(
        gctx, getParameterSet().getParameters(), this->referenceSurface());
  }

  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);

    sl << " * TrackParameters: ";
    sl << parameters().transpose() << std::endl;
    sl << " * charge: " << charge() << std::endl;
    if (covariance()) {
      sl << " * covariance matrix:\n" << *covariance() << std::endl;
    } else {
      sl << " * covariance matrix:\nnull" << std::endl;
    }
    sl << " * corresponding global parameters:" << std::endl;
    sl << " *    position  (x y z) = (" << position().transpose() << ")"
       << std::endl;
    sl << " *    momentum  (px py pz) = (" << momentum().transpose() << ")"
       << std::endl;

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

    return sl;
  }

  ChargePolicy m_oChargePolicy;    

  FullParameterSet m_oParameters;  

  Vector3D m_vPosition;            
  Vector3D m_vMomentum;            
};
}  // namespace Acts