PEC Algorithms


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.


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


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


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 < ε


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


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


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.


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/ .

Geometry fragmentation


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).


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.

Direct write

This, is the recommended method. No fracturing is done. The calculated map is applied as dose map using the etp2 capable hardware.

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.


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.


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 ``__ .

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

# 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)


[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