NTN_Measurements.c

#include "NTN_PropagationModel.h"
#include "LTE_NR.h"
#include "LTENR_PHY.h"
#define DegreesToRadians(degree) ((degree) * (M_PI / 180.0))
#define RadiansToDegrees(radian) ((radian) * (180.0 / M_PI))
 
static FILE* fpRMlog = NULL;
static FILE* fpLog = NULL;
 
// Shadowing St. dev removed from the plots.
void initNTN_UeAssociationLogs() {
 
    if (!get_protocol_log_status("NTN_UE_Beam_Association"))
        return;
 
    char s[BUFSIZ];
    sprintf(s, "%s\\%s", pszIOLogPath, "NTN_UE_Beam_Association.csv");
    fpRMlog = fopen(s, "w");
    if (!fpRMlog)
    {
        fnSystemError("Unable to open %s file", s);
        perror(s);
    }
 
    fprintf(fpRMlog, "%s,%s,%s,%s,",
        "Time(ms)", "Ue Name", "UeX(m)", "UeY(m)");
    
    fprintf(fpRMlog, "%s,%s,%s,%s,%s,",
        "Elevation Angle(°)", "Slant height(Km)", "Theta(°)", "EIRP(dBW)", "PathLoss(dB)");
    
    fprintf(fpRMlog, "%s,%s,%s,%s,",
        "ShadowLoss(dB)", "Additional Loss(dB)", "Clutter Loss(dB)", "Angular Antenna Gain(dB)");
    
    fprintf(fpRMlog, "%s,%s,",
         "UE Rx Antenna Gain(dB)", "CIR(dB)");
    
    fprintf(fpRMlog, "%s,%s,%s,%s,",
        "TotalLoss(dB)", "Noise(dBm)", "Rx Power(dBm)", "FR Channel Id");
    
    fprintf(fpRMlog, "%s,%s,%s,%s,",
        "Channel Bandwidth(MHz)", "Interference Power(dBm)", "Guard Band BW(MHz)", "SNR(dB)");
    
    fprintf(fpRMlog, "%s,%s,%s,%s,%s,\n",
        "SINR(dB)", "Current Beam Id", "CQI", "MCS Index", "Associated Beam");
 
}
 
void NTN_plotUeAssociation(ptrLTENR_PROPAGATIONINFO propInfo,int CA_ID, UINT layerId, bool isSelected) {
 
    ptrNTN_PROPAGATIONCONFIG ntnInfo = getNTN_PropInfo();
    ptrLTENR_UEPHY uePhy = LTENR_UEPHY_GET(propInfo->ueId, propInfo->ueIf);
    int frChannelId = getBeamChannelId(propInfo->selectedBeamId);
 
    ptrLTENR_ASSOCIATEDUEPHYINFO assocInfo = LTENR_ASSOCIATEDUEPHYINFO_GET(propInfo->gnbId, propInfo->gnbIf, propInfo->ueId, propInfo->ueIf);
    ptrLTENR_GNBPHY phy = LTENR_GNBPHY_GET(propInfo->gnbId, propInfo->gnbIf);
    ptrLTENR_CA ca = phy->spectrumConfig->CA[CA_ID];
    
    if (assocInfo->isAssociated && ca->configSlotType == SLOT_UPLINK) return;
 
    if (fpRMlog) {
        //DEVICE_CONFIGID
        NETSIM_ID ueId = propInfo->ueId;
        
        fprintf(fpRMlog, "%lf,%s,%.2lf,%.2lf,",
            ldEventTime / MILLISECOND, DEVICE_NAME(ueId),
            DEVICE_POSITION(ueId)->X, DEVICE_POSITION(ueId)->Y);
 
        fprintf(fpRMlog, "%.2lf,%.3lf,%.2lf,",
            RadiansToDegrees(propInfo->elevationAngle_rad),
            propInfo->slantHeight/1000 ,
            RadiansToDegrees(propInfo->theta_rad));
 
        fprintf(fpRMlog, "%.2lf,%.2lf,%.2lf,",
            ntnInfo->eirp_dBW,
            propInfo->dPathLoss,
            propInfo->dShadowFadingLoss);
        
        fprintf(fpRMlog, "%.2lf,%.2lf,%.2lf,%.2lf,",
            propInfo->dAdditionalLoss,
            propInfo->dClutterLoss,
            propInfo->angularAntennaGain_dB,
            uePhy->ueRxAntennaGain);
 
        if (ntnInfo->interferenceModel == NTN_CIR)
            fprintf(fpRMlog, "%.2lf,", ntnInfo->carrier_InterferenceRatio);
        else 
            fprintf(fpRMlog, "N/A,");
        
        fprintf(fpRMlog, "%.2lf,%.2lf,%.2lf,",
            propInfo->dTotalLoss,
            propInfo->downlink.thermalNoise,
            propInfo->downlink.rxPower_dbm[layerId]);
 
        fprintf(fpRMlog, "%d,%.2lf,%.2lf,%.2lf,",
            frChannelId,
            ntnInfo->channelBandwidth,
            propInfo->downlink.InterferencePower_dbm[layerId],
            ntnInfo->guardBand_MHz);
 
        fprintf(fpRMlog, "%.2lf,%.2lf,%u,",
            propInfo->downlink.SNR_db[layerId],
            propInfo->downlink.SINR_db[layerId],
            propInfo->selectedBeamId);
 
        
        if (assocInfo->downlinkAMCInfo[CA_ID])
        {
            fprintf(fpRMlog, "%d,%u,",
                assocInfo->downlinkAMCInfo[CA_ID][layerId]->cqiTable.CQIIndex,
                assocInfo->downlinkAMCInfo[CA_ID][layerId]->mcsTable.mcsIndex);
        }
        else
            fprintf(fpRMlog, "NA,NA,");
 
 
        if (isSelected) {
            fprintf(fpRMlog, "true,");
        }
 
        fprintf(fpRMlog, "\n");
        fflush(fpRMlog);
    }
    return;
}
 
