# Uncomment the following line to install pygad if it's not installed in your environment already
# pip install pygad
import matplotlib.pyplot as plt
import numpy as np
import tidy3d as td
import tidy3d.plugins.design as tdd
import tidy3d.web as web
TIDY3D
LEARNING CENTER
Example Library
Genetic algorithm optimization of a silicon on-chip reflector¶
Note: the cost of running the entire notebook is larger than 10 FlexCredits.
A genetic algorithm (GA) is a search heuristic that mimics the process of natural selection. This algorithm reflects the process of natural evolution where the fittest individuals are selected for reproduction in order to produce offspring of the next generation.
The steps in a GA are typically as follows:
Initial Population: The process begins with a set of individuals which is called a population. Each individual is a solution to the problem you want to solve.
Fitness Function: Each individual in the population has a fitness score which indicates how good it is at solving the problem.
Selection: The algorithm selects individuals, often the fittest among the population, to breed a new generation. The selection can be done in various ways, such as roulette wheel selection, tournament selection, etc.
Crossover: During crossover, parts of two individuals’ chromosome strings are swapped to get a new offspring, which may contain some parts of both parents’ strings. This simulates reproduction and biological crossover.
Mutation: In some new offspring, random genes are mutated or changed to maintain diversity within the population and to avoid premature convergence.
New Generation: The new generation of population is formed by the offspring. This new generation is then used in the next iteration of the algorithm.
Termination: The algorithm terminates if the population has converged (does not produce offspring that are significantly different from the previous generation), or a satisfactory solution has been found, or a set number of generations have been produced.
GAs have become a powerful tool for optimizing photonic components, leveraging their ability to efficiently search large and complex design spaces. In photonics, where the performance of components like waveguides, photonic crystals, and fibers can be highly sensitive to geometrical and material parameters, GAs offer a way to find optimal solutions that might be difficult to discover using traditional design methods.
In this notebook, we demonstrate the optimization of a compact silicon waveguide reflector using GA, utilizing the open source Python library pyGAD implemented into the Tidy3D Design plugin. The idea follows Zejie Yu, Haoran Cui, and Xiankai Sun, "Genetically optimized on-chip wideband ultracompact reflectors and Fabry–Perot cavities," Photon. Res. 5, B15-B19 (2017) DOI:10.1364/PRJ.5.000B15. The design region of the reflector consists of a grid divided into 18x18 pixels. Each pixel is a square measuring 120 nm by 120 nm.
Tidy3D is a powerful tool for photonic design optimization due to its fast speed and high throughput. Besides GA, we have demonstrated particle swarm optimizations of a polarization beam splitter and a bullseye cavity, CMA-ES optimization of an waveguide S-bend, Bayesian optimization of a Y-junction, and direct binary search optimization of an optical switch. Furthermore, we also have a growing list of gradient-based adjoint optimization examples including
Simulation Setup
For simplicity, we will use the silicon and oxide media directly from the material library.
Si = td.material_library["cSi"]["Palik_LowLoss"]
SiO2 = td.material_library["SiO2"]["Palik_LowLoss"]The simulation wavelength range is 1450 nm to 1650 nm.
lda0 = 1.55 # central wavelength
freq0 = td.C_0 / lda0 # central frequency
ldas = np.linspace(1.45, 1.65, 101) # wavelength range
freqs = td.C_0 / ldas # frequency range
fwidth = 0.5 * (np.max(freqs) - np.min(freqs)) # width of the source frequency rangeThe waveguide has a 500 nm width and 220 nm thickness. The design region consists of 18 by 18 pixels. Each pixel is 120 nm by 120 nm. Due to the symmetry, we only consider symmetric design so the total number of tunable pixels is 18*9=162.
w = 0.5 # width of the waveguide
t = 0.22 # thickness of the silicon
l = 1 # length of the waveguide in the simulation
Px = Py = 0.12 # pixel sizes in the x and y directions
Nx = 18 # number of pixels in the x direction
Ny = 9 # number of pixels in the y direction
buffer = 0.8 # buffer spacing
res = 15 # overall resolution setting (steps per wavelength)
gsx = gsy = 5 # number of grid steps per pixel in override regionWe will create an array of length 162 to represent a design. Each element corresponds to each pixel in the design region. An element value of 1 means the pixel is silicon while an element value of 0 means the pixel is void. To facilitate the optimization, we define a helper function create_design(pixels) that takes the pixel array and creates the Structures of the simulation, including the waveguide and the design region.
def create_design(pixels):
geo = 0
for i, pixel in enumerate(pixels):
if pixel == 1:
geo += td.Box(
center=(l + Px / 2 + Px * (i % Nx), Py * Ny - Py / 2 - Py * (i // Nx), t / 2),
size=(Px, Py, t),
)
geo += td.Box(
center=(l + Px / 2 + Px * (i % Nx), -(Py * Ny - Py / 2 - Py * (i // Nx)), t / 2),
size=(Px, Py, t),
)
geo = geo + td.Box(center=(0, 0, t / 2), size=(2 * l, w, t))
design = td.Structure(geometry=geo, medium=Si)
return designAs a quick check, we create a random array and plot the created structures.
np.random.seed(0) # fix a random seed for reproducibility
pixels = np.random.choice([0, 1], size=Nx * Ny)
design = create_design(pixels)
design.plot(z=t / 2)
plt.show()
Furthermore, we define a make_sim(pixels) function to define the entire simulation given the pixel array. The simulation includes a ModeSource to launch the TE0 mode at the waveguide and a ModeMonitor next to the source to measure the reflection. To minimize data download during the optimization, we will only record the reflection at the central wavelength of 1550 nm since the objective is to maximize this value.
def make_sim(pixels):
design = create_design(pixels)
# Add a mode source as excitation
mode_spec = td.ModeSpec(num_modes=1, target_neff=3.5)
mode_source = td.ModeSource(
center=(l / 2, 0, t / 2),
size=(0, 4 * w, 6 * t),
source_time=td.GaussianPulse(freq0=freq0, fwidth=fwidth),
direction="+",
mode_spec=mode_spec,
mode_index=0,
)
# Add a mode monitor to measure transmission at the output waveguide
mode_monitor = td.ModeMonitor(
center=(l / 4, 0, t / 2),
size=mode_source.size,
freqs=[freq0],
mode_spec=mode_spec,
name="mode",
)
# Define simulation domain size
Lx = l + Nx * Px + buffer
Ly = 2 * Ny * Py + 2 * buffer
Lz = 10 * t
eff_inf = 1e2 # effective infinity
# Define substrate structure
substrate = td.Structure(
geometry=td.Box.from_bounds(
rmin=(-eff_inf, -eff_inf, -eff_inf), rmax=(eff_inf, eff_inf, 0)
),
medium=SiO2,
)
run_time = 5e-13 # simulation run time
# Simulation box
sim_box = td.Box.from_bounds(rmin=(0, -Ly / 2, -Lz / 2), rmax=(Lx, Ly / 2, Lz / 2))
# Mesh override structure over the pixel region to ensure grid that conforms to the pixels
mesh_override = td.MeshOverrideStructure(
geometry=td.Box.from_bounds(rmin=(l, -Py * Ny, 0), rmax=(l + Px * Nx, Py * Ny, 0)),
dl=(
Px / gsx,
Py / gsy,
1,
), # the z-direction dl doesn't matter as the box size is 0 along z
)
# Define simulation
sim = td.Simulation(
center=sim_box.center,
size=sim_box.size,
grid_spec=td.GridSpec.auto(
min_steps_per_wvl=res, wavelength=lda0, override_structures=[mesh_override]
),
structures=[design, substrate],
sources=[mode_source],
monitors=[mode_monitor],
run_time=run_time,
boundary_spec=td.BoundarySpec.all_sides(boundary=td.PML()),
symmetry=(0, -1, 0),
)
return simAgain, we test it by defining a simulation with a random pixel array. From the 3D view, we confirm that the simulation setup is correct.
sim = make_sim(pixels)
sim.plot_3d()GA Setup
Now we are ready to setup a GA optimization. This can quickly be done using the Tidy3D Design plugin, which can efficiently manage the optimization with parallel cloud computing, reducing the runtime and saving FlexCredits.
First we need to define some hyperparameters. In this particular example, we will use 30 solutions per population and run the optimization for a total of 25 generations, and also specify early-stop criteria that stops the optimization if the fitness value doesn’t change for 6 consecutive generations. The MethodGenAlg class can be used to tune a number of parameters that change the selection, crossover, and mutation processes. We only change a few and leave the most to the default settings. Users are encouraged to explore these settings using the PyGAD docs and fine tune them for better results. For reproducibility, we also set a fixed random seed.
A list ParameterInt objects are created to store the binary values used to define the geometry of the reflector. These parameters and the GA method are supplied to a DesignSpace object, which manages the GA process and outputs the results of the optimization.
method = tdd.MethodGenAlg(
solutions_per_pop=30,
n_generations=25,
n_parents_mating=10,
keep_elitism=1,
parent_selection_type="sss",
crossover_type="single_point",
crossover_prob=0.7,
mutation_type="inversion",
mutation_prob=None,
seed=5,
stop_criteria_type="saturate",
stop_criteria_number=6,
)
parameters = [tdd.ParameterInt(name=str(i), span=(0, 1)) for i in range(Nx * Ny)]
design_space = tdd.DesignSpace(
method=method, parameters=parameters, task_name="GA_Notebook", path_dir="./data"
)We can optionally summarize the design space to check the setup.
summary = design_space.summarize()04:41:37 UTC Summary of DesignSpace Method: MethodGenAlg Method Args solutions_per_pop: 30 n_generations: 25 n_parents_mating: 10 stop_criteria_type: saturate stop_criteria_number: 6.0 parent_selection_type: sss keep_parents: -1 keep_elitism: 1 crossover_type: single_point crossover_prob: 0.7 mutation_type: inversion mutation_prob: None save_solution: False No. of Parameters: 162 Parameters: 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161 0: ParameterInt (0, 1) 1: ParameterInt (0, 1) 2: ParameterInt (0, 1) 3: ParameterInt (0, 1) 4: ParameterInt (0, 1) 5: ParameterInt (0, 1) 6: ParameterInt (0, 1) 7: ParameterInt (0, 1) 8: ParameterInt (0, 1) 9: ParameterInt (0, 1) 10: ParameterInt (0, 1) 11: ParameterInt (0, 1) 12: ParameterInt (0, 1) 13: ParameterInt (0, 1) 14: ParameterInt (0, 1) 15: ParameterInt (0, 1) 16: ParameterInt (0, 1) 17: ParameterInt (0, 1) 18: ParameterInt (0, 1) 19: ParameterInt (0, 1) 20: ParameterInt (0, 1) 21: ParameterInt (0, 1) 22: ParameterInt (0, 1) 23: ParameterInt (0, 1) 24: ParameterInt (0, 1) 25: ParameterInt (0, 1) 26: ParameterInt (0, 1) 27: ParameterInt (0, 1) 28: ParameterInt (0, 1) 29: ParameterInt (0, 1) 30: ParameterInt (0, 1) 31: ParameterInt (0, 1) 32: ParameterInt (0, 1) 33: ParameterInt (0, 1) 34: ParameterInt (0, 1) 35: ParameterInt (0, 1) 36: ParameterInt (0, 1) 37: ParameterInt (0, 1) 38: ParameterInt (0, 1) 39: ParameterInt (0, 1) 40: ParameterInt (0, 1) 41: ParameterInt (0, 1) 42: ParameterInt (0, 1) 43: ParameterInt (0, 1) 44: ParameterInt (0, 1) 45: ParameterInt (0, 1) 46: ParameterInt (0, 1) 47: ParameterInt (0, 1) 48: ParameterInt (0, 1) 49: ParameterInt (0, 1) 50: ParameterInt (0, 1) 51: ParameterInt (0, 1) 52: ParameterInt (0, 1) 53: ParameterInt (0, 1) 54: ParameterInt (0, 1) 55: ParameterInt (0, 1) 56: ParameterInt (0, 1) 57: ParameterInt (0, 1) 58: ParameterInt (0, 1) 59: ParameterInt (0, 1) 60: ParameterInt (0, 1) 61: ParameterInt (0, 1) 62: ParameterInt (0, 1) 63: ParameterInt (0, 1) 64: ParameterInt (0, 1) 65: ParameterInt (0, 1) 66: ParameterInt (0, 1) 67: ParameterInt (0, 1) 68: ParameterInt (0, 1) 69: ParameterInt (0, 1) 70: ParameterInt (0, 1) 71: ParameterInt (0, 1) 72: ParameterInt (0, 1) 73: ParameterInt (0, 1) 74: ParameterInt (0, 1) 75: ParameterInt (0, 1) 76: ParameterInt (0, 1) 77: ParameterInt (0, 1) 78: ParameterInt (0, 1) 79: ParameterInt (0, 1) 80: ParameterInt (0, 1) 81: ParameterInt (0, 1) 82: ParameterInt (0, 1) 83: ParameterInt (0, 1) 84: ParameterInt (0, 1) 85: ParameterInt (0, 1) 86: ParameterInt (0, 1) 87: ParameterInt (0, 1) 88: ParameterInt (0, 1) 89: ParameterInt (0, 1) 90: ParameterInt (0, 1) 91: ParameterInt (0, 1) 92: ParameterInt (0, 1) 93: ParameterInt (0, 1) 94: ParameterInt (0, 1) 95: ParameterInt (0, 1) 96: ParameterInt (0, 1) 97: ParameterInt (0, 1) 98: ParameterInt (0, 1) 99: ParameterInt (0, 1) 100: ParameterInt (0, 1) 101: ParameterInt (0, 1) 102: ParameterInt (0, 1) 103: ParameterInt (0, 1) 104: ParameterInt (0, 1) 105: ParameterInt (0, 1) 106: ParameterInt (0, 1) 107: ParameterInt (0, 1) 108: ParameterInt (0, 1) 109: ParameterInt (0, 1) 110: ParameterInt (0, 1) 111: ParameterInt (0, 1) 112: ParameterInt (0, 1) 113: ParameterInt (0, 1) 114: ParameterInt (0, 1) 115: ParameterInt (0, 1) 116: ParameterInt (0, 1) 117: ParameterInt (0, 1) 118: ParameterInt (0, 1) 119: ParameterInt (0, 1) 120: ParameterInt (0, 1) 121: ParameterInt (0, 1) 122: ParameterInt (0, 1) 123: ParameterInt (0, 1) 124: ParameterInt (0, 1) 125: ParameterInt (0, 1) 126: ParameterInt (0, 1) 127: ParameterInt (0, 1) 128: ParameterInt (0, 1) 129: ParameterInt (0, 1) 130: ParameterInt (0, 1) 131: ParameterInt (0, 1) 132: ParameterInt (0, 1) 133: ParameterInt (0, 1) 134: ParameterInt (0, 1) 135: ParameterInt (0, 1) 136: ParameterInt (0, 1) 137: ParameterInt (0, 1) 138: ParameterInt (0, 1) 139: ParameterInt (0, 1) 140: ParameterInt (0, 1) 141: ParameterInt (0, 1) 142: ParameterInt (0, 1) 143: ParameterInt (0, 1) 144: ParameterInt (0, 1) 145: ParameterInt (0, 1) 146: ParameterInt (0, 1) 147: ParameterInt (0, 1) 148: ParameterInt (0, 1) 149: ParameterInt (0, 1) 150: ParameterInt (0, 1) 151: ParameterInt (0, 1) 152: ParameterInt (0, 1) 153: ParameterInt (0, 1) 154: ParameterInt (0, 1) 155: ParameterInt (0, 1) 156: ParameterInt (0, 1) 157: ParameterInt (0, 1) 158: ParameterInt (0, 1) 159: ParameterInt (0, 1) 160: ParameterInt (0, 1) 161: ParameterInt (0, 1) Maximum Run Count: 780
Notes:
The maximum run count for MethodGenAlg is difficult to predict. Repeated solutions are not executed, reducing the total number of simulations. High crossover and mutation probabilities may result in an increased number of simulations, potentially exceeding the predicted maximum run count.
Discrete 'int' values are automatically rounded if optimizers generate 'float' predictions.
To run the GA optimization we need to define the fn_pre and fn_post functions for the optimizer. The pre function creates a Simulation from the parameters suggested by GA as a solution to the reflector. The post function defines how the SimulationData should be evaluated to create a single float value which is then fed back into the GA. By evaluating of the float values of the current generation the GA can then assemble the population for the next generation, based on our hyperparameters.
def fn_pre(**params):
pixels = np.array(list(params.values()))
sim = make_sim(pixels)
return sim
def fn_post(sim_data):
return abs(sim_data["mode"].amps.sel(direction="-").squeeze(drop=True).values) ** 2Once satisfied with the setup, the optimization can be started by calling DesignSpace.run with our fn_pre and fn_post functions. The DesignSpace will parallelize each generation by running the Simulation objects as a batch, and will prevent previously evaluated solutions from being recomputed. Once complete, we can combine all the solution outputs within a Pandas DataFrame for further analysis.
results = design_space.run(fn_pre, fn_post, verbose=True)
df = results.to_dataframe()04:41:38 UTC Running 30 Simulations
04:42:20 UTC Running 29 Simulations
04:42:55 UTC Generation 1 Best Fitness: 0.722
04:42:56 UTC Running 29 Simulations
04:43:32 UTC Generation 2 Best Fitness: 0.776
04:43:33 UTC Running 29 Simulations
04:44:10 UTC Generation 3 Best Fitness: 0.782
04:44:11 UTC Running 29 Simulations
04:44:47 UTC Generation 4 Best Fitness: 0.808
04:44:48 UTC Running 29 Simulations
04:45:24 UTC Generation 5 Best Fitness: 0.808
04:45:25 UTC Running 29 Simulations
04:46:01 UTC Generation 6 Best Fitness: 0.808
04:46:02 UTC Running 29 Simulations
04:47:39 UTC Generation 7 Best Fitness: 0.808
04:47:40 UTC Running 29 Simulations
04:48:51 UTC Generation 8 Best Fitness: 0.826
04:48:52 UTC Running 29 Simulations
04:49:28 UTC Generation 9 Best Fitness: 0.832
04:49:29 UTC Running 29 Simulations
04:50:05 UTC Generation 10 Best Fitness: 0.832
04:50:06 UTC Running 29 Simulations
04:50:42 UTC Generation 11 Best Fitness: 0.837
04:50:43 UTC Running 29 Simulations
04:51:20 UTC Generation 12 Best Fitness: 0.837
04:51:21 UTC Running 29 Simulations
04:51:58 UTC Generation 13 Best Fitness: 0.839
04:51:59 UTC Running 28 Simulations
04:52:34 UTC Generation 14 Best Fitness: 0.839
04:52:35 UTC Running 29 Simulations
04:53:13 UTC Generation 15 Best Fitness: 0.839
04:53:14 UTC Running 29 Simulations
04:53:49 UTC Generation 16 Best Fitness: 0.839
04:53:50 UTC Running 28 Simulations
04:54:24 UTC Generation 17 Best Fitness: 0.854
04:54:25 UTC Running 29 Simulations
04:55:01 UTC Generation 18 Best Fitness: 0.872
04:55:02 UTC Running 29 Simulations
04:55:38 UTC Generation 19 Best Fitness: 0.872
04:55:39 UTC Running 29 Simulations
04:56:14 UTC Generation 20 Best Fitness: 0.872
04:56:15 UTC Running 28 Simulations
04:56:49 UTC Generation 21 Best Fitness: 0.872
04:56:50 UTC Running 29 Simulations
04:57:58 UTC Generation 22 Best Fitness: 0.872
04:57:59 UTC Running 29 Simulations
04:59:00 UTC Generation 23 Best Fitness: 0.872
04:59:01 UTC Running 29 Simulations
05:00:01 UTC Generation 24 Best Fitness: 0.872
Best Result: 0.8722625438985785 Best Parameters: 0: 0 1: 0 2: 1 3: 0 4: 1 5: 1 6: 0 7: 1 8: 1 9: 1 10: 0 11: 0 12: 0 13: 1 14: 0 15: 1 16: 1 17: 0 18: 1 19: 0 20: 1 21: 0 22: 0 23: 1 24: 0 25: 0 26: 0 27: 0 28: 1 29: 1 30: 0 31: 1 32: 0 33: 0 34: 0 35: 0 36: 0 37: 0 38: 0 39: 0 40: 0 41: 1 42: 1 43: 0 44: 0 45: 1 46: 1 47: 0 48: 0 49: 1 50: 1 51: 1 52: 1 53: 1 54: 1 55: 1 56: 0 57: 0 58: 0 59: 0 60: 0 61: 0 62: 0 63: 0 64: 0 65: 0 66: 0 67: 0 68: 1 69: 1 70: 1 71: 1 72: 1 73: 0 74: 1 75: 1 76: 0 77: 1 78: 0 79: 1 80: 0 81: 0 82: 0 83: 1 84: 0 85: 1 86: 0 87: 1 88: 0 89: 0 90: 0 91: 0 92: 0 93: 1 94: 1 95: 0 96: 1 97: 1 98: 0 99: 0 100: 0 101: 1 102: 1 103: 1 104: 0 105: 1 106: 1 107: 0 108: 1 109: 0 110: 1 111: 1 112: 1 113: 0 114: 0 115: 1 116: 1 117: 1 118: 1 119: 0 120: 0 121: 1 122: 0 123: 1 124: 0 125: 1 126: 1 127: 1 128: 1 129: 0 130: 1 131: 0 132: 1 133: 0 134: 1 135: 0 136: 0 137: 1 138: 1 139: 0 140: 1 141: 1 142: 0 143: 0 144: 0 145: 1 146: 1 147: 1 148: 1 149: 0 150: 0 151: 0 152: 1 153: 1 154: 0 155: 0 156: 1 157: 0 158: 0 159: 1 160: 1 161: 0
Optimization and Results
The optimization prints the best fitness achieved in after the generation has been computed. We can further visualize this improvement using the optimizer object stored in the results. After the optimization is complete, we see that we achieved the best fitness (reflection) of 0.897.
# Plotting the best fitness over generations
ga_instance = results.optimizer
best_fitness = ga_instance.best_solutions_fitness
generations = range(len(best_fitness))
plt.plot(generations, best_fitness)
plt.title("Best Fitness over Generations")
plt.xlabel("Generation")
plt.ylabel("Best Fitness")
plt.show()
pixels_final, solution_fitness, solution_idx = ga_instance.best_solution()
print(f"Fitness value of the best solution = {solution_fitness:.3f}")
def plot_fitness_evolution(data_frame, solutions_per_pop, fitness_column_name="output"):
"""Plot the best, worst, and average fitness across generations."""
# Divide the solutions into generations
fitness_values = data_frame[fitness_column_name]
generation_fitness = [
fitness_values[i : i + solutions_per_pop]
for i in range(0, len(fitness_values), solutions_per_pop)
]
# Get min, max, and mean values per generation
min_fitness = [generation.min() for generation in generation_fitness]
max_fitness = [generation.max() for generation in generation_fitness]
mean_fitness = [generation.mean() for generation in generation_fitness]
plt.plot(min_fitness, label="Worst fitness", alpha=0.5)
plt.plot(max_fitness, label="Best fitness", alpha=0.5)
plt.plot(mean_fitness, label="Average fitness", alpha=0.5)
plt.xlabel("Generation")
plt.ylabel("Fitness")
plt.legend()
plt.show()
plot_fitness_evolution(df, 40)
Fitness value of the best solution = 0.872
Now that we have an optimized design, we will grab the best pixel array and re-simulate the design with a broadband ModeMonitor and a FieldMonitor at the central wavelength. This final simulation can be defined by copying the original simulation and updating the monitors.
sim_final = make_sim(pixels_final)
# Update mode monitor's recording frequencies
mode_monitor = sim.monitors[0].copy(update={"freqs": freqs})
# Add a field monitor to visualize field distribution
field_monitor = td.FieldMonitor(
center=(0, 0, t / 2), size=(td.inf, td.inf, 0), freqs=[freq0], name="field"
)
# Update simulation to use the new monitors
sim_final = sim_final.copy(update={"monitors": [mode_monitor, field_monitor]})
# Submit the simulation to the server
sim_data_final = web.run(simulation=sim_final, task_name="final design")05:00:02 UTC Created task 'final design' with resource_id 'fdve-3e931e44-db29-4532-ad4a-6a1c802e3def' and task_type 'FDTD'.
View task using web UI at 'https://tidy3d.simulation.cloud/workbench?taskId=fdve-3e931e44-db2 9-4532-ad4a-6a1c802e3def'.
Task folder: 'default'.
05:00:04 UTC Estimated FlexCredit cost: 0.025. This assumes the FDTD solver runs for the full simulation time; if early shutoff is reached, the billed cost can be lower. Use 'web.real_cost(task_id)' to get the billed FlexCredit cost after a simulation run.
05:00:05 UTC status = queued
To cancel the simulation, use 'web.abort(task_id)' or 'web.delete(task_id)' or abort/delete the task in the web UI. Terminating the Python script will not stop the job running on the cloud.
05:00:13 UTC status = preprocess
05:00:18 UTC starting up solver
running solver
05:00:19 UTC early shutoff detected at 41%, exiting.
status = postprocess
05:00:22 UTC status = success
05:00:24 UTC View simulation result at 'https://tidy3d.simulation.cloud/workbench?taskId=fdve-3e931e44-db2 9-4532-ad4a-6a1c802e3def'.
05:00:25 UTC Loading results from simulation_data.hdf5
After the simulation, we visualize the electric field norm at the central wavelength. As expected, a strong reflection is observed.
sim_data_final.plot_field("field", "Ey", "abs", vmin=0, vmax=1e2)
plt.show()
Finally plot the reflection spectrum, where we see a broadband reflection. Considering the very compact footprint, the performance is very good. With this reflector design, we can further construct other devices such as high-quality-factor Fabry–Perot cavities as demonstrated in the publication.
R = abs(sim_data_final["mode"].amps.sel(direction="-").squeeze(drop=True).values) ** 2
plt.plot(ldas, R, "red", linewidth=2)
plt.xlim(min(ldas), max(ldas))
plt.ylim(0, 1)
plt.xlabel("Wavelength (µm)")
plt.ylabel("Reflectivity")
plt.show()
With the optimized design, we can directly export a GDS file of the reflector for fabrication.
# Make the misc/ directory to store the GDS file if it doesn't exist already
import os
if not os.path.exists("./misc/"):
os.mkdir("./misc/")
sim_final.to_gds_file(fname="misc/optimized_reflector.gds", z=t / 2)
TERMS & CONDITIONS
How the process works:
Try this real URL to see an example: