Skip to main content

Substrates

Explanation​

All parametrisations either follow 2D Cartesian coordinates (x′,y′x', y') or 2D polar coordinates (r,φr, \varphi), depending on the type of substrate, and transform these into 3D Cartesian coordinates (x,y,zx, y, z).

Each of the 2D coordinates is determined from the index of the respective substrate patch, transforming them into the 3D coordinates of the patch vertices. The point at x‾=0\underline{x} = 0 determines the position of the substrate on the trajectory.

The following depictions are always for a sputter-up scenario.

Overview​

ShapeConcavePython nameParameters
Disknodiskn_r, n_phi, radius
Slanted rectanglenoslanted_rectanglen_x, n_y, size_x, size_y, tilt_x, tilt_y
Spherical lensnospherical_lensn_r, n_phi, r_curvature, r_base
Aspherical lensnoaspherical_lensn_r, n_phi, r_curvature, r_base, asph_k, asph_alpha_*
Toric lensnotoric_lensn_r, n_phi, r_curvature_x, r_curvature_y, height
Inverted spherical lensalwaysinverted_spherical_lensn_r, n_phi, r_curvature, r_base
Bent rectangleif height > 0bent_rectanglen_x, n_y, size_x, size_y, height
Parabolic lensif coefficient > 0parabolicradius, coefficient

Convex substrate types​

Slanted rectangle​

Slanted rectangle with its parameters
Slanted rectangle: sizes, patch counts and the tilt in x and y direction

slanted_rectangle

  • n_x: number NxN_x of patches in x-direction
  • n_y: number NyN_y of patches in y-direction
  • size_x: size SxS_x of the rectangle in x-direction
  • size_y: size SyS_y of the rectangle in y-direction
  • tilt_x: total z-tilt Δx\Delta_x of the rectangle in x-direction, can be 0
  • tilt_y: total z-tilt Δy\Delta_y of the rectangle in y-direction, can be 0
x(x′,y′)=−12Sx+SxNxx′y(x′,y′)=−12Sy+SyNyy′z(x′,y′)=ΔxSxx+ΔySyy\begin{aligned} x(x', y') &= -\frac{1}{2} S_x + \frac{S_x}{N_x} x' \\ y(x', y') &= -\frac{1}{2} S_y + \frac{S_y}{N_y} y' \\ z(x', y') &= \frac{\Delta_x}{S_x} x + \frac{\Delta_y}{S_y} y \end{aligned}

Spherical lens​

Spherical lens with curvature radius and base radius
Spherical lens: curvature radius $R_\mathrm{c}$ and base radius

spherical_lens

  • n_r: number of patches in radial direction
  • n_phi: number of patches in angular direction
  • r_curvature: curvature radius RcR_\mathrm{c} of the lens (if it would be a full sphere)
  • r_base: radius of the lens at its base
x(r,φ)=rcos⁡(φ)y(r,φ)=rsin⁡(φ)z(r,φ)=Rc2−r2−Rc\begin{aligned} x(r, \varphi) &= r \cos(\varphi) \\ y(r, \varphi) &= r \sin(\varphi) \\ z(r, \varphi) &= \sqrt{R_\mathrm{c}^2 - r^2} - R_\mathrm{c} \end{aligned}

Toric lens​

Toric lens with two curvature radii
Toric lens: two different curvature radii, one per axis

toric_lens

  • n_r: number of patches in radial direction
  • n_phi: number of patches in angular direction
  • r_curvature_x: curvature radius Rc,xR_{\mathrm{c}, x} of the lens in x-direction (if it would be a full torus)
  • r_curvature_y: curvature radius Rc,yR_{\mathrm{c}, y} of the lens in y-direction (if it would be a full torus)
  • height: height of the lens (between base and tip)

This parametrisation differs from the others, since the curvature radii are used ordered by their size, defined as Rc,minR_\mathrm{c, min} and Rc,maxR_\mathrm{c, max}.

Some additional functions used are:

z0(r)=Rc,max−Rc,min+zbase(r)z_0(r) = R_\mathrm{c, max} - R_\mathrm{c, min} + z_\mathrm{base}(r)

Also, the z position at the base of the lens is used:

zbase(r)=Rc,min2−r2z_\mathrm{base}(r) = \sqrt{R_\mathrm{c, min}^2 - r^2}

Finally, the semiaxes of the elliptic cuts at given radii are (in case of the yy curvature radius being the larger one):

Sx(r)=Rc,x2−zbase(r)Sy(r)=Rc,y2−z0(r)\begin{aligned} S_x(r) &= \sqrt{R_{\mathrm{c}, x}^2 - z_\mathrm{base}(r)} \\ S_y(r) &= \sqrt{R_{\mathrm{c}, y}^2 - z_0(r)} \end{aligned}

If on the other hand the x-axis has the larger curvature radius, the roles of x and y have to be switched. Put together we obtain:

x(r,φ)=Sx(r)cos⁡(φ)y(r,φ)=Sy(r)sin⁡(φ)z(r,φ)=z0(r)−Rc,max\begin{aligned} x(r, \varphi) &= S_x(r) \cos(\varphi) \\ y(r, \varphi) &= S_y(r) \sin(\varphi) \\ z(r, \varphi) &= z_0(r) - R_\mathrm{c, max} \end{aligned}

Disk​

Disk with radius and patch counts
Disk: radius and the number of radial and angular patches

disk

  • n_r: number of patches in radial direction
  • n_phi: number of patches in angular direction
  • radius: radius of the disk
