nr-gnb-phy.h

// Copyright (c) 2019 Centre Tecnologic de Telecomunicacions de Catalunya (CTTC)
//
// SPDX-License-Identifier: GPL-2.0-only
 
#ifndef NR_GNB_PHY_H
#define NR_GNB_PHY_H
 
#include "ideal-beamforming-algorithm.h"
#include "nr-control-messages.h"
#include "nr-fh-phy-sap.h"
#include "nr-gnb-cphy-sap.h"
#include "nr-harq-phy.h"
#include "nr-phy-sap.h"
#include "nr-phy.h"
 
#include <functional>
 
namespace ns3
{
 
class PacketBurst;
class NrNetDevice;
class NrUePhy;
class NrGnbMac;
class NrChAccessManager;
class BeamManager;
class NrFhPhySapUser;
class NrFhPhySapProvider;
 
class NrGnbPhy : public NrPhy
{
    friend class MemberNrGnbCphySapProvider<NrGnbPhy>;
    friend class NrMemberPhySapProvider;
    friend class NrHelper;
 
  public:
    enum CsiRsModel
    {
        CSI_RS_PER_UE,  
        CSI_RS_PER_BEAM 
    };
 
    static TypeId GetTypeId();
 
    NrGnbPhy();
 
    ~NrGnbPhy() override;
 
    void SetGnbCphySapUser(NrGnbCphySapUser* s);
    NrGnbCphySapProvider* GetGnbCphySapProvider();
 
    // FH Control SAPs
    void SetNrFhPhySapProvider(NrFhPhySapProvider* s);
    NrFhPhySapUser* GetNrFhPhySapUser();
 
    void SetN0Delay(uint32_t delay);
 
    void SetN1Delay(uint32_t delay);
 
    void SetN2Delay(uint32_t delay);
 
    uint32_t GetN0Delay() const;
 
    uint32_t GetN1Delay() const;
 
    uint32_t GetN2Delay() const;
 
    BeamId GetBeamId(uint16_t rnti) const override;
 
    void SetCam(const Ptr<NrChAccessManager>& s);
 
    Ptr<NrChAccessManager> GetCam() const;
 
    void SetTxPower(double pow);
 
    double GetTxPower() const override;
 
    void SetSubChannels(const std::vector<int>& rbIndexVector, size_t nTotalAllocRbs);
 
    bool RegisterUe(uint64_t imsi, const Ptr<NrUeNetDevice>& ueDevice);
 
    void AssignCsiRsOffset(const Ptr<NrUeNetDevice>& ueDevice);
 
    void PhyDataPacketReceived(const Ptr<Packet>& p);
 
    void GenerateDataCqiReport(const SpectrumValue& sinr);
 
    void PhyCtrlMessagesReceived(const Ptr<NrControlMessage>& msg);
 
    int8_t DoGetReferenceSignalPower() const;
 
    void SetPhySapUser(NrGnbPhySapUser* ptr);
 
    void ReportUlHarqFeedback(const UlHarqInfo& mes);
 
    void SetPattern(const std::string& pattern);
 
    std::string GetPattern() const;
 
    void SetCsiRsModel(enum CsiRsModel csiRsModel);
 
    enum CsiRsModel GetCsiRsModel() const;
 
    void SetCsiRsPeriodicity(uint16_t csiRsPeriodicity);
 
    uint16_t GetCsiRsPeriodicity() const;
 
    void SetPrimary();
 
    void ScheduleStartEventLoop(uint32_t nodeId,
                                uint16_t frame,
                                uint8_t subframe,
                                uint16_t slot) override;
 
    typedef void (*RxedGnbPhyCtrlMsgsTracedCallback)(const SfnSf sfn,
                                                     const uint16_t nodeId,
                                                     const uint16_t rnti,
                                                     const uint8_t bwpId,
                                                     Ptr<NrControlMessage>);
 
    typedef void (*TxedGnbPhyCtrlMsgsTracedCallback)(const SfnSf sfn,
                                                     const uint16_t nodeId,
                                                     const uint16_t rnti,
                                                     const uint8_t bwpId,
                                                     Ptr<NrControlMessage>);
 
    typedef void (*SlotStatsTracedCallback)(const SfnSf& sfnSf,
                                            uint32_t scheduledUe,
                                            uint32_t usedReg,
                                            uint32_t usedSym,
                                            uint32_t availableRb,
                                            uint32_t availableSym,
                                            uint16_t bwpId,
                                            uint16_t cellId);
 
