OFDM Transmitter

An OFDM symbol is generated by applying the $N$-point IFFT to the frequency-domain data vector $\mathbf{X} = [X[0], \dots, X[N-1]]$:

$$x[n] = \frac{1}{\sqrt{N}} \sum_{k=0}^{N-1} X[k]\,e^{j2\pi kn/N}, \quad n = 0, \dots, N-1$$

def ofdm_symbol(data_symbols, N_fft):
    """Generate one OFDM symbol via IFFT."""
    X = np.zeros(N_fft, dtype=complex)
    X[:len(data_symbols)] = data_symbols
    x = np.fft.ifft(X) * np.sqrt(N_fft)
    return x

The cyclic prefix (CP) copies the last $N_{\text{CP}}$ samples of the OFDM symbol to the front:

$$\tilde{x}[n] = x[(n + N - N_{\text{CP}}) \bmod N], \quad n = 0, \dots, N + N_{\text{CP}} - 1$$

The CP must be longer than the maximum channel delay to prevent inter-symbol interference (ISI).

def add_cp(x, N_cp):
    """Add cyclic prefix."""
    return np.concatenate([x[-N_cp:], x])

def remove_cp(y, N_cp):
    """Remove cyclic prefix."""
    return y[N_cp:]

Not all $N$ subcarriers carry data. Typical allocation:

• Data subcarriers: carry QAM symbols
• Pilot subcarriers: carry known symbols for channel estimation
• Null subcarriers: DC and guard bands (set to zero)

def subcarrier_mapping(data, pilots, pilot_idx, null_idx, N_fft):
    X = np.zeros(N_fft, dtype=complex)
    data_idx = [i for i in range(N_fft) if i not in pilot_idx and i not in null_idx]
    X[data_idx[:len(data)]] = data
    X[pilot_idx] = pilots
    return X

The PAPR of an OFDM symbol is:

$$\text{PAPR} = \frac{\max_n |x[n]|^2}{E[|x[n]|^2]}$$

OFDM suffers from high PAPR because the IFFT sums many independent subcarriers. For $N$ subcarriers, PAPR can reach $10\log_{10}(N)$ dB in the worst case.

def compute_papr(x):
    """Compute PAPR in dB."""
    return 10 * np.log10(np.max(np.abs(x)**2) / np.mean(np.abs(x)**2))

The complete transmitter pipeline:

1. Bit generation $\to$ QAM mapping $\to$ Subcarrier allocation
2. IFFT $\to$ CP insertion $\to$ Parallel-to-serial

def ofdm_transmitter(bits, M, N_fft, N_cp, pilot_idx, null_idx):
    k = int(np.log2(M))
    constellation = qam_constellation(M)
    n_data = N_fft - len(pilot_idx) - len(null_idx)
    n_sym = len(bits) // (n_data * k)
    tx_signal = []
    for s in range(n_sym):
        data_bits = bits[s*n_data*k:(s+1)*n_data*k]
        data_syms = constellation[data_bits.reshape(-1,k).dot(1<<np.arange(k)[::-1]) % M]
        X = subcarrier_mapping(data_syms, np.ones(len(pilot_idx)), pilot_idx, null_idx, N_fft)
        x = np.fft.ifft(X) * np.sqrt(N_fft)
        tx_signal.append(add_cp(x, N_cp))
    return np.concatenate(tx_signal)