Mastering Smith Charts: The Ultimate Guide to RF Impedance Matching

import numpy as np
import matplotlib.pyplot as plt

def impedance_to_gamma(z, z0=50):
    """Convert impedance to reflection coefficient"""
    z_norm = z / z0
    gamma = (z_norm - 1) / (z_norm + 1)
    return gamma

def gamma_to_impedance(gamma, z0=50):
    """Convert reflection coefficient to impedance"""
    z_norm = (1 + gamma) / (1 - gamma)
    return z_norm * z0

# Example: 75Ω load with 50Ω characteristic impedance
z_load = 75 + 0j  # Pure resistance
gamma = impedance_to_gamma(z_load)
print(f"Reflection coefficient: {gamma:.3f}")
print(f"Magnitude: {abs(gamma):.3f}, Phase: {np.angle(gamma, deg=True):.1f}°")

// Smith Chart transmission line calculator
function transformImpedance(zLoad, lineLength, frequency, z0 = 50) {
    const c = 299792458; // Speed of light
    const wavelength = c / frequency;
    const beta = 2 * Math.PI / wavelength;
    
    // Convert to normalized impedance
    const zNorm = zLoad / z0;
    
    // Calculate reflection coefficient
    const gamma = (zNorm - 1) / (zNorm + 1);
    
    // Rotate by electrical length (toward generator)
    const electricalLength = lineLength / wavelength;
    const phaseShift = -4 * Math.PI * electricalLength;
    const gammaRotated = gamma * Math.exp(1j * phaseShift);
    
    // Convert back to impedance
    const zNormNew = (1 + gammaRotated) / (1 - gammaRotated);
    return zNormNew * z0;
}

// Example: 100Ω load, λ/8 line at 1GHz
const result = transformImpedance(100, 0.0375, 1e9);
console.log(`Transformed impedance: ${result.real.toFixed(1)} + j${result.imag.toFixed(1)}Ω`);

import numpy as np

def design_l_network(z_load, z0=50, freq=1e9):
    """Design L-network to match load to z0"""
    # Normalize load impedance
    z_norm = z_load / z0
    r_norm = z_norm.real
    x_norm = z_norm.imag
    
    # Calculate Q factor for the network
    if r_norm < 1:
        # Shunt-first topology
        Q = np.sqrt((1/r_norm) - 1)
        x_series = Q * r_norm
        b_shunt = (x_norm + x_series) / (r_norm**2 + (x_norm + x_series)**2)
    else:
        # Series-first topology  
        Q = np.sqrt(r_norm - 1)
        x_series = x_norm + Q
        b_shunt = -Q / r_norm
    
    # Convert to component values
    omega = 2 * np.pi * freq
    
    if x_series > 0:
        L_series = (x_series * z0) / omega
        C_series = None
    else:
        L_series = None
        C_series = -1 / (omega * x_series * z0)
    
    if b_shunt > 0:
        C_shunt = (b_shunt) / (omega * z0)
        L_shunt = None
    else:
        C_shunt = None
        L_shunt = -z0 / (omega * b_shunt)
    
    return {
        'Q': Q,
        'L_series': L_series,
        'C_series': C_series,
        'L_shunt': L_shunt,
        'C_shunt': C_shunt
    }

# Example: Match 10+j20Ω load at 900MHz
result = design_l_network(10+20j, freq=900e6)
print(f"Network Q: {result['Q']:.2f}")
if result['L_series']:
    print(f"Series inductor: {result['L_series']*1e9:.1f}nH")
if result['C_shunt']:
    print(f"Shunt capacitor: {result['C_shunt']*1e12:.1f}pF")

