nr-phy.h

// Copyright (c) 2019 Centre Tecnologic de Telecomunicacions de Catalunya (CTTC)
//
// SPDX-License-Identifier: GPL-2.0-only
 
#ifndef NR_PHY_H
#define NR_PHY_H
 
#include "nr-phy-mac-common.h"
#include "nr-phy-sap.h"
 
#include <ns3/nr-spectrum-value-helper.h>
 
namespace ns3
{
 
class NrNetDevice;
class NrControlMessage;
class NrSpectrumPhy;
class AntennaArrayBasicModel;
class UniformPlanarArray;
 
class NrPhy : public Object
{
  public:
    NrPhy();
 
    ~NrPhy() override;
 
    static TypeId GetTypeId();
 
    // Called by SAP
    void EnqueueCtrlMessage(const Ptr<NrControlMessage>& m);
 
    void SetMacPdu(const Ptr<Packet>& p, const SfnSf& sfn, uint8_t symStart, uint16_t rnti);
 
    virtual void SendRachPreamble(uint32_t PreambleId, uint32_t Rnti);
 
    void PushBackSlotAllocInfo(const SlotAllocInfo& slotAllocInfo);
 
    void NotifyConnectionSuccessful();
 
    virtual void SetTbDecodeLatency(const Time& us);
 
    virtual Time GetTbDecodeLatency() const;
 
    virtual BeamId GetBeamId(uint16_t rnti) const = 0;
 
    Ptr<const SpectrumModel> GetSpectrumModel();
 
    uint32_t GetSymbolsPerSlot() const;
 
    Time GetSlotPeriod() const;
 
    Time GetSymbolPeriod() const;
 
    void SetNoiseFigure(double d);
 
    double GetNoiseFigure() const;
 
    virtual double GetTxPower() const = 0;
 
    // Installation / Helpers
    NrPhySapProvider* GetPhySapProvider();
 
    void SetDevice(Ptr<NrNetDevice> d);
 
    void InstallCentralFrequency(double f);
 
    void SetNumerology(uint16_t numerology);
 
    uint16_t GetNumerology() const;
 
    void SetSymbolsPerSlot(uint16_t symbolsPerSlot);
 
    void SetRbOverhead(double oh);
 
    double GetRbOverhead() const;
 
    Ptr<NrSpectrumPhy> GetSpectrumPhy() const;
 
    void InstallSpectrumPhy(const Ptr<NrSpectrumPhy>& spectrumPhy);
 
    virtual void ScheduleStartEventLoop(uint32_t nodeId,
                                        uint16_t frame,
                                        uint8_t subframe,
                                        uint16_t slot) = 0;
 
    void SetBwpId(uint16_t bwpId);
 
    uint16_t GetBwpId() const;
 
    uint16_t GetCellId() const;
 
    uint32_t GetRbNum() const;
 
    uint32_t GetChannelBandwidth() const;
 
    uint32_t GetSubcarrierSpacing() const;
 
    uint32_t GetL1L2CtrlLatency() const;
 
    // SAP
    void DoSetCellId(uint16_t cellId);
 
    void EncodeCtrlMsg(const Ptr<NrControlMessage>& msg);
 
    bool HasDlSlot() const;
 
    bool HasUlSlot() const;
 
    static bool HasDlSlot(const std::vector<LteNrTddSlotType>& pattern);
 
    static bool HasUlSlot(const std::vector<LteNrTddSlotType>& pattern);
 
    double GetCentralFrequency() const;
 
    virtual const SfnSf& GetCurrentSfnSf() const = 0;
 
    static std::string GetPattern(const std::vector<LteNrTddSlotType>& pattern);
 
    void SetPowerAllocationType(
        enum NrSpectrumValueHelper::PowerAllocationType powerAllocationType);
 
    enum NrSpectrumValueHelper::PowerAllocationType GetPowerAllocationType() const;
 
  protected:
    void DoDispose() override;
    void DoInitialize() override;
    void DoUpdateRbNum();
 
    void SetChannelBandwidth(uint16_t bandwidth);
 
    static bool IsTdd(const std::vector<LteNrTddSlotType>& pattern);
 
    std::vector<int> FromRBGBitmaskToRBAssignment(const std::vector<bool> rbgBitmask) const;
 
    virtual uint32_t GetNumRbPerRbg() const = 0;
 
    Ptr<PacketBurst> GetPacketBurst(SfnSf sf, uint8_t sym, uint16_t rnti);
 
    Ptr<SpectrumValue> GetNoisePowerSpectralDensity();
 
    Ptr<SpectrumValue> GetTxPowerSpectralDensity(const std::vector<int>& rbIndexVector);
 
    void PushFrontSlotAllocInfo(const SfnSf& newSfnSf, const SlotAllocInfo& slotAllocInfo);
 
    bool SlotAllocInfoExists(const SfnSf& sfnsf) const;
 
    SlotAllocInfo RetrieveSlotAllocInfo();
 
    SlotAllocInfo RetrieveSlotAllocInfo(const SfnSf& sfnsf);
 
    SlotAllocInfo& PeekSlotAllocInfo(const SfnSf& sfnsf);
 
    size_t SlotAllocInfoSize() const;
 
    bool IsCtrlMsgListEmpty() const;
 
    void EnqueueCtrlMsgNow(const Ptr<NrControlMessage>& msg);
 
    void EnqueueCtrlMsgNow(const std::list<Ptr<NrControlMessage>>& listOfMsgs);
 
    void InitializeMessageList();
    virtual std::list<Ptr<NrControlMessage>> PopCurrentSlotCtrlMsgs();
 
  protected:
    Ptr<NrNetDevice> m_netDevice;     
    Ptr<NrSpectrumPhy> m_spectrumPhy; 
 
    double m_txPower{0.0};     
    double m_noiseFigure{0.0}; 
 
    std::unordered_map<uint64_t, Ptr<PacketBurst>>
        m_packetBurstMap; 
 
    SlotAllocInfo m_currSlotAllocInfo; 
 
    NrPhySapProvider* m_phySapProvider; 
 
    uint32_t m_raPreambleId{0};                  
    std::list<Ptr<NrControlMessage>> m_ctrlMsgs; 
 
    std::vector<LteNrTddSlotType> m_tddPattern = {F, F, F, F, F, F, F, F, F, F}; 
 
  private:
    std::list<SlotAllocInfo> m_slotAllocInfo; 
    std::vector<std::list<Ptr<NrControlMessage>>> m_controlMessageQueue; 
 
    Time m_tbDecodeLatencyUs{MicroSeconds(100)}; 
    double m_centralFrequency{-1.0};             
    uint16_t m_channelBandwidth{
        0}; 
            // E.g. if set to 200, the bandwidth will be 20 MHz (= 200 * 100 KHz)
 
    uint16_t m_cellId{0}; 
    uint16_t m_bwpId{
        UINT16_MAX}; 
    uint16_t m_numerology{
        0}; 
    uint16_t m_symbolsPerSlot{14}; 
 
    uint16_t m_slotsPerSubframe{0}; 
    Time m_slotPeriod{0};           
    Time m_symbolPeriod{0};         
    uint32_t m_subcarrierSpacing{0}; 
    uint32_t m_rbNum{0};             
    double m_rbOh{0.04};             
 
    enum NrSpectrumValueHelper::PowerAllocationType m_powerAllocationType{
        NrSpectrumValueHelper::UNIFORM_POWER_ALLOCATION_USED}; 
};
 
} // namespace ns3
 
#endif /* NR_PHY_H */