Up

quantum{}

Specifications that define quantum models, i.e. how the Schrödinger equation should be solved.

quantum{


 debuglevel      = -1..3             # The higher this integer number, the more information on the numerical solver is printed to the screen output. (default: debuglevel = 1)

 allow_overlapping_regions = no      # Overlapping quantum regions computing the same band(s) are not allowed (default = no)
                           = yes     # Note that, in case such overlap is allowed, the quantum densities of the respective regions are added in the overlap region and a too high density will be computed.
                                     # Thus, please only allow such overlap when the quantum densities are known to be extremely small in the overlap region.


 Quantum regions
 region{                             # Inside the quantum region, the Schrödinger equation is solved.

   name       = "qr1"                # name of quantum region

   no_density = yes                  # don't calculate quantum mechanical charge density
              = no                   # calculate quantum mechanical charge density (default = no)

   x = [10.0, 20.0]                  # extension of quantum region in x direction [nm]
   y = [10.0, 20.0]                  # extension of quantum region in y direction [nm] (2D or 3D only )
   z = [10.0, 20.0]                  # extension of quantum region in z direction [nm] (3D only )

   Boundary conditions
   boundary{                         # boundary condition for Schrödinger equation (default is neumann)
      x = dirichlet                  # Dirichlet   boundary conditions (psi = 0)                    in x direction
        = neumann                    # Neumann boundary conditions (n ( m^-1 grad psi) = 0) in x direction
        = cbr                        # CBR boundary conditions in x direction (cbr{})
      y = dirichlet/neumann/cbr      # boundary conditions in y direction (2D or 3D only)
      z = dirichlet/neumann/cbr      # boundary conditions in z direction (3D only)

                                     # Quantum densities may exhibit pathological density values on the boundary (e.g. 0 in the case of Dirichlet boundary conditions).
                                     # Using classical_boundary_x, classical_boundary_y, classical_boundary_z, the computation of a classical density can be enforced
                                     # on the respective boundary points for the respective band(s). (The quantum calculation itself and respective results such as wavefunctions are not affected by this setting.)
      classical_boundary_x = no      # yes or no (default = no)
      classical_boundary_y = no      # yes or no (default = no)
      classical_boundary_z = no      # yes or no (default = no)
                                     # The number of points to be cut at each side can be explicitely specified.
      num_classical_x      = [1,1]   # (default = [1,1])
      num_classical_y      = [1,1]   # (default = [1,1])
      num_classical_z      = [1,1]   # (default = [1,1])
   }
   Note: In general, Dirichlet   boundary conditions correspond to     f       = constant.
            In general, Neumann boundary conditions correspond to   df / dx = constant.

   Note: Periodic boundary conditions along the appropriate directions are taken automatically
   - if global { ... periodic{ x = yes and/or y = yes and/or z = yes } } is specified
   - and if the quantum region extends over the whole simulation region along the appropriate direction.
   In this case, the dirichlet or neumann specifications under boundary{...} are ignored along the appropriate directions.

   Energy dispersion E(k_||)                 # 1D: E(k_||) = E(k_x,k_y),  2D: E(k_||) = E(k_z),  3D: not applicable
   calculate_dispersion{             # DEPRECATED use dispersion{ .. } in quantum bands.
      num_points      = 5            # number of k_|| points (in one direction), where energy dispersion will be calculated (1D: k_|| = (k_y,k_z), 2D:  k_|| = k_z) (default is 10)
      relative_size   = 0.2          # range of k_|| dispersion relative to size of Brillouin zone (default is 1.0)
                                     # Output is written to wf_dispersion_*.dat files (in units of [eV])
   }                                

   Output definitions
   output_wavefunctions{
      max_num        = 10            # number of eigenfunctions to print out (minimum value is 1, maximum value is 9999)
      all_k_points   = yes/no        # prints out the wavefunctions for all k_|| points (1D: k_|| = (k_y,k_z), 2D:  k_|| = k_z) that are used in the k_integration{} or dispersion{} (see below)
                                     # Enabling this option can produce a large number of output files

      structured     = no            # whole output is written in subdirectory Quantum/ (default is no)
                     = yes           # In subdirectory Quantum/ additional subdirectories are created to organize the structure of the output files in a meaningful way.
                                     # It is recommended to set this parameter to yes if a lot of output files are created, e.g. in case all_k_points = yes
                                     # and both amplitudes and probabilities are printed out.
      amplitudes     = "             # prints out the wavefunctions (psi) in units of 1D: nm-1/2, 2D: nm-1, 3D: nm-3/2. Enumerate desired output types:
                        yes          # for k.p it is equivalent to S_X_Y_Z
                        no           # no output is done for amplitudes (default is no)
                        S_X_Y_Z      # prints out the wavefunctions (psi) with respect to the basis (k.p only):
                                     # | S+ >, | S- >, | X+ > , | Y+ > , | Z+ > , | X- > , | Y- > , | Z- >
                                     # | X >, | Y >, | Z > correspond to x, y, z of the simulation coordinate system (and not crystal coordinate system).
                                     # + and - correspond to the spin projection along the z axis of the crystal system.
                        CB_HH_LH_SO  # prints out the wavefunctions (psi) with respect to the basis (k.p only):
                       "             # | cb+ >, | cb- >, | hh+ >, | lh+ >, | lh- >, | hh- >, | so+ >, | so- >
                                     # This basis is the same as used in L. C. Lew Yan Voon, M. Willatzen, The k.p method (2009) (Table 3.4);
                                     # G. Bastard, Wave Mechanics Applied to Semiconductor Heterostructures (1988); B. A. Foreman, PRB 48, 4964 (1993)
                                     #
    Example:
      amplitudes = "S_X_Y_Z CB_HH_LH_SO"
                                     #
                                     #
      probabilities  = "             # prints out the square of the wavefunctions (psi²) in units of 1D: nm-1, 2D: nm-2, 3D: nm-3. Enumerate desired output types:
                        yes          # prints out (psi²); for k.p psi² is the sum of the squares of all components of a spinor (default is yes)
                        no           # no output is done for probabilities
                        S_X_Y_Z      # same as for the amplitudes (k.p only)
                        CB_HH_LH_SO  # same as for the amplitudes (k.p only)
                       "             #
    Example:
      probabilities = "yes CB_HH_LH_SO"
                                     #
                                     #
      scale          = 0.7           # scale factor for output of amplitudes and probabilities (optional, default = 1.0).

      in_one_file    = yes/no        # prints out the amplitudes into one file and the probabilities into one file (default is yes).
                                     # If no is chosen, for each eigenvalue a separate file is written out.

      energy_shift   = shifted       # prints out the amplitudes and the probabilities shifted by the energy.
                     = not_shifted   # prints out the amplitudes and the probabilities as they are (an integral over volume is equal to 1).
                     = both          # prints out the amplitudes and the probabilities with and without energy shift (default is both).

      include_eigenvalues_in_shifted_files = yes  # Energy levels are added in output of shifted amplitudes and probabilities. (default is yes)
                                           = no   # Energy levels are suppressed in output of shifted amplitudes and probabilities.
                                                  # Instead a separate file with energy levels is written out.
   }                                
   # Note: The energy spectrum (i.e. the eigenvalues) are always written into the files wf_spectrum_*.dat.
          The projections of the eigenfunctions on the basis states of the bulk Hamiltonian are written into the files wf_spinor_composition_*.dat.

   output_subband_densities{
      max_num     = 10               # number of subband densities to be printed out (minimum value is 1, maximum value is 9999). If max_num is not present, the subband density is written out for each eigenvalue.
      in_one_file = yes/no           # prints out the subband densities into one file (default is yes).
                                     # If no is chosen, for each subband density a separate file is written out. This feature only makes sense for 1D simulations.
   }

   output_sparse_matrix{             # output sparse matrix used in Schroedinger equation solver
      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           # output matrix containing '0' and '1' for zero and non-zero entries of sparse matrix (same for imaginary part, if sparse matrix is complex valued)
              zero_nonzero_absolute  # output matrix containing '0' and '1' for zero and non-zero absolute values of entries of sparse matrix
              all                    # output all types listed above
             "                       #
      structured = no                # whole output is written in subdirectory Quantum/ (default is no)
                 = yes               # In subdirectory Quantum/ additional subdirectories are created to organize the structure of the output files in a meaningful way.
   }

   output_rotated_inverse_mass_tensor { # output components of tensor of the inverse mass in simulation coordinate system
      boxes      = yes/no            # (optional) For each grid point, in 1D two points are printed out to mimic
                                     # abrupt discontinuities at material interfaces (in 2D four points, in 3D eight points)
      structured = no                # whole output is written in subdirectory Quantum/ (default is no)
                 = yes               # In subdirectory Quantum/ additional subdirectories are created to organize the structure of the output files in a meaningful way.
   }

   Quantum models and solver definitions
   Gamma{                            # solves single-band effective mass Schrödinger equation for the Gamma conduction band
      num_ev           = 10          # number of eigenvalues

      Eigensolvers (choose one)
      lapack{}                       # LAPACK eigensolver: solves dense matrix problem (for 1D and small 2D systems only)
                                     # for 1D simulations without periodic boundary conditions a tridiagonal LAPACK solver is used for the single-band Hamiltonian (default)
      arpack{}                       # ARPACK eigensolver
                                     # ARPACK should be faster for large matrices (N > 1000) where only a few eigenvalues are sought (~5-30).
      accuracy         = 1e-6        # for ARPACK: accuracy of eigenvalue (default is: 1e-7)
      iterations       = 200         # for ARPACK: number of iterations for eigenvalue solver (default is: 500)
      preconditioner   = polynomial  # for ARPACK: polynomial preconditioner (slowest, but does not require to specify cutoff energy)
                       = chebyshev   # for ARPACK: Chebyshev preconditioner (requires cutoff energy) (default)
                       = legendre    # for ARPACK: Legendre preconditioner (requires cutoff energy)
      cutoff           = 0.3         # for ARPACK: cutoff energy (refers to the highest for electrons or lowest for holes converged eigenvalue of the last Quantum-Poisson iteration) (default is: 0.3 eV, minimum value is 0.001)
      abs_cutoff       = 2.5         # for ARPACK: absolute cutoff energy (on an absolute energy scale) is used only for the first iteration.
                                     # for ARPACK: If no abs_cutoff energy is specified, the polynomial preconditioner (slowest) is used automatically for the first iteration.
      order_polynomial = 15          # for ARPACK: order of the polynomial used for polynomial preconditioning (default is: 15)
      order_chebyshev  = 20          # for ARPACK: order of the polynomial used for Chebyshev preconditioning (default is: 20)
      order_legendre   = 20          # for ARPACK: order of the polynomial used for Legendre preconditioning (default is: 20)
      }

   # Note: The default behaviour is the following. When the Schrödinger equation is solved for the first time, the polynomial preconditioner is used, because there is no
                    suitable cutoff energy known. In all later Quantum-Poisson iterations the chebyshev preconditioner will be used (up to two times faster) with a cutoff energy
                    slightly above the highest eigenvalue, which was calculated in the last iteration.

Some more comments on the eigenvalue solvers
Memory usage of arpack (and also arpack_inv) only depends on the number of eigenvectors requested, and is not influenced by the type of preconditioner used.
Essentially, for each requested eigenvector (i.e. wave function), additional temporary space corresponding to 2.5 eigenvectors is needed during runtime.
Among the preconditioners, chebyshev preconditioning and legendre preconditioning are comparably fast, but require both the specification of a cutoff energy under (above) which all eigenvalues of interest are assumed to be located.
If this assumption is violated, only spurious parts of the energy spectrum will be computed.
On the other hand, setting the cutoff energy too generous will slow down convergence.
Since the energy spectrum often shifts during the Quantum-Poisson iteration, a more generous initial cutoff energy is also needed for the first Quantum-Poisson iteration step.
If this initial cutoff energy is not provided, much slower but more predictable polynomial preconditioning will be used for the first Quantum-Poisson iteration step instead of the specified chebyshev / legendre preconditioner.
Alternatively, this slower polynomial preconditioning can also be used for the entire Quantum-Poisson iteration.
In this case, no cutoff energies need to be specified at all.
Generally, it is advisable to use polynomial preconditioning when simulating a new structure until the distribution of the eigenvalues, the location of the Fermi level(s), and the required numbers of eigenvalues are better known.
Performance of all preconditioners can be further tuned by changing the order of the respective polynomial used, with optimal values typically lying between 10 and 30.
arpack will terminate once the desired accuracy has been reached or the specified number of iterations has been exceeded.
In the latter case, not all requested eigenvectors may have been calculated, or convergence may be incomplete.


      dispersion{                       # calculate k|| and ksuperlattice (if applicable) dispersion.
                                        # The energy dispersion E(k) along the specified paths and for the specified k space resolutions are completely independent from the k space resolution
                                        # that was used within the self-consistent cycle where the k.p density has been calculated. The latter is specified in k_integration{}.
         path{                          # Calculate dispersion along custom path in k-space. Multiple instances are allowed.
            name = "100"                # name of the dispersion which also defines the name of the output file.
            point{                      # specifies points in the path through k-space. At least two k points have to be defined. Line between two such points is called segment.
               k = [1.0, 0.0, 0.0]      # k-point represented by vector [kx, ky, kz]. The units are [nm-1].
                                        # for 1D simulation the k|| space is a ky-kz plane so ky, kz can be freely choosed.
                                        # kx can only be different from zero, if a periodic boundary condition along the x-direction is defined and the quantum region extends over the whole x-domain.
                                        # for 2D simulation the k|| space is a kz axis so kz can be freely choosed.
                                        # kx can only be different from zero if a periodic boundary condition along the x-direction is defined and the quantum region extends over the whole x-domain.
                                        # ky can only be different from zero if a periodic boundary condition along the y-direction is defined and the quantum region extends over the whole y-domain.
                                        # for 3D simulation the k|| space is empty.
                                        # kx can only be different from zero if a periodic boundary condition along the x-direction is defined and the quantum region extends over the whole x-domain.
                                        # ky can only be different from zero if a periodic boundary condition along the y-direction is defined and the quantum region extends over the whole y-domain.
                                        # kz can only be different from zero if a periodic boundary condition along the z-direction is defined and the quantum region extends over the whole z-domain.
            }                           #
            ...                         #

            spacing             = 0.5   # specifies approximate spacing for intermediate points in the path segments. Excludes num_points. Unit: [nm-1].
            num_points          = 10    # specifies number of points (intermediate + two corner points) for each single path segment. Excludes spacing.
         }                              #

         lines{                         # calculate dispersions along some predefined paths of high symmetry in k-space,
                                        # e.g. [100], [110], [111] and their equivalents (in total maximally 13).
            name = "lines"              # name of the dispersions which also defines the names of the output files.
            spacing             = 0.5   # specifies approximate spacing for intermediate points. Unit: [nm-1].
            k_max               = 1.0   # specifies a maximum absolute value (radius) for the k-vector. Unit: [nm-1].
         }                              #

         full{                          # calculate dispersion in 1D/2D/3D k-space depending on simulation dimensionality and pereodic boundary conditions.
            name = "3D"                 # name of the dispersion which also defines the name of the output file.
            kxgrid{                     # specifies a grid{...} in k-space for a 1D/2D/3D plot of the energy dispersion E(kx, ky, kz).
                                        # allowed only, if simulation is periodic along x-direction and current quantum region extends over the whole x-domain.
               line{                    #
                  pos     = -1          # Unit: [nm-1]
                  spacing = 0.02        # Unit: [nm-1]
               }                        #
               line{                    #
                  pos     = 1           # Unit: [nm-1]
                  spacing = 0.02        # Unit: [nm-1]
               }                        #
               ...                      #
            }                           #
            kygrid{                     # allowed only for 1D simulation or,
                                        # if simulation is periodic along y-direction and current quantum region extends over the whole y-domain.
               ...                      #
            }                           #
            kzgrid{                     # allowed only for 1D/2D simulation or,
                                        # if simulation is periodic along z-direction and current quantum region extends over the whole z-domain.
               ...                      #
            }                           #
         }                              #

         superlattice{                  # (convenience keyword) Calculate superlattice dispersion E(k_SL) along periodic directions. The intervals are set automatically to [-pi/Li, pi/Li], where Li is the simulation domain range along periodic directions with i=x,y,z.
            name = "superlattice"       # name of the dispersion which also defines the name of the output file.
            num_points_x   = 10         # specifies number of points along x direction in k space where dispersion is calculated. The simulation must be periodic along the x direction in direct space.
            num_points_y   = 15         # specifies number of points along y direction in k space where dispersion is calculated. The simulation must be periodic along the y direction in direct space.
            num_points_z   = 20         # specifies number of points along z direction in k space where dispersion is calculated. The simulation must be periodic along the z direction in direct space.
            num_points     = 20         # (convenience keyword) Specifies number of points along all appropriate directions in k space.
         }                              #

         output_dispersions{            # output all defined dispersions.
            max_num        = 10         # number of bands to print out (minimum value is 1, maximum value is 9999)
         }                              #

         output_masses{                 # output effective masses calculated from the dispersions.
            max_num        = 10         # number of bands to print out (minimum value is 1, maximum value is 9999)
         }                              #
      } # end: dispersion{}
   } # end: Gamma{}

   L{                            # solves single-band Schrödinger equation for the L conduction band
      ... (same as Gamma)
   }

   X{                            # solves single-band Schrödinger equation for the X conduction band
      ... (same as Gamma)
   }

   Delta{                        # solves single-band Schrödinger equation for the Delta conduction band
      ... (same as Gamma)
   }

   HH{                           # solves single-band Schrödinger equation for the heavy hole valence band
      ... (same as Gamma)
   }

   LH{                           # solves single-band Schrödinger equation for the light hole valence band
      ... (same as Gamma)
   }

   SO{                           # solves single-band Schrödinger equation for the split-off hole valence band
      ... (same as Gamma)
   }

   kp_6band{                     # solves 6-band k.p Schrödinger equation for the heavy, light and split-off hole valence bands
      ... (same as Gamma)

      kp_parameters{                       # advanced manipulation of k.p parameters from database
         use_Luttinger_parameters = no     # use DKK (Dresselhaus-Kip-Kittel) parameters (L, M, N) (optional, default is: no)
                                    yes    # use Luttinger parameters (gamma1, gamma2, gamma3)
         approximate_kappa        = no     # kappa for zinc blende crystal structure is taken from the database or input file (optional, default is: no)
                                    yes    # force to approximate kappa through others 6-band k.p parameters, even if kappa is given in database or input file
     }

      Eigensolvers (choose one)
      lapack{}                       # LAPACK eigensolver: solves dense matrix problem (for 1D and small 2D systems only)
      arpack{}                       # ARPACK eigensolver (default)
                                     # ARPACK should be faster for large matrices (N > 1000) where only a few eigenvalues are sought (~5-30).

      k_integration{                 # Integration over k_|| space for k.p density calculations (for 1D and 2D only).
                                     # By default the quantum mechanical charge density is calculated (no_density = no).
                                     # Therefore, k_integration{} is required.
                                     # If you do not need a quantum mechanical density, e.g. because you are not interested in a self-consistent simulation,
                                     # the calculation is much faster if you use  (no_density = yes). Then you can omit k_integration{} and only the eigenstates for k_|| = (k_y,k_z) = (0,0) = 0 are calculated.
        relative_size = 0.2          # range of k_|| integration relative to size of Brillouin zone (default is: 1.0, often 0.1-0.2 is sufficient)
        num_points    = 5            # number of k_|| points, where Schrödinger equation has to be solved (in one direction) (default is: 10)
                                     # In 1D, the number of Schrödinger equations that have to be solved depends quadratically on num_points.
                                     # In 2D, the number of Schrödinger equations that have to be solved depends linearly         on num_points.
        num_subpoints = 2            # number of points between two k_|| points, where wave functions and eigenvalues will be interpolated (default is: 5)
        max_symmetry  = no           # do not use symmetry of Brillouin zone to reduce number of k_|| points
                      = C2           # use up to C₂ symmetry of Brillouin zone to reduce number of k_|| points
                      = full         # use full symmetry of Brillouin zone to reduce number of k_|| points (default) (For example for a cubic k space the 1/8th of the zone.)
        force_k0_subspace = yes/no   # If set to yes, k_|| integration in quantum is modified in that only states for point k=0 are computed exactly, whereas all other k-points are computed in the subspace of the k=0 wavefunctions.
                                     # As a result of this approximation, computational speed is much improved (you may even be able to also enlarge the number of eigenvalues). (default is: no)
                                     # In case you are planning to use this approximation for final results, please make sure to check whether the resulting loss of accuracy in density is acceptable.
      }
   }

   kp_8band{                         # solves 8-band k.p Schrödinger equation for the Gamma conduction band and
                                     # the heavy, light and split-off hole valence bands
      num_electrons     = 6          # number of electron eigenvalues
      num_holes         = 12         # number of hole      eigenvalues
      accuracy          = 1e-8       # accuracy of eigenvalue (default is: 1e-7)
      iterations        = 200        # number of iterations for eigenvalue solver (default is: 500)

      kp_parameters{                           # advanced manipulation of k.p parameters from database
         use_Luttinger_parameters = no         # use DKK (Dresselhaus-Kip-Kittel) parameters (L', M=M', N') (optional, default is: no)
                                    yes        # use Luttinger parameters (gamma1', gamma2', gamma3')
         from_6band_parameters    = no         # 8-band k.p parameters are taken from database or input file (optional, default is: no)
                                    yes        # evaluate 8-band k.p parameters from 6-band k.p parameters, Kane parameter EP and temperature dependent band gap Eg
         approximate_kappa        = no         # kappa for zinc blende crystal structure is taken from the database or input file (optional, default is: no)
                                    yes        # force to approximate kappa through others 8-band k.p parameters, even if kappa is given in database or inputfile
         evaluate_S               = no         # S (S1, S2 for wurtzite) k.p parameter(s) is (are) taken from database or input file (optional, default is: no)
                                    yes        # evaluate S (S1, S2 for wurtzite) k.p parameter(s) from effective mass me (me.par, me,perp for wurtzite), Kane parameter(s), spin-orbit coupling(s) and temperature dependent band gap
         rescale_S_to             = 1.0        # set S for zinc blende crystal structure to specified value and rescale EP, L', N+' in order to preserve electron's effective mass (optional)
                                    [1.0,1.0]  # set S1, S2 for wurtzite crystal structure to specified values respectively and rescale EP1, EP2, L1', L2', N1+', N2+' in order to preserve electron's effective masses (optional)
     }

      k_integration{                 # Integration over k_|| space for density calculations (for 1D and 2D only)
         ... (same as kp_6band)
      }

      Eigensolvers (choose one)
      lapack{}                       # LAPACK eigensolver: solves dense matrix problem (for 1D and small 2D systems only)
      arpack_inv{}                   # ARPACK shift invert eigensolver (default)
                                     # ARPACK should be faster for large matrices (N > 1000) where only a few eigenvalues are sought (~5-30).

      Eigensolver parameters
      shift_window      = 0          # for LAPACK: integer value (default is: 0) (lapack only). When LAPACK is used, shifts the window of computed states by the specified number of states up (for positive integers) or down (for negative integers).
                                     #           Adjust when the computed states are not centered around the band gap.
      shift             = 0.2        # for ARPACK: energy shift relative to band edges (default is: 0.1 eV) (arpack_inv only)
      abs_shift         = 2.5        # for ARPACK: energy shift on an absolute energy scale (default is: 0.0 eV) (arpack_inv only)
      linear_solver{                 # for ARPACK: parameters for linear equation solver in shift invert preconditioner (arpack_inv only)
         iterations     = 500        # for ARPACK: number of iterations (default is: 10000). Occasionally, using even larger values than 10000 may be necessary to avoid diagonalization failure.
         abs_accuracy   = 1e-9       # for ARPACK: absolute accuracy (default is: 1e-8 [dimensionless])
         rel_accuracy   = 1e-9       # for ARPACK: relative accuracy (default is: 1e-8 [dimensionless]), 0.0 <= rel_accuracy <= 0.01
         use_cscg       = no         # for ARPACK: yes or  no (default is: no) When arpack_inv is used, 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.
         force_diagonal_preconditioner = no # for ARPACK: yes or  no (default is: no) When arpack_inv is used, forces the use of a slower but more robust diagonal preconditioner.
                                     #           As result, total runtime and stability of the arpack_inv solver may actually become much better and diagonalization failures may be avoided.
      }

      full_band_density = yes/no     # calculate density by filling all states up to fermi level and substracting a positive background charge (lapack only)
  
      shift_min_CB      = 0.0        # (optional) [eV] (default is: 0.0 eV, must be >= 0)
      shift_max_VB      = 0.0        # (optional) [eV] (default is: 0.0 eV, must be <= 0)

                                     # The flag spurious_handling is only for experts and program developers.
                                     # If you do not know how these parameters influence the code, it is very likely that you produce inocrrect results.
                                     # Some of these flags influence each other, and only certain combinations of them are meaningful.
                                     # Some of these flags are only for testing purposes, or are only valid for special input file structures.
                                     # A significant knowledge of spurious solutions, k.p parameters and g factors is required to understand their meanings.

   Note: nextnano++ versions up to 2015-08-19 rescale k.p parameters automatically in order to avoid spurious solutions.
          The behavior in later updates is different, however, and we recommend to not specify spurious_handling at all.
          If you want to restore the previous behavior, please use the default values of spurious_handling apart from the last entry which must be 1.0.
 ==>   spurious_handling = [ 0.0, 1.0, -1.0, 1.0, 0.0, 1.0 ]
       spurious_handling = [         # (optional) 6-dimensional double vector, related to spurious solutions, e.g. rescaling, discretization (e.g. centered finite differences, forward/backward)
                            0.0,     # (optional) If value > 0, forward-/backward differences are used for the first derivative discretization of the P material parameter (Kane parameter) in the 8-band k.p Hamiltonian.
                                     # Default is 0 (= FALSE), i.e. centered differences are used instead. This parameter might affect spurious solutions of the wavefunctions.
                                     # See eq. (1.50) and eq. (1.51) of PhD thesis T. Andlauer.
                            1.0,     # (optional) farband contribution to electrons = value - 1.0  (conduction band g factor, should be a material parameter but it is not) (default is: 1.0)
                                     #                S = 1 + farband contribution, by default farband contribution = 0. This corresponds to setting S=1.
                                     # (optional) It can be useful to set this value to 0.0 (farband contribution = -1). Then it corresponds to setting S=0. Otherwise the default is rescaling to that S=1.
                           -1.0,     # (optional) correction for electron g factor [eV] (default is: -1.0)
                            1.0,     # (optional) If value > 0, rescale everywhere (default is: 1 = TRUE)
                            0.0,     # (optional) If value > 0, upwinding is TRUE (default is: 0 = FALSE) ==> It seems that upwinding is not used at all.
                            1.0,     # (optional) If value > 0, avoid spurious solutions. (default is:  0 = FALSE)
                           ]

          By default, the following procedure is applied (for zincblende only, not for wurtzite):
          In order to avoid spurious solutions, the following rescaling is performed if upwinding = 0, avoid spurious solutions > 0, rescale everywhere > 0 or the following condition are met:
             val1 = S * ( L + 1)
             val2 = S * ( L +  M +  N + 2 ) / 4
             val3 = S * ( L + 2M + 2N + 3 ) / 9
             valmax = MAX(val1,max(val2,val3))

          E_gap is the real band gap.

          IF( .NOT. upWinding) THEN
           Reset S parameter
           IF (valmax > 0 .OR. rescaleEverywhere) THEN
            eq. (1.46) in PhD thesis T. Andlauer (S = A_c):
           
                                  (E_gap + 2/3 Delta_so)
            1/m_c = S + P2 ------------------------------
                            E_gap (E_gap +     Delta_so)

            Set S parameter by adding electronic far band contributions.
            S = 1 + farband contribution

            Calculate new P' parameter from e.g. S'=0 (default) or S'=1.
                                    E_gap (E_gap + Delta_so)
             P' = SQRT( 1/m_c - S' -------------------------- )
                                      (E_gap + 2/3 Delta_so)

            Calculate new L' and N+' parameters and set new value for P parameter.
            (eq. (1.30) in PhD thesis T. Andlauer: L'  = L + P'2 / E_gap)
            (eq. (1.30) in PhD thesis T. Andlauer: N+' = N+ + P'2 / E_gap)
            L'  = L'old  + (P'2 - P2) / ( E_gap)
            N+' = N+'old + (P'2 - P2) / ( E_gap)
  }


   Matrix elements definitions
   interband_matrix_elements{        # calculate interband matrix elements between wave functions of two different bands.
           KP6_Gamma{                     # SUM_k( < KP6_k,i | Gamma_j > ) , with k = 1 .. 6 indexing the component of the six-component k.p wave function
                                     # and i, j indexing the wave function numbers. kp_6band{} and Gamma{} calculation must be present.
         direction = [1,1,0]         # Defines polarization direction. From it a vector of unit length is calculated, which enters the calculation.
                                     # In 1D direction can be omitted, direction = [1,0,0] is then assumed.
      }                              #
      HH_Gamma{ ... }                # < HH_i | Gamma_j >
      LH_Gamma{ ... }                # < LH_i | Gamma_j >
      SO_Gamma{ ... }                # < SO_i | Gamma_j >
      HH_Delta{ ... }                # < HH_i | Delta_j >
      LH_Delta{ ... }                # < LH_i | Delta_j >
      SO_Delta{ ... }                # < SO_i | Delta_j >
      HH_X{ ... }                    # < HH_i | X_j >
      LH_X{ ... }                    # < LH_i | X_j >
      SO_X{ ... }                    # < SO_i | X_j >
      HH_L{ ... }                    # < HH_i | L_j >
      LH_L{ ... }                    # < LH_i | L_j >
      SO_L{ ... }                    # < SO_i | L_j >

      output_matrix_elements      = yes/no #
      output_transition_energies  = yes/no #
   }

   intraband_matrix_elements{        # calculate intraband matrix elements for wave functions within one band.
      Gamma{                         # < Gamma_i | eps.p | Gamma_j >,
                                     # where eps.p is a dot product of eps, which defines light polarization direction, and momentum vector p = i*hbar*grad.
                                     # Internally eps is normalized.
                                     # For further reading: J. H. Davies, "The Physics of Low-Dimensional Semiconductors. An Introduction", 2006, Chapters 10 and 8.
         direction = [1,1,0]         # Defines polarization direction. From it a vector of unit length is calculated, which enters the calculation.
                                     # In 1D direction can be omitted, direction = [1,0,0] is then assumed.
      }                              #
      Delta{ ... }                   #
      X{ ... }                       #
      L{ ... }                       #
      HH{ ... }                      #
      LH{ ... }                      #
      SO{ ... }                      #
      KP6{ ... }                     # SUM_k( < KP6_k,i | eps.p | KP6_k,j > ), k = 1..6
      KP8{ ... }                     # SUM_k( < KP8_k,i | eps.p | KP8_k,j > ), k = 1..8

      output_matrix_elements      = yes/no #
      output_transition_energies  = yes/no #
      output_oscillator_strengths = yes/no # Currently, only a simple formula is used, i.e. the free electron mass is used and not the "real" effective mass one.
   }

   dipole_moment_matrix_elements{    # calculate dipole moment matrix elements for wave functions within one band.
      Gamma{                         # < Gamma_i | eps.d | Gamma_j >,
                                     # where eps.d is a dot product of eps, which defines light polarization direction, and dipole moment vector d = e*r.
                                     # Internally eps is normalized.
                                     # For further reading: J. H. Davies, "The Physics of Low-Dimensional Semiconductors. An Introduction", 2006, Chapters 10 and 8.
         direction = [1,1,0]         # Defines polarization direction. From it a vector of unit length is calculated, which enters the calculation.
                                     # In 1D direction can be omitted, direction = [1,0,0] is then assumed.
      }                              #
      Delta{ ... }                   #
      X{ ... }                       #
      L{ ... }                       #
      HH{ ... }                      #
      LH{ ... }                      #
      SO{ ... }                      #
      KP6{ ... }                     # SUM_k( < KP6_k,i | eps.d | KP6_k,j > ), k = 1..6
      KP8{ ... }                     # SUM_k( < KP8_k,i | eps.d | KP8_k,j > ), k = 1..8

      output_matrix_elements      = yes/no #
      output_transition_energies  = yes/no #
      output_oscillator_strengths = yes/no # Currently, only a simple formula is used, i.e. the free electron mass is used and not the "real" effective mass one.
   }

   transition_energies{              # Calculate transition energies (energy difference) between two states in certain bands.
                                     # Use this if you want to calculate transition energies but but do not want to calculate the matrix elements.
                                     # Note that the matrix elements defined above also include specifiers for transition energies, i.e. output_transition_energies  = yes
      Gamma{}                        #
      KP6_Gamma{}                    #
      HH_Gamma{}                     #
      LH_Gamma{}                     #
      SO_Gamma{}                     #
      Delta{}                        #
      HH_Delta{}                     #
      LH_Delta{}                     #
      SO_Delta{}                     #
      X{}                            #
      HH_X{}                         #
      LH_X{}                         #
      SO_X{}                         #
      L{}                            #
      HH_L{}                         #
      LH_L{}                         #
      SO_L{}                         #
      HH{}                           #
      LH{}                           #
      SO{}                           #
      KP6{}                          #
      KP8{}                          #
   }
 

   calculate_lifetime{               # calculate the lifetimes of the state due LO phonon scattering
      phonon_energy = 0.036          # LO phonon energy [eV]
   }                                 # R. Ferreira, G. Bastard, Physical Review B 40, 1074 (1989) and Section 2.1.3 of the PhD thesis of G. Scarpa, Technische Universität München.
                                    

      For more details, see this tutorial: Scattering times for electrons in unbiased and biased single and multiple quantum wells


   bulk_dispersion{                  # calculate bulk k.p dispersion of the material at a specific position in the simulation domain.
      path{                          # calculate bulk k.p dispersion along custom path in k-space. Multiple instances are allowed.
         name = "from_Gamma_to_L"    # name of the dispersion which also defines the name of the output file.
         position{                   # specifies the point (x,y,z) in the simulation domain, where the dispersion has to be calculated.
            x = 5.5                  # for 1D simulations (x)
            y = 10.0                 # for 2D simulations (x,y)
            z = -1.1                 # for 3D simulations (x,y,z)
         }                           #
         shift_holes_to_zero = yes   # shifts the whole dispersion, so that the energy for the Gamma point for the highest hole band is equal to 0.0 eV.
                             = no    # default
         point{                      # specifies points in the path through k-space. At least two k points have to be defined. Line between two such points is called segment.
            k = [1.0, 0.0, 0.0]      # k-point represented by vector [kx, ky, kz]. The units are [nm-1].
         }                           #
         ...                         #

         spacing             = 0.5   # specifies approximate spacing for intermediate points in the path segments. Excludes num_points. Unit: [nm-1].
         num_points          = 10    # specifies number of points (intermediate + two corner points) for each single path segment. Excludes spacing.
      }                              #

      lines{                         # calculate bulk k.p dispersions along some predefined paths of high symmetry in k-space,
                                     # e.g. [100], [110], [111] and their equivalents (in total 13). Multiple instances are allowed.
         name = "lines"              # name of the dispersions which also defines the names of the output files.
         position{                   # specifies the point (x,y,z) in the simulation domain, where the dispersions have to be calculated.
            x = 5.5                  # for 1D simulations (x)
            y = 10.0                 # for 2D simulations (x,y)
            z = -1.1                 # for 3D simulations (x,y,z)
         }                           #
         shift_holes_to_zero = yes   # shifts the whole dispersion, so that the energy for the Gamma point for the highest hole band is equal to 0.0 eV.
                             = no    # default
         spacing             = 0.5   # specifies approximate spacing for intermediate points. Unit: [nm-1].
         k_max               = 1.0   # specifies a maximum absolute value (radius) for the k-vector. Unit: [nm-1].
      }                              #

      full{                          # calculate bulk k.p dispersion in 3D k-space. Multiple instances are allowed.
         name = "3D"                 # name of the dispersion which also defines the name of the output file.
         position{                   # specifies the point (x,y,z) in the simulation domain, where the dispersion has to be calculated.
            x = 5.5                  # for 1D simulations (x)
            y = 10.0                 # for 2D simulations (x,y)
            z = -1.1                 # for 3D simulations (x,y,z)
         }                           #
         shift_holes_to_zero = yes   # shifts the whole dispersion, so that the energy for the Gamma point for the highest hole band is equal to 0.0 eV.
                             = no    # default.
         kxgrid{                     # specifies a grid{...} in 3D k-space for a 3D plot of the energy dispersion E(kx, ky, kz).
            line{                    #
               pos     = -1          # Unit: [nm-1]
               spacing = 0.02        # Unit: [nm-1]
            }                        #
            line{                    #
               pos     = 1           # Unit: [nm-1]
               spacing = 0.02        # Unit: [nm-1]
            }                        #
            ...                      #
         }                           #
         kygrid{                     #
            ...                      #
         }                           #
         kzgrid{                     #
            ...                      #
         }                           #
      }                              #

      output_bulk_dispersions{}      # output all defined bulk k.p dispersions.
      output_masses{}                # output effective masses calculated from the dispersions.

   } # end: bulk_dispersion{}

 } # end: region{}

 Many body effects
 exchange_correlation{
   type             = lda            # include exchange-correlation effects in the LDA   approximation (Local         Density Approximation)
                    = lsda           # include exchange-correlation effects in the LSDA approximation (Local Spin Density Approximation)
   initial_spin_pol = 1.0            # breaks spin up/down symmetry if no magnetic field is present (default is: 0)
   output_spin_polarization{}        # output spin polarization [dimensionless]
   output_exchange_correlation{}     # output exchange correlation potentials [eV]
 }

}