matscipy.calculators.ewald.calculator

Pair potential + Ewald summation

Classes

`Ewald`()	Ewal summation calculator.
`EwaldShortRange`(alpha, cutoff)	Short range term of Ewald summation.

class matscipy.calculators.ewald.calculator.EwaldShortRange(alpha, cutoff)

Bases: CutoffInteraction

Short range term of Ewald summation.

Attributes:

cutoff: Physical cutoff distance for pair interaction.

Methods

`__call__`(r, qi, qj)	Compute interaction energy.
`derivative`([n])	Return specified derivative.
`first_derivative`(r, qi, qj)	Compute derivative w/r to distance.
`get_cutoff`()	Get cutoff.
`second_derivative`(r, qi, qj)	Compute second derivative w/r to distance.

__init__(alpha, cutoff): Initialize with cutoff.

first_derivative(r, qi, qj): Compute derivative w/r to distance.

second_derivative(r, qi, qj): Compute second derivative w/r to distance.

property cutoff: Physical cutoff distance for pair interaction.

derivative(n=1): Return specified derivative.

get_cutoff(): Get cutoff. Deprecated.

class matscipy.calculators.ewald.calculator.Ewald

Bases: PairPotential

Ewal summation calculator.

Attributes:

alpha: Get alpha.
directory
label
short_range

Methods

`allowed_wave_vectors`(cell, km, a, nk)	Compute allowed wave vectors and the prefactor I
`band_structure`()	Create band-structure object for plotting.
`calculate`(atoms, properties, system_changes)	Compute Coulomb interactions with Ewald summation.
`calculate_numerical_forces`(atoms[, d])	Calculate numerical forces using finite difference.
`calculate_numerical_stress`(atoms[, d, voigt])	Calculate numerical stress using finite difference.
`calculate_properties`(atoms, properties)	This method is experimental; currently for internal use.
`check_state`(atoms[, tol])	Check for any system changes since last calculation.
`determine_alpha`(charge, acc, cutoff, cell)	Determine an estimate for alpha on the basis of the cell, cutoff and desired accuracy (Adopted from LAMMPS)
`determine_kc`(cell, nk)	Determine maximal wave vector based in a given integer triplet
`determine_nk`(charge, cell, acc, a, natoms)	Determine the maximal number of points in reciprocal space for each direction, and the cutoff in reciprocal space
`first_derivative_kspace`(charge, natoms, vol, ...)	Return the kspace part of the force.
`get_birch_coefficients`(atoms)	Compute the Birch coefficients (Effective elastic constants at non-zero stress).
`get_born_elastic_constants`(atoms)	Compute the Born elastic constants.
`get_dynamical_matrix`(atoms)	Compute dynamical matrix (=mass weighted Hessian).
`get_elastic_constants`(atoms[, cg_parameters])	Compute the elastic constants at zero temperature.
`get_hessian`(atoms[, format])	Compute the real space + kspace Hessian
`get_magnetic_moments`([atoms])	Calculate magnetic moments projected onto atoms.
`get_non_affine_contribution_to_elastic_constants`(atoms)	get_non_affine_contribution_to_elastic_constants is deprecated, use elasticity.nonaffine_elastic_contribution instead!
`get_nonaffine_forces`(atoms)	Compute the non-affine forces which result from an affine deformation of atoms.
`get_numerical_non_affine_forces`(atoms[, d])	get_numerical_non_affine_forces is deprecated, use numerical.numerical_nonaffine_forces instead!
`get_property`(name[, atoms, allow_calculation])	Get the named property.
`get_stress_contribution_to_elastic_constants`(atoms)	Compute the correction to the elastic constants due to non-zero stress in the configuration.
`get_stresses`([atoms])	the calculator should return intensive stresses, i.e., such that stresses.sum(axis=0) == stress
`kspace_energy`(charge, pos, vol, I, k)	Return the energy from the reciprocal space contribution
`kspace_properties`(atoms[, prop, ...])	Calculate the recirprocal contributiom to the Hessian, the non-affine forces and the Born elastic constants
`read`(label)	Read atoms, parameters and calculated properties from output file.
`reset`()	Clear all information from old calculation.
`reset_kspace`(atoms)	Reset kspace setup.
`rms_kspace`(km, l, n, a, q2)	Compute the root mean square error of the force in reciprocal space
`rms_rspace`(charge, cell, a, rc)	Compute the root mean square error of the force in real space
`self_energy`(charge, a)	Return the self energy
`set`(**kwargs)	Set parameters like set(key1=value1, key2=value2, ...).
`set_label`(label)	Set label and convert label to directory and prefix.
`stress_kspace`(charge, pos, vol, a, I, k)	Return the stress contribution of the long-range Coulomb part.

