Keys.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 <vector>
#include <variant>
#include <fmt/format.h>
 
#include "Navigation/GNSS/Core/SatelliteIdentifier.hpp"
#include "Navigation/GNSS/SystemModel/MotionModel.hpp"
#include "Navigation/GNSS/SystemModel/InterFrequencyBiasModel.hpp"
#include "Navigation/GNSS/SystemModel/ReceiverClockModel.hpp"
 
namespace NAV::SPP
{
 
namespace States
{
 
constexpr size_t POS_STATE_COUNT = 4; 
constexpr size_t VEL_STATE_COUNT = 4; 
 
constexpr size_t POS_VEL_STATE_COUNT = 6; 
 
using StateKeyType = std::variant<Keys::MotionModelKey, Keys::RecvClkBias, Keys::RecvClkDrift, Keys::InterFreqBias>;
 
} // namespace States
 
namespace Meas
{
 
struct Psr
{
    bool operator==(const Psr& rhs) const { return satSigId == rhs.satSigId; }
    SatSigId satSigId;
};
struct Doppler
{
    bool operator==(const Doppler& rhs) const { return satSigId == rhs.satSigId; }
    SatSigId satSigId;
};
 
using MeasKeyTypes = std::variant<Psr, Doppler>;
 
} // namespace Meas
 
} // namespace NAV::SPP
 
std::ostream& operator<<(std::ostream& os, const NAV::SPP::Meas::Psr& obj);
 
std::ostream& operator<<(std::ostream& os, const NAV::SPP::Meas::Doppler& obj);
 
std::ostream& operator<<(std::ostream& os, const NAV::SPP::States::StateKeyType& obj);
 
std::ostream& operator<<(std::ostream& os, const NAV::SPP::Meas::MeasKeyTypes& obj);
 
namespace std
{
template<>
struct hash<NAV::SPP::Meas::Psr>
{
    size_t operator()(const NAV::SPP::Meas::Psr& psr) const
    {
        return std::hash<NAV::SatSigId>()(psr.satSigId);
    }
};
template<>
struct hash<NAV::SPP::Meas::Doppler>
{
    size_t operator()(const NAV::SPP::Meas::Doppler& doppler) const
    {
        return std::hash<NAV::SatSigId>()(doppler.satSigId) << 12;
    }
};
} // namespace std
 
#ifndef DOXYGEN_IGNORE
 
template<>
struct fmt::formatter<NAV::SPP::Meas::Psr> : fmt::formatter<std::string>
{
    template<typename FormatContext>
    auto format(const NAV::SPP::Meas::Psr& psr, FormatContext& ctx) const
    {
        return fmt::formatter<std::string>::format(fmt::format("psr({})", psr.satSigId), ctx);
    }
};
 
template<>
struct fmt::formatter<NAV::SPP::Meas::Doppler> : fmt::formatter<std::string>
{
    template<typename FormatContext>
    auto format(const NAV::SPP::Meas::Doppler& doppler, FormatContext& ctx) const
    {
        return fmt::formatter<std::string>::format(fmt::format("dop({})", doppler.satSigId), ctx);
    }
};
 
template<>
struct fmt::formatter<NAV::SPP::States::StateKeyType> : fmt::formatter<std::string>
{
    template<typename FormatContext>
    auto format(const NAV::SPP::States::StateKeyType& state, FormatContext& ctx) const
    {
        using namespace NAV::Keys; // NOLINT(google-build-using-namespace)
 
        if (const auto* s = std::get_if<MotionModelKey>(&state))
        {
            switch (*s)
            {
            case PosX:
                return fmt::formatter<std::string>::format("PosX", ctx);
            case PosY:
                return fmt::formatter<std::string>::format("PosY", ctx);
            case PosZ:
                return fmt::formatter<std::string>::format("PosZ", ctx);
            case VelX:
                return fmt::formatter<std::string>::format("VelX", ctx);
            case VelY:
                return fmt::formatter<std::string>::format("VelY", ctx);
            case VelZ:
                return fmt::formatter<std::string>::format("VelZ", ctx);
            case MotionModelKey_COUNT:
                return fmt::formatter<std::string>::format("MotionModelKey_COUNT", ctx);
            }
        }
        if (const auto* recvClkErr = std::get_if<RecvClkBias>(&state))
        {
            return fmt::formatter<std::string>::format(fmt::format("RecvClkBias({})", recvClkErr->satSys), ctx);
        }
        if (const auto* recvClkDrift = std::get_if<RecvClkDrift>(&state))
        {
            return fmt::formatter<std::string>::format(fmt::format("RecvClkDrift({})", recvClkDrift->satSys), ctx);
        }
        if (const auto* interFreqBias = std::get_if<NAV::Keys::InterFreqBias>(&state))
        {
            return fmt::formatter<std::string>::format(fmt::format("InterFreqBias({})", interFreqBias->freq), ctx);
        }
 
        return fmt::formatter<std::string>::format("ERROR", ctx);
    }
};
 
template<>
struct fmt::formatter<NAV::SPP::Meas::MeasKeyTypes> : fmt::formatter<std::string>
{
    template<typename FormatContext>
    auto format(const NAV::SPP::Meas::MeasKeyTypes& meas, FormatContext& ctx) const
    {
        if (const auto* psr = std::get_if<NAV::SPP::Meas::Psr>(&meas))
        {
            return fmt::formatter<std::string>::format(fmt::format("psr({})", psr->satSigId), ctx);
        }
        if (const auto* doppler = std::get_if<NAV::SPP::Meas::Doppler>(&meas))
        {
            return fmt::formatter<std::string>::format(fmt::format("doppler({})", doppler->satSigId), ctx);
        }
 
        return fmt::formatter<std::string>::format("ERROR", ctx);
    }
};
 
#endif