nr-helper.h

// Copyright (c) 2019 Centre Tecnologic de Telecomunicacions de Catalunya (CTTC)
//
// SPDX-License-Identifier: GPL-2.0-only
 
#ifndef NR_HELPER_H
#define NR_HELPER_H
 
#include "cc-bwp-helper.h"
#include "ideal-beamforming-helper.h"
#include "nr-bearer-stats-connector.h"
#include "nr-mac-scheduling-stats.h"
 
#include "ns3/net-device-container.h"
#include "ns3/node-container.h"
#include "ns3/nr-component-carrier.h"
#include "ns3/nr-control-messages.h"
#include "ns3/nr-eps-bearer.h"
#include "ns3/nr-spectrum-phy.h"
#include "ns3/object-factory.h"
 
namespace ns3
{
 
class NrUePhy;
class NrGnbPhy;
class SpectrumChannel;
class NrSpectrumValueHelper;
class NrGnbMac;
class NrEpcHelper;
class NrEpcTft;
class NrBearerStatsCalculator;
class NrMacRxTrace;
class NrPhyRxTrace;
class NrMacScheduler;
class NrGnbNetDevice;
class NrUeNetDevice;
class NrUeMac;
class BwpManagerGnb;
class BwpManagerUe;
class NrFhControl;
 
class NrHelper : public Object
{
  public:
    NrHelper();
    ~NrHelper() override;
 
    static TypeId GetTypeId();
 
    NetDeviceContainer InstallUeDevice(
        const NodeContainer& c,
        const std::vector<std::reference_wrapper<BandwidthPartInfoPtr>>& allBwps);
    NetDeviceContainer InstallGnbDevice(
        const NodeContainer& c,
        const std::vector<std::reference_wrapper<BandwidthPartInfoPtr>> allBwps);
 
    static uint32_t GetNumberBwp(const Ptr<const NetDevice>& gnbDevice);
    static Ptr<NrGnbPhy> GetGnbPhy(const Ptr<NetDevice>& gnbDevice, uint32_t bwpIndex);
    static Ptr<NrGnbMac> GetGnbMac(const Ptr<NetDevice>& gnbDevice, uint32_t bwpIndex);
    static Ptr<NrUeMac> GetUeMac(const Ptr<NetDevice>& ueDevice, uint32_t bwpIndex);
    static Ptr<NrUePhy> GetUePhy(const Ptr<NetDevice>& ueDevice, uint32_t bwpIndex);
    static Ptr<BwpManagerGnb> GetBwpManagerGnb(const Ptr<NetDevice>& gnbDevice);
    static Ptr<BwpManagerUe> GetBwpManagerUe(const Ptr<NetDevice>& ueDevice);
    static Ptr<NrMacScheduler> GetScheduler(const Ptr<NetDevice>& gnbDevice, uint32_t bwpIndex);
 
    void AttachToMaxRsrpGnb(const NetDeviceContainer& ueDevices,
                            const NetDeviceContainer& gnbDevices);
    void AttachToClosestGnb(const NetDeviceContainer& ueDevices,
                            const NetDeviceContainer& gnbDevices);
    void AttachToGnb(const Ptr<NetDevice>& ueDevice, const Ptr<NetDevice>& gnbDevice);
 
    void EnableTraces();
 
    void ActivateDataRadioBearer(NetDeviceContainer ueDevices, NrEpsBearer bearer);
    void ActivateDataRadioBearer(Ptr<NetDevice> ueDevice, NrEpsBearer bearer);
    void SetEpcHelper(Ptr<NrEpcHelper> NrEpcHelper);
 
    void SetBeamformingHelper(Ptr<BeamformingHelperBase> beamformingHelper);
 
    void SetSnrTest(bool snrTest);
    bool GetSnrTest() const;
 
    uint8_t ActivateDedicatedEpsBearer(NetDeviceContainer ueDevices,
                                       NrEpsBearer bearer,
                                       Ptr<NrEpcTft> tft);
 
    uint8_t ActivateDedicatedEpsBearer(Ptr<NetDevice> ueDevice,
                                       NrEpsBearer bearer,
                                       Ptr<NrEpcTft> tft);
 
    void DeActivateDedicatedEpsBearer(Ptr<NetDevice> ueDevice,
                                      Ptr<NetDevice> gnbDevice,
                                      uint8_t bearerId);
 
