Add link_performance as a method of LinkModel object.

Author: BastienTr

commpy/links.py

@@ -28,6 +28,7 @@
 def link_performance(link_model, SNRs, send_max, err_min, send_chunk=None, code_rate=1):
     """
     Estimate the BER performance of a link model with Monte Carlo simulation.
+    Equivalent to call link_model.link_performance(SNRs, send_max, err_min, send_chunk, code_rate).
 
     Parameters
     ----------
@@ -58,52 +59,7 @@ def link_performance(link_model, SNRs, send_max, err_min, send_chunk=None, code_
            Estimated Bit Error Ratio corresponding to each SNRs
     """
 
-    # Initialization
-    BERs = np.zeros_like(SNRs, dtype=float)
-    # Set chunk size and round it to be a multiple of num_bits_symbol*nb_tx to avoid padding
-    if send_chunk is None:
-        send_chunk = err_min
-    divider = link_model.num_bits_symbol * link_model.channel.nb_tx
-    send_chunk = max(divider, send_chunk // divider * divider)
-
-    receive_size = link_model.channel.nb_tx * link_model.num_bits_symbol
-    full_args_decoder = len(getfullargspec(link_model.decoder).args) > 1
-
-    # Computations
-    for id_SNR in range(len(SNRs)):
-        link_model.channel.set_SNR_dB(SNRs[id_SNR], code_rate, link_model.Es)
-        bit_send = 0
-        bit_err = 0
-        while bit_send < send_max and bit_err < err_min:
-            # Propagate some bits
-            msg = np.random.choice((0, 1), send_chunk)
-            symbs = link_model.modulate(msg)
-            channel_output = link_model.channel.propagate(symbs)
-
-            # Deals with MIMO channel
-            if isinstance(link_model.channel, MIMOFlatChannel):
-                nb_symb_vector = len(channel_output)
-                received_msg = np.empty(int(math.ceil(len(msg) / link_model.rate)))
-                for i in range(nb_symb_vector):
-                    received_msg[receive_size * i:receive_size * (i + 1)] = \
-                        link_model.receive(channel_output[i], link_model.channel.channel_gains[i],
-                                           link_model.constellation, link_model.channel.noise_std ** 2)
-            else:
-                received_msg = link_model.receive(channel_output, link_model.channel.channel_gains,
-                                                  link_model.constellation, link_model.channel.noise_std ** 2)
-            # Count errors
-            if full_args_decoder:
-                decoded_bits = link_model.decoder(channel_output, link_model.channel.channel_gains,
-                                                  link_model.constellation, link_model.channel.noise_std ** 2,
-                                                  received_msg, link_model.channel.nb_tx * link_model.num_bits_symbol)
-                bit_err += (msg != decoded_bits[:len(msg)]).sum()
-            else:
-                bit_err += (msg != link_model.decoder(received_msg)[:len(msg)]).sum()
-            bit_send += send_chunk
-        BERs[id_SNR] = bit_err / bit_send
-        if bit_err < err_min:
-            break
-    return BERs
+    return link_model.link_performance(SNRs, send_max, err_min, send_chunk, code_rate)
 
 
 class LinkModel:
@@ -191,6 +147,84 @@ def __init__(self, modulate, channel, receive, num_bits_symbol, constellation, E
         else:
             self.decoder = decoder
 
+    def link_performance(self, SNRs, send_max, err_min, send_chunk=None, code_rate=1):
+        """
+        Estimate the BER performance of a link model with Monte Carlo simulation.
+
+        Parameters
+        ----------
+        SNRs : 1D arraylike
+               Signal to Noise ratio in dB defined as :math:`SNR_{dB} = (E_b/N_0)_{dB} + 10 \log_{10}(R_cM_c)`
+               where :math:`Rc` is the code rate and :math:`Mc` the modulation rate.
+
+        send_max : int
+                   Maximum number of bits send for each SNR.
+
+        err_min : int
+                  link_performance send bits until it reach err_min errors (see also send_max).
+
+        send_chunk : int
+                      Number of bits to be send at each iteration. This is also the frame length of the decoder if available
+                      so it should be large enough regarding the code type.
+                      *Default*: send_chunck = err_min
+
+        code_rate : float in (0,1]
+                    Rate of the used code.
+                    *Default*: 1 i.e. no code.
+
+        Returns
+        -------
+        BERs : 1d ndarray
+               Estimated Bit Error Ratio corresponding to each SNRs
+        """
+
+        # Initialization
+        BERs = np.zeros_like(SNRs, dtype=float)
+        # Set chunk size and round it to be a multiple of num_bits_symbol*nb_tx to avoid padding
+        if send_chunk is None:
+            send_chunk = err_min
+        divider = self.num_bits_symbol * self.channel.nb_tx
+        send_chunk = max(divider, send_chunk // divider * divider)
+
+        receive_size = self.channel.nb_tx * self.num_bits_symbol
+        full_args_decoder = len(getfullargspec(self.decoder).args) > 1
+
+        # Computations
+        for id_SNR in range(len(SNRs)):
+            self.channel.set_SNR_dB(SNRs[id_SNR], code_rate, self.Es)
+            bit_send = 0
+            bit_err = 0
+            while bit_send < send_max and bit_err < err_min:
+                # Propagate some bits
+                msg = np.random.choice((0, 1), send_chunk)
+                symbs = self.modulate(msg)
+                channel_output = self.channel.propagate(symbs)
+
+                # Deals with MIMO channel
+                if isinstance(self.channel, MIMOFlatChannel):
+                    nb_symb_vector = len(channel_output)
+                    received_msg = np.empty(int(math.ceil(len(msg) / self.rate)))
+                    for i in range(nb_symb_vector):
+                        received_msg[receive_size * i:receive_size * (i + 1)] = \
+                            self.receive(channel_output[i], self.channel.channel_gains[i],
+                                         self.constellation, self.channel.noise_std ** 2)
+                else:
+                    received_msg = self.receive(channel_output, self.channel.channel_gains,
+                                                self.constellation, self.channel.noise_std ** 2)
+                # Count errors
+                if full_args_decoder:
+                    decoded_bits = self.decoder(channel_output, self.channel.channel_gains,
+                                                self.constellation, self.channel.noise_std ** 2,
+                                                received_msg, self.channel.nb_tx * self.num_bits_symbol)
+                    bit_err += (msg != decoded_bits[:len(msg)]).sum()
+                else:
+                    bit_err += (msg != self.decoder(received_msg)[:len(msg)]).sum()
+                bit_send += send_chunk
+            BERs[id_SNR] = bit_err / bit_send
+            if bit_err < err_min:
+                break
+        return BERs
+
 
 def idd_decoder(detector, decoder, decision, n_it):
     """
@@ -241,6 +275,7 @@ def idd_decoder(detector, decoder, decision, n_it):
                 bits_per_send : positive integer
                                 Number or bit send at each symbol vector.
     """
+
     def decode(y, h, constellation, noise_var, a_priori, bits_per_send):
         a_priori_decoder = a_priori.copy()
         nb_vect, nb_rx, nb_tx = h.shape