TIDY3D
LEARNING CENTER

Lectures
Tutorials
Applications

Example Library / Nanophotonics / Light extraction efficiency calculation of a square-shaped µ-LED

Light extraction efficiency calculation of a square-shaped µ-LED

Sign up now to simulate .ipynb

Note: The FC cost of running this notebook is larger than 100 FCs.

Micro-light-emitting diodes (µ-LEDs) based on InGaN have attracted significant attention as next-generation display technologies, with potential applications ranging from high-resolution panels to augmented and virtual reality systems. As µ-LED dimensions shrink, ensuring high internal quantum efficiency (IQE) and, critically, light extraction efficiency (LEE) becomes increasingly challenging. LEE, in particular, is strongly influenced by structural parameters such as chip cross-sectional geometry, lateral size, and p-GaN thickness.

The finite-difference time-domain (FDTD) method is a powerful tool for predicting and optimizing LEE, allowing systematic evaluation of design variations. These simulations, however, can be very computationally expensive and time-consuming, especially when sweeping a large number of parameters.

Hence, Tidy3D GPU-accelerated solver is the perfect tool to tackle these problems, where large simulations can be handled extremely fast, and in parallel. This makes it possible to complete in just a few hours a workload that would take weeks using other solvers on traditional HPC systems.

In this notebook, we will reproduce some results from the paper by Han-Youl Ryu, Jeongsang Pyo, and Hyun Yeol Ryu, *"Light Extraction Efficiency of GaN-Based Micro-Scale Light-Emitting Diodes Investigated Using Finite-Difference Time-Domain Simulation,"* IEEE Photonics Journal (2020). DOI:10.1109/JPHOT.2020.2977401.

First, we will calculate the LEE of a square LED as a function of its cross-sectional size and reflector absorption. Next, we will investigate the relation between LEE and p-GaN layer thickness. Finally, we will verify that, for larger LED sizes, the LEE is well represented by just a single dipole at the center, and that simulating and averaging multiple dipoles at different positions has little effect, greatly reducing computational cost.

Schematic of the experiment

For more information, please refer to our learning center, where you can find more examples involving LEDs among many other structures.

import matplotlib.pyplot as plt
import numpy as np
import tidy3d as td
import tidy3d.web as web

Since the notebook explores many parameter spaces, the cost of running it in full is quite high. For this reason, the global RUN parameter is set to False by default, to prevent unintentional execution.

RUN = False

Simulation Setup

First we will define global parameters that will be used in the simulation

# Set logging level to ERROR to avoid too many messages related to long runtimes
td.config.logging.level = "ERROR"

# Operation wavelength and frequency
wl1 = 0.440
wl2 = 0.480

f1 = td.C_0 / wl2
f2 = td.C_0 / wl1

fwidth = (f2 - f1) / 2
freq0 = f1 + fwidth
wl0 = td.C_0 / freq0

source_time = td.GaussianPulse(freq0=freq0, fwidth=fwidth)

# Define heights
nGanHeight = 3
MQWHeight = 0.05
reflectorThickness = 0.5

# Wavelength to monitor LEE
wvl_analysis = np.linspace(0.469, 0.472, 11)
freq_analysis = td.C_0 / wvl_analysis

Next we will define an auxiliary function to create the LED structure. The structure is defined by a stack of p-GaN, InGaN MQW and n-GaN on top of a silver reflector.

