MLCF¶

elf¶

ElF - allows for the creation of electronic descriptors (ElFs: ELectronic Fingerprints) out of real space electron densities

class mlc_func.elf.ElF(value, angles, basis, species, unitcell)¶

Class defining the electronic descriptors used by MLCF. ElF stands for ELectronic Fingerprint

Parameters:

value (dict or np.ndarray) – value of descriptor can either be a complex (dict) or real (np.ndarray) tensor.
angles (np.ndarray (3)) – angles by which ElF was rotated into local coordinate system (used to rotate forces into same CS).
basis (dict) – basis for elf representation
species (str,) – atomic species (element symbol)
unitcell (np.ndarray (3,3)) – unitcell of the system (used by fold_back_coords during alingment)

density¶

class mlc_func.elf.density.Density(rho, unitcell, grid)¶

Class defining the density on a real space grid

Parameters:	rho (np.ndarray) – 3-dim real space density. unitcell (np.ndarray (3,3)) – unitcell in Angstrom. grid (np.ndarray (3,)) – grid points.

mesh_3d(rmin=[0, 0, 0], rmax=0, scaled=False, pbc=True, indexing='xy')¶

Returns a 3d mesh taking into account periodic boundary conditions

Parameters:	rmax (rmin,) – lower and upper cutoff in every euclidean direction. scaled (boolean) – scale the meshes with unitcell size? pbc (boolean) – assume periodic boundary conditions? indexing ('xy' or 'ij') – indexing scheme used by np.meshgrid.
Returns:	X, Y, Z – defines mesh.
Return type:	tuple of np.ndarray

real_space¶

mlc_func.elf.real_space.S(r_i, r_o, nmax, gamma)¶

Overlap matrix between radial basis functions

Parameters:	r_i (float) – inner radial cutoff r_o (float) – outer radial cutoff nmax (int) – max. number of radial functions gamma (float) – damping parameter
Returns:	Overlap matrix
Return type:	np.ndarray (nmax, nmax)

mlc_func.elf.real_space.atomic_elf(pos, density, basis, chem_symbol)¶

Given an input density and an atomic position decompose the surrounding charge density into an ELF

Parameters:	pos ((,3) np.ndarray) – atomic position density (Density) – stores charge density rho, unitcell, and grid (see density.py) basis (dict) – specifies the basis set used for the ELF decomposition for each chem. element chem_symbol (str) – chemical element symbol
Returns:	dictionary containing the real ELF
Return type:	dict

mlc_func.elf.real_space.box_around(pos, radius, density)¶

Return dictionary containing box around an atom at position pos with given radius. Dictionary contains box in mesh, euclidean and spherical coordinates

Parameters:	pos (np.ndarray (3,) or (1,3),) – coordinates for box center radius (float) – box radius density (Density) – only needed for Density.unitcell and Density.grid
Returns:	{‘mesh’,’real’,’radial’}, box in mesh, euclidean and spherical coordinates
Return type:	dict

mlc_func.elf.real_space.decompose(rho, box, n_rad, n_l, r_i, r_o, gamma, V_cell=1)¶

Project the real space density rho onto a set of basis functions

Parameters:	rho (np.ndarray) – electron charge density on grid box (dict) – contains the mesh in spherical and euclidean coordinates, can be obtained with get_box_around() n_rad (int) – number of radial functions n_l (int) – number of spherical harmonics r_i (float) – inner radial cutoff in Angstrom r_o (float) – outer radial cutoff in Angstrom gamma (float) – exponential damping V_cell (float) – volume of one grid cell
Returns:	dictionary containing the complex ELF
Return type:	dict

mlc_func.elf.real_space.g(r, r_i, r_c, a, gamma)¶

Non-orthogonalized radial functions

Parameters:	r (float) – radius r_i (float) – inner radial cutoff r_o (float) – outer radial cutoff a (int) – exponent (equiv. to radial index n) gamma (float) – damping parameter
Returns:	value of radial function at radius r
Return type:	float

