poisson{ }

Calling sequence

poisson{ }

Properties

usage: $optional$
items: maximum 1

Dependencies

Exactly one of import_potential{ }, electric_field{ }, between_fermi_levels{ }, charge_neutral{ }, and zero_charge{ } must be specified.

Functionality

Presence of this group is triggering initialization of the Poisson equation. Calling it is required if Poisson equation is to be solved during a simulation. It gathers keywords controlling initialization of the electrostatic potential, numerical parameters of solvers, and related outputs.

Examples

poisson{
    between_fermi_levels{}
}

poisson{
    electric_field{...}
}

Nested keywords

debuglevel

Calling sequence

poisson{ debuglevel }

Properties

usage: $optional$
type: integer
values: $z \geq - 1$
default: $z = 1$
unit: $-$

Functionality

The higher this integer number, the more information on the numerical solver is printed to the screen output. Increasing the respective 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{ })

Example

poisson{
    debuglevel = 2
    between_fermi_levels{}
}

import_potential{ }

Calling sequence

poisson{ import_potential{ } }

Properties

usage: $optional$
items: maximum 1

Dependencies

The global group import{ } must be present.

Functionality

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.

Example

poisson{
    import_potential{...}
}

import{...}

import_potential{ import_from }

Calling sequence

poisson{ import_potential{ import_from } }

Properties

usage: $required$
type: character string

Functionality

Reference to imported data in import{ }. The data may have more than one component (e.g. vector field).

Example

poisson{
    import_potential{
        import_from = "qpc_landscape"
    }
}

import{
    file{
        name = "qpc_landscape"
        ...
    }
}

import_potential{ component_number }

Calling sequence

poisson{ import_potential{ component_number } }

Properties

usage: $optional$
type: integer
values: $z \geq 1$
default: $z = 1$
unit: $-$

Functionality

If imported data is a vector field, one may want to specify the component.

Example

poisson{
    import_potential{
        import_from = "qpc_landscape"
        component_number = 2
    }
}

import{
    file{
        name = "qpc_landscape"
        ...
    }
}

electric_field{ }

Calling sequence

poisson{ electric_field{ } }

Properties

usage: $optional$
items: maximum 1

Dependencies

electric_field{ direction } must be defined if simulate2D{ } or simulate3D{ } is already present.

Functionality

If electric_field{} is defined, this value in units of [V] is being added to the electrostatic potential.

Examples

poisson{
    electric_field{...}
}

global{
    simulate1D{ }
}

poisson{
    electric_field{
        direction = ...
        ...
    }
}

global{
    simulate2D{ }
}

electric_field{ direction }

Calling sequence

poisson{ electric_field{ direction } }

Properties

usage: $optional$
type: vector of 3 real numbers: $(r_{1}, r_{2}, r_{3})$
values: no constraints
default: $r_{1} = 1.0$ , $r_{2} = 0.0$ , $r_{3} = 0.0$
unit: $-$

Functionality

Orientation of electric field vector with respect to $(x, y, z)$ simulation coordinate system. For 1D simulations, the direction can be omitted and in this case the default will be used.

Examples

poisson{
    electric_field{
        direction = [ -1.0, 0.0, 0.0 ]
        ...
    }
}

poisson{
    electric_field{
        direction = [ 0.0, 0.5, 0.5 ]
        ...
    }
}

global{
    simulate3D{ }
}

electric_field{ strength }

Calling sequence

poisson{ electric_field{ strength } }

Properties

usage: $required$
type: real number
values: no constraints
unit: $V / m$

Functionality

Defines a constant electric field in the structure. If electric_field is defined, and the absolute value is larger than zero, then it is being used for the electrostatic potential calculation.

Example

poisson{
    electric_field{
        direction = [ -1.0, 0.0, 0.0 ]
        strength = 0.42
    }
}

electric_field{ reference_potential }

Calling sequence

poisson{ electric_field{ reference_potential } }

Properties

usage: $optional$
type: real number
values: no constraints
unit: $V$

