SingleFreeTrackParameters.hpp

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

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

namespace Acts {

template <class charge_t>
class SingleFreeTrackParameters {
 public:
  using Scalar = FreeScalar;
  using ParametersVector = FreeVector;
  using CovarianceMatrix = FreeSymMatrix;

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

  template <typename T = charge_t,
            std::enable_if_t<std::is_default_constructible_v<T>, int> = 0>
  SingleFreeTrackParameters(const ParametersVector& params,
                            std::optional<CovarianceMatrix> cov = std::nullopt)
      : m_paramSet(std::move(cov), params), m_chargeInterpreter(T()) {}

  SingleFreeTrackParameters(const Vector4D& pos4, Scalar phi, Scalar theta,
                            Scalar p, Scalar q,
                            std::optional<CovarianceMatrix> cov = std::nullopt)
      : m_paramSet(std::move(cov), ParametersVector::Zero()),
        m_chargeInterpreter(std::abs(q)) {
    assert((0 <= p) and "Absolute momentum must be positive");

    m_paramSet.setParameter<eFreePos0>(pos4[ePos0]);
    m_paramSet.setParameter<eFreePos1>(pos4[ePos1]);
    m_paramSet.setParameter<eFreePos2>(pos4[ePos2]);
    m_paramSet.setParameter<eFreeTime>(pos4[eTime]);
    auto dir = makeDirectionUnitFromPhiTheta(phi, theta);
    m_paramSet.setParameter<eFreeDir0>(dir[eMom0]);
    m_paramSet.setParameter<eFreeDir1>(dir[eMom1]);
    m_paramSet.setParameter<eFreeDir2>(dir[eMom2]);
    m_paramSet.setParameter<eFreeQOverP>((q != Scalar(0)) ? (q / p) : (1 / p));
  }

  template <typename T = charge_t,
            std::enable_if_t<std::is_default_constructible_v<T>, int> = 0>
  SingleFreeTrackParameters(const Vector4D& pos4, Scalar phi, Scalar theta,
                            Scalar qOverP,
                            std::optional<CovarianceMatrix> cov = std::nullopt)
      : m_paramSet(std::move(cov), ParametersVector::Zero()),
        m_chargeInterpreter(T()) {
    m_paramSet.setParameter<eFreePos0>(pos4[ePos0]);
    m_paramSet.setParameter<eFreePos1>(pos4[ePos1]);
    m_paramSet.setParameter<eFreePos2>(pos4[ePos2]);
    m_paramSet.setParameter<eFreeTime>(pos4[eTime]);
    auto dir = makeDirectionUnitFromPhiTheta(phi, theta);
    m_paramSet.setParameter<eFreeDir0>(dir[eMom0]);
    m_paramSet.setParameter<eFreeDir1>(dir[eMom1]);
    m_paramSet.setParameter<eFreeDir2>(dir[eMom2]);
    m_paramSet.setParameter<eFreeQOverP>(qOverP);
  }

  // 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.

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

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

  Vector4D fourPosition() const {
    Vector4D pos4;
    pos4[ePos0] = get<eFreePos0>();
    pos4[ePos1] = get<eFreePos1>();
    pos4[ePos2] = get<eFreePos2>();
    pos4[eTime] = get<eFreeTime>();
    return pos4;
  }
  Vector3D position() const {
    return parameters().template segment<3>(eFreePos0);
  }
  Scalar time() const { return get<eFreeTime>(); }

  Vector3D unitDirection() const {
    return parameters().template segment<3>(eFreeDir0).normalized();
  }
  Scalar absoluteMomentum() const {
    return m_chargeInterpreter.extractMomentum(get<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(get<eFreeDir0>(), get<eFreeDir1>());
    // absolute magnitude is f by construction
    Scalar magnitude = std::hypot(transverseMagnitude, get<eFreeDir2>());
    // such that we can extract sin(theta) = f*sin(theta) / f
    return (transverseMagnitude / magnitude) * absoluteMomentum();
  }
  Vector3D momentum() const { return absoluteMomentum() * unitDirection(); }

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

 private:
  FullFreeParameterSet m_paramSet;
  // TODO use [[no_unique_address]] once we switch to C++20
  charge_t m_chargeInterpreter;

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

}  // namespace Acts