UnitConverters.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2025 CERN for the benefit of the ATLAS collaboration
*/
#ifndef ACTSINTEROPS_UNITCONVERTER_H
#define ACTSINTEROPS_UNITCONVERTER_H
 
 
#include "GeoPrimitives/GeoPrimitives.h"
#include "GaudiKernel/SystemOfUnits.h"
 
#include "Acts/Definitions/Units.hpp"
#include "Acts/Definitions/Algebra.hpp"
#include "Acts/Definitions/Common.hpp"
#include "Acts/Utilities/MathHelpers.hpp"
 
#include <utility>
#include <concepts>
 
namespace ActsTrk{
    inline constexpr double energyToActs(const double athenaE) {
        using namespace Acts::UnitLiterals;
        constexpr double energyCnv = 1_MeV / Gaudi::Units::MeV;
        return energyCnv * athenaE;
    }

    inline constexpr double energyToAthena(const double actsE) {
        using namespace Acts::UnitLiterals;
        constexpr double energyCnv = Gaudi::Units::MeV / 1_MeV;
        return energyCnv * actsE;
    }

    inline constexpr double lengthToActs(const double athenaL) {
        using namespace Acts::UnitLiterals;
         constexpr double lengthCnv = 1_mm / Gaudi::Units::mm;
         return lengthCnv * athenaL;
    }

    inline constexpr double lengthToAthena(const double actsL) {
        using namespace Acts::UnitLiterals;
         constexpr double lengthCnv = Gaudi::Units::mm / 1_mm;
         return lengthCnv * actsL;
    }

    template <std::floating_point T>
    inline constexpr auto timeToActs(T athenaT) {
        using namespace Acts::UnitLiterals;
        constexpr auto timeCnv = static_cast<T>(1_ns / Gaudi::Units::ns);
        return timeCnv * athenaT;
    }

    template <std::floating_point T>
    inline constexpr double timeToAthena(T actsT) {
        using namespace Acts::UnitLiterals;
        constexpr auto timeCnv = static_cast<T>(Gaudi::Units::ns/ 1_ns);
        return timeCnv * actsT;
    }

    template <std::floating_point T>
    inline constexpr auto timeCovToActs(T athenaTCov) {
        using namespace Acts::UnitLiterals;
        constexpr auto sqr=[](double a) { return a*a;};
        constexpr auto timeCnv = static_cast<T>(sqr(1_ns / Gaudi::Units::ns));
        return timeCnv * athenaTCov;
    }

    template <std::floating_point T>
    inline constexpr double timeCovToAthena(T actsTCov) {
        using namespace Acts::UnitLiterals;
        constexpr auto sqr=[](double a) { return a*a;};
        constexpr auto timeCnv = static_cast<T>(sqr(Gaudi::Units::ns/ 1_ns));
        return timeCnv * actsTCov;
    }

    inline constexpr double velocityToActs(const double athenaV) {
        return athenaV  / timeToActs(1.);
    }

    inline constexpr double accelerationToActs(const double athenaA) {
        return athenaA / Acts::square(timeToActs(1.));
    }

    inline Acts::Vector3 convertDirToActs(const Amg::Vector3D& athenaDir) {
        return athenaDir;
    }

    inline Amg::Vector3D convertDirFromActs(const Acts::Vector3& actsDir) {
        return actsDir;
    }

    inline Acts::Vector4 convertPosToActs(const Amg::Vector3D& athenaPos,
                                          const double athenaTime =0.) {
        Acts::Vector4 pos{Acts::Vector4::Zero()};
        pos[Acts::eTime] = timeToActs(athenaTime);
        pos[Acts::ePos0] = lengthToActs(athenaPos.x());
        pos[Acts::ePos1] = lengthToActs(athenaPos.y());
        pos[Acts::ePos2] = lengthToActs(athenaPos.z());
        return pos;
    }

    inline std::pair<Amg::Vector3D, double> convertPosFromActs(const Acts::Vector4& actsPos) {
        Amg::Vector3D pos{Amg::Vector3D::Zero()};
        pos[Amg::x] = lengthToAthena(actsPos[Acts::ePos0]);
        pos[Amg::y] = lengthToAthena(actsPos[Acts::ePos1]);
        pos[Amg::z] = lengthToAthena(actsPos[Acts::ePos2]);
        return std::make_pair(std::move(pos), timeToAthena(actsPos[Acts::eTime]));
    }

    inline Acts::Vector4 convertMomToActs(const Amg::Vector3D& threeMom, const double mass = 0.) {
        using namespace Acts::UnitLiterals;
        Acts::Vector4 fourMom{Acts::Vector4::Zero()};
        fourMom[Acts::eEnergy] = energyToActs(std::sqrt(threeMom.dot(threeMom) + mass*mass));
        fourMom[Acts::eMom0] = energyToActs(threeMom.x());
        fourMom[Acts::eMom1] = energyToActs(threeMom.y());
        fourMom[Acts::eMom2] = energyToActs(threeMom.z());
        return fourMom;
    }

    inline std::pair<Amg::Vector3D, double> convertMomFromActs(const Acts::Vector4& actsMom) {
        Amg::Vector3D threeMom{Amg::Vector3D::Zero()};
        threeMom[Amg::x] = energyToAthena(actsMom[Acts::eMom0]);
        threeMom[Amg::y] = energyToAthena(actsMom[Acts::eMom1]);
        threeMom[Amg::z] = energyToAthena(actsMom[Acts::eMom2]);
        return std::make_pair(std::move(threeMom), energyToAthena(actsMom[Acts::eEnergy]));
    }
}
#endif