NTN_PropagationUtils.c

#include "NTN_PropagationModel.h"
#include "LTENR_PropagationModel.h"
#include "NTN_PropagationUtils.h"
#include <math.h>
 
#define BOLTZMANN 1.38064852e-23 //m2kgs-2K-1
#define TEMPERATURE 300 //kelvin
 
void updateNoisePower(ptrLTENR_PROPAGATIONINFO propInfo)
{
    ptrNTN_PROPAGATIONCONFIG ntnInfo = getNTN_PropInfo();
    double noise = BOLTZMANN * TEMPERATURE * ntnInfo->channelBandwidth * 1000000; //in W
    noise *= 1000; // in mW
    propInfo->downlink.thermalNoise = MW_TO_DBM(noise);
}
 
double calculate_sinr(double dReceivedPower_dbm, double interferencePower_dBm, double bandwidth_mHz)
{
    double noise = BOLTZMANN * TEMPERATURE * bandwidth_mHz * 1000000; //in W
    double Pmw = DBM_TO_MW(dReceivedPower_dbm);
    double Imw = DBM_TO_MW(interferencePower_dBm);
    noise *= 1000; // in mW
    return MW_TO_DBM(Pmw / (Imw + noise));
}
 
double NTNget_LOS_probability(NTN_SCENARIO scenario, double elevationAngle) 
{
    const int TABLE_SIZE = 9; // Constant table size for all scenarios
 
    elevationAngle = quantizeElevationAngle(elevationAngle);
    NTN_LOS_ElevationAngleTable* table;
    
    switch (scenario) 
    {
    case NTN_SCENARIO_DENSE_URBAN:
        table = denseUrbanScenario;
        break;
    case NTN_SCENARIO_URBAN:
        table = urbanScenario;
        break;
    case NTN_SCENARIO_RURAL:
        table = ruralScenario;
        break;
    default:
        fprintf(stderr, "Unknown scenario type");
        return -1;
    }
 
    // Find the LOS probability based on elevation angle
    for (int i = 0; i < TABLE_SIZE; i++) 
    {
        if (table[i].elevationAngle == elevationAngle) {
            return table[i].LOS_probability;
        }
    }
    fprintf(stderr, "Elevation angle entry not found in the los probability table");
    return -1; 
}
 
double get_shadowingSD(NTN_SCENARIO scenario, NTN_LOS_NLOS_STATE state, NTN_CARRIER_BAND band,double elevationAngle)
{
    NTN_ShadowingSD_ElevationAngleTable* table;
    const int TABLE_SIZE = 9;
 
    elevationAngle = quantizeElevationAngle(elevationAngle);
 
    // Select the appropriate table based on scenario and band
    if (scenario == NTN_SCENARIO_DENSE_URBAN)
    {
        table = (band == NTN_BAND_S) ? sBandShadowingSD_DenseUrban : kaBandShadowingSD_DenseUrban;
    }
    else if (scenario == NTN_SCENARIO_URBAN)
    {
        table = (band == NTN_BAND_S) ? sBandShadowingSD_Urban : kaBandShadowingSD_Urban;
    }
    else if (scenario == NTN_SCENARIO_RURAL)
    {
        table = (band == NTN_BAND_S) ? sBandShadowingSD_Rural : kaBandShadowingSD_Rural;
    }
    else
        table = NULL;
 
    if (table == NULL) {
        fprintf(stderr, "Unknown NTN scenario for shadowing SD calculations\n");
        return 6; // Return -1 to indicate error
    }
    
    for (int i = 0; i < TABLE_SIZE; i++) {
        if (table[i].elevationAngle == elevationAngle) {
            // Return the appropriate standard deviation based on LOS or NLOS state
            return (state == NTN_STATE_LOS) ? table[i].standardDeviation_LOS : table[i].standardDeviation_NLOS;
        }
    }
  
    fprintf(stderr, "Nearest elevation angle not found for shadowing SD calculations");
    return 6; //Ask what will be suitable to return
}
 
double get_clutterloss(NTN_SCENARIO scenario, NTN_LOS_NLOS_STATE state, NTN_CARRIER_BAND band, double elevationAngle)
{
    NTN_ShadowingSD_ElevationAngleTable* table;
    const int TABLE_SIZE = 9;
 
    elevationAngle = quantizeElevationAngle(elevationAngle);
 
    if (scenario == NTN_SCENARIO_DENSE_URBAN)
    {
        table = (band == NTN_BAND_S) ? sBandShadowingSD_DenseUrban : kaBandShadowingSD_DenseUrban;
    }
    else if (scenario == NTN_SCENARIO_URBAN)
    {
        table = (band == NTN_BAND_S) ? sBandShadowingSD_Urban : kaBandShadowingSD_Urban;
    }
    else if (scenario == NTN_SCENARIO_RURAL)
    {
        table = (band == NTN_BAND_S) ? sBandShadowingSD_Rural : kaBandShadowingSD_Rural;
    }
    else
        table = NULL;
 
    if (table == NULL) {
        fprintf(stderr, "Unknown NTN scenario for clutter loss calculations\n");
        return -1; // Return -1 to indicate error
    }
 
    for (int i = 0; i < TABLE_SIZE; i++) {
        if (table[i].elevationAngle == elevationAngle) {
            // Return the respective clutterloss for NLOS scenarios as per table
            return (state == NTN_STATE_LOS) ? 0 : table[i].clutterLoss_dB;
        }
    }
 
    fprintf(stderr, "Nearest elevation angle not found for clutter loss calculations");
    return -1; //Ask what will be suitable to return
}
 
double quantizeElevationAngle(double elevAngle) {
 
    double elevAngleQuantized;
 
    elevAngleQuantized = elevAngle <= 10 ? 10 : round(elevAngle / 10.0) * 10;
    return elevAngleQuantized;
}
 
int countDistinctBeamChannels(BeamNode* head) {
    int uniqueCount = 0;
    int seen[20] = { 0 }; 
 
    BeamNode* temp = head;
 
    while (temp != NULL) {
 
        if (!seen[temp->beamChannelId]) 
        {  
            seen[temp->beamChannelId] = 1;
            uniqueCount++;
        }
        temp = temp->next;
    }
 
    return uniqueCount;
}