DeviceLCAOCalculator

class DeviceLCAOCalculator(electrode_calculators=None, basis_set=None, exchange_correlation=None, numerical_accuracy_parameters=None, iteration_control_parameters=None, device_algorithm_parameters=None, poisson_solver=None, contour_parameters=None, electrode_voltages=None, electrode_temperatures=None, checkpoint_handler=None, dynamical_matrix_parameters=None, correction_extension=None, hamiltonian_derivatives_parameters=None, parallel_parameters=None)

The constructor for the DeviceLCAOCalculator.

Parameters:
  • electrode_calculators (list of LCAOCalculator) – Two calculators, one for each electrode.
  • basis_set (list | tuple | BasisSet) –

    An object describing the basis set used for the LCAO calculation. This keyword can be given in three ways.

    1. As a single BasisSet object.
    2. As a tuple (string, BasisSet). The string must match a tag on the atom in order to be applied.
    3. As a sequence of entries matching either of the above formats


    Default: BasisGGASG15.Medium

  • exchange_correlation (ExchangeCorrelation) – The exchange correlation functional for this calculation.
    Default: GGA.PBE
  • numerical_accuracy_parameters (NumericalAccuracyParameters) –

    The numerical accuracy parameters used for the DFT calculation.
    Default:

    NumericalAccuracyParameters(
        density_mesh_cutoff=75*Hartree,
        k_point_sampling=MonkhorstPackGrid(1, 1, 100),
        radial_step_size=0.001*Bohr,
        density_cutoff=1e-6,
        interaction_max_range=20*Angstrom,
        number_of_reciprocal_points=1024,
        reciprocal_energy_cutoff=1250*Hartree,
        occupation_method=FermiDirac(1000*Kelvin))
    
  • iteration_control_parameters (IterationControlParameters | NonSelfconsistent) –

    The iteration control parameters used for the DFT calculation. For non-self-consistent calculations set this parameter to NonSelfconsistent.
    Default:

    IterationControlParameters(
        tolerance=1e-4,
        max_steps=100,
        algorithm=PulayMixer(),
        damping_factor=0.1,
        number_of_history_steps=20,
        start_mixing_after_step=0,
        mixing_variable=HamiltonianVariable,
        linear_dependence_threshold=0.0,
        preconditioner=Preconditioner.Off)
    
  • 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=1e-13,
            maximum_iteration=400),
        self_energy_calculator_complex=RecursionSelfEnergy(
            storage_strategy=SaveInMemory(),
            tolerance=1e-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.

  • 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.
  • dynamical_matrix_parameters (not used) –

    Deprecated since version 2015: See the DynamicalMatrix analysis object.

  • correction_extension (GrimmeDFTD2 | GrimmeDFTD3) – The correction extension to used, when calculating energy, forces and stress.
    Default: None.
  • hamiltonian_derivatives_parameters (not used) –

    Deprecated since version 2015: 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
checkpointHandler()
Returns:The checkpoint handler.
Return type:CheckpointHandler
contourParameters()
Returns:The contour parameters.
Return type:ContourParameters
correctionExtension()
Returns:The correction extension or None if not set.
Return type:GrimmeDFTD2 | GrimmeDFTD3 | None
deviceAlgorithmParameters()
Returns:The device algorithm parameters.
Return type:DeviceAlgorithmParameters
dynamicalMatrixParameters()

Return the DynamicalMatrixParameters. Deprecated.

Returns:None since the class DynamicalMatrixParameters is deprecated.
Return type:None
electrodeCalculators()
Returns:The electrode calculators.
Return type:list of LCAOCalculator
electrodeTemperatures()
Returns:The electrode temperatures.
Return type:Sequence of PhysicalQuantity of type temperature.
electrodeVoltages()
Returns:The electrode voltages.
Return type:PhysicalQuantity of type electrical potential
exchangeCorrelation()
Returns:The exchange-correlation.
Return type:ExchangeCorrelation
hamiltonianDerivativesParameters()

Return the HamiltonianDerivativesParameters. Deprecated.

Returns:None since the class HamiltonianDerivativesParameters is deprecated.
Return type:None
isConverged()
Returns:True when the call to “update()” resulted in a converged SCF loop.
Return type:bool
iterationControlParameters()
Returns:The iteration control parameters.
Return type:IterationControlParameters
metatext()
Returns:The metatext of the object or None if no metatext is present.
Return type:str | unicode | None
numericalAccuracyParameters()
Returns:The numerical accuracy parameters.
Return type:NumericalAccuracyParameters
parallelParameters()
Returns:The parallel parameters object.
Return type:ParallelParameters
poissonSolver()
Returns:The Poisson solver set on the calculator.
Return type:DirectSolver | MultigridSolver | FastFourierSolver | FastFourier2DSolver
setBasisSet(basis_set)

Set the basis set.

Parameters:basis_set (list) – The basis set to use. The basis set is given as a sequence of BasisSet objects for each element in the configuration.
setCheckpointHandler(checkpoint_handler)

Set the checkpoint handler.

Parameters:checkpoint_handler (CheckpointHandler) – The checkpoint handler to use.
setCorrectionExtension(correction_extension)

Set the iteration correction extension.

Parameters:correction_extension (GrimmeDFTD2 | GrimmeDFTD3 | None) – The correction extension to use.
setExchangeCorrelation(exchange_correlation)

Set the exchange-correlation.

Parameters:exchange_correlation (ExchangeCorrelation) – The exchange-correlation to use.
setIterationControlParameters(iteration_control_parameters)

Set the iteration control parameters.

Parameters:iteration_control_parameters (IterationControlParameters) – The iteration control parameters to use.
setMetatext(metatext)

Set a given metatext string on the object.

Parameters:metatext (str | unicode | 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 numerical accuracy parameters to use.
setParallelParameters(parallel_parameters)

Method for setting the parallel parameters.

Parameters:parallel_parameters (ParallelParameters | None) – The parallel parameters to set. If None a default version of the parameters is used.
setPoissonSolver(poisson_solver)

Set the poisson solver.

Parameters:poisson_solver (DirectSolver | MultigridSolver | FastFourierSolver | FastFourier2DSolver) – The Poisson solver to set on the calculator.
upgrade(configuration)
versionUsed()
Returns:The version of ATK used to update the calculator.
Return type:str

Usage Examples

Define a DeviceLCAOCalculator with user defined NumericalAccuracyParameters, MultigridSolver, and DoubleContourIntegralParameters:

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

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

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

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

contour_parameters = DoubleContourIntegralParameters(
    integral_lower_bound=5.0*Hartree
    )

device_calculator = DeviceLCAOCalculator(
    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 = DeviceLCAOCalculator()
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 = DeviceLCAOCalculator()
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 DeviceLCAOCalculator object and the parameters of its electrode calculators must fulfill the conditions given below. In case the user does not set an electrode parameter, QuantumATK will automatically generate that parameter using these rules:

  • 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 parameter must be set to either the FastFourier2DSolver (default, and usually 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 direction, the user setting is ignored and the program always uses PeriodicBoundaryCondition for the electrodes and DirichletBoundaryCondition for the device.
  • The electrode_voltages parameter gives rise to a shift of the Fermi levels of the electrodes by \(-e \cdot 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).