void initNTNRadioMeasurementLogs() {
 
    if (!get_protocol_log_status("NTN_Radio_Measurement_Logs"))
        return;
 
    char s[BUFSIZ];
    sprintf(s, "%s\\%s", pszIOLogPath, "NTN_Radio_Measurement_Logs.csv");
    fpLog = fopen(s, "w");
 
    if (!fpLog) {
        fnSystemError("Unable to open %s file", s);
        perror(s);
    }
 
    fprintf(fpLog, "%s,%s,%s,%s,",
        "Time(ms)", "gNB or eNB Name", "UE Name", "Slant height(Km)");
 
    fprintf(fpLog, "%s,%s,%s,%s,%s,",
        "Elevation Angle(°)", "CC_ID", "Band", "Channel", "Rank");
 
    fprintf(fpLog, "%s,%s,%s,%s,%s,",
        "Layer ID", "EIRP(dBW)", "PathLoss(dB)", "ShadowFadingLoss(dB)", "AdditonalLoss(dB)");
 
    fprintf(fpLog, "%s,%s,%s,%s,%s,",
        "ClutterLoss(dB)", "TotalLoss(dB)", "BeamFormingGain(dB)", "Angular Antenna Gain(dB)", "UE Rx Antenna Gain(dB)");
 
    fprintf(fpLog, "%s,%s,%s,%s,",
        "Rx_Power(dBm)", "SNR(dB)", "SINR(dB)", "ThermalNoise(dBm)");
 
    fprintf(fpLog, "%s,%s,%s,\n",
        "InterferencePower(dBm)", "CQI Index", "MCS Index");
}
 
void NTNRadioMeasurementLog(ptrLTENR_GNBPHY phy, int CA_ID, ptrLTENR_ASSOCIATEDUEPHYINFO info)
{
    if (fpLog == NULL) return;
 
    UINT layerCount;
    ptrLTENR_PROPAGATIONINFO pinfo = info->propagationInfo[CA_ID];
    ptrLTENR_PROPAGATIONCONFIG propagation = pinfo->propagationConfig;
 
    ptrLTENR_UEPHY uePhy = LTENR_UEPHY_GET(pinfo->ueId, pinfo->ueIf);
    ptrLTENR_ASSOCIATEDUEPHYINFO assocInfo = LTENR_ASSOCIATEDUEPHYINFO_GET(pinfo->gnbId, pinfo->gnbIf, pinfo->ueId, pinfo->ueIf);
 
    ptrNTN_PROPAGATIONCONFIG ntnInfo = getNTN_PropInfo();
    int frChannelId = getBeamChannelId(pinfo->selectedBeamId);
 
    ptrLTENR_CA ca = phy->spectrumConfig->CA[CA_ID];
   
    if (!assocInfo->isAssociated || ca->configSlotType == SLOT_UPLINK) return;
    
    layerCount = pinfo->downlink.layerCount;
 
    for (UINT layerId = 0; layerId < layerCount; layerId++)
    {
 
        fprintf(fpLog, "%.2lf,%s,%s,%.3lf,",
            ldEventTime / MILLISECOND,
            DEVICE_NAME(pinfo->gnbId),
            DEVICE_NAME(pinfo->ueId),
            pinfo->slantHeight / 1000);
 
        fprintf(fpLog, "%.2lf,%d,%s,%d,",
            RadiansToDegrees(pinfo->elevationAngle_rad),
            CA_ID + 1,
            ca->operatingBand,
            frChannelId);
 
        fprintf(fpLog, "%d,%d,%.2lf,%.2lf,%.2lf,",
            pinfo->downlink.layerCount,
            layerId + 1,
            ntnInfo->eirp_dBW,
            pinfo->dPathLoss,
            pinfo->dShadowFadingLoss);
 
        fprintf(fpLog, "%.2lf,%.2lf,%.2lf,",
            pinfo->dAdditionalLoss,
            pinfo->dClutterLoss,
            pinfo->dTotalLoss);
 
        if (propagation->fastFadingModel == LTENR_FASTFADING_MODEL_AWGN_WITH_RAYLEIGH_FADING)
            fprintf(fpLog, "%lf,",pinfo->downlink.beamFormingGain[layerId]);
        else
            fprintf(fpLog, "%s,", "N/A");
 
        fprintf(fpLog, "%.2lf,%.2lf,",
            pinfo->angularAntennaGain_dB,
            uePhy->ueRxAntennaGain);
 
        fprintf(fpLog, "%.2lf,%.2lf,%.2lf,%.2lf,",
            pinfo->downlink.rxPower_dbm[layerId],
            pinfo->downlink.SNR_db[layerId],
            pinfo->downlink.SINR_db[layerId],
            pinfo->downlink.thermalNoise);
 
        fprintf(fpLog, "%.2lf,%d,%d\n",
            pinfo->downlink.InterferencePower_dbm[layerId],
            info->downlinkAMCInfo[CA_ID][layerId]->cqiTable.CQIIndex,
            info->downlinkAMCInfo[CA_ID][layerId]->mcsTable.mcsIndex);
    }
    if (nDbgFlag) fflush(fpLog);
}