Next: D. Iteration Schemes in Up: Dissertation Grasser Previous: B2. Real Device Classes

# C. Overview of the Input Deck Programming Language

MINIMOS-NT is equipped with a quite powerful control language called Input Deck Programming Language (IPL). During a simulation several decisions are imaginable, various parameters must be given. Using the IPL the user is able to customize his simulation by creating his own input deck files written in plain ASCII text. MINIMOS-NT provides default input deck files with standard settings. However, for standard simulations most of the IPL features are hidden. This section gives a rough overview of the most important features.

MINIMOS-NT uses IPL files as input files. First, the files are read and checked for correct syntax. All elements are stored in a kind of database and can be queried by the simulator afterwards.

Other input deck files can be inserted using the #include command, e.g.,

```#include <defaults.ipd>
```

The basic unit is a keyword. MINIMOS-NT only reads those keywords, which are used for the current simulation type. Keywords may contain simple constants or complex expressions and can be of one of the following types:

 Type Example Boolean a = true; Integer a = 3; Real a = 3.1415; Complex a = 4.3 + 3.1 j; Quantity a = 3.5 m; a = 7.38 "m/s"; String a = "This is a string"; Array a = [ 1, 2, 3 ]; a = [ 1, "pi", 3 A];

Standard mathematical operations and functions are available which are defined for the types Integer, Real, and Complex in general. Additionally, several useful functions are defined. New functions can be simply defined by the user.

```inc(x) = x + 1;
a = (17.2 + 22.9) * 2;          // 80.2
b = sin (a);                    // sin(80.2)
c = inc (b);                    // sin(80.2) + 1
```

Keywords can be grouped in arbitrarily nested sections enclosed in braces, e.g.,

```X                               // section X
{
a = yes;
Y                            // subsection Y within section X
{
b = 3 V;
}                            // end of subsection Y
c = Y.b + 34 V;              // 37 V
}                               // end of section X
```

Keywords and sections have a so-called full name which also includes the location (directory path). In the example above the full name of b is `~`X.Y.b. The tilde (`~`) denotes the root section hence this is called an absolute path. If the tilde is omitted, it is a relative path starting from the current position.

Sections may be inherited from base sections. Keywords and sections given in the base section are visible in the inherited section. They may be overwritten by a local value.

```X
{
a = yes;
b = 3;
}

Y : X                           // inherit Y from X
{
a = no;
}
```

Section Y contains a = no and b = 3.

Whenever a section is inherited from a base section, only variables given in the base section can be locally modified. New variables can be added by using the plus (+) sign. This is necessary in cases where keywords are not a priori known by the simulator (e.g., contacts).

```X
{
a = yes;
b = 3;
}

Y : X                           // inherit Y from X
{
+c = "Test";                  // add c to section Y
}
```

Section Y now contains a = yes, b = 3, and d = "Test".

Keywords can be classified by the access the simulator is allowed to perform: External keywords (defined by a leading ext which can be read and written, and `normal' keywords (need not to be specified) which can be read only by the simulator, e.g.,

```ext a1;                         // may be read and written by the simulator
a2 = 5;                         // may be read only by the simulator
```

In MINIMOS-NT most of the external keywords are located in the Extern section for convenience. It is important to note that all keywords are evaluated at run-time and may therefore vary with time in case they contain references to an external keyword.

```Extern
{
ext t = 0;                   // the current simulation time
}

aux T = 300 ms;                 // T is defined as a constant
a = sin(2*pi*Extern.t/T);       // depends on Extern.t which may vary
```

The qualifier aux denotes that the variable T cannot be inquired by the simulator. It is used in the default files to emphasize the fact that this is an auxiliary variable which will not be inquired and is just used to build more complex control expressions.

IPL supports comfortable unit handling. Units containing a division, multiplication, or power function must be double-quoted to avoid ambiguities.

```s = 2 s;                        // s is the unit
m = 3 m/s;                      // error: (3 m)/s or 3 "m/s"
q = 3 "m/s";                    // OK
t = (s/1 s)*1 "m/s" + b;        //  ->  4 "m/s"
```

Each quantity keyword has a default unit which is the SI-unit. Exceptions are given in Table C.2. In case of missing units these default units will be used.

 Type Default unit length "um" volume "um^3" voltage "V" electric field "V/cm" velocity "cm/s" concentration "cm^-3" density of states "cm^-3" capture cross section "cm^2" thermal resistance "K cm^2/W" mobility "cm^2/V s" energy "eV"

Next: D. Iteration Schemes in Up: Dissertation Grasser Previous: B2. Real Device Classes
Tibor Grasser
1999-05-31