    void SetUeMacAttribute(const std::string& n, const AttributeValue& v);
 
    void SetGnbMacAttribute(const std::string& n, const AttributeValue& v);
 
    void SetUeAntennaTypeId(const std::string&);
 
    void SetGnbAntennaTypeId(const std::string&);
 
    void SetGnbSpectrumAttribute(const std::string& n, const AttributeValue& v);
 
    void SetUeSpectrumAttribute(const std::string& n, const AttributeValue& v);
 
    void SetUeChannelAccessManagerAttribute(const std::string& n, const AttributeValue& v);
 
    void SetGnbChannelAccessManagerAttribute(const std::string& n, const AttributeValue& v);
 
    void SetSchedulerAttribute(const std::string& n, const AttributeValue& v);
 
    void SetUePhyAttribute(const std::string& n, const AttributeValue& v);
 
    void SetGnbPhyAttribute(const std::string& n, const AttributeValue& v);
 
    void SetUeAntennaAttribute(const std::string& n, const AttributeValue& v);
 
    void SetGnbAntennaAttribute(const std::string& n, const AttributeValue& v);
 
    void SetUeChannelAccessManagerTypeId(const TypeId& typeId);
 
    void SetGnbChannelAccessManagerTypeId(const TypeId& typeId);
 
    void SetSchedulerTypeId(const TypeId& typeId);
 
    void SetGnbBwpManagerAlgorithmTypeId(const TypeId& typeId);
 
    void SetGnbBwpManagerAlgorithmAttribute(const std::string& n, const AttributeValue& v);
 
    void SetUeBwpManagerAlgorithmTypeId(const TypeId& typeId);
 
    void SetUeBwpManagerAlgorithmAttribute(const std::string& n, const AttributeValue& v);
 
    void SetGnbDlAmcAttribute(const std::string& n, const AttributeValue& v);
 
    void SetGnbUlAmcAttribute(const std::string& n, const AttributeValue& v);
 
    /*
     * @brief Sets beam managers attribute.
     * @param n the name of the attribute
     * @param v the value of the attribute
     */
    void SetGnbBeamManagerAttribute(const std::string& n, const AttributeValue& v);
 
    void SetGnbBeamManagerTypeId(const TypeId& typeId);
 
    void SetUlErrorModel(const std::string& errorModelTypeId);
 
    void SetDlErrorModel(const std::string& errorModelTypeId);
 
    void EnableFhControl();
 
    void ConfigureFhControl(NetDeviceContainer gnbNetDevices);
 
    /*
     * @brief Sets the FH Control attributes.
     * @param n the name of the attribute
     * @param v the value of the attribute
     */
    void SetFhControlAttribute(const std::string& n, const AttributeValue& v);
 
    void EnableDlDataPhyTraces();
 
    void EnableDlCtrlPhyTraces();
 
    void EnableUlPhyTraces();
 
    Ptr<NrPhyRxTrace> GetPhyRxTrace();
 
    Ptr<NrMacRxTrace> GetMacRxTrace();
 
    void EnableGnbPacketCountTrace();
 
    void EnableUePacketCountTrace();
 
    void EnableTransportBlockTrace();
 
    void EnableGnbPhyCtrlMsgsTraces();
 
    void EnableUePhyCtrlMsgsTraces();
 
    void EnableGnbMacCtrlMsgsTraces();
 
    void EnableUeMacCtrlMsgsTraces();
 
    Ptr<NrBearerStatsCalculator> GetRlcStatsCalculator();
 
    void EnableRlcSimpleTraces();
 
    void EnablePdcpSimpleTraces();
 
    void EnableRlcE2eTraces();
 
    void EnablePdcpE2eTraces();
 
    Ptr<NrBearerStatsCalculator> GetPdcpStatsCalculator();
 
    void EnableDlMacSchedTraces();
 
    void EnableUlMacSchedTraces();
 
    void EnablePathlossTraces();
 
    /*
     * @brief Enable DL CTRL pathloss trace from a serving cell (this trace connects
     * to NrSpectrumPhy trace, which is implementation wise different from
     * EnablePathlossTrace function which is implemented in by using
     * MultiModelSpectrumChannel trace and which
     * generates pathloss traces for both DL and UL
     */
    void EnableDlCtrlPathlossTraces(NetDeviceContainer& netDeviceContainer);
 
