nr-initial-association.h

// Copyright (c) 2020 Centre Tecnologic de Telecomunicacions de Catalunya (CTTC)
//
// SPDX-License-Identifier: GPL-2.0-only
 
#ifndef NR_INITIAL_ASSOC_H
#define NR_INITIAL_ASSOC_H
#include "ns3/nr-module.h"
#include "ns3/object.h"
 
namespace ns3
{
const uint16_t NR_NUM_BANDS_FOR_SSB = 20;      
const double TRANSMIT_POWER_INIT_ASSOC = 30.0; 
 
struct NrAnglePair
{
    double rowAng = 90; 
    double colAng = 90; 
};
 
 
class NrInitialAssociation : public Object
{
  public:
    NrInitialAssociation() = default;
 
    struct ChannelParams
    {
        Ptr<ThreeGppChannelModel> channelModel{nullptr};
        Ptr<ThreeGppPropagationLossModel> pathLossModel{nullptr};
        Ptr<const SpectrumModel> spectralModel{nullptr};
        Ptr<ThreeGppSpectrumPropagationLossModel> spectrumPropModel{nullptr};
    };
 
    struct Mobilities
    {
        Ptr<MobilityModel> ueMobility{nullptr};
        Ptr<MobilityModel> gnbMobility{nullptr};
    };
 
    struct AntennaArrayModels
    {
        Ptr<UniformPlanarArray> gnbArrayModel{
            nullptr}; 
        std::vector<Ptr<UniformPlanarArray>>
            ueArrayModel; 
    };
 
    struct LocalSearchParams
    {
        ChannelParams chParams;
        Mobilities mobility;
        AntennaArrayModels antennaArrays;
        double maxPsdFound = 0.0;
    };
 
    bool CheckNumBeamsAllowed() const;
 
    static TypeId GetTypeId();
 
    void SetNumMainInterfererGnb(uint8_t numInterfere);
 
    uint8_t GetNumMainInterfererGnb() const;
 
    void SetHandoffMargin(double margin);
 
    double GetCarrierFrequency() const;
 
    double GetHandoffMargin() const;
 
    std::vector<double> GetRowBeamAngles() const;
 
    void SetRowBeamAngles(std::vector<double> rowVect);
 
    std::vector<double> GetColBeamAngles() const;
 
    void SetColBeamAngles(std::vector<double> colVect);
 
    void SetUeDevice(const Ptr<NetDevice>& ueDev);
 
    void SetGnbDevices(const NetDeviceContainer& gnbDevices);
 
    Ptr<const NetDevice> GetUeDevice() const;
 
    void InitializeIntfSet(uint16_t numIntfs, bool useRelRsrp, double relRsrpThreshold);
 
    std::vector<double> GetInterference(const std::vector<uint16_t>& idxVal) const;
 
    double GetTotalInterference(const std::vector<double>& cumSumIntf) const;
 
    size_t GetNumIntfGnbsByRelRsrp(const std::vector<double> cumSumIntf,
                                   const double relRsrpThreshold,
                                   const double totalInterference) const;
 
    std::pair<Ptr<NetDevice>, double> FindAssociatedGnb();
 
    Ptr<NetDevice> GetAssociatedGnb() const;
 
    NetDeviceContainer GetInterferingGnbs() const;
 
    double GetMaxRsrp(uint64_t gnbId) const;
 
    NrAnglePair GetBestBfv(uint64_t gnbId) const;
 
    double GetRelativeRsrpRatio() const;
 
    void SetStartSsbRb(uint16_t startSsb);
 
    void SetNumSsbRb(uint16_t numSsbRb);
 
    double GetAssociatedRsrp() const;
 
    void SetUeActivePanel(int8_t panelIndex) const;
 
    uint8_t GetUeActivePanel() const;
 
    void SetPrimaryCarrier(double index);
 
    double GetPrimaryCarrier() const;
 
  private:
    LocalSearchParams ExtractUeParameters() const;
 
    Ptr<UniformPlanarArray> ExtractGnbParameters(const Ptr<NetDevice>& gnbDevice,
                                                 LocalSearchParams& searchParam) const;
 
    double ComputeMaxRsrp(const Ptr<NetDevice>& gnbDevice, LocalSearchParams& lsps);
 
    double ComputeRxPsd(Ptr<const SpectrumSignalParameters> spectrumSigParam) const;
 
    PhasedArrayModel::ComplexVector GenBeamforming(double angRow,
                                                   double angCol,
                                                   Ptr<UniformPlanarArray> gnbArrayModel) const;
 
    double ComputeRsrpRatio(double totalRsrp, std::vector<uint16_t> idxVal);
 
    void PopulateRsrps(LocalSearchParams& lsps);
 
    /***
     * @brief Parse string with angles and set column angles
     * @param colAngles String with angles separated by vertical bar e.g. 0|10|20
     */
    void ParseColBeamAngles(std::string colAngles);
    /***
     * @brief Parse string with angles and set row angles
     * @param rowAngles String with angles separated by vertical bar e.g. 0|10|20
     */
    void ParseRowBeamAngles(std::string rowAngles);
 
    Ptr<const NetDevice> m_ueDevice{
        nullptr};                    
    NetDeviceContainer m_gnbDevices; 
    double m_freq;                   
    double m_handoffMargin{0.0};     
    size_t m_startSsb{0};            
    size_t m_numBandsSsb{NR_NUM_BANDS_FOR_SSB}; 
 
    uint8_t m_numMainInterfererGnb{6};            
    size_t m_numIntfGnbs{m_numMainInterfererGnb}; 
    double m_rsrpRatio{0.0};          
    NetDeviceContainer m_intfGnbDevs; 
    std::vector<double> m_maxRsrps;   
    double m_rsrpAsscGnb;
    Ptr<NetDevice> m_associatedGnb{nullptr}; 
 
    std::vector<NrAnglePair> m_bestBfVectors; 
    PhasedArrayModel::ComplexVector m_beamformingVector; 
    std::vector<double> m_rowBeamAngles; 
    std::vector<double> m_colBeamAngles; 
 
    double m_primaryCarrierIndex{0}; 
};
} // namespace ns3
#endif // NR_INITIAL_ASSOC_H