アンテナのインピーダンス整合 — 反射を最小化して効率的に電力を供給する

import numpy as np
import matplotlib.pyplot as plt

def draw_smith_chart(ax, color_grid="#444444", alpha_grid=0.4):
    """スミスチャートの等抵抗円と等リアクタンス円を描画"""
    # 単位円（外枠）
    theta_circle = np.linspace(0, 2 * np.pi, 361)
    ax.plot(np.cos(theta_circle), np.sin(theta_circle), color="white", linewidth=1.5)

    # 等抵抗円 r = const.
    r_values = [0, 0.2, 0.5, 1.0, 2.0, 5.0]
    for r in r_values:
        center_x = r / (1 + r)
        radius = 1 / (1 + r)
        circle_theta = np.linspace(0, 2 * np.pi, 361)
        cx = center_x + radius * np.cos(circle_theta)
        cy = radius * np.sin(circle_theta)
        # 単位円内部のみ描画
        mask = cx**2 + cy**2 <= 1.01
        cx_masked = np.where(mask, cx, np.nan)
        cy_masked = np.where(mask, cy, np.nan)
        ax.plot(cx_masked, cy_masked, color=color_grid, linewidth=0.8, alpha=alpha_grid)

    # 等リアクタンス円 x = const.
    x_values = [0.2, 0.5, 1.0, 2.0, 5.0]
    for x in x_values:
        center_x = 1.0
        center_y = 1.0 / x
        radius = 1.0 / abs(x)
        arc_theta = np.linspace(0, 2 * np.pi, 361)
        cx = center_x + radius * np.cos(arc_theta)
        cy_pos = center_y + radius * np.sin(arc_theta)  # +x
        cy_neg = -center_y + radius * np.sin(arc_theta)  # -x
        # 単位円内部のみ
        for cy in [cy_pos, cy_neg]:
            mask = cx**2 + cy**2 <= 1.01
            cx_masked = np.where(mask, cx, np.nan)
            cy_masked = np.where(mask, cy, np.nan)
            ax.plot(cx_masked, cy_masked, color=color_grid, linewidth=0.8,
                    alpha=alpha_grid)

    # 実軸
    ax.plot([-1, 1], [0, 0], color=color_grid, linewidth=0.8, alpha=alpha_grid)

    # チャートの設定
    ax.set_xlim([-1.15, 1.15])
    ax.set_ylim([-1.15, 1.15])
    ax.set_aspect("equal")
    ax.set_facecolor("#1a1a2e")
    ax.axis("off")

def z_to_gamma(z):
    """正規化インピーダンス z から反射係数 Γ を計算"""
    return (z - 1) / (z + 1)

def gamma_to_z(gamma):
    """反射係数 Γ から正規化インピーダンス z を計算"""
    return (1 + gamma) / (1 - gamma)

# スミスチャートの描画テスト
fig, ax = plt.subplots(figsize=(8, 8))
fig.patch.set_facecolor("#1a1a2e")
draw_smith_chart(ax)

# いくつかのインピーダンス点をプロット
impedances = {
    "50 Ω (matched)": 1.0 + 0j,
    "100 + j50 Ω": 2.0 + 1.0j,
    "25 - j30 Ω": 0.5 - 0.6j,
    "Open": 100 + 0j,
    "Short": 0.01 + 0j,
}

colors = ["#00e5ff", "#e040fb", "#ffca28", "#76ff03", "#ff6e40"]
for (label, z), color in zip(impedances.items(), colors):
    gamma = z_to_gamma(z)
    ax.plot(gamma.real, gamma.imag, "o", color=color, markersize=10)
    ax.annotate(label, (gamma.real, gamma.imag), fontsize=9, color=color,
                textcoords="offset points", xytext=(10, 10))

ax.set_title("Smith Chart with Impedance Points", fontsize=14, color="white", pad=15)
plt.tight_layout()
plt.savefig("smith_chart_basic.png", dpi=150, bbox_inches="tight",
            facecolor="#1a1a2e")
plt.show()

import numpy as np
import matplotlib.pyplot as plt

