NTN.c

#include "NTN.h"
#include "NTN_PropagationModel.h"
#include "stdafx.h"
#include "LTENR_Spectrum.h"
#include "LTENR_AMCTable.h"
#include "LTENR_MAC.h"
#include "LTENR_PHY.h"
#include "LTENR_Multiplexing.h"
#include "LTENR_Spectrum.h"
#include "LTENR_HARQ.h"
#include <stdarg.h>
 
void SendToNTNReceiver(NETSIM_ID gnbId, NETSIM_ID gnbIf, ptrLTENR_ASSOCIATEDUEPHYINFO info, bool isUplink, NetSim_PACKET* packet)
{
    ptrLTENR_GNBPHY phy = LTENR_GNBPHY_GET(gnbId, gnbIf);
    double slotTime = LTENR_PHY_GetSlotTime(gnbId, gnbIf);
 
    NetSim_EVENTDETAILS pevent;
    memset(&pevent, 0, sizeof pevent);
    pevent.dEventTime = phy->currentFrameInfo->slotEndTime;
    pevent.dPacketSize = packet->pstruMacData->dPacketSize;
    if (packet->pstruAppData)
    {
        pevent.nApplicationId = packet->pstruAppData->nApplicationId;
        pevent.nSegmentId = packet->pstruAppData->nSegmentId;
    }
    if (isUplink)
    {
        pevent.nDeviceId = gnbId;
        pevent.nInterfaceId = gnbIf;
        pevent.nDeviceType = DEVICE_TYPE(gnbId);
    }
    else
    {
        pevent.nDeviceId = info->ueId;
        pevent.nInterfaceId = info->ueIf;
        pevent.nDeviceType = DEVICE_TYPE(info->ueId);
    }
 
    pevent.dEventTime = phy->currentFrameInfo->slotEndTime + calculateRoundTripPD(gnbId, info->ueId, slotTime);
    pevent.nEventType = MAC_IN_EVENT;
    pevent.nPacketId = packet->nPacketId;
    pevent.nProtocolId = LTENR_PROTODATA_GET(gnbId, gnbIf)->macProtocol;
    pevent.pPacket = packet;
    fnpAddEvent(&pevent);
}
 
double calculateRoundTripPD(NETSIM_ID gnbId, NETSIM_ID ueId, double slotTime)
{
    ptrNTN_PROPAGATIONCONFIG ntnInfo = getNTN_PropInfo();
    double gnbSatDelay, ueSatDelay; 
    
    gnbSatDelay = calculatePropagationDelay(gnbId, ntnInfo->ntnId);
    gnbSatDelay = quantizeDelay(gnbSatDelay, slotTime);
 
    ueSatDelay = calculatePropagationDelay(ueId, ntnInfo->ntnId);
    ueSatDelay = quantizeDelay(ueSatDelay, slotTime);
    
    return (gnbSatDelay+ueSatDelay);
}
 
double quantizeDelay(double delay,double slotTime)
{
    double qunatizedDelay = ceil(delay / slotTime) * slotTime;
    return qunatizedDelay;
}
 
double calculatePropagationDelay(NETSIM_ID d1, NETSIM_ID d2)
{
    double x1 = DEVICE_POSITION(d1)->X;
    double y1 = DEVICE_POSITION(d1)->Y;
    double z1 = DEVICE_POSITION(d1)->Z;
 
    double x2 = DEVICE_POSITION(d2)->X;
    double y2 = DEVICE_POSITION(d2)->Y;
    double z2 = DEVICE_POSITION(d2)->Z;
 
    
    double distance_m = sqrt(pow(x2 - x1, 2) + pow(y2 - y1, 2) + pow(z2 - z1, 2));
 
    double delay = distance_m/300; // The delay calculated is in microsecond 
 
    return delay;
}
 
