def pathloss(mobile, baseStation, cell):
""" pathloss calculation. different models are possible.
The pathloss consists of a distance loss, a loss due to disalignment with the antenna lobe and the shadowing loss (LNS). Returns: Pathloss in linear format. """
LNS = mobile.baseStations[baseStation]['LNS']
distance = mobile.baseStations[baseStation]['distance']
distancepathloss = 128.1 + 37.6*log10(distance/1e3) # distance in meters
antennaG = antennaGain(getAngleUEBSHex(baseStation.position, cell.center, mobile.position))
pathloss = distancepathloss + LNS - antennaG
#print "%.2f" % pathloss, '=', "%.2f" % distancepathloss, '+', "%.2f" % LNS, '-', "%.2f" % antennaG
return utils.dBToW(-pathloss)
def pathloss(mobile, baseStation, cell):
""" pathloss calculation. different models are possible.
The pathloss consists of a distance loss, a loss due to disalignment with the antenna lobe and the shadowing loss (LNS). Returns: Pathloss in linear format. """
LNS = mobile.baseStations[baseStation]['LNS']
distance = mobile.baseStations[baseStation]['distance']
distancepathloss = 128.1 + 37.6 * log10(
distance / 1e3) # distance in meters
antennaG = antennaGain(
getAngleUEBSHex(baseStation.position, cell.center, mobile.position))
pathloss = distancepathloss + LNS - antennaG
#print "%.2f" % pathloss, '=', "%.2f" % distancepathloss, '+', "%.2f" % LNS, '-', "%.2f" % antennaG
return utils.dBToW(-pathloss)
def fsf(N, T, centerFrequency, totalTime, bandwidth, relativeVelocity):
"""Returns frequency selective fading over a number of subcarriers and time slots."""
delay_taps = 1e-05 * array([
0, 0.0060, 0.0075, 0.0145, 0.0150, 0.0155, 0.0190, 0.0220, 0.0225,
0.0230, 0.0335, 0.0370, 0.0430, 0.0510, 0.0685, 0.0725, 0.0735, 0.0800,
0.0960, 0.1020, 0.1100, 0.1210, 0.1845
])
delay_taps.shape = (23, 1) # promote
tapGains_dB = array([
-6.4000, -3.4000, -2.0000, -3.0000, -3.5500, -7.0000, -3.4000, -3.4000,
-5.6000, -7.4000, -4.6000, -7.8000, -7.8000, -9.3000, -12.0000,
-8.5000, -13.2000, -11.2000, -20.8000, -14.5000, -11.7000, -17.2000,
-16.7000
])
tapGains_dB.shape = (23, 1) # promote
startTime = 0 # no effect
chunkwidth = bandwidth / N
N_harmonics = 5 # magic number from model
numTaps = delay_taps.size
speedOfLight = 3e8
dopplerFrequency = relativeVelocity * centerFrequency / speedOfLight
chunkCenters = linspace(centerFrequency - bandwidth / 2,
centerFrequency + bandwidth / 2 - chunkwidth,
num=N)
timeStamp = linspace(startTime,
startTime + totalTime * (1 - 1. / T),
num=T)
tapGains = utils.dBToW(tapGains_dB)
tapGainsNorm = tapGains / np.sum(tapGains)
N_chunks = chunkCenters.size
path_rand = random.rand(numTaps, N_harmonics)
phase_rand = random.rand(numTaps, N_harmonics)
H = empty([chunkCenters.size, timeStamp.size], dtype=complex)
H[:] = nan
for t in range(timeStamp.size):
disc_dopp_freq = dopplerFrequency * cos(2 * math.pi * path_rand)
disc_dopp_phase = 2 * math.pi * phase_rand
for f in range(chunkCenters.size):
H[f,
t] = instantChunkFading(timeStamp[t], chunkCenters[f],
tapGainsNorm, disc_dopp_phase,
disc_dopp_freq, delay_taps, N_harmonics)
# normalize
H[:, t] = H[:, t] / sum(abs(H[:, t])) * N_chunks
return H, chunkCenters, timeStamp
def fsf(N, T, centerFrequency, totalTime, bandwidth, relativeVelocity):
"""Returns frequency selective fading over a number of subcarriers and time slots."""
delay_taps = 1e-05 * array([0,
0.0060,
0.0075,
0.0145,
0.0150,
0.0155,
0.0190,
0.0220,
0.0225,
0.0230,
0.0335,
0.0370,
0.0430,
0.0510,
0.0685,
0.0725,
0.0735,
0.0800,
0.0960,
0.1020,
0.1100,
0.1210,
0.1845])
delay_taps.shape = (23,1) # promote
tapGains_dB = array([-6.4000,
-3.4000,
-2.0000,
-3.0000,
-3.5500,
-7.0000,
-3.4000,
-3.4000,
-5.6000,
-7.4000,
-4.6000,
-7.8000,
-7.8000,
-9.3000,
-12.0000,
-8.5000,
-13.2000,
-11.2000,
-20.8000,
-14.5000,
-11.7000,
-17.2000,
-16.7000])
tapGains_dB.shape = (23,1) # promote
startTime = 0 # no effect
chunkwidth = bandwidth/N
N_harmonics = 5 # magic number from model
numTaps = delay_taps.size
speedOfLight = 3e8
dopplerFrequency = relativeVelocity * centerFrequency / speedOfLight
chunkCenters = linspace(centerFrequency-bandwidth/2,centerFrequency+bandwidth/2-chunkwidth, num=N)
timeStamp = linspace(startTime, startTime+totalTime*(1-1./T),num=T)
tapGains = utils.dBToW(tapGains_dB)
tapGainsNorm = tapGains/np.sum(tapGains)
N_chunks = chunkCenters.size
path_rand = random.rand(numTaps, N_harmonics)
phase_rand = random.rand(numTaps, N_harmonics)
H = empty([chunkCenters.size, timeStamp.size ],dtype=complex)
H[:] = nan
for t in range(timeStamp.size):
disc_dopp_freq = dopplerFrequency * cos(2*math.pi*path_rand)
disc_dopp_phase = 2*math.pi*phase_rand
for f in range(chunkCenters.size):
H[f,t] = instantChunkFading(timeStamp[t], chunkCenters[f], tapGainsNorm,disc_dopp_phase, disc_dopp_freq, delay_taps, N_harmonics)
# normalize
H[:,t] = H[:,t]/sum(abs(H[:,t]))*N_chunks
return H, chunkCenters, timeStamp
