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 */