Closed Form IA ALgorithm

This notebook simulates the Closed Form Interference Alignment algorithm.

Some initialization code



In [1]:

    
%pylab inline

# xxxxxxxxxx Add the parent folder to the python path. xxxxxxxxxxxxxxxxxxxx
import sys
import os
pyphysim_folder = "~/cvs_files/pyphysim/"
pyphysim_folder = os.path.expanduser(pyphysim_folder)
sys.path.append(pyphysim_folder)
# xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

import numpy as np

# Import the simulation runner
from apps.simulate_ia import ClosedFormSimulationRunner
from pyphysim.simulations import results

# We will use clear_output to erase the progressbar after the simulation has finished.
from IPython.display import clear_output

# We will use pprint to print the simulation parameters
from pprint import pprint









    



Populating the interactive namespace from numpy and matplotlib

Run the algorithm



In [2]:

    
%%file ia_config_file_closed.txt

[Scenario]
        SNR = [  0.   5.  10.  15.  20.  25.  30.]
        M = 4
        modulator = PSK
        NSymbs = 100
        Nr = 2
        Nt = 2
        Ns = 1
[General]
        rep_max = 50
        max_bit_errors = 10000
        unpacked_parameters = SNR,









    



Overwriting ia_config_file_closed.txt

First we need to create a "view" of the engines. Note that you need to start the engines before calling the code below.



In [3]:

    
from IPython.parallel import Client
cl = Client()
dview = cl.direct_view()

# Add the folder containing PyPhysim to the python path in all the
# engines
dview.execute('import sys')
dview.execute('sys.path.append("{0}")'.format(pyphysim_folder))









    Out[3]:





<AsyncResult: execute>

All we need to do now is creating the runner object, call its "simulate" method (or the simulate_in_parallel method) and save the results to a file.



In [4]:

    
runner_parallel = ClosedFormSimulationRunner('ia_config_file_closed.txt', read_command_line_args=False)
pprint(runner_parallel.params.parameters)
runner_parallel.simulate_in_parallel(dview)

# xxxxxxxxxx Get the parameters xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
K = 3  # Always 3 form the closed form IA algorithm
Nr = runner_parallel.params["Nr"]
Nt = runner_parallel.params["Nt"]
Ns = runner_parallel.params["Ns"]
modulator_name = runner_parallel.modulator.name
# xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

# xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
# File name (without extension) for the figure and result files.
results_filename_parallel = 'ia_closedform_results_{0}_{1}x{2}({3})_120_parallel'.format(
    modulator_name,
    Nr,
    Nt,
    Ns)
# xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

# xxxxxxxxxx Save the simulation results to a file xxxxxxxxxxxxxxxxxxxx
runner_parallel.results.save_to_file('{0}.pickle'.format(results_filename_parallel))
# xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

print "Runned iterations: {0}".format(runner_parallel.runned_reps)
print "Elapsed Time: {0}".format(runner_parallel.elapsed_time)









    



{'K': 3,
 'M': 4,
 'NSymbs': 100,
 'Nr': 2,
 'Ns': 1,
 'Nt': 2,
 'SNR': array([  0.,   5.,  10.,  15.,  20.,  25.,  30.]),
 'max_bit_errors': 10000,
 'max_iterations': array([60]),
 'modulator': 'PSK',
 'rep_max': 50,
 'unpacked_parameters': ['SNR']}
Runned iterations: [50, 50, 50, 50, 50, 50, 50]
Elapsed Time: 0.65s
[**********************100%**********************]  SNR: [  0.   5.  10.  15.  20.  25.  30.]

Plot the results



In [5]:

    
results_parallel = results.SimulationResults.load_from_file('{0}.pickle'.format(
    results_filename_parallel))

# Get the BER and SER from the results object
ber_parallel = results_parallel.get_result_values_list('ber')
ser_parallel = results_parallel.get_result_values_list('ser')

# Get the SNR from the simulation parameters
SNR_parallel = np.array(results_parallel.params['SNR'])

# Can only plot if we simulated for more then one value of SNR
if SNR_parallel.size > 1:
    fig = figure(figsize=(12,9))
    semilogy(SNR_parallel, ber_parallel, '--g*', label='BER')
    semilogy(SNR_parallel, ser_parallel, '--b*', label='SER')
    xlabel('SNR')
    ylabel('Error')
    title('Closed Form IA Algorithm\nK={0}, Nr={1}, Nt={2}, Ns={3}, {4}'.format(K, Nr, Nt, Ns, modulator_name))
    legend()

    grid(True, which='both', axis='both')
    show()