Generating Fading Channels

A Rayleigh fading channel coefficient is:

$$h \sim \mathcal{CN}(0, \sigma^2)$$

The envelope $|h|$ follows a Rayleigh distribution with parameter $\sigma$, and the power $|h|^2$ follows an exponential distribution with mean $\sigma^2$.

rng = np.random.default_rng(42)
N = 100000
h = (rng.standard_normal(N) + 1j * rng.standard_normal(N)) \
    * np.sqrt(sigma2 / 2)

The Rayleigh model applies when there is no dominant line-of-sight path and many scattered multipath components contribute to the signal.

A Ricean fading channel with $K$-factor $K$ is:

$$h = \sqrt{\frac{K}{K+1}}\,h_{\mathrm{LOS}} + \sqrt{\frac{1}{K+1}}\,h_{\mathrm{NLOS}}$$

where $h_{\mathrm{LOS}} = e^{j\phi}$ is the deterministic LOS component and $h_{\mathrm{NLOS}} \sim \mathcal{CN}(0, 1)$.

The envelope $|h|$ follows a Rice distribution. When $K = 0$, Ricean reduces to Rayleigh; as $K \to \infty$, the channel becomes AWGN.

def rice_channel(K, N, rng):
    h_los = np.exp(1j * rng.uniform(0, 2*np.pi))
    h_nlos = (rng.standard_normal(N)
              + 1j * rng.standard_normal(N)) / np.sqrt(2)
    return np.sqrt(K/(K+1)) * h_los \
         + np.sqrt(1/(K+1)) * h_nlos

The Nakagami-$m$ distribution generalizes Rayleigh ($m=1$) and approximates Rice. The envelope PDF is:

$$f_{|h|}(r) = \frac{2m^m r^{2m-1}}{\Gamma(m)\Omega^m} \exp\!\left(-\frac{mr^2}{\Omega}\right), \quad r \ge 0$$

where $\Omega = E[|h|^2]$ and $m \ge 1/2$.

from scipy.stats import nakagami
m = 2.0
samples = nakagami.rvs(m, scale=np.sqrt(omega), size=N)

The power $|h|^2$ follows a Gamma distribution: $|h|^2 \sim \Gamma(m, \Omega/m)$.

For an $N_r \times N_t$ MIMO system, the Kronecker model generates:

$$\mathbf{H} = \mathbf{R}_r^{1/2} \mathbf{H}_w (\mathbf{R}_t^{1/2})^T$$

where $\mathbf{H}_w$ has i.i.d. $\mathcal{CN}(0,1)$ entries, $\mathbf{R}_r \in \mathbb{C}^{N_r \times N_r}$ is the receive correlation, and $\mathbf{R}_t \in \mathbb{C}^{N_t \times N_t}$ is the transmit correlation.

def kronecker_mimo(Rr, Rt, rng):
    Nr, Nt = Rr.shape[0], Rt.shape[0]
    Lr = np.linalg.cholesky(Rr)
    Lt = np.linalg.cholesky(Rt)
    Hw = (rng.standard_normal((Nr, Nt))
          + 1j * rng.standard_normal((Nr, Nt))) / np.sqrt(2)
    return Lr @ Hw @ Lt.T

For a mobile terminal moving at velocity $v$, the maximum Doppler frequency is $f_d = v f_c / c$ and the channel autocorrelation is:

$$R_h(\tau) = J_0(2\pi f_d \tau)$$

where $J_0$ is the zeroth-order Bessel function. To generate time-correlated samples at sampling rate $f_s$:

1. Build the autocorrelation matrix $[\mathbf{R}]_{ij} = J_0(2\pi f_d |i-j|/f_s)$
2. Apply Cholesky: $\mathbf{h} = \mathbf{L}\mathbf{z}$

Alternatively, filter white noise through the Doppler spectrum:

$$S_h(f) = \frac{1}{\pi f_d \sqrt{1 - (f/f_d)^2}}, \quad |f| \le f_d$$

from scipy.special import j0
R = j0(2 * np.pi * fd * np.abs(
    np.arange(N)[:, None] - np.arange(N)[None, :]) / fs)

The 3GPP defines standardized channel models (TR 38.901) with:

• Delay profiles: TDL-A through TDL-E (tapped delay line models)
• Cluster-based: each cluster has a delay, angle of arrival/departure, and power
• Large-scale parameters: path loss, shadow fading, $K$-factor, delay spread, angular spread

For Python simulation, the key steps are:

1. Select a TDL model (e.g., TDL-A for NLOS)
2. Scale delays by desired delay spread
3. Generate per-tap Rayleigh or Ricean coefficients
4. Apply Doppler filtering per tap

# TDL-A model (simplified)
tdl_a_delays = np.array([0, 30, 70, 90, 110, 190, 410]) * 1e-9
tdl_a_powers_db = np.array([0, -1, -2, -3, -8, -17.2, -20.8])
tdl_a_powers = 10 ** (tdl_a_powers_db / 10)
tdl_a_powers /= tdl_a_powers.sum()  # normalize