import{ }

Calling sequence

import{ }

Properties

usage: $optional$
items: maximum 1

Dependencies

At least one of analytic_function{ } and file{ } must be present if output_imports{ } is defined.

Functionality

Specifications for importing data from a file or generating them from an analytic function, e.g. electrostatic potential, alloy profile, strain profile, doping profile, generation rate profile, electron or hole Fermi level profile.

Once a file has been imported or a function has been defined, it can be used several times, e.g. the same file could include the alloy concentration of a ternary for different region objects.

Data with dimensionality deviating from the simulation dimension can also be imported, e.g. an absorption spectrum for solar cell modeling.

Examples

import{
    file{...}
    output_imports{}
}

import{
    analytic_function{...}
    output_imports{}
}

Nested keywords

directory

Calling sequence

import{ directory }

Properties

usage: $optional$
type: character string
default: empty

Functionality

Name of directory where files to be imported are located (if data are imported from files)

Example

import{
    directory = "D:\\import_files\\"
    file{...}
}

file{ }

Calling sequence

import{ file{ } }

Properties

usage: $optional$
items: no constraints

Functionality

—

Example

import{
    file{...}
}

file{ name }

Calling sequence

import{ file{ name } }

Properties

usage: $required$
type: character string

Functionality

Name for referencing the imported data in the input file, e.g. “imported_potential_profile_2D”

Example

import{
    file{
        name = "1D_import"
        ...
    }
}

file{ filename }

Calling sequence

import{ file{ filename } }

Properties

usage: $required$
type: character string

Functionality

Name of file which is imported. Three ways of using are available.

One can define an absolute path to a file, e.g., "D:\\precious_data.dat". If so then directory is ignored if specified.

If the path is not specified here, e.g., "precious_data.dat" then the file must be located in the directory specified by directory.

When neither path is specified here, e.g., "precious_data.dat", nor the directory is defined, then the file must be located in the directory of the input file

Examples

import{
    file{
        name = "1D_import"
        filename = "D:\\precious_data.dat"
        ...
    }
}

import{
    directory = "D:\\"
    file{
        name = "1D_import"
        filename = "precious_data.dat"
        ...
    }
}

import{
    file{
        name = "1D_import"
        filename = "precious_data.dat"
        ...
    }
}

file{ format }

Calling sequence

import{ file{ format } }

Properties

usage: $required$
type: choice
values: AVS or DAT

Functionality

Format of the file to be imported. Formats .fld and .dat are supported for options AVS and DAT, respectively.

Example

import{
    directory = "D:\\"
    file{
        name = "1D_import"
        filename = "precious_data.dat"
        format = DAT
    }
}

file{ scale }

Calling sequence

import{ file{ scale } }

Properties

usage: $optional$
type: real number
values: no constraints
default: $r = 1.0$
unit: $-$

Functionality

A factor used to multiply the imported data. Can be used to change units of imported data for consistency with nextnano++, e.g., conversion from J to eV.

Examples

import{
    directory = "D:\\"
    file{
        name = "1D_import"
        filename = "precious_data.dat"
        format = DAT
        scale = 1.6022e-19
    }
}

import{
    directory = "D:\\"
    file{
        name = "1D_import"
        filename = "precious_data.dat"
        format = DAT
        scale = -1
    }
}

file{ number_of_dimensions }

Calling sequence

import{ file{ number_of_dimensions } }

Properties

usage: $optional$
type: integer
values: $1 \leq z \leq 3$
default: simulation dimension
unit: $-$

Functionality

Explicit specification of the number of dimensions of the space onto which the data is defined. Can be only used for .dat files.

Example

import{
    directory = "D:\\"
    file{
        name = "1D_import"
        filename = "precious_spectra.dat"
        format = DAT
        number_of_dimensions = 1
    }
}

analytic_function{ }

Calling sequence

import{ analytic_function{ } }

Properties

usage: $optional$
items: no constraints

Dependencies

At least one of analytic_function{ component{ } } and analytic_function{ function } must be defined.
analytic_function{ component{ } } and analytic_function{ function } cannot be defined together.
analytic_function{ label } cannot be defined if analytic_function{ component{ } } as already present.

Functionality

Defines analytic functions to be imported here. Does not need to be defined if data are imported from files.

Example

import{
    analytic_function{
        name = "function_1"
        component{...}
    }
    analytic_function{
        name = "function_2"
        function = ...
    }
    analytic_function{
        name = "function_3"
        function = ...
        label = ...
    }
}

analytic_function{ name }

Calling sequence

import{ analytic_function{ name } }

Properties

usage: $required$
type: character string

Functionality

Name for referencing the imported function in the input file.

Example

import{
    analytic_function{
        name = "Distribution_FD"
        function = ...
    }
}

analytic_function{ function }

Calling sequence

import{ analytic_function{ function } }

Properties

usage: $optional$
type: character string

Functionality

String defining the function in case only one component needs to be defined, otherwise use component.

Attention

One should use the syntax allowed for functions:

white spaces are ignored
valid operators are “+”, “-”, “*”, “/” and “^”
multiplication signs always have to be spelled out (i.e. “5*x” is valid, “5x” is not)
variable names are fixed to “x”, “y” and “z” (capital letters are also allowed)
additional functions also available (e.g. “exp” , “sqrt”, “sin”, see full list below), have to be followed by brackets (“exp(x)” is valid, “exp x” is not)
global variables are allowed if preceded by “$” (e.g. “$PI”)
exponential notation (“2e-3” or “4E10”) is allowed

