mgr_1

#!/usr/bin/env python
import pandas as panda
import numpy as np
import matplotlib.pyplot as plt
import math


#constants
freq_reuse_factor = 3
R_c = 600
mi = 0.6
centre_range = mi * R_c
edge_range = R_c - centre_range
f = 2.1 #* 10**9 #[GHz]
h_UE = 1.5 #[m]
h_BS = 10 # [m]
d = 1 ### ?
R_0 = 100 #[m], nominal reference distance
gamma = 4 #path loss exponent
alfa = ...
omega = 1.25
C = 3*10**8 #[m/s]

#noise
k = 1.38 * 10**(-23)
T_0 = 297
BW = 20 #[MHz] ?, w atykule BW = 5MHz i S = 25 sub-ch
S = 100 #number of subchannels in the whole bandwidth
N = k * T_0 * (BW * 10**6/S)

#values needed to calculate fi and ni
Xf = 6 * math.log10(f/2) #correction factor for frequencies above 2 GHz
Xh = -d * math.log10(h_UE/2) #correction factor for the receiver
s = 1 #shadowing term, normal random variable (value from normal distribution) ???
T = 16 #number of subchannels available at the edge of a cell, T=4 w artykule

#bilans
G_T = 18
G_R = 0
L_T = 7 #?
L_R = 1# ?
P_T = 10 #[dBm]


def calculateFi(R, R_0_prim, c, freq):
    power_1 = (G_T + G_R - (s + Xf + Xh + L_T + L_R))/10
    power_2 = (G_T + G_R - (s + L_T + L_R))/10

    wavelght = c / (freq * 10**9)

    if(R/R_c > R_0_prim/R_c):
        fi = (R_0/R_c)**gamma * (wavelght/(4*math.pi*R_0_prim))**2 * 10**power_1
    else:
        fi = (wavelght/(4*math.pi*R_c))**2 * 10**power_2

    return fi

def changeToLinear(x):
    linear = 10**(x/10)
    return linear

def calculateNi(R, R_0_prim):
    if(R/R_c > R_0_prim/R_c):
        ni = gamma
    else:
        ni = 2

    return ni

def calculateP_Tc(P_T, omega):
    P_T_Wat = 10**(P_T/10 - 3)
    P_Tc = P_T_Wat/(omega*T + S - freq_reuse_factor*T)

    return P_Tc

def calculateFresnelZoneBreakpoint(h_t, h_r, c, freq):
    sum = h_t + h_r
    diff = h_t - h_r
    wavelght = c / (freq * 10**9)
    R_0_prim = 1/wavelght*math.sqrt((sum**2 - diff**2)**2 -2*(sum**2 + diff**2)*(wavelght/2)**2 + (wavelght/2)**4)

    return R_0_prim

def calculateSINRinCellCenter(R, mi, omega, P_Tc, ni, fi, fi_2):
    S = (R/R_c)**(-ni)
    I_c1 = 6*(fi_2/fi) * math.sqrt(3)**(-gamma)
    I_c2 = 12*(fi_2/fi) * math.sqrt(3*freq_reuse_factor)**(-gamma)
    # I_c1 = 6 * math.sqrt(3)**(-gamma)
    # I_c2 = 12 * math.sqrt(3*freq_reuse_factor)**(-gamma)
    Noise = N / (fi *P_Tc)

    SINR = S/(I_c1 + I_c2 + Noise)

    return SINR

def calculateSINRinCellEdge(R, mi, omega, P_Tc, ni, fi, fi_2):
    S = (R/R_c)**(-ni)
    # I_c = 6* math.sqrt(3*freq_reuse_factor)**(-gamma)
    # Noise = N / (omega*0.0001728125828342691 *P_Tc)
    I_c = 6*(fi_2/fi) * math.sqrt(3*freq_reuse_factor)**(-gamma)
    Noise = N / (omega*fi *P_Tc)

    SINR = S/(I_c + Noise)

    return SINR

def plotGraph(x, y):
    graph = panda.DataFrame(y, x)
    graph.plot(kind='line', grid=True)
    plt.show()
    plt.savefig('wykres SINR.png')


def main():
    calculated_SINR = []
    x = []
    P_tc = calculateP_Tc(P_T, omega)
    R_0_prim = calculateFresnelZoneBreakpoint(h_BS, h_UE, C, f)
    file = open("calculated_SINR.txt", "w")
    file.write("P_tc: ")
    file.write(str(P_tc))
    file.write(" \n")
    file.write("R_0_prim: ")
    file.write(str(R_0_prim))
    file.write(" \n")

    fi_result = calculateFi(200, R_0_prim, C, f)
    fi_2 = calculateFi(500, R_0_prim, C, f)

    for r in range(1, R_c):
        ni_result = calculateNi(r, R_0_prim)
        # x.append(i/R_c)
        x.append(r)

        if(r < R_0_prim):
            sinr = calculateSINRinCellCenter(r, mi, omega, P_tc, ni_result, fi_result, fi_2)
        else:
            sinr = calculateSINRinCellEdge(r, mi, omega, P_tc, ni_result, fi_result, fi_2)
        sinr_in_dB = 10*math.log10(sinr)
        calculated_SINR.append(sinr_in_dB)

        file.write(str(sinr_in_dB))
        file.write(" \n")

    plotGraph(x, calculated_SINR)
    file.close()

if __name__ == "__main__":
    main()