NTN_PropagationModel.c

#include "NTN_PropagationModel.h"
#include "LTENR_PropagationModel.h"
#include "LTE_NR.h"
#include "LTENR_PHY.h"
#include "NTN.h"
 
#define EARTH_RADIUS 6371000
#define BOLTZMANN -228.6 // dBW/K/Hz
#define CIR_MW_TO_DBM(mw)   ((mw) <= ZERO_MW?NEGATIVE_DBM:-10.0*log10(mw))
#define CIR_DBM_TO_MW(dbm)  ((dbm) == NEGATIVE_DBM? 0.0: pow(10.0,(-dbm)/10.0))
 
#define NTN_RX_ANTENNA_TEMPERATURE  290
 
static bool isNTNScenarioVar = false;
static ptrNTN_PROPAGATIONCONFIG ntnInfo = NULL;
 
bool isNTNScenario()
{
    //return false;
    return isNTNScenarioVar;
}
 
void setNTNpropagationInfo(ptrNTN_PROPAGATIONCONFIG propagation) {
    ntnInfo = propagation;
}
 
ptrNTN_PROPAGATIONCONFIG getNTN_PropInfo()
{
    return ntnInfo;
}
 
void setNTNScenario()
{
    isNTNScenarioVar = true;
    return ;
}
 
 
double calculateSlantRange(double altitude, double elevationAngle_rad)
{
    double sinAlpha = sin(elevationAngle_rad);
    double d = sqrt(pow(EARTH_RADIUS * sinAlpha, 2) + pow(altitude, 2) + 2 * altitude * EARTH_RADIUS) - EARTH_RADIUS * sinAlpha;
    return d;
}
 
double calculateNTN_SNR(ptrLTENR_PROPAGATIONINFO propInfo, double beamformingGain) {
    ptrNTN_PROPAGATIONCONFIG ntnInfo = getNTN_PropInfo();
    double snr, eirp_dBW;
    eirp_dBW = ntnInfo->eirpDensity + MW_TO_DBM(ntnInfo->channelBandwidth);
 
    ntnInfo->eirp_dBW = eirp_dBW;
    double B_db = MW_TO_DBM(ntnInfo->channelBandwidth * pow(10, 6));
    snr = eirp_dBW + propInfo->angularAntennaGain_dB + propInfo->rxG_T - BOLTZMANN - propInfo->dTotalLoss - B_db + beamformingGain;
 
    return snr;
}
 
double calculateFreeSpacePathLoss(ptrLTENR_PROPAGATIONINFO propInfo)
{
    NETSIM_ID ueId = propInfo->ueId;
 
    ptrNTN_PROPAGATIONCONFIG ntnInfo = getNTN_PropInfo();
     
    double altitude = DEVICE_POSITION(ntnInfo->ntnId)->Z;
 
    propInfo->slantHeight = calculateSlantRange(altitude, propInfo->elevationAngle_rad);
 
    return 32.45 + 20 * log10(propInfo->centralFrequency_GHz) + 20 * log10(propInfo->slantHeight);
}
 
static double NTN_log_normal_distribution(ptrNTN_PROPAGATIONCONFIG info, double std)
{
    double ldRandomNumber = 0.0;
    double fFac, fRsq, fV1, fV2;
    double st, phase, loss;
 
    if (info->SHADOWVAR.isConstructiveShadow == 0)
    {
        do
        {
            ldRandomNumber = RANDOM_01;
            fV1 = (double)(2.0 * ldRandomNumber - 1.0);
            //calculate the Random number from this function
            ldRandomNumber = RANDOM_01;
            fV2 = (double)(2.0 * ldRandomNumber - 1.0);
            fRsq = fV1 * fV1 + fV2 * fV2;
        } while (fRsq >= 1.0 || fRsq == 0.0);
 
        fFac = (double)(sqrt(-2.0 * log(fRsq) / fRsq));
        info->SHADOWVAR.Gset = fV1 * fFac;
        info->SHADOWVAR.Iset = fV2 * fFac;
 
        st = info->SHADOWVAR.Gset; //st = Gset || Iset;
        info->SHADOWVAR.isConstructiveShadow = 1;
    }
    else
    {
        st = info->SHADOWVAR.Iset;
        info->SHADOWVAR.isConstructiveShadow = 0;
    }
 
    phase = RANDOM_01;
    if (phase <= 0.5)
        loss = -1 * std * st;
    else
        loss = std * st;
 
    return loss;
}
 
