satellite-topology.h

Go to the documentation of this file.

/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
/*
 * Copyright (c) 2013 Magister Solutions Ltd.
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2 as
 * published by the Free Software Foundation;
 *
 * This program 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 General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 *
 * Author: Bastien Tauran <bastien.tauran@viveris.fr>
 */
#ifndef SATELLITE_TOPOLOGY_H
#define SATELLITE_TOPOLOGY_H
 
#include "lorawan-ground-mac-gateway.h"
#include "lorawan-mac-end-device.h"
#include "lorawan-mac-gateway.h"
#include "lorawan-orbiter-mac-gateway.h"
#include "satellite-gw-llc.h"
#include "satellite-gw-mac.h"
#include "satellite-gw-phy.h"
#include "satellite-net-device.h"
#include "satellite-orbiter-feeder-llc.h"
#include "satellite-orbiter-feeder-mac.h"
#include "satellite-orbiter-feeder-phy.h"
#include "satellite-orbiter-net-device.h"
#include "satellite-orbiter-user-llc.h"
#include "satellite-orbiter-user-mac.h"
#include "satellite-orbiter-user-phy.h"
#include "satellite-ut-llc.h"
#include "satellite-ut-mac.h"
#include "satellite-ut-phy.h"
 
#include <ns3/node-container.h>
#include <ns3/node.h>
#include <ns3/object.h>
 
#include <map>
#include <ostream>
#include <stdint.h>
#include <utility>
 
namespace ns3
{
 
class SatTopology : public Object
{
  public:
    typedef struct
    {
        uint32_t m_satId;
        uint32_t m_beamId;
        std::map<std::pair<uint32_t, uint32_t>, Ptr<SatNetDevice>> m_netDevice;
        std::map<std::pair<uint32_t, uint32_t>, Ptr<SatGwLlc>> m_llc;
        std::map<std::pair<uint32_t, uint32_t>, Ptr<SatGwMac>> m_dvbMac;
        std::map<std::pair<uint32_t, uint32_t>, Ptr<LorawanGroundMacGateway>> m_loraMac;
        std::map<std::pair<uint32_t, uint32_t>, Ptr<SatGwPhy>> m_phy;
    } GwLayers_s;
 
    typedef struct
    {
        uint32_t m_satId;
        uint32_t m_beamId;
        uint32_t m_groupId;
        Ptr<SatNetDevice> m_netDevice;
        Ptr<SatUtLlc> m_llc;
        Ptr<SatUtMac> m_dvbMac;
        Ptr<LorawanMacEndDevice> m_loraMac;
        Ptr<SatUtPhy> m_phy;
    } UtLayers_s;
 
    typedef struct
    {
        uint32_t m_satId;
        Ptr<SatOrbiterNetDevice> m_netDevice;
        std::map<uint32_t, Ptr<SatOrbiterFeederLlc>> m_feederLlc;
        std::map<uint32_t, Ptr<SatOrbiterUserLlc>> m_userLlc;
        std::map<uint32_t, Ptr<SatOrbiterFeederMac>> m_feederMac;
        std::map<uint32_t, Ptr<SatOrbiterUserMac>> m_dvbUserMac;
        std::map<uint32_t, Ptr<LorawanOrbiterMacGateway>> m_loraUserMac;
        std::map<uint32_t, Ptr<SatOrbiterFeederPhy>> m_feederPhy;
        std::map<uint32_t, Ptr<SatOrbiterUserPhy>> m_userPhy;
    } OrbiterLayers_s;
 
    SatTopology();
 
    ~SatTopology();
 
    static TypeId GetTypeId(void);
 
    void DoDispose();
 
    void Reset();
 
    void SetStandard(SatEnums::Standard_t standard);
 
    SatEnums::Standard_t GetStandard();
 
    void SetForwardLinkRegenerationMode(SatEnums::RegenerationMode_t forwardLinkRegenerationMode);
 
    SatEnums::RegenerationMode_t GetForwardLinkRegenerationMode();
 
    void SetReturnLinkRegenerationMode(SatEnums::RegenerationMode_t returnLinkRegenerationMode);
 
    SatEnums::RegenerationMode_t GetReturnLinkRegenerationMode();
 
    void AddGwNode(uint32_t gwId, Ptr<Node> gw);
 
    void AddUtNode(Ptr<Node> ut);
 
    void AddOrbiterNode(Ptr<Node> orbiter);
 
    void AddGwUserNode(Ptr<Node> gwUser);
 
    void AddUtUserNode(Ptr<Node> utUser, Ptr<Node> ut);
 
    void ConnectGwToUt(Ptr<Node> ut, Ptr<Node> gw);
 
    void UpdateGwConnectedToUt(Ptr<Node> ut, Ptr<Node> gw);
 
    void DisconnectGwFromUt(Ptr<Node> ut);
 
    Ptr<Node> GetGwFromUt(Ptr<Node> ut) const;
 
