Tilt a mode monitor at 45 degrees

[felme1]

Hello,

I am not quite sure if this is the right place to ask this, but I wouldn't know where else to go, so here I go.
I am using meep to calculate the S-Parameters of photonic components. I am doing so by following this tutorial: https://meep.readthedocs.io/en/latest/Python_Tutorials/GDSII_Import/.
This works great, however I have noticed, that the mode monitors are always oriented in Manhattan directions.
Now I have a two port device with the second (output) port facing up at a 45 degree angle. I have tried to apply the .rotate() method to the size vector of the Volume which constitutes the mp.ModeRegion. Unfortunately this didn't work and produced the following error code:
RuntimeError: meep: Could not determine normal direction for given grid_volume.
Does Meep just not have the option to have a mode Monitor face any other way than the Manhattan directions? But If it does offer such a functionality how do I use it?

Thank you in advance!

PS: Here is the code where I tried to tilt the mode monitor by 45 dgrees:

res = 10  # pixels/μm
is_3D = False  # 3d calculation?
gdsII_file = "45deg_wg.gds"

# Materials used in the simulation
Si = mp.Medium(index=3.45)
SiO2 = mp.Medium(index=1.444)

#dimensions of the coupler that is to be simulated
bend_length = 7.601
bend_width = 4.209
port1_x = -3.801
port1_y = -1.354
port2_x = 3.2699999999999996
port2_y = 1.5750000000000002
si_thickness = 0.22

x_margin = 0.5
y_margin = 1

#dimensions of the simulation
sim_thickness = 2
pml_thickness = 2

# Set up frequency points for simulation
npoints = 20
lcen = 1.55  #central wavelength
dwl = 0.05
fcen = 1 / lcen
df = 1 / dwl
df_source =  3 * dwl / lcen**2  # ONLY USE FOR SOURCES TO ENSURE LARGE ENOUGH FREQUENCY BANDWIDTH FOR SIMULATION
wl = np.linspace(lcen - dwl/2, lcen + dwl/2, npoints)
fpoints = 1 / wl


cell_thickness = pml_thickness + sim_thickness + pml_thickness if is_3D else 0
si_thickness = si_thickness if is_3D else 20

# Sets the min and max values for the cell and the silicon. Our simulation will be centered at y=0
si_zmax = 0.5 * si_thickness
si_zmin = -0.5 * si_thickness

#import geometry from gds file
geometry = mp.get_GDSII_prisms(Si, gdsII_file, 1, si_zmin, si_zmax)

#define simulation volume
cell = mp.Vector3(bend_length + 2*pml_thickness + 2*x_margin,bend_width+2*pml_thickness + 2*y_margin,cell_thickness)
cell_center = mp.Vector3(0,0,0)

#define location and geometry of source and monitors
z_axis = mp.Vector3(0,0,1)
bend_angle = math.radians(45)
port_size = mp.Vector3(0,1,1)
port_size_out = port_size.rotate(z_axis, bend_angle)
port1 = mp.Volume(center=mp.Vector3(port1_x,port1_y,0), size=port_size)
port2 = mp.Volume(center=mp.Vector3(port2_x,port2_y,0), size=port_size_out)#.rotate(z_axis, np.deg2rad(45))
source = mp.Volume(center=mp.Vector3(port1_x-0.5*x_margin,port1_y,0),size=port_size)

mode_parity = mp.NO_PARITY if is_3D else mp.EVEN_Y + mp.ODD_Z

# setup source
sources = [
    mp.EigenModeSource(
        src=mp.GaussianSource(wavelength=lcen, fwidth=df_source),
        size=source.size,
        center=source.center,
        eig_band=1,
        eig_parity=mode_parity,
        eig_match_freq=True,
    )
]

#setup simulation
sim = mp.Simulation(
    resolution=res,
    cell_size=cell,
    boundary_layers=[mp.Absorber(pml_thickness)],
    sources=sources,
    geometry=geometry,
    default_material=SiO2
)


# Adds mode monitors at each of the ports to track the energy that goes in or out
mode_monitor_1 = sim.add_mode_monitor(fpoints, mp.ModeRegion(volume=port1))
mode_monitor_2 = sim.add_mode_monitor(fpoints, mp.ModeRegion(volume=port2))

plot_plane = mp.Volume(center=cell_center, size=mp.Vector3(cell.x, cell.y, 0))
sim.plot2D(output_plane=plot_plane if is_3D else None) # No parameters are needed for a 2D simulation. 
#plt.savefig("output/sim_setup.png")
plt.show()

sim_handler = SimulationHandler("output/fieldData.h5", cell_x=cell.x, cell_y=cell.y, res=res)

def updateField(sim):
    ex = np.array([sim.get_array(center=cell_center,size=mp.Vector3(cell.x, cell.y, 0),component=mp.Ex)])
    ey = np.array([sim.get_array(center=cell_center,size=mp.Vector3(cell.x, cell.y, 0),component=mp.Ey)])
    ez = np.array([sim.get_array(center=cell_center,size=mp.Vector3(cell.x, cell.y, 0),component=mp.Ez)])
    hx = np.array([sim.get_array(center=cell_center,size=mp.Vector3(cell.x, cell.y, 0),component=mp.Hx)])
    hy = np.array([sim.get_array(center=cell_center,size=mp.Vector3(cell.x, cell.y, 0),component=mp.Hy)])
    hz = np.array([sim.get_array(center=cell_center,size=mp.Vector3(cell.x, cell.y, 0),component=mp.Hz)])
    sim_handler.update_fields(ex, ey, ez, hx, hy, hz)

sim.run(mp.at_every(1, updateField), until=150)

# Finds the S parameters
norm_mode_coeff = sim.get_eigenmode_coefficients(mode_monitor_1, [1], eig_parity=mode_parity).alpha[0, :, 0]#
port1_coeff = sim.get_eigenmode_coefficients(mode_monitor_1, [1], eig_parity=mode_parity).alpha[0, :, 1] / norm_mode_coeff
port2_coeff = sim.get_eigenmode_coefficients(mode_monitor_2, [1], eig_parity=mode_parity).alpha[0, :, 0] / norm_mode_coeff

np.savez('output/s_params.npz', wl=wl, s11=port1_coeff, s21=port2_coeff)

[stevengj]

I believe it should work the same way as oblique-waveguide sources: https://meep.readthedocs.io/en/latest/Python_Tutorials/Eigenmode_Source/#oblique-waveguides

That is, you make a mode monitor that slices through your oblique waveguide in one of the cartesian (xyz) directions, and you just pass an eig_kpoint that goes in the oblique direction.

[felme1]

Thank you! This seems to have done the trick.