def _run_simulation(self, current_parameters):
"""The _run_simulation method is where the actual code to simulate
the system is.
The implementation of this method is required by every subclass of
SimulationRunner.
"""
# xxxxx Input parameters (set in the constructor) xxxxxxxxxxxxxxxxx
NSymbs = current_parameters['NSymbs']
modulator = current_parameters['modulator']
M = modulator.M
SNR = current_parameters["SNR"]
# xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
# xxxxx Input Data xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
inputData = np.random.randint(0, M, NSymbs)
# xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
# xxxxx Modulate input data xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
modulatedData = modulator.modulate(inputData)
# xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
# xxxxx Pass through the channel xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
noiseVar = 1. / dB2Linear(SNR)
noise = misc.randn_c(NSymbs) * np.sqrt(noiseVar)
receivedData = modulatedData + noise
# xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
# xxxxx Demodulate received data xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
demodulatedData = modulator.demodulate(receivedData)
# xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
# xxxxx Calculates the symbol and bit error rates xxxxxxxxxxxxxxxxx
symbolErrors = sum(inputData != demodulatedData)
bitErrors = misc.count_bit_errors(inputData, demodulatedData)
numSymbols = inputData.size
numBits = inputData.size * fundamental.level2bits(M)
# xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
# xxxxx Return the simulation results xxxxxxxxxxxxxxxxxxxxxxxxxxxxx
symbolErrorsResult = Result.create("symbol_errors", Result.SUMTYPE,
symbolErrors)
numSymbolsResult = Result.create("num_symbols", Result.SUMTYPE,
numSymbols)
bitErrorsResult = Result.create("bit_errors", Result.SUMTYPE, bitErrors)
numBitsResult = Result.create("num_bits", Result.SUMTYPE, numBits)
berResult = Result.create("ber", Result.RATIOTYPE, bitErrors, numBits)
serResult = Result.create("ser", Result.RATIOTYPE, symbolErrors,
numSymbols)
simResults = SimulationResults()
simResults.add_result(symbolErrorsResult)
simResults.add_result(numSymbolsResult)
simResults.add_result(bitErrorsResult)
simResults.add_result(numBitsResult)
simResults.add_result(berResult)
simResults.add_result(serResult)
# xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
return simResults
# Pass the precoded data through the channel
received_signal = multiuser_channel.corrupt_concatenated_data(all_data)
# Filter the received data
receive_filter = np.linalg.pinv(newH)
received_symbols = np.dot(receive_filter, received_signal)
# Demodulate the filtered symbols
decoded_symbols = modulator.demodulate(received_symbols)
# Calculates the number of symbol errors
num_symbol_errors += np.sum(decoded_symbols != input_data)
num_symbols += input_data.size
# Calculates the number of bit errors
num_bit_errors += misc.count_bit_errors(input_data, decoded_symbols)
num_bits += input_data.size * fundamental.level2bits(M)
pbar.progress(rep + 1)
# Calculate the Symbol Error Rate
print()
print(num_symbol_errors)
print(num_symbols)
print("SER: {0}".format(float(num_symbol_errors) / float(num_symbols)))
print("BER: {0}".format(float(num_bit_errors) / float(num_bits)))
# xxxxxxxxxx Finished xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
toc = time()
print(misc.pretty_time(toc - tic))
def _run_simulation(self, current_parameters): # pylint: disable=R0914,R0915
# xxxxxxxxxx Prepare the scenario for this iteration. xxxxxxxxxxxxx
# This will create user in random positons and calculate pathloss
# (if the scenario includes it). After that, it will generate
# random channels from all transmitters to all receivers.
self._create_users_channels_according_to_scenario(current_parameters)
# xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
# xxxxx Input parameters (set in the constructor) xxxxxxxxxxxxxxxxx
M = self.modulator.M
NSymbs = current_parameters["NSymbs"]
K = current_parameters["num_cells"]
# Nr = current_parameters["Nr"]
# Nt = current_parameters["Nt"]
Ns = current_parameters["Ns"]
SNR = current_parameters["SNR"]
if current_parameters["scenario"] == "NoPathLoss":
pt = self._calc_transmit_power(SNR, self.noise_var)
elif current_parameters["scenario"] == "Random":
pt = self._calc_transmit_power(SNR, self.noise_var, self._path_loss_border)
else:
raise ValueError("Invalid scenario")
# Store the original (maximum) number of streams for each user for
# later usage
if isinstance(Ns, int):
orig_Ns = np.ones(K, dtype=int) * Ns
else:
orig_Ns = Ns.copy()
# xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
# xxxxx Calc. precoders and receive filters for IA xxxxxxxxxxxxxxxx
# We need to perform IA before generating any data so that we know
# how many streams we need to send (and thus generate data. Note
# that it is not always equal to Ns. It can be lower for some user
# if the IA algorithm chooses a precoder that sends zero energy in
# some stream.
self.ia_solver.clear()
self.ia_solver.initialize_with = current_parameters["initialize_with"]
try:
self.ia_top_object.solve(Ns=Ns, P=pt)
except (RuntimeError, LinAlgError):
raise SkipThisOne("Could not find the IA solution. Skipping this repetition")
# If any of the Nr, Nt or Ns variables were integers (meaning all
# users have the same value) we will convert them by numpy arrays
# with correct size (K).
# Nr = self.ia_solver.Nr
# Nt = self.ia_solver.Nt
Ns = self.ia_solver.Ns
cumNs = np.cumsum(self.ia_solver.Ns)
# xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
# xxxxx Input Data xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
# inputData has the data of all users (vertically stacked)
inputData = self.data_RS.randint(0, M, [np.sum(Ns), NSymbs])
# xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
# xxxxx Modulate input data xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
# modulatedData has the data of all users (vertically stacked)
modulatedData = self.modulator.modulate(inputData)
# xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
# xxxxxxxxxx Perform the Interference Alignment xxxxxxxxxxxxxxxxxxx
# Split the data. transmit_signal will be a list and each element
# is a numpy array with the data of a user
transmit_signal = np.split(modulatedData, cumNs[:-1])
transmit_signal_precoded = map(np.dot, self.ia_solver.full_F, transmit_signal)
# xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
# xxxxx Pass through the channel xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
# noinspection PyProtectedMember
multi_user_channel = self.ia_solver._multiUserChannel
# received_data is an array of matrices, one matrix for each receiver.
received_data = multi_user_channel.corrupt_data(transmit_signal_precoded)
# xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
# xxxxx Perform the Interference Cancelation xxxxxxxxxxxxxxxxxxxxxx
received_data_no_interference = map(np.dot, self.ia_solver.full_W_H, received_data)
# xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
# xxxxx Demodulate Data xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
received_data_no_interference = np.vstack(received_data_no_interference)
demodulated_data = self.modulator.demodulate(received_data_no_interference)
# xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
# xxxxx Calculates the symbol and bit error rates xxxxxxxxxxxxxxxxx
symbolErrors = np.sum(inputData != demodulated_data)
bitErrors = misc.count_bit_errors(inputData, demodulated_data)
numSymbols = inputData.size
numBits = inputData.size * fundamental.level2bits(M)
ia_cost = self.ia_solver.get_cost()
# xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
# xxxxxxxxxx Calculates the Sum Capacity xxxxxxxxxxxxxxxxxxxxxxxxxx
sirn_all_k = self.ia_solver.calc_SINR()
calc_capacity = lambda sirn: np.sum(np.log2(1 + sirn))
# Array with the sum capacity of each user
sum_capacity = list(map(calc_capacity, sirn_all_k))
# Total sum capacity
total_sum_capacity = np.sum(sum_capacity)
# xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
# xxxxxxxxxx Number of iterations of the IA algorithm xxxxxxxxxxxxx
ia_runned_iterations = self.ia_solver.runned_iterations
# xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
# xxxxx Return the simulation results xxxxxxxxxxxxxxxxxxxxxxxxxxxxx
symbolErrorsResult = Result.create("symbol_errors", Result.SUMTYPE, symbolErrors)
numSymbolsResult = Result.create("num_symbols", Result.SUMTYPE, numSymbols)
bitErrorsResult = Result.create("bit_errors", Result.SUMTYPE, bitErrors)
numBitsResult = Result.create("num_bits", Result.SUMTYPE, numBits)
berResult = Result.create("ber", Result.RATIOTYPE, bitErrors, numBits, accumulate_values=False)
serResult = Result.create("ser", Result.RATIOTYPE, symbolErrors, numSymbols, accumulate_values=False)
ia_costResult = Result.create("ia_cost", Result.RATIOTYPE, ia_cost, 1, accumulate_values=False)
sum_capacityResult = Result.create(
"sum_capacity", Result.RATIOTYPE, total_sum_capacity, 1, accumulate_values=False
)
ia_runned_iterationsResult = Result.create(
"ia_runned_iterations", Result.RATIOTYPE, ia_runned_iterations, 1, accumulate_values=False
)
# xxxxxxxxxx chosen stream configuration index xxxxxxxxxxxxxxxxxxxx
# Interpret Ns as a multidimensional index
stream_index_multi = Ns - 1
# Convert to a 1D index suitable for storing
stream_index = int(np.ravel_multi_index(stream_index_multi, orig_Ns))
num_choices = int(np.prod(orig_Ns))
stream_statistics = Result.create("stream_statistics", Result.CHOICETYPE, stream_index, num_choices)
# xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
simResults = SimulationResults()
simResults.add_result(symbolErrorsResult)
simResults.add_result(numSymbolsResult)
simResults.add_result(bitErrorsResult)
simResults.add_result(numBitsResult)
simResults.add_result(berResult)
simResults.add_result(serResult)
simResults.add_result(ia_costResult)
simResults.add_result(sum_capacityResult)
simResults.add_result(ia_runned_iterationsResult)
simResults.add_result(stream_statistics)
# xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
return simResults
# Pass the precoded data through the channel
received_signal = multiuser_channel.corrupt_concatenated_data(all_data)
# Filter the received data
receive_filter = np.linalg.pinv(newH)
received_symbols = np.dot(receive_filter, received_signal)
# Demodulate the filtered symbols
decoded_symbols = modulator.demodulate(received_symbols)
# Calculates the number of symbol errors
num_symbol_errors += np.sum(decoded_symbols != input_data)
num_symbols += input_data.size
# Calculates the number of bit errors
num_bit_errors += misc.count_bit_errors(input_data, decoded_symbols)
num_bits += input_data.size * fundamental.level2bits(M)
pbar.progress(rep + 1)
# Calculate the Symbol Error Rate
print()
print(num_symbol_errors)
print(num_symbols)
print("SER: {0}".format(float(num_symbol_errors) / float(num_symbols)))
print("BER: {0}".format(float(num_bit_errors) / float(num_bits)))
# xxxxxxxxxx Finished xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
toc = time()
print(misc.pretty_time(toc - tic))
def __simulate_for_one_metric(self, Ns_all_users,
external_int_data_all_metrics,
MsPk_all_users, Wk_all_users, metric_name,
current_parameters):
"""
This method is only called inside the _run_simulation method.
This method has the common code that is execute for each metric
inside the _run_simulation method.
Parameters
----------
Ns_all_users : np.ndarray
Number of streams for each user. This variable controls how
many data streams will be generated for each user of the K
users. This is a 1D numpy array of size K.
external_int_data_all_metrics : np.ndarray
The data of the external interference sources (2D numpy array).
MsPk_all_users : np.ndarray
The precoders of all users returned by the block diagonalize
method for the given metric. This is a 1D numpy array of 2D numpy
arrays.
Wk_all_users : np.ndarray
The receive filter for all users (1D numpy array of 2D numpy
arrays).
metric_name : string
Metric name. This string will be appended to each result name.
Returns
-------
TODO: Write the rest of the docstring
"""
# pylint: disable=R0914
Ns_total = np.sum(Ns_all_users)
self.data_RS = np.random.RandomState(self.data_gen_seed)
input_data = self.data_RS.randint(
0, current_parameters['M'],
[Ns_total, current_parameters['NSymbs']])
symbols = self.modulator.modulate(input_data)
# Prepare the transmit data. That is, the precoded_data as well as
# the external interference sources' data.
precoded_data = np.dot(np.hstack(MsPk_all_users), symbols)
# external_int_data_all_metrics = (
# np.sqrt(self.pe)
# * misc.randn_c_RS(
# self.ext_data_RS, self.ext_int_rank, self.NSymbs))
all_data = np.vstack([precoded_data, external_int_data_all_metrics])
# xxxxxxxxxx Pass the precoded data through the channel xxxxxxxxxxx
self.multiuser_channel.set_noise_seed(self.noise_seed)
received_signal = self.multiuser_channel.corrupt_concatenated_data(
all_data)
# xxxxxxxxxx Filter the received data xxxxxxxxxxxxxxxxxxxxxxxxxxxxx
# noinspection PyArgumentList
Wk = block_diag(*Wk_all_users)
received_symbols = np.dot(Wk, received_signal)
# xxxxxxxxxx Demodulate the filtered symbols xxxxxxxxxxxxxxxxxxxxxx
decoded_symbols = self.modulator.demodulate(received_symbols)
# xxxxxxxxxx Calculates the Symbol Error Rate xxxxxxxxxxxxxxxxxxxxx
num_symbol_errors = np.sum(decoded_symbols != input_data, 1)
# num_symbol_errors = sum_user_data(num_symbol_errors,
# Ns_all_users)
num_symbols = np.ones(Ns_total) * input_data.shape[1]
# xxxxxxxxxx Calculates the Bit Error Rate xxxxxxxxxxxxxxxxxxxxxxxx
num_bit_errors = misc.count_bit_errors(decoded_symbols, input_data, 1)
# num_bit_errors = sum_user_data(num_bit_errors,
# Ns_all_users)
num_bits = num_symbols * np.log2(current_parameters['M'])
# xxxxxxxxxx Calculates the Package Error Rate xxxxxxxxxxxxxxxxxxxx
ber = num_bit_errors / num_bits
per = 1. - ((1. - ber)**current_parameters['packet_length'])
num_packages = num_bits / current_parameters['packet_length']
num_package_errors = per * num_packages
# xxxxxxxxxx Calculates the Spectral Efficiency xxxxxxxxxxxxxxxxxxx
# nominal spectral Efficiency per stream
nominal_spec_effic = self.modulator.K
effective_spec_effic = (1 - per) * nominal_spec_effic
# xxxxx Map the per stream metric to a global metric xxxxxxxxxxxxxx
num_bit_errors = np.sum(num_bit_errors)
num_bits = np.sum(num_bits)
num_symbol_errors = np.sum(num_symbol_errors)
num_symbols = np.sum(num_symbols)
num_package_errors = np.sum(num_package_errors)
num_packages = np.sum(num_packages)
effective_spec_effic = np.sum(effective_spec_effic)
# xxxxx Calculate teh SINR xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
Uk_all_users = np.empty(Wk_all_users.size, dtype=np.ndarray)
for ii in range(Wk_all_users.size):
Uk_all_users[ii] = Wk_all_users[ii].conjugate().T
SINR_all_k = self.multiuser_channel.calc_JP_SINR(
MsPk_all_users, Uk_all_users)
# xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
# None metric
ber_result = Result.create('ber_{0}'.format(metric_name),
Result.RATIOTYPE, num_bit_errors, num_bits)
ser_result = Result.create('ser_{0}'.format(metric_name),
Result.RATIOTYPE, num_symbol_errors,
num_symbols)
per_result = Result.create('per_{0}'.format(metric_name),
Result.RATIOTYPE, num_package_errors,
num_packages)
spec_effic_result = Result.create('spec_effic_{0}'.format(metric_name),
Result.RATIOTYPE,
effective_spec_effic, 1)
sinr_result = Result('sinr_{0}'.format(metric_name),
Result.RATIOTYPE,
accumulate_values=True)
for k in range(Wk_all_users.size):
sinr_k = SINR_all_k[k]
for value in sinr_k:
sinr_result.update(value, 1)
return (ber_result, ser_result, per_result, spec_effic_result,
sinr_result)
def _run_simulation(self, current_parameters):
"""The _run_simulation method is where the actual code to simulate
the system is.
The implementation of this method is required by every subclass of
SimulationRunner.
"""
# xxxxx Input parameters (set in the constructor) xxxxxxxxxxxxxxxxx
NSymbs = current_parameters['NSymbs']
modulator = current_parameters['modulator']
M = modulator.M
SNR = current_parameters["SNR"]
# xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
# xxxxx Input Data xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
inputData = np.random.randint(0, M, NSymbs)
# xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
# xxxxx Modulate input data xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
modulatedData = modulator.modulate(inputData)
# xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
# xxxxx Pass through the channel xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
noiseVar = 1. / dB2Linear(SNR)
noise = misc.randn_c(NSymbs) * np.sqrt(noiseVar)
receivedData = modulatedData + noise
# xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
# xxxxx Demodulate received data xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
demodulatedData = modulator.demodulate(receivedData)
# xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
# xxxxx Calculates the symbol and bit error rates xxxxxxxxxxxxxxxxx
symbolErrors = sum(inputData != demodulatedData)
bitErrors = misc.count_bit_errors(inputData, demodulatedData)
numSymbols = inputData.size
numBits = inputData.size * fundamental.level2bits(M)
# xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
# xxxxx Return the simulation results xxxxxxxxxxxxxxxxxxxxxxxxxxxxx
symbolErrorsResult = Result.create(
"symbol_errors", Result.SUMTYPE, symbolErrors)
numSymbolsResult = Result.create(
"num_symbols", Result.SUMTYPE, numSymbols)
bitErrorsResult = Result.create(
"bit_errors", Result.SUMTYPE, bitErrors)
numBitsResult = Result.create("num_bits", Result.SUMTYPE, numBits)
berResult = Result.create("ber", Result.RATIOTYPE, bitErrors, numBits)
serResult = Result.create(
"ser", Result.RATIOTYPE, symbolErrors, numSymbols)
simResults = SimulationResults()
simResults.add_result(symbolErrorsResult)
simResults.add_result(numSymbolsResult)
simResults.add_result(bitErrorsResult)
simResults.add_result(numBitsResult)
simResults.add_result(berResult)
simResults.add_result(serResult)
# xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
return simResults
def _run_simulation(
self, # pylint: disable=R0914,R0915
current_parameters):
# xxxxxxxxxx Prepare the scenario for this iteration. xxxxxxxxxxxxx
# This will create user in random positions and calculate pathloss
# (if the scenario includes it). After that, it will generate
# random channels from all transmitters to all receivers.
self._create_users_channels_according_to_scenario(current_parameters)
# xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
# xxxxx Input parameters (set in the constructor) xxxxxxxxxxxxxxxxx
M = self.modulator.M
NSymbs = current_parameters["NSymbs"]
K = current_parameters["num_cells"]
# Nr = current_parameters["Nr"]
# Nt = current_parameters["Nt"]
Ns = current_parameters["Ns"]
SNR = current_parameters["SNR"]
if current_parameters['scenario'] == 'NoPathLoss':
pt = self._calc_transmit_power(SNR, self.noise_var)
elif current_parameters['scenario'] == 'Random':
pt = self._calc_transmit_power(SNR, self.noise_var,
self._path_loss_border)
else:
raise ValueError('Invalid scenario')
# Store the original (maximum) number of streams for each user for
# later usage
if isinstance(Ns, int):
orig_Ns = np.ones(K, dtype=int) * Ns
else:
orig_Ns = Ns.copy()
# xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
# xxxxx Calc. precoders and receive filters for IA xxxxxxxxxxxxxxxx
# We need to perform IA before generating any data so that we know
# how many streams we need to send (and thus generate data. Note
# that it is not always equal to Ns. It can be lower for some user
# if the IA algorithm chooses a precoder that sends zero energy in
# some stream.
self.ia_solver.clear()
self.ia_solver.initialize_with = current_parameters['initialize_with']
try:
self.ia_top_object.solve(Ns=Ns, P=pt)
except (RuntimeError, LinAlgError):
raise SkipThisOne(
"Could not find the IA solution. Skipping this repetition")
# If any of the Nr, Nt or Ns variables were integers (meaning all
# users have the same value) we will convert them by numpy arrays
# with correct size (K).
# Nr = self.ia_solver.Nr
# Nt = self.ia_solver.Nt
Ns = self.ia_solver.Ns
cumNs = np.cumsum(self.ia_solver.Ns)
# xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
# xxxxx Input Data xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
# inputData has the data of all users (vertically stacked)
inputData = self.data_RS.randint(0, M, [np.sum(Ns), NSymbs])
":type: np.ndarray"
# xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
# xxxxx Modulate input data xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
# modulatedData has the data of all users (vertically stacked)
modulatedData = self.modulator.modulate(inputData)
# xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
# xxxxxxxxxx Perform the Interference Alignment xxxxxxxxxxxxxxxxxxx
# Split the data. transmit_signal will be a list and each element
# is a numpy array with the data of a user
transmit_signal = np.split(modulatedData, cumNs[:-1])
transmit_signal_precoded = map(np.dot, self.ia_solver.full_F,
transmit_signal)
# xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
# xxxxx Pass through the channel xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
# noinspection PyProtectedMember
multi_user_channel = self.ia_solver._multiUserChannel
# received_data is an array of matrices, one matrix for each receiver.
received_data = multi_user_channel.corrupt_data(
transmit_signal_precoded)
# xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
# xxxxx Perform the Interference Cancellation xxxxxxxxxxxxxxxxxxxxx
received_data_no_interference = map(np.dot, self.ia_solver.full_W_H,
received_data)
# xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
# xxxxx Demodulate Data xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
received_data_no_interference = np.vstack(
received_data_no_interference)
demodulated_data = self.modulator.demodulate(
received_data_no_interference)
# xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
# xxxxx Calculates the symbol and bit error rates xxxxxxxxxxxxxxxxx
symbolErrors = np.sum(inputData != demodulated_data)
bitErrors = misc.count_bit_errors(inputData, demodulated_data)
numSymbols = inputData.size
numBits = inputData.size * fundamental.level2bits(M)
ia_cost = self.ia_solver.get_cost()
# xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
# xxxxxxxxxx Calculates the Sum Capacity xxxxxxxxxxxxxxxxxxxxxxxxxx
sirn_all_k = self.ia_solver.calc_SINR()
calc_capacity = lambda sirn: np.sum(np.log2(1 + sirn))
# Array with the sum capacity of each user
sum_capacity = list(map(calc_capacity, sirn_all_k))
# Total sum capacity
total_sum_capacity = np.sum(sum_capacity)
# xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
# xxxxxxxxxx Number of iterations of the IA algorithm xxxxxxxxxxxxx
ia_runned_iterations = self.ia_solver.runned_iterations
# xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
# xxxxx Return the simulation results xxxxxxxxxxxxxxxxxxxxxxxxxxxxx
symbolErrorsResult = Result.create("symbol_errors", Result.SUMTYPE,
symbolErrors)
numSymbolsResult = Result.create("num_symbols", Result.SUMTYPE,
numSymbols)
bitErrorsResult = Result.create("bit_errors", Result.SUMTYPE,
bitErrors)
numBitsResult = Result.create("num_bits", Result.SUMTYPE, numBits)
berResult = Result.create("ber",
Result.RATIOTYPE,
bitErrors,
numBits,
accumulate_values=False)
serResult = Result.create("ser",
Result.RATIOTYPE,
symbolErrors,
numSymbols,
accumulate_values=False)
ia_costResult = Result.create("ia_cost",
Result.RATIOTYPE,
ia_cost,
1,
accumulate_values=False)
sum_capacityResult = Result.create("sum_capacity",
Result.RATIOTYPE,
total_sum_capacity,
1,
accumulate_values=False)
ia_runned_iterationsResult = Result.create("ia_runned_iterations",
Result.RATIOTYPE,
ia_runned_iterations,
1,
accumulate_values=False)
# xxxxxxxxxx chosen stream configuration index xxxxxxxxxxxxxxxxxxxx
# Interpret Ns as a multidimensional index
stream_index_multi = Ns - 1
# Convert to a 1D index suitable for storing
stream_index = int(np.ravel_multi_index(stream_index_multi, orig_Ns))
num_choices = int(np.prod(orig_Ns))
stream_statistics = Result.create("stream_statistics",
Result.CHOICETYPE, stream_index,
num_choices)
# xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
simResults = SimulationResults()
simResults.add_result(symbolErrorsResult)
simResults.add_result(numSymbolsResult)
simResults.add_result(bitErrorsResult)
simResults.add_result(numBitsResult)
simResults.add_result(berResult)
simResults.add_result(serResult)
simResults.add_result(ia_costResult)
simResults.add_result(sum_capacityResult)
simResults.add_result(ia_runned_iterationsResult)
simResults.add_result(stream_statistics)
# xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
return simResults
def _run_simulation(self, # pylint: disable=R0914,R0915
current_parameters):
# xxxxx Input parameters (set in the constructor) xxxxxxxxxxxxxxxxx
M = self.modulator.M
NSymbs = current_parameters["NSymbs"]
K = current_parameters["K"]
Nr = current_parameters["Nr"]
Nt = current_parameters["Nt"]
Ns = current_parameters["Ns"]
SNR = current_parameters["SNR"]
# Dependent parameters
noise_var = 1 / dB2Linear(SNR)
# xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
# xxxxx Calc. precoders and receive filters for IA xxxxxxxxxxxxxxxx
# We need to perform IA before generating any data so that we know
# how many streams we need to send (and thus generate data. Note
# that it is not always equal to Ns. It can be lower for some user
# if the IA algorithm chooses a precoder that sends zero energy in
# some stream.
self.multiUserChannel.randomize(Nr, Nt, K)
self.multiUserChannel.noise_var = noise_var
self.ia_solver.clear()
self.ia_solver.solve(Ns)
# If any of the Nr, Nt or Ns variables were integers (meaning all
# users have the same value) we will convert them by numpy arrays
# with correct size (K).
# Nr = self.ia_solver.Nr
# Nt = self.ia_solver.Nt
Ns = self.ia_solver.Ns
cumNs = np.cumsum(self.ia_solver.Ns)
# xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
# xxxxx Input Data xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
# inputData has the data of all users (vertically stacked)
inputData = np.random.randint(0, M, [np.sum(Ns), NSymbs])
# xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
# xxxxx Modulate input data xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
# modulatedData has the data of all users (vertically stacked)
modulatedData = self.modulator.modulate(inputData)
# xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
# xxxxxxxxxx Perform the Interference Alignment xxxxxxxxxxxxxxxxxxx
# Split the data. transmit_signal will be a list and each element
# is a numpy array with the data of a user
transmit_signal = np.split(modulatedData, cumNs[:-1])
transmit_signal_precoded = map(
np.dot, self.ia_solver.full_F, transmit_signal)
# xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
# xxxxx Pass through the channel xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
# noinspection PyProtectedMember
multi_user_channel = self.ia_solver._multiUserChannel
# received_data is an array of matrices, one matrix for each receiver.
received_data = multi_user_channel.corrupt_data(
transmit_signal_precoded)
# xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
# xxxxx Perform the Interference Cancellation xxxxxxxxxxxxxxxxxxxxx
received_data_no_interference = map(
np.dot, self.ia_solver.full_W_H, received_data)
# xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
# xxxxx Demodulate Data xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
received_data_no_interference = np.vstack(
received_data_no_interference)
demodulated_data = self.modulator.demodulate(
received_data_no_interference)
# xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
# xxxxx Calculates the symbol and bit error rates xxxxxxxxxxxxxxxxx
symbolErrors = np.sum(inputData != demodulated_data)
bitErrors = misc.count_bit_errors(inputData, demodulated_data)
numSymbols = inputData.size
numBits = inputData.size * fundamental.level2bits(M)
ia_cost = self.ia_solver.get_cost()
# xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
# xxxxxxxxxx Calculates the Sum Capacity xxxxxxxxxxxxxxxxxxxxxxxxxx
sirn_all_k = self.ia_solver.calc_SINR()
calc_capacity = lambda sirn: np.sum(np.log2(1 + sirn))
# Array with the sum capacity of each user
sum_capacity = np.array(list(map(calc_capacity, sirn_all_k)))
# Total sum capacity
total_sum_capacity = np.sum(sum_capacity)
# xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
# xxxxxxxxxx Number of iterations of the IA algorithm xxxxxxxxxxxxx
ia_runned_iterations = self.ia_solver.runned_iterations
# xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
# xxxxx Return the simulation results xxxxxxxxxxxxxxxxxxxxxxxxxxxxx
symbolErrorsResult = Result.create(
"symbol_errors", Result.SUMTYPE, symbolErrors)
numSymbolsResult = Result.create(
"num_symbols", Result.SUMTYPE, numSymbols)
bitErrorsResult = Result.create(
"bit_errors", Result.SUMTYPE, bitErrors)
numBitsResult = Result.create("num_bits", Result.SUMTYPE, numBits)
berResult = Result.create("ber", Result.RATIOTYPE, bitErrors, numBits,
accumulate_values=False)
serResult = Result.create("ser", Result.RATIOTYPE, symbolErrors,
numSymbols, accumulate_values=False)
ia_costResult = Result.create(
"ia_cost", Result.RATIOTYPE, ia_cost, 1, accumulate_values=False)
sum_capacityResult = Result.create(
"sum_capacity", Result.RATIOTYPE, total_sum_capacity, 1,
accumulate_values=False)
ia_runned_iterationsResult = Result.create(
"ia_runned_iterations", Result.RATIOTYPE, ia_runned_iterations, 1,
accumulate_values=False)
simResults = SimulationResults()
simResults.add_result(symbolErrorsResult)
simResults.add_result(numSymbolsResult)
simResults.add_result(bitErrorsResult)
simResults.add_result(numBitsResult)
simResults.add_result(berResult)
simResults.add_result(serResult)
simResults.add_result(ia_costResult)
simResults.add_result(sum_capacityResult)
simResults.add_result(ia_runned_iterationsResult)
# xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
return simResults
def test_count_bit_errors(self):
a = np.random.randint(0, 16, 20)
b = np.random.randint(0, 16, 20)
expected_bit_count = np.sum(misc.count_bits(misc.xor(a, b)))
self.assertEqual(expected_bit_count, misc.count_bit_errors(a, b))
# This will cancel the interference
received_data_no_interference = map(np.dot, ia_solver.W_H,
received_data)
# xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
# xxxxx Demodulate Data xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
received_data_no_interference = np.vstack(
received_data_no_interference)
# received_data_no_interference = np.vstack(received_data_no_interference2)
demodulated_data = modulator.demodulate(received_data_no_interference)
# demodulated_data = map(modulator.demodulate, received_data_no_interference)
# xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
# xxxxx Calculates the symbol and bit error rates xxxxxxxxxxxxxxxxx
symbolErrors = symbolErrors + np.sum(inputData != demodulated_data)
bitErrors = bitErrors + misc.count_bit_errors(inputData,
demodulated_data)
numSymbols = numSymbols + inputData.size
numBits = numBits + inputData.size * fundamental.level2bits(M)
#ia_cost = ia_solver.get_cost()
# xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
print()
print(bitErrors)
print(numBits)
BER = bitErrors / numBits
print("BER: {0}".format(BER))
SINRs = multi_user_channel.calc_SINR(ia_solver.F, ia_solver.W)
sum_capacity = np.sum(np.log2(1 + np.hstack(SINRs)))
print("Sum Capacity: {0}".format(sum_capacity))
def _run_simulation(self, current_parameters):
# xxxxx Input parameters (set in the constructor) xxxxxxxxxxxxxxxxx
NSymbs = current_parameters["NSymbs"]
M = self.modulator.M
Nr = current_parameters["Nr"]
Nt = current_parameters["Nt"]
SNR = current_parameters["SNR"]
# xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
# xxxxxxxxxx Create the channel xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
channel = misc.randn_c(Nr, Nt)
self.mimo_object.set_channel_matrix(channel)
# xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
# xxxxx Input Data xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
num_layers = self.mimo_object.getNumberOfLayers()
inputData = np.random.randint(0, M, NSymbs * num_layers)
# xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
# xxxxx Modulate input data xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
modulatedData = self.modulator.modulate(inputData)
# xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
# xxxxx Encode with the MIMO scheme xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
transmit_signal = self.mimo_object.encode(modulatedData)
# xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
# xxxxx Pass through the channel xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
noiseVar = 1 / dB2Linear(SNR)
awgn_noise = (misc.randn_c(Nr, NSymbs) * np.sqrt(noiseVar))
received_signal = np.dot(channel, transmit_signal) + awgn_noise
# xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
# xxxxx Decode with the MIMO Scheme xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
mimo_decoded_data = self.mimo_object.decode(received_signal)
# xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
# xxxxx Demodulate received data xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
demodulatedData = self.modulator.demodulate(mimo_decoded_data)
# xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
# xxxxx Calculates the symbol and bit error rates xxxxxxxxxxxxxxxxx
symbolErrors = sum(inputData != demodulatedData)
bitErrors = misc.count_bit_errors(inputData, demodulatedData)
numSymbols = inputData.size
numBits = inputData.size * fundamental.level2bits(M)
# xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
# xxxxx Return the simulation results xxxxxxxxxxxxxxxxxxxxxxxxxxxxx
symbolErrorsResult = Result.create(
"symbol_errors", Result.SUMTYPE, symbolErrors)
numSymbolsResult = Result.create(
"num_symbols", Result.SUMTYPE, numSymbols)
bitErrorsResult = Result.create("bit_errors",
Result.SUMTYPE, bitErrors)
numBitsResult = Result.create("num_bits", Result.SUMTYPE, numBits)
berResult = Result.create("ber", Result.RATIOTYPE, bitErrors, numBits)
serResult = Result.create(
"ser", Result.RATIOTYPE, symbolErrors, numSymbols)
simResults = SimulationResults()
simResults.add_result(symbolErrorsResult)
simResults.add_result(numSymbolsResult)
simResults.add_result(bitErrorsResult)
simResults.add_result(numBitsResult)
simResults.add_result(berResult)
simResults.add_result(serResult)
# xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
return simResults
def __simulate_for_one_metric(self,
Ns_all_users,
external_int_data_all_metrics,
MsPk_all_users,
Wk_all_users,
metric_name,
current_parameters):
"""
This method is only called inside the _run_simulation method.
This method has the common code that is execute for each metric
inside the _run_simulation method.
Parameters
----------
Ns_all_users : 1D numpy array of size K.
Number of streams for each user. This variable controls how
many data streams will be generated for each user of the K
users.
external_int_data_all_metrics : 2D numpy array
The data of the external interference sources.
MsPk_all_users : 1D numpy array of 2D numpy arrays
The precoders of all users returned by the block diagonalize
method for the given metric.
Wk_all_users : 1D numpy array of 2D numpy arrays
The receive filter for all users.
metric_name : string
Metric name. This string will be appended to each result name.
Returns
-------
TODO: Write the rest of the docstring
"""
# pylint: disable=R0914
Ns_total = np.sum(Ns_all_users)
self.data_RS = np.random.RandomState(self.data_gen_seed)
input_data = self.data_RS.randint(
0,
current_parameters['M'],
[Ns_total, current_parameters['NSymbs']])
symbols = self.modulator.modulate(input_data)
# Prepare the transmit data. That is, the precoded_data as well as
# the external interferece sources' data.
precoded_data = np.dot(np.hstack(MsPk_all_users),
symbols)
# external_int_data_all_metrics = (
# np.sqrt(self.pe)
# * misc.randn_c_RS(
# self.ext_data_RS, self.ext_int_rank, self.NSymbs))
all_data = np.vstack([precoded_data,
external_int_data_all_metrics])
# xxxxxxxxxx Pass the precoded data through the channel xxxxxxxxxxx
self.multiuser_channel.set_noise_seed(self.noise_seed)
received_signal = self.multiuser_channel.corrupt_concatenated_data(
all_data
)
# xxxxxxxxxx Filter the received data xxxxxxxxxxxxxxxxxxxxxxxxxxxxx
# noinspection PyArgumentList
Wk = block_diag(*Wk_all_users)
received_symbols = np.dot(Wk, received_signal)
# xxxxxxxxxx Demodulate the filtered symbols xxxxxxxxxxxxxxxxxxxxxx
decoded_symbols = self.modulator.demodulate(received_symbols)
# xxxxxxxxxx Calculates the Symbol Error Rate xxxxxxxxxxxxxxxxxxxxx
num_symbol_errors = np.sum(decoded_symbols != input_data, 1)
# num_symbol_errors = sum_user_data(num_symbol_errors,
# Ns_all_users)
num_symbols = np.ones(Ns_total) * input_data.shape[1]
# xxxxxxxxxx Calculates the Bit Error Rate xxxxxxxxxxxxxxxxxxxxxxxx
num_bit_errors = misc.count_bit_errors(decoded_symbols, input_data, 1)
# num_bit_errors = sum_user_data(num_bit_errors,
# Ns_all_users)
num_bits = num_symbols * np.log2(current_parameters['M'])
# xxxxxxxxxx Calculates the Package Error Rate xxxxxxxxxxxxxxxxxxxx
ber = num_bit_errors / num_bits
per = 1. - ((1. - ber) ** current_parameters['packet_length'])
num_packages = num_bits / current_parameters['packet_length']
num_package_errors = per * num_packages
# xxxxxxxxxx Calculates the Spectral Efficiency xxxxxxxxxxxxxxxxxxx
# nominal spectral Efficiency per stream
nominal_spec_effic = self.modulator.K
effective_spec_effic = (1 - per) * nominal_spec_effic
# xxxxx Map the per stream metric to a global metric xxxxxxxxxxxxxx
num_bit_errors = np.sum(num_bit_errors)
num_bits = np.sum(num_bits)
num_symbol_errors = np.sum(num_symbol_errors)
num_symbols = np.sum(num_symbols)
num_package_errors = np.sum(num_package_errors)
num_packages = np.sum(num_packages)
effective_spec_effic = np.sum(effective_spec_effic)
# xxxxx Calculate teh SINR xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
Uk_all_users = np.empty(Wk_all_users.size, dtype=np.ndarray)
for ii in range(Wk_all_users.size):
Uk_all_users[ii] = Wk_all_users[ii].conjugate().T
SINR_all_k = self.multiuser_channel.calc_JP_SINR(MsPk_all_users,
Uk_all_users)
# xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
# None metric
ber_result = Result.create(
'ber_{0}'.format(metric_name),
Result.RATIOTYPE,
num_bit_errors,
num_bits)
ser_result = Result.create(
'ser_{0}'.format(metric_name),
Result.RATIOTYPE,
num_symbol_errors,
num_symbols)
per_result = Result.create(
'per_{0}'.format(metric_name),
Result.RATIOTYPE,
num_package_errors,
num_packages)
spec_effic_result = Result.create(
'spec_effic_{0}'.format(metric_name),
Result.RATIOTYPE,
effective_spec_effic,
1)
sinr_result = Result(
'sinr_{0}'.format(metric_name),
Result.RATIOTYPE,
accumulate_values=True)
for k in range(Wk_all_users.size):
sinr_k = SINR_all_k[k]
for value in sinr_k:
sinr_result.update(value, 1)
return (ber_result,
ser_result,
per_result,
spec_effic_result,
sinr_result)
def test_count_bit_errors(self):
a = np.random.randint(0, 16, 20)
b = np.random.randint(0, 16, 20)
expected_bit_count = np.sum(misc.count_bits(misc.xor(a, b)))
self.assertEqual(expected_bit_count, misc.count_bit_errors(a, b))
#dot2 = lambda w, r: np.dot(w.transpose().conjugate(), r)
# This will cancel the interference
received_data_no_interference = map(np.dot,
ia_solver.W_H, received_data)
# xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
# xxxxx Demodulate Data xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
received_data_no_interference = np.vstack(received_data_no_interference)
# received_data_no_interference = np.vstack(received_data_no_interference2)
demodulated_data = modulator.demodulate(received_data_no_interference)
# demodulated_data = map(modulator.demodulate, received_data_no_interference)
# xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
# xxxxx Calculates the symbol and bit error rates xxxxxxxxxxxxxxxxx
symbolErrors = symbolErrors + np.sum(inputData != demodulated_data)
bitErrors = bitErrors + misc.count_bit_errors(inputData, demodulated_data)
numSymbols = numSymbols + inputData.size
numBits = numBits + inputData.size * fundamental.level2bits(M)
#ia_cost = ia_solver.get_cost()
# xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
print()
print(bitErrors)
print(numBits)
BER = bitErrors / numBits
print("BER: {0}".format(BER))
SINRs = multi_user_channel.calc_SINR(ia_solver.F, ia_solver.W)
sum_capacity = np.sum(np.log2(1+np.hstack(SINRs)))
print("Sum Capacity: {0}".format(sum_capacity))
def _run_simulation(self, current_parameters):
# To make sure that this function does not modify the object state,
# we sobrescibe self to None.
#self = None
# xxxxx Input parameters (set in the constructor) xxxxxxxxxxxxxxxxx
NSymbs = current_parameters["NSymbs"]
M = current_parameters["M"]
SNR = current_parameters["SNR"]
# xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
# xxxxx Input Data xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
inputData = np.random.randint(0, M, NSymbs)
# xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
# xxxxx Modulate input data xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
modulatedData = self.modulator.modulate(inputData)
# xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
# xxxxx Pass through the channel xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
noiseVar = 1 / dB2Linear(SNR)
noise = ((np.random.standard_normal(NSymbs) +
1j * np.random.standard_normal(NSymbs)) *
np.sqrt(noiseVar / 2))
receivedData = modulatedData + noise
# xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
# xxxxx Demodulate received data xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
demodulatedData = self.modulator.demodulate(receivedData)
# xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
# xxxxx Calculates the symbol and bit error rates xxxxxxxxxxxxxxxxx
symbolErrors = sum(inputData != demodulatedData)
bitErrors = misc.count_bit_errors(inputData, demodulatedData)
numSymbols = inputData.size
numBits = inputData.size * mod.level2bits(M)
# xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
# xxxxx Return the simulation results xxxxxxxxxxxxxxxxxxxxxxxxxxxxx
symbolErrorsResult = Result.create(
"symbol_errors", Result.SUMTYPE, symbolErrors)
numSymbolsResult = Result.create(
"num_symbols", Result.SUMTYPE, numSymbols)
bitErrorsResult = Result.create("bit_errors", Result.SUMTYPE, bitErrors)
numBitsResult = Result.create("num_bits", Result.SUMTYPE, numBits)
berResult = Result.create("ber", Result.RATIOTYPE, bitErrors, numBits)
serResult = Result.create(
"ser", Result.RATIOTYPE, symbolErrors, numSymbols)
simResults = SimulationResults()
simResults.add_result(symbolErrorsResult)
simResults.add_result(numSymbolsResult)
simResults.add_result(bitErrorsResult)
simResults.add_result(numBitsResult)
simResults.add_result(berResult)
simResults.add_result(serResult)
return simResults
def _run_simulation(self, current_parameters):
# To make sure that this function does not modify the object state,
# we sobrescibe self to None.
#self = None
# xxxxx Input parameters (set in the constructor) xxxxxxxxxxxxxxxxx
NSymbs = current_parameters["NSymbs"]
M = current_parameters["M"]
SNR = current_parameters["SNR"]
# xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
# xxxxx Input Data xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
inputData = np.random.randint(0, M, NSymbs)
# xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
# xxxxx Modulate input data xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
modulatedData = self.modulator.modulate(inputData)
# xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
# xxxxx Pass through the channel xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
noiseVar = 1 / dB2Linear(SNR)
noise = ((np.random.standard_normal(NSymbs) +
1j * np.random.standard_normal(NSymbs)) *
np.sqrt(noiseVar / 2))
receivedData = modulatedData + noise
# xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
# xxxxx Demodulate received data xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
demodulatedData = self.modulator.demodulate(receivedData)
# xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
# xxxxx Calculates the symbol and bit error rates xxxxxxxxxxxxxxxxx
symbolErrors = sum(inputData != demodulatedData)
bitErrors = misc.count_bit_errors(inputData, demodulatedData)
numSymbols = inputData.size
numBits = inputData.size * mod.level2bits(M)
# xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
# xxxxx Return the simulation results xxxxxxxxxxxxxxxxxxxxxxxxxxxxx
symbolErrorsResult = Result.create("symbol_errors", Result.SUMTYPE,
symbolErrors)
numSymbolsResult = Result.create("num_symbols", Result.SUMTYPE,
numSymbols)
bitErrorsResult = Result.create("bit_errors", Result.SUMTYPE,
bitErrors)
numBitsResult = Result.create("num_bits", Result.SUMTYPE, numBits)
berResult = Result.create("ber", Result.RATIOTYPE, bitErrors, numBits)
serResult = Result.create("ser", Result.RATIOTYPE, symbolErrors,
numSymbols)
simResults = SimulationResults()
simResults.add_result(symbolErrorsResult)
simResults.add_result(numSymbolsResult)
simResults.add_result(bitErrorsResult)
simResults.add_result(numBitsResult)
simResults.add_result(berResult)
simResults.add_result(serResult)
return simResults
