pyoptics.litho.hopkins

Hopkins imaging: transmission cross coefficients (TCC) and their sum of coherent systems (SOCS) decomposition.

Abbe’s method (LithoSimulation) sums the image over the source points, so every new mask costs a full source integration. Hopkins’ method moves the source integration in front: if the mask diffracts the same way for all source points (the Hopkins approximation), the image is:

I(r) = sum_{o, o'} a_o a_o'^* TCC[o, o'] exp(i*(f_o - f_o').r)

with the mask spectrum a_o (the diffraction orders o = (m, n) of one period) and the transmission cross coefficients:

TCC[o, o'] = sum_{source points s, polarization states, field components}
             w_s H_o(s) H_o'(s)^*,

where H_o(s) is the field in the image (or in the resist) that a unit order o produces for the source point s: pupil (apodization, aberrations, defocus) and the polarization transfer of the projector and the wafer stack. The TCC depends on the illumination, the projector, the wafer stack, the focus and the pitch, but not on the shapes on the mask: computed once, it images any layout with the same pitches by a sum over pairs of orders.

Polarization: the mask spectrum is a field of Jones matrices, a_o = sum_regions J_region*C_region[o]. If all Jones matrices are multiples of the identity (thin masks, film masks at normal incidence), the mask is scalar and the TCC is indexed by the orders o. Otherwise (e.g. a boundary layer with different TE and TM transmissions) each used element (j, k) of the Jones matrices (j: pupil component, k: incident component) is a “channel” c, and the TCC is indexed by (o, c). For a RigorousMask the mask spectrum is the Jones matrices of the orders that rcwa computes at normal incidence; Abbe’s method recomputes them for every source point.

The TCC is Hermitian and positive semidefinite, so its eigenvectors phi_k and eigenvalues lambda_k >= 0 give the SOCS decomposition:

I(r) = sum_k lambda_k |sum_o a_o phi_k[o] exp(i*f_o.r)|^2,

a sum of coherent images through the kernels phi_k. Few kernels usually carry almost all of the energy (the sum of the eigenvalues). Truncated SOCS is the basis of imaging large layouts by FFT convolutions with the kernels, and its sum of coherent images has simple gradients with respect to the mask (inverse lithography, source mask optimization).

Approximations against Abbe’s method: the mask Jones matrices are those at normal incidence (s = 0). For a ThinMask, whose transmissions do not depend on the angle of incidence, Hopkins and Abbe agree exactly (up to rounding); for a FilmMask, the angle dependence of the absorber is dropped. Truncated SOCS adds the energy of the dropped kernels as a further error.

References

H. H. Hopkins, “On the diffraction theory of optical images”, Proc. R. Soc. Lond. A 217, 408-432 (1953).

N. B. Cobb, “Fast optical and process proximity correction algorithms for integrated circuit manufacturing”, Ph.D. dissertation, University of California, Berkeley (1998).

A. Erdmann, “Optical and EUV Lithography: A Modeling Perspective”, SPIE Press (2021).

Classes

SOCS	Sum of coherent systems: the leading eigenvalues and eigenvectors (kernels) of a TCC.
TCC	Transmission cross coefficients of a lithographic system.

class pyoptics.litho.hopkins.TCC(sim, foci=(0.0,), depth=0.0)

Bases: object

Transmission cross coefficients of a lithographic system.

Parameters:

simLithoSimulation

Illumination, projector, wafer stack and mask stack; its layout sets the pitches (and so the orders). Any layout with the same pitches can be imaged afterwards.

focisequence of numbers, optional

Foci (one TCC each), see LithoSimulation.image().

depthnumber, optional

Depth in the resist (wafer stack only).

Attributes:

m, narrays

Order indices along x and y.

f_x, f_yarrays

Spatial angular frequencies of the orders.

channelslist

“scalar” for a scalar mask, otherwise the Jones matrix elements (j, k) of the mask that are used.

matrixarray

Shape (len(foci), N, N), N = len(n)*len(m)*len(channels), index ((n, m), c) in C order.

mask_vector(coefficients, jones=None)

Mask spectrum a[(n, m), c] from region coefficients.

Parameters:

coefficientsdict

Fourier coefficients of the regions on the order grid, e.g. from MaskLayout.region_coefficients().

jonesdict, optional

Jones matrices of the regions; default: those of the mask stack of the simulation at normal incidence.

layout_vector(layout)

Mask spectrum of a layout with the pitches of the TCC (tone and boundary layer as in LithoSimulation).

open_frame()

Intensity of a clear mask for all foci.

image(x, y=None, layout=None, mask_vector=None, normalize=True)

Image for all foci.

Parameters:

x, yarrays

Image grid; y=None gives the cut at y = 0.

layoutMaskLayout, optional

Default: the layout of the simulation.

mask_vectorarray, optional

A mask spectrum (e.g. from mask_vector()) instead of a layout.

normalizebool, optional

Divide by the open frame.

Returns:

array

Shape (len(foci), len(y), len(x)), or (len(foci), len(x)) for y=None.

socs(n_kernels=None, energy=None)

SOCS decomposition.

Parameters:

n_kernelsint, optional

Number of kernels to keep (largest eigenvalues).

energynumber, optional

Keep the fewest kernels whose eigenvalues sum to at least this fraction of the total (e.g. 0.999); applied per focus, the largest count is used for all. Default (neither given): all kernels with positive eigenvalues.

Returns:

SOCS

class pyoptics.litho.hopkins.SOCS(tcc, eigenvalues, kernels, total)

Bases: object

Sum of coherent systems: the leading eigenvalues and eigenvectors (kernels) of a TCC.

Attributes:

tccTCC

eigenvaluesarray (len(foci), n_kernels)

kernelsarray (len(foci), N, n_kernels)

energyarray (len(foci),)

Fraction of the TCC’s trace carried by the kept kernels.

kernel_fields(x, y=None, focus_index=0)

Coherent amplitude kernels in real space.

The fields of the kernels for a unit mask spectrum, sum_o phi_k[o, c] exp(i f_o.r), summed over the channels.

Parameters:

xarray

x coordinates.

yarray, optional

y coordinates; None gives cuts at y = 0.

focus_indexint, optional

Index of the focus.

Returns:

fieldsarray

Shape (n_kernels, len(y), len(x)).

image(x, y=None, layout=None, mask_vector=None, normalize=True)

Image as the sum of the coherent images of the kernels.

Parameters:

x, yarrays

Image grid; y=None gives the cut at y = 0.

layoutMaskLayout, optional

Default: the layout of the simulation.

mask_vectorarray, optional

A mask spectrum instead of a layout.

normalizebool, optional

Divide by the open frame.

Returns:

array

Shape (len(foci), len(y), len(x)), or (len(foci), len(x)) for y=None.