Plotting method in Modem and bit-level representation.

* Add a method plotCons in the class modem that plots the constellation.
* Give an example for plotCons.
* Add a method bit_lvl_repr that convert channel matrix to Bit-level representation.

Author: akou97

README.md

@@ -54,6 +54,7 @@ Modulation/Demodulation
 - OFDM Tx/Rx signal processing
 - MIMO Maximum Likelihood (ML) Detection.
 - MIMO K-best Schnorr-Euchner Detection.
+- Convert channel matrix to Bit-level representation.
 
 Sequences
 ---------

commpy/examples/plotConsModem.py

@@ -0,0 +1,16 @@
+# Authors: Youness Akourim <akourim97@gmail.com>
+# License: BSD 3-Clause
+
+from commpy.modulation import PSKModem, QAMModem
+
+# =============================================================================
+# Example constellation plot of Modem
+# =============================================================================
+
+# PSK corresponding to PSKModem for 4 bits
+psk = PSKModem(16)
+psk.plotCons()
+
+# QAM corresponding to QAMModem for 2bits
+Qam = QAMModem(4)
+Qam.plotCons()

commpy/links.py

@@ -65,6 +65,7 @@ def link_performance(link_model, SNRs, send_max, err_min, send_chunk=None, code_
         link_model.channel.set_SNR_dB(SNRs[id_SNR], code_rate, link_model.Es)
         bit_send = 0
         bit_err = 0
+        receive_size = link_model.channel.nb_tx * link_model.num_bits_symbol
         while bit_send < send_max and bit_err < err_min:
             # Propagate some bits
             msg = np.random.choice((0, 1), send_chunk)
@@ -74,14 +75,14 @@ def link_performance(link_model, SNRs, send_max, err_min, send_chunk=None, code_
             # Deals with MIMO channel
             if isinstance(link_model.channel, MIMOFlatChannel):
                 nb_symb_vector = len(channel_output)
-                received_msg = np.empty(nb_symb_vector * link_model.channel.nb_tx, dtype=channel_output.dtype)
+                received_msg = np.empty_like(msg, int)
                 for i in range(nb_symb_vector):
-                     received_msg[link_model.channel.nb_tx * i:link_model.channel.nb_tx * (i+1)] = \
+                     received_msg[receive_size * i:receive_size * (i+1)] = \
                          link_model.receive(channel_output[i], link_model.channel.channel_gains[i], link_model.constellation)
             else:
                 received_msg = channel_output
             # Count errors
-            bit_err += (msg != received_msg[:len(msg)]).sum()  # Remove MIMO padding
+            bit_err += (msg != received_msg).sum()  # Remove MIMO padding
             bit_send += send_chunk
         BERs[id_SNR] = bit_err / bit_send
     return BERs
@@ -98,13 +99,13 @@ class linkModel:
         channel : _FlatChannel object
 
         receive : function with prototype receive(y, H, constellation) that return a binary array.
-                    y : 1D ndarray of floats
+                    y : 1D ndarray
                         Received complex symbols (shape: num_receive_antennas x 1)
 
-                    h : 2D ndarray of floats
+                    h : 2D ndarray
                         Channel Matrix (shape: num_receive_antennas x num_transmit_antennas)
 
-                    constellation : 1D ndarray of floats
+                    constellation : 1D ndarray
 
         num_bits_symbols : int
 

commpy/modulation.py

@@ -1,4 +1,4 @@
-# Authors: Veeresh Taranalli <veeresht@gmail.com> & Bastien Trotobas <bastien.trotobas@gmail.com>
+# Authors: Veeresh Taranalli <veeresht@gmail.com> & Bastien Trotobas <bastien.trotobas@gmail.com> & Youness Akourim <akourim97@gmail.com>
 # License: BSD 3-Clause
 
 """
@@ -15,19 +15,20 @@
    ofdm_rx              -- OFDM Receive Signal Processing
    mimo_ml              -- MIMO Maximum Likelihood (ML) Detection.
    kbest                -- MIMO K-best Schnorr-Euchner Detection.
+   bit_lvl_repr         -- Bit level representation
 
 """
 from itertools import product
 
+import matplotlib.pyplot as plt
+from commpy.utilities import bitarray2dec, dec2bitarray
 from numpy import arange, array, zeros, pi, cos, sin, sqrt, log2, argmin, \
     hstack, repeat, tile, dot, sum, shape, concatenate, exp, \
-    log, vectorize, empty
+    log, vectorize, empty, eye, kron
 from numpy.fft import fft, ifft
 from numpy.linalg import qr
 
-from commpy.utilities import bitarray2dec, dec2bitarray
-
-__all__ = ['PSKModem', 'QAMModem', 'ofdm_tx', 'ofdm_rx', 'mimo_ml', 'kbest']
+__all__ = ['PSKModem', 'QAMModem', 'ofdm_tx', 'ofdm_rx', 'mimo_ml', 'kbest', 'bit_lvl_repr']
 
 
 class Modem:
@@ -99,6 +100,44 @@ def demodulate(self, input_symbols, demod_type, noise_var=0):
 
         return demod_bits
 
+    def plotCons(self):
+        """ Plot the constellation """
+        # init some arrays
+        beta = self.num_bits_symbol
+        numbit = '0' + str(beta) + 'b'
+        Bin = []
+        mot = []
+        const = []
+
+        # creation of w array
+        reel = [pow(2, i) for i in range(beta // 2 - 1, -1, -1)]
+        im = [1j * pow(2, i) for i in range(beta // 2 - 1, -1, -1)]
+        w = concatenate((reel, im), axis=None)
+
+        listBin = [format(i, numbit) for i in range(2 ** beta)]
+        for e in listBin:
+            for i in range(beta):
+                Bin.append(ord(e[i]) - 48)
+                if (ord(e[i]) - 48 == 0):
+                    mot.append(-1)
+                else:
+                    mot.append(1)
+            const.append(dot(w, mot))
+            mot = []
+        symb = self.modulate(Bin)
+
+        # plot the symbols
+        x = symb.real
+        y = symb.imag
+
+        plt.plot(x, y, '+',linewidth=4)
+        for i in range(len(x)):
+            plt.text(x[i], y[i] , listBin[i])
+
+        plt.title('Constellation')
+        plt.grid()
+        plt.show()
+
 
 class PSKModem(Modem):
     """ Creates a Phase Shift Keying (PSK) Modem object. """
@@ -225,27 +264,35 @@ def kbest(y, h, constellation, K):
 
     K : positive integer
         Number of candidates kept at each step
+
+    raises
+    ------
+    ValueError
+                If h has more columns than rows.
     """
+    nb_tx, nb_rx = h.shape
+    if nb_rx > nb_tx:
+        raise ValueError('h has more columns than rows')
+
     # QR decomposition
     q, r = qr(h)
     yt = q.conj().T.dot(y)
 
     # Initialization
     m = len(constellation)
-    n = len(yt)
     nb_can = 1
 
     if isinstance(constellation[0], complex):
         const_type = complex
     else:
         const_type = float
-    X = empty((n, K * m), dtype=const_type)  # Set of current candidates
+    X = empty((nb_rx, K * m), dtype=const_type)  # Set of current candidates
     d = tile(yt[:, None], (1, K * m))        # Corresponding distance vector
     d_tot = zeros(K * m, dtype=float)        # Corresponding total distance
     hyp = empty(K * m, dtype=const_type)     # Hypothesis vector
 
     # Processing
-    for coor in range(n-1, -1, -1):
+    for coor in range(nb_rx-1, -1, -1):
         nb_hyp = nb_can * m
 
         # Copy best candidates m times
@@ -269,3 +316,29 @@ def kbest(y, h, constellation, K):
         d[:coor, :nb_can] -= r[:coor, coor, None] * hyp[argsort[:nb_can]]
         d_tot[:nb_can] = d_tot[argsort[:nb_can]]
     return X[:, 0]
+
+
+def bit_lvl_repr(H, w):
+    """ Bit-level representation of matrix H with weights w.
+
+    parameters
+    ----------
+    H   :   2D ndarray (shape : nb_rx, nb_tx)
+            Channel Matrix.
+
+    w   :   1D ndarray of complex (length : beta)
+            Bit level representation weights. The length must be even.
+
+    return
+    ------
+    A : 2D nbarray (shape : nb_rx, nb_tx*beta)
+        Channel matrix adapted to the bit-level representation.
+    """
+    beta = len(w)
+    if beta%2 == 0:
+        m, n = H.shape
+        In = eye(n,n)
+        kr = kron(In,w)
+        return dot(H,kr)
+    else:
+       raise ValueError('Beta must be even.')