def createStructure(pGanHeight=0.1, size=3, GANExtinctionCoef=30):
    """
    Create a layered µ-LED structure.

    Parameters
    ----------
    pGanHeight : float
        Thickness of the p-GaN layer (in µm).
    size : float
        Lateral size of the LED (in µm).
    GANExtinctionCoef : float
        Extinction coefficient of GaN (in cm⁻¹).

    Returns
    -------
    structure : list
        List of Tidy3D Structure objects representing the LED layers.
    z_MQW_center : float
        z-coordinate of the MQW layer center.
    MQWHeight : float
        Thickness of the MQW region (in µm).
    dimensions : tuple
        Overall dimensions of the LED (Lx, Ly, total height).
    """

    L = size

    # Define materials
    reflectorThickness = 0.5
    kGan = GANExtinctionCoef * (wl0 * 10**-4) / (4 * np.pi)
    nGanMedium = td.Medium.from_nk(n=2.45, k=kGan, freq=freq0)
    MQWMedium = td.Medium.from_nk(n=2.49, k=0, freq=freq0)
    pGanMedium = td.Medium.from_nk(n=2.45, k=kGan, freq=freq0)
    reflectorMedium = td.Lorentz.from_nk(n=0.14, k=2.47, freq=freq0)

    # Compute z centers
    z_reflector_center = reflectorThickness / 2
    z_pGan_center = reflectorThickness + pGanHeight / 2
    z_MQW_center = reflectorThickness + pGanHeight + MQWHeight / 2
    z_nGan_center = reflectorThickness + pGanHeight + MQWHeight + nGanHeight / 2

    reflector_box = td.Box(
        center=(0, 0, z_reflector_center - 50), size=(10 * L, 10 * L, reflectorThickness + 100)
    )
    pGan_box = td.Box(center=(0, 0, z_pGan_center), size=(L, L, pGanHeight))
    MQW_box = td.Box(center=(0, 0, z_MQW_center), size=(L, L, MQWHeight))
    nGan_box = td.Box(center=(0, 0, z_nGan_center), size=(L, L, nGanHeight))

    # Create structure list with materials
    structure = [
        td.Structure(geometry=reflector_box, medium=reflectorMedium, name="reflector"),
        td.Structure(geometry=pGan_box, medium=pGanMedium, name="pGan"),
        td.Structure(geometry=MQW_box, medium=MQWMedium, name="MQW"),
        td.Structure(geometry=nGan_box, medium=nGanMedium, name="nGan"),
    ]

    total_height = reflectorThickness + pGanHeight + MQWHeight + nGanHeight

    return structure, z_MQW_center, MQWHeight, (L, L, total_height)

Next, we will define a function to return the Simulation object. The source is a PointDipole. We will add a normalization monitor at the MQW to record the emitted power, along with two other FluxMonitors to record the total extracted power and the extracted power in the z+ direction.

We will also define an auxiliary function to automatically set the appropriate symmetry when applicable, based on the source position.

Since some µ-LEDs can be relatively large, and the fields can remain confined inside the structure for a long time, we will increase the shutoff parameter from the default value of 1e-5 to 1e-4.

def parseSymmetry(geometrySymmetry, polarization, posx, posy=0):
    """Parse geometry symmetry and polarization to set Tidy3D symmetry flags.

    Parameters
    ----------
    geometrySymmetry : tuple of bool
        Symmetry along (x, y, z) axes.
    polarization : str
        Dipole polarization ("Ex", "Ey", or "Ez").
    posx : float
        x-position of the source (µm).
    posy : float, optional
        y-position of the source (µm), default is 0.

    Returns
    -------
    list of int
        Symmetry settings for (x, y, z), with 0 for none, ±1 for symmetry/antisymmetry.
    """

    if polarization == "Ex":
        sym = (-1 if geometrySymmetry[0] else 0, 1 if geometrySymmetry[1] else 0, 0)
    elif polarization == "Ey":
        sym = (1 if geometrySymmetry[0] else 0, -1 if geometrySymmetry[1] else 0, 0)
    elif polarization == "Ez":
        sym = (1 if geometrySymmetry[0] else 0, 1 if geometrySymmetry[1] else 0, 0)

    return [sym[0] if posx == 0 else 0, sym[1] if posy == 0 else 0, 0]
