Developing Custom Etching/Deposition Models in VICTORY Process

 

Introduction

VICTORY Process is supplied with a wide range of models and data for an extensive set of materials, so that you can simulate many process steps without the need to make changes in the default setup. However, you may wish to expand its capability by using your proprietary data and models. Thanks to the open modeling interface used by VICTORY Process

  • you can use your own models and data by customizing
    • the open model libraries and
    • the open material database and
  • you don’t have to share your local extensions, which may contain proprietary data, with SILVACO, but you can still smoothly upgrade to later versions of VICTORY Process while keeping your local extensions.

In this paper we describe how to define your own etching or deposition model and how to use this model for simulation.

 

The Open Etching/Deposition Model Library

With the installation package of VICTORY Process, you also get the open etching/deposition model library, which includes

  • source code of implementations of various etching and deposition models and
  • a shared library, containing these models.

The shared library is built by compiling and linking the above source code and is loaded during run time of VICTORY Process. Therefore by

  • implementing your own models,
  • compiling and linking them into a shared brary, and
  • instructing VICTORY Process to load your local library, instead of the default one
    you may
  • extend the built-in capabilities of VICTORY Process and
  • customize it for your specific needs.

 

Creating a Local Etching/Deposition Model Library

We start with making a copy of available source code of the default etching/deposition model library as a starting point for developing a new model:

  1. Create a folder, where the local model libraries shall be stored, for example, $HOME/VP_LocalModelLibraries

  2. Copy recursively the installation folder
    $SILVACO/lib/victoryp/<VERSION>/common/etchdepo

    to the new folder created in 1. Here:

    <VERSION> ... is a placeholder for the installed version of VICTORY Process (e.g. 4.4.0.R).

    This copies all files of the etching/deposition model library from the installation of VICTORY Process to your local folder.

  3. Go to the new folder
    $HOME/VP_LocalModelLibraries/etchdepo

  4. In this folder call the unix command

    gmake -f Makefile_linux

    This compiles all model files and builds the shared library (libVP_ED_C_Models.so) containing the local etching/deposition model library.

  5. Set the value of the environment variable

    SILVACO_MODEL_FILES

    to the string

    $HOME/VP_LocalModelLibraries/

    which is the name of the folder, that contains the etchdepo/ folder of your local etching/deposition model library.

After steps 1-5 are successfully completed, VICTORY Process will look for the etching/deposition model library in the folder

$HOME/VP_LocalModelLibraries/etchdepo

instead of taking it from the installation folder.

 

Implementing a New Model in the Open Etching/Deposition Model Library

Let us develop our own reaction model for deposition, named custom_reaction. A reaction model is called for each exposed surface point and it calculates the deposition rate at this point. It usually takes the following parameters (and probably others) :

  • flux - amount of particles arriving at the surface point
  • rate - deposition/etch rate at an unshaded planar surface

Assume, that we want to grow material preferably in vertical direction. This means, that our reaction model should also know the

  • local normal orientation at the surface point (three values of type double).

Note, that the values of the above parameters are not known until the reaction function is actually called for a particular surface point. They are calculated within the numerical engine of VICTORY Process and then passed to the reaction function. In the VICTORY Process manual this type of parameters is called “dependencies”.

All reaction functions are defined in the file

empiricalReactionModels.lib

of the open etching/deposition model library, so we have to open the above file and add the code shown in Listing 1.

 


Listing 1: C-function implementation of our custom reaction model.

 

After making these modification we need to rebuild the local etching/deposition model library.

Therefore we

  • call the command

gmake -f Makefile_linux

• in the folder

$HOME/VP_LocalModelLibraries/etchdepo

Now we can use this function for defining a model within a VICTORY Process input deck.

 

Defining a New Model in the Input Deck

In order to use our new reaction model we first need to tell VICTORY Process that

  • the deposition rate shall be calculated by the function custom_reaction_function from the etching/deposition model library and that
  • VICTORY Process should pass the dependencies

    - normal
    - flux
    - rate

