ParametersBase.icc

Go to the documentation of this file.

/*
  Copyright (C) 2002-2024 CERN for the benefit of the ATLAS collaboration
*/
 
///////////////////////////////////////////////////////////////////
// ParametersBase.icc, (c) ATLAS Detector software
///////////////////////////////////////////////////////////////////
 
// Gaudi
#include "GaudiKernel/MsgStream.h"
// Trk
#include "TrkEventPrimitives/ParamDefs.h"
// STD
#include <iomanip>
#include <ostream>
#include <sstream>
#include <utility>
 
namespace Trk {
 
namespace {
template <typename T>
int sgn(const T& val) {
  return (val > 0) - (val < 0);
}
}  // namespace
 
// Helper protected ctor*/
template <int DIM, class T>
ParametersBase<DIM, T>::ParametersBase(
    const AmgVector(DIM) parameters,
    std::optional<AmgSymMatrix(DIM)>&& covariance, const T chargeDef)
    : ParametersCommon<DIM, T>(parameters, std::move(covariance), chargeDef)
{
  // cppcheck-suppress missingReturn; false positive
}
 
// Helper protected ctor
template <int DIM, class T>
ParametersBase<DIM, T>::ParametersBase(
    std::optional<AmgSymMatrix(DIM)>&& covariance)
    : ParametersCommon<DIM, T>(std::move(covariance))
{
  // cppcheck-suppress missingReturn; false positive
}
 
// Protected Constructor with local arguments - persistency only
template <int DIM, class T>
ParametersBase<DIM, T>::ParametersBase(
    const AmgVector(DIM) & parameters,
    std::optional<AmgSymMatrix(DIM)>&& covariance)
    : ParametersCommon<DIM, T>(parameters, std::move(covariance))
{
  // cppcheck-suppress missingReturn; false positive
}
 
 
template<int DIM, class T>
double
ParametersBase<DIM, T>::charge() const
{
  return m_chargeDef.charge();
}
 
template<int DIM, class T>
const Amg::Vector3D&
ParametersBase<DIM, T>::position() const
{
  return m_position;
}
 
template<int DIM, class T>
const Amg::Vector3D&
ParametersBase<DIM, T>::momentum() const
{
  return m_momentum;
}
 
template <int DIM, class T>
double ParametersBase<DIM, T>::pT() const {
  return momentum().perp();
}
 
template <int DIM, class T>
double ParametersBase<DIM, T>::eta() const {
  return momentum().eta();
}
 
/** equality operator */
template <int DIM, class T>
bool ParametersBase<DIM, T>::operator==(
    const ParametersBase<DIM, T>& rhs) const {
  // tolerance for comparisons
  constexpr double tolerance = 1e-8;
 
  // compare parameters
  if (!this->parameters().isApprox(rhs.parameters(), tolerance)) {
    return false;
  }
 
  // compare covariance
  if (((this->covariance() != nullptr) && (rhs.covariance() != nullptr) &&
       !this->covariance()->isApprox(*rhs.covariance(), tolerance)) ||
      (!this->covariance() !=
       !rhs.covariance())) {  // <-- this is: covariance()
                              // XOR pCast->covariance()
    return false;
  }
 
  // compare position
  if (!this->position().isApprox(rhs.position(), tolerance)) {
    return false;
  }
 
  // compare momentum
  if (!this->momentum().isApprox(rhs.momentum(), tolerance)) {
    return false;
  }
 
  // compare charge definition
  if (m_chargeDef != rhs.m_chargeDef) {
    return false;
  }
 
  return true;
}
 
template <int DIM, class T>
MsgStream& ParametersBase<DIM, T>::dump(MsgStream& sl) const {
  std::ostringstream output{};
  dump(output);
  sl << output.str();
  return sl;
}
 
template <int DIM, class T>
std::ostream& ParametersBase<DIM, T>::dump(std::ostream& sl) const {
  const std::string nl{"\n"};
  sl << std::setiosflags(std::ios::fixed);
  sl << std::setprecision(7);
  sl << " * TrackParameters on Surface" << nl;
  sl << " * loc1  : " << this->parameters()[Trk::loc1] << nl;
  sl << " * loc2  : " << this->parameters()[Trk::loc2] << nl;
  sl << " * phi   : " << this->parameters()[Trk::phi] << nl;
  sl << " * Theta : " << this->parameters()[Trk::theta] << nl;
  sl << " * q/p   : " << this->parameters()[Trk::qOverP] << nl;
  if (this->parameters().rows() > 5) {
    sl << " * mass  : " << this->parameters()[Trk::trkMass]
       << " (extended parameters)" << nl;
  }
  sl << " * charge: " << this->charge() << nl;
  sl << " * covariance matrix = " << this->covariance() << nl;
  sl << " * corresponding global parameters:" << nl;
  sl << " *    position  (x,  y,  z ) = (" << this->position().x() << ", "
     << this->position().y() << ", " << this->position().z() << ")" << nl;
  sl << " *    momentum  (px, py, pz) = (" << this->momentum().x() << ", "
     << this->momentum().y() << ", " << this->momentum().z() << ")" << nl;
  sl << std::setprecision(-1);
  if (this->hasSurface()) {
    sl << "associated surface:" << nl;
    this->associatedSurface().dump(sl) << std::endl;
  } else {
    sl << "no associated surface" << std::endl;
  }
 
  return sl;
}
 
template <int DIM, class T>
MsgStream& operator<<(MsgStream& sl, const Trk::ParametersBase<DIM, T>& p) {
  return p.dump(sl);
}
 
template <int DIM, class T>
std::ostream& operator<<(std::ostream& sl,
                         const Trk::ParametersBase<DIM, T>& p) {
  return p.dump(sl);
}
}  // end of namespace Trk