calculation_required
export_properties
get_atoms
get_charges
get_default_parameters
get_dipole_moment
get_forces
get_magnetic_moment
get_potential_energies
get_potential_energy
get_stress
read_atoms
todict

name = 'Ewald'

default_parameters: Dict[str, Any] = {'accuracy': 1e-06, 'cutoff': 3, 'kspace': {}, 'verbose': True}: Default parameters

__init__(): Construct calculator.

property short_range

property alpha: Get alpha.

set(**kwargs)

Set parameters like set(key1=value1, key2=value2, …).

A dictionary containing the parameters that have been changed is returned.

Subclasses must implement a set() method that will look at the chaneged parameters and decide if a call to reset() is needed. If the changed parameters are harmless, like a change in verbosity, then there is no need to call reset().

The special keyword ‘parameters’ can be used to read parameters from a file.

reset(): Clear all information from old calculation.

static determine_alpha(charge, acc, cutoff, cell): Determine an estimate for alpha on the basis of the cell, cutoff and desired accuracy (Adopted from LAMMPS)

static determine_nk(charge, cell, acc, a, natoms): Determine the maximal number of points in reciprocal space for each direction, and the cutoff in reciprocal space

static determine_kc(cell, nk): Determine maximal wave vector based in a given integer triplet

static rms_kspace(km, l, n, a, q2): Compute the root mean square error of the force in reciprocal space

static rms_rspace(charge, cell, a, rc): Compute the root mean square error of the force in real space

static allowed_wave_vectors(cell, km, a, nk): Compute allowed wave vectors and the prefactor I

static self_energy(charge, a): Return the self energy

static kspace_energy(charge, pos, vol, I, k): Return the energy from the reciprocal space contribution

static first_derivative_kspace(charge, natoms, vol, pos, I, k): Return the kspace part of the force.

static stress_kspace(charge, pos, vol, a, I, k): Return the stress contribution of the long-range Coulomb part.

reset_kspace(atoms): Reset kspace setup.

calculate(atoms, properties, system_changes): Compute Coulomb interactions with Ewald summation.

kspace_properties(atoms, prop='Hessian', divide_by_masses=False)

Calculate the recirprocal contributiom to the Hessian, the non-affine forces and the Born elastic constants

Parameters:

atoms (ase.Atoms) – Atomic configuration in a local or global minima.
prop ("Hessian", "Born" or "Naforces") – Compute either the Hessian/Dynamical matrix, the Born constants or the non-affine forces.
divide_by_masses (bool) – if true return the dynamic matrix else Hessian matrix
Restrictions –
---------- –
systems (This method is currently only implemented for three dimensional) –

get_hessian(atoms, format=''): Compute the real space + kspace Hessian

get_nonaffine_forces(atoms)

Compute the non-affine forces which result from an affine deformation of atoms.

Parameters:: atoms (ase.Atoms) – Atomic configuration in a local or global minima.

band_structure(): Create band-structure object for plotting.

calculate_numerical_forces(atoms, d=0.001)

Calculate numerical forces using finite difference.

All atoms will be displaced by +d and -d in all directions.

calculate_numerical_stress(atoms, d=1e-06, voigt=True): Calculate numerical stress using finite difference.

calculate_properties(atoms, properties): This method is experimental; currently for internal use.

calculation_required(atoms, properties)

check_state(atoms, tol=1e-15): Check for any system changes since last calculation.

property directory: str

discard_results_on_any_change = False: Whether we purge the results following any change in the set() method.

export_properties()

get_atoms()

get_birch_coefficients(atoms)

Compute the Birch coefficients (Effective elastic constants at non-zero stress).

Parameters:: atoms (ase.Atoms) – Atomic configuration in a local or global minima.

get_born_elastic_constants(atoms)

Compute the Born elastic constants.

Parameters:: atoms (ase.Atoms) – Atomic configuration in a local or global minima.

get_charges(atoms=None)

get_default_parameters()

get_dipole_moment(atoms=None)

get_dynamical_matrix(atoms): Compute dynamical matrix (=mass weighted Hessian).

get_elastic_constants(atoms, cg_parameters={'M': None, 'atol': 1e-05, 'callback': None, 'maxiter': None, 'tol': 1e-05, 'x0': None})

Compute the elastic constants at zero temperature. These are sum of the born, the non-affine and the stress contribution.

Parameters:

atoms (ase.Atoms) – Atomic configuration in a local or global minima.
cg_parameters (dict) –
Dictonary for the conjugate-gradient solver.

x0: {array, matrix}
Starting guess for the solution.

tol/atol: float, optional
Tolerances for convergence, norm(residual) <= max(tol*norm(b), atol).

