Monte Carlo BER simulator for Polar Code

[niniogolem]

Hello everyone! I am trying to develop a Monte Carlo simulator for X channel for selection of most reliable bit channel indexes of a generic polar code. The code has worked for AWGN channel, no problem. But when I go to Rayleigh channel, I cannot make it to outperform uncoded transmission! I have tried everything, from running more simulations (convergence issues), adding CRC aided SCL, adjusting SNR, using ZF and MMSE equalizer, clipping LLR (to 500) but no change, always no waterfall and the slope of coded and uncoded transmission is the same. I show the ber plots of awgn and rayleigh for comparison.

# Generador Monte Carlo de bits congelados con XLA acceleration

# Función compilada XLA para simulacion de batch_size
@tf.function(jit_compile=True)
def simulacion_batch_size(snr_prueba, bitsxsimb, batch_size, datos, codificador, mapeador, demapeador, decodificador):
    # Bloques de transmision
    bits = datos([batch_size, 1]) # solo 1 bit de datos por bit-canal
    bits_codif = codificador(bits) # codifica a N bits
    x = mapeador(bits_codif)

    # Canal Rayleigh
    no, h, y = canalRayleigh(snr_prueba, bitsxsimb, coderate=1.0/N, x=x) # solo 1 bit de datos por bit-canal

    # Bloques de recepcion
    mmse = tf.math.conj(h) / tf.cast(tf.math.square(tf.abs(h)) + no, tf.complex64)
    y_eq = mmse[:, tf.newaxis] * y
    no_eff = no * tf.math.square(tf.abs(mmse))
    llr = tf.clip_by_value(demapeador(y_eq, tf.expand_dims(no_eff, -1)), -LLR_clip, LLR_clip)
    bits_decodif = decodificador(llr)

    # Cálculo de errores y borrado de variables intermedias
    err = tf.math.count_nonzero(tf.not_equal(bits, bits_decodif), dtype=tf.int32)
    del bits, bits_codif, x, y, y_eq, llr, bits_decodif
    
    return tf.cast(err, tf.int64), tf.constant(batch_size, dtype=tf.int64)

# Parámetros de la simulacion
batch_size = 2000 # Emplea la VRAM de la GPU
num_iter = 10000 # Itera para incrementar simulaciones por bit-canal
# Info: Cada bit-canal se simula batch_size * num_iter veces
snr_prueba = 12.0 # Se observa similar BER que 4.0 dB en canal AWGN

# Inicializa los bloques necesarios
BER_bits = np.zeros(N)
datos = sionna.phy.mapping.BinarySource()
constelacion = sionna.phy.mapping.Constellation("pam", bitsxsimb)
mapeador = sionna.phy.mapping.Mapper(constellation=constelacion)
demapeador = sionna.phy.mapping.Demapper("app", constellation=constelacion)

for i in range(N):
    print(f"Procesando bit-canal {i+1}/{N}", end="", flush=True)

    # Se setean los bits congelados y reinicia conteo errores
    bits_congelados = np.array([j for j in range(N) if j != i]) # se analiza cada bit-canal
    codificador = sionna.phy.fec.polar.encoding.PolarEncoder(bits_congelados, N)
    decodificador = sionna.phy.fec.polar.decoding.PolarSCLDecoder(bits_congelados, N, list_size=list_scl)
    errores_totales = 0
    bits_totales = 0

    # Se itera varias veces para acumular errores
    for b in range(num_iter):
        # Ejecuta iteración compilada con XLA
        err, total = simulacion_batch_size(snr_prueba, bitsxsimb, batch_size, datos, codificador, mapeador, demapeador, decodificador)
        errores_totales += int(err.numpy())
        bits_totales += int(total.numpy())

    print()
    BER_bits[i] = errores_totales / bits_totales

# Resultados Monte Carlo
indices_ordenados = np.argsort(BER_bits)
bits_congelados = indices_ordenados[-(N-K):]

(it should said Rayleigh channel comparison)

[niniogolem]

I have tested that the Rayleigh Channel and the equalizer work ok, they do.

# Canal Rayleigh
@tf.function(jit_compile=True)
def canalRayleigh(ebno_db, bitsxsimb, coderate, x):
    bloque = tf.shape(x)[0]
    no = sionna.phy.utils.ebnodb2no(ebno_db, bitsxsimb, coderate=coderate)
    awgn_real = sionna.phy.config.tf_rng.normal(tf.shape(x), mean=0.0 ,stddev=tf.sqrt(no/2.0))
    awgn_imag = sionna.phy.config.tf_rng.normal(tf.shape(x), mean=0.0 ,stddev=tf.sqrt(no/2.0))
    awgn = tf.complex(awgn_real, awgn_imag)
    h_real = sionna.phy.config.tf_rng.normal([bloque], stddev=tf.sqrt(0.5), dtype=tf.float32)
    h_imag = sionna.phy.config.tf_rng.normal([bloque], stddev=tf.sqrt(0.5), dtype=tf.float32)
    h = tf.complex(h_real, h_imag)
    y = tf.expand_dims(h, -1) * x + awgn
    return no, h, y

[niniogolem]

I found the solution! in case anyone has similar issues, the thing was that block fading due to h was distorting the code performance. I had to change to h by symbol instead of by block. so I plan to add an interleaver to the code with block fading, to simulate the same diversity. I have also made public my code.