8PSK constellation diagram about sionna HOT 6 CLOSED

no = ebnodb2no(ebno_db, num_bits_per_symbol=self.num_bits_per_symbol, coderate=1)

import numpy as np
import tensorflow as tf
import time # for throughput measurements

# Configure the notebook to use only a single GPU and allocate only as much memory as needed
# For more details, see https://www.tensorflow.org/guide/gpu
gpus = tf.config.list_physical_devices('GPU')
print('Number of GPUs available :', len(gpus))
if gpus:
    gpu_num = 0 # Number of the GPU to be used
    try:
        #tf.config.set_visible_devices([], 'GPU')
        tf.config.set_visible_devices(gpus[gpu_num], 'GPU')
        print('Only GPU number', gpu_num, 'used.')
        tf.config.experimental.set_memory_growth(gpus[gpu_num], True)
    except RuntimeError as e:
        print(e)
        
# Import Sionna
try:
    import sionna
except ImportError as e:
    # Install Sionna if package is not already installed
    import os
    os.system("pip install sionna")
    import sionna
    

# For the implementation of the Keras models
from tensorflow.keras import Model

# Import required Sionna components
from sionna.mapping import Constellation, Mapper, Demapper
from sionna.utils import BinarySource, compute_ber, BinaryCrossentropy, ebnodb2no, PlotBER
from sionna.channel import AWGN
from sionna.fec.ldpc import LDPC5GEncoder, LDPC5GDecoder

class UncodedSystemAWGN(Model): 
    def __init__(self, n,constellation,NUM_BITS_PER_SYMBOL_psk):
        super().__init__() 
        self.num_bits_per_symbol = NUM_BITS_PER_SYMBOL_psk
        self.n = n
        self.k = int(n*1)
        self.coderate = 1
        self.constellation = constellation
        self.mapper = Mapper(constellation=self.constellation)
        self.demapper = Demapper("app", constellation=self.constellation, hard_out=True)
        self.binary_source = BinarySource()
        self.awgn_channel = AWGN()
    
    @tf.function(jit_compile=True) 
    def __call__(self, batch_size, ebno_db):
        no = ebnodb2no(ebno_db, num_bits_per_symbol=self.num_bits_per_symbol, coderate=1)
        bits = self.binary_source([batch_size, self.n])
        codewords = bits
        x = self.mapper(codewords)
        y = self.awgn_channel([x, no])
        bits_hat = self.demapper([y,no])
        return bits, bits_hat

class CodedSystemAWGN(Model): 
    def __init__(self, n, coderate, constellation,NUM_BITS_PER_SYMBOL):
        super().__init__() 
        self.num_bits_per_symbol = NUM_BITS_PER_SYMBOL
        self.n = n
        self.k = int(n*coderate)
        self.coderate = coderate
        self.constellation = constellation
        self.mapper = Mapper(constellation=self.constellation)
        self.demapper = Demapper("app", constellation=self.constellation)
        self.binary_source = BinarySource()
        self.awgn_channel = AWGN()
        self.encoder = LDPC5GEncoder(self.k, self.n)
        self.decoder = LDPC5GDecoder(self.encoder, hard_out=True)
    
    @tf.function(jit_compile=True) # activate graph execution to speed things up
    def __call__(self, batch_size, ebno_db):
        no = ebnodb2no(ebno_db, num_bits_per_symbol=self.num_bits_per_symbol, coderate=self.coderate)
        bits = self.binary_source([batch_size, self.k])
        codewords = self.encoder(bits)
        x = self.mapper(codewords)
        y = self.awgn_channel([x, no])
        llr = self.demapper([y,no])
        bits_hat = self.decoder(llr)
        return bits, bits_hat

NUM_BITS_PER_SYMBOL_qam = 4

constellation2 = Constellation("qam", NUM_BITS_PER_SYMBOL_qam)
constellation2.show();

NUM_BITS_PER_SYMBOL_psk = 3

real = 1 * np.cos(np.pi/4)
imag = 1 * np.sin(np.pi/4)
CONST_SHAPE = np.array([-1, 1, 1j, -1j, complex(real, imag), complex(real, -imag), complex(-real, imag), complex(-real, -imag)]) # set the shape of the constellation diagram
constellation1 = Constellation("custom", NUM_BITS_PER_SYMBOL_psk, CONST_SHAPE)
constellation1.show();

n = 1200
k = 800
coderate = k/n
model_coded_awgn = CodedSystemAWGN(n, coderate, constellation1,NUM_BITS_PER_SYMBOL_psk)
model_uncoded_awgn = UncodedSystemAWGN(n,constellation1,NUM_BITS_PER_SYMBOL_psk)
model_coded_awgn_2 = CodedSystemAWGN(n, coderate, constellation2,NUM_BITS_PER_SYMBOL_qam)
model_uncoded_awgn_2 = UncodedSystemAWGN(n,constellation2,NUM_BITS_PER_SYMBOL_qam)

ber_plots = PlotBER("AWGN")

ber_plots.simulate(model_uncoded_awgn,
                  ebno_dbs=tf.range(0,15),
                  batch_size=256,
                  num_target_block_errors=100, # simulate until 100 block errors occured
                  legend="Uncoded 8PSK",
                  soft_estimates=True,
                  max_mc_iter=100, # run 100 Monte-Carlo simulations (each with batch_size samples)
                  show_fig=False);

ber_plots.simulate(model_uncoded_awgn_2,
                  ebno_dbs=tf.range(0,15),
                  batch_size=256,
                  num_target_block_errors=100, # simulate until 100 block errors occured
                  legend="Uncoded 16QAM",
                  soft_estimates=True,
                  max_mc_iter=100, # run 100 Monte-Carlo simulations (each with batch_size samples)
                  show_fig=True);

ber_plots = PlotBER("AWGN")

ber_plots.simulate(model_coded_awgn,
                  ebno_dbs=tf.range(0,9),
                  batch_size=256,
                  num_target_block_errors=100, # simulate until 100 block errors occured
                  legend="Coded 8PSK",
                  soft_estimates=True,
                  max_mc_iter=100, # run 100 Monte-Carlo simulations (each with batch_size samples)
                  show_fig=False);

ber_plots.simulate(model_coded_awgn_2,
                  ebno_dbs=tf.range(0,9),
                  batch_size=256,
                  num_target_block_errors=100, # simulate until 100 block errors occured
                  legend="Coded 16QAM",
                  soft_estimates=True,
                  max_mc_iter=100, # run 100 Monte-Carlo simulations (each with batch_size samples)
                  show_fig=True);