cc-bwp-helper.h

// Copyright (c) 2020 Centre Tecnologic de Telecomunicacions de Catalunya (CTTC)
//
// SPDX-License-Identifier: GPL-2.0-only
 
#ifndef CC_BWP_HELPER_H
#define CC_BWP_HELPER_H
 
#include <ns3/propagation-loss-model.h>
#include <ns3/ptr.h>
#include <ns3/spectrum-channel.h>
#include <ns3/spectrum-propagation-loss-model.h>
 
#include <memory>
#include <vector>
 
namespace ns3
{
 
/*
 * Upper limits of the number of component carriers used for Carrier
 * Aggregation (CA). In NR, this number depends on the CC contiguousness.
 * Eventually, the number of CCs may also depend on the operation frequency
 */
static const uint8_t MAX_CC_INTRA_BAND =
    8; 
static const uint8_t MAX_CC_INTER_BAND =
    16; 
 
struct BandwidthPartInfo
{
    uint8_t m_bwpId{0};             
    double m_centralFrequency{0.0}; 
    double m_lowerFrequency{0.0};   
    double m_higherFrequency{0.0};  
    double m_channelBandwidth{0.0}; 
 
    BandwidthPartInfo() = default;
 
    void SetChannel(Ptr<SpectrumChannel> channel);
 
    Ptr<SpectrumChannel> GetChannel() const;
 
  private:
    Ptr<SpectrumChannel>
        m_channel; 
};
 
typedef std::unique_ptr<BandwidthPartInfo> BandwidthPartInfoPtr;
typedef std::unique_ptr<const BandwidthPartInfo> BandwidthPartInfoConstPtr;
typedef std::vector<std::reference_wrapper<BandwidthPartInfoPtr>> BandwidthPartInfoPtrVector;
 
std::ostream& operator<<(std::ostream& os, const BandwidthPartInfo& item);
 
struct ComponentCarrierInfo
{
    uint8_t m_ccId{0};            
    double m_centralFrequency{0}; 
    double m_lowerFrequency{0};   
    double m_higherFrequency{0};  
    double m_channelBandwidth{0}; 
 
    std::vector<BandwidthPartInfoPtr> m_bwp; 
 
    bool AddBwp(BandwidthPartInfoPtr&& bwp);
};
 
typedef std::unique_ptr<ComponentCarrierInfo> ComponentCarrierInfoPtr;
 
std::ostream& operator<<(std::ostream& os, const ComponentCarrierInfo& item);
 
struct OperationBandInfo
{
    uint8_t m_bandId{0};            
    double m_centralFrequency{0.0}; 
    double m_lowerFrequency{0.0};   
    double m_higherFrequency{0.0};  
    double m_channelBandwidth{0};   
 
    std::vector<ComponentCarrierInfoPtr> m_cc; 
 
    bool AddCc(ComponentCarrierInfoPtr&& cc);
 
    BandwidthPartInfoPtr& GetBwpAt(uint32_t ccId, uint32_t bwpId) const;
 
    BandwidthPartInfoPtrVector GetBwps() const;
};
 
std::ostream& operator<<(std::ostream& os, const OperationBandInfo& item);
 
class CcBwpCreator
{
  public:
    struct SimpleOperationBandConf
    {
        SimpleOperationBandConf(double centralFreq = 28e9,
                                double channelBw = 400e6,
                                uint8_t numCc = 1)
            : m_centralFrequency(centralFreq),
              m_channelBandwidth(channelBw),
              m_numCc(numCc)
        {
        }
 
        double m_centralFrequency{28e9};  
        double m_channelBandwidth{400e6}; 
        uint8_t m_numCc{1};               
        uint8_t m_numBwp{1};              
    };
 
    OperationBandInfo CreateOperationBandContiguousCc(const SimpleOperationBandConf& conf);
 
    OperationBandInfo CreateOperationBandNonContiguousCc(
        const std::vector<SimpleOperationBandConf>& configuration);
 
    static BandwidthPartInfoPtrVector GetAllBwps(
        const std::vector<std::reference_wrapper<OperationBandInfo>>& operationBands);
 
    static void PlotNrCaBwpConfiguration(const std::vector<OperationBandInfo*>& bands,
                                         const std::string& filename);
 
    static void PlotLteCaConfiguration(const std::vector<OperationBandInfo*>& bands,
                                       const std::string& filename);
 
  private:
    void InitializeCc(std::unique_ptr<ComponentCarrierInfo>& cc,
                      double ccBandwidth,
                      double lowerFreq,
                      uint8_t ccPosition,
                      uint8_t ccId) const;
    void InitializeBwp(BandwidthPartInfoPtr& bwp,
                       double bwOfBwp,
                       double lowerFreq,
                       uint8_t bwpPosition,
                       uint8_t bwpId) const;
    std::unique_ptr<ComponentCarrierInfo> CreateCc(double ccBandwidth,
                                                   double lowerFreq,
                                                   uint8_t ccPosition,
                                                   uint8_t ccId,
                                                   uint8_t bwpNumber);
    static void PlotFrequencyBand(std::ofstream& outFile,
                                  uint16_t index,
                                  double xmin,
                                  double xmax,
                                  double ymin,
                                  double ymax,
                                  const std::string& label);
 
    uint8_t m_operationBandCounter{0};
    uint8_t m_componentCarrierCounter{0};
    uint8_t m_bandwidthPartCounter{0};
};
 
} // namespace ns3
 
#endif /* CC_BWP_HELPER_H */