matscipy.calculators.polydisperse.calculator

Classes

`InversePowerLawPotential`(epsilon, cutoff, ...)	Functional form for a smoothed inverse-power-law potential (IPL) with an repulsive exponent of 10.
`Polydisperse`(f[, cutoff])

class matscipy.calculators.polydisperse.calculator.InversePowerLawPotential(epsilon, cutoff, na, q, minSize, maxSize)

Bases: object

Functional form for a smoothed inverse-power-law potential (IPL) with an repulsive exponent of 10.

Parameters:

epsilon (float) – Energy scale
cutoff (float) – Cutoff for the pair-interaction
minSize (float) – Minimal size of a particle, lower bound of distribtuion
maxSize (float) – Maximal size of a particle, upper bound of distribtuion
na (float) – Non-additivity paramter for pairwise sizes
q (int) – Smooth the potential up to the q-th derivative. For q=0 the potential is smoothed, for q=1 the potential and its first derivative are zero at the cutoff,…
Reference
---------- –
1. Lerner, Journal of Non-Crystalline Solids, 522, 119570.

Methods

`__call__`(r, ijsize)	Return function value (potential energy)
`first_derivative`(r, ijsize)	Return first derivative
`get_coeffs`()	Return the smoothing coefficients of the potential.
`get_cutoff`()	Return the cutoff.
`get_maxSize`()	Return the maximal size of a particle (=Upper boundary of distribution)
`get_minSize`()	Return the minimal size of a particle (=Lower boundary of distribution)
`mix_sizes`(isize, jsize)	Nonadditive interaction rule for the cross size of particles i and j.
`second_derivative`(r, ijsize)	Return second derivative

derivative

__init__(epsilon, cutoff, na, q, minSize, maxSize)

mix_sizes(isize, jsize): Nonadditive interaction rule for the cross size of particles i and j.

get_cutoff(): Return the cutoff.

get_coeffs(): Return the smoothing coefficients of the potential.

get_maxSize(): Return the maximal size of a particle (=Upper boundary of distribution)

get_minSize(): Return the minimal size of a particle (=Lower boundary of distribution)

first_derivative(r, ijsize): Return first derivative

second_derivative(r, ijsize): Return second derivative

derivative(n=1)

class matscipy.calculators.polydisperse.calculator.Polydisperse(f, cutoff=None)

Bases: MatscipyCalculator

Attributes:

directory
label

Methods

`band_structure`()	Create band-structure object for plotting.
`calculate`(atoms, properties, system_changes)	Do the calculation.
`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.
`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, divide_by_masses])	Calculate the Hessian matrix for a polydisperse systems where atoms interact via a pair potential.
`get_magnetic_moments`([atoms])	Calculate magnetic moments projected onto atoms.
`get_non_affine_contribution_to_elastic_constants`(atoms)	Compute the correction of non-affine displacements to the elasticity tensor.
`get_nonaffine_forces`(atoms)	Compute the non-affine forces which result from an affine deformation of atoms.
`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
`read`(label)	Read atoms, parameters and calculated properties from output file.
`reset`()	Clear all information from old calculation.
`set`(**kwargs)	Set parameters like set(key1=value1, key2=value2, ...).
`set_label`(label)	Set label and convert label to directory and prefix.

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

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, …)

default_parameters: Dict[str, Any] = {}: Default parameters

name = 'Polydisperse'

__init__(f, cutoff=None)

Basic calculator implementation.

restart: str: Prefix for restart file. May contain a directory. Default is None: don’t restart.
ignore_bad_restart_file: bool: Deprecated, please do not use. Passing more than one positional argument to Calculator() is deprecated and will stop working in the future. Ignore broken or missing restart file. By default, it is an error if the restart file is missing or broken.
directory: str or PurePath: Working directory in which to read and write files and perform calculations.
label: str: Name used for all files. Not supported by all calculators. May contain a directory, but please use the directory parameter for that instead.
atoms: Atoms object: Optional Atoms object to which the calculator will be attached. When restarting, atoms will get its positions and unit-cell updated from file.

calculate(atoms, properties, system_changes)

Do the calculation.

properties: list of str: List of what needs to be calculated. Can be any combination of ‘energy’, ‘forces’, ‘stress’, ‘dipole’, ‘charges’, ‘magmom’ and ‘magmoms’.
system_changes: list of str: List of what has changed since last calculation. Can be any combination of these six: ‘positions’, ‘numbers’, ‘cell’, ‘pbc’, ‘initial_charges’ and ‘initial_magmoms’.

Subclasses need to implement this, but can ignore properties and system_changes if they want. Calculated properties should be inserted into results dictionary like shown in this dummy example:

self.results = {'energy': 0.0,
                'forces': np.zeros((len(atoms), 3)),
                'stress': np.zeros(6),
                'dipole': np.zeros(3),
                'charges': np.zeros(len(atoms)),
                'magmom': 0.0,
                'magmoms': np.zeros(len(atoms))}

The subclass implementation should first call this implementation to set the atoms attribute and create any missing directories.

get_hessian(atoms, format='sparse', divide_by_masses=False)

Calculate the Hessian matrix for a polydisperse systems where atoms interact via a pair potential. For an atomic configuration with N atoms in d dimensions the hessian matrix is a symmetric, hermitian matrix with a shape of (d*N,d*N). The matrix is due to the cutoff function a sparse matrix, which consists of dense blocks of shape (d,d), which are the mixed second derivatives. The result of the derivation for a pair potential can be found in: L. Pastewka et. al. “Seamless elastic boundaries for atomistic calculations”, Phys. Ev. B 86, 075459 (2012).

Parameters:

atoms (ase.Atoms) – Atomic configuration in a local or global minima.
format ("sparse" or "neighbour-list") – Output format of the hessian matrix.
divide_by_masses (bool) – Divide the block “l,m” by the corresponding atomic masses “sqrt(m_l, m_m)” to obtain dynamical matrix.
Restrictions
----------
systems (This method is currently only implemented for three dimensional)

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, 'rtol': 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.

rtol/atol: float, optional
Tolerances for convergence, norm(residual) <= max(rtol*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, 'rtol': 1e-05, 'x0': None})

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.

rtol/atol: float, optional
Tolerances for convergence, norm(residual) <= max( rtol*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_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.

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

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)

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

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.

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)