SatMetaDataStore.hpp

Go to the documentation of this file.

//==============================================================================
//
//  This file is part of GNSSTk, the ARL:UT GNSS Toolkit.
//
//  The GNSSTk is free software; you can redistribute it and/or modify
//  it under the terms of the GNU Lesser General Public License as published
//  by the Free Software Foundation; either version 3.0 of the License, or
//  any later version.
//
//  The GNSSTk is distributed in the hope that it will be useful,
//  but WITHOUT ANY WARRANTY; without even the implied warranty of
//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
//  GNU Lesser General Public License for more details.
//
//  You should have received a copy of the GNU Lesser General Public
//  License along with GNSSTk; if not, write to the Free Software Foundation,
//  Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110, USA
//
//  This software was developed by Applied Research Laboratories at the
//  University of Texas at Austin.
//  Copyright 2004-2022, The Board of Regents of The University of Texas System
//
//==============================================================================
 
//==============================================================================
//
//  This software was developed by Applied Research Laboratories at the
//  University of Texas at Austin, under contract to an agency or agencies
//  within the U.S. Department of Defense. The U.S. Government retains all
//  rights to use, duplicate, distribute, disclose, or release this software.
//
//  Pursuant to DoD Directive 523024
//
//  DISTRIBUTION STATEMENT A: This software has been approved for public
//                            release, distribution is unlimited.
//
//==============================================================================
 
#ifndef GNSSTK_SATMETADATASTORE_HPP
#define GNSSTK_SATMETADATASTORE_HPP
 
#include <map>
#include <set>
#include "SatMetaData.hpp"
#include "SatMetaDataSort.hpp"
#include "NavID.hpp"
 
namespace gnsstk
{
   class SatMetaDataStore
   {
   public:
      struct Signal
      {
         Signal()
               : carrier(CarrierBand::Unknown), code(TrackingCode::Unknown),
                 nav(NavType::Unknown)
         {}
         Signal(CarrierBand c, TrackingCode r, NavType n)
               : carrier(c), code(r), nav(n)
         {}
         inline bool operator<(const Signal& right) const;
         inline bool operator==(const Signal& right) const;
         inline bool operator!=(const Signal& right) const
         { return !operator==(right); }
         CarrierBand carrier; 
         TrackingCode code;   
         NavType nav;         
      };
      class SystemBlock
      {
      public:
         inline bool operator<(const SystemBlock& right) const;
         SatelliteSystem sys;
         std::string blk;
      };
      class SVNID
      {
      public:
         SVNID();
         SVNID(SatelliteSystem sys, const std::string& svn);
         SatelliteSystem system;
         std::string id;
         bool operator<(const SVNID& right) const;
      };
      class LaunchConfig
      {
      public:
         SVNID svn;
         gnsstk::CommonTime launchTime;
         std::string type;             
         std::string mission;          
      };
      typedef std::set<Signal> SignalSet;
      typedef std::map<std::string, SignalSet> SignalMap;
      typedef std::multiset<SatMetaData, SatMetaDataSort> SatSet;
      typedef std::map<SatelliteSystem, SatSet> SatMetaMap;
      typedef std::vector<SatMetaData::ClockType> ClockVec;
      typedef std::map<SystemBlock, ClockVec> ClockConfigMap;
      typedef std::map<SVNID, LaunchConfig> LaunchMap;
      typedef std::map<SVNID, unsigned long> NORADMap;
 
      SatMetaDataStore() = default;
 
      virtual bool loadData(const std::string& sourceName);
 
      bool findSat(SatelliteSystem sys, uint32_t prn,
                   const gnsstk::CommonTime& when,
                   SatMetaData& sat)
         const;
 
      bool findSat(const SatID& prn,
                   const gnsstk::CommonTime& when,
                   SatMetaData& sat)
         const
      { return findSat(prn.system, prn.id, when, sat); }
 
      bool getSVN(SatelliteSystem sys, uint32_t prn,
                  const gnsstk::CommonTime& when,
                  std::string& svn)
         const;
 
      bool getSVN(const SatID& sat, const gnsstk::CommonTime& when,
                  std::string& svn)
         const
      { return getSVN(sat.system, sat.id, when, svn); }
 