to this function.

For that purpose, we use the input deck statement

REACTION name=”custom_reaction” c_function=”custom_reaction_function” dep1=”normal” dep2=”flux” dep3=”rate”

which creates a new reaction model, named “custom_reaction”. We can refer to this reaction model later in the deck. You have to be aware that:

  • the dependency “normal”, which represents a 3D vector of unit length, corresponds to 3 parameters of the C-function custom_reaction_function - one for each component of the 3D vector. It is very important that
  • the order of dependencies in the C-function and in the REACTION statement must be the same, otherwise the numerical engine of VICTORY Process will pass them in incorrect order with unpredictable results.

The value of the second dependency “flux” is the relative amount of particles arriving at the local surface point. For single particle problems as the one shown in this example, the “flux” at a plane unshaded surface is 1, while for other points it is between 0 and 1. The “flux” is determined

  • by the conditions in the reactor chamber and by
  • structural shading effects.

Its value is calculated by a separate model, which can be either

  • a user-defined flux model
  • one of the predefined flux models based on flux functions from the open etching/deposition model library

Therefore, in order to use our custom reaction model we must couple it with a flux model. This is done by means of the TOPOGRAPHYMODEL statement. Here, we use a simple predefined flux model named “constant”, which assumes, that the same amount of particles arrives at every exposed surface point. By coupling the reaction model with a flux model within the input deck statement

TOPOGRAPHYMODEL name=”custom_model” reaction=”custom_reaction” flux=”constant”

we create a our custom topography (deposition) model, which can be used for deposition simulation.

 

Using the Custom Deposition Model for Simulation

Let us start with the structure, shown on Figure 1 and deposit copper over the exposed oxide (but not silicon) surface with our model defined in the previous section.
In order to do this we have to

  • specify the deposition rate for copper over oxide using an ETCHDEPOPROPERTIES statement. The rate specified there corresponds to the “ratedependency in our reaction model. Moreover we have to
  • call the DEPOSIT statement, where we choose our custom topography model along with rates and other parameters.
Figure 1: Input structure for deposition simulation.

The full deck described here and in previous section is shown on Listing 2

 

Listing 2: VICTORY Process input deck for custom reaction model example.

 

Note, that in the ETCHDEPOPROPERTIES statement we define the deposition rate for copper over oxide and over copper (itself). If we don’t do this, after the first time step, when all exposed oxide is covered by copper, the deposition would stop. The parameter MAXCFL, used in the DEPOSIT statement, controls the time step. The smaller the value of this parameter the shorter the time step and the longer the simulation time, but numerical accuracy increases. The result of running the deck shown in Listing 2 is presented on Figure 2a.

For comparison, Figure 2b shows the result of deposition using the predefined reaction model, named “fluxdependent” instead of our custom reaction model. This reaction model assumes that the deposition rate is proportional to the particle flux at the surface point. Coupled with the “constantflux model it results in a conformal deposition of the copper over the exposed oxide (but not over the silicon, where the deposition rate is still zero). The corresponding deck is shown on Listing 3. Note, that the topography model defined in Listing 3 is equivalent to predefined topography model named “conformal”. Therefore, we could remove the TOPOGRAPHYMODEL statement from the deck altogether and set the parameter “MODEL=conformal” in the DEPOSIT statement instead. We kept the TOPOGRAPHYMODEL statement just to show explicitly the reaction model and flux model used for simulation.

a) Deposition with custom reaction model


b) Deposition with predefined reaction model

Figure 2: Deposition simulation results.

 

Listing 3: VICTORY Process input deck for custom reaction model example.

 

Conclusion

VICTORY Process allows user to extend the available set of etching and deposition models with its own models. It can be done by:

  • extending a local copy of the open etching/deposition model library with C-implementations of new models
  • instructing VICTORY Process to call the new model during the simulation, via the input deck.

Thereby VICTORY Process can be customized without the need to share proprietary models and data with SILVACO.

 

Download PDF version of this article.