mlc_func.elf.real_space.get_W(r_i, r_o, n, gamma)¶

Get matrix to orthonormalize radial basis functions

Parameters:	r_i (float) – inner radial cutoff r_o (float) – outer radial cutoff n (int) – max. number of radial functions gamma (float) – damping parameter
Returns:	W, orthogonalization matrix
Return type:	np.ndarray

mlc_func.elf.real_space.get_elf_thread(pos, density, basis, chem_symbol, i, all_positions, mode)¶: Method that should be used in a parallel executions. One thread/process computes and orients the ElF for a single atom inside a system

mlc_func.elf.real_space.get_elfs(atoms, density, basis, view=<mlc_func.elf.serial_view.serial_view object>, orient_mode='none')¶

Given an input density and an ASE Atoms object decompose the complete charge density into atomic ELFs

Parameters:	atoms (ase.Atoms) – density (Density) – stores charge density rho, unitcell, and grid (see density.py) basis (dict) – specifies the basis set used for the ELF decomposition for each chem. element view (ipyparallel.balanced_view) – for parallel execution through sync map orient_mode (str) – {‘none’: do not orient and return complex tensor, ‘elf’/’nn’: orient using the elf or nn algorithm and return real tensor}
Returns:	list containing the complex/real atomic ELFs
Return type:	list

mlc_func.elf.real_space.get_elfs_oriented(atoms, density, basis, mode, view=<mlc_func.elf.serial_view.serial_view object>)¶: Outdated, use get_elfs() with “mode=’elf’/’nn’” instead. Like get_elfs, but returns real, oriented elfs mode = {‘elf’: Use the ElF algorithm to orient fingerprint,

‘nn’: Use nearest neighbor algorithm}

mlc_func.elf.real_space.mesh_around(pos, radius, density, unit='A')¶: Similar to box_around but only returns mesh

mlc_func.elf.real_space.orient_elf(i, elf, all_pos, mode)¶

Takes an ElF and orient it according to the rule specified in mode.

Parameters:	i (int) – Index of the atom in all_pos elf (ElF) – ElF to orient all_pos (numpy.ndarray) – positions of all atoms in system (including the one with index i) mode (str,) – {‘elf’: Use the ElF algorithm to orient fingerprint, ‘nn’: Use nearest neighbor algorithm}, ‘water’: molecular alignment (can only be used for neat water), ‘neutral’: keep alignment unchanged
Returns:	oriented version of elf
Return type:	ElF

mlc_func.elf.real_space.orient_elfs(elfs, atoms, mode)¶: Convenience function that applies orient_elf to a list of elfs. (Exists for compatibility reasons)

mlc_func.elf.real_space.radials(r, r_i, r_o, W, gamma)¶

Get orthonormal radial basis functions

Parameters:	r (float) – radius r_i (float) – inner radial cutoff r_o (float) – outer radial cutoff W (np.ndarray) – orthogonalization matrix gamma (float) – damping parameter
Returns:	radial functions
Return type:	np.ndarray

geom¶

Module that provides algebraic operations on SO(3) tensors

mlc_func.elf.geom.fold_back_coords(i, coords, unitcell)¶

Return the periodic images of coords in a unit-cell that are closest to coords[i]

Parameters:	i (int) – central atom coords (np.ndarray (?, 3)) – all atomic positions in given sytem unitcell (np.ndarray (3,3)) – unitcell in angstrom
Returns:	peridic images of coords
Return type:	np.ndarray (?, 3)

mlc_func.elf.geom.get_casimir(tensor)¶

Get the casimir element (equiv. to L_2 norm) of a complex tensor

Parameters:	tensor (dict) – dictionary containing tensor in its complex form
Returns:	Casimir element {‘n,l’}
Return type:	dict

