Units.hpp

Go to the documentation of this file.

// This file is part of INSTINCT, the INS Toolkit for Integrated
// Navigation Concepts and Training by the Institute of Navigation of
// the University of Stuttgart, Germany.
//
// 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 https://mozilla.org/MPL/2.0/.

 
#pragma once
 
#include <cstddef>
#include <string>
 
#include "Navigation/Constants.hpp"
#include "Navigation/Transformations/Units.hpp"
#include "util/Eigen.hpp"
#include "util/Json.hpp"
 
namespace NAV
{
 
namespace Units
{

enum class ImuAccelerometerUnits : uint8_t
{
    m_s2,  
    g,     
    COUNT, 
};

enum class ImuGyroscopeUnits : uint8_t
{
    rad_s, 
    deg_s, 
    COUNT, 
};

enum class ImuAccelerometerNoiseUnits : uint8_t
{
    m_s2_sqrts, 
    m_s2_sqrth, 
    COUNT,      
};

enum class ImuGyroscopeNoiseUnits : uint8_t
{
    rad_s_sqrts, 
    rad_s_sqrth, 
    deg_s_sqrts, 
    deg_s_sqrth, 
    COUNT,       
};

enum class ImuAccelerometerIRWUnits : uint8_t
{
    m_s3_sqrts, 
    m_s3_sqrth, 
    COUNT,      
};

enum class ImuGyroscopeIRWUnits : uint8_t
{
    rad_s2_sqrts, 
    rad_s2_sqrth, 
    deg_s2_sqrts, 
    deg_s2_sqrth, 
    COUNT,        
};

enum class ImuAccelerometerFilterNoiseUnits : uint8_t
{
    m_s2_sqrtHz, 
    mg_sqrtHz,   
    COUNT,       
};

enum class ImuGyroscopeFilterNoiseUnits : uint8_t
{
    rad_s_sqrtHz,  
    rad_hr_sqrtHz, 
    deg_s_sqrtHz,  
    deg_hr_sqrtHz, 
    COUNT,         
};

enum class ImuAccelerometerFilterBiasUnits : uint8_t
{
    m_s2,   
    microg, 
    COUNT,  
};

enum class ImuGyroscopeFilterBiasUnits : uint8_t
{
    rad_s, 
    rad_h, 
    deg_s, 
    deg_h, 
    COUNT, 
};

void to_json(json& j, const ImuAccelerometerUnits& data);
void from_json(const json& j, ImuAccelerometerUnits& data);

void to_json(json& j, const ImuGyroscopeUnits& data);
void from_json(const json& j, ImuGyroscopeUnits& data);

void to_json(json& j, const ImuAccelerometerNoiseUnits& data);
void from_json(const json& j, ImuAccelerometerNoiseUnits& data);

void to_json(json& j, const ImuGyroscopeNoiseUnits& data);
void from_json(const json& j, ImuGyroscopeNoiseUnits& data);

void to_json(json& j, const ImuAccelerometerIRWUnits& data);
void from_json(const json& j, ImuAccelerometerIRWUnits& data);

void to_json(json& j, const ImuGyroscopeIRWUnits& data);
void from_json(const json& j, ImuGyroscopeIRWUnits& data);

void to_json(json& j, const ImuAccelerometerFilterNoiseUnits& data);
void from_json(const json& j, ImuAccelerometerFilterNoiseUnits& data);

void to_json(json& j, const ImuGyroscopeFilterNoiseUnits& data);
void from_json(const json& j, ImuGyroscopeFilterNoiseUnits& data);

void to_json(json& j, const ImuAccelerometerFilterBiasUnits& data);
void from_json(const json& j, ImuAccelerometerFilterBiasUnits& data);

void to_json(json& j, const ImuGyroscopeFilterBiasUnits& data);
void from_json(const json& j, ImuGyroscopeFilterBiasUnits& data);
 
} // namespace Units

template<typename Derived>
[[nodiscard]] typename Derived::PlainObject convertUnit(const Eigen::MatrixBase<Derived>& value, Units::ImuAccelerometerUnits unit)
{
    switch (unit)
    {
    case Units::ImuAccelerometerUnits::m_s2:
        return value;
    case Units::ImuAccelerometerUnits::g:
        return value * InsConst::G_NORM;
    case Units::ImuAccelerometerUnits::COUNT:
        break;
    }
    return value;
}

template<typename Derived>
[[nodiscard]] typename Derived::PlainObject convertUnit(const Eigen::MatrixBase<Derived>& value, Units::ImuGyroscopeUnits unit)
{
    switch (unit)
    {
    case Units::ImuGyroscopeUnits::rad_s:
        return value;
    case Units::ImuGyroscopeUnits::deg_s:
        return deg2rad(value);
    case Units::ImuGyroscopeUnits::COUNT:
        break;
    }
    return value;
}

template<typename Derived>
[[nodiscard]] typename Derived::PlainObject convertUnit(const Eigen::MatrixBase<Derived>& value, Units::ImuAccelerometerNoiseUnits unit)
{
    switch (unit)
    {
    case Units::ImuAccelerometerNoiseUnits::m_s2_sqrts:
        return value;
    case Units::ImuAccelerometerNoiseUnits::m_s2_sqrth:
        return value / 60.0;
    case Units::ImuAccelerometerNoiseUnits::COUNT:
        break;
    }
    return value;
}

template<typename Derived>
[[nodiscard]] typename Derived::PlainObject convertUnit(const Eigen::MatrixBase<Derived>& value, Units::ImuGyroscopeNoiseUnits unit)
{
    switch (unit)
    {
    case Units::ImuGyroscopeNoiseUnits::rad_s_sqrts:
        return value;
    case Units::ImuGyroscopeNoiseUnits::rad_s_sqrth:
        return value / 60.0;
    case Units::ImuGyroscopeNoiseUnits::deg_s_sqrts:
        return deg2rad(value);
    case Units::ImuGyroscopeNoiseUnits::deg_s_sqrth:
        return deg2rad(value) / 60.0;
    case Units::ImuGyroscopeNoiseUnits::COUNT:
        break;
    }
    return value;
}

template<typename Derived>
[[nodiscard]] typename Derived::PlainObject convertUnit(const Eigen::MatrixBase<Derived>& value, Units::ImuAccelerometerIRWUnits unit)
{
    switch (unit)
    {
    case Units::ImuAccelerometerIRWUnits::m_s3_sqrts:
        return value;
    case Units::ImuAccelerometerIRWUnits::m_s3_sqrth:
        return value / 60.0;
    case Units::ImuAccelerometerIRWUnits::COUNT:
        break;
    }
    return value;
}

template<typename Derived>
[[nodiscard]] typename Derived::PlainObject convertUnit(const Eigen::MatrixBase<Derived>& value, Units::ImuGyroscopeIRWUnits unit)
{
    switch (unit)
    {
    case Units::ImuGyroscopeIRWUnits::rad_s2_sqrts:
        return value;
    case Units::ImuGyroscopeIRWUnits::rad_s2_sqrth:
        return value / 60.0;
    case Units::ImuGyroscopeIRWUnits::deg_s2_sqrts:
        return deg2rad(value);
    case Units::ImuGyroscopeIRWUnits::deg_s2_sqrth:
        return deg2rad(value) / 60.0;
    case Units::ImuGyroscopeIRWUnits::COUNT:
        break;
    }
    return value;
}

template<typename Derived>
[[nodiscard]] typename Derived::PlainObject convertUnit(const Eigen::MatrixBase<Derived>& value, Units::ImuAccelerometerFilterNoiseUnits unit)
{
    switch (unit)
    {
    case Units::ImuAccelerometerFilterNoiseUnits::m_s2_sqrtHz:
        return value;
    case Units::ImuAccelerometerFilterNoiseUnits::mg_sqrtHz:
        return value * 1e-3 * InsConst::G_NORM;
    case Units::ImuAccelerometerFilterNoiseUnits::COUNT:
        break;
    }
    return value;
}

template<typename Derived>
[[nodiscard]] typename Derived::PlainObject convertUnit(const Eigen::MatrixBase<Derived>& value, Units::ImuGyroscopeFilterNoiseUnits unit)
{
    switch (unit)
    {
    case Units::ImuGyroscopeFilterNoiseUnits::rad_s_sqrtHz:
        return value;
    case Units::ImuGyroscopeFilterNoiseUnits::rad_hr_sqrtHz:
        return value / 3600.0;
    case Units::ImuGyroscopeFilterNoiseUnits::deg_s_sqrtHz:
        return deg2rad(value);
    case Units::ImuGyroscopeFilterNoiseUnits::deg_hr_sqrtHz:
        return deg2rad(value) / 3600.0;
    case Units::ImuGyroscopeFilterNoiseUnits::COUNT:
        break;
    }
    return value;
}

template<typename Derived>
[[nodiscard]] typename Derived::PlainObject convertUnit(const Eigen::MatrixBase<Derived>& value, Units::ImuAccelerometerFilterBiasUnits unit)
{
    switch (unit)
    {
    case Units::ImuAccelerometerFilterBiasUnits::m_s2:
        return value;
    case Units::ImuAccelerometerFilterBiasUnits::microg:
        return value * 1e-6 * InsConst::G_NORM;
    case Units::ImuAccelerometerFilterBiasUnits::COUNT:
        break;
    }
    return value;
}

template<typename Derived>
[[nodiscard]] typename Derived::PlainObject convertUnit(const Eigen::MatrixBase<Derived>& value, Units::ImuGyroscopeFilterBiasUnits unit)
{
    switch (unit)
    {
    case Units::ImuGyroscopeFilterBiasUnits::rad_s:
        return value;
    case Units::ImuGyroscopeFilterBiasUnits::rad_h:
        return value / 3600.0;
    case Units::ImuGyroscopeFilterBiasUnits::deg_s:
        return deg2rad(value);
    case Units::ImuGyroscopeFilterBiasUnits::deg_h:
        return deg2rad(value) / 3600.0;
    case Units::ImuGyroscopeFilterBiasUnits::COUNT:
        break;
    }
    return value;
}

[[nodiscard]] std::string to_string(Units::ImuAccelerometerUnits unit);
[[nodiscard]] std::string to_string(Units::ImuGyroscopeUnits unit);
[[nodiscard]] std::string to_string(Units::ImuAccelerometerNoiseUnits unit);
[[nodiscard]] std::string to_string(Units::ImuGyroscopeNoiseUnits unit);
[[nodiscard]] std::string to_string(Units::ImuAccelerometerIRWUnits unit);
[[nodiscard]] std::string to_string(Units::ImuGyroscopeIRWUnits unit);
[[nodiscard]] std::string to_string(Units::ImuAccelerometerFilterNoiseUnits unit);
[[nodiscard]] std::string to_string(Units::ImuGyroscopeFilterNoiseUnits unit);
[[nodiscard]] std::string to_string(Units::ImuAccelerometerFilterBiasUnits unit);
[[nodiscard]] std::string to_string(Units::ImuGyroscopeFilterBiasUnits unit);
 
} // namespace NAV