pyoptics.litho.opc

Optical proximity correction (OPC) of Manhattan layouts.

The printed shape of a feature depends on its neighbourhood (pitch, line ends, corners): OPC changes the mask so that the printed edges land on the target edges (the design).

Rule-based OPC

bias_table() tabulates, through pitch, the mask bias that prints the target CD of lines (or trenches) at one common dose, anchored on one pitch; the bias is then looked up for every feature. insert_srafs() adds sub-resolution assist features (scattering bars) to isolated or semi-dense lines, which make them image more like dense lines and move the process window of the forbidden pitches; sraf_margin() checks that the assists do not print.

Model-based OPC

The edges of the target polygons are cut into fragments (FragmentedLayout: short fragments at the corners, the rest of an edge in pieces of at most max_length). Every fragment has a site (its midpoint on the target edge, on corner fragments nearer to the fragment’s inner end) where the edge placement error (EPE) is measured: the distance from the target edge to the printed edge (threshold model) along the outward normal, positive if the printed feature is too large. model_opc() moves the fragments along their normals and re-images until the EPEs are small: either every fragment against its own EPE (“local”, the simplest scheme) or all fragments together from the Jacobian of the EPEs (a MEEF matrix) by regularized least squares (“jacobian”, the default). Line ends grow hammerheads, convex corners serifs and concave corners are cut back, as in the classic picture; the rounding of the printed corners cannot be corrected, so the corner sites get less weight. The image of every iteration is computed on a grid of one period, with Abbe’s method or, faster, with the Hopkins TCC (or its SOCS kernels) of the target layout, and interpolated along the normals.

Only Manhattan polygons are supported, no curvilinear masks, and the threshold model stands in for the resist.

References

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

A. K.-K. Wong, “Resolution Enhancement Techniques in Optical Lithography”, SPIE Press (2001).

R. Socha et al., “Forbidden pitches for 130 nm lithography and below”, Proc. SPIE 4000, 1140 (2000).

A. K. Wong, R. A. Ferguson and S. M. Mansfield, “The mask error factor in optical lithography”, IEEE Trans. Semicond. Manuf. 13, 235-242 (2000).

A. Poonawala and P. Milanfar, “Mask design for optical microlithography - an inverse imaging problem”, IEEE Trans. Image Process. 16, 774-788 (2007).

Classes

FragmentedLayout	Target polygons with their edges cut into movable fragments.
OPCResult	Result of model_opc().

Functions

bias_table	Mask bias of lines through pitch that prints the target CD at one dose (rule-based OPC).
edge_placement_errors	Edge placement errors of the threshold contour of an image.
image_grid	Grid of one period for images that edge_placement_errors() interpolates.
insert_srafs	Sub-resolution assist features next to the lines of a 1D layout.
model_opc	Model-based OPC: move the fragments of the target edges until the printed edges (threshold model) are on the target.
sample_image	Periodic cubic spline interpolation of an image.
sraf_margin	How far the assist features are from printing.

pyoptics.litho.opc.bias_table(sim, pitches, cd_target, threshold=0.3, anchor=None, focus=0.0, max_bias=None, make_layout=None)

Mask bias of lines through pitch that prints the target CD at one dose (rule-based OPC).

Parameters:

simLithoSimulation

Stack, illumination and projector; its layout (1D lines or trenches) gives orientation and tone.

pitchessequence of numbers

cd_targetnumber

Target CD on the wafer.

thresholdnumber, optional

Resist threshold (intensity relative to the open frame).

anchornumber, optional

Pitch that prints at cd_target without bias and so sets the dose (default: the first pitch).

focusnumber, optional

max_biasnumber, optional

Largest absolute bias searched (default: cd_target).

make_layoutcallable, optional

make_layout(pitch, cd) gives the layout of a pitch with the mask CD of the (first) line, e.g. with SRAFs (insert_srafs()). Default: lines and spaces with the orientation and tone of sim.layout.

Returns:

biasarray

Mask CD - target CD for every pitch (nan where no bias in the range prints the target).

dosenumber

The common dose.

pyoptics.litho.opc.insert_srafs(layout, width, distance, count=1, spacing=None, min_space=None)

Sub-resolution assist features next to the lines of a 1D layout.

Parameters:

layoutMaskLayout

Lines (or trenches) along y or x with one feature per period.

widthnumber

Width of the assists (well below the resolution, so they do not print).

distancenumber

Center to center distance of the first assist from the line.

countint, optional

Assists on each side of the line.

spacingnumber, optional

Center to center distance of further assists (default: distance).

min_spacenumber, optional

Smallest space between an assist and a line or another assist; assists from both sides of a space that come closer are merged into one in the middle (default: width).

Returns:

MaskLayout

The main line first, then the assists (same tone: absorber bars on a clear field, clear slits for a dark field).

pyoptics.litho.opc.sraf_margin(sim, threshold=0.3, dose=1.0, foci=(0.0,))

How far the assist features are from printing.

The assists are the layout features after the first; the margin is the smallest relative distance of the image at their centers from the threshold over the foci.

Parameters:

simLithoSimulation

Simulation whose layout contains the assists.

thresholdnumber, optional

Printing threshold.

dosenumber, optional

Relative dose.

focisequence of numbers, optional

Foci to check.

Returns:

marginfloat

Positive: the assists do not print; np.inf without assists.

class pyoptics.litho.opc.FragmentedLayout(layout, max_length=40.0, corner_length=15.0, corner_site=0.75)