    typedef void (*RBStatsTracedCallback)(const SfnSf& sfnSf,
                                          uint8_t sym,
                                          const std::vector<int>& rbMap,
                                          uint16_t bwpId,
                                          uint16_t cellId);
 
    uint32_t GetNumRbPerRbg() const override;
 
    const SfnSf& GetCurrentSfnSf() const override;
 
    void ChangeBeamformingVector(Ptr<NrNetDevice> dev);
    void ChangeToQuasiOmniBeamformingVector();
 
  protected:
    void DoDispose() override;
 
    bool DoesFhAllocationFit(uint16_t bwpId, uint32_t mcs, uint32_t nRegs, uint8_t dlRank) const;
 
    // FFR SAPs
    NrFhPhySapUser* m_nrFhPhySapUser{nullptr};         
    NrFhPhySapProvider* m_nrFhPhySapProvider{nullptr}; 
 
  private:
    void EnableCsiRs();
    void SetTddPattern(const std::vector<LteNrTddSlotType>& pattern);
 
    void StartSlot(const SfnSf& startSlot);
 
    void EndSlot();
 
    void StartVarTti(const std::shared_ptr<DciInfoElementTdma>& dci);
 
    void EndVarTti(const std::shared_ptr<DciInfoElementTdma>& lastDci);
 
    void SendDataChannels(const Ptr<PacketBurst>& pb,
                          const Time& varTtiPeriod,
                          const std::shared_ptr<DciInfoElementTdma>& dci);
 
    void SendCtrlChannels(const Time& varTtiPeriod);
 
    std::list<Ptr<NrControlMessage>> RetrieveMsgsFromDCIs(const SfnSf& sfn)
        __attribute__((warn_unused_result));
 
    void ChannelAccessGranted(const Time& time);
 
    void ChannelAccessLost();
 
    bool TimeToTransmitCsiRs(uint16_t currentOffset) const;
 
    void TransmitCsiRsPerUe(Ptr<NrUeNetDevice> ueDev);
 
    Time ScheduleCsiRs(Time varTti, uint16_t currentOffset);
 
    Time DlCtrl(const std::shared_ptr<DciInfoElementTdma>& dci) __attribute__((warn_unused_result));
    Time UlCtrl(const std::shared_ptr<DciInfoElementTdma>& dci) __attribute__((warn_unused_result));
 
    Time DlData(const std::shared_ptr<DciInfoElementTdma>& dci) __attribute__((warn_unused_result));
 
    Time UlData(const std::shared_ptr<DciInfoElementTdma>& dci) __attribute__((warn_unused_result));
 
    Time UlSrs(const std::shared_ptr<DciInfoElementTdma>& dci) __attribute__((warn_unused_result));
 
    void QueueMib();
    void QueueSib();
 
    void DoStartSlot();
 
    void GenerateAllocationStatistics(const SlotAllocInfo& allocInfo) const;
 
    // NrGnbCphySapProvider forwarded methods
    void DoSetBandwidth(uint16_t ulBandwidth, uint16_t dlBandwidth);
    void DoSetEarfcn(uint16_t dlEarfcn, uint16_t ulEarfcn);
    void DoAddUe(uint16_t rnti);
    void DoRemoveUe(uint16_t rnti);
    void DoSetPa(uint16_t rnti, double pa);
    void DoSetTransmissionMode(uint16_t rnti, uint8_t txMode);
    void DoSetSrsConfigurationIndex(uint16_t rnti, uint16_t srcCi);
    void DoSetMasterInformationBlock(NrRrcSap::MasterInformationBlock mib);
    void DoSetSystemInformationBlockType1(NrRrcSap::SystemInformationBlockType1 sib1);
    void DoSetEarfcn(uint16_t Earfcn);
 
    void StoreRBGAllocation(std::unordered_map<uint8_t, std::vector<bool>>* map,
                            const std::shared_ptr<DciInfoElementTdma>& dci) const;
 
    static void GenerateStructuresFromPattern(const std::vector<LteNrTddSlotType>& pattern,
                                              std::map<uint32_t, std::vector<uint32_t>>* toSendDl,
                                              std::map<uint32_t, std::vector<uint32_t>>* toSendUl,
                                              std::map<uint32_t, std::vector<uint32_t>>* generateDl,
                                              std::map<uint32_t, std::vector<uint32_t>>* generateUl,
                                              std::map<uint32_t, uint32_t>* dlHarqfbPosition,
                                              uint32_t n0,
                                              uint32_t n2,
                                              uint32_t n1,
                                              uint32_t l1l2CtrlLatency);
 
