GnssCombination.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 <tuple>
 
#include "NodeData/NodeData.hpp"
#include "GnssObs.hpp"
#include "Navigation/GNSS/Ambiguity/CycleSlipDetector/PolynomialCycleSlipDetector.hpp"
 
namespace NAV
{
 
class GnssCombination : public NodeData
{
  public:
    [[nodiscard]] static std::string type()
    {
        return "GnssCombination";
    }
 
    [[nodiscard]] std::string getType() const override { return type(); }
 
    [[nodiscard]] static std::vector<std::string> parentTypes()
    {
        return { NodeData::type() };
    }
 
    struct Combination
    {
        struct Term
        {
            int sign = +1;                                                        
            SatSigId satSigId = { Code::None, 0 };                                
            GnssObs::ObservationType obsType = GnssObs::ObservationType::Carrier; 
            std::optional<double> value;                                          
        };
 
        std::string description;      
        std::optional<double> result; 
        std::vector<Term> terms;      
 
        std::optional<PolynomialCycleSlipDetectorResult> cycleSlipResult;                  
        std::optional<double> cycleSlipPrediction;                                         
        std::optional<double> cycleSlipMeasMinPred;                                        
        std::vector<std::tuple<InsTime, Polynomial<double>, double>> cycleSlipPolynomials; 
    };
 
    std::vector<Combination> combinations;
 
    [[nodiscard]] std::vector<std::string> dynamicDataDescriptors() const override
    {
        std::vector<std::string> descriptors;
        descriptors.reserve(combinations.size() * 4);
 
        for (const auto& comb : combinations)
        {
            descriptors.push_back(comb.description);
            descriptors.push_back(comb.description + " Cycle Slip");
            descriptors.push_back(comb.description + " Prediction");
            descriptors.push_back(comb.description + " Meas - Pred");
        }
 
        return descriptors;
    }
 
    [[nodiscard]] std::optional<double> getDynamicDataAt(const std::string& descriptor) const override
    {
        for (const auto& comb : combinations)
        {
            if (descriptor == comb.description) { return comb.result; }
            if (descriptor == comb.description + " Cycle Slip" && comb.cycleSlipResult) { return static_cast<double>(*comb.cycleSlipResult); }
            if (descriptor == comb.description + " Prediction") { return comb.cycleSlipPrediction; }
            if (descriptor == comb.description + " Meas - Pred") { return comb.cycleSlipMeasMinPred; }
        }
        return std::nullopt;
    }
 
    [[nodiscard]] std::vector<std::pair<std::string, double>> getDynamicData() const override
    {
        std::vector<std::pair<std::string, double>> dynData;
        dynData.reserve(combinations.size() * 4);
        for (const auto& comb : combinations)
        {
            if (comb.result) { dynData.emplace_back(comb.description, *comb.result); }
            if (comb.cycleSlipResult) { dynData.emplace_back(comb.description + " Cycle Slip", static_cast<double>(*comb.cycleSlipResult)); }
            if (comb.cycleSlipPrediction) { dynData.emplace_back(comb.description + " Prediction", *comb.cycleSlipPrediction); }
            if (comb.cycleSlipMeasMinPred) { dynData.emplace_back(comb.description + " Meas - Pred", *comb.cycleSlipMeasMinPred); }
        }
        return dynData;
    }
};
 
} // namespace NAV