Simulation description

structures

structures contains the main struct object, structure generators and helper functions related to the generation of structure geometries.

structure definition class struct

class pyGDM2.structures.struct(step, geometry, material, n1=None, n2=None, normalization='auto', n3=None, spacing=5000.0, auto_shift_structure=False, check_geometry_consistency=True, verbose=True)

structure container

Defines a nanostructure to perform a GDM simulation on. This includes the geometry and the material-specific dielectric function(s) for each meshpoint

Note: This class works only with the new pure-python interface!

Parameters
  • step (float) – stepsize used for discretization

  • geometry (list of tuples) – list of coordinates of the meshpoints of the geometry. Several structure generators are provided in the module structures

  • material (instance of materials class or list of such) – use material classes provided by the materials module. If a single instance is provided, the according material will be used for the entire structure

  • normalization (str, default: 'auto') – set mesh-type. Either ‘auto’ (default), ‘cube’, or ‘hex’, or alternatively the numeric mesh normalization factor (float).

  • auto_shift_structure (bool, default: False) – whether to shift the structure to positive z values if structure or parts of it are below 0

  • check_geometry_consistency (bool, default: True) – whether to test geometry for consistency. If yes, inconsistent meshpoints will be removed and a warning will be produced

  • verbose (int, default: 1) – 0: print nothing, 1: print some runtime info

__init__(step, geometry, material, n1=None, n2=None, normalization='auto', n3=None, spacing=5000.0, auto_shift_structure=False, check_geometry_consistency=True, verbose=True)

Initialization

setDtype(dtypef, dtypec)

set dtype of arrays

setWavelength(wavelength)

set wavelength and evaluate environment / structure properties

Structure generators

pyGDM2.structures.rect_wire(step, L, H, W, mesh='cube', ORIENTATION=1)

Generate rectangular wire with long axis along X on X/Y plane

Parameters
  • step (float) – stepsize in nw

  • H, W (L,) – Length, Height and Width as Nr. of steps

  • mesh (string, default: 'cube') – meshing type. ‘cube’ or ‘hex’

  • ORIENTATION (int, default: 1) – For hex. meshing only. ‘1’ or ‘2’. Orientation of Hexagons.

Returns

list of 3d coordinates in tuples (x,y,z)

Return type

list of tuples

pyGDM2.structures.rect_dimer(step, L, H, W, G, mesh='cube', ORIENTATION=1)

Generate rectangular wire dimer with long axis along X on X/Y plane

Using rectwire model for generation of the two dimer particles.

Note : Using an even number gap will result in non-symmetric position with respect to (X=0,Y=0)

Parameters
  • step (float) – stepsize in nw

  • H, W (L,) – Length, Height and Width as Nr. of steps

  • G (int (zero or positive)) – Gap between dimers, in Nr. of steps

  • mesh (string, default: 'cube') – meshing type. ‘cube’ or ‘hex’

  • ORIENTATION (int, default: 1) – For hex. meshing only. ‘1’ or ‘2’. Orientation of Hexagons.

Returns

list of 3d coordinates in tuples (x,y,z)

Return type

list of tuples

pyGDM2.structures.prism(step, NSIDE, H, truncate_ratio=0.0, mesh='cube', ORIENTATION=1)

Generate prism on X/Y plane

Parameters
  • step (float) – stepsize in nw

  • NSIDE (int) – sidelength of regular prism (in nrs of dipoles)

  • H (int) – height of prism (in nrs of dipoles)

  • truncate_ratio (float) – truncate edges. give the ratio of total sidelength to remove. value between 0 [no truncation] and 1 [truncate at sidelength center]

  • mesh (string, default: 'cube') – meshing type. ‘cube’ or ‘hex’

  • ORIENTATION (int, default: 1) – For hex. meshing only. ‘1’ or ‘2’. Orientation of Hexagons.

Returns

list of 3d coordinates in tuples (x,y,z)

Return type

list of tuples

pyGDM2.structures.rhombus(step, L, H, alpha=90.0, mesh='cube', ORIENTATION=1)

Generate planar rhombus structure on X/Y plane

Parameters
  • step (float) – stepsize in nw

  • L (int) – sidelength of regular prism (in nrs of dipoles)

  • H (int) – height of prism (in nrs of dipoles)

  • alpha (float, default: 90) – top/bottom angle of rhombus (in degrees)

  • mesh (string, default: 'cube') – meshing type. ‘cube’ or ‘hex’

  • ORIENTATION (int, default: 1) – For hex. meshing only. ‘1’ or ‘2’. Orientation of Hexagons.

Returns

list of 3d coordinates in tuples (x,y,z)

Return type

list of tuples

pyGDM2.structures.hexagon(step, NSIDE, H, rotate=0.0, mesh='cube', ORIENTATION=1)

Generate regular hexagon on X/Y plane

Parameters
  • step (float) – stepsize in nw

  • NSIDE (int) – sidelength of regular hexagon (in nrs of dipoles)

  • H (int) – height of hexagon (in nrs of dipoles)

  • rotate (float, default: 0) – rotation angle (in degrees)

  • mesh (string, default: 'cube') – meshing type. ‘cube’ or ‘hex’

  • ORIENTATION (int, default: 1) – For hex. meshing only. ‘1’ or ‘2’. Orientation of Hexagons.

Returns

list of 3d coordinates in tuples (x,y,z)

Return type

list of tuples

pyGDM2.structures.double_hexagon(step, NSIDE1, NSIDE2, DX, DY, H, rotate=0.0, mesh='cube', ORIENTATION=1)

Generate regular hexagon on X/Y plane

Parameters
  • step (float) – stepsize in nw

  • NSIDE1 (int) – sidelength of hexagon1 (in nrs of dipoles)

  • NSIDE2 (int) – sidelength of hexagon2 (in nrs of dipoles)

  • DX (int) – X-offset of hexagon2 (in nrs of dipoles)

  • DY (int) – Y-offset of hexagon2 (in nrs of dipoles)

  • H (int) – height of hexagon (in nrs of dipoles)

  • rotate (float, default: 0) – rotation angle (in degrees)

  • mesh (string, default: 'cube') – meshing type. ‘cube’ or ‘hex’

  • ORIENTATION (int, default: 1) – For hex. meshing only. ‘1’ or ‘2’. Orientation of Hexagons.

Returns

list of 3d coordinates in tuples (x,y,z)

Return type

list of tuples

pyGDM2.structures.diabolo(step, nside_upper, nside_lower, length, width, H, dir_prisms='in', mesh='cube', ORIENTATION=1)

generate diabolo structure on X/Y plane

Parameters
  • step (float) – stepsize in nw

  • nside_upper (int) – sidelength of upper regular prism (in nrs of dipoles)

  • nside_lower (int) – sidelength of upper regular prism (in nrs of dipoles)

  • length (int) – length of bridge between prisms (in nrs of dipoles)

  • width (int) – width of bridge between prisms (in nrs of dipoles)

  • H (int) – height of prism (in nrs of dipoles)

  • dir_prisms (str, default="in") – “in” or “out”. Direction of prism tips, inwards or outwards.

  • mesh (string, default: 'cube') – meshing type. ‘cube’ or ‘hex’

  • ORIENTATION (int, default: 1) – For hex. meshing only. ‘1’ or ‘2’. Orientation of Hexagons.

Returns

list of 3d coordinates in tuples (x,y,z)

Return type

list of tuples

pyGDM2.structures.polygon(step, config_dict, H, mesh='cube', ORIENTATION=1, plot_testing=False, verbose=False)

Generate polygonal, planar structure on X/Y plane

Can take a list of polygons, they can be either added or removed. The order of adding / removing polygons is important!

Requires module shapely.

