GenericFreeTrackParameters.hpp

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

// This file is part of the Acts project.
//
// Copyright (C) 2019-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/Algebra.hpp"
#include "Acts/Definitions/Common.hpp"
#include "Acts/Definitions/TrackParametrization.hpp"
#include "Acts/EventData/TrackParametersConcept.hpp"
#include "Acts/EventData/detail/PrintParameters.hpp"
#include "Acts/Utilities/UnitVectors.hpp"

#include <cassert>
#include <cmath>
#include <optional>
#include <type_traits>

namespace Acts {

template <class particle_hypothesis_t>
class GenericFreeTrackParameters {
 public:
  using Scalar = ActsScalar;
  using ParametersVector = FreeVector;
  using CovarianceMatrix = FreeSquareMatrix;
  using ParticleHypothesis = particle_hypothesis_t;

  GenericFreeTrackParameters(const ParametersVector& params,
                             std::optional<CovarianceMatrix> cov,
                             ParticleHypothesis particleHypothesis)
      : m_params(params),
        m_cov(std::move(cov)),
        m_particleHypothesis(std::move(particleHypothesis)) {}

  GenericFreeTrackParameters(const Vector4& pos4, Scalar phi, Scalar theta,
                             Scalar qOverP, std::optional<CovarianceMatrix> cov,
                             ParticleHypothesis particleHypothesis)
      : m_params(FreeVector::Zero()),
        m_cov(std::move(cov)),
        m_particleHypothesis(std::move(particleHypothesis)) {
    auto dir = makeDirectionFromPhiTheta(phi, theta);
    m_params[eFreePos0] = pos4[ePos0];
    m_params[eFreePos1] = pos4[ePos1];
    m_params[eFreePos2] = pos4[ePos2];
    m_params[eFreeTime] = pos4[eTime];
    m_params[eFreeDir0] = dir[eMom0];
    m_params[eFreeDir1] = dir[eMom1];
    m_params[eFreeDir2] = dir[eMom2];
    m_params[eFreeQOverP] = qOverP;
  }

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

  template <typename other_track_parameter_t>
  static GenericFreeTrackParameters create(
      const other_track_parameter_t& other) {
    static_assert(
        Concepts::FreeTrackParametersConcept<other_track_parameter_t>);

    return GenericFreeTrackParameters(
        other.parameters(), other.particleHypothesis(), other.covariance());
  }

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

  const ParametersVector& parameters() const { return m_params; }
  const std::optional<CovarianceMatrix>& covariance() const { return m_cov; }

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

  Vector4 fourPosition() const {
    Vector4 pos4;
    pos4[ePos0] = m_params[eFreePos0];
    pos4[ePos1] = m_params[eFreePos1];
    pos4[ePos2] = m_params[eFreePos2];
    pos4[eTime] = m_params[eFreeTime];
    return pos4;
  }
  Vector3 position() const { return m_params.segment<3>(eFreePos0); }
  Scalar time() const { return m_params[eFreeTime]; }

  Scalar phi() const { return phi(direction()); }
  Scalar theta() const { return theta(direction()); }
  Scalar qOverP() const { return m_params[eFreeQOverP]; }

  Vector3 direction() const {
    return m_params.segment<3>(eFreeDir0).normalized();
  }
  Scalar absoluteMomentum() const {
    return m_particleHypothesis.extractMomentum(m_params[eFreeQOverP]);
  }
  Scalar transverseMomentum() const {
    // direction vector w/ arbitrary normalization can be parametrized as
    //   [f*sin(theta)*cos(phi), f*sin(theta)*sin(phi), f*cos(theta)]
    // w/ f,sin(theta) positive, the transverse magnitude is then
    //   sqrt(f^2*sin^2(theta)) = f*sin(theta)
    Scalar transverseMagnitude =
        std::hypot(m_params[eFreeDir0], m_params[eFreeDir1]);
    // absolute magnitude is f by construction
    Scalar magnitude = std::hypot(transverseMagnitude, m_params[eFreeDir2]);
    // such that we can extract sin(theta) = f*sin(theta) / f
    return (transverseMagnitude / magnitude) * absoluteMomentum();
  }
  Vector3 momentum() const { return absoluteMomentum() * direction(); }

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

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

 private:
  FreeVector m_params;
  std::optional<FreeSquareMatrix> m_cov;
  // TODO use [[no_unique_address]] once we switch to C++20
  ParticleHypothesis m_particleHypothesis;

  friend std::ostream& operator<<(std::ostream& os,
                                  const GenericFreeTrackParameters& tp) {
    detail::printFreeParameters(
        os, tp.parameters(),
        tp.covariance().has_value() ? &tp.covariance().value() : nullptr);
    return os;
  }
};

}  // namespace Acts