    void ConnectGwToBeam(uint32_t beamId, Ptr<Node> gw);
 
    Ptr<Node> GetGwFromBeam(uint32_t beamId) const;
 
    void AddOrbiterFeederMacPair(Ptr<SatOrbiterFeederMac> mac, Ptr<SatOrbiterFeederMac> usedMac);
 
    Ptr<SatOrbiterFeederMac> GetOrbiterFeederMacUsed(Ptr<SatOrbiterFeederMac> mac) const;
 
    Mac48Address GetGwAddressInUt(uint32_t utId);
 
    NodeContainer GetGwNodes() const;
 
    NodeContainer GetUtNodes() const;
 
    NodeContainer GetOrbiterNodes() const;
 
    NodeContainer GetGwUserNodes() const;
 
    NodeContainer GetUtUserNodes() const;
 
    NodeContainer GetUtUserNodes(NodeContainer uts) const;
 
    NodeContainer GetUtUserNodes(Ptr<Node> ut) const;
 
    Ptr<Node> GetUtNode(Ptr<Node> utUser) const;
 
    uint32_t GetNGwNodes() const;
 
    uint32_t GetNUtNodes() const;
 
    uint32_t GetNOrbiterNodes() const;
 
    uint32_t GetNGwUserNodes() const;
 
    uint32_t GetNUtUserNodes() const;
 
    Ptr<Node> GetGwNode(uint32_t nodeId) const;
 
    Ptr<Node> GetUtNode(uint32_t nodeId) const;
 
    Ptr<Node> GetOrbiterNode(uint32_t nodeId) const;
 
    Ptr<Node> GetGwUserNode(uint32_t nodeId) const;
 
    Ptr<Node> GetUtUserNode(uint32_t nodeId) const;
 
    Ptr<Node> GetNodeFromId(uint32_t nodeId) const;
 
    void AddGwLayersDvb(Ptr<Node> gw,
                        uint32_t gwSatId,
                        uint32_t gwBeamId,
                        uint32_t utSatId,
                        uint32_t utBeamId,
                        Ptr<SatNetDevice> netDevice,
                        Ptr<SatGwLlc> llc,
                        Ptr<SatGwMac> mac,
                        Ptr<SatGwPhy> phy);
 
    void AddGwLayersLora(Ptr<Node> gw,
                         uint32_t gwSatId,
                         uint32_t gwBeamId,
                         uint32_t utSatId,
                         uint32_t utBeamId,
                         Ptr<SatNetDevice> netDevice,
                         Ptr<LorawanGroundMacGateway> mac,
                         Ptr<SatGwPhy> phy);
 
    void UpdateGwSatAndBeam(Ptr<Node> gw, uint32_t satId, uint32_t beamId);
 
    uint32_t GetGwSatId(Ptr<Node> gw) const;
 
    uint32_t GetGwBeamId(Ptr<Node> gw) const;
 
    Ptr<SatNetDevice> GetGwNetDevice(Ptr<Node> gw, uint32_t utSatId, uint32_t utBeamId) const;
 
    Ptr<SatGwLlc> GetGwLlc(Ptr<Node> gw, uint32_t utSatId, uint32_t utBeamId) const;
 
    Ptr<SatGwMac> GetDvbGwMac(Ptr<Node> gw, uint32_t utSatId, uint32_t utBeamId) const;
 
    Ptr<LorawanGroundMacGateway> GetLoraGwMac(Ptr<Node> gw,
                                              uint32_t utSatId,
                                              uint32_t utBeamId) const;
 
    Ptr<SatGwPhy> GetGwPhy(Ptr<Node> gw, uint32_t utSatId, uint32_t utBeamId) const;
 
    void AddUtLayersDvb(Ptr<Node> ut,
                        uint32_t satId,
                        uint32_t beamId,
                        uint32_t groupId,
                        Ptr<SatNetDevice> netDevice,
                        Ptr<SatUtLlc> llc,
                        Ptr<SatUtMac> mac,
                        Ptr<SatUtPhy> phy);
 
    void AddUtLayersLora(Ptr<Node> ut,
                         uint32_t satId,
                         uint32_t beamId,
                         uint32_t groupId,
                         Ptr<SatNetDevice> netDevice,
                         Ptr<LorawanMacEndDevice> mac,
                         Ptr<SatUtPhy> phy);
 
    void UpdateUtSatAndBeam(Ptr<Node> ut, uint32_t satId, uint32_t beamId);
 
    void UpdateUtGroup(Ptr<Node> ut, uint32_t groupId);
 
    uint32_t GetUtSatId(Ptr<Node> ut) const;
 
    uint32_t GetUtBeamId(Ptr<Node> ut) const;
 
    uint32_t GetUtGroupId(Ptr<Node> ut) const;
 
    Ptr<SatNetDevice> GetUtNetDevice(Ptr<Node> ut) const;
 