mlc_func.elf.geom.get_elfcs_angles(i, coords, tensor)¶

Get angles relating global coordinate system to local coordinate system (LCS) defined by electronic structure

Parameters:	i (int) – LCS around atom i coords (np.ndarray (?, 3)) – all atomic positions in given sytem tensor (dict) – complex tensor (electronic descriptor) to use for alignment
Returns:	Euler angles alpha, beta, gamma
Return type:	list of floats

mlc_func.elf.geom.get_euler_angles(co)¶

Given a coordinate system co, return the euler angles that relate this CS to the standard CS

Parameters:	co (np.ndarray (3,3)) – coordinates of the body-fixed axes in the global coordinate system
Returns:	euler angles
Return type:	tuple of floats

mlc_func.elf.geom.get_max(tensor)¶: Get the maximum radial index and maximum ang. momentum in tensor

mlc_func.elf.geom.get_nncs_angles(i, coords, tensor=None)¶

Get angles relating global coordinate system to local coordinate system (LCS) defined by nearest neighbors

Parameters:	i (int) – LCS around atom i coords (np.ndarray (?, 3)) – all atomic positions in given sytem tensor (None) – placeholder
Returns:	Euler angles alpha, beta, gamma
Return type:	list of floats

mlc_func.elf.geom.make_complex(tensor_array, n_rad, n_l)¶

Take real tensors provided as a np.ndarray and convert them into complex tensors represented as a dictionary

Parameters:	tensor_array (np.ndarray) – real tensor (ordering: radial ang.momentum projection like: s1 ppp1 ddddd1 s2 etc.) n_rad (int,) – number of radials n_l (int,) – maximum angular momentum
Returns:	dictionary containing complex tensor elements (keys: {‘n,l,m’})
Return type:	dict

mlc_func.elf.geom.make_real(tensor)¶: Take complex tensors provided as a dict and convert them into real tensors

mlc_func.elf.geom.rotate_tensor(tensor, angles, inverse=False)¶

Rotate a complex tensor.

Parameters:	tensor (dict) – complex rank-2 tensor to rotate; the tensor is expected to be complete i.e. no entries should be missing angles (np.ndarray (3,)) – euler angles: alpha, beta, gamma inverse (bool,) – {False: rotate vector, True: rotate CS}
Returns:	Rotated version of tensor
Return type:	dict

Remember that in nncs and elfcs alignment, inverse = True should be used

mlc_func.elf.geom.rotate_vector(vec, angles, inverse=False)¶

Rotate a real vector (euclidean order: xyz) with euler angles

Parameters:	vec (np.ndarray (?, 3)) – vector(s) to rotate, note that if more than one vector provided, ever vector is rotated by the same angles. angles (np.ndarray (3)) – euler angles: alpha, beta, gamma. inverse (bool) – {False: rotate vector, True: rotate coordinate system}
Returns:	rotated vector(s)
Return type:	np.ndarray

water¶

mlc_func.elf.water.get_water_angles(i, coords, tensor=None)¶: Get euler angles to rotate to the water molecule centered CS for coords[i]. (Assumes that ordering in coords is OHHOHH…)

mlc_func.elf.water.tip4p_to_str(arr)¶: Giving a tip4p array (created with waterc_to_tip4p) return a string that can be used inside a SIESTA input file

mlc_func.elf.water.waterc_to_tip4p(coords)¶: Starting from water coordinates, return the parameters of a tip4p model describing the same system

siesta¶

Utility functions for real-space grid properties

mlc_func.elf.siesta.get_atoms(path, n_atoms=-1)¶: find atomic data in siesta .out file for first n_atoms atoms and return as ase Atoms object

mlc_func.elf.siesta.get_density(file_path)¶

Import data from RHO file (or similar real-space grid files) Data is saved in global variables.

Structure of RHO file: first three lines give the unit cell vectors fourth line the grid dimensions subsequent lines give density on grid