    /*
     * @brief Enable DL CTRL pathloss trace from a serving cell (this trace connects
     * to NrSpectrumPhy trace, which is implementation wise different from
     * EnablePathlossTrace function which is implemented in by using
     * MultiModelSpectrumChannel trace and which generates pathloss traces for
     * both DL and UL)
     */
    void EnableDlDataPathlossTraces(NetDeviceContainer& netDeviceContainer);
 
    int64_t AssignStreams(NetDeviceContainer c, int64_t stream);
 
    struct AntennaParams
    {
        std::string antennaElem{"ns3::IsotropicAntennaModel"}; 
        size_t nAntCols{1};          
        size_t nAntRows{1};          
        bool isDualPolarized{false}; 
        size_t nHorizPorts{1};       
        size_t nVertPorts{1};        
        double bearingAngle{0.0};    
        double polSlantAngle{0.0};   
        double downtiltAngle{0.0};   
    };
 
    struct MimoPmiParams
    {
        std::string pmSearchMethod{"ns3::NrPmSearchFull"}; 
        std::string fullSearchCb{"ns3::NrCbTwoPort"}; 
        uint8_t rankLimit{UINT8_MAX}; 
        double rankThreshold{0.0};
        std::string rankTechnique{"Sasaoka"};
        uint8_t subbandSize{1}; 
        std::string downsamplingTechnique{"FirstPRB"}; 
    };
 
    struct InitialAssocParams
    {
        std::vector<double> rowAngles{0, 90}; 
        std::vector<double> colAngles{0, 90}; 
        double handoffMargin{0};              
        double primaryCarrierIndex{0};        
    };
 
    void SetPmSearchTypeId(const TypeId& typeId);
 
    void SetPmSearchAttribute(const std::string& name, const AttributeValue& value);
 
    void SetInitialAssocTypeId(const TypeId& typeId);
 
    void SetInitialAssocAttribute(const std::string& name, const AttributeValue& value);
 
    void SetupGnbAntennas(const AntennaParams& ap);
 
    void SetupUeAntennas(const AntennaParams& ap);
 
    void SetupMimoPmi(const MimoPmiParams& mp);
 
    void SetupInitialAssoc(const InitialAssocParams& params);
 
    std::pair<double, BandwidthPartInfoPtrVector> CreateBandwidthParts(
        std::vector<CcBwpCreator::SimpleOperationBandConf> bandConfs,
        const std::string& scenario = "RMa",
        const std::string& channelCondition = "Default",
        const std::string& channelModel = "ThreeGpp");
 
    NS_DEPRECATED("Obsolete method")
    void UpdateDeviceConfigs(const NetDeviceContainer& netDevs);
 
    // Handover related functions
    void AddX2Interface(NodeContainer gnbNodes);
    void AddX2Interface(Ptr<Node> gnbNode1, Ptr<Node> gnbNode2);
 
    std::string GetHandoverAlgorithmType() const;
    void SetHandoverAlgorithmType(std::string type);
    void SetHandoverAlgorithmAttribute(std::string n, const AttributeValue& v);
    void HandoverRequest(Time hoTime,
                         Ptr<NetDevice> ueDev,
                         Ptr<NetDevice> sourceGnbDev,
                         Ptr<NetDevice> targetGnbDev);
    void HandoverRequest(Time hoTime,
                         Ptr<NetDevice> ueDev,
                         Ptr<NetDevice> sourceGnbDev,
                         uint16_t targetCellId);
 
  private:
    bool m_enableMimoFeedback{false}; 
    ObjectFactory m_pmSearchFactory;  
    uint8_t m_csiFeedbackFlags{
        CQI_CSI_IM | CQI_CSI_RS |
        CQI_PDSCH_MIMO}; 
 
    int64_t DoAssignStreamsToChannelObjects(Ptr<NrSpectrumPhy> phy, int64_t currentStream);
 
    void DoDeActivateDedicatedEpsBearer(Ptr<NetDevice> ueDevice,
                                        Ptr<NetDevice> gnbDevice,
                                        uint8_t bearerId);
 