def getSim(
    pGanHeight=0.1,
    size=20,
    pad=1,
    padz=1,
    min_steps_per_wvl=12,
    GANExtinctionCoef=30,
    background_medium=td.Medium.from_nk(n=1.5, k=0, freq=freq0),
    source_position=(0, 0),
    polarization="Ex",
    symmetry=(1, 1, 0),
):
    """Build a Tidy3D simulation of a square µ-LED with dipole excitation.

    Parameters
    ----------
    pGanHeight : float
        Thickness of the p-GaN layer (µm).
    size : float
        Lateral size of the LED (µm).
    pad : float
        Padding in x and y directions (µm).
    padz : float
        Padding in z direction (µm).
    min_steps_per_wvl : int
        Minimum grid steps per wavelength.
    GANExtinctionCoef : float
        Extinction coefficient of GaN (cm⁻¹).
    background_medium : td.Medium
        Background medium of the simulation.
    source_position : tuple
        (x, y) position of the dipole source (µm).
    polarization : str
        Dipole polarization ("Ex", "Ey", or "Ez").
    symmetry : tuple
        Symmetry settings for the simulation.

    Returns
    -------
    td.Simulation
        Configured Tidy3D simulation with structures, source, and monitors.
    """

    structures, QWCenter, QWHeight, structure_size = createStructure(
        pGanHeight=pGanHeight, size=size, GANExtinctionCoef=GANExtinctionCoef
    )

    x, y = source_position
    zPosition = QWCenter
    dipole = td.PointDipole(
        center=(x, y, zPosition),
        polarization=polarization,
        source_time=source_time,
        name=f"dipole_{x}_{y}_{polarization}",
    )

    symmetry = parseSymmetry(symmetry, polarization, x, y)

    grid_spec = td.GridSpec.auto(min_steps_per_wvl=min_steps_per_wvl, wavelength=wl1)

    boundary_spec = td.BoundarySpec(
        x=td.Boundary(minus=td.PML(), plus=td.PML()),
        y=td.Boundary(minus=td.PML(), plus=td.PML()),
        z=td.Boundary(minus=td.Absorber(), plus=td.PML()),
    )

    sim_size = [i + 2 * pad for i in structure_size[:2]] + [2 * padz + structure_size[2]]
    sim_center = [0, 0, structure_size[2] / 2 + padz]

    # Monitors

    norm_flux_monitor = td.FluxMonitor(
        center=structures[2].geometry.center,
        size=structures[2].geometry.size,
        name="norm_flux_monitor",
        freqs=freq_analysis,
    )

    outside_flux_monitor = td.FluxMonitor(
        center=(sim_center[0], sim_center[1], sim_center[2] - pad / 2),
        size=[sim_size[0] - pad, sim_size[1] - pad, sim_size[2] - pad / 2],
        freqs=norm_flux_monitor.freqs,
        name="outside_flux_monitor",
        exclude_surfaces=["z-"],
    )

    lateral_flux_monitor = td.FluxMonitor(
        center=(sim_center[0], sim_center[1], sim_center[2] - pad / 2),
        size=[sim_size[0] - pad, sim_size[1] - pad, sim_size[2] - pad / 2],
        freqs=norm_flux_monitor.freqs,
        name="lateral_flux_monitor",
        exclude_surfaces=["z-", "z+"],
    )

    sim = td.Simulation(
        size=sim_size,
        center=sim_center,
        grid_spec=grid_spec,
        structures=structures,
        sources=[dipole],
        monitors=[norm_flux_monitor, outside_flux_monitor, lateral_flux_monitor],
        run_time=20e-12,
        boundary_spec=boundary_spec,
        medium=background_medium,
        symmetry=symmetry,
        shutoff=1e-4,
    )

    return sim

Now we can plot and inspect the geometry.

sim = getSim()
sim.plot_3d()
fig, ax = plt.subplots(1, 2, figsize=(10, 5))
sim.plot(z=sim.structures[2].geometry.center[2], ax=ax[0])
sim.plot(x=0, ax=ax[1])
plt.show()

Finally, we will define a function for calculating the LEE

def calculateLEE(sim_data, monitor_name="outside_flux_monitor"):
    fluxDipole = sim_data["norm_flux_monitor"].flux
    fluxOutside = sim_data[monitor_name].flux

    return np.mean(fluxOutside / fluxDipole)

LEE as a Function of Length and Reflector Absorption