Parameters
  • step (float) – stepsize in nm

  • config_dict (dict or list of dict) –

    every dictionary describes one polygon and contains the keywords:
    • N (mandatory): number of eges

    • S (mandatory): side length in units of step

    • offset: optional offset. tuple (X, Y). default: (0,0)

    • aspect: optional aspect ratio (X/Y). default: 1

    • alpha: optional rotation angle (in degrees). default: 0

    • mode: optional. either ‘add’ or ‘remove’. Will either add the

      polygon to the collection or remove it. default: ‘add’

  • H (int) – height of planar structure in units of steps

  • mesh (string, default: 'cube') – meshing type. ‘cube’ or ‘hex’

  • ORIENTATION (int, default: 1) – For hex. meshing only. ‘1’ or ‘2’. Orientation of Hexagons.

  • plot_testing (bool, default: False) – plot polygon outlines using matplotlib’s pyplot

  • verbose (bool, default: False) – print timing info

Returns

list of 3d coordinates in tuples (x,y,z)

Return type

list of tuples

pyGDM2.structures.sphere(step, R, mesh='cube', ORIENTATION=1)

Generate sphere with radius R on X/Y plane

Parameters
  • step (float) – stepsize in nw

  • R (float) – radius of sphere (in nrs of dipoles). Not limited to integer numbers.

  • mesh (string, default: 'cube') – meshing type. ‘cube’ or ‘hex’

  • ORIENTATION (int, default: 1) – For hex. meshing only. ‘1’ or ‘2’. Orientation of Hexagons.

Returns

list of 3d coordinates in tuples (x,y,z)

Return type

list of tuples

pyGDM2.structures.spheroid(step, R1, R2, R3, mesh='cube', ORIENTATION=1)

Generate spheroid with radii R1, R2, R3 along X, Y, Z axis

  • if R3>R2=R1 –> prolate spheroid

  • if R3<R2=R1 –> oblate spheroid

  • if R3=R2=R1 –> sphere

contributed by C. Majorel.

Parameters
  • step (float) – stepsize in nm

  • R1 (float) – radius along X axis (in nrs of steps). Not limited to integer numbers.

  • R2 (float) – radius along Y axis (in nrs of steps). Not limited to integer numbers.

  • R3 (float) – radiu along Z axis (in nrs of steps). Not limited to integer numbers.

  • mesh (string, default: 'cube') – meshing type. ‘cube’ or ‘hex’

  • ORIENTATION (int, default: 1) – For hex. meshing only. ‘1’ or ‘2’. Orientation of Hexagons.

Returns

list of 3d coordinates in tuples (x,y,z)

Return type

list of tuples

pyGDM2.structures.nanodisc(step, R, H, ELONGATED=0, mesh='cube', ORIENTATION=1)

Generate round nanodisc in X/Y plane. Height H, Radius R.

Parameters
  • step (float) – stepsize in nw

  • R (float) – radius of circular crosssection (in nrs of dipoles). Not limited to integer numbers.

  • H (int) – Height of Structure (in nrs of dipoles).

  • ELONGATED (int, default: 0) – add optional elongation “bridge” between half-circles (in nrs of steps)

  • mesh (string, default: 'cube') – meshing type. ‘cube’ or ‘hex’

  • ORIENTATION (int, default: 1) – For hex. meshing only. ‘1’ or ‘2’. Orientation of Hexagons.

Returns

list of 3d coordinates in tuples (x,y,z)

Return type

list of tuples

pyGDM2.structures.nanorod(step, L, R, caps='flat', mesh='cube', ORIENTATION=1)

Generate round nanorod with axis along X on X/Y plane

Parameters
  • step (float) – stepsize in nw

  • L (int) – length of rod (in nrs of dipoles).

  • R (float) – radius of circular crosssection (in nrs of dipoles). Not limited to integer numbers.

  • caps (str, default: 'flat') – ‘flat’: flat caps, ‘round’: semispherical caps

  • mesh (string, default: 'cube') – meshing type. ‘cube’ or ‘hex’

  • ORIENTATION (int, default: 1) – For hex. meshing only. ‘1’ or ‘2’. Orientation of Hexagons.

Returns

list of 3d coordinates in tuples (x,y,z)

Return type

list of tuples

pyGDM2.structures.lshape_rect(step, L, W, H, DELTA, mesh='cube', ORIENTATION=1)

Generate symmetric L-shaped nanoantenna in X/Y plane formed by two rectangular elements.

Parameters
  • step (float) – stepsize in nw

  • L,W,H (int) – length,width,height of each rod (in nrs of dipoles)

  • DELTA (int (odd number)) – Gap width - only odd numbers work for symmetry reasons! (in nr of dipoles)

  • mesh (string, default: 'cube') – meshing type. ‘cube’ or ‘hex’

  • ORIENTATION (int, default: 1) – For hex. meshing only. ‘1’ or ‘2’. Orientation of Hexagons.

Returns

list of 3d coordinates in tuples (x,y,z)

Return type

list of tuples

pyGDM2.structures.lshape_rect_nonsym(step, L1, W1, L2, W2, H, DELTA, mesh='cube', ORIENTATION=1)

Generate symmetric L-shaped nanoantenna in X/Y plane formed by two rectangular elements.

Parameters
  • step (float) – stepsize in nw

  • L,W,H (int) – length,width,height of each rod (in nrs of dipoles)

  • DELTA (int (odd number)) – Gap width - only odd numbers work for symmetry reasons! (in nr of dipoles)

  • mesh (string, default: 'cube') – meshing type. ‘cube’ or ‘hex’

  • ORIENTATION (int, default: 1) – For hex. meshing only. ‘1’ or ‘2’. Orientation of Hexagons.

Returns

list of 3d coordinates in tuples (x,y,z)

Return type

list of tuples

pyGDM2.structures.lshape_round(step, L, W, H, DELTA, RAD, mesh='cube', ORIENTATION=1)

Generate symmetric L-shaped nanoantenna in X/Y plane formed by two rectangular elements.

Parameters
  • step (float) – stepsize in nm

  • L,W,H (int) – length,width,height of each rod (in nrs of dipoles)

  • DELTA (int (odd number)) – Gap width - only odd numbers work for symmetry reasons! (in nr of dipoles)

  • RAD (float) – radius of curvature in steps (nr of dipoles)

  • mesh (string, default: 'cube') – meshing type. ‘cube’ or ‘hex’

  • ORIENTATION (int, default: 1) – For hex. meshing only. ‘1’ or ‘2’. Orientation of Hexagons.

Returns

list of 3d coordinates in tuples (x,y,z)

Return type

list of tuples

pyGDM2.structures.split_ring(step, R, W, H, G=- 1, alphaG=0.0, mesh='cube', ORIENTATION=1)

Generate splitring structure on X/Y plane

If G (gap) is set: close the resonator up to “gap” (G=)

Parameters
  • step (float) – stepsize in nw

  • R,W,H (int,int,int) – Dimensions: Radius, linewidth and height of structure (in nr. of dipoles)

  • G ((optional) int, default: -1) – Gap width in numbers of steps. If G == -1, alphaG is taken instead

  • alphaG ((optional) float, default: 0) – Gap width as angle in degrees. Allowed angles: Between 0 and 180. ‘0’: entirely closed

  • mesh (string, default: 'cube') – meshing type. ‘cube’ or ‘hex’

  • ORIENTATION (int, default: 1) – For hex. meshing only. ‘1’ or ‘2’. Orientation of Hexagons.

Returns

list of 3d coordinates in tuples (x,y,z)

Return type

list of tuples

pyGDM2.structures.rect_split_ring(step, L1, L2, H, W, G=False, mesh='cube', ORIENTATION=1)

