rspie is an assortment of tools to launch and analyze computational electromagnetism simulations in Photonic Tools.
x-component of the electric field at position (x, y, z) of an electric
dipole with frequency omega and located at position (xd, yd, zd) including
near-field components.
y-component of the electric field at position (x, y, z) of an electric
dipole with frequency omega and located at position (xd, yd, zd) including
near-field components.
z-component of the electric field at position (x, y, z) of an electric
dipole with frequency omega and located at position (xd, yd, zd) including
near-field components.
x-component of the electric field at position (x, y, z) of an electric
dipole with frequency omega and located at position (xd, yd, zd) in its
radiation zone.
y-component of the electric field at position (x, y, z) of an electric
dipole with frequency omega and located at position (xd, yd, zd) in its
radiation zone.
z-component of the electric field at position (x, y, z) of an electric
dipole with frequency omega and located at position (xd, yd, zd) in its
radiation zone.
x-component of the magnetic field at position (x, y, z) of an electric
dipole with frequency omega and located at position (xd, yd, zd) including
near-field components.
y-component of the magnetic field at position (x, y, z) of an electric
dipole with frequency omega and located at position (xd, yd, zd) including
near-field components.
z-component of the magnetic field at position (x, y, z) of an electric
dipole with frequency omega and located at position (xd, yd, zd) including
near-field components.
x-component of the magnetic field at position (x, y, z) of an electric
dipole with frequency omega and located at position (xd, yd, zd) in its
radiation zone.
y-component of the magnetic field at position (x, y, z) of an electric
dipole with frequency omega and located at position (xd, yd, zd) in its
radiation zone.
z-component of the magnetic field at position (x, y, z) of an electric
dipole with frequency omega and located at position (xd, yd, zd) in its
radiation zone.
This function runs a simulation using DiffractMOD to estimate the
phase difference that a rectangular pillar of given geometry and
composition will provide to a plane wave at normal incidence.
This is done by simulating a periodic grating in a square lattice with
the pillar in the center.
The launch field, as configured in the auxiliary script, is assumed to
be a plane wave at normal incidence, and is launched from inside the
substrate. The launch field has linear polarization along the x-axis.
The pillar is assumed to be on top of a substrate whose refractive
index can also be provided.
All the refractive indices are assumed to be real and isotropic.
The width is the length of the pillar along the x-axis, and the height
is the length along the y-axis. This before the rotation defined by
Angle is applied.
Parameters
----------
config (dict) : with the following keys (not all which need to be provided)
'Angle' (float) : angle (in degrees) that orients the pillar (default=0)
'Aspect' (float) : width/height of the pillar (default=1)
'Fill' (float) : width/Period (used to fix width) (default=0.25)
'Period' (float) : period of the square lattice in um.
'PillarHeight' (float): length of pillar (in um) in the z-dir (measured from the top of the substrate)
'PillarIndex' (float): refractive index of the pillar
'SubstrateIndex' (float): refractive index of the substrate
'background_index' (float): refractive index of the background
simulscript (str): path to the template circuit to run the simulation
hide (bool) : whether to hide the simulation window or not
cleanup (bool) : whether to delete the output files or not
Returns
-------
(float, float) : (overlap_magnitude, overlap_phase_in_degrees)
Parameters
----------
filename (str): path to the .fld file
Returns
-------
extent, data (tuple): (extent, data)
extent (tuple): (xmin, xmax, zmin, zmax)
data (np.ndarray): 2D array of the data
Give a text string of definitions, parse them into a dictionary.
Each line in the text string should be of the form: var_name = var_value
where var_name should be a valid Python variable name, and var_value
a string or an expression that may depend on the other variables defined
in the given text.
The given text might have commentary lines starting with #, which will
make them be omitted. The text may also have empty lines.
If provided aux_vars is a dictionary whose values and keys will also be used
to make sense of the definitions in the given text.
Parameters
----------
def_text (str): text string of definitions
aux_vars (dict): auxiliary variables to be used in the expressions
max_iteration_depth (int): number of iterations to try to parse the definitions
Returns
-------
vars_dict (dict): dictionary of definitions
Example
-------
>>> def_text = '''x = 1
y = x+1
'''
>>> def_dict = recursive_def_parser(def_text)
>>> print(def_dict)
{'x': 1, 'y': 2}
This function can be used to load a 3D .dat file from RSoft.
It assumes that the file has real-valued data.
Parameters
----------
fname (str): path to the .dat file
Returns
-------
x_coords, y_coords, z_coords, num_array (tuple): (x_coords, y_coords, z_coords, num_array)
x_coords (np.ndarray): 1D array of the x coordinates
y_coords (np.ndarray): 1D array of the y coordinates
z_coords (np.ndarray): 1D array of the z coordinates
num_array (np.ndarray): 3D array of the data
This function can be used to load a 2D .dat file from RSoft.
It assumes that the file has real-valued data.
Parameters
----------
fname (str): path to the .dat file
Returns
-------
(tuple): (x_coords, y_coords, num_array, file_format)
file_format (str): the format of the data in the file
x_coords (np.ndarray): 1D array of the x coordinates
y_coords (np.ndarray): 1D array of the y coordinates
num_array (np.ndarray): 2D array of the data with each row corresponding to strip of
constant y and each column corresponding to a strip of constant x.
The first row corresponds to the lowest (x,y) value pair.
This function saves a 2D array to a dat file that can be read by RSoft.
xmin, xmax, ymin, ymax need to match the bounds of the simulation volume
in the RSoft simulation where the file will be used as input.
Parameters
----------
fname (str) : The filename where the data will be saved.
data_array (numpy.ndarray) : The 2D array that will be saved.
wavelength (float) : The wavelength of the simulation.
xmin (float) : The minimum x value of the simulation.
xmax (float) : The maximum x value of the simulation.
ymin (float) : The minimum y value of the simulation.
ymax (float) : The maximum y value of the simulation.
Returns
-------
None
Calculates the electric and magnetic fields of an electric dipole.
Parameters
----------
x, y, z : (float, float, float) coordinates of the point where the field is calculated
xd, yd, zd : (float, float, float) coordinates of the dipole
thetadip, phidip : (float, float) polar and azimuthal angles of the dipole moment
omega : (float) frequency of the dipole
Returns
-------
EBfield : (np.array) electric and magnetic fields (Ex, Ey, Ez, Bx, By, Bz)
Calculates the electric and magnetic fields of an electric dipole in the
radiation zone.
Parameters
----------
x, y, z : (float, float, float) coordinates of the point where the field is calculated
xd, yd, zd : (float, float, float) coordinates of the dipole
thetadip, phidip : (float, float) polar and azimuthal angles of the dipole moment
omega : (float) frequency of the dipole
Returns
-------
EBfield : (np.array) electric and magnetic fields (Ex, Ey, Ez, Bx, By, Bz)
This function returns a numpy array of evenly spaced points
between lmin and lmax with a spacing of dx. If symm is 'even',
the array will have an even number of points symmetrically
distributed about the midpoint without including it. If symm is
'odd', the array will have an odd number of points with the given
points symmetrically distributed about the midpoint, including
the midpoint itself. Given this the given array may not contain
the endpoints lmin and lmax.
Parameters
----------
lmin (float) : the minimum value of the interval
lmax (float) : the maximum value of the interval
dx (float) : the spacing between points
symm (str) : wheter to include the midpoint or not.
Returns
-------
interspace (numpy array): The evenly spaced array of points
This function takes a dictionary of parameters defining a metalens
and returns a circuit object that corresponds to it.
The circuit also includes a launch field consisting of a plane wave
incident at normal incidence.
The circuit also includes a DFT monitor that monitors the field at
the end of the pillars and saves Ex, Ey, Ez, Hx, Hy, Hz when the circuit
is run.
Parameters
----------
metal_config : dict
A dictionary of parameters defining a metasurface. The keys are:
ApertureRadius : float
The radius of the aperture in the metasurface.
period : float
The period of the square grid of pillars in the metasurface.
PillarHeight : float
The height of the pillars in the metasurface.
circuitFname : str
The name of the file to save the circuit to.
PillarIndex : float
The index of refraction of the pillars.
SubstrateIndex : float
The index of refraction of the substrate.
background_index : float
The index of refraction of the background.
free_space_wavelength : float
The wavelength of the light in free space.
phase_func : function
A function that takes in x and y coordinates and returns the
radius that a post at that location should have. For example
this could be the classical Fresnel phase profile.
pillar_func : function
A function that takes in a phase and returns the width that
a post at that location should have to impart that phase. This
would usually be a function that is an interpolation radii and
phases that a previous simulation should have provided.
Returns
-------
circuit : rspie.circuit.Circuit
This function returns a function that takes x and y coordinates
and returns the required phase pickup for the given focal length
and medium wavelength.
This function determines the phase profile of meta-atoms with the given
characteristics.
The meta-atoms have a rectangular cross section.
Parameters
----------
config : dict with keys:
'focal_length' : float
focal length of the lens
'medium_wavelength' : float
wavelength of the medium
'Period' : float
period of the square grid used to simulate the phase response of meta-atoms
'free_space_wavelength' : float
wavelength of the free space
'PillarIndex' : float
index of the pillar
'SubstrateIndex' : float
index of the substrate
'background_index' : float
index of the background
'Angle' : float
angle of the rectangular meta-atom
'fill_steps' : int
number of fill_factors to use
'Har' : int
how many harmonics are used in the RCWA simulation
'Aspect' : float
aspect ratio of the rectangular meta-atom
'min_width' : float
minimum width of the pillars
'max_width' : float
maximum width of the pillars
Returns
-------
overlap_phases : np.array
overlap phases for each fill factor, given in radians
pillar_widths : list of floats
widths of the pillars corresponding to the phases
Parameters
----------
config : dict
dictionary of parameters for the simulation
simulscript : str
path to the simulation script
cleanup : bool
whether to delete the mode files after the simulation is complete
verbose : bool
whether to print the output of the simulation to the console
Returns
-------
modes : list of dicts
list of mode dictionaries, each with keys:
'mode' : np.array
mode field
'neff' : float
effective index of the mode
'width' : float
width of the mode
'height' : float
height of the mode
This function can be used to read
the data stores in the output fiels from
the Photonic Tools mode solver.
Parameters
----------
filename : str
Returns
-------
extent (tuple), lines(np.array), n_eff (np.array)
Put everything together
Create a string of definitions using the key-value pairs in
the given dictionary, prepending and appending adequate
headers and footers.
Parameters
----------
block_dicts (list): a list with dictionaries defining the block
block_header (str): header of the block (e.g. 'segment')
offset (int) : offset to add to the index of the block
Returns
-------
(tuple) (block_length (int) , block(str))
Put together the circuit text from the its segments,
monitors, launch fields and variables.
Parameters
----------
None
Returns
-------
circuit_text (str): the circuit text
Parse self.vars as instance attributes.
Parameters
----------
None
Returns
-------
None
Save circuit to self.full_filename.
Returns
-------
None
Run the circuit.
Parameters
----------
None
Returns
-------
None
Opens the created circuit in RSoft.