First, we will investigate the relation between the LEE, the device size, and the reflector absorption coefficient. We will create a Batch object to run the simulations in parallel. Before running, we can also estimate the maximum cost of the batch.

sizes = [1, 5, 15, 30]
abs = [0, 10, 30, 50]
sims_varying_abs = {}
for l in sizes:
    for a in abs:
        sims_varying_abs[str((l, a))] = getSim(size=l, GANExtinctionCoef=a)


batch_varying_abs = web.Batch(simulations=sims_varying_abs, folder_name="LedLEECalculation")
batch_varying_abs.estimate_cost();
16:53:31 -03 Maximum FlexCredit cost: 354.029 for the whole batch.

Next, we run the batch.

if RUN:
    batch_data_varying_abs = batch_varying_abs.run(path_dir="varying_abs")






We can now verify the effective cost of the batch. Since some simulations ended before the stipulated runtime, the actual cost is smaller than the estimated maximum.






batch_varying_abs.real_cost();







16:53:44 -03 Total billed flex credit cost: 232.624.                            







Post-processing the data.






import pandas as pd

df = pd.DataFrame()

for k in batch_data_varying_abs.keys():
    tup = eval(k)
    abs = float(tup[1])
    l = float(tup[0])

    sim_data = batch_data_varying_abs[k]
    lee = calculateLEE(sim_data)
    df.loc[abs, l] = lee.values







As we can see, the LEE decreases with both the LED cross-section size and the reflector absorption.






fig, ax = plt.subplots()

ax.set_xlabel("Reflector absorption (cm$^{-1}$)")
ax.set_ylabel("LEE")

df.T.plot(ax=ax, marker="o")
ax.set_ylim(0.7, 1)
plt.show()

























LEE as a Function of p-GaN Thickness


Next, we will investigate the influence of the p-GaN layer thickness for LEDs of sizes 5, 10 and 20 µm






pGanHeights = np.linspace(0.060, 0.140, 9)

sims_varyingpGan_L5 = {}
sims_varyingpGan_L10 = {}
sims_varyingpGan_L20 = {}

for p in pGanHeights:
    sim_L5 = getSim(pGanHeight=p, size=5)
    sims_varyingpGan_L5[str(p)] = sim_L5

    sim_L10 = getSim(pGanHeight=p, size=10)
    sims_varyingpGan_L10[str(p)] = sim_L10

    sim_L20 = getSim(pGanHeight=p, size=20)
    sims_varyingpGan_L20[str(p)] = sim_L20


batch_varyingpGan_L5 = web.Batch(simulations=sims_varyingpGan_L5, folder_name="LEECalculation")
batch_varyingpGan_L10 = web.Batch(simulations=sims_varyingpGan_L10, folder_name="LEECalculation")
batch_varyingpGan_L20 = web.Batch(simulations=sims_varyingpGan_L20, folder_name="LEECalculation")











if RUN:
    batch_data_varyingpGan_L5 = batch_varyingpGan_L5.run(path_dir="varyingpGan_L5")
    batch_data_varyingpGan_L10 = batch_varyingpGan_L10.run(path_dir="varyingpGan_L10")
    batch_data_varyingpGan_L20 = batch_varyingpGan_L20.run(path_dir="varyingpGan_L20")












































Lee_varyingpGan_L5 = []
Lee_varyingpGan_L10 = []
Lee_varyingpGan_L20 = []

for p in pGanHeights:
    sim_data_L5 = batch_data_varyingpGan_L5[str(p)]
    Lee_varyingpGan_L5.append(calculateLEE(sim_data_L5))

    sim_data_l10 = batch_data_varyingpGan_L10[str(p)]
    Lee_varyingpGan_L10.append(calculateLEE(sim_data_l10))

    sim_data_l20 = batch_data_varyingpGan_L20[str(p)]
    Lee_varyingpGan_L20.append(calculateLEE(sim_data_l20))