void calculateNTN_totalloss(ptrLTENR_PROPAGATIONINFO propInfo)
{
 
    ptrNTN_PROPAGATIONCONFIG ntnInfo = getNTN_PropInfo();
 
    NETSIM_ID ueId = propInfo->ueId;
 
    if (ntnInfo->pathLossModel == NTN_PATHLOSS_MODEL_FREE_SPACE)
    {
        propInfo->dPathLoss = calculateFreeSpacePathLoss(propInfo);
    }
    else
        propInfo->dPathLoss = 0;
 
    if (ntnInfo->shadowFadingModel == NTN_SHADOWFADING_MODEL_LOGNORMAL)
    {
        propInfo->dShadowFadingLoss = calculateNTNshadowloss(propInfo);
    }
    else
        propInfo->dShadowFadingLoss = 0;
 
    if (ntnInfo->clutterlossModel == NTN_CLUTTERLOSS_MODEL_TR38_811)
    {
        propInfo->dClutterLoss = calculateNTNclutterloss(propInfo);
    }
    else
        propInfo->dClutterLoss = 0;
 
    propInfo->dAdditionalLoss = ntnInfo->additionalLoss;
 
    propInfo->dTotalLoss = propInfo->dPathLoss + propInfo->dShadowFadingLoss
        + propInfo->dAdditionalLoss + propInfo->dClutterLoss;
 
}
 
ptrBeamNode addBeamCenters(UINT beamCount)
{
    char filename[BUFSIZ];
    sprintf(filename, "%s\\Default\\CenterPoints.csv", pszIOPath);
 
    FILE* file = fopen(filename, "r");
    if (file == NULL) {
        fprintf(stderr, "Error opening file\n");
        return NULL;
    }
 
    ptrBeamNode head = NULL;
    ptrBeamNode tail = NULL;
 
    UINT cellId, id = 1;
    int channelId;
    double x, y;
    char buffer[256];
 
    // Read the CSV file line by line
    while (fgets(buffer, sizeof(buffer), file) != NULL) {
        if (sscanf(buffer, "%d,%lf,%lf,%d", &cellId, &x, &y, &channelId) == 4)
        {
            ptrBeamNode newBeam = (ptrBeamNode)malloc(sizeof(BeamNode));
            if (!newBeam) {
                fprintf(stderr, "Memory allocation failed\n");
                fclose(file);
                return NULL;
            }
            newBeam->beamCoord = (NetSim_COORDINATES*)malloc(sizeof(NetSim_COORDINATES));
 
            // Set the beam data
            newBeam->beamId = id;
            newBeam->beamCoord->X = x;
            newBeam->beamCoord->Y = y;
            newBeam->beamChannelId = channelId;
            newBeam->next = NULL;
 
 
            if (head == NULL) {
                head = newBeam;
            }
            else {
                tail->next = newBeam;
            }
            tail = newBeam;
            id += 1;
        }
    }
    if (id - 1 != beamCount)
    {
        fprintf(stderr, "\nCount of beams not matching");
    }
    fclose(file);  // Close the file
    return head;   // Return the head of the linked list
}
 
void calculateNTNAntennaGain(ptrLTENR_PROPAGATIONINFO propInfo) 
{
    CalculateTheta(propInfo); // Updating the angle from the current best beam
 
    NETSIM_ID ueId = propInfo->ueId;
    NetSim_COORDINATES* uePos = DEVICE_POSITION(ueId);
    double antennaGain;
 
    ptrNTN_PROPAGATIONCONFIG ntnInfo = getNTN_PropInfo();
 
    double k = 2 * M_PI * propInfo->centralFrequency_GHz * pow(10, 9) / (3 * pow(10, 8)); // k is wave number,
 
    antennaGain = calculateAntennaGain(propInfo->theta_rad, k, ntnInfo->antennaAperture);
 
    propInfo->angularAntennaGain_dB = antennaGain;
    propInfo->netAntennaGain_dB = propInfo->angularAntennaGain_dB + ntnInfo->maxAntennaGain;
    return;
}
 