Functionality

Note

If poisson{ } group is not called at all, then electric potential $ϕ = 0$ is assumed everywhere.

Example

poisson{
    electric_field{
        direction = [ -1.0, 0.0, 0.0 ]
        strength = 0.42
        reference_potential = -1.3
    }
}

between_fermi_levels{ }

Calling sequence

poisson{ between_fermi_levels{ } }

Properties

usage: $optional$
items: maximum 1

Functionality

When this group is used then the average value of quasi-Fermi levels is taken as the $ϕ_{i = 0}$ at every non-Dirichlet point of the simulation grid. Non-Dirichlet points are the grid points in the regions of the simulation, for which Dirichlet boundary conditions (in this case for potential) are not imposed. The group between_fermi_levels{} is used by default if the poisson{ } group is not specified in the input file at all.

Example

poisson{
    between_fermi_levels{}
}

charge_neutral{ }

Calling sequence

poisson{ charge_neutral{ } }

Properties

usage: $optional$
items: maximum 1

Functionality

The recommended keyword for specifying $ϕ_{i = 0}$ is charge_neutral{}. By using it, $ϕ_{i = 0}$ is evaluated by requirement of charge neutrality at every point of the simulation grid. The potential is determined by solving charge neutrality equation with the bisection algorithm.

Example

poisson{
    charge_neutral{}
}

zero_charge{ }

Calling sequence

poisson{ zero_charge{ } }

Properties

usage: $optional$
items: maximum 1

Functionality

Linear Poisson equation is solved without charges as initialization step of $ϕ_{i = 0}$ .

newton_solver{ }

Calling sequence

poisson{ newton_solver{ } }

Properties

usage: $optional$
items: maximum 1

Functionality

The Newton solver is used for solving the nonlinear Poisson equation. It is solved with a Newton iteration using inexact line search.The Poisson equation is nonlinear because the charge carrier density $ρ$ depends on the electrostatic potential $ϕ$ , i.e. $ρ (ϕ)$ . For each Newton step a system of linear equations, $A \cdot x = b$ , is solved with a linear solver, in order to obtain a gradient. This gradient is used for the inexact line search. Generally, low temperature simulations make the Poisson equation extremely nonlinear at the beginning of the iteration and thus require more line search steps than usual. Using debuglevel = 2 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 Parameters for solver of nonlinear poisson equation are as follows:

newton_solver{ iterations }

Calling sequence

poisson{ newton_solver{ iterations } }

Properties

usage: $optional$
type: integer
values: $z \geq 1$
default: $z = 30$
unit: $-$

Functionality

Number of iterations for Newton solver

Example

poisson{
    between_fermi_levels{}
    newton_solver{}
}

newton_solver{ search_steps }

Calling sequence

poisson{ newton_solver{ search_steps } }

Properties

usage: $optional$
type: integer
values: $1 \leq z \leq 50$
default: $z = 30$
unit: $-$

Functionality

—

Example

poisson{
    between_fermi_levels{}
    newton_solver{
        search_steps = 40
    }
}

newton_solver{ residual }

Calling sequence

poisson{ newton_solver{ residual } }

Properties

usage: $optional$
type: real number
values: [0.0, ...)
default: $r = 10^{3}$ for 1D; $r = 10^{1}$ for 2D; $r = 10^{- 4}$ for 3D
unit: ${cm}^{- 2}$ for 1D; ${cm}^{- 1}$ for 2D; $none$ for 3D

Functionality

—

Example

poisson{
    between_fermi_levels{}
    newton_solver{
        residual = 1e2
    }
}

newton_solver{ gradient_shift }

Calling sequence

poisson{ newton_solver{ gradient_shift } }

Properties

usage: $optional$
type: real number
values: $- 10^{- 6} \leq r \leq 10^{- 6}$
default: $r = 1 e - 11$
unit: $-$

Functionality

Slightly nudges the gradient in case it is effectively zero

Example

poisson{
    between_fermi_levels{}
    newton_solver{
        residual = -1e-8
    }
}

