ChannelModelBase.h Source File¶

Simu5G: ChannelModelBase.h Source File
Simu5G
//
//                  Simu5G
//
// Copyright (C) 2012-2021 Giovanni Nardini, Giovanni Stea, Antonio Virdis et al. (University of Pisa)
// Copyright (C) 2022-2026 Giovanni Nardini, Giovanni Stea et al. (University of Pisa)
//
// This file is part of a software released under the license included in file
// "license.pdf". Please read LICENSE and README files before using it.
// The above files and the present reference are part of the software itself,
// and cannot be removed from it.
//
 
#ifndef STACK_PHY_CHANNELMODEL_CHANNELMODELBASE_H_
#define STACK_PHY_CHANNELMODEL_CHANNELMODELBASE_H_
 
#include <inet/common/ModuleRefByPar.h>
 
#include "simu5g/common/LteCommon.h"
#include "simu5g/common/LteControlInfo.h"
#include "simu5g/common/carrierAggregation/ComponentCarrier.h"
#include "simu5g/stack/phy/PhyBase.h"
#include "simu5g/stack/phy/packet/LteAirFrame.h"
namespace simu5g {
 
using namespace inet;
using namespace omnetpp;
 
class LteAirFrame;
class PhyBase;
class Binder;
struct LinkKey
{
    MacNodeId a = NODEID_NONE;
    MacNodeId b = NODEID_NONE;
 
    LinkKey() = default;
    explicit LinkKey(MacNodeId node) : a(node), b(node) {}
    LinkKey(MacNodeId x, MacNodeId y)
        : a(num(x) <= num(y) ? x : y), b(num(x) <= num(y) ? y : x) {}
 
    bool operator<(const LinkKey& o) const
    {
        return num(a) != num(o.a) ? num(a) < num(o.a) : num(b) < num(o.b);
    }
    bool operator==(const LinkKey& o) const { return a == o.a && b == o.b; }
};
 
inline std::ostream& operator<<(std::ostream& os, const LinkKey& k)
{
    return num(k.a) == num(k.b) ? (os << k.a) : (os << "[" << k.a << "," << k.b << "]");
}
struct RadioLink
{
    // ---- geometry ----
    MacNodeId txId = NODEID_NONE;
    MacNodeId rxId = NODEID_NONE;
    inet::Coord txCoord;
    inet::Coord rxCoord;
 
    // ---- channel state ----
    // stateKey indexes the *per-link* state: losMap_, lastComputedSF_,
    // jakesFadingMap_ and lastCorrelationPoint_.
    LinkKey stateKey;
 
    // stateNodeId is the *node* the state belongs to -- the UE. It selects which
    // module owns the maps (with useUeSideMaps they are fetched from that UE's own
    // channel model via obtainShadowingMap() / obtainUeJakesMap(), otherwise they
    // are this module's), it indexes positionHistory_, which is genuinely a node
    // property because it defines the node's speed, and it distinguishes
    // background UEs.
    MacNodeId stateNodeId = NODEID_NONE;
 
    inet::Coord stateCoord;      // position feeding computeSpeed + correlation distance
    bool useUeSideMaps = false;  // the former 'cqiDl' flag
 
    // ---- link budget ----
    double txAntennaGain = 0.0;
    double rxAntennaGain = 0.0;
    double noiseFigure = 0.0;
    bool txIsBaseStation = false;   // gates angular attenuation
 
    // The cell this link belongs to. Only the interference computation needs it --
    // that model is genuinely cellular-topology-aware, since it asks which cell an
    // interferer is in. For a cellular link it is the base-station endpoint; for a
    // UE-to-UE link it is the transmitter's serving cell.
    MacNodeId cellId = NODEID_NONE;
 
    // ---- tag, not a switch ----
    Direction dir = UNKNOWN_DIRECTION;
};
class ChannelModelBase : public cSimpleModule
{
  protected:
    // Reference to Binder module
    inet::ModuleRefByPar<Binder> binder_;
 