maxiter: int
Maximum number of iterations. Iteration will stop after maxiter steps even if the specified tolerance has not been achieved.

M: {sparse matrix, dense matrix, LinearOperator}
Preconditioner for A.

callback: function
User-supplied function to call after each iteration.

get_forces(atoms=None)

get_magnetic_moment(atoms=None)

get_magnetic_moments(atoms=None): Calculate magnetic moments projected onto atoms.

get_non_affine_contribution_to_elastic_constants(atoms, eigenvalues=None, eigenvectors=None, pc_parameters=None, cg_parameters={'M': None, 'atol': 1e-05, 'callback': None, 'maxiter': None, 'tol': 1e-05, 'x0': None})

get_non_affine_contribution_to_elastic_constants is deprecated, use elasticity.nonaffine_elastic_contribution instead!

Compute the correction of non-affine displacements to the elasticity tensor. The computation of the occuring inverse of the Hessian matrix is bypassed by using a cg solver.

If eigenvalues and and eigenvectors are given the inverse of the Hessian can be easily computed.

Parameters:

atoms (ase.Atoms) – Atomic configuration in a local or global minima.
eigenvalues (array) – Eigenvalues in ascending order obtained by diagonalization of Hessian matrix. If given, use eigenvalues and eigenvectors to compute non-affine contribution.
eigenvectors (array) – Eigenvectors corresponding to eigenvalues.
cg_parameters (dict) –
Dictonary for the conjugate-gradient solver.

x0: {array, matrix}
Starting guess for the solution.

tol/atol: float, optional
Tolerances for convergence, norm(residual) <= max(tol*norm(b), atol).

maxiter: int
Maximum number of iterations. Iteration will stop after maxiter steps even if the specified tolerance has not been achieved.

M: {sparse matrix, dense matrix, LinearOperator}
Preconditioner for A.

callback: function
User-supplied function to call after each iteration.
pc_parameters (dict) –
Dictonary for the incomplete LU decomposition of the Hessian.

A: array_like
Sparse matrix to factorize.

drop_tol: float
Drop tolerance for an incomplete LU decomposition.

fill_factor: float
Specifies the fill ratio upper bound.

drop_rule: str
Comma-separated string of drop rules to use.

permc_spec: str
How to permute the columns of the matrix for sparsity.

diag_pivot_thresh: float
Threshold used for a diagonal entry to be an acceptable pivot.

relax: int
Expert option for customizing the degree of relaxing supernodes.

panel_size: int
Expert option for customizing the panel size.

options: dict
Dictionary containing additional expert options to SuperLU.

get_numerical_non_affine_forces(atoms, d=1e-06)

get_numerical_non_affine_forces is deprecated, use numerical.numerical_nonaffine_forces instead!

Calculate numerical non-affine forces using central finite differences. This is done by deforming the box, rescaling atoms and measure the force.

Parameters:: atoms (ase.Atoms) – Atomic configuration in a local or global minima.

get_potential_energies(atoms=None)

get_potential_energy(atoms=None, force_consistent=False)

get_property(name, atoms=None, allow_calculation=True): Get the named property.

get_stress(atoms=None)

get_stress_contribution_to_elastic_constants(atoms)

Compute the correction to the elastic constants due to non-zero stress in the configuration. Stress term results from working with the Cauchy stress.

Parameters:: atoms (ase.Atoms) – Atomic configuration in a local or global minima.

get_stresses(atoms=None): the calculator should return intensive stresses, i.e., such that stresses.sum(axis=0) == stress

ignored_changes: Set[str] = {}: Properties of Atoms which we ignore for the purposes of cache

implemented_properties: List[str] = ['energy', 'free_energy', 'stress', 'forces', 'hessian', 'dynamical_matrix', 'nonaffine_forces', 'birch_coefficients', 'nonaffine_elastic_contribution', 'stress_elastic_contribution', 'born_constants', 'elastic_constants']: Properties calculator can handle (energy, forces, …)

property label

read(label)

Read atoms, parameters and calculated properties from output file.

Read result from self.label file. Raise ReadError if the file is not there. If the file is corrupted or contains an error message from the calculation, a ReadError should also be raised. In case of succes, these attributes must set:

atoms: Atoms object: The state of the atoms from last calculation.
parameters: Parameters object: The parameter dictionary.
results: dict: Calculated properties like energy and forces.

The FileIOCalculator.read() method will typically read atoms and parameters and get the results dict by calling the read_results() method.

classmethod read_atoms(restart, **kwargs)

set_label(label)

Set label and convert label to directory and prefix.

Examples:

label=’abc’: (directory=’.’, prefix=’abc’)
label=’dir1/abc’: (directory=’dir1’, prefix=’abc’)
label=None: (directory=’.’, prefix=None)

todict(skip_default=True)