linear_solver{ }

Calling sequence

poisson{ linear_solver{ } }

Properties

usage: $optional$
items: maximum 1

Functionality

Parameters for linear equation solver in Newton algorithm.

Example

poisson{
    between_fermi_levels{}
    linear_solver{}
}

linear_solver{ iterations }

Calling sequence

poisson{ linear_solver{ iterations } }

Properties

usage: $optional$
type: integer
values: $z \geq 1$
default: $z = 1000$
unit: $-$

Functionality

number of iterations for linear equation solver

Example

poisson{
    between_fermi_levels{}
    linear_solver{
        iterations = 2000
    }
}

linear_solver{ abs_accuracy }

Calling sequence

poisson{ linear_solver{ abs_accuracy } }

Properties

usage: $optional$
type: real number
values: [0.0, ...)
default: $r = 10^{1}$ for 1D; $r = 10^{- 3}$ for 2D; $r = 10^{- 8}$ for 3D
unit: ${cm}^{- 2}$ for 1D; ${cm}^{- 1}$ for 2D; $none$ for 3D

Functionality

—

Example

poisson{
    between_fermi_levels{}
    linear_solver{
        abs_accuracy = 1e-2
    }
}

linear_solver{ rel_accuracy }

Calling sequence

poisson{ linear_solver{ rel_accuracy } }

Properties

usage: $optional$
type: real number
values: $0.0 \leq r \leq 10^{- 6}$
default: $r = 1 e - 13$
unit: $-$

Functionality

—

Example

poisson{
    between_fermi_levels{}
    linear_solver{
        rel_accuracy = 1e-15
    }
}

linear_solver{ dkr_value }

Calling sequence

poisson{ linear_solver{ dkr_value } }

Properties

usage: $optional$
type: real number
values: (..., 0.5]
default: $r = 0.0$
unit: $-$

Functionality

A parameter to speed up calculations, affects preconditioning. Negative values are ignored but will switch to a slightly slower but more stable preconditioner.

Example

poisson{
    between_fermi_levels{}
    linear_solver{
        dkr_value = 0.1
    }
}

linear_solver{ use_cscg }

Calling sequence

poisson{ linear_solver{ use_cscg } }

Properties

usage: $optional$
type: choice
values: yes or no
default: no

Functionality

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.

Example

poisson{
    between_fermi_levels{}
    linear_solver{
        use_cscg = yes
    }
}

linear_solver{ force_diagonal_preconditioner }

Calling sequence

poisson{ linear_solver{ force_diagonal_preconditioner } }

Properties

usage: $optional$
type: choice
values: yes or no
default: no

Functionality

Forces the use of a slower but more robust diagonal preconditioner. Should be used only for debugging purposes, enabling will make code much slower or prevent convergence. 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.

Example

poisson{
    between_fermi_levels{}
    linear_solver{
        force_diagonal_preconditioner = yes
    }
}

linear_solver{ force_iteration }

Calling sequence

poisson{ linear_solver{ force_iteration } }

Properties

usage: $optional$
type: choice
values: yes or no
default: no

Functionality

Only for debugging purposes, enabling will make code much slower or prevent convergence

Example

poisson{
    between_fermi_levels{}
    linear_solver{
        force_iteration = yes
    }
}

bisection{ }

Calling sequence

poisson{ bisection{ } }

Properties

usage: $optional$
items: maximum 1

Functionality

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:

ρ = p - n + s u m (N_{D, i o n i z e d}) - s u m (N_{A, i o n i z e d}) = 0

Thus, a true classical charge neutrality is computed for classical carrier and doping situations.

Additionally, bisection is also used to determine the electrostatic potential at which contacts become charge neutral, which is also needed for ohmic contacts and charge-neutral contacts. The bisection for these contacts is performed in any case, i.e. independently to the bisection used when charge_neutral = yes is set. 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.

Example

poisson{
    between_fermi_levels{}
    bisection{}
}