static void updateNTN_elevationAngle(ptrLTENR_PROPAGATIONINFO propInfo)
{
    ptrNTN_PROPAGATIONCONFIG ntnInfo = getNTN_PropInfo();
 
    double x1 = DEVICE_POSITION(ntnInfo->ntnId)->X;
    double y1 = DEVICE_POSITION(ntnInfo->ntnId)->Y;
    double z1 = DEVICE_POSITION(ntnInfo->ntnId)->Z;
 
    double x2 = DEVICE_POSITION(propInfo->ueId)->X;
    double y2 = DEVICE_POSITION(propInfo->ueId)->Y;
 
    double dis = sqrt(pow(x1 - x2, 2) + pow(y1 - y2, 2));
    double theta = atan(z1 / dis);
    propInfo->elevationAngle_rad = theta;
    return;
}
 
void allocateInfo(ptrLTENR_PROPAGATIONINFO propInfo)
{
    // Allocate and copy pointer members separately
    UINT layerCount = min(propInfo->downlink.txAntennaCount, propInfo->downlink.rxAntennaCount);
    propInfo->downlink.rxPower_dbm = malloc(layerCount * sizeof(double));
    propInfo->downlink.SNR_db = malloc(layerCount * sizeof(double));
    propInfo->downlink.SINR_db = malloc(layerCount * sizeof(double));
    propInfo->downlink.EB_by_N0 = malloc(layerCount * sizeof(double));
    propInfo->downlink.InterferencePower_dbm = malloc(layerCount * sizeof(double));
    propInfo->downlink.spectralEfficiency = malloc(layerCount * sizeof(double));
 
    layerCount = min(propInfo->uplink.txAntennaCount, propInfo->uplink.rxAntennaCount);
 
    propInfo->uplink.rxPower_dbm = malloc(layerCount * sizeof(double));
    propInfo->uplink.SNR_db = malloc(layerCount * sizeof(double));
    propInfo->uplink.SINR_db = malloc(layerCount * sizeof(double));
    propInfo->uplink.EB_by_N0 = malloc(layerCount * sizeof(double));
    propInfo->uplink.InterferencePower_dbm = malloc(layerCount * sizeof(double));
    propInfo->uplink.spectralEfficiency = malloc(layerCount * sizeof(double));
}
 
static void freeInfo(ptrLTENR_PROPAGATIONINFO propInfo)
{
    if (!propInfo) return;
 
    free(propInfo->downlink.rxPower_dbm);
    free(propInfo->downlink.SNR_db);
    free(propInfo->downlink.SINR_db);
    free(propInfo->downlink.EB_by_N0);
    free(propInfo->downlink.InterferencePower_dbm);
    free(propInfo->downlink.spectralEfficiency);
 
    free(propInfo->uplink.rxPower_dbm);
    free(propInfo->uplink.SNR_db);
    free(propInfo->uplink.SINR_db);
    free(propInfo->uplink.EB_by_N0);
    free(propInfo->uplink.InterferencePower_dbm);
    free(propInfo->uplink.spectralEfficiency);
    
}
 
static void deepCopyPropagationInfo(ptrLTENR_PROPAGATIONINFO propInfo, ptrLTENR_PROPAGATIONINFO tempInfo)
{
    if (!propInfo || !tempInfo) {
        fprintf(stderr, "PorpInfo not copied");
        return;
    }
    UINT layerCount = propInfo->downlink.layerCount;
 
    propInfo->angularAntennaGain_dB = tempInfo->angularAntennaGain_dB;
    propInfo->netAntennaGain_dB = tempInfo->netAntennaGain_dB;
    propInfo->rxG_T = tempInfo->rxG_T;
    propInfo->selectedBeamId = tempInfo->selectedBeamId;
 
    propInfo->slantHeight = tempInfo->slantHeight;
    propInfo->theta_rad = tempInfo->theta_rad;
    propInfo->dPathLoss = tempInfo->dPathLoss;
    propInfo->dShadowFadingLoss = tempInfo->dShadowFadingLoss;
    propInfo->dAdditionalLoss = tempInfo->dAdditionalLoss;
    propInfo->dClutterLoss = tempInfo->dClutterLoss;
    propInfo->dTotalLoss = tempInfo->dTotalLoss;
    propInfo->downlink.thermalNoise = tempInfo->downlink.thermalNoise;
 
    for (int layerId = 0; layerId < layerCount; layerId++)
    {
        propInfo->downlink.SNR_db[layerId] = tempInfo->downlink.SNR_db[layerId];
        propInfo->downlink.rxPower_dbm[layerId] = tempInfo->downlink.rxPower_dbm[layerId];
        propInfo->downlink.EB_by_N0[layerId] = tempInfo->downlink.EB_by_N0[layerId];
        propInfo->downlink.spectralEfficiency[layerId] = tempInfo->downlink.spectralEfficiency[layerId];
        propInfo->downlink.SINR_db[layerId] = tempInfo->downlink.SINR_db[layerId];
        propInfo->downlink.InterferencePower_dbm[layerId] = tempInfo->downlink.InterferencePower_dbm[layerId];
    }
 
    layerCount = propInfo->uplink.layerCount;
 
    for (int layerId = 0; layerId < layerCount; layerId++)
    {
        propInfo->uplink.SNR_db[layerId] = tempInfo->uplink.SNR_db[layerId];
        propInfo->uplink.rxPower_dbm[layerId] = tempInfo->uplink.rxPower_dbm[layerId];
        propInfo->uplink.EB_by_N0[layerId] = tempInfo->uplink.EB_by_N0[layerId];
        propInfo->uplink.spectralEfficiency[layerId] = tempInfo->uplink.spectralEfficiency[layerId];
        propInfo->uplink.SINR_db[layerId] = tempInfo->uplink.SINR_db[layerId];
        propInfo->uplink.InterferencePower_dbm[layerId] = tempInfo->uplink.InterferencePower_dbm[layerId];
    }
    return;
}
 