Parameters:	file_path (string) – path to RHO (or RHOXC) file from which density is read
Returns:
Return type:	Density

mlc_func.elf.siesta.get_density_bin(file_path)¶: Same as get_data for binary (unformatted) files

mlc_func.elf.siesta.get_energy(path, keywords=['Total'])¶: find energy values specified by keywords in siesta output file.

mlc_func.elf.siesta.get_forces(path, n_atoms=-1)¶: find forces in siesta .out file for first n_atoms atoms

ml¶

This module contains everything regarding machine learning

energy_network¶

Module that implements Energy_Network, the machine learned correcting functional (MLCF) for energies

class mlc_func.ml.energy_network.Dataset(data, species)¶

data¶: Alias for field number 0

species¶: Alias for field number 1

class mlc_func.ml.energy_network.Energy_Network(subnets)¶

Machine learned correcting functional (MLCF) for energies

Parameters:	subnets (list of Subnetwork) – each subnetwork belongs to a single atom inside the system and computes the atomic contributio to the total energy

construct_network()¶: Builds the tensorflow graph from subnets

get_cost()¶

Build the tensorflow node that defines the cost function

Returns:	cost_list – list of costs for subnets. subnets whose outputs are added together share cost functions
Return type:	[tensorflow.placeholder]

get_energies(summarize=True, which='train')¶

Uses trained model on training or test sets

Parameters:	which (str) – {‘train’,’test’} which set logits are computed for
Returns:	resulting energies grouped by independent subnet datasets
Return type:	list of numpy.ndarray

get_feed(which='train', train_valid_split=0.8, seed=42)¶

Return a dictionary that can be used as a feed_dict in tensorflow