    // Reference to cell info module
    inet::ModuleRefByPar<CellInfo> cellInfo_;
 
    // Reference to the corresponding PHY layer
    opp_component_ptr<PhyBase> phy_;
 
    // Reference to the component carrier
    inet::ModuleRefByPar<ComponentCarrier> componentCarrier_;
 
    // Carrier Frequency and its base-10 logarithm
    GHz carrierFrequency_;
    double carrierFrequencyHz_;
    double carrierFrequencyGHz_;
    double log10CarrierFrequencyGHz_;
 
    // Number of bands for this carrier
    unsigned int numBands_ = -1;
 
  public:
 
    void initialize(int stage) override;
    int numInitStages() const override { return inet::NUM_INIT_STAGES; }
 
    /*
     * Returns the carrier frequency
     */
    virtual GHz getCarrierFrequency() const { return GHz(carrierFrequencyGHz_); }
 
    /*
     * Returns the number of logical bands
     */
    virtual unsigned int getNumBands() const { return numBands_; }
 
    /*
     * Returns the numerology index
     */
    virtual unsigned int getNumerologyIndex() const { return componentCarrier_->getNumerologyIndex(); }
 
    virtual void setPhy(PhyBase *phy) { phy_ = phy; }
 
    /*
     * Compute the error probability of the transmitted packet according to CQI used, TX mode, and the received power
     * After that, it generates a random number to check if this packet will be corrupted or not
     *
     * @param frame pointer to the packet
     * @param lteInfo pointer to the user control info
     * @param rsrpVector the per-band received power captured for this frame, when the
     *        caller already has it (the D2D one-to-many capture-effect path). Empty
     *        otherwise; models that do not need it ignore it.
     */
    virtual bool isReceptionSuccessful(LteAirFrame *frame, UserControlInfo *lteInfo, const std::vector<double>& rsrpVector = {}) = 0;
 
    /*
     * Compute attenuation (path loss + optional shadowing) over a radio link.
     *
     * @param link the two endpoints and the channel-state key to evaluate against
     */
    virtual double getAttenuation(const RadioLink& link) = 0;
    /*
     * Compute the path-loss attenuation according to the selected scenario
     *
     * @param distance between UE and eNodeB
     * @param los line-of-sight flag
     */
    virtual double computePathLoss(double distance, double dbp, bool los) = 0;
    /*
     * Compute SIR for each band for user nodeId according to multipath fading
     *
     * @param frame pointer to the packet
     * @param lteInfo pointer to the user control info
     */
    virtual std::vector<double> getSIR(LteAirFrame *frame, UserControlInfo *lteInfo) = 0;
    /*
     * Compute SINR for each band for user nodeId according to path loss, shadowing (optional), and multipath fading
     *
     * @param frame pointer to the packet
     * @param lteInfo pointer to the user control info
     */
    virtual std::vector<double> getSINR(LteAirFrame *frame, UserControlInfo *lteInfo) = 0;
    /*
     * Compute SINR for each band for a background UE according to path loss
     *
     * @param frame pointer to the packet
     * @param lteInfo pointer to the user control info
     */
    virtual std::vector<double> getSINR_bgUe(LteAirFrame *frame, UserControlInfo *lteInfo) = 0;
 
    /*
     * Compute received power for a background UE according to path loss
     *
     */
    virtual double getReceivedPower_bgUe(double txPower, inet::Coord txPos, inet::Coord rxPos, Direction dir, bool losStatus, MacNodeId bsId) = 0;
 
    /*
     * Compute received useful signal for each band for user nodeId according to path loss, shadowing (optional), and multipath fading
     *
     * @param frame pointer to the packet
     * @param lteInfo pointer to the user control info
     */
    virtual std::vector<double> getRSRP(LteAirFrame *frame, UserControlInfo *lteInfo) = 0;
 
    virtual bool isUplinkInterferenceEnabled() { return false; }
    virtual bool recordsUlTransmissionMap() { return isUplinkInterferenceEnabled(); }
};
 
} //namespace
 
#endif
 