void NTN_BestBeamSelectionAlgorithm(ptrLTENR_PROPAGATIONINFO propInfo,int CA_ID, UINT layerId)
{
    ptrNTN_PROPAGATIONCONFIG ntnInfo = getNTN_PropInfo();
    
    ptrBeamNode tempbeamList = ntnInfo->beamList;
    double bestSNR = NEGATIVE_DBM, snr = NEGATIVE_DBM; // Minimum snr value
    double interference;
    
    updateNTNBandwidth(propInfo);
    updateNTN_elevationAngle(propInfo);
    updateNoisePower(propInfo);
 
    ptrLTENR_PROPAGATIONINFO tempInfo = (ptrLTENR_PROPAGATIONINFO)malloc(sizeof(LTENR_PROPAGATIONINFO));
 
    if (!tempInfo)
    {
        printf("Memory allocation failed.\n");
        return;
    }
 
    memcpy(tempInfo, propInfo, sizeof(*propInfo));
 
    allocateInfo(tempInfo);
 
    while (tempbeamList)
    {
        tempInfo->selectedBeamId = tempbeamList->beamId;
 
        calculateNTN_totalloss(tempInfo);
 
        calculateNTNAntennaGain(tempInfo);
 
        updateNTN_RxG_T(tempInfo);
 
        // Calculate SINR for the current beam
        tempInfo->downlink.SNR_db[layerId] = calculateNTN_SNR(tempInfo, LTENR_BeamForming_Downlink_GetValue(tempInfo, layerId));
 
        updateNTNRxPower(tempInfo, layerId);
 
        NTN_calculateSINR(tempInfo, layerId);
 
        updateNTN_EB_by_N0(tempInfo, layerId);
 
        snr = tempInfo->downlink.SNR_db[layerId];
 
        NTN_plotUeAssociation(tempInfo, CA_ID, layerId, false);
 
        // Update the best beam based on the SINR value
        if (snr > bestSNR)
        {
            deepCopyPropagationInfo(propInfo, tempInfo);
            bestSNR = snr;
        }
        tempbeamList = tempbeamList->next;
    }
    NTN_plotUeAssociation(propInfo,CA_ID,layerId, true);
 
    freeInfo(tempInfo);
    free(tempInfo);
 
    return;
}
 
static double NTN_calculateCIR_InterferencePower(ptrLTENR_PROPAGATIONINFO propInfo, UINT layerId) {
 
    double snr_mw, noise_mw, sinr_mw, interference_mw;
    noise_mw = DBM_TO_MW(propInfo->downlink.thermalNoise);
    snr_mw = DBM_TO_MW(propInfo->downlink.SNR_db[layerId]);
    sinr_mw = DBM_TO_MW(propInfo->downlink.SINR_db[layerId]);
 
    interference_mw = noise_mw * (snr_mw / sinr_mw - 1);
    
    return MW_TO_DBM(interference_mw);
}
 