x(r,φ)=rcos⁡(φ)y(r,φ)=rsin⁡(φ)z(r,φ)=0\begin{aligned} x(r, \varphi) &= r \cos(\varphi) \\ y(r, \varphi) &= r \sin(\varphi) \\ z(r, \varphi) &= 0 \end{aligned}

Aspherical lens​

Aspherical lens with conic shape factor
Aspherical lens: spherical base shape plus a conic factor and alpha coefficients

aspherical_lens

  • n_r: number of patches in radial direction
  • n_phi: number of patches in angular direction
  • r_curvature: curvature radius RcR_\mathrm{c} of the lens (if it would be a full sphere)
  • r_base: radius of the lens at its base
  • asph_k: conic shape factor κ\kappa

Additionally, aspherical lenses require an arbitrary number of alpha coefficients αj\alpha_j, named asph_alpha_4, asph_alpha_6, asph_alpha_8 and so on. The number in the parameter name describes the exponent of the coefficient (has to be even and at least 4) and its value is the coefficient itself. Any unspecified coefficient is set to 0 automatically.

The function resulting from the coefficients defines the height of the surface:

zasph(r)=r2Rc(1+1−(1+κ)r2Rc2)+∑j=2α2jr2jz_\mathrm{asph}(r) = \frac{r^2}{R_\mathrm{c} \left( 1 + \sqrt{1 - (1 + \kappa)\frac{r^2}{R_\mathrm{c}^2}} \right)} + \sum_{j = 2} \alpha_{2j} r^{2j} x(r,φ)=rcos⁡(φ)y(r,φ)=rsin⁡(φ)z(r,φ)=zasph(r)\begin{aligned} x(r, \varphi) &= r \cos(\varphi) \\ y(r, \varphi) &= r \sin(\varphi) \\ z(r, \varphi) &= z_\mathrm{asph}(r) \end{aligned}

Potentially concave substrate types​

Inverted spherical lens​

Inverted spherical lens, concave side towards the source
Inverted spherical lens: the same shape as the spherical lens, with the curvature turned inwards

inverted_spherical_lens

  • n_r: number of patches in radial direction
  • n_phi: number of patches in angular direction
  • r_curvature: curvature radius RcR_\mathrm{c} of the lens (if it would be a full sphere)
  • r_base: radius of the lens at its base

Inverted spherical lenses are always concave.

x(r,φ)=rcos⁡(φ)y(r,φ)=rsin⁡(φ)z(r,φ)=−Rc2−r2+Rc\begin{aligned} x(r, \varphi) &= r \cos(\varphi) \\ y(r, \varphi) &= r \sin(\varphi) \\ z(r, \varphi) &= -\sqrt{R_\mathrm{c}^2 - r^2} + R_\mathrm{c} \end{aligned}

Bent rectangle​

Bent rectangle with height difference between base and tip
Bent rectangle: sizes, patch counts and the height difference that bends it

bent_rectangle

  • n_x: number NxN_x of patches in x-direction
  • n_y: number NyN_y of patches in y-direction
  • size_x: size SxS_x of the rectangle in x-direction
  • size_y: size SyS_y of the rectangle in y-direction
  • height: height difference hh between base and tip, can be negative

Bent rectangles are only concave if height is set to a value greater than 0.

The curvature radius of the rectangle is obtained using:

Rc=12h(h2+Sy44)R_\mathrm{c} = \frac{1}{2 h} \left( h^2 + \frac{S_y^4}{4}\right )

The parametrisation is then:

x(x′,y′)=−12Sx+SxNxx′y(x′,y′)=−12Sy+SyNyy′z(x′,y′)=Rc−h∣h∣Rc2−y2\begin{aligned} x(x', y') &= -\frac{1}{2} S_x + \frac{S_x}{N_x} x' \\ y(x', y') &= -\frac{1}{2} S_y + \frac{S_y}{N_y} y' \\ z(x', y') &= R_\mathrm{c} - \frac{h}{|h|} \sqrt{R_\mathrm{c}^2 - y^2} \end{aligned}

Parabolic lens​

Parabolic lens with coefficient and base radius
Parabolic lens: base radius and the coefficient of the parabola

parabolic

  • radius: radius at the base of the lens
  • coefficient: coefficient α\alpha of the parabolic shape function

Parabolic lenses are only concave if coefficient is set to a value greater than 0.

x(r,φ)=rcos⁡(φ)y(r,φ)=rsin⁡(φ)z(r,φ)=αr2\begin{aligned} x(r, \varphi) &= r \cos(\varphi) \\ y(r, \varphi) &= r \sin(\varphi) \\ z(r, \varphi) &= \alpha r^2 \end{aligned}

Custom substrates​

An entirely custom geometry is defined as a list of triangles:

list_of_triangles = [
(SRT.PhysVector(0, 0, 0), SRT.PhysVector(-2, -2, 2), SRT.PhysVector(2, -2, 2)),
(SRT.PhysVector(0, 0, 0), SRT.PhysVector(2, -2, 2), SRT.PhysVector(2, 2, 2))
]

s.generate_geometry_from_mesh_triangles(list_of_triangles, invert_normal = False)

invert_normal flips all triangle normals in case they are not oriented towards the histogram. Individual normals cannot be flipped, so define the mesh consistently.

Larger meshes in the GMSH .msh format can be loaded through the helper module:

import SRTHelper as SRTHelper

list_of_triangles = SRTHelper.load_mesh_from_file("custom.msh")

s.generate_geometry_from_mesh_triangles(list_of_triangles, invert_normal = False)

The mesh loader needs the Python package gmsh. The coordinate system of the mesh is taken as it is, so the coordinate origin of the mesh is fixed to the current trajectory point.