def draw_smith_chart(ax, color_grid="#444444", alpha_grid=0.4):
    """スミスチャートの描画（簡略版）"""
    theta_circle = np.linspace(0, 2 * np.pi, 361)
    ax.plot(np.cos(theta_circle), np.sin(theta_circle), color="white", linewidth=1.5)

    r_values = [0, 0.2, 0.5, 1.0, 2.0, 5.0]
    for r in r_values:
        center_x = r / (1 + r)
        radius = 1 / (1 + r)
        cx = center_x + radius * np.cos(theta_circle)
        cy = radius * np.sin(theta_circle)
        mask = cx**2 + cy**2 <= 1.01
        ax.plot(np.where(mask, cx, np.nan), np.where(mask, cy, np.nan),
                color=color_grid, linewidth=0.8, alpha=alpha_grid)

    x_values = [0.2, 0.5, 1.0, 2.0, 5.0]
    for x in x_values:
        radius = 1.0 / abs(x)
        cx = 1.0 + radius * np.cos(theta_circle)
        for sign in [1, -1]:
            cy = sign / x + radius * np.sin(theta_circle)
            mask = cx**2 + cy**2 <= 1.01
            ax.plot(np.where(mask, cx, np.nan), np.where(mask, cy, np.nan),
                    color=color_grid, linewidth=0.8, alpha=alpha_grid)

    ax.plot([-1, 1], [0, 0], color=color_grid, linewidth=0.8, alpha=alpha_grid)
    ax.set_xlim([-1.15, 1.15])
    ax.set_ylim([-1.15, 1.15])
    ax.set_aspect("equal")
    ax.set_facecolor("#1a1a2e")
    ax.axis("off")

# 設計パラメータ
Z0 = 50          # 特性インピーダンス [Ω]
ZL = 100 + 50j   # 負荷インピーダンス [Ω]
f = 1e9          # 周波数 [Hz]

zL = ZL / Z0     # 正規化
yL = 1 / zL      # 正規化アドミタンス

# R_L > Z0 なのでタイプ1（並列→直列）
RL = ZL.real
XL = ZL.imag

# 並列素子のサセプタンス B の計算
disc = RL / Z0 * (RL**2 + XL**2 - Z0 * RL)
if disc < 0:
    print("タイプ1では整合できません")
else:
    B1 = (XL + np.sqrt(disc)) / (RL**2 + XL**2)
    B2 = (XL - np.sqrt(disc)) / (RL**2 + XL**2)

    # 直列素子のリアクタンス X
    X1 = 1/B1 + XL*Z0/RL - Z0/(B1*RL)
    X2 = 1/B2 + XL*Z0/RL - Z0/(B2*RL)

# スミスチャート上の軌跡を計算
fig, axes = plt.subplots(1, 2, figsize=(16, 8))
fig.patch.set_facecolor("#1a1a2e")

solutions = [(B1, X1, "Solution 1"), (B2, X2, "Solution 2")]
colors_sol = [["#00e5ff", "#e040fb"], ["#ffca28", "#76ff03"]]

for idx, (B, X, title) in enumerate(solutions):
    ax = axes[idx]
    draw_smith_chart(ax)

    # ステップ1: 並列素子 jB を追加（アドミタンス面上で等gに沿って移動）
    # 負荷のアドミタンス yL から yL + jB*Z0 へ
    b_norm = B * Z0  # 正規化サセプタンス
    n_points = 100
    b_sweep = np.linspace(0, b_norm, n_points)
    z_path1 = []
    for b in b_sweep:
        y = yL + 1j * b
        z = 1 / y
        gamma = (z - 1) / (z + 1)
        z_path1.append(gamma)
    z_path1 = np.array(z_path1)
    ax.plot(z_path1.real, z_path1.imag, color=colors_sol[idx][0], linewidth=2.5,
            label=f"Step 1: Parallel B={B*1e3:.2f} mS")

    # ステップ1終了後のインピーダンス
    y_after = yL + 1j * b_norm
    z_after = 1 / y_after

    # ステップ2: 直列素子 jX を追加（等rに沿って移動）
    x_norm = -X / Z0  # 正規化リアクタンス（符号注意: 打ち消し）
    x_sweep = np.linspace(0, x_norm, n_points)
    z_path2 = []
    for x in x_sweep:
        z = z_after - 1j * x  # 直列リアクタンスを引いて整合点へ
        gamma = (z - 1) / (z + 1)
        z_path2.append(gamma)
    z_path2 = np.array(z_path2)

    # 正しく計算: 直列 jX を加える（Z_after_physical + jX）
    z_phys_after = z_after * Z0
    x_sweep2 = np.linspace(0, -X, n_points)
    z_path2 = []
    for x in x_sweep2:
        z_phys = z_phys_after + 1j * x
        z_norm = z_phys / Z0
        gamma = (z_norm - 1) / (z_norm + 1)
        z_path2.append(gamma)
    z_path2 = np.array(z_path2)
    ax.plot(z_path2.real, z_path2.imag, color=colors_sol[idx][1], linewidth=2.5,
            label=f"Step 2: Series X={-X:.1f} Ω")

    # 始点と終点
    gamma_L = (zL - 1) / (zL + 1)
    ax.plot(gamma_L.real, gamma_L.imag, "o", color="white", markersize=12, zorder=5)
    ax.annotate(f"$Z_L$ = {ZL:.0f} Ω", (gamma_L.real, gamma_L.imag),
                fontsize=10, color="white", textcoords="offset points", xytext=(10, 10))
    ax.plot(0, 0, "*", color="#ff6e40", markersize=15, zorder=5)
    ax.annotate("Matched", (0, 0), fontsize=10, color="#ff6e40",
                textcoords="offset points", xytext=(10, -15))

    ax.set_title(title, fontsize=14, color="white", pad=15)
    ax.legend(fontsize=10, loc="lower left", facecolor="#1a1a2e",
              edgecolor="white", labelcolor="white")