void NTN_calculateSINR(ptrLTENR_PROPAGATIONINFO propInfo, UINT layerId) {
 
    ptrNTN_PROPAGATIONCONFIG ntnInfo = getNTN_PropInfo();
 
    if (ntnInfo->interferenceModel == NTN_NONE) {
        propInfo->downlink.InterferencePower_dbm[layerId] = NEGATIVE_DBM;
        propInfo->downlink.SINR_db[layerId] = propInfo->downlink.SNR_db[layerId];
    }
    else if (ntnInfo->interferenceModel == NTN_CIR) {
        propInfo->downlink.SINR_db[layerId] = NTN_calculateCIR_Sinr(propInfo->downlink.SNR_db[layerId], ntnInfo->carrier_InterferenceRatio);
        propInfo->downlink.InterferencePower_dbm[layerId] = NTN_calculateCIR_InterferencePower(propInfo,layerId);
 
    }
    else if (ntnInfo->interferenceModel == NTN_EXACT_GEOMETRIC_MODEL)
    {
        double interferencePower = calculateInterferencePower(propInfo, layerId);
        propInfo->downlink.InterferencePower_dbm[layerId] = interferencePower;
        propInfo->downlink.SINR_db[layerId] = calculate_sinr((propInfo->downlink.SNR_db[layerId] + propInfo->downlink.thermalNoise), interferencePower, ntnInfo->channelBandwidth);
    }
    else {
        fprintf(stderr, "Unknown Interference Model");
        propInfo->downlink.InterferencePower_dbm[layerId] = NEGATIVE_DBM;
        propInfo->downlink.SINR_db[layerId] = propInfo->downlink.SNR_db[layerId];
    }
    return;
}
 
static double Magnitude(NetSim_COORDINATES* p) {
    return sqrt(p->X * p->X + p->Y * p->Y + p->Z * p->Z);
}
 
// Function to calculate dot product of two vectors
static double DotProduct(NetSim_COORDINATES* v1, const NetSim_COORDINATES* v2) {
    return v1->X * v2->X + v1->Y * v2->Y + v1->Z * v2->Z;
}
 
 
void CalculateTheta(ptrLTENR_PROPAGATIONINFO propInfo) {
    // Calculate vectors
    ptrNTN_PROPAGATIONCONFIG ntnInfo = getNTN_PropInfo();
 
    NetSim_COORDINATES* beam = getBeamCoordinates(propInfo->selectedBeamId);
    NetSim_COORDINATES* satellite = DEVICE_POSITION(ntnInfo->ntnId);
    NetSim_COORDINATES* receiver = DEVICE_POSITION(propInfo->ueId);
 
    NetSim_COORDINATES v1 = {
        .X = beam->X - satellite->X,
        .Y = beam->Y - satellite->Y,
        .Z = beam->Z - satellite->Z
    };
    NetSim_COORDINATES v2 = {
        .X = receiver->X - satellite->X,
        .Y = receiver->Y - satellite->Y,
        .Z = receiver->Z - satellite->Z
    };
 
    // Calculate magnitudes
    double mag_v1 = Magnitude(&v1);
    double mag_v2 = Magnitude(&v2);
 
    // Normalize vectors
    NetSim_COORDINATES v1_norm = {
        .X = v1.X / mag_v1,
        .Y = v1.Y / mag_v1,
        .Z = v1.Z / mag_v1 };
 
    NetSim_COORDINATES v2_norm = {
        .X = v2.X / mag_v2,
        .Y = v2.Y / mag_v2,
        .Z = v2.Z / mag_v2 };
 
    // Calculate dot product of normalized vectors
    double dot_product = DotProduct(&v1_norm, &v2_norm);
 
    // Calculate theta (angle in radians)
    propInfo->theta_rad = acos(dot_product);
    return;
}
 
static void NTN_setLOS_state(ptrLTENR_PROPAGATIONINFO propInfo)
{
    ptrNTN_PROPAGATIONCONFIG ntnInfo = getNTN_PropInfo();
    double LOS_probability;
    double r = RANDOM_01;
 
    if (ntnInfo->los_mode != NTN_LOS_MODE_USER_DEFINED)
    {
        double elevationAngle = propInfo->elevationAngle_rad * 180 / M_PI;
        LOS_probability = NTNget_LOS_probability(ntnInfo->outScenario, elevationAngle);
    }
    else
        LOS_probability = ntnInfo->los_probability;
 
    if (r <= LOS_probability)
        ntnInfo->state = NTN_STATE_LOS;
    else
        ntnInfo->state = NTN_STATE_NLOS;
    return;
}
 