fig, ax = plt.subplots()
ax.plot(pGanHeights, Lee_varyingpGan_L5, "o-", label="L= 5 µm")
ax.plot(pGanHeights, Lee_varyingpGan_L10, "o-", label="L= 10 µm")
ax.plot(pGanHeights, Lee_varyingpGan_L20, "o-", label="L= 20 µm")
ax.set_xlabel("pGan Heights")
ax.set_ylabel("LEE")
ax.legend()


ax.set_ylim(0.5, 1)

ax.set_xlabel("p-GaN Thickness (µm)")
ax.set_ylabel("LEE")
plt.show()





















We can also decompose the total LEE into its lateral and vertical components. The results match well the ones presented on the Fig. 6 of the reference paper






Lee_varyingpGan_L20_lateral = []
Lee_varyingpGan_L20 = []
for p in pGanHeights:
    sim_data_l20 = batch_data_varyingpGan_L20[str(p)]
    Lee_varyingpGan_L20.append(calculateLEE(sim_data_l20))
    Lee_varyingpGan_L20_lateral.append(
        calculateLEE(sim_data_l20, monitor_name="lateral_flux_monitor")
    )

Lee_varyingpGan_L20_top = np.array(Lee_varyingpGan_L20) - np.array(Lee_varyingpGan_L20_lateral)











fig, ax = plt.subplots()

ax.plot(pGanHeights, Lee_varyingpGan_L20, "o-", label="Total LEE")
ax.plot(pGanHeights, Lee_varyingpGan_L20_top, "o-", label="Top LEE")
ax.plot(pGanHeights, Lee_varyingpGan_L20_lateral, "o-", label="Lateral LEE")

ax.set_xlabel("p-GaN Thickness (µm)")
ax.set_ylabel("LEE")

ax.legend()
plt.title("LEE vs p-GaN Thickness")
ax.set_ylim(0, 0.9)
plt.show()

























Relative Error for Single Dipole LEE Calculation


Now, we will run batch simulations with distributed dipoles to calculate the average LEE value and compare the results with those from a single dipole at the center, to estimate how accurate the single dipole approximation is.


We will define a function to calculate the mean LEE by exploiting the rotational and mirror symmetries of the structure. The lee_dict is a dictionary mapping each dipole position to its corresponding LEE. The function ensures the correct contributions are included (e.g., a dipole at (1,1) has the same LEE contribution as (-1,1), (-1,-1), and (1,-1)).






def averageLee(lee_dict):
    """Compute the average LEE using rotational and mirror symmetries.

    Parameters
    ----------
    lee_dict : dict
        Dictionary mapping dipole position keys (e.g., 'dipole_x_y')
        to their corresponding LEE values.

    Returns
    -------
    np.ndarray
        Symmetry-averaged LEE.
    """

    avg_lee = 0
    count = 0

    for key, values in lee_dict.items():
        posX, posY = key.split("_")[1:3]
        posX, posY = float(posX), float(posY)

        # Case 1: source at center -> counts once
        if (posX == 0) and (posY == 0):
            avg_lee += np.array(values)
            count += 1

        # Case 2: source on x- or y-axis -> symmetric copy doubles contribution
        elif posY == 0:
            avg_lee += 2 * np.array(values)
            count += 2

        elif posX == 0:
            avg_lee += 2 * np.array(values)
            count += 2

        # Case 3: source off axes -> four symmetric positions
        else:
            avg_lee += 4 * np.array(values)
            count += 4

    return avg_lee / count


def calculateLees(Total_lee, batch_data):
    """Calculate the center LEE and the symmetry-averaged LEE.

    Parameters
    ----------
    Total_lee : list
        List of LEE values for all dipole positions.
    batch_data : dict
        Dictionary mapping position keys to dipole metadata.

    Returns
    -------
    tuple
        - center_lee : float
            Mean LEE at the center dipole.
        - avgLee : np.ndarray
            Symmetry-averaged LEE across all dipoles.
    """

    center_lee = Total_lee[0]

    lee_dict = {key: Total_lee[i] for i, key in enumerate(batch_data.keys())}
    avgLee = averageLee(lee_dict)

    return float(np.mean(center_lee)), avgLee