      bool findSatBySVN(SatelliteSystem sys, const std::string& svn,
                        const gnsstk::CommonTime& when,
                        SatMetaData& sat)
         const;
 
      bool findSatBySlotFdma(uint32_t slotID,
                             int32_t channel,
                             const gnsstk::CommonTime& when,
                             SatMetaData& sat)
         const;
 
      bool getPRN(SatelliteSystem sys, const std::string& svn,
                  const gnsstk::CommonTime& when,
                  uint32_t& prn)
         const;
 
      std::set<std::string> getSignalSet(const Signal& sig)
         const;
 
      std::set<std::string> getSignalSet(const SignalSet& signals)
         const;
 
      std::set<std::string> getSignalSet(CarrierBand band, TrackingCode code,
                                         NavType nav)
         const
      { return getSignalSet(Signal(band,code,nav)); }
      
      SatSet getSatsBySignal(const SignalSet& signals);
      
      SatSet getSatsBySignal(const SignalSet& signals, const CommonTime& when);
 
      SatSet getSatsBySignal(
         const SignalSet& signals,
         const CommonTime& beginTime,
         const CommonTime& endTime,
         const std::set<SatMetaData::Status>& status = {
            SatMetaData::Status::Operational,
            SatMetaData::Status::Decommissioned,
            SatMetaData::Status::Test });
 
      SatMetaMap satMap;
      SignalMap sigMap;
      ClockConfigMap clkMap;
      LaunchMap launchMap;
      NORADMap noradMap;
 
   protected:
      bool addSat(const std::vector<std::string>& vals, unsigned long lineNo);
      bool addSignal(const std::vector<std::string>& vals,
                     unsigned long lineNo);
      bool addClock(const std::vector<std::string>& vals, unsigned long lineNo);
      bool addLaunch(const std::vector<std::string>& vals,
                     unsigned long lineNo);
      bool addNORAD(const std::vector<std::string>& vals, unsigned long lineNo);
   }; // class SatMetaDataStore
 
 
   bool SatMetaDataStore::Signal ::
   operator<(const Signal& right)
      const
   {
      if (static_cast<int>(carrier) < static_cast<int>(right.carrier))
      {
         return true;
      }
      if (static_cast<int>(carrier) > static_cast<int>(right.carrier))
      {
         return false;
      }
      if (static_cast<int>(code) < static_cast<int>(right.code))
      {
         return true;
      }
      if (static_cast<int>(code) > static_cast<int>(right.code))
      {
         return false;
      }
      if (static_cast<int>(nav) < static_cast<int>(right.nav))
      {
         return true;
      }
      return false;
   }
 
 
   bool SatMetaDataStore::Signal ::
   operator==(const Signal& right)
      const
   {
      if ((carrier != CarrierBand::Any) &&
          (right.carrier != CarrierBand::Any) &&
          (carrier != right.carrier))
      {
         return false;
      }
      if ((code != TrackingCode::Any) &&
          (right.code != TrackingCode::Any) &&
          (code != right.code))
      {
         return false;
      }
      if ((nav != NavType::Any) &&
          (right.nav != NavType::Any) &&
          (nav != right.nav))
      {
         return false;
      }
      return true;
   }
 
 
   bool SatMetaDataStore::SystemBlock ::
   operator<(const SatMetaDataStore::SystemBlock& right)
      const
   {
      if (static_cast<int>(sys) < static_cast<int>(right.sys))
         return true;
      if (static_cast<int>(sys) > static_cast<int>(right.sys))
         return false;
      return blk < right.blk;
   }
 
 
   inline std::ostream& operator<<(std::ostream& s,
                                   const SatMetaDataStore::SystemBlock& sblk)
   {
      s << gnsstk::StringUtils::asString(sblk.sys) << " " << sblk.blk;
      return s;
   }
 
 
   inline std::ostream& operator<<(std::ostream& s,
                                   const SatMetaDataStore::SVNID& svn)
   {
      s << gnsstk::StringUtils::asString(svn.system) << " " << svn.id;
      return s;
   }
 
} // namespace gnsstk
 
#endif // GNSSTK_SATMETADATASTORE_HPP