    Ptr<SatUtLlc> GetUtLlc(Ptr<Node> ut) const;
 
    Ptr<SatUtMac> GetDvbUtMac(Ptr<Node> ut) const;
 
    Ptr<LorawanMacEndDevice> GetLoraUtMac(Ptr<Node> ut) const;
 
    Ptr<SatUtPhy> GetUtPhy(Ptr<Node> ut) const;
 
    void AddOrbiterFeederLayers(Ptr<Node> orbiter,
                                uint32_t satId,
                                uint32_t utBeamId,
                                Ptr<SatOrbiterNetDevice> netDevice,
                                Ptr<SatOrbiterFeederLlc> llc,
                                Ptr<SatOrbiterFeederMac> mac,
                                Ptr<SatOrbiterFeederPhy> phy);
 
    void AddOrbiterUserLayersDvb(Ptr<Node> orbiter,
                                 uint32_t satId,
                                 uint32_t beamId,
                                 Ptr<SatOrbiterNetDevice> netDevice,
                                 Ptr<SatOrbiterUserLlc> llc,
                                 Ptr<SatOrbiterUserMac> mac,
                                 Ptr<SatOrbiterUserPhy> phy);
 
    void AddOrbiterUserLayersLora(Ptr<Node> orbiter,
                                  uint32_t satId,
                                  uint32_t beamId,
                                  Ptr<SatOrbiterNetDevice> netDevice,
                                  Ptr<LorawanOrbiterMacGateway> mac,
                                  Ptr<SatOrbiterUserPhy> phy);
 
    uint32_t GetOrbiterSatId(Ptr<Node> orbiter) const;
 
    Ptr<SatOrbiterNetDevice> GetOrbiterNetDevice(Ptr<Node> orbiter) const;
 
    Ptr<SatOrbiterFeederLlc> GetOrbiterFeederLlc(Ptr<Node> orbiter, uint32_t utBeamId) const;
 
    Ptr<SatOrbiterUserLlc> GetOrbiterUserLlc(Ptr<Node> orbiter, uint32_t beamId) const;
 
    Ptr<SatOrbiterFeederMac> GetOrbiterFeederMac(Ptr<Node> orbiter, uint32_t utBeamId) const;
 
    Ptr<SatOrbiterUserMac> GetDvbOrbiterUserMac(Ptr<Node> orbiter, uint32_t beamId) const;
 
    Ptr<LorawanOrbiterMacGateway> GetLoraOrbiterUserMac(Ptr<Node> orbiter, uint32_t beamId) const;
 
    Ptr<SatOrbiterFeederPhy> GetOrbiterFeederPhy(Ptr<Node> orbiter, uint32_t utBeamId) const;
 
    Ptr<SatOrbiterUserPhy> GetOrbiterUserPhy(Ptr<Node> orbiter, uint32_t beamId) const;
 
    void EnableMapPrint(bool enableMapPrint)
    {
        m_enableMapPrint = enableMapPrint;
    }
 
    void PrintTopology(std::ostream& os) const;
 
    uint32_t GetClosestSat(GeoCoordinate position);
 
  private:
    SatEnums::Standard_t m_standard;                            // Standard used
    SatEnums::RegenerationMode_t m_forwardLinkRegenerationMode; // Regeneration mode on forward link
    SatEnums::RegenerationMode_t m_returnLinkRegenerationMode;  // Regeneration mode on return link
 
    std::map<uint32_t, Ptr<Node>> m_gwIds;                 // List of GW nodes
    NodeContainer m_gws;                                   // List of GW nodes
    NodeContainer m_uts;                                   // List of UT nodes
    NodeContainer m_orbiters;                              // List of orbiter nodes
    NodeContainer m_gwUsers;                               // List of GW user nodes
    NodeContainer m_utUsers;                               // List of UT user nodes
    std::map<Ptr<Node>, NodeContainer> m_detailledUtUsers; // Map associating UT to UT users
 
    std::map<Ptr<Node>, GwLayers_s> m_gwLayers; // Map giving protocol layers for all GWs
    std::map<Ptr<Node>, UtLayers_s> m_utLayers; // Map giving protocol layers for all UTs
    std::map<Ptr<Node>, OrbiterLayers_s>
        m_orbiterLayers; // Map giving protocol layers for all orbiters
 
    std::map<Ptr<Node>, Ptr<Node>> m_utToGwMap;  // Map of GW connected for each UT
    std::map<uint32_t, Ptr<Node>> m_beamToGwMap; // Map of GW connected for each satellite beam
    std::map<Ptr<SatOrbiterFeederMac>, Ptr<SatOrbiterFeederMac>>
        m_orbiterFeederMacMap; // Map giving which Feeder Mac is really used
 
    bool m_enableMapPrint; // Is map printing enabled or not
};
 
} // namespace ns3
 
#endif /* SATELLITE_TOPOLOGY_H */