plt.tight_layout()
plt.savefig("l_matching_smith.png", dpi=150, bbox_inches="tight",
            facecolor="#1a1a2e")
plt.show()

# 設計結果の表示
omega = 2 * np.pi * f
print("=" * 50)
print(f"負荷: Z_L = {ZL} Ω")
print(f"目標: Z_0 = {Z0} Ω")
print(f"周波数: {f/1e9:.1f} GHz")
print("=" * 50)

for i, (B, X, title) in enumerate(solutions):
    print(f"\n{title}:")
    print(f"  並列サセプタンス B = {B*1e3:.3f} mS")
    if B > 0:
        C = B / omega
        print(f"  → 並列キャパシタ C = {C*1e12:.2f} pF")
    else:
        L = -1 / (omega * B)
        print(f"  → 並列インダクタ L = {L*1e9:.2f} nH")

    print(f"  直列リアクタンス X = {-X:.2f} Ω")
    if -X > 0:
        L = -X / omega
        print(f"  → 直列インダクタ L = {L*1e9:.2f} nH")
    else:
        C = 1 / (omega * X)
        print(f"  → 直列キャパシタ C = {C*1e12:.2f} pF")

import numpy as np
import matplotlib.pyplot as plt

def quarter_wave_vswr(f, f0, Z0, ZL):
    """λ/4変成器のVSWRを周波数の関数として計算"""
    Z1 = np.sqrt(Z0 * ZL)  # 変成器の特性インピーダンス
    beta_l = (np.pi / 2) * (f / f0)  # β × l（設計周波数でπ/2）

    # 入力インピーダンス
    tan_bl = np.tan(beta_l)
    # 特異点の処理
    with np.errstate(divide="ignore", invalid="ignore"):
        Zin = Z1 * (ZL + 1j * Z1 * tan_bl) / (Z1 + 1j * ZL * tan_bl)

    # 反射係数
    Gamma = (Zin - Z0) / (Zin + Z0)
    Gamma_mag = np.abs(Gamma)

    # VSWR
    vswr = (1 + Gamma_mag) / (1 - Gamma_mag + 1e-10)
    return vswr, Gamma_mag

f0 = 10e9  # 設計周波数 [Hz]
Z0 = 50    # 特性インピーダンス [Ω]

f = np.linspace(0.1 * f0, 2.5 * f0, 1000)

# 異なるインピーダンス比
ZL_values = [75, 100, 200, 500]

fig, axes = plt.subplots(1, 2, figsize=(14, 6))

colors = ["#00e5ff", "#e040fb", "#ffca28", "#76ff03"]
for ZL, color in zip(ZL_values, colors):
    vswr, gamma = quarter_wave_vswr(f, f0, Z0, ZL)
    Z1 = np.sqrt(Z0 * ZL)

    axes[0].plot(f / f0, vswr, color=color, linewidth=2,
                 label=f"$Z_L$ = {ZL} Ω ($Z_1$ = {Z1:.1f} Ω)")
    axes[1].plot(f / f0, -20 * np.log10(gamma + 1e-10), color=color, linewidth=2,
                 label=f"$Z_L$ = {ZL} Ω")

# VSWR = 2 の基準線
axes[0].axhline(y=2, color="red", linestyle="--", alpha=0.5, linewidth=1)
axes[0].text(0.15, 2.1, "VSWR = 2", fontsize=10, color="red")

axes[0].set_xlabel(r"$f / f_0$", fontsize=13)
axes[0].set_ylabel("VSWR", fontsize=13)
axes[0].set_title("Quarter-Wave Transformer: VSWR vs Frequency", fontsize=13)
axes[0].legend(fontsize=10, loc="upper left")
axes[0].grid(True, alpha=0.3)
axes[0].set_xlim([0.1, 2.5])
axes[0].set_ylim([1, 12])

axes[1].axhline(y=10, color="red", linestyle="--", alpha=0.5, linewidth=1)
axes[1].text(0.15, 11, "RL = 10 dB", fontsize=10, color="red")

axes[1].set_xlabel(r"$f / f_0$", fontsize=13)
axes[1].set_ylabel("Return Loss [dB]", fontsize=13)
axes[1].set_title("Quarter-Wave Transformer: Return Loss vs Frequency", fontsize=13)
axes[1].legend(fontsize=10, loc="lower left")
axes[1].grid(True, alpha=0.3)
axes[1].set_xlim([0.1, 2.5])
axes[1].set_ylim([0, 50])

plt.tight_layout()
plt.savefig("quarter_wave_bandwidth.png", dpi=150, bbox_inches="tight")
plt.show()