Values

class autode.values.Allocation(*args, **kwargs)

__init__(x, units: Unit | str = Unit(mb))

Allocation of memory or disk, must be non-negative

Parameters:

x (float)

Keyword Arguments:

units (autode.units.Unit | str | None)

implemented_units: Sequence[Unit] = [Unit(byte), Unit(mb), Unit(gb), Unit(tb)]

class autode.values.Angle(*args, **kwargs)

Angle in some units, defaults to radians

__init__(value, units=Unit(rad))

Value constructor

Keyword Arguments:

units (autode.units.Unit | str | None)

implemented_units: Sequence[Unit] = [Unit(rad), Unit(°)]

class autode.values.Coordinate(*args, units=Unit(Å))

implemented_units: List[Unit] = [Unit(Å), Unit(bohr), Unit(nm), Unit(pm), Unit(m)]

property x

x component in Cartesian space

property y

y component in Cartesian space

property z

z component in Cartesian space

class autode.values.Coordinates(input_array, units=Unit(Å))

implemented_units: List[Unit] = [Unit(Å), Unit(bohr), Unit(nm), Unit(pm), Unit(m)]

class autode.values.Distance(*args, **kwargs)

Distance in some units, defaults to Angstroms

__init__(value, units=Unit(Å))

Value constructor

Keyword Arguments:

units (autode.units.Unit | str | None)

implemented_units: Sequence[Unit] = [Unit(Å), Unit(bohr), Unit(pm), Unit(nm), Unit(m)]

class autode.values.Energies(*args: Energy)

List of energies on an identical geometry/structure

__init__(*args: Energy)

Parameters:

*args (autode.values.Energy)

append(other: Energy) → None

Add another energy to this list, if it does not already appear

copy()

Return a shallow copy of the list.

first(energy_type: Type[Energy]) → TypeEnergy | None

Return the last instance of a particular energy type in these list of energies

Returns:

Energy

Return type:

(autode.values.Energy | None)

property first_potential: PotentialEnergy | None

First potential energy in this list

last(energy_type: Type[Energy]) → TypeEnergy | None

Return the last instance of a particular energy type in these list of energies

Returns:

Energy

Return type:

(autode.values.Energy | None)

property last_potential: PotentialEnergy | None

First potential energy in this list

class autode.values.Energy(*args, **kwargs)

Type of energy in some units e.g. Potential, Free etc. defaults to Hartrees

__init__(value: Any, units: Unit | str = Unit(Ha), method: Method | None = None, keywords: Keywords | None = None, estimated: bool = False)

Energy as a value. Has a method_str attribute which is set using a method used to calculate the energy along with any keywords e.g. PBE0/def2-SVP used to calculate it

Parameters:

• method (autode.wrappers.methods.Method)

• keywords (autode.wrappers.keywords.Keywords | None) – Set of keywords which this energy has been calculated at

• estimated (bool) – Has this energy been estimated rather than calculated

implemented_units: Sequence[Unit] = [Unit(Ha), Unit(kcal mol-1), Unit(kJ mol-1), Unit(eV), Unit(J)]

set_method_str(method: Method | None, keywords: Keywords | None) → None

class autode.values.EnergyArray(input_array: ndarray | Sequence, units: Unit | str | None = None)

implemented_units: List[Unit] = [Unit(Ha), Unit(eV), Unit(kcal mol-1), Unit(kJ mol-1), Unit(J)]

class autode.values.Enthalpy(H)

class autode.values.EnthalpyCont(*args, **kwargs)

Enthalpy contribution: H = E + H_cont

class autode.values.ForceConstant(*args, **kwargs)

__init__(value, units=Unit(Ha Å^-2))

Value constructor

Keyword Arguments:

units (autode.units.Unit | str | None)

implemented_units: Sequence[Unit] = [Unit(Ha Å^-2), Unit(Ha a0^-2), Unit(J m^-2), Unit(J ang^-2), Unit(J m^-2 kg^-1)]

class autode.values.FreeEnergy(*args, **kwargs)

(Gibbs) Free Energy (G)

class autode.values.FreeEnergyCont(*args, **kwargs)

Free energy contribution: G = E + G_cont

class autode.values.Frequency(*args, **kwargs)

__init__(value, units=Unit(cm ^ -1))

Value constructor

Keyword Arguments:

units (autode.units.Unit | str | None)

implemented_units: Sequence[Unit] = [Unit(cm^-1), Unit(s^-1)]

property is_imaginary: bool

Imaginary frequencies are quoted as negative for simplicity

property real: Frequency

A frequencies real (positive) value

class autode.values.Gradient(input_array, units=Unit(Ha(Å) ^ -1))

implemented_units: List[Unit] = [Unit(Ha(Å)^-1), Unit(Ha(bohr)^-1), Unit(eV(Å)^-1), Unit(kcal mol-1(Å)^-1)]

class autode.values.GradientRMS(*args, **kwargs)

__init__(x, units: Unit | str = Unit(Ha(Å) ^ -1))

Value constructor

Keyword Arguments:

units (autode.units.Unit | str | None)

implemented_units: Sequence[Unit] = [Unit(Ha(Å)^-1), Unit(Ha(bohr)^-1), Unit(eV(Å)^-1)]

class autode.values.MWDistance(*args, **kwargs)

Mass-weighted distance in some units, defaults to angstroms amu^(1/2)

__init__(value, units=Unit(Å amu^1/2))

Value constructor

Keyword Arguments:

units (autode.units.Unit | str | None)

implemented_units: Sequence[Unit] = [Unit(Å amu^1/2)]

class autode.values.Mass(*args, **kwargs)

__init__(value, units=Unit(amu))

Value constructor

Keyword Arguments:

units (autode.units.Unit | str | None)

implemented_units: Sequence[Unit] = [Unit(amu), Unit(kg), Unit(m_e)]

class autode.values.MomentOfInertia(input_array, units=Unit(amu Å^2))

implemented_units: List[Unit] = [Unit(amu Å^2), Unit(kg m^2)]

class autode.values.PotentialEnergy(*args, **kwargs)

Potential electronic energy (0 K, no zero-point energy)

class autode.values.Temperature(*args, **kwargs)

Temperature in some units, defaults to Kelvin

__init__(value, units=Unit(kelvin))

Value constructor

Keyword Arguments:

units (autode.units.Unit | str | None)

implemented_units: Sequence[Unit] = [Unit(kelvin), Unit(celsius)]

class autode.values.Value(*args, **kwargs)

Abstract base class for a value with a defined set of units, along with perhaps other attributes and methods

x = Value(0.0)

__init__(x: Any, units: Unit | str | None = None)

Value constructor

Keyword Arguments:

units (autode.units.Unit | str | None)

copy()

Copy this value, with its units

implemented_units: Sequence[Unit] = []

to(units)

Convert this value to a new unit, returning a copy

Return type:

(autode.values.Value)

Raises:

(TypeError) –

class autode.values.ValueArray(input_array: ndarray | Sequence, units: Unit | str | None = None)

Abstract base class for an array of values, e.g. gradients or a Hessian

implemented_units: List[Unit] = []

to(units) → Any

Convert this array to a new unit, returning a copy

Return type:

(autode.values.ValueArray)

Raises:

(TypeError) –

to_(units) → None

Convert this array into a set of new units, inplace. This will not copy the array

Raises:

(TypeError) –

autode.values.method_string(method: Method | None, keywords: Keywords | None) → str

Create a method string for a method and the keywords