if __name__ == '__main__1':
try:
# noinspection PyUnresolvedReferences
from matplotlib import pyplot as plt
_MATPLOTLIB_AVAILABLE = True
except ImportError:
_MATPLOTLIB_AVAILABLE = False
# xxxxxxxxxx Parameters xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
params = SimulationParameters.load_from_config_file('bd_config_file.txt')
# xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
# xxxxxxxx Load the results from the file xxxxxxxxxxxxxxxxxxxxxxxxxxxxx
results_filename = 'bd_results_{Nr}x{Nt}_ext_int_rank_{ext_int_rank}'
results_filename.format(**params.parameters)
results = SimulationResults.load_from_file('{0}{1}'.format(
results_filename, '.pickle'))
SNR = results.params['SNR']
if _MATPLOTLIB_AVAILABLE is True and SNR.size > 1:
Pe_dBm = 10.
# Save the Spectral Efficiency curve for the given Pe_dBm
spec_fig = plot_spectral_efficience_all_metrics(results, Pe_dBm)
# spec_fig.tight_layout()
spec_fig.subplots_adjust(bottom=0.08, right=0.98, top=0.95, left=0.07)
spec_fig.savefig('{0}_Pe_{1}_spec_effic.pdf'.format(
results_filename, Pe_dBm))
per_all_fig = plot_per_all_metrics(results, Pe_dBm)
# per_all_fig.tight_layout()
per_all_fig.subplots_adjust(bottom=0.08,
def _run_simulation(self, current_parameters): # pylint: disable=R0914
"""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.
Parameters
----------
current_parameters : SimulationParameters object
SimulationParameters object with the parameters for the
simulation. The self.params variable is not used directly. It
is first unpacked (in the SimulationRunner.simulate method
which then calls _run_simulation) for each combination.
"""
# xxxxxxxxxx Prepare the scenario for this iteration. xxxxxxxxxxxxx
# This will place the users at the locations specified by the
# scenario (random locations or not), calculate the path loss and
# generate a new random channel (in the self.multiuser_channel
# variable).
self._create_users_according_to_scenario(current_parameters)
# This will calculate pathloss and generate random channels from
# all transmitters to all receivers as well as from the external
# interference sources to all receivers. This method must be called
# after the _create_users_according_to_scenario method so that the
# users are already created (we need their positions for the
# pathloss)
self._create_users_channels(current_parameters)
# xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
# xxxxx Perform the block diagonalization for each metric xxxxxxxxx
# None Metric
(MsPk_all_users_None,
Wk_all_users_None,
Ns_all_users_None) \
= self.bd_obj_None.block_diagonalize_no_waterfilling(
self.multiuser_channel)
# Naive Metric
(MsPk_all_users_naive,
Wk_all_users_naive,
Ns_all_users_naive) \
= self.bd_obj_naive.block_diagonalize_no_waterfilling(
self.multiuser_channel)
# Fixed Metric
(MsPk_all_users_fixed,
Wk_all_users_fixed,
Ns_all_users_fixed) \
= self.bd_obj_fixed.block_diagonalize_no_waterfilling(
self.multiuser_channel)
# Capacity Metric
(MsPk_all_users_capacity,
Wk_all_users_capacity,
Ns_all_users_capacity) \
= self.bd_obj_capacity.block_diagonalize_no_waterfilling(
self.multiuser_channel)
# effective_throughput Metric
(MsPk_all_users_effec_throughput,
Wk_all_users_effec_throughput,
Ns_all_users_effec_throughput) \
= self.bd_obj_effec_throughput.block_diagonalize_no_waterfilling(
self.multiuser_channel)
(Ms_all_users_Whitening,
Wk_all_users_Whitening,
Ns_all_users_Whitening) \
= self.bd_obj_whitening.block_diagonalize_no_waterfilling(
self.multiuser_channel)
# xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
# xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
# Since we will use the same data for the external interference no
# matter which metric is used, lets create that data here.
external_int_data_all_metrics = (np.sqrt(self.pe) * misc.randn_c_RS(
self.ext_data_RS, current_parameters['ext_int_rank'],
current_parameters['NSymbs']))
# xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
# xxx Run the Simulation and get the results for each metric xxxxxx
# xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
# None metric
(ber_result_None, ser_result_None, per_result_None,
spec_effic_result_None,
sinr_result_None) = self.__simulate_for_one_metric(
Ns_all_users_None, external_int_data_all_metrics,
MsPk_all_users_None, Wk_all_users_None, 'None',
current_parameters)
# naive metric
(ber_result_naive, ser_result_naive, per_result_naive,
spec_effic_result_naive,
sinr_result_naive) = self.__simulate_for_one_metric(
Ns_all_users_naive, external_int_data_all_metrics,
MsPk_all_users_naive, Wk_all_users_naive, 'naive',
current_parameters)
# fixed metric
(ber_result_fixed, ser_result_fixed, per_result_fixed,
spec_effic_result_fixed,
sinr_result_fixed) = self.__simulate_for_one_metric(
Ns_all_users_fixed, external_int_data_all_metrics,
MsPk_all_users_fixed, Wk_all_users_fixed, 'fixed',
current_parameters)
# capacity metric
(ber_result_capacity, ser_result_capacity, per_result_capacity,
spec_effic_result_capacity,
sinr_result_capacity) = self.__simulate_for_one_metric(
Ns_all_users_capacity, external_int_data_all_metrics,
MsPk_all_users_capacity, Wk_all_users_capacity, 'capacity',
current_parameters)
# effective throughput metric
(ber_result_effec_throughput, ser_result_effec_throughput,
per_result_effec_throughput, spec_effic_result_effec_throughput,
sinr_result_effec_throughput) = self.__simulate_for_one_metric(
Ns_all_users_effec_throughput, external_int_data_all_metrics,
MsPk_all_users_effec_throughput, Wk_all_users_effec_throughput,
'effec_throughput', current_parameters)
# Whitening BD
(ber_result_Whitening, ser_result_Whitening, per_result_Whitening,
spec_effic_result_Whitening,
sinr_result_Whitening) = self.__simulate_for_one_metric(
Ns_all_users_Whitening, external_int_data_all_metrics,
Ms_all_users_Whitening, Wk_all_users_Whitening, 'Whitening',
current_parameters)
simResults = SimulationResults()
# Add the 'None' results
simResults.add_result(ber_result_None)
simResults.add_result(ser_result_None)
simResults.add_result(per_result_None)
simResults.add_result(spec_effic_result_None)
simResults.add_result(sinr_result_None)
# Add the naive results
simResults.add_result(ber_result_naive)
simResults.add_result(ser_result_naive)
simResults.add_result(per_result_naive)
simResults.add_result(spec_effic_result_naive)
simResults.add_result(sinr_result_naive)
# Add the fixed results
simResults.add_result(ber_result_fixed)
simResults.add_result(ser_result_fixed)
simResults.add_result(per_result_fixed)
simResults.add_result(spec_effic_result_fixed)
simResults.add_result(sinr_result_fixed)
# Add the capacity results
simResults.add_result(ber_result_capacity)
simResults.add_result(ser_result_capacity)
simResults.add_result(per_result_capacity)
simResults.add_result(spec_effic_result_capacity)
simResults.add_result(sinr_result_capacity)
# Add the effective throughput results
simResults.add_result(ber_result_effec_throughput)
simResults.add_result(ser_result_effec_throughput)
simResults.add_result(per_result_effec_throughput)
simResults.add_result(spec_effic_result_effec_throughput)
simResults.add_result(sinr_result_effec_throughput)
# Add the 'Whitening' results
simResults.add_result(ber_result_Whitening)
simResults.add_result(ser_result_Whitening)
simResults.add_result(per_result_Whitening)
simResults.add_result(spec_effic_result_Whitening)
simResults.add_result(sinr_result_Whitening)
# xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
return simResults
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 _run_simulation(self, current_parameters): # pylint: disable=R0914
"""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.
Parameters
----------
current_parameters : SimulationParameters object
SimulationParameters object with the parameters for the
simulation. The self.params variable is not used directly. It
is first unpacked (in the SimulationRunner.simulate method
which then calls _run_simulation) for each combination.
"""
# xxxxxxxxxx Prepare the scenario for this iteration. xxxxxxxxxxxxx
# This will place the users at the locations specified by the
# scenario (random locations or not), calculate the path loss and
# generate a new random channel (in the self.multiuser_channel
# variable).
self._create_users_according_to_scenario(current_parameters)
# This will calculate pathloss and generate random channels from
# all transmitters to all receivers as well as from the external
# interference sources to all receivers. This method must be called
# after the _create_users_according_to_scenario method so that the
# users are already created (we need their positions for the
# pathloss)
self._create_users_channels(current_parameters)
# xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
# xxxxx Perform the block diagonalization for each metric xxxxxxxxx
# None Metric
(MsPk_all_users_None,
Wk_all_users_None,
Ns_all_users_None) \
= self.bd_obj_None.block_diagonalize_no_waterfilling(
self.multiuser_channel)
# Naive Metric
(MsPk_all_users_naive,
Wk_all_users_naive,
Ns_all_users_naive) \
= self.bd_obj_naive.block_diagonalize_no_waterfilling(
self.multiuser_channel)
# Fixed Metric
(MsPk_all_users_fixed,
Wk_all_users_fixed,
Ns_all_users_fixed) \
= self.bd_obj_fixed.block_diagonalize_no_waterfilling(
self.multiuser_channel)
# Capacity Metric
(MsPk_all_users_capacity,
Wk_all_users_capacity,
Ns_all_users_capacity) \
= self.bd_obj_capacity.block_diagonalize_no_waterfilling(
self.multiuser_channel)
# effective_throughput Metric
(MsPk_all_users_effec_throughput,
Wk_all_users_effec_throughput,
Ns_all_users_effec_throughput) \
= self.bd_obj_effec_throughput.block_diagonalize_no_waterfilling(
self.multiuser_channel)
(Ms_all_users_Whitening,
Wk_all_users_Whitening,
Ns_all_users_Whitening) \
= self.bd_obj_whitening.block_diagonalize_no_waterfilling(
self.multiuser_channel)
# xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
# xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
# Since we will use the same data for the external interference no
# matter which metric is used, lets create that data here.
external_int_data_all_metrics = (
np.sqrt(self.pe) *
misc.randn_c_RS(
self.ext_data_RS,
current_parameters['ext_int_rank'],
current_parameters['NSymbs']))
# xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
# xxx Run the Simulation and get the results for each metric xxxxxx
# xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
# None metric
(ber_result_None,
ser_result_None,
per_result_None,
spec_effic_result_None,
sinr_result_None) = self.__simulate_for_one_metric(
Ns_all_users_None,
external_int_data_all_metrics,
MsPk_all_users_None,
Wk_all_users_None,
'None',
current_parameters)
# naive metric
(ber_result_naive,
ser_result_naive,
per_result_naive,
spec_effic_result_naive,
sinr_result_naive) = self.__simulate_for_one_metric(
Ns_all_users_naive,
external_int_data_all_metrics,
MsPk_all_users_naive,
Wk_all_users_naive,
'naive',
current_parameters)
# fixed metric
(ber_result_fixed,
ser_result_fixed,
per_result_fixed,
spec_effic_result_fixed,
sinr_result_fixed) = self.__simulate_for_one_metric(
Ns_all_users_fixed,
external_int_data_all_metrics,
MsPk_all_users_fixed,
Wk_all_users_fixed,
'fixed',
current_parameters)
# capacity metric
(ber_result_capacity,
ser_result_capacity,
per_result_capacity,
spec_effic_result_capacity,
sinr_result_capacity) = self.__simulate_for_one_metric(
Ns_all_users_capacity,
external_int_data_all_metrics,
MsPk_all_users_capacity,
Wk_all_users_capacity,
'capacity',
current_parameters)
# effective throughput metric
(ber_result_effec_throughput,
ser_result_effec_throughput,
per_result_effec_throughput,
spec_effic_result_effec_throughput,
sinr_result_effec_throughput) = self.__simulate_for_one_metric(
Ns_all_users_effec_throughput,
external_int_data_all_metrics,
MsPk_all_users_effec_throughput,
Wk_all_users_effec_throughput,
'effec_throughput',
current_parameters)
# Whitening BD
(ber_result_Whitening,
ser_result_Whitening,
per_result_Whitening,
spec_effic_result_Whitening,
sinr_result_Whitening) = self.__simulate_for_one_metric(
Ns_all_users_Whitening,
external_int_data_all_metrics,
Ms_all_users_Whitening,
Wk_all_users_Whitening,
'Whitening',
current_parameters)
simResults = SimulationResults()
# Add the 'None' results
simResults.add_result(ber_result_None)
simResults.add_result(ser_result_None)
simResults.add_result(per_result_None)
simResults.add_result(spec_effic_result_None)
simResults.add_result(sinr_result_None)
# Add the naive results
simResults.add_result(ber_result_naive)
simResults.add_result(ser_result_naive)
simResults.add_result(per_result_naive)
simResults.add_result(spec_effic_result_naive)
simResults.add_result(sinr_result_naive)
# Add the fixed results
simResults.add_result(ber_result_fixed)
simResults.add_result(ser_result_fixed)
simResults.add_result(per_result_fixed)
simResults.add_result(spec_effic_result_fixed)
simResults.add_result(sinr_result_fixed)
# Add the capacity results
simResults.add_result(ber_result_capacity)
simResults.add_result(ser_result_capacity)
simResults.add_result(per_result_capacity)
simResults.add_result(spec_effic_result_capacity)
simResults.add_result(sinr_result_capacity)
# Add the effective thoughput results
simResults.add_result(ber_result_effec_throughput)
simResults.add_result(ser_result_effec_throughput)
simResults.add_result(per_result_effec_throughput)
simResults.add_result(spec_effic_result_effec_throughput)
simResults.add_result(sinr_result_effec_throughput)
# Add the 'Whitening' results
simResults.add_result(ber_result_Whitening)
simResults.add_result(ser_result_Whitening)
simResults.add_result(per_result_Whitening)
simResults.add_result(spec_effic_result_Whitening)
simResults.add_result(sinr_result_Whitening)
# xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
return simResults
# xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
if __name__ == '__main__1':
try:
from matplotlib import pyplot as plt
_MATPLOTLIB_AVAILABLE = True
except ImportError:
_MATPLOTLIB_AVAILABLE = False
# xxxxxxxxxx Parameters xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
params = SimulationParameters.load_from_config_file('bd_config_file.txt')
# xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
# xxxxxxxx Load the results from the file xxxxxxxxxxxxxxxxxxxxxxxxxxxxx
results_filename = 'bd_results_{Nr}x{Nt}_ext_int_rank_{ext_int_rank}'
results_filename.format(**params.parameters)
results = SimulationResults.load_from_file(
'{0}{1}'.format(results_filename, '.pickle'))
SNR = results.params['SNR']
if _MATPLOTLIB_AVAILABLE is True and SNR.size > 1:
Pe_dBm = 10
# Save the Spectral Efficiency curve for the given Pe_dBm
spec_fig = plot_spectral_efficience_all_metrics(results, Pe_dBm)
# spec_fig.tight_layout()
spec_fig.subplots_adjust(bottom=0.08, right=0.98, top=0.95, left=0.07)
spec_fig.savefig('{0}_Pe_{1}_spec_effic.pdf'.format(
results_filename, Pe_dBm))
per_all_fig = plot_per_all_metrics(results, Pe_dBm)
# per_all_fig.tight_layout()
per_all_fig.subplots_adjust(
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