Generate rectangular splitring structure on X/Y plane

If G (gap) is set: close the resonator up to “gap” (G=)

Parameters
  • step (float) – stepsize in nw

  • H, W (L1,L2,) – Length (L1:X,L2:Y), Height and Width in Nr. of steps

  • G ((optional) int, default: False) –

    Gap of a closed splitring.

    If False: totally open splitring, If ‘0’: entirely closed

  • mesh (string, default: 'cube') – meshing type. ‘cube’ or ‘hex’

  • ORIENTATION (int, default: 1) – For hex. meshing only. ‘1’ or ‘2’. Orientation of Hexagons.

Returns

list of 3d coordinates in tuples (x,y,z)

Return type

list of tuples

Mesher

pyGDM2.structures._meshCubic(XRANGE, YRANGE, ZRANGE, condition, Z_offset=0.5)

mesh on a cubic grid

Mesh a 3d structure on a cubic grid within given spacial limits using a boolean selection function

Parameters
  • XRANGE (tuple) – tuple of 2 ints (x0, x1): Indices of x-coordinates on mesh

  • YRANGE (tuple) – tuple of 2 ints (y0, y1): Indices of y-coordinates on mesh

  • ZRANGE (tuple) – tuple of 2 ints (z0, z1): Indices of z-coordinates on mesh

  • condition (function) – function of mesh-coord.-indices, whether to place a meshpoint or not: ‘func(xi,yi,zi)’, must returns a Boolean

  • Z_offset (float, default: 0.5) – additional z-offset, to avoid placing dipoles at z=0

Returns

list of 3d coordinate-index tuples

Return type

list of tuples

pyGDM2.structures._meshHexagonalCompact(XRANGE, YRANGE, ZRANGE, condition, ORIENTATION=1, Z_offset=0.5, auto_expand_range=True)

mesh on a hexagonal compact grid

Parameters
  • XRANGE (tuple) – tuple of 2 ints (x0, x1): Indices of x-coordinates on mesh

  • YRANGE (tuple) – tuple of 2 ints (y0, y1): Indices of y-coordinates on mesh

  • ZRANGE (tuple) – tuple of 2 ints (z0, z1): Indices of z-coordinates on mesh

  • condition (function) – function of mesh-coord.-indices, whether to place a meshpoint or not: ‘func(xi,yi,zi)’, must returns a Boolean

  • ORIENTATION (int, default: 1) – For hex. meshing only. ‘1’ or ‘2’. Orientation of Hexagons.

  • Z_offset (float, default: 0.5) – additional z-offset, to avoid placing dipoles at z=0

  • auto_expand_range (bool, default: True) – automatically expand meshing range in order to account for denser than cubic meshing

Returns

list of 3d coordinate-index tuples

Return type

list of tuples

Other functions

pyGDM2.structures.image_to_struct(img_name, nm_per_pixel, stepsize, H, threshold=100, useDarkPixel=True, returnImage=False, center_structure=True, mesh='cube', ORIENTATION=1)

Convert an image to a planar structure

Might be useful with SEM images

Parameters
  • img_name (string or numpy array) – path to image-file or numpy array containing image. Array values should range from 0 to 255.

  • nm_per_pixel (float) – number of nanometers corresponding to one pixel in image

  • stepsize (float) – target stepsize

  • H (int) – Height of final structure in numbers of stepsize

  • threshold (float, (default: 100)) – threshold value between [0, 255] to declare a pixel as structure all brighter pixels will be used

  • useDarkPixel (bool, default: True) – if False, use bright pixels as structure (below threshold), instead of the dark ones

  • returnImage (bool, default: False) – if True, returns a 2D numpy array corresponding to the image AND the structure

  • center_structure (bool, default: True) – whether to automatically center structure

  • mesh (string, default: 'cube') – meshing type. ‘cube’ or ‘hex’

  • ORIENTATION (int, default: 1) – For hexagonal meshing only. ‘1’ or ‘2’. Orientation of Hexagons.

Returns

  • struct (list of tuples) – list of 3d coordinates in tuples (x,y,z)

  • if returnImage==True – returns tuple: (img_array, struct)

pyGDM2.structures.struct_to_image(STRUCT, RGB=True, minimum_size=- 1, projection='XY')

generate image-compatible array from structure geometry

Parameters
  • struct (list of tuple or core.simulation) – list of coordinate tuples or instance of core.simulation

  • RGB (bool, default: True) – If True, generates an RGB array. If False, generate a 2D array with simply 0 and 1 as entries (0: no material, 1: material)

  • minimum_size (int, default: -1) – minimum canvas size in pixels. -1: use structure extensions. If >0: enlarge canvas and center structure if structure extensions smaller than image.

  • projection (str, default: "XY") – 2D plane for projection. One of [‘XY’, ‘XZ’, ‘YZ’]

Returns

  • np.array for image conisting of rgb tuples for each pixel.

  • Plot e.g. using matplotlib’s imshow.

  • Save to bitmap or png file e.g. using scipy.misc.imsave.

pyGDM2.structures.get_normalization(mesh)

Provide normalization factor for mesh type

Parameters

mesh (string) – mesh used for structure generator

Returns

normalization – normalization factor corresponding to mesh

Return type

float

pyGDM2.structures.center_struct(STRUCT, returnOffsets=False)

Center a structure on the x/y plane around (0,0)

Parameters
  • STRUCT (list of tuples, or struct-object or simulation-class) – list of (x,y,z) coordinate tuples, as generated by the functions of the structure module; or struct or simulation object (which includes the geometry information)

  • returnOffsets (bool, default: False) – if True, return tuple of applied (X,Y)-offset together with structure

Returns

    • list of 3d coordinates as tuples (x,y,z); or struct or – simulation object with adapted geometry.

  • - optionally (Offset-tuple as second return value)

pyGDM2.structures.rotate_XY(STRUCT, ALPHA)

Rotate a structure around the z axis

see rotate() for full documentation

materials

materials is a collection of classes defining the dispersion of materials.

fromFile class

class pyGDM2.materials.fromFile(refindex_file, unit_wl='micron', interpolate_order=1, name=None)

tabulated dispersion

Use tabulated data provided from textfile for the complex material refractive index

