SingleBoundTrackParameters.hpp

Go to the documentation of this file. Or view the newest version in sPHENIX GitHub for file SingleBoundTrackParameters.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/detail/PrintParameters.hpp"
#include "Acts/EventData/detail/TransformationFreeToBound.hpp"
#include "Acts/Surfaces/Surface.hpp"
#include "Acts/Utilities/UnitVectors.hpp"

#include <cassert>
#include <cmath>
#include <memory>
#include <type_traits>

namespace Acts {

template <class charge_t>
class SingleBoundTrackParameters {
 public:
  using Scalar = BoundScalar;
  using ParametersVector = BoundVector;
  using CovarianceMatrix = BoundSymMatrix;

  SingleBoundTrackParameters(std::shared_ptr<const Surface> surface,
                             const ParametersVector& params, Scalar q,
                             std::optional<CovarianceMatrix> cov = std::nullopt)
      : m_paramSet(std::move(cov), params),
        m_surface(std::move(surface)),
        m_chargeInterpreter(std::abs(q)) {
    assert((0 <= (params[eBoundQOverP] * q)) and
           "Inconsistent q/p and q signs");
    assert(m_surface);
  }

  template <typename T = charge_t,
            std::enable_if_t<std::is_default_constructible_v<T>, int> = 0>
  SingleBoundTrackParameters(std::shared_ptr<const Surface> surface,
                             const ParametersVector& params,
                             std::optional<CovarianceMatrix> cov = std::nullopt)
      : m_paramSet(std::move(cov), params),
        m_surface(std::move(surface)),
        m_chargeInterpreter(T()) {
    assert(m_surface);
  }

  SingleBoundTrackParameters(std::shared_ptr<const Surface> surface,
                             const GeometryContext& geoCtx,
                             const Vector4D& pos4, const Vector3D& dir,
                             Scalar p, Scalar q,
                             std::optional<CovarianceMatrix> cov = std::nullopt)
      : m_paramSet(std::move(cov),
                   detail::transformFreeToBoundParameters(
                       pos4.segment<3>(ePos0), pos4[eTime], dir,
                       (q != Scalar(0)) ? (q / p) : (1 / p), *surface, geoCtx)),
        m_surface(std::move(surface)),
        m_chargeInterpreter(std::abs(q)) {
    assert((0 <= p) and "Absolute momentum must be positive");
    assert(m_surface);
  }

  template <typename T = charge_t,
            std::enable_if_t<std::is_default_constructible_v<T>, int> = 0>
  SingleBoundTrackParameters(std::shared_ptr<const Surface> surface,
                             const GeometryContext& geoCtx,
                             const Vector4D& pos4, const Vector3D& dir,
                             Scalar qOverP,
                             std::optional<CovarianceMatrix> cov = std::nullopt)
      : m_paramSet(std::move(cov), detail::transformFreeToBoundParameters(
                                       pos4.segment<3>(ePos0), pos4[eTime], dir,
                                       qOverP, *surface, geoCtx)),
        m_surface(std::move(surface)),
        m_chargeInterpreter(T()) {
    assert(m_surface);
  }

  // this class does not have a custom default constructor and thus should not
  // provide any custom default cstors, dstor, or assignment. see ISOCPP C.20.

  const FullBoundParameterSet& getParameterSet() const { return m_paramSet; }
  ParametersVector parameters() const { return m_paramSet.getParameters(); }
  const std::optional<CovarianceMatrix>& covariance() const {
    return m_paramSet.getCovariance();
  }

  template <BoundIndices kIndex>
  Scalar get() const {
    return m_paramSet.template getParameter<kIndex>();
  }
  template <BoundIndices kIndex>
  Scalar uncertainty() const {
    return m_paramSet.template getUncertainty<kIndex>();
  }

  Vector4D fourPosition(const GeometryContext& geoCtx) const {
    const Vector2D loc(get<eBoundLoc0>(), get<eBoundLoc1>());
    const Vector3D dir =
        makeDirectionUnitFromPhiTheta(get<eBoundPhi>(), get<eBoundTheta>());
    Vector4D pos4;
    pos4.segment<3>(ePos0) = m_surface->localToGlobal(geoCtx, loc, dir);
    pos4[eTime] = get<eBoundTime>();
    return pos4;
  }
  Vector3D position(const GeometryContext& geoCtx) const {
    const Vector2D loc(get<eBoundLoc0>(), get<eBoundLoc1>());
    const Vector3D dir =
        makeDirectionUnitFromPhiTheta(get<eBoundPhi>(), get<eBoundTheta>());
    return m_surface->localToGlobal(geoCtx, loc, dir);
  }
  Scalar time() const { return get<eBoundTime>(); }

  Vector3D unitDirection() const {
    return makeDirectionUnitFromPhiTheta(get<eBoundPhi>(), get<eBoundTheta>());
  }
  Scalar absoluteMomentum() const {
    return m_chargeInterpreter.extractMomentum(get<eBoundQOverP>());
  }
  Scalar transverseMomentum() const {
    return std::sin(get<eBoundTheta>()) * absoluteMomentum();
  }
  Vector3D momentum() const { return absoluteMomentum() * unitDirection(); }

  constexpr Scalar charge() const {
    return m_chargeInterpreter.extractCharge(get<eBoundQOverP>());
  }

  const Surface& referenceSurface() const { return *m_surface; }
  RotationMatrix3D referenceFrame(const GeometryContext& geoCtx) const {
    return m_surface->referenceFrame(geoCtx, position(geoCtx), momentum());
  }

 private:
  FullBoundParameterSet m_paramSet;
  std::shared_ptr<const Surface> m_surface;
  // TODO use [[no_unique_address]] once we switch to C++20
  charge_t m_chargeInterpreter;

  friend bool operator==(const SingleBoundTrackParameters& lhs,
                         const SingleBoundTrackParameters& rhs) {
    return (lhs.m_paramSet == rhs.m_paramSet) and
           (lhs.m_surface == rhs.m_surface) and
           (lhs.m_chargeInterpreter == rhs.m_chargeInterpreter);
  }
  friend bool operator!=(const SingleBoundTrackParameters& lhs,
                         const SingleBoundTrackParameters& rhs) {
    return !(lhs == rhs);
  }
  friend std::ostream& operator<<(std::ostream& os,
                                  const SingleBoundTrackParameters& tp) {
    detail::printBoundParameters(
        os, tp.referenceSurface(), tp.parameters(),
        tp.covariance().has_value() ? &tp.covariance().value() : nullptr);
    return os;
  }
};

}  // namespace Acts