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 re-implemented in 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 time
^{4.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 location**s*is implemented in both versions. The optimization estimates the number of collisions until an ion reaches a material interface and refrains from*point location**s*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.

2003-03-27