Next, we define a function to create a batch by placing the dipoles in a grid around the LED. Since we can use mirror and rotational symmetries, the dipoles only need to be placed in a quarter of the MQW area.






def createSingleDipoleBatch(
    simBase,
    source_time,
    dipoles_per_dimension=5,
    xSpan=(0, 1),
    polarization="inplane",  # inplane or outofplane
    symmetry=(1, 1, 0),
):
    """Create a batch of simulations with dipoles placed across the LED structure.

    Parameters
    ----------
    simBase : td.Simulation
        Base LED simulation.
    source_time : td.SourceTime
        Time profile of the dipole source.
    dipoles_per_dimension : int, optional
        Number of dipole positions sampled per dimension (default=5).
    xSpan : tuple of float, optional
        Range of x positions for dipoles (µm), default is (0, 1).
    polarization : str, optional
        Polarization of dipoles: "inplane" (Ex) or "outofplane" (Ez).
    symmetry : tuple, optional
        Symmetry settings for the simulation (default=(1,1,0)).

    Returns
    -------
    dict
        Dictionary mapping keys (format: 'pol_x_y_index') to Tidy3D Simulation objects.
    """

    sims = {}

    x = np.linspace(xSpan[0], xSpan[1], dipoles_per_dimension)
    for i in range(dipoles_per_dimension):
        y = x[i]

        if polarization == "outofplane":
            pol = "Ez"
            xList = x[i:]
        elif polarization == "inplane":
            pol = "Ex"
            xList = x
        else:
            pol = polarization
            xList = x[i:] if polarization == "Ez" else x

        for pos in xList:
            zPosition = simBase.sources[0].center[2]
            dipole = td.PointDipole(
                center=(pos, y, zPosition),
                polarization=pol,
                source_time=source_time,
                name=f"dipole_{x}_{y}_{polarization}",
            )

            sim = simBase.updated_copy(
                sources=[dipole], symmetry=parseSymmetry(symmetry, pol, pos, y)
            )

            sims[f"{pol}_{pos}_{y}_{i}"] = sim

    print("Number of Simulations:", len(sims))

    return sims







Now we can create the batch simulation for different LED sizes.






simBase = getSim(size=1)
sims_l1 = createSingleDipoleBatch(
    simBase,
    source_time=source_time,
    dipoles_per_dimension=4,
    xSpan=(0, 0.4),
    polarization="inplane",
    symmetry=(1, 1, 0),
)
batch_l1 = web.Batch(simulations=sims_l1, folder_name="LED")

simBase = getSim(size=2.5)
sims_l2d5 = createSingleDipoleBatch(
    simBase,
    source_time=source_time,
    dipoles_per_dimension=4,
    xSpan=(0, 0.9 * 2.5 / 2),
    polarization="inplane",
    symmetry=(1, 1, 0),
)
batch_l2d5 = web.Batch(simulations=sims_l2d5, folder_name="LED")

simBase = getSim(size=3)
sims_l3 = createSingleDipoleBatch(
    simBase,
    source_time=source_time,
    dipoles_per_dimension=4,
    xSpan=(0, 0.9 * 3 / 2),
    polarization="inplane",
    symmetry=(1, 1, 0),
)
batch_l3 = web.Batch(simulations=sims_l3, folder_name="LED")


simBase = getSim(size=5)
sims_l5 = createSingleDipoleBatch(
    simBase,
    source_time=source_time,
    dipoles_per_dimension=3,
    xSpan=(0, 2),
    polarization="inplane",
    symmetry=(1, 1, 0),
)

batch_l5 = web.Batch(simulations=sims_l5, folder_name="LED")


simBase = getSim(size=10)
sims_l10 = createSingleDipoleBatch(
    simBase,
    source_time=source_time,
    dipoles_per_dimension=3,
    xSpan=(0, 0.9 * 10 / 2),
    polarization="inplane",
    symmetry=(1, 1, 0),
)
batch_l10 = web.Batch(simulations=sims_l10, folder_name="LED")