Bases: object

Target polygons with their edges cut into movable fragments.

Parameters:

layoutMaskLayout

Target layout made with MaskLayout.from_polygons().

max_lengthnumber, optional

Longest fragment.

corner_lengthnumber, optional

Length of the fragments at the ends of an edge. Edges shorter than 2*corner_length are one fragment, edges shorter than 3*corner_length two.

corner_sitenumber, optional

Position of the site on the end fragments of edges with three or more fragments, as a fraction of the fragment length from the corner (0.5: the midpoint); away from the corner, where the rounding of the printed corner matters less.

Attributes:

start, endarrays (n_fragments, 2)

End points of the fragments on the target edges (counterclockwise).

normalarray (n_fragments, 2)

Outward unit normals.

sitesarray (n_fragments, 2)

Midpoints, where the EPE is evaluated.

polygons(offsets)

The polygons with every fragment moved by its offset along its outward normal (jogs between the fragments of an edge, corners at the intersections of the moved end fragments).

layout(offsets)

MaskLayout of the moved polygons.

pyoptics.litho.opc.image_grid(layout, spacing=2.0)

Grid of one period for images that edge_placement_errors() interpolates.

Parameters:

layoutMaskLayout

Layout periodic in x and y.

spacingnumber, optional

Largest grid spacing.

Returns:

x, y1d arrays

Cell [-pitch/2, pitch/2), periodic.

pyoptics.litho.opc.sample_image(I, x, y, points)

Periodic cubic spline interpolation of an image.

Parameters:

I2d array

Image of shape (len(y), len(x)) on the grid of image_grid().

x, y1d arrays

The grid.

pointsarray

Points of shape (…, 2) as (x, y).

Returns:

valuesarray

Shape points.shape[:-1].

pyoptics.litho.opc.edge_placement_errors(I, x, y, sites, normals, threshold, bright=False, search=30.0, step=0.25)

Edge placement errors of the threshold contour of an image.

Parameters:

Iarray (len(y), len(x))

Image (times the dose) on the periodic grid of image_grid().

x, yarrays

sites, normalsarrays (n, 2)

Points on the target edges and outward unit normals.

thresholdnumber

brightbool, optional

The features are bright (dark field mask).

searchnumber, optional

Largest distance searched along the normals; an edge that is not found counts as -search (feature missing at the site) or +search.

stepnumber, optional

Sampling step along the normals.

Returns:

array (n,)

Distance of the printed edge from the site along the normal (positive: outside, the printed feature is larger).

class pyoptics.litho.opc.OPCResult(layout, fragments, offsets, epe, history, x, y, image)

Bases: tuple

Result of model_opc().

layout : the corrected MaskLayout; fragments : FragmentedLayout of the target; offsets, epe : arrays (n_fragments,); history : array (iterations + 1, 2) of the largest and the RMS abs(EPE), starting with the target as the mask; x, y, image : the final image (times the dose) on the grid.

epe

Alias for field number 3

fragments

Alias for field number 1

history

Alias for field number 4

image

Alias for field number 7

layout

Alias for field number 0

offsets

Alias for field number 2

x

Alias for field number 5

y

Alias for field number 6

pyoptics.litho.opc.model_opc(sim, layout=None, threshold=0.3, dose=1.0, focus=0.0, method='jacobian', max_iter=20, damping=0.6, regularization=0.05, corner_weight=0.3, tol=0.25, max_offset=None, max_length=40.0, corner_length=15.0, corner_site=0.75, spacing=2.0, search=30.0, imager='hopkins', energy=0.999)

Model-based OPC: move the fragments of the target edges until the printed edges (threshold model) are on the target.

Parameters:

simLithoSimulation

Stack, illumination, projector and wafer stack.

layoutMaskLayout, optional

Target made with MaskLayout.from_polygons() (default: the layout of sim).

threshold, dose, focusnumbers, optional

Threshold model at this dose and focus.

method“jacobian” or “local”, optional

“local”: every fragment is moved against its own EPE, offset -= damping*EPE (fragments do not know about each other). “jacobian”: the response of all EPEs to all fragment moves (the Jacobian, a MEEF matrix, by finite differences of the target) is computed once for the target, and the moves solve the regularized least squares problem min |W*(EPE + J*move)|**2 + mu*|offset + move|**2 (W: weights of the sites, corner_weight for the corner fragments; mu: regularization times the mean of diag(J^T W**2 J)), damped by damping. The regularization keeps the mask close to the target where the EPEs hardly depend on the moves (e.g. alternating moves of short fragments). This handles the cross talk of short fragments (line ends, corners) and targets that cannot be reached everywhere (rounded corners). Updating the Jacobian on the way does not help: the EPEs near the corners are not smooth functions of the moves.

max_iterint, optional

dampingnumber, optional

Fraction of the computed move applied per iteration.

regularization, corner_weightnumbers, optional

See method.

tolnumber, optional

Stop when every abs(EPE) is below tol.

max_offsetnumber, optional

Largest abs(offset) of a fragment (default: 2*corner_length).

max_length, corner_length, corner_sitenumbers, optional

Fragmentation, see FragmentedLayout.

spacingnumber, optional

Grid spacing of the images.

searchnumber, optional

Search range of the edges along the normals.

imager“abbe”, “hopkins” or “socs”, optional

Abbe imaging of every mask, or the TCC of the target (exact for thin masks) or its SOCS kernels (energy fraction kept: energy).

energynumber, optional

Returns:

OPCResult