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