simBase = getSim(size=20)
sims_l20 = createSingleDipoleBatch(
    simBase,
    source_time=source_time,
    dipoles_per_dimension=3,
    xSpan=(0, 0.9 * 20 / 2),
    polarization="inplane",
    symmetry=(1, 1, 0),
)
batch_l20 = web.Batch(simulations=sims_l20, folder_name="LED")







Number of Simulations: 16
Number of Simulations: 16
Number of Simulations: 16
Number of Simulations: 9
Number of Simulations: 9
Number of Simulations: 9






We can define a function to plot all the sources of a given batch together for inspection.






def plot_batch(batch, **args):
    """Function for visualize all sources for a given batch"""
    fig, ax = plt.subplots()
    sims = list(batch.simulations.values())
    z = sims[0].sources[0].center[2]
    sims[0].updated_copy(symmetry=[0, 0, 0]).plot(z=z, ax=ax, monitor_alpha=0)
    for sim in sims[1:]:
        sim.updated_copy(symmetry=[0, 0, 0]).plot(
            z=z, ax=ax, monitor_alpha=0, fill_structures=False
        )
    plt.show()


plot_batch(batch_l1)

























if RUN:
    batch_l1_data = batch_l1.run(path_dir="MultipleDipolesL1Ex")
    batch_l2d5_data = batch_l2d5.run(path_dir="MultipleDipolesL2d5Ex")
    batch_l5_data = batch_l5.run(path_dir="MultipleDipolesL5Ex")
    batch_l10_data = batch_l10.run(path_dir="MultipleDipolesL10Ex")
    batch_l20_data = batch_l20.run(path_dir="MultipleDipolesL20Ex")













































































Total_lee1 = [calculateLEE(sim_data) for sim_data in batch_l1_data.values()]
Total_lee2d5 = [calculateLEE(sim_data) for sim_data in batch_l2d5_data.values()]
Total_lee5 = [calculateLEE(sim_data) for sim_data in batch_l5_data.values()]
Total_lee10 = [calculateLEE(sim_data) for sim_data in batch_l10_data.values()]
Total_lee20 = [calculateLEE(sim_data) for sim_data in batch_l20_data.values()]







As we can see, the error in the single dipole approximation tends to decrease with size. Hence, using only a dipole at the center can greatly reduce computational cost while still providing accurate results.






fig, ax = plt.subplots()

size = [1, 2.5, 5, 10, 20]
lee0 = []
avgLee = []

center, avg = calculateLees(Total_lee1, batch_l1_data)
lee0.append(center)
avgLee.append(avg)

center, avg = calculateLees(Total_lee2d5, batch_l2d5_data)
lee0.append(center)
avgLee.append(avg)


center, avg = calculateLees(Total_lee5, batch_l5_data)
lee0.append(center)
avgLee.append(avg)

center, avg = calculateLees(Total_lee10, batch_l10_data)
lee0.append(center)
avgLee.append(avg)

center, avg = calculateLees(Total_lee20, batch_l20_data)
lee0.append(center)
avgLee.append(avg)

ax.plot(size, lee0, "o-", color="blue", label="Single Dipole")
ax.plot(size, avgLee, "o-", color="red", label="Average Lee")

ax.set_ylim(0.7, 1)
ax.set_xlabel("LED Size (µm)")
ax.set_ylabel("LEE")
plt.legend()
plt.show()


























          

          

            Example library
          

          
          

          

            

              


                

                  More Examples
                



              Read More
            

            

              

              

                
                
                

                  
                    Optical forces
                    

                    Optical forces
                  
                

                
                

                  
                    Hyperbolic polaritons in nanostructured hBN
                    

                    Hyperbolic polaritons in nanostructured hBN
                  
                

                
                

                  
                    Unidirectional SPP from non-Hermitian metagratings
                    

                    Unidirectional SPP from non-Hermitian metagratings
                  
                

                
                
              

              

              

                
No matching results found.

              

            

          

          

          
          

          

            
            
              
              Previous Tutorial
            
            
            
            
              Next Tutorial