double calculateNTNshadowloss(ptrLTENR_PROPAGATIONINFO propInfo)
{
    ptrNTN_PROPAGATIONCONFIG ntnInfo = getNTN_PropInfo();
 
    double elevationAngle = propInfo->elevationAngle_rad * 180 / M_PI;
    NTN_setLOS_state(propInfo);
    double stdDeviation = get_shadowingSD(ntnInfo->outScenario, ntnInfo->state, ntnInfo->carrierBand, elevationAngle);
    ntnInfo->standardDeviation = stdDeviation;
    return NTN_log_normal_distribution(ntnInfo, stdDeviation);
}
 
double calculateNTNclutterloss(ptrLTENR_PROPAGATIONINFO propInfo)
{
    ptrNTN_PROPAGATIONCONFIG ntnInfo = getNTN_PropInfo();
 
    double elevationAngle = propInfo->elevationAngle_rad * 180 / M_PI;
    NTN_setLOS_state(propInfo);
 
    return get_clutterloss(ntnInfo->outScenario, ntnInfo->state, ntnInfo->carrierBand, elevationAngle);
 
}
 
void updateNTNBandwidth(ptrLTENR_PROPAGATIONINFO propInfo) {
 
    ptrNTN_PROPAGATIONCONFIG ntnInfo = getNTN_PropInfo();
    double totalBandwidth = propInfo->bandwidth_MHz;
 
    if (ntnInfo->ntnFR_factor != NTN_FREQUENCY_REUSE_FACTOR_1)
    {
        totalBandwidth -= ntnInfo->guardBand_MHz * (ntnInfo->channelCount - 1);
        ntnInfo->channelBandwidth = totalBandwidth / ntnInfo->channelCount;
    }
    else
        ntnInfo->channelBandwidth = totalBandwidth;
    return;
}
 
double calculateAntennaGain(double theta, double k, double a)
{
    // k is wawenumber, a is antenna apperture 
    if (theta == 0)
    {
        return 0;
    }
 
    else if (fabs(theta) <= M_PI / 2) {
        // Section 6.4.1 3GPP TR 38.811
        //double x =2*M_PI*a*sin(theta); 
        double x = k * a * sin(theta);
        double besselJ1 = _j1(x);
        double J1_x = besselJ1 / x;
        double gain = 4 * pow(J1_x, 2);
        double maxGain_dbm = MW_TO_DBM(gain);
        return maxGain_dbm;
    }
    else {
        fprintf(stderr, "Theta not in range");
        return 0.0;  // Gain is zero if theta is outside the valid range
    }
}
 
double getDistancefromBeam(ptrLTENR_PROPAGATIONINFO propInfo)
{
    ptrBeamNode tempbeamList = ntnInfo->beamList;
 
    NetSim_COORDINATES* uePos = DEVICE_POSITION(propInfo->ueId);
 
    while (tempbeamList)
    {
        if (propInfo->selectedBeamId == tempbeamList->beamId)
        {
            double dx = uePos->X - tempbeamList->beamCoord->X;
            double dy = uePos->Y - tempbeamList->beamCoord->Y;
            double distance = sqrt(dx * dx + dy * dy);
            return distance;
        }
        tempbeamList = tempbeamList->next;
    }
    return -1;
}
 
void updateNTN_RxG_T(ptrLTENR_PROPAGATIONINFO propInfo) {
    ptrNTN_PROPAGATIONCONFIG ntnInfo = getNTN_PropInfo();
 
    ptrLTENR_UEPHY uePhy = LTENR_UEPHY_GET(propInfo->ueId, propInfo->ueIf);
 
    propInfo->rxG_T = uePhy->ueRxAntennaGain - (MW_TO_DBM(NTN_RX_ANTENNA_TEMPERATURE) + ntnInfo->noiseFigure);
    return;
}
 
void updateNTN_EB_by_N0(ptrLTENR_PROPAGATIONINFO propInfo, UINT layerId) 
{
    propInfo->downlink.EB_by_N0[layerId] = DBM_TO_MW(propInfo->downlink.SINR_db[layerId]);
    propInfo->downlink.spectralEfficiency[layerId] = log2(1 + propInfo->downlink.EB_by_N0[layerId]);
}
 
