GoogleColab によるpythonで行う太陽電池に使用する反射防止膜の光学シミュレーター

!pip install numpy
!pip install scipy
!pip install matplotlib

import numpy as np
import matplotlib.pyplot as plt

def fresnel_coefficients(theta, n1, n2):
    theta_t = np.arcsin(n1 * np.sin(theta) / n2)
    r_s = (n1 * np.cos(theta) - n2 * np.cos(theta_t)) / (n1 * np.cos(theta) + n2 * np.cos(theta_t))
    r_p = (n1 * np.cos(theta_t) - n2 * np.cos(theta)) / (n1 * np.cos(theta_t) + n2 * np.cos(theta))
    t_s = 1 + r_s
    t_p = 1 + r_p
    return r_s, r_p, t_s, t_p

def transfer_matrix_method(layers, theta, wavelengths):
    R = np.zeros_like(wavelengths)
    T = np.zeros_like(wavelengths)

    for i, wavelength in enumerate(wavelengths):
        n = [layer["n"](wavelength) for layer in layers]
        d = [layer["d"] for layer in layers]

        M = np.identity(2)
        for j in range(1, len(layers) - 1):
            n_j, n_j1 = n[j], n[j + 1]
            d_j = d[j]
            theta_j = np.arcsin(n[0] * np.sin(theta) / n_j)
            theta_j1 = np.arcsin(n_j * np.sin(theta_j) / n_j1)
            delta = 2 * np.pi * n_j * d_j * np.cos(theta_j) / wavelength

            M_j = np.array([[np.cos(delta), 1j * np.sin(delta) / (n_j * np.cos(theta_j))],
                           [1j * n_j * np.sin(delta) * np.cos(theta_j), np.cos(delta)]])
            M = np.dot(M, M_j)

       r_s, r_p, t_s, t_p = fresnel_coefficients(theta, n[0], n[-1])
       M = np.dot(M, np.array([[t_s, 0], [0, t_p]]))
       M = np.linalg.inv(M)

       r_s, r_p, t_s, t_p = fresnel_coefficients(theta, n[-1], n[0])
       M = np.dot(M, np.array([[t_s, 0], [0, t_p]]))

       r = np.abs(M[1, 0] / M[0, 0])
       t = 1 / np.abs(M[0, 0])

       R[i] = r ** 2
       T[i] = t ** 2

    return R, T

def plot_reflectance_transmittance(wavelengths, R, T):
    plt.figure()
    plt.plot(wavelengths, R, label='Reflectance')
    plt.plot(wavelengths, T, label='Transmittance')
    plt.xlabel('Wavelength (nm)')
    plt.ylabel('Fraction')
    plt.legend()
    plt.show()

wavelengths = np.linspace(300, 800, 500)

# 空気、反射防止フィルム (シリコン窒化物)、太陽電池 (シリコン) の屈折率データ
n_air = 1
n_si3n4 = 2.1
n_si = 3.5

# 層構造の定義
layers = [
    {"n": lambda wl: n_air, "d": 0},
    {"n": lambda wl: n_si3n4, "d": 100},
    {"n": lambda wl: n_si, "d": 0},
]

theta = np.radians(8) # 入射角 (8°)
R, T = transfer_matrix_method(layers, theta, wavelengths)
plot_reflectance_transmittance(wavelengths, R, T)

from scipy.optimize import minimize

def optimize_AR_coating(layers, theta, wavelengths):
    def objective(x):
        layers[1]["n"] = lambda wl: x[0]
        layers[1]["d"] = x[1]
        R, _ = transfer_matrix_method(layers, theta, wavelengths)
        return np.mean(R)

    initial_guess = [2.1, 100]
    bounds = [(1.0, None), (0, None)] # 屈折率は1以上、膜厚は0以上
    result = minimize(objective, initial_guess, method='L-BFGS-B', bounds=bounds)
    return result.x

optimal_n, optimal_d = optimize_AR_coating(layers, theta, wavelengths)
print(f"Optimal refractive index: {optimal_n:.4f}")
print(f"Optimal thickness (nm): {optimal_d:.4f}")

# 最適化された反射防止膜の層構造を定義
optimized_layers = [
    {"n": lambda wl: n_air, "d": 0},
    {"n": lambda wl: optimal_n, "d": optimal_d},
    {"n": lambda wl: n_si, "d": 0},
]

R_opt, T_opt = transfer_matrix_method(optimized_layers, theta, wavelengths)
plot_reflectance_transmittance(wavelengths, R_opt, T_opt)