    Ptr<NrGnbPhy> CreateGnbPhy(const Ptr<Node>& n,
                               const BandwidthPartInfoPtr& bwp,
                               const Ptr<NrGnbNetDevice>& dev,
                               const NrSpectrumPhy::NrPhyRxCtrlEndOkCallback& phyEndCtrlCallback);
    Ptr<NrMacScheduler> CreateGnbSched();
    Ptr<NrGnbMac> CreateGnbMac();
    Ptr<NrFhControl> CreateNrFhControl();
 
    Ptr<NrUeMac> CreateUeMac() const;
    Ptr<NrUePhy> CreateUePhy(const Ptr<Node>& n,
                             const BandwidthPartInfoPtr& bwp,
                             const Ptr<NrUeNetDevice>& dev,
                             const NrSpectrumPhy::NrPhyDlHarqFeedbackCallback& dlHarqCallback,
                             const NrSpectrumPhy::NrPhyRxCtrlEndOkCallback& phyRxCtrlCallback);
 
    Ptr<NetDevice> InstallSingleUeDevice(
        const Ptr<Node>& n,
        const std::vector<std::reference_wrapper<BandwidthPartInfoPtr>> allBwps);
    Ptr<NetDevice> InstallSingleGnbDevice(
        const Ptr<Node>& n,
        const std::vector<std::reference_wrapper<BandwidthPartInfoPtr>> allBwps);
 
    void DoHandoverRequest(Ptr<NetDevice> ueDev,
                           Ptr<NetDevice> sourceGnbDev,
                           uint16_t targetCellId);
    void AttachToClosestGnb(const Ptr<NetDevice>& ueDevice, const NetDeviceContainer& gnbDevices);
 
    void AttachToMaxRsrpGnb(const Ptr<NetDevice>& ueDevice, const NetDeviceContainer& gnbDevices);
 
    ObjectFactory m_gnbNetDeviceFactory;            
    ObjectFactory m_ueNetDeviceFactory;             
    ObjectFactory m_channelFactory;                 
    ObjectFactory m_ueMacFactory;                   
    ObjectFactory m_gnbMacFactory;                  
    ObjectFactory m_ueSpectrumFactory;              
    ObjectFactory m_gnbSpectrumFactory;             
    ObjectFactory m_uePhyFactory;                   
    ObjectFactory m_gnbPhyFactory;                  
    ObjectFactory m_ueChannelAccessManagerFactory;  
    ObjectFactory m_gnbChannelAccessManagerFactory; 
    ObjectFactory m_schedFactory;                   
    ObjectFactory m_ueAntennaFactory;               
    ObjectFactory m_gnbAntennaFactory;              
    ObjectFactory m_gnbBwpManagerAlgoFactory;       
    ObjectFactory m_ueBwpManagerAlgoFactory;        
    ObjectFactory m_channelConditionModelFactory;   
    ObjectFactory m_spectrumPropagationFactory;     
    ObjectFactory m_pathlossModelFactory;           
    ObjectFactory m_gnbDlAmcFactory;                
    ObjectFactory m_gnbUlAmcFactory;                
    ObjectFactory m_gnbBeamManagerFactory;          
    ObjectFactory m_ueBeamManagerFactory;           
    ObjectFactory m_handoverAlgorithmFactory;       
    ObjectFactory m_fhControlFactory;
    ObjectFactory m_initialAttachmentFactory; 
 
    uint16_t m_cellIdCounter{1}; 
 
    Ptr<NrEpcHelper> m_nrEpcHelper{nullptr};                 
    Ptr<BeamformingHelperBase> m_beamformingHelper{nullptr}; 
 
    bool m_snrTest{false};
    bool m_fhEnabled{false};
 
    Ptr<NrPhyRxTrace> m_phyStats; 
    Ptr<NrMacRxTrace> m_macStats; 
 
    NrBearerStatsConnector
        m_radioBearerStatsConnectorSimpleTraces; 
    NrBearerStatsConnector
        m_radioBearerStatsConnectorCalculator; 
 
    std::map<uint8_t, NrComponentCarrier> m_componentCarrierPhyParams; 
    std::vector<Ptr<Object>>
        m_channelObjectsWithAssignedStreams; 
    Ptr<NrMacSchedulingStats> m_macSchedStats; 
    bool m_useIdealRrc;
    std::vector<OperationBandInfo> m_bands;
 
    InitialAssocParams
        m_initialParams; 
};
 
} // namespace ns3
 
#endif /* NR_HELPER_H */