Parameters:	which ({'train',test'}) – which part of the dataset is used train_valid_split (float) – ratio of train and validation set size seed (int) – seed parameter for the random shuffle algorithm, make
Returns:	either (training feed dictionary, validation feed dict.) or (testing feed dictionary, None)
Return type:	(dictionary, dictionary)

load_all(net_dir)¶: Loads the model in net_dir including all subnets and datasets using pickle

predict(features, species, use_masks=False, return_gradient=False)¶

Get predicted energies

Parameters:	features (np.ndarray) – input features species (str) – predict atomic contribution to energy for this species use_masks (bool) – whether masks should be applied to the provided features return_gradient (bool) – instead of returning energies, return gradient of network w.r.t. input features
Returns:	predicted energies or gradient
Return type:	np.ndarray

restore_model(path)¶: Load trained model from path

save_all(net_dir, override=False)¶: Saves the model including all subnets and datasets using pickle to directory net_dir, if directory exists only save if override = True

save_model(path)¶: Save trained model to path

train(step_size=0.01, max_steps=50001, b_=0, verbose=True, optimizer=None, adaptive_rate=False, multiplier=1.0)¶

Train the master neural network

Parameters:	step_size (float) – step size for gradient descent max_steps (int) – number of training epochs b (float) – regularization parameter verbose (boolean) – print cost for intermediate training epochs optimizer (tf.nn.GradientDescentOptimizer,tf.nn.AdamOptimizer, ..) – adaptive_rate (boolean) – wether to adjust step_size if cost increases not recommended for AdamOptimizer multiplier (list of float) – multiplier that allow to give datasets more weight than others
Returns:
Return type:	None

class mlc_func.ml.energy_network.Subnet¶

Subnetwork that is associated with one Atom

add_dataset(dataset, targets, test_size=0.2, target_filter=None, scale=True)¶

Adds dataset to the subnetwork.

Parameters:	dataset (dataset) – contains datasets that will be associated with subnetwork for training and evaluation targets (np.ndarray) – target values for training and evaluation
Returns:
Return type:	None

get_feed(which, train_valid_split=0.8, seed=None)¶

Return a dictionary that can be used as a feed_dict in tensorflow

Parameters:	which (str,) – {‘train’, ‘valid’, ‘test’} which part of the dataset is used train_valid_split (float) – ratio of train and validation set size seed (int) – seed parameter for the random shuffle algorithm
Returns:
Return type:	dict

get_logits(i)¶

Builds the subnetwork by defining logits and placeholders

Parameters:	i (int) – index to label datasets
Returns:
Return type:	tensorflow tensors

load(path)¶: Load subnet from path

save(path)¶: Use pickle to save the subnet to path

mlc_func.ml.energy_network.build_energy_mlcf(feature_src, target_src, masks={}, automask_std=0, filters=[], autofilt_percent=0, test_size=0.2)¶

Return a trainable energy MLCF (neural network)

Parameters:	feature_src (list) – list of paths to the hdf5 containing the features target_src (list) – list of paths to the csv files containing the target energies entries in target_scr and feature_src correspond to each other masks (dict,) – containing list booleans; can be used to select which features to use. keys specify the atomic species. default: use all features automask_std (float,) – if mask not set exclude all features whose stdev across dataset is smaller than this value filters (list,) – containing list of booleans; can be used to exclude datapoints in sets (e.g. outliers) autofilt_percent (float,) – exclude this percentile of extreme datapoints from set (only if filters not set) test_size (float,) – relative size of hold_out (test) set
Returns:
Return type:	Energy_Network

mlc_func.ml.energy_network.get_energy_filters(target_src, autofilt_percent=0)¶

For a given energy target dataset return filter that cutoff the upper and lower percentile specified in autofilt_percent

Parameters:	target_src (str) – path of csv file containing energy targets autofilt_percent (float) – percentile to cut off
Returns:	filters
Return type:	list of bool

mlc_func.ml.energy_network.load_energy_model(path)¶

Load energy MLCF

Parameters:	path (str) – directory in which energy MLCF is stored
Returns:
Return type:	Energy_Network

force_network¶

Module that implements Force_Network, the machine learned correcting functional (MLCF) for forces

class mlc_func.ml.force_network.Force_Network(species, scaler, basis, datasets={}, mask=[], n_layers=3, nodes_per_layer=8, b=0)¶

MLCF for force perdiction

Parameters:

species (str) – chemical element symbol
scaler (sklearn Scaler) –
basis (dict) – basis that was used to create electronic descriptors
datasets (dict) – datasets provided as {‘X_train’: np.ndarray, ‘X_test’: etc…}
mask (list of bool) – used to mask the features and filter out features with low variance
n_layers (int) – number of hidden layers, default = 3
nodes_per_layer (int) – nodes for each hidden layer, default = 8
b (float) – l2-regularization strenght, default = 0

evaluate(plot=False, on='test')¶

Evaluate model performance

Parameters:	plot (bool) – plot correlation plots on (str) – {‘test’,’train’,’valid’} which set to evaluat on
Returns:	containing rmse, mae and max. abs. error
Return type:	dict

learning_curve(steps=5)¶

Create a learning curve by varying the training set size

Parameters:	steps (int) – how many different training set sizes to use
Returns:	{‘N’: training set size,’train’: training loss, ‘valid’: validation loss}
Return type:	dict,

load_all(net_dir)¶

Load force MLCF from net_dir

Parameters:	net_dir (str) – path to directory containing MLCF

predict(feat, processed=False)¶

Get predicted forces

Parameters:	feat (np.ndarray) – input features processed (bool) – are features processed (scaled, masked)?
Returns:	predicted forces
Return type:	np.ndarray

predict_from_hdf5(path)¶

Get force prediction but instead of providing features, give source path where features are found

Parameters:	path (str) – path to .hdf5 file containing features

np.ndarray

force prediction

save_all(net_dir, override=False)¶

Save force MLCF

Parameters:	net_dir (str) – directory to save mlcf to override (bool) – if net_dir already contains model, allow to override? default = False
Returns:
Return type:	None

train(step_size=0.001, max_epochs=50001, b=0, early_stopping=False, batch_size=500, epochs_per_output=500, restart=False, tol_train=0, tol_valid=0)¶

Train the model

Parameters:	step_size (float) – step size to take during gradient descent, default=0.001 max_epochs (int) – max. number of epochs to train, default=50001 b (float) – l2-regularization early_stopping (bool) – use early stopping (interrupt training once valid loss increases), default=False batch_size (int) – number of samples per batch, default=500 epochs_per_output (int) – only print overview every epochs_per_output steps, default=500 restart (bool) – restart training from beginning (reset network), default=False tol_train (float) – stop training if relative value of training loss decreases by less than this value tol_valid (float) – stop training if relative value of validation loss decreases by less than this value
Returns:
Return type:	None

mlc_func.ml.force_network.build_force_mlcf(feature_src, target_src, traj_src, species, mask=[], filters=[], automask_std=0, autofilt_percent=0, test_size=0.2, random_state=42)¶

Return a trainable force MLCF (neural network)

Parameters:	feature_src (list) – list of paths to the hdf5 containing the features target_src (list) – list of paths to the csv files containing the target forces entries in target_scr and feature_src correspond to each other traj_src (list) – list of paths to the .traj/.xyz files (needed to determine species of each atom) species (string) – containing the species that model should be fitted for mask (list) – containing booleans; can be used to select which features to use. default: use all features filters (list) – containing list of booleans; can be used to exclude datapoints in sets (e.g. outliers) automask_std (float) – if mask not set exclude all features whose stdev across dataset is smaller than this value autofilt_percent (float) – exclude this percentile of extreme datapoints from set (only if filters not set) test_size (float) – relative size of hold_out (test) set random_state (int) – state used to perform shuffle before spliting dataset
Returns:
Return type:	Force_Network

mlc_func.ml.force_network.load_force_model(net_dir, species)¶

Load force MLCF from net_dir for a given element

Parameters:	net_dir (str) – path to directory containing MLCF species (str) – specifies which chemical element to load model for

ensemble_network¶

class mlc_func.ml.ensemble_network.Ensemble_Network(network, n=3)¶

Ensemble Network to obtain confidence intervals for predictions

Parameters:	network (Network) – root network from which to create ensemble n (int) – ensemble size

predict(feat, processed=False)¶

Get mean prediction across ensemble

Parameters:	feat (np.ndarray) – input features processed (bool) – are features processed (scaled, masked)?
Returns:	mean prediction
Return type:	np.ndarray

predict_from_hdf5(path)¶

Get mean prediction across ensemble but instead of providing features, give source path where features are found

Parameters:	path (str) – path to .hdf5 file containing features
Returns:	mean prediction
Return type:	np.ndarray

save(net_dir, override=False)¶

Save ensemble Network

Parameters:	net_dir (str) – directory where to save network override (bool) – if network already exists allow to override? default = False

std_predict(feat, processed=False)¶

Get standard deviation of predictions across ensemble

Parameters:	feat (np.ndarray) – input features processed (bool) – are features processed (scaled, masked)?
Returns:	std of predictions
Return type:	np.ndarray

train(idx)¶

Train model specified by idx

Parameters:	idx (int) – index (ensemble) –

train_next()¶: Train the next untrained model

mlc_func.ml.ensemble_network.load_ensemble_network(net_dir, n, species)¶

Loads an ensemble Network

Parameters:	net_dir (str) – directory in which network is stored n (int) – number of networks per ensemble species (str) – which chem. element to load for

Ensemble_Network

md¶

Defines ASE calculators that combine a baseline method (e.g. SIESTA) and the Machine learned correcting functional (MLCF)

calculator¶

class mlc_func.md.calculator.MLCF_Calculator(base_calculator=None, feature_getter=None, log_accuracy=True)¶

MLCF_Calculator that consists of a baseline calculator (base_calculator), e.g. Siesta, and a Machine learned correcting functional (MLCF).

Parameters:	base_calculator (ase.Calculator) – baseline method to get first approximation to forces feature_getter (FeatureGetter) – read the electron density and transforms it into features (electronic fingerprints) log_accuracy (bool) – whether to log energies, forces and features during MD simulation, default: True

set_base_calculator(base_calculator)¶: Sets the baseline calculator :param base_calculator: any ASE calculator can be used (only tested for SiestaCalculator) :type base_calculator: ase.Calculator

set_feature_getter(feature_getter)¶

Sets the feature_getter

Parameters:	feature_getter (FeatureGetter) –

set_force_model(models)¶

Sets the force MLCF

Parameters:	models (dict) – dictionary containing the force models, dict keys should correspond to element symbol

class mlc_func.md.calculator.Siesta_Calculator(basis='qz', xc='BH')¶

Provides default options for the Siesta calculator, such as pre-defined custom basis sets and functionals. :param basis, str: {‘dz_custom’,’dz’,’qz_custom’,’sz’,’uf’,’szp’}, basis set to be used :param xc: {‘PBE’,’BH’,’PW92’,’revPBE’, …}, exchange-correlation functional :type xc: str

read_eigenvalues()¶: Read eigenvalues from the ‘.EIG’ file. This is done pr. kpoint.

read_results()¶: Overrides read_results in base class to skip reading the charge density etc. for speed-up

set_solution_method(method)¶

Whether diagonalization or orbital minimization should be used.

Parameters:	method (str,) – {‘diagon’,’OMM’}
Returns:
Return type:	None

mlc_func.md.calculator.load_from_file(input_file)¶: Read input_file that defines baseline calculator and MLCF model and return MLCF_Calculator

mlc_func.md.calculator.load_mlcf(model_path, client=None)¶: Given a directory model_path, load and return a calculator that uses the MLCF contained in that directory. For parallel computing an ipyparallel client can be provided. The baseline calculator of the returned instance still has to be set before usage.

mlc_func.md.calculator.log_all(energy_siesta=None, energy_corrected=None, forces_siesta=None, forces_corrected=None, features=None)¶: Used to log energies, forces and features during MD simultation

feature_io¶

class mlc_func.md.feature_io.DescriptorGetter(basis, client=None, rhopath='./H2O.RHOXC')¶

Reads the real space electron density and returns electronic descriptors

Parameters:	basis (dict) – dictionary defining the basis client (ipyparallel.client) – for parallel processing rhopath (str) – path under which the electron density can be found after every MD step

get_features(atoms)¶

Return the electronic descriptos for a set of atoms, electron density is read from file specified in self.rhopath

Parameters:	ase.Atoms (atoms,) –

set_masks(masks)¶

Parameters:	masks (dictionary) – dictionary containing the masks that are applied to the electronic descriptors before feeding them into the neural network, dict keys correspond to element symbols

set_scalers(scalers)¶

Parameters:	scalers (dictionary) – dictionary containing the scalers that are used to transform the electronic descriptors before feeding them to the neural network, dict keys correspond to element symbols

class mlc_func.md.feature_io.FeatureGetter(client=None)¶: Base-class for any feature getter

listintegrator¶

mixer¶

class mlc_func.md.mixer.Mixer(fast_calculator, slow_calculator, n, correct_species='')¶

ASE Calculator that uses the time step mixing method defined in E. Anglada, J. Junquera, and J. M. Soler, Physical Review E68, 055701 (2003)

Parameters:	fast_calculator (ase.Calculator) – fast, “quick and dirty” method slow_calculator (ase.Calculator) – slow accurate method n (int,) – Mixing parameter, correct with slow calculator after n steps correct_species (str) – only apply correctiong to elements specified in this string. Example: ‘oh’ only corrects Oxygen and Hydrogen