    void CallMacForSlotIndication(const SfnSf& currentSlot);
 
    std::list<Ptr<NrControlMessage>> RetrieveDciFromAllocation(
        const SlotAllocInfo& alloc,
        const DciInfoElementTdma::DciFormat& format,
        uint32_t kDelay,
        uint32_t k1Delay);
 
    void PushDlAllocation(const SfnSf& sfnSf) const;
 
    void PushUlAllocation(const SfnSf& sfnSf) const;
 
    void StartEventLoop(uint16_t frame, uint8_t subframe, uint16_t slot);
 
    void DoCheckOrReleaseChannel();
 
    void RetrievePrepareEncodeCtrlMsgs();
 
    void PrepareRbgAllocationMap(const std::deque<VarTtiAllocInfo>& allocations);
 
    void FillTheEvent();
 
  private:
    NrGnbPhySapUser* m_phySapUser{nullptr}; 
    NrGnbCphySapProvider* m_gnbCphySapProvider{
        nullptr}; 
    NrGnbCphySapUser* m_gnbCphySapUser{
        nullptr}; 
 
    std::set<uint64_t> m_ueAttached;             
    std::set<uint16_t> m_ueAttachedRnti;         
    std::vector<Ptr<NrUeNetDevice>> m_deviceMap; 
 
    NrRrcSap::SystemInformationBlockType1 m_sib1; 
    Time m_lastSlotStart;                         
    uint8_t m_currSymStart{0}; 
    std::unordered_map<uint8_t, std::vector<bool>>
        m_rbgAllocationPerSym; 
    std::unordered_map<uint8_t, std::vector<bool>>
        m_rbgAllocationPerSymDataStat; 
 
    TracedCallback<uint64_t, SpectrumValue&, SpectrumValue&> m_ulSinrTrace; 
 
    TracedCallback<SfnSf, uint16_t, uint16_t, uint8_t, Ptr<const NrControlMessage>>
        m_phyRxedCtrlMsgsTrace;
 
    TracedCallback<SfnSf, uint16_t, uint16_t, uint8_t, Ptr<const NrControlMessage>>
        m_phyTxedCtrlMsgsTrace;
 
    TracedCallback<const SfnSf&,
                   uint32_t,
                   uint32_t,
                   uint32_t,
                   uint32_t,
                   uint32_t,
                   uint16_t,
                   uint16_t>
        m_phySlotCtrlStats;
    TracedCallback<const SfnSf&,
                   uint32_t,
                   uint32_t,
                   uint32_t,
                   uint32_t,
                   uint32_t,
                   uint16_t,
                   uint16_t>
        m_phySlotDataStats;
 
    TracedCallback<const SfnSf&, uint8_t, const std::vector<int>&, uint16_t, uint16_t>
        m_rbStatistics;
 
    std::map<uint32_t, std::vector<uint32_t>>
        m_toSendDl; 
    std::map<uint32_t, std::vector<uint32_t>>
        m_toSendUl; 
    std::map<uint32_t, std::vector<uint32_t>>
        m_generateUl; 
    std::map<uint32_t, std::vector<uint32_t>>
        m_generateDl; 
 
    std::map<uint32_t, uint32_t> m_dlHarqfbPosition; 
 
    enum ChannelStatus
    {
        NONE,      
        REQUESTED, 
        GRANTED,   
        TO_LOSE    
    };
 
    ChannelStatus m_channelStatus{NONE}; 
    EventId m_channelLostTimer; 
 
    Ptr<NrChAccessManager> m_cam; 
 
    friend class NrPatternTestCase;
 
    uint32_t m_n0Delay{0}; 
    uint32_t m_n1Delay{
        0}; 
    uint32_t m_n2Delay{0}; 
 
    SfnSf m_currentSlot;     
    bool m_isPrimary{false}; 
 
    bool m_enableCsiRs{false}; 
    CsiRsModel m_csiRsModel{CsiRsModel::CSI_RS_PER_UE}; 
    uint16_t m_csiRsPeriodicity{10};                    
    std::map<uint16_t, std::set<Ptr<NrUeNetDevice>>> m_csiRsOffsetToUes; 
 
    Time m_lastBfChange; 
};
 
} // namespace ns3
 
#endif /* NR_GNB_PHY_H */