# PEC Algorithms¶

## Introduction¶

The physical origin for the *proximity effect* is the interaction (scattering) of the beam (electrons) with the resist layer and the substrate.
This scattering causes an undesired “blurring” that leads to a (geometry-dependent) effective reduction of the resolution.

This undesired effect can be (partially) compensated, by modifying the dose (in practice this breaks down to modify the dwell times) such that the resulting pattern is as close as possible to the desired pattern.

More general information about PEC can be found on Wikipedia or in literature.

## Dose Correction Calculation¶

The basic goal is to calculate a “dose map” D(x,y) for the structure, such that the result is improved.

### Algorithms¶

One important measure one needs to know is how electrons interact with the resist and the substrate, the *point spread function*. Currently both algorithms
use a double-gauss function [1] with the common parameters α, β, and η. Currently smile2 does not provide an integrated simulation to determine these parameters [2] . Both algorithms assume that these parameters are
known [3] .

### Mathematical description¶

Note

This chapter gives only rough description. A more detailed description can be found in the *customer cloud* as pdf.

#### Local¶

The local or *iterative* method is described in detail in [4] . The idea is to iteratively modify the dose distribution (increase or decrease) and terminate
if

- the limit of iteration steps is reached, or
- the difference between becomes “small”: ρ
_{out}- ρ_{desired}< ε

Note

In our implementation, we use a multiplicative approach to modify the dose

#### Deconvolution¶

The idea behind this approach is, to apply the filter that reverts the effect of the proximity effect to ρ_{out} .

Warning

For many structures, this algorithm works really good. However, it produces sometimes unexpected overexposed regions. We currently investigate this issue, and expect to add a solution in a future release of smile2.

## Structure treatment¶

### Map Calculation¶

If **map_pec** is used, the calculated dose scales are applied as a dose map (**recommended method**). The “work horses” that performs the map calculation is the ImageMapPECGen node.

Note

All **map_pec** nodes are implemented in Python and come as “open” .py source files.
The source file can be found in SMILE2_INSTALL_DIR/data/scripts/extensions/map_pec.py .

### Geometry fragmentation¶

Warning

The way how to set up PEC has changed since smile2 version 2.0.1.

The **shape_pec** plug-in is not yet ported to the new API and therefore nod included in smile2 version 2.0.1. It will be re-added in a future update.

**shape_pec** is an alternative method, if the **map_pec** cannot be used (eg. the etp2 module has been purchased).

Warning

We recommend to use the **map_pec** (Direct Write) method.

The fragmentation is performed based on the calculated dose map. From an algorithmic point of view, the fragmentation is performed, using a quad-tree.

## Cached vs. on the fly calculation¶

No matter if use a cache or an on-the-fly method, the underlying calculation is the same.

The cached version has the advantage that the (possibly) time-consuming calculations can be performed on your desktop, saving valuable on-sem-time. however keep, in mind if you modify a structure (alignment is allowed), the calculated cache becomes invalid.

## Finding parameters¶

One major difficulty, is to find the right (or: a working) set of model parameters. Currently smile2 does not include an integrated simulation to determine these parameters [2], therefore users rely on 3rd party solutions to calculate (or measure) these parameters.

### Calculation¶

There are several commercial and free (Monte-Carlo-based) software solutions, that aim to calculate point spread functions. We can recommend
the free *Casino* package, which can be downloaded from the *Casino web page*, or from our *customer cloud*.

### Measuring¶

There is no real *direct solution* to measure alpha, beta, and eta. However, several measuring techniques are published, that claim high
accuracy of the the obtained results, eg `https://doi.org/10.1016/S0167-9317(00)00320-8`__ .

All these methods have in common derive an expression form the PSF, and fit this expression to experimentally obtained results (structures exposed by variation of the dose).

### Base Dose¶

The *target dose* for structures with enabled PEC might differ form the one that you use without PEC. For structures without PEC, usually a dose “that works best for my designs”
is used. For structures with enabled PEC, the *correct clear* dose (usually fund in the data sheet of the resist) should be used.

## Extending the PEC Calculation¶

The complete PEC system is implemented in Python, and available as Python source. It can act as a starting point for modifications, or as a reference.

The simplest way to add your own calculation algorithm is, to generate a (somehow: in smile, or with an external program) a scalar field, and to use this scalar field to set it to a map cache node.

This task, however, requires to generate a “map” of the initial dose. Here, the smile2 Python API can help. Eg., the following script generates a numpy array, containing a 2d “map” of the initial dose distribution:

- ::
import litho.core as lc import numpy as np

# get the active document doc=lc.document.active

# now, create a stream bundle. # a stream bundle is a “compiled structure”, that can be efficiently be exposed on all kind of devices

# options for the stream bundle. Initialize them from the document opts = lc.StreamBundle.optsFromDocument(doc)

# .. and modify them … opts.settings = lc.StreamBundle.Settings.IgnoreHwCompensationMatrix | lc.StreamBundle.Settings.NoSorting opts.resolutionReduction = 1 opts.xInvert=False opts.yInvert=False

# now, create the stream bundle .. streamBundle = lc.StreamBundle.fromDocument(doc, opts) # .. and “expose” it to a numpy array of size (4096,4096) rho_desired = np.zeros(shape=(4096,4096)) streamBundle.blendDoseMap(rho_desired) # rho_desired now contains an “exposed” structure.

# save it .. np.savetxt(“/home/hans/rho_desired.dat”, rho_desired)

Footnotes

[1] | However, it is possible (and quite easy) to replace the double-gauss with any other function. How to do this is described in the pec python module documentation. |

[2] | (1, 2) If you want to work on this or even have an algorithm/module/whatever and you would like to integrate it, we would be happy to assist you. |

[3] | They can be “found” in literature for standard setups. For more “exotic” setups they can be either determined experimentally or found with simulations (eg. with CASINO) |

[4] | TODO: Link to paper |