def test_optimPCDTX(self):
# test for simple problem with known outcome
H = np.array([[[1. - 1j, -1.], [-1., 1.]], [[1. - 1j, 1.], [-1., 1.]],
[[0.5, 1.j], [1., -1.j]]])
for k in np.arange(3):
H[k, :, :] = scipy.dot(H[k, :, :], H[k, :, :].conj().T)
noisepower = np.ones(3)
rate = 1
linkBandwidth = 1
p0 = 10
m = 2
pS = 5
pMax = 10
obj, solution, status = optimMinPow.optimizePCDTX(
H, noisepower, rate, linkBandwidth, pMax, p0, m, pS, 0)
answerObj = 13.9204261
answerSol = np.array([0.32342002, 0.24371824, 0.27855287, 0.15430887])
np.testing.assert_almost_equal(obj, answerObj)
np.testing.assert_almost_equal(solution, answerSol)
for k in np.arange(H.shape[0]):
ptx = optimMinPow2x2DTX.ptxOfMu(solution[k], rate, linkBandwidth,
noisepower[k], H[k, :, :])
rate_test = solution[k] * np.real(
utils.ergMIMOCapacityCDITCSIR(H[k, :, :], ptx))
np.testing.assert_almost_equal(rate_test, rate)
def test_optimPCDTX_trivial(self):
# test for simple problem with known outcome
H = np.ones([3, 2, 2])
for k in np.arange(3):
H[k, :, :] = scipy.dot(H[k, :, :], H[k, :, :].conj().T)
noisepower = np.ones(3)
rate = 1
linkBandwidth = 1
p0 = 10
m = 2
pS = 5
pMax = 10
obj, solution, status = optimMinPow.optimizePCDTX(
H, noisepower, rate, linkBandwidth, pMax, p0, m, pS, 0)
answerObj = 17.000000115485285
answerSol = np.array([0.33333334, 0.33333334, 0.33333334, 0.])
np.testing.assert_almost_equal(obj, answerObj)
np.testing.assert_almost_equal(solution, answerSol)
for k in np.arange(H.shape[0]):
ptx = optimMinPow2x2DTX.ptxOfMu(solution[k], rate, linkBandwidth,
noisepower[k], H[k, :, :])
rate_test = solution[k] * np.real(
utils.ergMIMOCapacityCDITCSIR(H[k, :, :], ptx))
np.testing.assert_almost_equal(rate_test, rate)
def test_optimPCDTXrandomChannel(self):
# test for simple problem with known outcome
users = 22
n_tx = 2
n_rx = 2
H = np.empty([users, n_tx, n_rx],
dtype=complex) # very important to make it complex!
for k in np.arange(users):
H[k, :, :] = 10e-7 * utils.rayleighChannel(n_tx, n_rx)
H[k, :, :] = scipy.dot(H[k, :, :], H[k, :, :].conj().T)
noisepower = np.ones(users) * 4e-14
rate = 1.2e7 / users # bps
linkBandwidth = 1e7
p0 = 100
m = 2.4
pS = 50
pMax = 40
obj, solution, status = optimMinPow.optimizePCDTX(
H, noisepower, rate, linkBandwidth, pMax, p0, m, pS, 0)
# Test that all calls were correct and their order. What goes in must come out.
for k in np.arange(users):
ptx = optimMinPow2x2DTX.ptxOfMu(
solution[k], rate, linkBandwidth, noisepower[k],
H[k, :, :]) # power as a function of the MIMO link
rate_test = solution[k] * np.real(
utils.ergMIMOCapacityCDITCSIR(
H[k, :, :], ptx / noisepower[k])) * linkBandwidth # bps
np.testing.assert_almost_equal(rate_test, rate)
def OFDMA_BA(bitloadPerUser, pPerResource, systemBandwidth, totalTime,
noiseIfPowerPerResource, CSI):
"""The considered State of the Art comparison. Allocated target bitload over resources at an equal power share until user target is fulfilled. If the load is too high, np.nan is returned.
Input:
bitload: array of bit load by user index
pPerResource: (N,T) power level
systemBandwidth: in Hz
totalTime: in seconds
noiseIfPowerPerResource: noise plus interference power (N,T)
CSI: (n_tx, n_rx, N,T)
Output:
lastUsedResource: Flattened CSI index where allocation finished."""
N = CSI.shape[2]
T = CSI.shape[3]
K = CSI.shape[4]
resourceTime = totalTime / T
resourceBandwidth = systemBandwidth / N
pTxBA = np.empty([rateSteps])
pTxBA[:] = np.nan
baseSNR = pPerResource / (noiseIfPowerPerResource)
#user = np.random.permutation(K)[0]
user = 0
usedRBCounter = np.zeros(T)
flag = False
for n in np.arange(N):
for t in np.arange(T):
usedRBCounter[t] = usedRBCounter[t] + 1
H = CSI[:, :, n, t, user]
bitsInThisRB = resourceBandwidth * resourceTime * np.real(
utils.ergMIMOCapacityCDITCSIR(H, baseSNR[n, t, user]))
bitloadPerUser[user] = bitloadPerUser[user] - bitsInThisRB
if bitloadPerUser[user] <= 0:
user = user + 1
if user >= K:
flag = True
break
if flag:
break
if (bitloadPerUser < 0).all():
pTxBA = pPerResource[0, 0, 0] * usedRBCounter
return pTxBA
def OFDMA_BA(bitloadPerUser, pPerResource, systemBandwidth, totalTime, noiseIfPowerPerResource, CSI):
"""The considered State of the Art comparison. Allocated target bitload over resources at an equal power share until user target is fulfilled. If the load is too high, np.nan is returned.
Input:
bitload: array of bit load by user index
pPerResource: (N,T) power level
systemBandwidth: in Hz
totalTime: in seconds
noiseIfPowerPerResource: noise plus interference power (N,T)
CSI: (n_tx, n_rx, N,T)
Output:
lastUsedResource: Flattened CSI index where allocation finished."""
N = CSI.shape[2]
T = CSI.shape[3]
K = CSI.shape[4]
resourceTime = totalTime / T
resourceBandwidth = systemBandwidth / N
pTxBA = np.empty([rateSteps])
pTxBA[:] = np.nan
baseSNR = pPerResource / (noiseIfPowerPerResource)
#user = np.random.permutation(K)[0]
user = 0
usedRBCounter = np.zeros(T)
flag = False
for n in np.arange(N):
for t in np.arange(T):
usedRBCounter[t] = usedRBCounter[t] + 1
H = CSI[:,:,n,t,user]
bitsInThisRB = resourceBandwidth * resourceTime * np.real(utils.ergMIMOCapacityCDITCSIR(H, baseSNR[n,t,user]))
bitloadPerUser[user] = bitloadPerUser[user] - bitsInThisRB
if bitloadPerUser[user] <= 0:
user = user+1
if user >= K:
flag = True
break
if flag:
break
if (bitloadPerUser<0).all():
pTxBA = pPerResource[0,0,0] * usedRBCounter
return pTxBA
def test_optimPCDTX(self):
# test for simple problem with known outcome
H = np.array([[[1.-1j,-1.],[-1.,1.]],[[1.-1j,1.],[-1.,1.]],[[0.5,1.j],[1.,-1.j]]])
for k in np.arange(3):
H[k,:,:] = scipy.dot(H[k,:,:], H[k,:,:].conj().T)
noisepower = np.ones(3)
rate = 1
linkBandwidth = 1
p0 = 10
m = 2
pS = 5
pMax = 10
obj, solution, status = optimMinPow.optimizePCDTX(H, noisepower, rate, linkBandwidth, pMax, p0, m, pS, 0)
answerObj = 13.9204261
answerSol = np.array([ 0.32342002, 0.24371824, 0.27855287, 0.15430887])
np.testing.assert_almost_equal(obj, answerObj)
np.testing.assert_almost_equal(solution, answerSol)
for k in np.arange(H.shape[0]):
ptx = optimMinPow2x2DTX.ptxOfMu(solution[k], rate, linkBandwidth, noisepower[k], H[k,:,:])
rate_test = solution[k]*np.real(utils.ergMIMOCapacityCDITCSIR(H[k,:,:], ptx))
np.testing.assert_almost_equal(rate_test, rate)
def test_optimPCDTX_trivial(self):
# test for simple problem with known outcome
H = np.ones([3,2,2])
for k in np.arange(3):
H[k,:,:] = scipy.dot(H[k,:,:], H[k,:,:].conj().T)
noisepower = np.ones(3)
rate = 1
linkBandwidth = 1
p0 = 10
m = 2
pS = 5
pMax = 10
obj, solution, status = optimMinPow.optimizePCDTX(H, noisepower, rate, linkBandwidth, pMax, p0, m, pS, 0)
answerObj = 17.000000115485285
answerSol = np.array([ 0.33333334, 0.33333334, 0.33333334, 0. ])
np.testing.assert_almost_equal(obj, answerObj)
np.testing.assert_almost_equal(solution, answerSol)
for k in np.arange(H.shape[0]):
ptx = optimMinPow2x2DTX.ptxOfMu(solution[k], rate, linkBandwidth, noisepower[k], H[k,:,:])
rate_test = solution[k]*np.real(utils.ergMIMOCapacityCDITCSIR(H[k,:,:], ptx))
np.testing.assert_almost_equal(rate_test, rate)
def test_optimPCDTXrandomChannel(self):
# test for simple problem with known outcome
users = 22
n_tx = 2
n_rx = 2
H = np.empty([users, n_tx, n_rx],dtype=complex) # very important to make it complex!
for k in np.arange(users):
H[k,:,:] = 10e-7*utils.rayleighChannel(n_tx,n_rx)
H[k,:,:] = scipy.dot(H[k,:,:], H[k,:,:].conj().T)
noisepower = np.ones(users) * 4e-14
rate = 1.2e7/users # bps
linkBandwidth = 1e7
p0 = 100
m = 2.4
pS = 50
pMax = 40
obj, solution, status = optimMinPow.optimizePCDTX(H, noisepower, rate, linkBandwidth, pMax, p0, m, pS, 0)
# Test that all calls were correct and their order. What goes in must come out.
for k in np.arange(users):
ptx = optimMinPow2x2DTX.ptxOfMu(solution[k], rate, linkBandwidth, noisepower[k], H[k,:,:]) # power as a function of the MIMO link
rate_test = solution[k]*np.real(utils.ergMIMOCapacityCDITCSIR(H[k,:,:], ptx/noisepower[k]))*linkBandwidth # bps
np.testing.assert_almost_equal(rate_test, rate)
def RB_bit_capacity(mobile, n, t, bw, time, power):
"""Bit capacity of resource block"""
return bw * time * np.real(
utils.ergMIMOCapacityCDITCSIR(mobile.OFDMA_EC[:, :, n, t], power))
def ba(rate, wrld, cell, mobiles, users):
"""The considered State of the Art comparison. Allocated target bitload over resources at an equal power share until user target is fulfilled. If the load is too high, np.nan is returned.
Input:
bitload: array of bit load by user index
pPerResource: (N,T) power level
systemBandwidth: in Hz
totalTime: in seconds
noiseIfPowerPerResource: noise plus interference power (N,T)
CSI: (n_tx, n_rx, N,T)
Output:
lastUsedResource: Flattened CSI index where allocation finished."""
N = wrld.PHY.numFreqChunks
T = wrld.PHY.numTimeslots
K = users
bitloadPerUser = rate * wrld.PHY.simulationTime * np.ones(users)
pPerResource = np.ones([N, T, users]) * cell.pMax / N
systemBandwidth = wrld.PHY.systemBandwidth
totalTime = wrld.PHY.simulationTime
pSupplyBA = np.nan
CSI_BA = np.empty([2, 2, N, T, users], dtype=complex)
CSI_BA[:] = np.nan
noiseIfPowerPerResource = np.empty([N, T, users])
noiseIfPowerPerResource[:] = np.nan
for idx, obj in enumerate(mobiles):
CSI_BA[:, :, :, :,
idx] = obj.baseStations[obj.BS]['cells'][cell]['CSI_OFDMA']
noiseIfPowerPerResource[:, :,
idx] = obj.noiseIfPower * np.ones([N, T]) / N
resourceTime = totalTime / T
resourceBandwidth = systemBandwidth / N
baseSNR = pPerResource / (noiseIfPowerPerResource)
user = 0
usedRBCounter = np.zeros(T)
flag = False
for n in np.arange(N):
for t in np.arange(T):
usedRBCounter[t] = usedRBCounter[t] + 1
H = np.dot(CSI_BA[:, :, n, t, user], CSI_BA[:, :, n, t,
user].conj().T)
bitsInThisRB = resourceBandwidth * resourceTime * np.real(
utils.ergMIMOCapacityCDITCSIR(H, baseSNR[n, t, user]))
bitloadPerUser[user] = bitloadPerUser[user] - bitsInThisRB
if bitloadPerUser[user] <= 0:
user = user + 1
if user >= K:
flag = True
break
if flag:
break
if (bitloadPerUser < 0).all():
pTxBA = pPerResource[0, 0, 0] * usedRBCounter
pSupplyBA = scistats.nanmean(mobiles[0].BS.p0 +
mobiles[0].BS.m * pTxBA)
else:
logger.warning('SOTA overload.')
pSupplyBA = np.nan
logger.info('{0:50} {1:5.2f} W'.format('SOTA objective:', pSupplyBA))
return pSupplyBA
def RB_bit_capacity(mobile, n, t, bw, time, power):
"""Bit capacity of resource block"""
return int(bw * time * np.real(utils.ergMIMOCapacityCDITCSIR(mobile.OFDMA_EC[:,:,n,t], power)) )
def ba(rate, wrld, cell, mobiles, users):
"""The considered State of the Art comparison. Allocated target bitload over resources at an equal power share until user target is fulfilled. If the load is too high, np.nan is returned.
Input:
bitload: array of bit load by user index
pPerResource: (N,T) power level
systemBandwidth: in Hz
totalTime: in seconds
noiseIfPowerPerResource: noise plus interference power (N,T)
CSI: (n_tx, n_rx, N,T)
Output:
lastUsedResource: Flattened CSI index where allocation finished."""
N = wrld.PHY.numFreqChunks
T = wrld.PHY.numTimeslots
K = users
bitloadPerUser = rate * wrld.PHY.simulationTime * np.ones(users)
pPerResource = np.ones([N,T,users])*cell.pMax/N
systemBandwidth = wrld.PHY.systemBandwidth
totalTime = wrld.PHY.simulationTime
pSupplyBA = np.nan
CSI_BA = np.empty([2,2,N,T, users], dtype=complex)
CSI_BA[:] = np.nan
noiseIfPowerPerResource = np.empty([N,T,users])
noiseIfPowerPerResource[:] = np.nan
for idx, obj in enumerate(mobiles):
CSI_BA[:,:,:,:,idx] = obj.baseStations[obj.BS]['cells'][cell]['CSI_OFDMA']
noiseIfPowerPerResource[:,:,idx] = obj.noiseIfPower * np.ones([N,T]) / N
resourceTime = totalTime / T
resourceBandwidth = systemBandwidth / N
baseSNR = pPerResource / (noiseIfPowerPerResource)
user = 0
usedRBCounter = np.zeros(T)
flag = False
for n in np.arange(N):
for t in np.arange(T):
usedRBCounter[t] = usedRBCounter[t] + 1
H = np.dot(CSI_BA[:,:,n,t,user], CSI_BA[:,:,n,t,user].conj().T)
bitsInThisRB = resourceBandwidth * resourceTime * np.real(utils.ergMIMOCapacityCDITCSIR(H, baseSNR[n,t,user]))
bitloadPerUser[user] = bitloadPerUser[user] - bitsInThisRB
if bitloadPerUser[user] <= 0:
user = user+1
if user >= K:
flag = True
break
if flag:
break
if (bitloadPerUser<0).all():
pTxBA = pPerResource[0,0,0] * usedRBCounter
pSupplyBA = scistats.nanmean(mobiles[0].BS.p0 + mobiles[0].BS.m * pTxBA)
else:
logger.warning( 'SOTA overload.')
pSupplyBA = np.nan
logger.info( '{0:50} {1:5.2f} W'.format('SOTA objective:', pSupplyBA))
return pSupplyBA
