|
Up
| | This is the old documentation.
Here's the link to the new documentation.
poisson{}
Specifications for the
Poisson equation
poisson{
import_potential{
# Import electrostatic potential from file or analytic function and use it as initial guess
for solving the Poisson equation.
# If no Poisson equation is solved, the imported data determines
the electrostatic potential that is used throughout the simulation,
# i.e. in this case an electrostatic potential can be read in that is
fixed during the rest of the simulation
# and is used as input to the Schrödinger equation and for the
calculation of the densities.
# The solution obtained from a problem solved previously using a
different meshing is accepted.
import_from =
"1D_import" # reference to
imported data in import{}. The data may
have more than one component (e.g. vector field).
component_number = 4
# 1)
}
# -r to read in a previously saved
potential as an initial guess (raw data for potential and Fermi levels).
electric_field{
strength = -75.0e5
# Defines a constant electric
field (in units of [V/m])
in the structure. If
electric_field
is defined, and
the absolute value is larger than 0.0 V/m, then it is being used for the
electrostatic potential
calculation
direction = [3, 1, 1] # . For
1D simulations, the direction can be omitted and in this case [100] will be
used.
}
reference_potential = 0.0 # If
electric_field
is defined, this value in units of
[V] is being added to the
electrostatic potential.
# The 'leftmost' grid point (x,y,z) is taken as the reference
position.
Output definitions
output_potential{}
# [eV]
output_electric_field{} #
prints out the electric field [kV/cm] = 105 [V/m]
output_electric_displacement{} # output electric displacement
output_electric_polarization{} #
output_dielectric_tensor{ #
boxes = yes/no
#
# abrupt discontinuities at interfaces (in 2D four points, in 3D eight
points)
}
output_sparse_matrix{ #
type = "
#
enumerate desired types of sparse matrix output in .mtx format
(optional). If type is not defined,
values is taken as default type.
values
# output sparse matrix as it is (also imaginary part, if sparse matrix is
complex valued)
zero_nonzero
#
zero_nonzero_absolute #
all
#
"
#
}
charge_neutral
= yes/no
# yes)
#
# charge_neutral = no is set and neither a potential is imported nor a fixed electric field is set,
# then the potential is set at non-Dirichlet points to the Fermi level(s) (both Fermi levels are equal at the beginning).
bisection{
# parameters for bisection search. Used for the initial solution of
the Poisson equation when
charge_neutral = yes is set.
# Bisection is performed in order to achieve local charge neutrality at
each grid point:
# rho = p - n + sum(ND,ionized) - sum(NA,ionized) = 0
# Thus, a true classical charge neutrality is computed for classical
carrier and doping situations.
#
# which is also needed for e.g. ohmic contacts and Schottky contacts
using Schottky barriers,
# but not for Fermi contacts as inside them the electrostatic potential
is initialized exactly the same way as specified outside/between of contacts.
# The bisection for contacts is performed in any case, i.e. independently
from the bisection used when charge_neutral = yes
is set.
delta
= 10.0
# range of bisection search (default is:
10.0 [V])
iterations =
40
#
40). This is the maximum number of
iterations allowed
# residual (when
charge_neutral = yes is set).
residual
= 1e3
#
1e3/cm3)
# Default values of
40 and 1e3 are used here as written.
However, for the other bisection used for contacts,
#
the values from the input file are internally modified in that
iterations is always increased to be at least
40 and
# residual
is reduced to be at most 1e3 cm-3,
i.e. the contact setup ignores bisection definitions which are weaker than these
default settings.
# 1e-10
cm-3, in AlN even smaller, so the residual needs to be
adjusted in some cases.
#
Making the default values smaller may result in significantly longer initialization times, especially in 3D,
}
# and will provide no benefit for other materials than wide band gap
semiconductors (e.g. nitrides). Also note that low temperatures cause low
densities.
newton_solver{
# parameters for solver of nonlinear poisson equation
iterations = 20
#
40)
# 1 (not recommended)
actually means that there is no Newton iteration at all, only a line search
along the gradient descent direction.
search_steps = 40
#
30), value must be between
1 and 50.
At sub-Kelvin temperature
# 30 may be needed to achieve (very slow!) convergence.
#
residual =
1e-4
#
1e3/cm2
(1D), 1e1/cm
(2D), 1e-4
(3D))
#
#
gradient_shift =
1e-13
# gradient_shift is not equal to
0, then the gradient is slightly nudged in one direction in case of disappearing gradient
# (e.g. at very low temperature with only Fermi contacts defined).
# For hole-dominated systems, a very small negative value (e.g.
-1e-13) may possibly work better.
# [-1e-6,1e-6].
}
thus require more line search steps than usual.
Using debuglevel = 2 in poisson{} displays
information on the line searchs steps (search_steps):
In the .log file of your simulation, you can find more information on the
convergence of the Newton solver.
Solving nonlinear Poisson equation...
Newton step: 1 0.035911148242035
# iteration #1
line search step: 1
0.0588936099361 #
line search step: 0.5
0.035845173647528 #
line search step: 0.25
0.028258431359213 #
line search step: 0.125
0.031636171717465 #
Newton step: 2 0.028258431359213
#
line search step: 1
0.00015195015656418 #
Newton step: 3 0.00015195015656418
#
line search step: 1
4.6609920274663e-006 #
Newton step: 4 4.6609920274663e-006
#
line search step: 1
5.3557267975735e-009 #
Newton step: 5 5.3557267975735e-009
#
line search step: 1
1.4100842164663e-011 #
Newton step: 6 1.4100842164663e-011
#
linear_solver{ # parameters for linear equation solver in Newton algorithm
iterations =
1000 # 1000)
abs_accuracy = 1e-8 # 1e1/cm2
(1D), 1e-3/cm
(2D), 1e-8
(3D))
rel_accuracy =
1e-13 # 1e-13 [dimensionless]),
0.0 <= rel_accuracy <= 0.01
dkr_value =
0.0 # ("magic parameter" to speed up calculations, affects preconditioning,
must be <= 0.5) (default is:
0.0)
#
use_cscg =
no
# yes or
no (default is:
no) Forces the slower but occasionally more robust CSCG (Composite
Step Conjugate Gradient ) linear solver to be used
#
rather than the cg (Conjugate Gradient) linear solver. May occasionally prevent a diagonalization failure.
# Only for debugging purposes, enabling will make code much slower or prevent convergence.
force_diagonal_preconditioner = no
#
yes
no (default is:
no) Forces the use of a slower but more robust diagonal preconditioner.
# Only for debugging purposes, enabling will make code much slower or prevent convergence.
# Please try setting it to
yes in case preconditioning fails or the linear solver diverges.
If set to yes,
iterations may have to be further increased.
force_iteration
= no
#
yes
no (default is:
no)
# Only for debugging purposes, enabling will make code much slower or prevent convergence.
}
# Note: abs_accuracy
should be smaller than the Newton solver residual by at least one order of
magnitude.
cg started: 0.000000000000000E+000 -9.999999999999997E-007 1000
# cg = conjugate gradient solver for linear system of equations:
rel_accuracy abs_accuracy iterations
1 0.708301112278990
#
2 4.327819305951094E-015
#
3 1.005673461650542E-028
#
cg matmuls: 3
#
cg residual (rel,abs): 1.419838885209067E-028 2.864375403532904E-014
#
debuglevel =
-1..3
#
debuglevel = 1)
#
debuglevel to 2 or more significantly increases the volume of the diagnostic output
displayed in nextnanomat (or a shell window).
# As result of the additional I/O load, particularly 1D simulations
will slow down correspondingly (especially for current{}
and poisson{}).
# The bisection method is a well known algorithm for finding
the root of a function.
# The delta is the so-called convergence tolerance parameter.
# Specifically in nextnano we use this method to find the initial solution of the Poisson equation that generally converges very fast using the default parameters and no extra tuning is required.
}
Examples
poisson{} # solves Poisson equation
poisson{ # solves Poisson equation
newton_solver{ residual =
1e-10 } # with a residual of
1e-10
output_potential{} #
and prints out the electrostatic potential [eV]
}
Further remarks
- The nonlinear Poisson equation is solved with a Newton iteration using
inexact line search.
- The Poisson equation is nonlinear because the charge carrier density
rho depends on the electrostatic potential phi, i.e. rho(phi).
- For each Newton step a system of linear equations, A.x = b, is solved
with a linear solver, in order to obtain a gradient.
- This gradient is used for the inexact line search.
Further details can be found in the
PhD thesis of T. Zibold (Chapter 2).
|
