Next: 1.1 Outline of the
Up: Dissertation
Previous: List of Tables
1. Introduction
The increasing functionality and complexity of TCAD simulation tools
raises high demands for new software technologies supporting their
development by teams consisting of people specialized in many different
fields. Current simulator development has to be done by at least
coordinating the work of physicists, numerical analysts, and software
developers to obtain consistent projects. Thus concepts for the integration
of their work like the usage of convenient interface abstraction techniques
are demanded. Another important issue is the amount of time, often
referred to in terms of the legendary ``person-year'' which has to be spent
for the development of new simulators or models.
Solution concepts for these demands are generally summarized under the term
``Rapid Application Development'' strategies and address the following
points:
- Modular development approaches heavily support the collaboration of a
number of people and reflect their organization in groups specialized on
specific tasks such as the development of the simulator kernel, equation
solvers, time step control algorithms, and physical models.
- The reuse of code once developed should be supported to minimize the
efforts for writing and debugging code for similar tasks. This challenge
is commonly met by defining style guides for the code and the usage of
object-oriented programming languages.
- To decrease the time required for the implementation and testing of
new algorithms and models within existing applications often scripting
languages are employed.
- All the above mentioned concepts should be efficient in terms of
memory and CPU time consumption during the development, testing, and
application of new models or simulators.
The evolution of various TCAD environments and simulators during the
last decade reflects the trend to concentrate more and more on these
requirements. An example for a large hierarchical structure of libraries
serving for different tasks within an TCAD framework is documented for
the VISTA TCAD environment [18,14]. The functionality of
TCAD frameworks has commonly been achieved by utilizing various
interpreted languages. Commonly known examples in this field are TMA Suprem-4
[60] and FLOOPS/FLOODS [24,23] based on TCL
[34] interpreters as well as VISTA [38] and
SIESTA [57] wrapped into LISP interpreters.
Various attempts have been made to support the scripting of
physical models for ECAD and TCAD applications. The result is a
number of different applications offering various scripting abilities, from
the simple parameterization of fixed models towards the support for
complete user defined models. These attempts can be classified into three
main streams:
- A simple possibility is to support the definition of arbitrary models
via user defined subroutines which will be compiled into the executable
of the application. Examples for this approach are PROMIS 1.6
[19] and ZOMBIE [21]. In case this process is
sufficiently supported by an according framework, it offers a very
effective solution in terms of CPU usage. The most appealing
disadvantage is that model developers have to be aware of the programming
language and partially of the internal data and algorithm structures of
the affected application. Another issue is that the lacking portability
of algorithms defined in such a manner.
- The second approach is to use a general purpose extension language,
like TCL [34] or Perl [65]. These languages are
widely available on almost all modern operating systems. The advantage of
using one of these is the high portability, the stability, and the vast
amount of available documentation. The show stopping disadvantages are
insufficient computational speed and lacking support for native data type
representations of abstract data types. The latter could be addressed by
some recently upcoming interpreters for object-oriented extension
languages like C++ interpreters [27,28] or Python
[26], but various tests did not reveal sufficient speed
improvements over the other interpreter languages. Thus this approach is
used within TCAD environments mostly for the parameterization or
flexible control of fixed models. A recent example for such an approach
can be found in [64] describing the implementation of a
three-dimensional diffusion simulator utilizing a newly designed ``Simulation Command Language
(SCL)''.
- The third approach is to equip TCAD simulators with modules
capable of the discretization of analytical mathematical expressions.
Advanced examples for that strategy can be found in [42],
[25] for the description of models in the field of device
simulations. Other implementations in process simulators which should be
mentioned are ALAMODE [68], PROPHET [43], and
Amigos [41,42]. A closer inspection shows that they
implement all kinds of modeling languages varying from simple
dial-an-operator schemes up to languages capable of handling complex
analytical expressions independent from pre-defined operator libraries.
None of this scripting languages is portable to other simulators, mostly
because their implementation depends heavily on the exact layout of the
grid and data structures of the simulator program. Another disadvantage
of these modules is the restriction to the mathematical part of the
formulation of new models. Aspects like variations in the iteration
schemes, the input, and output of simulation data, handling of the
simulation grid and other algorithms commonly used within simulator
programs are left out.
The concepts described within this thesis are mostly resulting from the
demand for enhanced and portable possibilities for the development of
scriptable and extendible TCAD applications. The attempt is made to
avoid the inherent problems of previously developed solution techniques and
to provide new answers to the above described problems with the
``Algorithm Library''. The design concept of the ``Algorithm Library'' is to offer an open
framework for the object-oriented implementation, management and
documentation of any kind of algorithms and physical models required within
TCAD applications. Additionally it provides the ``Model Definition Language'' - an
object-oriented interpreter and compiler language - which is designed to
meet the performance requirements of TCAD simulators by simultaneously
offering advanced abstraction possibilities and language features
supporting the joint development of models by physicists and computer
scientists.
The Algorithm Library is designed to contain solution concepts and support for all
groups of people concerned with the development, implementation and
application of TCAD tools and frameworks, e.g. framework engineers,
application engineers, model developers, and TCAD engineers. Thereby it
offers on the one hand a single interface for the interaction and
communication between these user groups and on the other hand a single tool
set for the solution of interdisciplinary problems.
Special attention has been spent to the portability of the
Algorithm Library to a number of different operating systems and compilers. Another
major goal was to assure the applicability of its concepts to existing
TCAD applications.
Next: 1.1 Outline of the
Up: Dissertation
Previous: List of Tables
Robert Mlekus
1999-11-14