The Monte-Carlo Ion Implantation simulator developed at the Institute for Microelectronics
[56,57,58,59,60] is an implementation of this
simulation methodology. It is fully integrated with the WAFER-STATE-SERVER and was
C++ based on a previously developed FORTRAN implementation which was
not WAFER-STATE conforming. The new implementation differs from the previous version
in the following major points.
- The FORTRAN implementation takes as input a geometry that is stored
on a PIF file. The output of the simulator is a dopant profile that is
also stored on a PIF file. The simulator, however, completely ignores
other attributes that are already existing in the input file. The histogram
(damage information) that is used as input in consecutive invocations of the
Monte-Carlo simulator, is stored on a separate file (not on a PIF
file). This approach is not WAFER-STATE conforming since a topography simulation
step can not be applied after a Monte-Carlo simulations without taking into account
the extra (simulator specific) damage file.
The new implementation manages all input and output data likewise. The damage
information is stored as a Wafer attribute (i. e. on a grid) which is
queried by the simulator at startup and written upon completion of the
simulation. This is fully WAFER-STATE conforming in the sense that a topography
altering process step does not need to take into account additional (simulator
specific) data. Attributes that are existing on the input Wafer and ignored
by the simulator are also present on the resulting output Wafer.
- The input PIF file for the FORTRAN simulator does not contain
all informations necessary for a Monte-Carlo simulation. Therefore additional
information has to be passed on the command line (e.g. the material type of a
simulation domain) or is hard-coded (e.g. material density), respectively.
The new implementation takes these informations from the input Wafer, where
they are stored as constant attributes (as opposed to distributed attributes).
- In the FORTRAN implementation the simulation domain is discretized
into leafs of a fixed size. Thus, the simulator has a fixed resolution that is
determined at compile time4.1. As a consequence the memory requirements are also fixed for every
simulation problem. The resolution must be selected according to the most
demanding geometry that is to be simulated. This is especially crucial if
regions of largely differing aspect ratios have to be treated at the very same
time (e.g. gate and bulk regions). A point bucket oct-tree, that associates leafs with a
certain material type is used for the point location operation.
The new implementation uses dynamic memory allocation and a variable
resolution. The memory usage thereby is adapted to the simulation domain and
is thus determined by the simulation problem. Geometry handling is completely
delegated to the WAFER-STATE-SERVER. The geometry data are stored in a finite oct-tree which
is also used to perform the point location operations (i. e. material
locations). Therefore no point bucket oct-tree is necessary in the simulator.
- The most time consuming part of both implementations is the point location
operation. Therefore, an optimization to minimize the number of point locations is
implemented in both versions. The optimization estimates the number of
collisions until an ion reaches a material interface and refrains from
point locations during the determined number of collisions. The optimization must not
overestimate this number or an error is introduced (one or more collisions
with a wrong material type). Due to the lack of a geometry support in the
FORTRAN implementation, the optimization is restricted to determining the
distance to the surface within a leaf of the point bucket oct-tree.
The C++ implementation uses the distance method of the WAFER-STATE-SERVER to compute
the distance from a given point to the nearest interface. The implementation
of this method uses a finite oct-tree that contains just the surface elements of
each Wafer segment. Thereby, on the one hand side the number of searched
elements is minimized. On the other hand side, the estimation of the number of
collisions until an interface is reached is also better, thus a better
reduction of point location operations is achieved.
- To achieve WAFER-STATE conformity the simulator has to store the resulting
profile on an unstructured grid. This is realized by delegating meshing
operations to the WAFER-STATE-SERVER (via the Gridder interface). Thereby, the WAFER-STATE-SERVER
acts as a grid manager that is responsible to hold the grid data structures and to
provide interpolation mechanisms to interpolate from the histogram information
onto the tetrahedral grid elements. It is worth mentioning, that the main
advantage of this new approach is that the simulator is capable of storing and
reading polygonal information without having a built-in gridding mechanism.
The long simulation times of ion-implantation simulations and the
comparably huge number of point location operations that are necessary during the
simulation run, justify the usage of the oct-tree data structures for this
application. Although the pre-processing time for building the oct-tree is much
larger as with the alternative available jump-and-walk algorithm the total execution
time is reduced.