void LTENR_NTN_PhyOut_HandleBroadCast() {
    NetSim_PACKET* packet = pstruEventDetails->pPacket;
    NETSIM_ID d = pstruEventDetails->nDeviceId;
    NETSIM_ID in = pstruEventDetails->nInterfaceId;
    NETSIM_ID r = packet->nReceiverId;
    double slotTime;
    for (r = 0; r < NETWORK->nDeviceCount; r++)
    {
        if (d == r + 1)
            continue;
 
        for (NETSIM_ID rin = 0; rin < DEVICE(r + 1)->nNumOfInterface; rin++)
        {
            if (!isLTE_NRInterface(r + 1, rin + 1))
                continue;
 
            ptrLTENR_PROTODATA data = LTENR_PROTODATA_GET(r + 1, rin + 1);
            if (data->isDCEnable) {
                if (data->MasterCellType == MMWAVE_CELL_TYPE) {
                    if (fn_NetSim_isDeviceLTENR(r + 1, rin + 1)) {
                        if (!fn_NetSim_isDeviceLTENR(d, in))
                            continue;
                    }
                    else {
                        continue;
                    }
                }
                else {
                    if (!fn_NetSim_isDeviceLTENR(r + 1, rin + 1)) {
                        if (fn_NetSim_isDeviceLTENR(d, in))
                            continue;
                    }
                    else {
                        continue;
                    }
                }
            }
            switch (data->deviceType)
            {
            case LTENR_DEVICETYPE_UE:
            {
                double endTime = LTENR_PHY_GetSlotEndTime(d, in);
                NetSim_PACKET* p = fn_NetSim_Packet_CopyPacket(packet);
 
                p->pstruPhyData->dArrivalTime = pstruEventDetails->dEventTime;
                p->pstruPhyData->dEndTime = endTime - 1;
                p->pstruPhyData->dPacketSize = p->pstruMacData->dPacketSize;
                p->pstruPhyData->dPayload = p->pstruMacData->dPacketSize;
                p->pstruPhyData->dStartTime = pstruEventDetails->dEventTime;
                p->pstruMacData->Packet_MACProtocol = NULL;
                p->pstruMacData->Packet_MACProtocol = LTENR_MSG_COPY(packet);
 
                pstruEventDetails->pPacket = p;
                slotTime = LTENR_PHY_GetSlotTime(d, in);
                // check how to add propagation info
                pstruEventDetails->dEventTime = endTime - 1 + calculateRoundTripPD(d, r+1, slotTime);
                pstruEventDetails->nEventType = PHYSICAL_IN_EVENT;
                pstruEventDetails->nDeviceId = r + 1;
                pstruEventDetails->nDeviceType = DEVICE_TYPE(r + 1);
                pstruEventDetails->nInterfaceId = rin + 1;
                pstruEventDetails->pPacket->nTransmitterId = d;
                pstruEventDetails->pPacket->nReceiverId = r + 1;
 
                fnpAddEvent(pstruEventDetails);
            }
            break;
            default:
                break;
            }
        }
    }
 
    fn_NetSim_Packet_FreePacket(packet);
    pstruEventDetails->pPacket = NULL;
}
 
void LTENR_NTN_PhyOut_HandleUnicast() {
 
    NetSim_PACKET* packet = pstruEventDetails->pPacket;
    NETSIM_ID d = pstruEventDetails->nDeviceId;
    NETSIM_ID in = pstruEventDetails->nInterfaceId;
    NETSIM_ID r = packet->nReceiverId;
    NETSIM_ID rin = LTENR_FIND_ASSOCIATEINTERFACE(d, in, r);
 
    if (rin == 0)
    {
        fn_NetSim_Packet_FreePacket(packet);
        return;
    }
 
    double endTime = LTENR_PHY_GetSlotEndTime(d, in);
    double slotTime = LTENR_PHY_GetSlotTime(d, in);
    packet->pstruPhyData->dArrivalTime = pstruEventDetails->dEventTime;
    packet->pstruPhyData->dEndTime = endTime - 1;
    packet->pstruPhyData->dPacketSize = packet->pstruMacData->dPacketSize;
    packet->pstruPhyData->dPayload = packet->pstruMacData->dPacketSize;
    packet->pstruPhyData->dStartTime = pstruEventDetails->dEventTime;
 
    pstruEventDetails->dEventTime = endTime - 1 + calculateRoundTripPD(d,r,slotTime);
    pstruEventDetails->nEventType = PHYSICAL_IN_EVENT;
    pstruEventDetails->nDeviceId = r;
    pstruEventDetails->nDeviceType = DEVICE_TYPE(r);
    pstruEventDetails->nInterfaceId = rin;
    fnpAddEvent(pstruEventDetails);
}
 
double LTENR_PHY_GetSlotTime(NETSIM_ID d, NETSIM_ID in)
{
    double slotTime; 
    if (isGNB(d, in))
    {
        ptrLTENR_FRAMEINFO fi = ((ptrLTENR_GNBPHY)LTENR_GNBPHY_GET(d, in))->currentFrameInfo;
        slotTime = fi->slotEndTime - fi->slotStartTime;
        return slotTime;
    }
    else
    {
        ptrLTENR_UEPHY phy = LTENR_UEPHY_GET(d, in);
        return LTENR_PHY_GetSlotTime(phy->gnBId, phy->gnbIf);
    }
}