Parameters
  • refindex_file (str) –

    path to text-file with the tabulated refractive index (3 whitespace separated columns: #1 wavelength, #2 real(n), #3 imag(n))

    Data can be obtained e.g. from https://refractiveindex.info/ using the “Full database record” export function.

  • unit_wl (str, default: 'micron') – Units of the wavelength in file, one of [‘micron’, ‘nm’]

  • interpolate_order (int, default: 1) – interpolation order for data (1: linear, 2: square, 3: cubic) “1” uses numpy.interp, “2” and “3” require scipy (using scipy.interpolate.interp1d)

  • name (str, default: None) – optional name attribute for material class. By default use filename.

__init__(refindex_file, unit_wl='micron', interpolate_order=1, name=None)

Use tabulated dispersion

epsilon(wavelength)

Tabulated interpolated dielectric function

constant dielectric function material

Parameters

wavelength (real) – wavelength at which to evaluate dielectric function (in nm)

Predefined materials

class pyGDM2.materials.dummy(n=2 + 0j)

constant index

Material with spectrally constant refractive index

Parameters

n (complex, default: (2.0 + 0.0j)) – complex refractive index of constant material (returned dielectric function will be n**2)

class pyGDM2.materials.gold(interpolate_order=1)

gold index

Complex dielectric function of gold from: P. B. Johnson and R. W. Christy. Optical Constants of the Noble Metals, Phys. Rev. B 6, 4370-4379 (1972)

Parameters

interpolate_order (int, default: 1) – interpolation order for data (1: linear, 2: square, 3: cubic) “1” uses numpy, “2” and “3” require scipy (scipy.interpolate.interp1d)

class pyGDM2.materials.silver(interpolate_order=1)

gold index

Complex dielectric function of silver from: P. B. Johnson and R. W. Christy. Optical Constants of the Noble Metals, Phys. Rev. B 6, 4370-4379 (1972)

Parameters

interpolate_order (int, default: 1) – interpolation order for data (1: linear, 2: square, 3: cubic) “1” uses numpy, “2” and “3” require scipy (scipy.interpolate.interp1d)

class pyGDM2.materials.alu(interpolate_order=1)

alu index

Complex dielectric function of aluminium from: A. D. Rakić, A. B. Djurišic, J. M. Elazar, and M. L. Majewski. Optical properties of metallic films for vertical-cavity optoelectronic devices, Appl. Opt. 37, 5271-5283 (1998)

Parameters

interpolate_order (int, default: 1) – interpolation order for data (1: linear, 2: square, 3: cubic) “1” uses numpy, “2” and “3” require scipy (scipy.interpolate.interp1d)

class pyGDM2.materials.silicon(interpolate_order=1)

silicon index

Complex dielectric function of silicon from: Edwards, D. F. in Handbook of Optical Constants of Solids (ed. Palik, E. D.) 547–569 (Academic Press, 1997).

Parameters

interpolate_order (int, default: 1) – interpolation order for data (1: linear, 2: square, 3: cubic) “1” uses numpy, “2” and “3” require scipy (scipy.interpolate.interp1d)

class pyGDM2.materials.sio2(interpolate_order=1)

SiO2 refractive index

Contributed by C. Majorel

Complex dielectric function for SiO2 from:
  • range 210nm –> 6700nm : I. H. Malitson. Interspecimen comparison of the refractive index of fused silica, J. Opt. Soc. Am. 55, 1205-1208 (1965)

  • range 7000nm –> 50000nm :

S. Popova, T. Tolstykh, V. Vorobev. Optical characteristics of amorphous quartz in the 1400–200 cm-1 region, Opt. Spectrosc. 33, 444–445 (1972)

Parameters

interpolate_order (int, default: 1) – interpolation order for data (1: linear, 2: square, 3: cubic) “1” uses numpy, “2” and “3” require scipy (scipy.interpolate.interp1d)

class pyGDM2.materials.tio2(orientation='avg')

TiO2 dispersion

model for visible and NIR range (~500nm - ~1500nm) from https://refractiveindex.info/?shelf=main&book=TiO2&page=Devore-o

Parameters

orientation (str, default: 'avg') –

  • ‘avg’ (or ‘mean’): average of n_o and n_e: n = (2*n_o + n_e) / 3

  • ’n_o’ : ordinary axis permittivity

  • ’n_e’ : extra-ordinary axis permittivity

class pyGDM2.materials.hyperdopedConstantDielectric(n, N_dop, factor_gamma=0.1, act_eff=1.0, carrier='electron')

hyperdoped material with constant ref.index + dopant plasmon resonance

Parameters
  • n (complex) – constant complex refractive index

  • N_dop (float) – Dopant density (cm^-3)

  • factor_gamma (float. default: 0.1) – ratio damping term and plasmon frequency. The default of 0.1 is chosen arbitrarily, resulting in some reasonably broad resonances. The correct value must be obtained experimentally.

  • carrier (string, default: 'electron') – carrier type. ‘electron’ or ‘hole’

  • act_eff (float) – Activation efficiency of dopants, value between 0 and 1. (0=0%, 1=100% activated dopants; the latter being the default behavior)

Notes

For details about the theory and for a discussion on how to choose a value for the damping term, see:

[1] C. Majorel et al. “Theory of plasmonic properties of hyper-doped silicon nanostructures”. Optics Communications 453, 124336 (2019). URL https://doi.org/10.1016/j.optcom.2019.124336

class pyGDM2.materials.hyperdopedFromFile(refindex_file, Ndop, k_mass, damping, unit_wl='micron', interpolate_order=1, name=None)

Add doping-induced plasmon response to tabulated dielectric permittivity

Parameters
  • refindex_file (str) – path to text-file with the tabulated refractive index (3 whitespace separated columns: #1 wavelength, #2 real(n), #3 imag(n)) Data can be obtained e.g. from https://refractiveindex.info/ using the “Full database record” export function.

  • Ndop (float) – Dopant density (cm^-3)

  • damping (float) – damping term (s^-1). See [1] for a discussion on how to choose the damping.

  • k_mass (float) – ratio between the mass of the electron and the effective mass in the material

  • unit_wl (str, default: 'micron') – Units of the wavelength in file, one of [‘micron’, ‘nm’]

  • interpolate_order (int, default: 1) – interpolation order for data (1: linear, 2: square, 3: cubic) “1” uses numpy.interp, “2” and “3” require scipy (using scipy.interpolate.interp1d)

  • name (str, default: None) – optional name attribute for material class. By default use filename.

Notes

For details about the theory and for a discussion on how to choose a value for the damping term, see:

[1] C. Majorel et al. “Theory of plasmonic properties of hyper-doped silicon nanostructures”. Optics Communications 453, 124336 (2019). URL https://doi.org/10.1016/j.optcom.2019.124336

class pyGDM2.materials.hyperdopedSilicon(N_dop, factor_gamma=0.1, act_eff=1.0, carrier='electron')

hyperdoped silicon with plasmon resonance

Complex dielectric function of silicon (<1770nm) from: Edwards, D. F. in Handbook of Optical Constants of Solids (ed. Palik, E. D.) 547–569 (Academic Press, 1997).

and range 1770nm –> 22220 nm :

Parameters
  • N_dop (float) – Dopant density (cm^-3)

  • factor_gamma (float, default: 0.1) – ratio damping term and plasmon frequency. The default of 0.1 is an arbitrary resulting in some reasonably broad resonances. The correct value must be obtained experimentally.

  • carrier (string, default: 'electron') – carrier type. ‘electron’ or ‘hole’

  • act_eff (float , default: 1) – Activation efficiency of dopants, value between 0 and 1. (0=0%, 1=100% activated dopants; the latter being the default behavior)

Notes

See also: [1] D. Chandler-Horowitz and P. M. Amirtharaj. “High-accuracy, midinfrared refractive index values of silicon”. J. Appl. Phys. 97, 123526 (2005). URL https://doi.org/10.1063/1.1923612

[2] C. Majorel et al. “Theory of plasmonic properties of hyper-doped silicon nanostructures”. Optics Communications 453, 124336 (2019). URL https://doi.org/10.1016/j.optcom.2019.124336

fields

fields contains the main efield object and field-generator functions for frequently used fundamental fields.

Incident electro-magnetic field class efield

class pyGDM2.fields.efield(field_generator, wavelengths, kwargs)

incident electromagnetic field container class

Defines an incident electric field including information about wavelengths, polarizations, focal spot or whatever optional parameter is supported by the used field generator.

Parameters
  • field_generator (callable) –

    field generator function. Mandatory arguments are

  • wavelengths (list) – list of wavelengths (wavelengths in nm)

  • kwargs (list of dict or dict) –

    possible additional keyword arguments, passed to field_generator. Either dict or list of dicts.

    • If list of dicts, each entry must correspond exactly to one parameters-set for field-generator.

    • If dict, maybe contain lists for configurations of the parameters. In that case, all possible parameter-permutations will be generated.

Examples

>>> kwargs = dict(theta = [0.0,45,90])
[{'theta': 0.0}, {'theta': 45.0}, {'theta': 90.0}]

is equivalent to:

>>> kwargs = [dict(theta=0.0), dict(theta=45.0), dict(theta=90.0)]
[{'theta': 0.0}, {'theta': 45.0}, {'theta': 90.0}]
__init__(field_generator, wavelengths, kwargs)

initialize field container

setDtype(dtypef, dtypec)

set dtype of arrays

field generators

pyGDM2.fields.plane_wave(pos, env_dict, wavelength, inc_angle=180, inc_plane='xz', theta=None, E_s=0.0, E_p=1.0, phase_Es=0.0, phase=0.0, returnField='E')

generalized incident planewave

supports oblique angles, arbitrary polarization states, 2 interfaces. Default config gives incident plane wave from top (z), linear polarized along x, with amplitude 1

Original code by Ch. Girard, python implementation by C. Majorel

Parameters
  • pos (np.array) – list of 3-tuple coordinates to evaluate field at: [[x1,y1,z1], [x2,y2,z2], … ]

  • env_dict (dict) – Must be compatible with sim.dyads.getConfigDictG typed numba dict. description of environment. Must contain [‘eps1’, ‘eps2’, ‘eps3’, ‘spacing’].

  • wavelength (float) – Wavelength in nm

  • inc_angle (float, default: 180) –

    incident angle with respect to e_z, in degrees. Default is inc from top.
    • 0deg = along Z (from neg to pos Z)

    • 90deg = along X [‘xz’], along Y [‘yz’] (from pos to neg)

    • 180deg = along Z (from pos to neg Z)

    • 270deg = along X [‘xz’], along Y [‘yz’] (from neg to pos)

  • inc_plane (str, default: 'xz') – plane of incidence, one of [‘xz’, ‘yz’]

  • theta (float, default: None) – alternative specification for a linear polarization angle. If given, this will override E_s and E_p as well as their respective phases. In degrees. At normal incidence: 0deg = OX, 90deg = OY. If `inc_plane`==’xz’: 0deg –> p-polarization; 90deg –> s-polarization (inverse for `inc_plane`==’yz’)

E_s, E_pfloat, default: 0.0, 1.0

Apmplitudes of s-polarized and p-polarized plane wave components. At 0 / 180 degrees incident angle (normal incindence), ‘p’ is polarized along x, ‘s’ along y. Then, at 90deg ‘p’ is along z.

phase_Esfloat, default: 0.0

additional phase for E_s component (in rad). Can be used to generate elliptic polarization. For instance, left circular polarization (LCP) can be obtained with: E_s=np.sqrt(0.5), E_p=np.sqrt(0.5), phase_Es=-np.pi/2. RCP: phase_Es=+np.pi/2.

phasefloat, default: 0.0

additional absolute phase for entire plane wave (in rad).

returnFieldstr, default: ‘E’

if ‘E’: returns electric field; if ‘B’ or ‘H’: magnetic field

Returns

E0 (B0) – list of (complex) 3-tuples: [(Ex1, Ey1, Ez1), …]

Return type

Complex E-(B-)Field at each dipole position as

pyGDM2.fields.gaussian(pos, env_dict, wavelength, theta=None, polarization_state=None, xSpot=0.0, ySpot=0.0, zSpot=0.0, NA=- 1.0, spotsize=- 1.0, kSign=- 1.0, paraxial=False, phase=0.0, E0=1 + 0j, returnField='E')

Normal incident (along Z) Gaussian Beam Field

obligatory “einKwargs” are one of ‘theta’ or ‘polarization_state’ and one of ‘NA’ or ‘spotsize’

polarization is defined by one of the two kwargs:
  • theta: linear polarization angle in degrees, theta=0 –> along X.

    Amplitude = 1 for both, E and B

  • polarization_state. tuple (E0x, E0y, Dphi, phi): manually

    define x and y amplitudes, phase difference and absolute phase of plane wave.

Parameters
  • pos (np.array) – list of 3-tuple coordinates to evaluate field at: [[x1,y1,z1], [x2,y2,z2], … ]

  • env_dict (dict) – Must be compatible with sim.dyads.getConfigDictG typed numba dict. description of environment. Must contain [‘eps1’, ‘eps2’, ‘eps3’, ‘spacing’].

  • wavelength (float) – Wavelength in nm

  • theta (float, default: None) – either ‘theta’ or ‘polarization_state’ must be given. linear polarization angle in degrees, 0deg = 0X direction

  • polarization_state (4-tuple of float, default: None) –

    either ‘theta’ or ‘polarization_state’ must be given.

    polarization state with field amplitudes and phases, tuple of 4 float: (E0x, E0y, Dphi, Aphi): E0X amplitde, E0Y amplitde, phase difference between X and Y components (in rad), absolute phase of plane wave (in rad). The field is then calculated as E = (E0x, E0y*exp(i*Dphi*z), 0)*exp(i*Aphi*z). Note that this means the handedness depends on the propagation direction (kSign)!

    Dphi :
    • positive: left hand rotating polarization

    • negative: right hand rotating polarization

    • example: left circular pol. with (kSign=-1, E0x=1, E0y=1, Dphi=np.pi/2., phi=0)

    xSpot,ySpot,zSpotfloat, default: 0,0,0

    x/y/z coordinates of focal point

    NAfloat

    Numerical aperture to calculate beamwaist

    spotsizefloat (optional)

    Gaussian beamwaist (overrides “NA”)

    kSignfloat, default: -1

    Direction of Beam. -1: top to Bottom, 1 Bottom to top

    paraxialbool, default: False

    Use paraxial Gaussian beam: No longitudinal fields. If “False”, longitudinal components are obtained using Maxwell equation div(E)=0 as condition

    phasefloat, default: 0

    additional phase of the beam, in degrees

    E0complex or function, default: complex(1,0)

    Either complex value or function of r=(x, y) (normalized to units of waist!). In case of a function, it needs to return the complex amplitude at the given position relative to beam axis (pos. in units of waist).

    returnFieldstr, default: ‘E’

    if ‘E’: returns electric field; if ‘B’ or ‘H’: magnetic field

Returns

E0

Return type

Complex E-Field at each dipole position

Notes

  • paraxial correction :

    see: Novotny & Hecht. “Principles of nano-optics”. Cambridge University Press (2006)

pyGDM2.fields.dipole_electric(pos, env_dict, wavelength, x0, y0, z0, mx, my, mz, returnField='E', R_farfield_approx=- 1)

field emitted by an electric dipole at (x0,y0,z0) with complex amplitude (mx,my,mz)

mandatory kwargs along with wavelength are: x0, y0, z0, mx, my, mz

To take into account a dielectric interface, dipole_electric uses a mirror-charge approximation in the (quasistatic) near-field and an asymptotic approximation for the far-field. Can handle only a single interface (hence cases with n1 != n2 = n3).

Parameters
  • pos (np.array) – list of 3-tuple coordinates to evaluate field at: [[x1,y1,z1], [x2,y2,z2], … ]

  • env_dict (dict) – Must be compatible with sim.dyads.getConfigDictG typed numba dict. description of environment. Must contain either “eps_env” or [“eps1”, “eps2”].

  • wavelength (float) – Wavelength in nm

  • x0,y0,z0 (float) – x/y/z coordinates of electric dipole position

  • mx,my,mz (float) – x/y/z amplitude of elec. dipole vector

  • returnField (str, default: 'E') – if ‘E’: returns electric field; if ‘B’ or ‘H’: magnetic field

  • R_farfield_approx (float, default: -1) – optional emitter-observer distance (in nm) starting from which an asymptotic farfield approximation will be used (to be used with caution!). -1: Do not use far-field approximation.

Returns

E0/H0

Return type

Complex field at each position ( (Ex,Ey,Ez)-tuples )

Notes

for free-space propagators, see e.g. G. S. Agarwal, Phys. Rev. A, 11(230), (1975), Eqs. (4.5)/(4.6)

pyGDM2.fields.dipole_magnetic(pos, env_dict, wavelength, x0, y0, z0, mx, my, mz, returnField='E', R_farfield_approx=- 1)

field emitted by a magnetic dipole at (x0,y0,z0) with complex amplitude (mx,my,mz)

mandatory kwargs along with wavelength are: x0, y0, z0, mx, my, mz

To take into account a dielectric interface, dipole_magnetic uses a mirror-charge approximation in the (quasistatic) near-field and an asymptotic approximation for the far-field. Can handle only a single interface (hence cases with n1 != n2 = n3).

Parameters
  • pos (np.array) – list of 3-tuple coordinates to evaluate field at: [[x1,y1,z1], [x2,y2,z2], … ]

  • env_dict (dict) – Must be compatible with sim.dyads.getConfigDictG typed numba dict. description of environment. Must contain either “eps_env” or [“eps1”, “eps2”].

  • wavelength (float) – Wavelength in nm

  • x0,y0,z0 (float) – x/y/z coordinates of electric dipole position

  • mx,my,mz (float) – x/y/z amplitude of elec. dipole vector

  • returnField (str, default: 'E') – if ‘E’: returns electric field; if ‘B’ or ‘H’: magnetic field

  • R_farfield_approx (float, default: -1) – optional emitter-observer distance (in nm) starting from which an asymptotic farfield approximation will be used (to be used with caution!). -1: Do not use far-field approximation.

Returns

E0/H0

Return type

Complex field at each position ( (Ex,Ey,Ez)-tuples )

Notes

for free-space propagators, see e.g. G. S. Agarwal, Phys. Rev. A, 11(230), (1975), Eqs. (4.5)/(4.6)

pyGDM2.fields.fast_electron(pos, env_dict, wavelength, electron_kinetic_energy, x0, y0, kSign=- 1, avoid_div_lim_distance=10.0, returnField='E')

Electric field created by a fast electron moving along (OZ)

The electron beam crosses the (OXY) plane in (x0, y0)

Parameters
  • pos (np.array) – list of 3-tuple coordinates to evaluate field at: [[x1,y1,z1], [x2,y2,z2], … ]

  • env_dict (dict) – Must be compatible with sim.dyads.getConfigDictG typed numba dict. description of environment. Must contain either “eps_env” or [“eps1”, “eps2”].

  • wavelength (float) – Wavelength in nm

  • electron_kinetic_energy (float) – electron kinetic energy (keV)

  • y0 (x0,) – position of the electron beam (nm)

  • kSign (int, default: -1) – sign of wavenumber. +1: electron propagation from bottom to top (towards increasing z) -1: electron propagation from top to bottom (towards smaller z, default) either kSign or k0 must be given.

  • avoid_div_lim_distance (float, default: 10.0) – set a min. distance (in nm) between the location where the E-field is computed and the electron trajectory to avoid divergence

  • returnField (str, default: 'E') – if ‘E’: returns electric field; if ‘B’: magnetic field

Returns

E0 (B0) – list of (complex) 3-tuples: [(Ex1, Ey1, Ez1), …]

Return type

Complex E-(B-)Field at each dipole position as

vector beams

pyGDM2.fields.HermiteGauss00(pos, env_dict, wavelength, xSpot=0.0, ySpot=0.0, zSpot=0.0, kSign=- 1.0, NA=0.5, f=100, w0=1, returnField='E')

Gaussian TEM mode (0,0)

Focal fields - Expressions from Novotny & Hecht - Principle of Nano-Optics (3.6) Generalized to take into account the presence of an interface

Authors: A. Arbouet, Y. Brûlé, G. Colas-des-Francs, 2021

posnp.array

list of 3-tuple coordinates to evaluate field at: [[x1,y1,z1], [x2,y2,z2], … ]

env_dictdict

Must be compatible with sim.dyads.getConfigDictG typed numba dict. description of environment. Must contain either “eps_env” or [“eps2”].

wavelengthfloat

Wavelength in nm

thetafloat, default: None

either ‘theta’ or ‘polarization_state’ must be given. linear polarization angle in degrees, 0deg = 0X direction

polarization_state4-tuple of float, default: None

either ‘theta’ or ‘polarization_state’ must be given. polarization state with field amplitudes and phases, tuple of 4 float: (E0x, E0y, Dphi, Aphi): E0X amplitde, E0Y amplitde, phase difference between X and Y components (in rad), absolute phase of plane wave (in rad). The field is then calculated as E = (E0x, E0y*exp(i*Dphi*z), 0)*exp(i*Aphi*z).

Dphi :
  • positive: left hand rotating polarization

  • negative: right hand rotating polarization

  • example: left circular pol. with (E0x=1, E0y=1, Dphi=np.pi/2., phi=0)

xSpot, ySpot, zSpotfloat, float, float, default: 0, 0, 0

focal spot position (in nm)

kSignint, default: -1

sign of wavenumber. +1: propagation from bottom to top (towards increasing z) -1: propagation from top to bottom (towards smaller z, default)

NAfloat, default: 0.5

lens numerical aperture (NA = n sin thetamax),

ffloat, default: 100

lens focal distance (mm)

w0float, default: 1

beam waist (mm)

returnFieldstr, default: ‘E’

if ‘E’: returns electric field; if ‘B’: magnetic field

E0 (B0): Complex E-(B-)Field at each dipole position as

list of (complex) 3-tuples: [(Ex1, Ey1, Ez1), …]

pyGDM2.fields.HermiteGauss10(pos, env_dict, wavelength, xSpot=0.0, ySpot=0.0, zSpot=0.0, kSign=- 1.0, NA=0.5, f=100, w0=1, returnField='E')

Gaussian TEM mode (1,0)

Focal fields - Expressions from Novotny & Hecht - Principle of Nano-Optics (3.6) Generalized to take into account the presence of an interface

Authors: A. Arbouet, Y. Brûlé, G. Colas-des-Francs, 2021

posnp.array

list of 3-tuple coordinates to evaluate field at: [[x1,y1,z1], [x2,y2,z2], … ]

env_dictdict

Must be compatible with sim.dyads.getConfigDictG typed numba dict. description of environment. Must contain either “eps_env” or [“eps2”].

wavelengthfloat

Wavelength in nm

thetafloat, default: None

either ‘theta’ or ‘polarization_state’ must be given. linear polarization angle in degrees, 0deg = 0X direction

polarization_state4-tuple of float, default: None

either ‘theta’ or ‘polarization_state’ must be given. polarization state with field amplitudes and phases, tuple of 4 float: (E0x, E0y, Dphi, Aphi): E0X amplitde, E0Y amplitde, phase difference between X and Y components (in rad), absolute phase of plane wave (in rad). The field is then calculated as E = (E0x, E0y*exp(i*Dphi*z), 0)*exp(i*Aphi*z).

Dphi :
  • positive: left hand rotating polarization

  • negative: right hand rotating polarization

  • example: left circular pol. with (E0x=1, E0y=1, Dphi=np.pi/2., phi=0)

xSpot, ySpot, zSpotfloat, float, float, default: 0, 0, 0

focal spot position (in nm)

kSignint, default: -1

sign of wavenumber. +1: propagation from bottom to top (towards increasing z) -1: propagation from top to bottom (towards smaller z, default)

NAfloat, default: 0.5

lens numerical aperture (NA = n sin thetamax),

ffloat, default: 100

lens focal distance (mm)

w0float, default: 1

beam waist (mm)

returnFieldstr, default: ‘E’

if ‘E’: returns electric field; if ‘B’: magnetic field

E0 (B0): Complex E-(B-)Field at each dipole position as

list of (complex) 3-tuples: [(Ex1, Ey1, Ez1), …]

pyGDM2.fields.HermiteGauss01(pos, env_dict, wavelength, xSpot=0.0, ySpot=0.0, zSpot=0.0, kSign=- 1.0, NA=0.5, f=100, w0=1, returnField='E')

Gaussian TEM mode (0,1)

Focal fields - Expressions from Novotny & Hecht - Principle of Nano-Optics (3.6) Generalized to take into account the presence of an interface

Authors: A. Arbouet, Y. Brûlé, G. Colas-des-Francs, 2021

posnp.array

list of 3-tuple coordinates to evaluate field at: [[x1,y1,z1], [x2,y2,z2], … ]

env_dictdict

Must be compatible with sim.dyads.getConfigDictG typed numba dict. description of environment. Must contain either “eps_env” or [“eps2”].

wavelengthfloat

Wavelength in nm

thetafloat, default: None

either ‘theta’ or ‘polarization_state’ must be given. linear polarization angle in degrees, 0deg = 0X direction

polarization_state4-tuple of float, default: None

either ‘theta’ or ‘polarization_state’ must be given. polarization state with field amplitudes and phases, tuple of 4 float: (E0x, E0y, Dphi, Aphi): E0X amplitde, E0Y amplitde, phase difference between X and Y components (in rad), absolute phase of plane wave (in rad). The field is then calculated as E = (E0x, E0y*exp(i*Dphi*z), 0)*exp(i*Aphi*z).

Dphi :
  • positive: left hand rotating polarization

  • negative: right hand rotating polarization

  • example: left circular pol. with (E0x=1, E0y=1, Dphi=np.pi/2., phi=0)

xSpot, ySpot, zSpotfloat, float, float, default: 0, 0, 0

focal spot position (in nm)

kSignint, default: -1

sign of wavenumber. +1: propagation from bottom to top (towards increasing z) -1: propagation from top to bottom (towards smaller z, default)

NAfloat, default: 0.5

lens numerical aperture (NA = n sin thetamax),

ffloat, default: 100

lens focal distance (mm)

w0float, default: 1

beam waist (mm)

returnFieldstr, default: ‘E’

if ‘E’: returns electric field; if ‘B’: magnetic field

E0 (B0): Complex E-(B-)Field at each dipole position as

list of (complex) 3-tuples: [(Ex1, Ey1, Ez1), …]

pyGDM2.fields.Radial_pol_doughnut(pos, env_dict, wavelength, xSpot=0.0, ySpot=0.0, zSpot=0.0, kSign=- 1.0, NA=0.5, f=100, w0=1, returnField='E')

radially polarized doughnut mode

Focal fields - Expressions from Novotny & Hecht - Principle of Nano-Optics (3.6) Generalized to take into account the presence of an interface

Authors: A. Arbouet, Y. Brûlé, G. Colas-des-Francs, 2021

posnp.array

list of 3-tuple coordinates to evaluate field at: [[x1,y1,z1], [x2,y2,z2], … ]

env_dictdict

Must be compatible with sim.dyads.getConfigDictG typed numba dict. description of environment. Must contain either “eps_env” or [“eps2”].

wavelengthfloat

Wavelength in nm

thetafloat, default: None

either ‘theta’ or ‘polarization_state’ must be given. linear polarization angle in degrees, 0deg = 0X direction

polarization_state4-tuple of float, default: None

either ‘theta’ or ‘polarization_state’ must be given. polarization state with field amplitudes and phases, tuple of 4 float: (E0x, E0y, Dphi, Aphi): E0X amplitde, E0Y amplitde, phase difference between X and Y components (in rad), absolute phase of plane wave (in rad). The field is then calculated as E = (E0x, E0y*exp(i*Dphi*z), 0)*exp(i*Aphi*z).

Dphi :
  • positive: left hand rotating polarization

  • negative: right hand rotating polarization

  • example: left circular pol. with (E0x=1, E0y=1, Dphi=np.pi/2., phi=0)

xSpot, ySpot, zSpotfloat, float, float, default: 0, 0, 0

focal spot position (in nm)

kSignint, default: -1

sign of wavenumber. +1: propagation from bottom to top (towards increasing z) -1: propagation from top to bottom (towards smaller z, default)

NAfloat, default: 0.5

lens numerical aperture (NA = n sin thetamax),

ffloat, default: 100

lens focal distance (mm)

w0float, default: 1

beam waist (mm)

returnFieldstr, default: ‘E’

if ‘E’: returns electric field; if ‘B’: magnetic field

E0 (B0): Complex E-(B-)Field at each dipole position as

list of (complex) 3-tuples: [(Ex1, Ey1, Ez1), …]

pyGDM2.fields.Azimuth_pol_doughnut(pos, env_dict, wavelength, xSpot=0.0, ySpot=0.0, zSpot=0.0, kSign=- 1.0, NA=0.5, f=100, w0=1, returnField='E')

Azimuthally polarized doughnut mode

Focal fields - Expressions from Novotny & Hecht - Principle of Nano-Optics (3.6) Generalized to take into account the presence of an interface

Authors: A. Arbouet, Y. Brûlé, G. Colas-des-Francs, 2021

posnp.array

list of 3-tuple coordinates to evaluate field at: [[x1,y1,z1], [x2,y2,z2], … ]

env_dictdict

Must be compatible with sim.dyads.getConfigDictG typed numba dict. description of environment. Must contain either “eps_env” or [“eps2”].

wavelengthfloat

Wavelength in nm

thetafloat, default: None

either ‘theta’ or ‘polarization_state’ must be given. linear polarization angle in degrees, 0deg = 0X direction

polarization_state4-tuple of float, default: None

either ‘theta’ or ‘polarization_state’ must be given. polarization state with field amplitudes and phases, tuple of 4 float: (E0x, E0y, Dphi, Aphi): E0X amplitde, E0Y amplitde, phase difference between X and Y components (in rad), absolute phase of plane wave (in rad). The field is then calculated as E = (E0x, E0y*exp(i*Dphi*z), 0)*exp(i*Aphi*z).

Dphi :
  • positive: left hand rotating polarization

  • negative: right hand rotating polarization

  • example: left circular pol. with (E0x=1, E0y=1, Dphi=np.pi/2., phi=0)

xSpot, ySpot, zSpotfloat, float, float, default: 0, 0, 0

focal spot position (in nm)

kSignint, default: -1

sign of wavenumber. +1: propagation from bottom to top (towards increasing z) -1: propagation from top to bottom (towards smaller z, default)

NAfloat, default: 0.5

lens numerical aperture (NA = n sin thetamax),

ffloat, default: 100

lens focal distance (mm)

w0float, default: 1

beam waist (mm)

returnFieldstr, default: ‘E’

if ‘E’: returns electric field; if ‘B’: magnetic field

E0 (B0): Complex E-(B-)Field at each dipole position as

list of (complex) 3-tuples: [(Ex1, Ey1, Ez1), …]

deprecated generators

pyGDM2.fields.planewave(pos, env_dict, wavelength, theta=None, polarization_state=None, kSign=- 1, returnField='E', deprecationwarning=True, **kwargs)

Normally incident (along Z) planewave in homogeneous environment

DEPRECATED - Use plane_wave() instead.

polarization is defined by one of the two kwargs:
  • theta: linear polarization angle in degrees, theta=0 –> along X.

    Amplitude = 1 for both, E and B

  • polarization state. tuple (E0x, E0y, Dphi, phi): manually

    define x and y amplitudes, phase difference and absolute phase of plane wave.

Parameters
  • pos (np.array) – list of 3-tuple coordinates to evaluate field at: [[x1,y1,z1], [x2,y2,z2], … ]

  • env_dict (dict) – Must be compatible with sim.dyads.getConfigDictG typed numba dict. description of environment. Must contain either “eps_env” or [“eps2”].

  • wavelength (float) – Wavelength in nm

  • theta (float, default: None) – either ‘theta’ or ‘polarization_state’ must be given. linear polarization angle in degrees, 0deg = 0X direction.

  • polarization_state (4-tuple of float, default: None) –

    either ‘theta’ or ‘polarization_state’ must be given. polarization state with field amplitudes and phases, tuple of 4 float: (E0x, E0y, Dphi, Aphi): E0X amplitde, E0Y amplitde, phase difference between X and Y components (in rad), absolute phase of plane wave (in rad). The field is then calculated as E = (E0x, E0y*exp(i*Dphi*z), 0)*exp(i*Aphi*z). Note that this means the handedness depends on the propagation direction (kSign)!

    Dphi :
    • positive: left hand rotating polarization

    • negative: right hand rotating polarization

    • example: left circular pol. with (1, 1, np.pi/2., 0) and kSign=-1

  • kSign (int, default: -1) – sign of wavenumber. +1: propagation from bottom to top (towards increasing z) -1: propagation from top to bottom (towards smaller z, default) either kSign or k0 must be given.

  • returnField (str, default: 'E') – if ‘E’: returns electric field; if ‘B’ or ‘H’: magnetic field

  • deprecationwarning (bool, default: True) – whether or not to emit a deprecation warning

Returns

E0 (B0) – list of (complex) 3-tuples: [(Ex1, Ey1, Ez1), …]

Return type

Complex E-(B-)Field at each dipole position as

pyGDM2.fields.focused_planewave(pos, env_dict, wavelength, theta=None, polarization_state=None, xSpot=0.0, ySpot=0.0, NA=- 1.0, spotsize=- 1.0, kSign=- 1, phase=0.0, consider_substrate_reflection=False, returnField='E')

Normally incident (along Z) planewave with gaussian intensity profile

DEPRECATED - Use gaussian() instead.

focused at (x0,y0)

polarization is defined by one of the two kwargs:
  • theta: linear polarization angle in degrees, theta=0 –> along X.

    Amplitude = 1 for both, E and B

  • polarization state. tuple (E0x, E0y, Dphi, phi): manually

    define x and y amplitudes, phase difference and absolute phase of plane wave.

Parameters
  • pos (np.array) – list of 3-tuple coordinates to evaluate field at: [[x1,y1,z1], [x2,y2,z2], … ]

  • env_dict (dict) – Must be compatible with sim.dyads.getConfigDictG typed numba dict. description of environment. Must contain either “eps_env” or [“eps2”].

  • wavelength (float) – Wavelength in nm

  • theta (float, default: None) – either ‘theta’ or ‘polarization_state’ must be given. linear polarization angle in degrees, 0deg = 0X direction

  • polarization_state (4-tuple of float, default: None) –

    either ‘theta’ or ‘polarization_state’ must be given. polarization state with field amplitudes and phases, tuple of 4 float: (E0x, E0y, Dphi, Aphi): E0X amplitde, E0Y amplitde, phase difference between X and Y components (in rad), absolute phase of plane wave (in rad). The field is then calculated as E = (E0x, E0y*exp(i*Dphi*z), 0)*exp(i*Aphi*z).

    Dphi :
    • positive: left hand rotating polarization

    • negative: right hand rotating polarization

    • example: left circular pol. with (E0x=1, E0y=1, Dphi=np.pi/2., phi=0)

  • ySpot (xSpot,) – focal spot position (in nm)

  • kSign (int, default: -1) – sign of wavenumber. +1: propagation from bottom to top (towards increasing z) -1: propagation from top to bottom (towards smaller z, default)

  • phase (float, default: 0) – additional phase of the beam, in degrees

  • consider_substrate_reflection (bool, default: False) – Whether to consider the reflection / transmission coefficient at the substrate for adjusting the field amplitude

  • returnField (str, default: 'E') – if ‘E’: returns electric field; if ‘B’: magnetic field

Returns

E0 (B0) – list of (complex) 3-tuples: [(Ex1, Ey1, Ez1), …]

Return type

Complex E-(B-)Field at each dipole position as

pyGDM2.fields.evanescent_planewave(pos, env_dict, wavelength, theta_inc=0, polar='p', inc_plane='xz', returnField='E')

oblique incident planewave, only linear polarization

DEPRECATED - Use plane_wave() instead.

Oblique incidence (from bottom to top) through n1/n2/n3 layer interfaces. May be used to simulate evanescent fields in the total internal reflection configuration. Linear polarization. Amplitude = 1 for both, E and B.

Original fortran code by Ch. Girard, python implementation by C. Majorel

Parameters
  • pos (np.array) – list of 3-tuple coordinates to evaluate field at: [[x1,y1,z1], [x2,y2,z2], … ]

  • env_dict (dict) – Must be compatible with sim.dyads.getConfigDictG typed numba dict. description of environment. Must contain [‘eps1’, ‘eps2’, ‘eps3’, ‘spacing’].

  • wavelength (float) – Wavelength in nm

  • theta_inc (float, default: 0) –

    incident angle in the XZ plane with respect to e_z, in degrees.
    • 0deg = along Z (from neg to pos Z)

    • 90deg = along X (from pos to neg X)

    • 180deg = along Z (from pos to neg Z)

    • 270deg = along X (from neg to pos X)

  • polar (str, default: 'p') – incident linear polarization. Either ‘s’ or ‘p’. At 0 / 180 degrees incident angle (normal incindence), ‘p’ is polarized along x, ‘s’ along y. Then, at 90deg ‘p’ is along z.

  • inc_plane (str, default: 'xz') – plane of incidence, one of [‘xz’, ‘yz’]

  • returnField (str, default: 'E') – if ‘E’: returns electric field; if ‘B’ or ‘H’: magnetic field

Returns

E0 (B0) – list of (complex) 3-tuples: [(Ex1, Ey1, Ez1), …]

Return type

Complex E-(B-)Field at each dipole position as

Environment - set of Green’s Dyads

The simulation environment and type of simulation is described by a dyads-class, containing the Green’s tensors used for field-propagation. pyGDM offers so far non-retarded sets of Green’s dyads for 3D and 2D simulations with up to three homogeneous layers.

The dyads classes must follow the reference implementation:

pyGDM2.propagators.DyadsBaseClass(dtype='f')

Bases: object

Green’s tensors container class - pure-python API

Defines the frame of a linear GDM simulation via the Green’s tensors, self-terms and material-polarizability relations.

Parameters

dtype ((optional) str, default: ‘f’) – precision (‘f’: float/single/32bit or ‘d’: double/64bit)

3D - 1-2-3 layer non-retarded surface dyads

pyGDM2.propagators.DyadsQuasistatic123(n1=None, n2=None, n3=None, spacing=5000, radiative_correction=True)

Bases: object

Green’s tensors container class - pure-python API

Defines the frame of a linear GDM simulation via the Green’s tensors, self-terms and material-polarizability relations.

Parameters

dtype ((optional) str, default: ‘f’) – precision (‘f’: float/single/32bit or ‘d’: double/64bit)

2D - 1-2-3 layer non-retarded surface dyads

pyGDM2.propagators_2D.DyadsQuasistatic2D123(n1=None, n2=None, n3=None, spacing=5000, ky0=None, ignore_incident_field_error=False)

Bases: object

Green’s tensors container class - pure-python API

Defines the frame of a linear GDM simulation via the Green’s tensors, self-terms and material-polarizability relations.

Parameters

dtype ((optional) str, default: ‘f’) – precision (‘f’: float/single/32bit or ‘d’: double/64bit)