bisection{ delta }

Calling sequence

poisson{ bisection{ delta } }

Properties

usage: $optional$
type: real number
values: [0.0, ...)
default: $r = 10.0$
unit: $eV$

Functionality

Range of bisection search.

Example

poisson{
    between_fermi_levels{}
    bisection{
        delta = 7.0
    }
}

bisection{ residual }

Calling sequence

poisson{ bisection{ residual } }

Properties

usage: $optional$
type: real number
values: [0.0, ...)
default: $r = 1 e 3$
unit: ${cm}^{- 3}$

Functionality

—

Example

poisson{
    between_fermi_levels{}
    bisection{
        residual = 1e1
    }
}

bisection{ iterations }

Calling sequence

poisson{ bisection{ iterations } }

Properties

usage: $optional$
type: integer
values: $1 \leq z \leq 100$
default: $z = 40$
unit: $-$

Functionality

—

Example

poisson{
    between_fermi_levels{}
    bisection{
        iterations = 60
    }
}

bisection{ robust }

Calling sequence

poisson{ bisection{ robust } }

Properties

usage: $optional$
type: choice
values: yes or no
default: no

Functionality

When robust=yes then a slower charge neutrality algorithm designed to be stable for large band gaps or low temperatures.

Note

The bisection algorithm is also used for initializing quasi-Fermi levels in Ohmic and charge-neutral contacts. In this case, the values specified in the input file may become internally modified. - iterations is always increased to be at least 40 - residual is reduced to be at most 1e3 cm^-3 - robust is always equal yes

Therefore, the contact setup ignores bisection definitions which provide lower accuracy than these default settings.

The intrinsic density in GaN at T=300 K is of the order 1e-10 cm^-3, even smaller in AlN. Extremely low carrier densities may be also expected at low temperatures. In such cases the residual needs to be adjusted to obtain reasonable initialization of the contacts.

Attention

Reducing the default value of residual may result in significantly longer initialization times, especially in 3D simulations.

Example

poisson{
    between_fermi_levels{}
    bisection{
        robust = yes
    }
}

output_potential{ }

Calling sequence

poisson{ output_potential{ } }

Properties

usage: $optional$
items: maximum 1

Functionality

Prints out the electrostatic potential in (eV).

Example

poisson{
    between_fermi_levels{}
    output_potential{}
}

output_electric_field{ }

Calling sequence

poisson{ output_electric_field{ } }

Properties

usage: $optional$
items: maximum 1

Functionality

Prints out the electric field in kv/cm.

Example

poisson{
    between_fermi_levels{}
    output_electric_field{}
}

output_electric_displacement{ }

Calling sequence

poisson{ output_electric_displacement{ } }

Properties

usage: $optional$
items: maximum 1

Functionality

Prints out the output electric displacement

Example

poisson{
    between_fermi_levels{}
    output_electric_displacement{}
}

output_electric_polarization{ }

Calling sequence

poisson{ output_electric_polarization{ } }

Properties

usage: $optional$
items: maximum 1

Functionality

Prints out the output electric polarization

Example

poisson{
    between_fermi_levels{}
    output_electric_polarization{}
}

output_dielectric_tensor{ }

Calling sequence

poisson{ output_dielectric_tensor{ } }

Properties

usage: $optional$
items: maximum 1

Functionality

Prints out the output dielectric tensor in simulation coordinate system, as it is used while setting up the sparse matrix for the Poisson solver.

Example

poisson{
    between_fermi_levels{}
    output_dielectric_tensor{}
}

output_dielectric_tensor{ boxes }

Calling sequence

poisson{ output_dielectric_tensor{ boxes } }

Properties

usage: $optional$
type: choice
values: yes or no
default: no

Functionality

For each grid point, in 1D two points are printed out to mimic abrupt discontinuities at interfaces (in 2D four points, in 3D eight points)

Example

poisson{
    between_fermi_levels{}
    output_dielectric_tensor{
        boxes = yes
    }
}

Last update: 02/04/2025