GnssAnalyzer.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 "internal/Node/Node.hpp"
 
#include "Navigation/GNSS/Core/SatelliteIdentifier.hpp"
#include "Navigation/GNSS/Ambiguity/CycleSlipDetector.hpp"
#include "Navigation/Math/Polynomial.hpp"
 
namespace NAV
{
class GnssAnalyzer : public Node
{
  public:
    GnssAnalyzer();
    ~GnssAnalyzer() override;
    GnssAnalyzer(const GnssAnalyzer&) = delete;
    GnssAnalyzer(GnssAnalyzer&&) = delete;
    GnssAnalyzer& operator=(const GnssAnalyzer&) = delete;
    GnssAnalyzer& operator=(GnssAnalyzer&&) = delete;
 
    [[nodiscard]] static std::string typeStatic();
 
    [[nodiscard]] std::string type() const override;
 
    [[nodiscard]] static std::string category();
 
    void guiConfig() override;
 
    [[nodiscard]] json save() const override;
 
    void restore(const json& j) override;
 
  private:
    constexpr static size_t INPUT_PORT_INDEX_GNSS_OBS = 0;          
    constexpr static size_t OUTPUT_PORT_INDEX_GNSS_COMBINATION = 0; 
 
    struct Combination
    {
        enum class Unit
        {
            Meters, 
            Cycles, 
        };
 
        Unit unit = Unit::Meters;
 
        struct Term
        {
            enum class ObservationType
            {
                Pseudorange, 
                Carrier,     
            };
 
            int sign = +1;                                      
            SatSigId satSigId = { Code::G1C, 1 };               
            int8_t freqNum = -128;                              
            ObservationType obsType = ObservationType::Carrier; 
            bool receivedDuringRun = false;                     
        };
        std::vector<Term> terms{ Term() }; 
 
        PolynomialCycleSlipDetector<std::string> polynomialCycleSlipDetector{ /* windowSize = */ 4, /* polyDegree = */ 2 };
        double polynomialCycleSlipDetectorThresholdPercentage = 0.5;
        bool polynomialCycleSlipDetectorOutputWhenWindowSizeNotReached = false;
        bool polynomialCycleSlipDetectorOutputPolynomials = false;
        std::vector<std::pair<InsTime, Polynomial<double>>> polynomials;
 
        [[nodiscard]] std::string description() const
        {
            std::string desc;
            for (const auto& term : terms)
            {
                if (!desc.empty()) { desc += " "; }
                desc += term.sign == 1 ? "+" : "-";
                desc += " ";
                switch (term.obsType)
                {
                case Term::ObservationType::Pseudorange:
                    desc += unit == Unit::Cycles ? "P" : "p";
                    break;
                case Term::ObservationType::Carrier:
                    desc += unit == Unit::Cycles ? "Φ" : "φ";
                    break;
                }
                desc += fmt::format("({})", term.satSigId);
            }
            if (unit == Unit::Cycles) { desc += " [cycles]"; }
            else { desc += " [m]"; }
 
            return desc;
        }
 
        [[nodiscard]] double calcCombinationFrequency() const
        {
            double combinedFreq = 0.0;
            for (const auto& term : terms)
            {
                double freq = term.satSigId.freq().getFrequency(term.freqNum);
                combinedFreq += static_cast<double>(term.sign) * freq;
            }
            return combinedFreq == 0 ? terms.front().satSigId.freq().getFrequency(terms.front().freqNum) : combinedFreq;
        }
    };
 
    std::vector<Combination> _combinations{ Combination() };
 
    bool initialize() override;
 
    void deinitialize() override;
 
    void receiveGnssObs(InputPin::NodeDataQueue& queue, size_t pinIdx);
 
    friend void to_json(json& j, const Combination& data);
    friend void from_json(const json& j, Combination& data);
    friend void to_json(json& j, const Combination::Term& data);
    friend void from_json(const json& j, Combination::Term& data);
};
 
} // namespace NAV