DeviceHuckelCalculator

class DeviceHuckelCalculator(electrode_calculators=None, basis_set=None, pair_potentials=None, numerical_accuracy_parameters=None, iteration_control_parameters=None, device_algorithm_parameters=None, weighting_scheme=None, poisson_solver=None, contour_parameters=None, electrode_voltages=None, electrode_temperatures=None, checkpoint_handler=None, spin_polarization=None, dynamical_matrix_parameters=None, hamiltonian_derivatives_parameters=None, parallel_parameters=None)

Class for representing calculations using the extended Huckel Model for DeviceConfigurations.

Parameters:

  • electrode_calculators (tuple of HuckelCalculator) – A tuple of HuckelCalculator objects containing a calculator for each electrode.

  • basis_set (list of HuckelBasisParameters) – An object describing the basis set used for the Extended-Huckel calculation.
    Default: HoffmannHuckelParameters.All

  • pair_potentials (PairPotential) – The repulsive pair potentials used for total energy and force calculations.
    Default: No pair potential

  • numerical_accuracy_parameters (NumericalAccuracyParameters) –

    The NumericalAccuracyParameters used for the self-consistent Huckel calculation.
    Default:

    NumericalAccuracyParameters(
    density_mesh_cutoff=10.0*Hartree,
    k_point_sampling=MonkhorstPackGrid(1, 1, 100),
    radial_step_size=0.01*Angstrom,
    density_cutoff=1.0e-6,
    interaction_max_range=10*Angstrom,
    number_of_reciprocal_points=1024,
    reciprocal_energy_cutoff=1250.0*Hartree,
    occupation_method=FermiDirac(300.0*Kelvin))

  • iteration_control_parameters (IterationControlParameters) – The IterationControlParameters used for the self- consistent Huckel calculation. For non-self-consistent calculations set this parameter to NonSelfconsistent.
    Default: NonSelfconsistent.

  • device_algorithm_parameters (DeviceAlgorithmParameters) –

    The DeviceAlgorithmParameters used for the device simulation.
    Default:

    DeviceAlgorithmParameters(
    initial_density_type=NeutralAtom(
        electrode_constraint_length=10.0*Angstrom),
    electrode_constraint=ElectrodeConstraint.Off,
    self_energy_calculator_real=RecursionSelfEnergy(
        storage_strategy=SaveInMemory(),
        tolerance=1.0e-13,
        maximum_iteration=400),
    self_energy_calculator_complex=RecursionSelfEnergy(
        storage_strategy=SaveInMemory(),
        tolerance=1.0e-13,
        maximum_iteration=400),
    non_equilibrium_method=GreensFunction(),
    equilibrium_method=GreensFunction(),
    store_grids=True,
    store_basis_on_grid=Automatic,
    scf_restart_step_length=0.1*Angstrom,
    enforce_different_electrodes=False)

    Note that the electrode constraint for a SurfaceConfiguration will be set to ElectrodeConstraint.DensityMatrix(electrode_constraint_length=10.0*Angstrom.

  • weighting_scheme (HoffmannWeighting | WolfsbergWeighting) – The weighting scheme used for calculating off-site matrix elements of the Huckel Hamiltonian.
    Default: WolfsbergWeighting

  • poisson_solver (DirectSolver | MultigridSolver | FastFourier2DSolver) – The Poisson solver used to determine the electrostatic potential.
    Default: Configuration dependent. FastFourier2DSolver for a DeviceConfiguration without any metallic or dielectric SpatialRegion. For others: MultigridSolver. The default boundary conditions are [PeriodicBoundaryCondition, PeriodicBoundaryCondition, DirichletBoundaryCondition].

  • contour_parameters (ContourParameters) –

    The parameters used for the complex contour integration.
    Default:

    ContourParameters(
    equilibrium_contour=SemiCircleContour(
        integral_lower_bound=1.5*Hartree,
        circle_eccentricity=0.3,
        logarithmic_bunching=0.3,
        circle_points=30,
        fermi_line_points=10,
        fermi_function_poles=8),
    non_equilibrium_contour=RealAxisContour(
        real_axis_point_density=0.001*Hartree,
        real_axis_infinitesimal=0.001*Hartree,
        real_axis_kbt_padding_factor=5.0),
    method=DoubleContour())

  • electrode_voltages (PhysicalQuantity of type electrical potential) – The voltages applied to the two electrodes.
    Default: (0.0, 0.0) * Volt

  • electrode_temperatures (Sequence of PhysicalQuantity of type temperature) – The temperatures used in the Fermi-Dirac distribution of the electrodes. They represent the physical temperatures used for the integration of the transmission spectra.
    Default: (300, 300) * Kelvin

  • checkpoint_handler (CheckpointHandler) – The CheckpointHandler used for specifying the save-file and the time interval. between saving the calculation during the scf-loop.
    Default: A default CheckpointHandler object.

  • spin_polarization (Unpolarized | Polarized | Noncollinear | SpinOrbit) – Flag indicating if the calculation is spin-polarized or not.
    Default: Unpolarized

  • dynamical_matrix_parameters (not used) –
    Deprecated: from v2015, see the DynamicalMatrix analysis object.

  • hamiltonian_derivatives_parameters (not used) –
    Deprecated: from v2015, see the HamiltonianDerivatives analysis object.

  • parallel_parameters (ParallelParameters) – The parameters used to control parallelization options.
    Default: ParallelParameters(processes_per_saddle_search=1)

basisSet()
Returns:

The basis set.

Return type:

list of HuckelBasisParameters

checkpointHandler()
Returns:

The CheckpointHandler used for specifying the save-file and the time interval. between saving the calculation during the scf-loop.

Return type:

CheckpointHandler

contourParameters()
Returns:

The contour integral parameters.

deviceAlgorithmParameters()
Returns:

The device algorithm parameters.

Return type:

DeviceAlgorithmParameters

dynamicalMatrixParameters()

This method is deprecated.

electrodeCalculators()
Returns:

The electrode calculator of each electrode.

Return type:

list of SemiEmpiricalCalculator

electrodeTemperatures()
Returns:

The electrode temperatures.

Return type:

Sequence of PhysicalQuantity of type temperature.

electrodeVoltages()
Returns:

The electrode voltages as PhysicalQuantity of length 2.

Return type:

PhysicalQuantity of type electrical potential

hamiltonianDerivativesParameters()

This method is deprecated.

hamiltonianParametrization()
Returns:

The Hamiltonian parametrization associated with a semi-empirical calculator.

Return type:

SemiEmpiricalHamiltonianParametrization

isConverged()
Returns:

True when the call to “update()” resulted in a converged SCF loop.

Return type:

bool

iterationControlParameters()
Returns:

The IterationControlParameters used for a self-consistent calculation. For non-self-consistent calculations this parameter is NonSelfconsistent.

Return type:

IterationControlParameters

metatext()
Returns:

The metatext of the object or None if no metatext is present.

Return type:

str | None

nlinfo()
Returns:

The nlinfo.

Return type:

dict

numberOfSpins()
Returns:

The number of spins.

Return type:

int

numericalAccuracyParameters()
Returns:

The NumericalAccuracyParameters used for the self-consistent Huckel calculation.

Return type:

NumericalAccuracyParameters

pairPotentials()
Returns:

The repulsive pair potentials used for total energy and force calculations.

Return type:

PairPotential

parallelParameters()
Returns:

The parameters used to control parallelization options.

Return type:

ParallelParameters

poissonSolver()
Returns:

The Poisson solver used to determine the electrostatic potential.

Return type:

DirectSolver | MultigridSolver | FastFourierSolver | FastFourier2DSolver

setCheckpointHandler(checkpoint_handler)

Set the the checkpoint handler.

Parameters:

checkpoint_handler (CheckpointHandler) – The CheckpointHandler used for specifying the save-file and the time interval. between saving the calculation during the scf-loop.

setHamiltonianParametrization(hamiltonian_parametrization)

Set and check the Hamiltonian parametrization.

Parameters:

hamiltonian_parametrization (HamiltonianParametrization) – An object describing the Hamiltonian parametrization for the semi-empirical calculation.

setIterationControlParameters(iteration_control_parameters)

Set the iteration control parameters.

Parameters:

iteration_control_parameters (IterationControlParameters) – The IterationControlParameters used for a self-consistent calculation. For non-self-consistent calculations this parameter is NonSelfconsistent.

setMetatext(metatext)

Set a given metatext string on the object.

Parameters:

metatext (str | None) – The metatext string that should be set. A value of “None” can be given to remove the current metatext.

setNumericalAccuracyParameters(numerical_accuracy_parameters)

Set the numerical accuracy parameters.

Parameters:

numerical_accuracy_parameters (NumericalAccuracyParameters) – The NumericalAccuracyParameters used for the self-consistent Huckel calculation.

setPairPotentials(pair_potentials)

Set the pair potentials.

Parameters:

pair_potentials (PairPotential) – The repulsive pair potentials used for total energy and force calculations.

setParallelParameters(parallel_parameters)

Set the parallel paramters.

Parameters:

parallel_parameters (ParallelParameters) – The parameters used to control parallelization options.

setPoissonSolver(poisson_solver)

Set the poisson solver.

Parameters:

poisson_solver (DirectSolver | MultigridSolver | FastFourierSolver | FastFourier2DSolver) – The Poisson solver used to determine the electrostatic potential.

setSpinPolarization(spin_polarization)

Set the spin polarization.

Parameters:

spin_polarization (Unpolarized | Polarized | Noncollinear | SpinOrbit) – Flag indicating if the calculation is spin-polarized or not.

spinPolarization()
Returns:

Flag indicating if the calculation is spin-polarized or not.

Return type:

Unpolarized | Polarized | Noncollinear | SpinOrbit

uniqueString()

Return a unique string representing the state of the object.

upgrade(configuration)

Private method for updating the calculator from the configuration, if it is possible @private

versionUsed()
Returns:

The version of ATK used to update the calculator.

Return type:

str

weightingScheme()
Returns:

The weighting scheme used for calculating off-site matrix elements of the Huckel Hamiltonian.

Return type:

HoffmannWeighting | WolfsbergWeighting

Attention

The DeviceHuckelCalculator is being deprecated. Use the DeviceSemiEmpiricalCalculator with the HuckelHamiltonianParametrization instead.

Usage Examples

Define a DeviceHuckelCalculator with user defined NumericalAccuracyParameters, MultigridSolver, and DoubleContourIntegralParameters

numerical_accuracy_parameters = NumericalAccuracyParameters(
    density_mesh_cutoff=10.*Units.Hartree,
    k_point_sampling=(3,2,100),
    interaction_max_range=10.*Angstrom,
    )

electrode_poisson_solver = MultigridSolver(
    boundary_conditions=[PeriodicBoundaryCondition,
                         PeriodicBoundaryCondition,
                         PeriodicBoundaryCondition]
    )

poisson_solver = MultigridSolver(
    boundary_conditions=[PeriodicBoundaryCondition,
                         PeriodicBoundaryCondition,
                         DirichletBoundaryCondition]
    )

electrode_calculator = HuckelCalculator(
    numerical_accuracy_parameters=numerical_accuracy_parameters,
    poisson_solver=electrode_poisson_solver
    )

contour_parameters = DoubleContourIntegralParameters(
    integral_lower_bound=5.0*Units.Hartree
    )

device_calculator = DeviceHuckelCalculator(
    electrode_calculators=[electrode_calculator,electrode_calculator],
    contour_parameters=contour_parameters,
    numerical_accuracy_parameters=numerical_accuracy_parameters,
    poisson_solver=poisson_solver,
    electrode_voltages=(0.2*Volt, -0.3*Volt)
    )

Perform a voltage sweep, and calculate I-V characteristics

calculator = DeviceHuckelCalculator()
device_configuration = DeviceConfiguration(...)

# Define voltages for voltage ramp, [0.0,0.1, ..., 1.0]*Volt
voltages = numpy.linspace(0.0,1.0,11)*Volt
for v in voltages:

    # Set the calculator on the configuration using the old calculation as starting input.
    device_configuration.setCalculator(
        calculator(electrode_voltages=(0*Volt,v)),
        initial_state=device_configuration,
        )

    # Calculate the transmission
    t = TransmissionSpectrum(device_configuration)

    # Calculate the current.
    current = t.current()
    print t.bias(), t.current()

Perform a gate bias scan

calculator = DeviceHuckelCalculator()
device_configuration = DeviceConfiguration(...)
metal_region = BoxRegion(...)

# Define gate_voltages for scan, [0.0,0.1, ..., 1.0]*Volt
gate_voltage=numpy.linspace(0.0,1.0,11)*Volt
for v in gate_voltage:
    device_configuration.setMetallicRegions(
        [metallic_region(value = gate_voltage)]
        )
    # Set the calculator on the configuration using the old calculation as starting input.
    device_configuration.setCalculator(
        calculator(),
        initial_state=device_configuration,
    )

    # Calculate the transmission
    t = TransmissionSpectrum(device_configuration)

    # Calculate the conductance
    print t.bias(), t.conductance()

Notes

The parameters for the constructor of a DeviceHuckelCalculator object and the parameters of its electrode calculators must fulfill the following conditions: In case the user does not set an electrode parameter, QuantumATK will generate that parameter using the rules below.

  • The NumericalAccuracyParameters must be the same for the electrodes and the device. The central region of the device does not use k-points in the C-direction and this parameter is only used for the electrodes. The electrodes need a very dense k-point sampling in the C direction.

  • The poisson_solver must be set to either the FastFourier2DSolver (default, and normally recommended) or the MultigridSolver or DirectSolver in case electrostatic gates and/or dielectric regions are included. The same boundary conditions in the A and B directions must be used for the electrodes as for the device calculator. In the C directions the user setting is ignored and the program always uses PeriodicBoundaryCondition for the electrodes and DirichletBoundaryCondition for the device.

  • The electrode_voltages give rise to a shift of the Fermi levels of the electrodes by \(-e V_\mathrm{bias}\) , where \(V_\mathrm{bias}\) is the applied bias. Thus, a higher \(V_\mathrm{bias}\) on the right electrode than the left gives rise to an electron flow from left to right, corresponding to an electrical current from right to left (the current will be negative in this case; see TransmissionSpectrum).

For the details of the extended-Hückel model, see the chapter on Semi Empirical.