See also table at the bottom of this site.

Example

import{
    analytic_function{
        name = "Distribution_FD"
        function = 1/(exp(x) + 1)
    }
}

analytic_function{ label }

Calling sequence

import{ analytic_function{ label } }

Properties

usage: $optional$
type: character string

Functionality

Label to be displayed in legend in case only one component is defined. If it’s not defined then, analytic_function{ name } is displayed.

Example

import{
    analytic_function{
        name = "Distribution_FD"
        function = 1/(exp(x) + 1)
        label = "Fermi Dirac"
    }
}

analytic_function{ component{ } }

Calling sequence

import{ analytic_function{ component{ } } }

Properties

usage: $optional$
items: no constraints

Functionality

In case multiple components are needed, define one component group for each component.

Example

import{
    analytic_function{
        name = "Distributions"
        component{...}
        component{...}
    }
}

analytic_function{ component{ function_i } }

Calling sequence

import{ analytic_function{ component{ function_i } } }

Properties

usage: $optional$
type: character string

Functionality

String defining the function for this component.

Example

import{
    analytic_function{
        name = "Distributions"
        component{
            function_i = 1/(exp(x) + 1)
        }
        component{
            function_i = 1/(exp(x) - 1)
        }
    }
}

analytic_function{ component{ label } }

Calling sequence

import{ analytic_function{ component{ label } } }

Properties

usage: $optional$
type: character string

Functionality

Label to be displayed in legend for this component.

Example

import{
    analytic_function{
        name = "Distributions"
        component{
            function_i = 1/(exp(x) + 1)
            label = "Fermi-Dirac"
        }
        component{
            function_i = 1/(exp(x) - 1)
            label = "Bose-Einstein"
        }
    }
}

output_imports{ }

Calling sequence

import{ output_imports{ } }

Properties

usage: $optional$
items: maximum 1

Functionality

Output all imported data including scale factor. The filenames correspond to the entry given in name = .... The files will be written to a folder called Imports/.

Example

import{
    file{...}
    analytic_function{...}
    output_imports{}
}

Operators and Functions supported by analytic_function{} group, sorted with decreasing precedence:

Operators

power (exponentiation)	`^`
multiplication, division	`*` `/`
plus and minus	`+` `-`
round arithmetic brackets	`(` `)`

Functions

`sqrt()`	square root $\sqrt{}$
`cbrt()`	cubic root $\sqrt[3]{}$
`exp()`	exponential function $\exp ()$
`log()`	natural logarithm $\log$
`ln()`	natural logarithm $\ln$
`log2()`	decadic logarithm (base 2) $\log_{2}$
`log10()`	decadic logarithm (base 10) $\log_{10}$
`sin()`	sine $\sin ()$
`cos()`	cosine $\cos ()$
`tan()`	tangent $\tan ()$
`asin()`	acrsine $\sin^{- 1} ()$
`acos()`	arccosine $\cos^{- 1} ()$
`atan()`	arctangent $\tan^{- 1} ()$
`sinh()`	hyperbolic sine $\sinh ()$
`cosh()`	hyperbolic cosine $\cosh ()$
`tanh()`	hyperbolic tangent $\tanh ()$
`asinh()`	inverse hyperbolic sine $\sinh^{- 1} ()$
`acosh()`	inverse hyperbolic cosine $\cosh^{- 1} ()$
`atanh()`	inverse hyperbolic tangent $\tanh^{- 1} ()$
`erf()`	error function $erf ()$
`erfc()`	complementary error function $erfc ()$
`gamma()`	Gamma function $Γ ()$
`fdm3half()`	complete Fermi–Dirac integral $F_{- 3 / 2} ()$ of order -3/2 (includes the $1 / Γ (- 1 / 2)$ prefactor)
`fdmhalf()`	complete Fermi–Dirac integral $F_{- 1 / 2} ()$ of order -1/2 (includes the $1 / Γ (1 / 2)$ prefactor)
`fdzero()`	complete Fermi–Dirac integral $F_{0} ()$ of order 0 (includes the $1 / Γ (1) = 1$ prefactor)
`fdphalf()`	complete Fermi–Dirac integral $F_{1 / 2} ()$ of order 1/2 (includes the $1 / Γ (3 / 2)$ prefactor)
`fdp3half()`	complete Fermi–Dirac integral $F_{3 / 2} ()$ of order 3/2 (includes the $1 / Γ (5 / 2)$ prefactor)
`abs()`	absolute value $\| \|$
`floor()`	floor function floor(x): largest integer $\leq x$
`ceil()`	ceiling function ceil(x): smallest integer $\geq x$
`round()`	rounds the number to the nearest integer
`sign()`	sign function
`heaviside()`	Heaviside step function (corresponds to `isnotnegative()`)
`ispositive()`	check if value is positive
`isnegative()`	check if value is negative
`iszero()`	check if value is zero
`isnotpositive()`	check if value is not positive
`isnotnegative()`	check if value is not negative (corresponds to `heaviside()`)
`isnotzero()`	check if value is not zero