Calculate ring resonator modes using cylindrical coordinates with angular dependence

Ring Resonator in Cylindrical Coordinates

This example calculates 2D ring-resonator modes using cylindrical coordinates, where modes have angular dependence exp(imφ) for integer m.

Overview

Cylindrical ring resonators are fundamental structures for:

Whispering gallery mode (WGM) resonators: Ultra-high Q cavities
Integrated photonics: On-chip filters and sensors
Optical gyroscopes: Rotation sensing
Nonlinear optics: Enhanced light-matter interaction

Using cylindrical coordinates exploits the rotational symmetry for efficient simulation.

Simulation Parameters

Parameter	Default Value	Description
`resolution`	20	Pixels per μm
`n`	3.4	Waveguide refractive index
`w`	1	Waveguide width
`r`	1	Inner radius of ring
`pad`	4	Padding to PML
`dpml`	32	PML thickness
`m`	3	Angular mode number
`fcen`	0.15	Center frequency
`df`	0.1	Frequency width

Physical Setup

The ring resonator structure:

Ring waveguide: High-index (n=3.4) annular waveguide
Angular modes: exp(imφ) dependence, where m is an integer
Cylindrical simulation: Uses Meep's dimensions=mp.CYLINDRICAL
Point source: Ez-polarized excitation

The angular mode number m determines the number of wavelengths that fit around the ring circumference. Higher m gives higher-order modes.

Python Code

"""
Ring Resonator in Cylindrical Coordinates with OptixLog Integration

Calculates 2D ring-resonator modes using cylindrical coordinates
with angular dependence exp(imφ).

Based on the Meep tutorial: ring-cyl.py
"""

import os
import argparse
import optixlog
import meep as mp
import matplotlib
matplotlib.use("agg")
import matplotlib.pyplot as plt
import numpy as np

api_key = os.getenv("OPTIX_API_KEY", "")
api_url = os.getenv("OPTIX_API_URL", "https://optixlog.com")
project_name = os.getenv("OPTIX_PROJECT", "MeepExamples")


def main(args):
    """Main simulation function for cylindrical ring resonator."""
    
    if not optixlog.is_master_process():
        return
    
    try:
        client = optixlog.init(
            api_key=api_key,
            api_url=api_url,
            project=project_name,
            run_name=f"ring_cyl_m{args.m}",
            config={
                "simulation_type": "ring_resonator",
                "angular_mode": args.m
            },
            create_project_if_not_exists=True
        )
        
        # Simulation parameters
        n = 3.4       # index of waveguide
        w = 1         # width of waveguide
        r = 1         # inner radius of ring
        pad = 4       # padding
        dpml = 32     # PML thickness
        resolution = 20
        
        m = args.m
        fcen = args.fcen
        df = args.df
        
        client.log(
            step=0,
            resolution=resolution,
            waveguide_index=n,
            waveguide_width=w,
            inner_radius=r,
            angular_mode_m=m,
            center_frequency=fcen,
        )
        
        # Cell setup
        sr = r + w + pad + dpml
        cell = mp.Vector3(sr, 0, 0)
        
        geometry = [
            mp.Block(
                center=mp.Vector3(r + (w / 2)),
                size=mp.Vector3(w, mp.inf, mp.inf),
                material=mp.Medium(index=n),
            )
        ]
        
        pml_layers = [mp.PML(dpml)]
        
        sources = [
            mp.Source(
                src=mp.GaussianSource(fcen, fwidth=df),
                component=mp.Ez,
                center=mp.Vector3(r + 0.1),
            )
        ]
        
        sim = mp.Simulation(
            cell_size=cell,
            geometry=geometry,
            boundary_layers=pml_layers,
            resolution=resolution,
            sources=sources,
            dimensions=mp.CYLINDRICAL,
            m=m,
        )
        
        # Run with Harminv
        harminv = mp.Harminv(mp.Ez, mp.Vector3(r + 0.1), fcen, df)
        
        sim.run(
            mp.after_sources(harminv),
            until_after_sources=200,
        )
        
        modes = harminv.modes
        client.log(step=1, num_modes_found=len(modes))
        
        for i, mode in enumerate(modes):
            client.log(
                step=2 + i,
                mode_number=i + 1,
                frequency=float(mode.freq),
                quality_factor=float(mode.Q) if mode.Q > 0 else 0,
            )
        
    except Exception as e:
        print(f"Simulation Error: {e}")


if __name__ == "__main__":
    parser = argparse.ArgumentParser()
    parser.add_argument("-fcen", type=float, default=0.15)
    parser.add_argument("-df", type=float, default=0.1)
    parser.add_argument("-m", type=int, default=3)
    args = parser.parse_args()
    main(args)

How to Run

# Set your OptixLog API key
export OPTIX_API_KEY="your_api_key_here"

# Run with default angular mode m=3
python ring-cyl.py

# Different angular modes
python ring-cyl.py -m 5
python ring-cyl.py -m 10

# Custom frequency range
python ring-cyl.py -fcen 0.2 -df 0.15