GenericBoundTrackParameters.hpp

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

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

namespace Acts {

template <class particle_hypothesis_t>
class GenericBoundTrackParameters {
 public:
  using Scalar = ActsScalar;
  using ParametersVector = BoundVector;
  using CovarianceMatrix = BoundSquareMatrix;
  using ParticleHypothesis = particle_hypothesis_t;

  GenericBoundTrackParameters(std::shared_ptr<const Surface> surface,
                              const ParametersVector& params,
                              std::optional<CovarianceMatrix> cov,
                              ParticleHypothesis particleHypothesis)
      : m_params(params),
        m_cov(std::move(cov)),
        m_surface(std::move(surface)),
        m_particleHypothesis(std::move(particleHypothesis)) {
    assert(m_surface);
    normalizePhiTheta();
  }

  template <typename other_particle_hypothesis_t>
  GenericBoundTrackParameters(
      const GenericBoundTrackParameters<other_particle_hypothesis_t>& other)
      : GenericBoundTrackParameters(other.referenceSurface().getSharedPtr(),
                                    other.parameters(), other.covariance(),
                                    other.particleHypothesis()) {}

  static Result<GenericBoundTrackParameters> create(
      std::shared_ptr<const Surface> surface, const GeometryContext& geoCtx,
      const Vector4& pos4, const Vector3& dir, Scalar qOverP,
      std::optional<CovarianceMatrix> cov,
      ParticleHypothesis particleHypothesis,
      ActsScalar tolerance = s_onSurfaceTolerance) {
    Result<BoundVector> bound = detail::transformFreeToBoundParameters(
        pos4.segment<3>(ePos0), pos4[eTime], dir, qOverP, *surface, geoCtx,
        tolerance);

    if (!bound.ok()) {
      return bound.error();
    }

    return GenericBoundTrackParameters{std::move(surface), std::move(*bound),
                                       std::move(cov),
                                       std::move(particleHypothesis)};
  }

  GenericBoundTrackParameters() = delete;
  GenericBoundTrackParameters(const GenericBoundTrackParameters&) = default;
  GenericBoundTrackParameters(GenericBoundTrackParameters&&) = default;
  ~GenericBoundTrackParameters() = default;
  GenericBoundTrackParameters& operator=(const GenericBoundTrackParameters&) =
      default;
  GenericBoundTrackParameters& operator=(GenericBoundTrackParameters&&) =
      default;

  ParametersVector& parameters() { return m_params; }
  const ParametersVector& parameters() const { return m_params; }
  ActsVector<2> spatialImpactParameters() const { return m_params.head<2>(); }
  ActsVector<3> impactParameters() const {
    ActsVector<3> ip;
    ip.template head<2>() = m_params.template head<2>();
    ip(2) = m_params(eBoundTime);
    return ip;
  }

  std::optional<CovarianceMatrix>& covariance() { return m_cov; }
  const std::optional<CovarianceMatrix>& covariance() const { return m_cov; }
  std::optional<ActsSquareMatrix<2>> spatialImpactParameterCovariance() const {
    if (not m_cov.has_value()) {
      return std::nullopt;
    }

    return m_cov.value().template topLeftCorner<2, 2>();
  }

  std::optional<ActsSquareMatrix<3>> impactParameterCovariance() const {
    if (not m_cov.has_value()) {
      return std::nullopt;
    }

    ActsSquareMatrix<3> ipCov;
    ipCov.template topLeftCorner<2, 2>() =
        m_cov.value().template topLeftCorner<2, 2>();
    ipCov.template block<2, 1>(0, 2) =
        m_cov.value().template block<2, 1>(0, eBoundTime);
    ipCov.template block<1, 2>(2, 0) =
        m_cov.value().template block<1, 2>(eBoundTime, 0);
    ipCov(2, 2) = m_cov.value()(eBoundTime, eBoundTime);
    return ipCov;
  }

  template <BoundIndices kIndex>
  Scalar get() const {
    return m_params[kIndex];
  }

  Vector2 localPosition() const { return m_params.segment<2>(eBoundLoc0); }
  Vector4 fourPosition(const GeometryContext& geoCtx) const {
    Vector4 pos4;
    pos4.segment<3>(ePos0) =
        m_surface->localToGlobal(geoCtx, localPosition(), direction());
    pos4[eTime] = m_params[eBoundTime];
    return pos4;
  }
  Vector3 position(const GeometryContext& geoCtx) const {
    return m_surface->localToGlobal(geoCtx, localPosition(), direction());
  }
  Scalar time() const { return m_params[eBoundTime]; }

  Scalar phi() const { return m_params[eBoundPhi]; }
  Scalar theta() const { return m_params[eBoundTheta]; }
  Scalar qOverP() const { return m_params[eBoundQOverP]; }

  Vector3 direction() const {
    return makeDirectionFromPhiTheta(m_params[eBoundPhi],
                                     m_params[eBoundTheta]);
  }
  Scalar absoluteMomentum() const {
    return m_particleHypothesis.extractMomentum(m_params[eBoundQOverP]);
  }
  Scalar transverseMomentum() const {
    return std::sin(m_params[eBoundTheta]) * absoluteMomentum();
  }
  Vector3 momentum() const { return absoluteMomentum() * direction(); }

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

  const ParticleHypothesis& particleHypothesis() const {
    return m_particleHypothesis;
  }

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

 private:
  BoundVector m_params;
  std::optional<BoundSquareMatrix> m_cov;
  std::shared_ptr<const Surface> m_surface;
  // TODO use [[no_unique_address]] once we switch to C++20
  ParticleHypothesis m_particleHypothesis;

  void normalizePhiTheta() {
    auto [phi, theta] =
        detail::normalizePhiTheta(m_params[eBoundPhi], m_params[eBoundTheta]);
    m_params[eBoundPhi] = phi;
    m_params[eBoundTheta] = theta;
  }

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

}  // namespace Acts