# Advanced Smith Chart analysis for filter design
def analyze_filter_response(s_params, freqs):
    """Analyze filter S-parameters on Smith Chart"""
    z0 = 50
    results = []
    
    for i, freq in enumerate(freqs):
        s11 = s_params[i, 0, 0]  # Input reflection
        s22 = s_params[i, 1, 1]  # Output reflection
        
        # Convert S-parameters to impedance
        z_in = z0 * (1 + s11) / (1 - s11)
        z_out = z0 * (1 + s22) / (1 - s22)
        
        # Calculate VSWR and return loss
        vswr_in = (1 + abs(s11)) / (1 - abs(s11))
        vswr_out = (1 + abs(s22)) / (1 - abs(s22))
        rl_in = -20 * np.log10(abs(s11))
        rl_out = -20 * np.log10(abs(s22))
        
        results.append({
            'frequency': freq,
            'z_in': z_in,
            'z_out': z_out,
            'vswr_in': vswr_in,
            'vswr_out': vswr_out,
            'return_loss_in': rl_in,
            'return_loss_out': rl_out
        })
    
    return results

# Stability analysis for amplifiers
def stability_analysis(s_params):
    """Analyze amplifier stability using S-parameters"""
    s11, s12, s21, s22 = s_params
    delta = s11*s22 - s12*s21
    
    # Rollett stability factor
    K = (1 - abs(s11)**2 - abs(s22)**2 + abs(delta)**2) / (2*abs(s12*s21))
    
    # Additional stability check
    stable = K > 1 and abs(delta) < 1
    
    return {
        'K_factor': K,
        'delta': delta,
        'unconditionally_stable': stable
    }

# Modern Smith Chart workflow with scikit-rf
import skrf as rf
import numpy as np
import matplotlib.pyplot as plt

# Load measurement data
ntwk = rf.Network('antenna_measurement.s1p')

# Create Smith Chart plot
fig, ax = plt.subplots(subplot_kw={'projection': 'smith'})

# Plot impedance data
ax.plot(ntwk.s_smith[:, 0, 0], label='Measured Data')

# Add VSWR circles
for vswr in [1.5, 2.0, 3.0]:
    gamma = (vswr - 1) / (vswr + 1)
    circle = plt.Circle((0, 0), gamma, fill=False, 
                       linestyle='--', alpha=0.5)
    ax.add_patch(circle)

# Customize plot
ax.set_title('Antenna Impedance vs Frequency')
ax.legend()
plt.tight_layout()
plt.show()

# Calculate matching network
z_target = 50  # Target impedance
matching_ntwk = ntwk.shunt_capacitor(1e-12)  # Add 1pF shunt cap
matching_ntwk = matching_ntwk.series_inductor(10e-9)  # Add 10nH series L

# Verify matching performance
print(f"Original VSWR: {ntwk.s_vswr.mean():.2f}")
print(f"Matched VSWR: {matching_ntwk.s_vswr.mean():.2f}")

# Optimization example: minimize VSWR across frequency band
import scipy.optimize as opt

def vswr_objective(params, freq_array, z_load_array):
    """Objective function for matching network optimization"""
    L_series, C_shunt = params
    vswr_values = []
    
    for freq, z_load in zip(freq_array, z_load_array):
        omega = 2 * np.pi * freq
        
        # Apply series L and shunt C
        z_intermediate = z_load + 1j * omega * L_series
        y_intermediate = 1 / z_intermediate
        y_final = y_intermediate + 1j * omega * C_shunt
        z_final = 1 / y_final
        
        # Calculate VSWR
        gamma = (z_final - 50) / (z_final + 50)
        vswr = (1 + abs(gamma)) / (1 - abs(gamma))
        vswr_values.append(vswr)
    
    # Return maximum VSWR (minimize worst case)
    return max(vswr_values)

# Optimization setup
freq_range = np.linspace(800e6, 1200e6, 50)
z_load_freq = 20 + 1j * 30 * (freq_range / 1e9)  # Frequency-dependent load

# Optimize matching network
initial_guess = [10e-9, 5e-12]  # Initial L, C values
bounds = [(1e-9, 100e-9), (1e-12, 50e-12)]  # Component value bounds

result = opt.minimize(vswr_objective, initial_guess, 
                     args=(freq_range, z_load_freq),
                     bounds=bounds, method='L-BFGS-B')

print(f"Optimal L: {result.x[0]*1e9:.1f}nH")
print(f"Optimal C: {result.x[1]*1e12:.1f}pF")
print(f"Maximum VSWR: {result.fun:.2f}")