void updateNTNRxPower(ptrLTENR_PROPAGATIONINFO propInfo, UINT layerId)
{
    ptrNTN_PROPAGATIONCONFIG ntnInfo = getNTN_PropInfo();
 
    ptrLTENR_UEPHY uePhy = LTENR_UEPHY_GET(propInfo->ueId, propInfo->ueIf);
    propInfo->downlink.rxPower_dbm[layerId] = propInfo->downlink.SNR_db[layerId] + propInfo->downlink.thermalNoise;
}
 
void updateNTN_TxPower(ptrLTENR_PROPAGATIONINFO propInfo, UINT layerId) {
 
    ptrNTN_PROPAGATIONCONFIG ntnInfo = getNTN_PropInfo();
    double eirp_dBW = ntnInfo->eirpDensity + MW_TO_DBM(ntnInfo->channelBandwidth);
    double txPowerDBm = eirp_dBW + 30 - ntnInfo->maxAntennaGain;
    propInfo->downlink.totaltxpower_dbm = txPowerDBm;
    return;
}
 
double calculateInterferencePower(ptrLTENR_PROPAGATIONINFO propInfo, UINT layerId) {
 
    ptrNTN_PROPAGATIONCONFIG ntnInfo = getNTN_PropInfo();
    ptrBeamNode tempbeamList = ntnInfo->beamList;
    double interferenceLinear = 0, snr = 0;
    UINT currChannelId;
 
    while (tempbeamList)
    {
        if (tempbeamList->beamId == propInfo->selectedBeamId) {
            currChannelId = tempbeamList->beamChannelId;
            break;
        }
        tempbeamList = tempbeamList->next;
    }
    ptrLTENR_PROPAGATIONINFO tempInfo = (ptrLTENR_PROPAGATIONINFO)malloc(sizeof(LTENR_PROPAGATIONINFO));
    if (!tempInfo)
    {
        printf("Memory allocation failed.\n");
        return;
    }
 
    memcpy(tempInfo, propInfo, sizeof(LTENR_PROPAGATIONINFO));
    allocateInfo(tempInfo);
    tempbeamList = ntnInfo->beamList;
 
    while (tempbeamList)
    {
        tempInfo->selectedBeamId = tempbeamList->beamId;
        // Calculate Rx power for all the beams with same channel Id
        if (tempbeamList->beamId != propInfo->selectedBeamId && tempbeamList->beamChannelId == currChannelId) {
 
            calculateNTN_totalloss(tempInfo);
            calculateNTNAntennaGain(tempInfo);
 
            updateNTN_RxG_T(tempInfo);
 
            // Calculate SINR for the current beam
            snr = calculateNTN_SNR(tempInfo, LTENR_BeamForming_Downlink_GetValue(tempInfo, layerId));
            updateNTNRxPower(tempInfo, layerId);
            interferenceLinear += DBM_TO_MW(snr + propInfo->downlink.thermalNoise);
        }
        tempbeamList = tempbeamList->next;
    }
    freeInfo(tempInfo);
    propInfo->downlink.InterferencePower_dbm[layerId] = MW_TO_DBM(interferenceLinear);
    return MW_TO_DBM(interferenceLinear);
}
 
double NTN_calculateCIR_Sinr(double snr, double cir)
{
    double snr_mw, cir_mw, sinr_mw;
    snr_mw = CIR_DBM_TO_MW(snr);
    cir_mw = CIR_DBM_TO_MW(cir);
    sinr_mw = snr_mw + cir_mw;
    return CIR_MW_TO_DBM(sinr_mw);
}
 
 
NetSim_COORDINATES* getBeamCoordinates( UINT id) {
 
    ptrNTN_PROPAGATIONCONFIG ntnInfo = getNTN_PropInfo();
 
    ptrBeamNode beamList = ntnInfo->beamList;
    while (beamList) {
        if (beamList->beamId == id)
            return beamList->beamCoord;
        beamList = beamList->next;
    }
    return NULL;
}
 
int getBeamChannelId( UINT id) {
 
    ptrNTN_PROPAGATIONCONFIG ntnInfo = getNTN_PropInfo();
    ptrBeamNode beamList = ntnInfo->beamList;
    while (beamList) {
        if (beamList->beamId == id)
            return beamList->beamChannelId;
        beamList = beamList->next;
    }
    return -1;
}