C++ documentation

This list is incomplete. You can help by expanding it!

Representations

Spherical Expansion

template<>
struct rascal::internal::RadialContribution<RadialBasisType::GTO> : public rascal::internal::RadialContributionBase

Implementation of the radial contribution for Gaussian Type Orbitals radial basis functions and gaussian smearing of the atom density.

\[ R^{GTO}_{n}(r) = \mathcal{N}_n\ r^{n} \exp[-br^2] \]

\[\begin{split}\begin{gather*} \newcommand{\dd}{\mathrm{d}\,} \mathcal{N}_n^2 = \frac{2}{\sigma_n^{2n + 3}\Gamma(n + 3/2)}\\ \sigma_n = (r_\text{cut}-\delta r_\text{cut}) \max(\sqrt{n},1)/n_\text{max}\\ b=\frac{1}{2\sigma_n}\\ \int_0^\infty R^{GTO}_{n}(r) R^{GTO}_{n^\prime}(r) \dd{r}= 2 \left(\frac{1}{2 \sigma_{n}^2}+ \frac{1}{2 \sigma_{n^\prime}^2} \right)^{-\frac{1}{2} (3+n+n^\prime)} \Gamma(\frac{3+n+n^\prime}{2}) \end{gather*}\end{split}\]

See the theory page for more details.

Public Functions

inline virtual void set_hyperparameters(const Hypers_t &hypers) override

Set hyperparameters.

Parameters

hypers – is expected to be the same as the the input of the spherical expansion

template<AtomicSmearingType AST>
inline Matrix_t compute_contribution(const double distance, const double sigma)

Define the contribution from a neighbour atom to the expansion without requiring a cluster object so it can be used with the spline.

template<AtomicSmearingType AST, size_t Order, size_t Layer>
inline Vector_Ref compute_center_contribution(ClusterRefKey<Order, Layer> &center, int)

define the contribution from the central atom to the expansion

inline Vector_Ref compute_center_contribution(double fac_a)

define the contribution from the central atom to the expansion

template<AtomicSmearingType AST, size_t Order, size_t Layer>
inline Matrix_Ref compute_neighbour_contribution(const double distance, const ClusterRefKey<Order, Layer> &pair)

define the contribution from a neighbour atom to the expansion

template<size_t Order, size_t Layer>
inline Matrix_Ref compute_neighbour_derivative(const double distance, const ClusterRefKey<Order, Layer>&, int)

Compute the radial derivative of the neighbour contribution.

inline void finalize_radial_integral_neighbour()

Orthonormalize the radial integral computed with compute_neighbour_contribution within the neighbour loop It is useful for splining the GTO basis.

inline void precompute_radial_sigmas()

Compute common prefactors for the radial Gaussian basis functions

inline void precompute_radial_overlap()

Compute the radial overlap matrix for later orthogonalization.

Throws

runtime_error – if the overlap matrix cannot be diagonalized

Public Members

Vector_t radial_norm_factors = {}

constant factors of the GTO basis N_n=sqrt(2/(n+3/2)) b_n^{3+2n}/4

Matrix_t radial_ortho_matrix = {}

S_{nn’}^{-1/2}, orthonormalization matrix of the GTO basis.

Matrix_t ortho_norm_matrix = {}

combination of radial_ortho_matrix and radial_norm_factors not symmetric

template<>
struct rascal::internal::RadialContribution<RadialBasisType::DVR> : public rascal::internal::RadialContributionBase

Implementation of the radial contribution for DVR basis

See the theory page for more details.

Public Functions

inline explicit RadialContribution(const Hypers_t &hypers)

Constructor.

virtual ~RadialContribution() = default

Destructor.

RadialContribution(const RadialContribution &other) = delete

Copy constructor.

RadialContribution(RadialContribution &&other) = default

Move constructor.

RadialContribution &operator=(const RadialContribution &other) = delete

Copy assignment operator.

RadialContribution &operator=(RadialContribution &&other) = default

Move assignment operator.

inline virtual void set_hyperparameters(const Hypers_t &hypers) override

Set hyperparameters.

Parameters

hypers – is expected to be the same as the the input of the spherical expansion

inline Vector_Ref compute_center_contribution(const double fac_a)

define the contribution from the central atom to the expansion

template<AtomicSmearingType AST, size_t Order, size_t Layer>
inline Matrix_Ref compute_neighbour_contribution(const double distance, const ClusterRefKey<Order, Layer> &pair)

define the contribution from a neighbour atom to the expansion

template<size_t Order, size_t Layer>
inline Matrix_Ref compute_neighbour_derivative(const double, const ClusterRefKey<Order, Layer>&, int)

Compute the radial derivative of the neighbour contribution.

class rascal::CalculatorSphericalExpansion : public rascal::CalculatorBase

Handles the expansion of an environment in a spherical and radial basis.

The local environment of each atom is represented by Gaussians of a certain width (user-defined; can be constant, species-dependent, or radially dependent). This density field is expanded in an angular basis of spherical harmonics (à la SOAP) and a radial basis of either Gaussians (again, as in SOAP/SphericalInvariants) or one of the more recent bases currently under development.

Public Functions

inline virtual void set_hyperparameters(const Hypers_t &hypers) override

Set the hyperparameters of this descriptor from a json-like container.

Todo:

(max, felix) document the SOAP/SphExpn-specific hypers here

Parameters

hypers – structure (usually parsed from json) containing the options and hyperparameters

Throws

logic_error – if an invalid option or combination of options is specified in the structure

inline virtual bool does_gradients() const override

Returns if the calculator is able to compute gradients of the representation w.r.t. atomic positions ?

inline explicit CalculatorSphericalExpansion(const Hypers_t &hyper)

Construct a new Calculator using a hyperparameters container

See set_hyperparameters() for a description of the hypers

Todo:

(max) ffs, why isn’t the link above working in Sphinx? And why aren’t the todos showing?!

Parameters

hyper – container (usually parsed from json) for the options and hyperparameters

Throws

logic_error – if an invalid option or combination of options is specified in the container

CalculatorSphericalExpansion(const CalculatorSphericalExpansion &other) = delete

Copy constructor.

inline CalculatorSphericalExpansion(CalculatorSphericalExpansion &&other) noexcept

Move constructor.

virtual ~CalculatorSphericalExpansion() = default

Destructor.

CalculatorSphericalExpansion &operator=(const CalculatorSphericalExpansion &other) = delete

Copy assignment operator.

CalculatorSphericalExpansion &operator=(CalculatorSphericalExpansion &&other) = default

Move assignment operator.

template<class StructureManager>
void compute(StructureManager &managers)

Compute representation for a given structure manager.

Template Parameters

StructureManager – a (single or collection) of structure manager(s) (in an iterator) held in shared_ptr

template<internal::CutoffFunctionType FcType, class StructureManager>
void compute_by_radial_contribution(StructureManager &managers)

choose the RadialBasisType and AtomicSmearingType from the hypers

template<internal::CutoffFunctionType FcType, internal::RadialBasisType RadialType, internal::AtomicSmearingType SmearingType, class StructureManager>
void compute_by_radial_contribution(StructureManager &managers)

When the RadialBasisType has beeen already selected this function serves for a distinction of the cases for the optimization type

template<internal::CutoffFunctionType FcType, internal::RadialBasisType RadialType, internal::AtomicSmearingType SmearingType, internal::OptimizationType OptType, class StructureManager, std::enable_if_t<internal::is_proper_iterator<StructureManager>::value, int> = 0>
inline void compute_loop(StructureManager &managers)

loop over a collection of manangers if it is an iterator. Or just call compute_impl() if it’s a single manager (see below)

template<internal::CutoffFunctionType FcType, internal::RadialBasisType RadialType, internal::AtomicSmearingType SmearingType, internal::OptimizationType OptType, class StructureManager, std::enable_if_t<not (internal::is_proper_iterator<StructureManager>::value), int> = 0>
inline void compute_loop(StructureManager &manager)

single manager case

template<internal::CutoffFunctionType FcType, internal::RadialBasisType RadialType, internal::AtomicSmearingType SmearingType, internal::OptimizationType OptType, class StructureManager>
void compute_impl(std::shared_ptr<StructureManager> manager)

Compute the spherical expansion given several options.

Compute the spherical expansion

Spherical Invariants

class rascal::CalculatorSphericalInvariants : public rascal::CalculatorBase

Public Functions

CalculatorSphericalInvariants(const CalculatorSphericalInvariants &other) = delete

Copy constructor.

inline CalculatorSphericalInvariants(CalculatorSphericalInvariants &&other) noexcept

Move constructor.

virtual ~CalculatorSphericalInvariants() = default

Destructor.

CalculatorSphericalInvariants &operator=(const CalculatorSphericalInvariants &other) = delete

Copy assignment operator.

CalculatorSphericalInvariants &operator=(CalculatorSphericalInvariants &&other) = default

Move assignment operator.

inline virtual void set_hyperparameters(const Hypers_t &hypers) override

Pure Virtual Function to set hyperparameters of the representation.

inline void set_hyperparameters_powerspectrum(const Hypers_t &hypers)

Set hyperparameters when computing the PowerSpectrum.

Parameters

hypers – a json type object containing fields:

• coefficient_subselection (optional) if not present then all the coefficients are computed following max_radial, max_angular and the atomic species present. it should have the following form `{‘a’: […], ‘b’: […], ‘n1’: […], ‘n2’: […], ‘l’: […]}` where ‘a’ and ‘b’ are lists of atomic species, ‘n1’ and ‘n2’ are lists of radial expension indices and ‘l’ is the list of spherical expansion index. Each of these lists have the same size and their ith element refers to one PowerSpectrum coefficient that will be computed. Note that values in ‘n1’, ‘n2’, ‘l’ should not exceed max_radial-1 and max_angular.

inline virtual bool does_gradients() const override

Returns if the calculator is able to compute gradients of the representation w.r.t. atomic positions ?

template<class StructureManager>
void compute(StructureManager &managers)

Compute representation for a given structure manager.

TODO(felix) add mechanism to check if the StructureManager is compatible with the representation

Template Parameters

StructureManager – a (single or collection) of structure manager(s) (in an iterator) held in shared_ptr

template<internal::SphericalInvariantsType BodyOrder, class StructureManager, std::enable_if_t<internal::is_proper_iterator<StructureManager>::value, int> = 0>
inline void compute_loop(StructureManager &managers)

loop over a collection of manangers if it is an iterator. Or just call compute_impl

template<internal::SphericalInvariantsType BodyOrder, class StructureManager, std::enable_if_t<not (internal::is_proper_iterator<StructureManager>::value), int> = 0>
inline void compute_loop(StructureManager &manager)

single manager case

template<internal::SphericalInvariantsType BodyOrder, std::enable_if_t<BodyOrder == internal::SphericalInvariantsType::RadialSpectrum, int> = 0, class StructureManager>
void compute_impl(std::shared_ptr<StructureManager> manager)

compute representation \( \nu == 1 \)

template<internal::SphericalInvariantsType BodyOrder, std::enable_if_t<BodyOrder == internal::SphericalInvariantsType::PowerSpectrum, int> = 0, class StructureManager>
void compute_impl(std::shared_ptr<StructureManager> manager)

compute representation \( \nu == 2 \)

template<internal::SphericalInvariantsType BodyOrder, std::enable_if_t<BodyOrder == internal::SphericalInvariantsType::BiSpectrum, int> = 0, class StructureManager>
void compute_impl(std::shared_ptr<StructureManager> manager)

compute representation \( \nu == 3 \)

template<class StructureManager, class Invariants, class InvariantsDerivative, class ExpansionCoeff>
void initialize_per_center_powerspectrum_soap_vectors(Invariants &soap_vector, InvariantsDerivative &soap_vector_gradients, ExpansionCoeff &expansions_coefficients, std::shared_ptr<StructureManager> manager)

initialize the soap vectors with only the keys needed for each center

template<class StructureManager, class SpectrumNorm>
inline void update_gradients_for_normalization(Property_t<StructureManager> &soap_vectors, PropertyGradient_t<StructureManager> &soap_vector_gradients, std::shared_ptr<StructureManager> manager, SpectrumNorm &inv_norms, const size_t &grad_component_size)

Update the gradients p^{i} to include normalization, N_i, resulting in {p}^{i}. We have: {p}^{i} = p^{i} / N_i

• {p}^{i} [{p}^{i} p^{i} / N_i], where $$ is a dot product between vectors. Note that this expects the soap vectors to be normalized already, and the norm stored separately.

Public Members

std::set<internal::SortedKey<Key_t>, internal::CompareSortedKeyLess> unique_pair_list = {}

list of possible input pairs when using coefficient_subselection

std::map<internal::SortedKey<Key_t>, std::vector<PowerSpectrumCoeffIndex>, internal::CompareSortedKeyLess> coeff_indices_map = {}

list of coefficient that will be computed, mapping keys to a list invariant coefficients that will be computed

std::map<internal::SortedKey<Key_t>, internal::SortedKey<Key_t>, internal::CompareSortedKeyLess> key_map = {}

map the possible keys of the coefficient to the keys of the powerspectrum. If sparsification then it maps to (0,0) always otherwise it maps onto itself

std::vector<PowerSpectrumCoeffIndex> coeff_indices = {}

list of coefficient that will be computed if there is no sparsification

bool is_sparsified = {false}

tell if the calculator has been sparsified using the coefficient_subselection input

struct PowerSpectrumCoeffIndex

Spherical Covariants

class rascal::CalculatorSphericalCovariants : public rascal::CalculatorBase

Public Functions

CalculatorSphericalCovariants(const CalculatorSphericalCovariants &other) = delete

Copy constructor.

inline CalculatorSphericalCovariants(CalculatorSphericalCovariants &&other) noexcept

Move constructor.

virtual ~CalculatorSphericalCovariants() = default

Destructor.

CalculatorSphericalCovariants &operator=(const CalculatorSphericalCovariants &other) = delete

Copy assignment operator.

CalculatorSphericalCovariants &operator=(CalculatorSphericalCovariants &&other) = default

Move assignment operator.

inline virtual void set_hyperparameters(const Hypers_t &hypers) override

Pure Virtual Function to set hyperparameters of the representation.

template<class StructureManager>
void compute(StructureManager &managers)

Compute representation for a given structure manager.

TODO(felix) add mechanism to check if the StructureManager is compatible with the representation

Template Parameters

StructureManager – a (single or collection) of structure manager(s) (in an iterator) held in shared_ptr

template<internal::SphericalCovariantsType Type, class StructureManager, std::enable_if_t<internal::is_proper_iterator<StructureManager>::value, int> = 0>
inline void compute_loop(StructureManager &managers)

loop over a collection of manangers if it is an iterator. Or just call compute_impl

template<internal::SphericalCovariantsType Type, class StructureManager, std::enable_if_t<not (internal::is_proper_iterator<StructureManager>::value), int> = 0>
inline void compute_loop(StructureManager &manager)

single manager case

template<internal::SphericalCovariantsType Type, std::enable_if_t<Type == internal::SphericalCovariantsType::LambdaSpectrum, int> = 0, class StructureManager>
void compute_impl(std::shared_ptr<StructureManager> manager)

compute representation lambda spectrum

Kernels

Kernel

class rascal::Kernel

Public Functions

inline Kernel(Kernel &&other) noexcept

Move constructor.

Public Members

std::vector<std::string> identifiers = {}

list of names identifying the properties that should be used to compute the kernels

Hypers_t parameters = {}

parameters of the kernel

internal::TargetType target_type = {}

Defines if the similarity is defined on the level of structures or per atom

template<>
struct rascal::internal::KernelImpl<internal::KernelType::Cosine> : public rascal::internal::KernelImplBase

Public Functions

template<class Property_t, internal::TargetType Type, std::enable_if_t<Type == internal::TargetType::Structure, int> = 0, class StructureManagers>
inline math::Matrix_t compute(StructureManagers &managers_a, StructureManagers &managers_b, const std::string &representation_name)

Compute the kernel between 2 set of structure(s), structure wise.

Template Parameters

StructureManagers – should be an iterable over shared pointer of structure managers like ManagerCollection

Parameters

• managers_a – a ManagerCollection or similar collection of structure managers

• managers_b – a ManagerCollection or similar collection of structure managers

• representation_name – name under which the representation data has been registered in the elements of managers_a and managers_b

Returns

kernel matrix

template<class Property_t, internal::TargetType Type, std::enable_if_t<Type == internal::TargetType::Structure, int> = 0, class StructureManagers>
inline math::Matrix_t compute(StructureManagers &managers_a, const std::string &representation_name)

Compute the kernel between 1 set of structure(s) with itself, structure wise.

Template Parameters

StructureManagers – should be an iterable over shared pointer of structure managers like ManagerCollection

Parameters

• managers_a – a ManagerCollection or similar collection of structure managers

• representation_name – name under which the representation data has been registered in the elements of managers_a and managers_b

Returns

kernel matrix

template<class Property_t, internal::TargetType Type, std::enable_if_t<Type == internal::TargetType::Atom, int> = 0, class StructureManagers>
inline math::Matrix_t compute(const StructureManagers &managers_a, const StructureManagers &managers_b, const std::string &representation_name)

Compute the kernel between 2 set of structures for a given representation specified by the name, atom wise.

Parameters

• managers_a – a ManagerCollection or similar collection of structure managers

• managers_b – a ManagerCollection or similar collection of structure managers

• representation_name – name under which the representation data has been registered in the elements of managers_a and managers_b

Returns

kernel matrix

template<class Property_t, internal::TargetType Type, std::enable_if_t<Type == internal::TargetType::Atom, int> = 0, class StructureManagers>
inline math::Matrix_t compute(const StructureManagers &managers_a, const std::string &representation_name)

Compute the kernel between 1 set of structure(s) with itself for a given representation specified by the name, atom wise.

Parameters

• managers_a – a ManagerCollection or similar collection of structure managers

• representation_name – name under which the representation data has been registered in the elements of managers_a and managers_b

Returns

kernel matrix

Public Members

size_t zeta = {1}

exponent of the cosine kernel

SparseKernel

class rascal::SparseKernel

Public Functions

inline SparseKernel(SparseKernel &&other) noexcept

Move constructor.

template<class Calculator, class StructureManagers, class SparsePoints>
inline math::Matrix_t compute(const Calculator &calculator, const StructureManagers &managers, const SparsePoints &sparse_points)

The root compute kernel function. It computes the kernel between 2 set of structures for a given representation specified by the calculator.

Parameters

• calculator – the calculator which has been used to calculate the representation on the two managers has been registered in the elements of managers and managers_b

• managers – a ManagerCollection or similar collection of structure managers

• managers_b – a ManagerCollection or similar collection of structure managers or a set of pseudo points

template<class Calculator, class StructureManagers, class SparsePoints>
inline math::Matrix_t compute_derivative(const Calculator &calculator, const StructureManagers &managers, const SparsePoints &sparse_points, const bool compute_neg_stress)

The root compute kernel function. It computes the kernel between the representation gradients of a set of structures with the set of pseudo points. The energy is defined as a sum of atomic contributions

\[ E(A) = \sum_{i \in A} \epsilon_{a_i}(X_i), \]

where \(\epsilon_{a_i}\) is an atomic energy function for atoms of type \(a_i\) modeled with a GPR model with sparse points \(T_m\)

\[ \epsilon_{a_i} (X_i) = \sum_m \alpha_m \delta_{b_m a_i} k(X_i,T_m), \]

where \(b_m\) is the atom type associated with the sparse point \(T_m\). To summarize our model, the energy is given by

\[ E(A) = \sum_m \alpha_m \sum_{i \in A} \delta_{b_m a_i} k(X_i,T_m), \]

thus the forces with respect to the position of atom \(i\) is in the kernel formulation

\[ \vec{\nabla}_i E = \sum_m \alpha_m \sum_{i \in A} \delta_{b_m a_i} \sum_{j \in i} \vec{\nabla}_i k(X_j,T_m), \]

and the virial negative stress

\[ \frac{ \partial E }{ \partial\eta_{\alpha\beta} } = \sum_m \alpha_m \sum_{i \in A} \delta_{b_m a_i} \frac{ \partial k(X_i, T_m) }{ \partial\eta_{\alpha\beta} }, \]

where \(\eta_{\alpha\beta}\) correspond to the 3x3 deformation (strain) tensor in the \(\alpha\beta \in \{xx, yy, zz, yz, xz, xy\}\) spatial dimensions (following Voigt convention).

Parameters

• calculator – the calculator which has been used to calculate the representation on the two managers has been registered in the elements of managers and managers_b

• sparse_points – class of pseudo points

• managers_b – a ManagerCollection or similar collection of structure managers

Public Members

std::vector<std::string> identifiers = {}

list of names identifying the properties that should be used to compute the kernels

Hypers_t parameters = {}

parameters of the kernel

internal::TargetType target_type = {}

Defines if the similarity is defined on the level of structures or per atom

template<>
struct rascal::internal::SparseKernelImpl<internal::SparseKernelType::GAP> : public rascal::internal::KernelImplBase

Implementation of the sparse kernel used in GAP. The kernel between local environments \(X_i^a\) and \(X_j^b\) with central atom types \(a\) and \(b\) is:

\[ k(X_i^a, X_j^b) = \delta_{ab} k(X_i, X_j), \]

where \(k(X_i, X_j)\) is the cosine kernel. When building a model for properties associated with the structure we assume that the training will be done on the property itself (not divided by the number of atoms).

It is particularly designed to build the \(K_{MM}\) and \(K_{NM}\) matrices needed by the sparse kernel formulation where the kernel matrix is given by:

\[ K = K_{MM} + K_{MN} \Lambda^{-2} K_{NM} \]

with \(\Lambda\) the regularization matrix.

Public Functions

template<class Property_t, internal::TargetType Type, std::enable_if_t<Type == internal::TargetType::Structure, int> = 0, class StructureManagers, class SparsePoints>
inline math::Matrix_t compute(StructureManagers &managers, SparsePoints &sparse_points, const std::string &representation_name)

Compute the kernel between a set of structure(s) and a set of pseudo points, per structure.

Template Parameters

StructureManagers – should be an iterable over shared pointer of structure managers like ManagerCollection

Parameters

• sparse_points – a SparsePoints* class

• managers – a ManagerCollection or similar collection of structure managers

• representation_name – name under which the representation data has been registered in the elements of managers and managers_b

Returns

kernel matrix

template<class SparsePoints>
inline math::Matrix_t compute(SparsePoints &sparse_points)

Compute the kernel between a set of pseudo points.

Template Parameters

SparsePoints – should be a set a set of SparsePoints

Parameters

sparse_points – a SparsePoints* class

Returns

kernel matrix MxM

template<class Property_t, internal::TargetType Type, std::enable_if_t<Type == internal::TargetType::Atom, int> = 0, class StructureManagers, class SparsePoints>
inline math::Matrix_t compute(const StructureManagers &managers, const SparsePoints &sparse_points, const std::string &representation_name)

Compute the kernel between a set of structure(s) and a set of pseudo points.

Template Parameters

StructureManagers – should be an iterable over shared pointer of structure managers like ManagerCollection

Parameters

• sparse_points – a SparsePoints* class

• managers – a ManagerCollection or similar collection of structure managers

• representation_name – name under which the representation data has been registered in the elements of managers and managers_b

Returns

kernel matrix

template<class Property_t, class PropertyGradient_t, internal::TargetType Type, std::enable_if_t<Type == internal::TargetType::Atom, int> = 0, class StructureManagers, class SparsePoints>
inline math::Matrix_t compute_derivative(StructureManagers &managers, SparsePoints &sparse_points, const std::string &representation_name, const std::string &representation_grad_name, const bool compute_neg_stress)

This documentation contains specific information for the GAP implementation See SparseKernel::compute_derivative for general kernel gradient derivation.

The storage of the kernel forces would scale with indices \(m\) x \(i\) x \(j\), but we don’t need to store individual neighbour contributions and can therefore contract over all neighbors of a particular center. This routine returns the already contracted kernel derivative for center \(X_i\)

\[ \sum_{j \in A_i} \vec{\nabla}_i k(X_j, T_m) \]

so the resulting matrix has the shape of the number of centers (index \(i\)) times 3 (three Cartesian dimensions) times the number of sparse points (index \(m\)). The number of centers and Cartesian dimensions are merged to one dimension, such that the x, y, z spatial dimensions appear in successive order in the row dimension.

The derivative of the kernel of environment \(X_j\) with respect to the position of \(\mathbf{r}_i\) atom \(i\) and the sparse point \(T_m\) is obtained by the chain rule

\[ \vec{\nabla}_i k(X_j, T_m) = \frac{ \partial k(X_j, T_m) }{ \partial \mathbf{r}_i } = \frac{ \partial k(X_j, T_m) }{ \partial X_{j} } \cdot \frac{ \partial X_j }{ \partial \mathbf{r}_i }, \]

where \(\cdot\) corresponds to the contraction of the chain rule. For the derivative of the GAP kernel we have:

\[ \frac{ \partial k(X_{j}, T_m) }{ \partial X_{j}} = \zeta (\sum_n X_{jn} T_{mn})^{\zeta-1} T_m \]

Besides that, the negative stress tensor in the kernel formulation is computed by also using the chain rule and contracting over the number of atoms dimension as

\[ \frac{ \partial k(X_j, T_m) }{ \partial\eta_{\alpha\beta} } = \sum_{i\in A} \sum_{j\in i} [\mathbf{r}_{ji} \otimes \vec{\nabla}_j k(X_i, T_m)]_{\alpha\beta}. \]

See https://aip.scitation.org/doi/full/10.1063/1.2214719 for more details with a short range potential. The elements are stored at the end of the returned matrix using the Voigt format (xx, yy, zz, zy, zx, yx) in the order of managers.

Template Parameters

StructureManagers – should be an iterable over shared pointer of structure managers like ManagerCollection

Parameters

• sparse_points – a SparsePoints* class

• managers – a ManagerCollection or similar collection of structure managers

• representation_name – name under which the representation gradient data has been registered in the elements of managers

• compute_neg_stress – the computed negative stresses are appended at the end of the kernel matrix

Returns

kernel matrix

Public Members

size_t zeta = {1}

exponent of the cosine kernel

Math utilities (namespace rascal::math)

class rascal::math::SphericalHarmonics

Compute a full set of spherical harmonics (optimized version)

Follows the algorithm described in https://arxiv.org/abs/1410.1748 except for an additonal \((-1)^m\) factor to follow the wikipedia article convention https://en.wikipedia.org/wiki/Spherical_harmonics#Real_form. It effectively cancels out the Condon-Shortley phase in the final real spherical harmonics.

In brief, this class computes the real spherical harmonics where the imaginary components of the usual complex functions are instead stored in the negative-m indices:

\[\begin{split}\begin{equation} Y_\ell^m(\theta, \phi) = \begin{cases} \sqrt{\frac{2\ell + 1}{2\pi} \frac{(\ell + m)!}{(\ell - m)!}} P_\ell^{-m}(\cos\theta) (-1)^m \sin(-m\phi) & \text{for } m < 0\\ \sqrt{\frac{2\ell + 1}{4\pi}} P_\ell(\cos\theta) & \text{for } m = 0\\ \sqrt{\frac{2\ell + 1}{2\pi} \frac{(\ell - m)!}{(\ell + m)!}} P_\ell^{m}(\cos\theta) (-1)^m \cos(m\phi) & \text{for } m > 0 \end{cases} \end{equation}\end{split}\]

Note that \(P_\ell^{m}\) includes the Condon-Shortley phase. In case you’re wondering why it’s \(\frac{1}{2π}\) on the \(m \neq 0\) components (instead of \(\frac{1}{4π}\)), there’s an extra factor of 1/2 that comes from integrating cos² or sin² over the full circle of φ, so these are indeed normalized in the same sense as the complex spherical harmonics:

\[ \iint_{\mathcal{S}^2} dΩ\; Y_\ell^m(θ, \phi) Y_{\ell'}^{m'}(θ, \phi) = δ_{\ell\ell'}δ_{mm'} \]

(this extra factor of \(\frac{1}{\sqrt{2}}\) is not included in the normalization of the associated Legendre polynomials defined above; however, all other normalization factors are.)

The class can also compute \((Y^m_l)^*\), with the real and imaginary parts of the complex conjugate are stored in a real-valued vector following the same convention.

Cartesian gradients can optionally be computed in addition.

Part of the efficiency derives from moving the direction-independent calculations into a separate precompute() method; you must therefore call precompute() (which also sets \(\ell_\text{max}\)) before any call to calc().

Once calc() has been called for a direction vector, the results can be retrieved with get_harmonics() (and the gradients, if computed, with get_harmonics_derivatives())

Note the storage order of the harmonics components here follows the “compressed” format, with the \(\ell\) index varying the slowest, from 0 to \(\ell_\text{max}\), and \(m\) varying from \(-\ell\) to \(\ell\) for each value of \(\ell\), for a total of \((\ell_\text{max}+1)^2\) components. For example, the first few entries of the array would have the \((\ell, m)\) numbers: (0,0) (1,-1) (1,0) (1, 1) (2, -2)….

Public Functions

inline explicit SphericalHarmonics(bool calculate_derivatives = false)

Construct a SphericalHarmonics class with a default setting for whether to calculate the gradients

Remember to call precompute to finish initialization

void precompute(size_t max_angular, bool calculate_derivatives = false)

Precomputes as many parameters as possible

Parameters

• max_angular – Maximum angular momentum number \(\ell_\text{max}\)

• calculate_derivatives – Whether to precompute for the derivatives as well. If the internal default (set at construction) is false, but the value provided here is true, the internal default will be set to true. If the value provided here is false (default argument) then the internal default is not changed; derivatives will be precomputed only if the internal default is true.

void calc(const Eigen::Ref<const Eigen::Vector3d> &direction, bool calculate_derivatives, bool conjugate = false)

Compute a full set of spherical harmonics given a direction vector. If calculate_derivatives flag is on, the derivatives are additionally computed. This function returns void, results have to be retrieved with get functions. The components are stored in real-valued format.

Warning

Prints warning and normalizes direction if it is not already normalized.

Parameters

• direction – unit vector defining the angles (arguments for the \(Y_\ell^m\))

• calculate_derivatives – Compute the gradients too?

• conjugate – Compute \((Y^m_l)^*\)?

inline void calc(const Eigen::Ref<const Eigen::Vector3d> &direction, bool conjugate = false)

Same as calc(), but using the internal default to decide whether to compute derivatives.

inline const Matrix_Ref get_assoc_legendre_polynom_raw()

Returns the (max_angular+1, max_angular+2) matrix related to the associated legendre polynomial with only zeros entries in the last column. Used for testing purposes.

inline const Vector_Ref get_harmonics()

Access the computed spherical harmonics.

Returns

(Eigen)matrix containing the results. Sized \((\ell_\text{max}+1)^2\), the index collects \(\ell\) and \(m\) quantum numbers stored in compact format ( \(m\) varies fastest, from \(-\ell\) to \(\ell\), and \(\ell\) from 0 to \(\ell_\text{max}\)).

inline const Matrix_Ref get_harmonics_derivatives()

Access the Cartesian gradients of the harmonics, if computed

Todo:

(alex) what happens if they haven’t been computed and this gets called anyway?

Returns

(Eigen)matrix containing the results. Sized 3 by \((\ell_\text{max}+1)^2\); the first index runs over the the x, y, and z gradient components and the second index collects \(\ell\) and \(m\) quantum numbers, stored in compact format ( \(m\) varies fastest, from \(-\ell\) to \(\ell\), and \(\ell\) from 0 to \(\ell_\text{max}\)).

Private Functions

void compute_assoc_legendre_polynom(double cos_theta)

Compute a set of normalized associated Legendre polynomials, namely \(P_\ell^{m}\).

These are normalized for use in computing the real spherical harmonics; see the class documentation for details. In particular, the \(m=0\) harmonics require an extra factor of \(\frac{1}{\sqrt{2}}\). The negative-m functions are not computed due to symmetry.

Note that \(P_\ell^{m}\) includes the Condon-Shortley phase.

Stores the results as an (Eigen)matrix containing the evaluated polynomials, sized \(\ell_\text{max}\) by \((2\ell_\text{max} + 1)\); the row is indexed by \(\ell\) and the column by \(m \geq 0\).

Parameters

cos_theta – (aka x) Where to evaluate the polynomial

void compute_cos_sin_angle_multiples(double cos_phi, double sin_phi)

Compute \((-1)^m\cos(m\phi)\) and \((-1)^m\sin(m\phi)\) from the recurrence relations

The relations are (these are the same recurrence relations used to calculate the Chebyshev polynomials):

\[\begin{split}\begin{eqnarray} \cos(m\phi) &=& 2\cos(\phi)\cos((m-1)\phi) - \cos((m-2)\phi)\\ \sin(m\phi) &=& 2\cos(\phi)\sin((m-1)\phi) - \sin((m-2)\phi) \end{eqnarray}\end{split}\]

and they require only \(\cos(\phi)\) and \(\sin(\phi)\) to start.

Stores the results as an (Eigen)matrix, sized \(m_\text{max}\) by 2 with the \((-1)^m\cos(m\phi)\) stored in the first column and \((-1)^m\sin(m\phi)\) in the second column, with \(m\) being the row index

Parameters

• cos_phi – Value of \(\cos(\phi)\) to start the relation

• sin_phi – Value of \(\sin(\phi)\) to start the relation

void compute_spherical_harmonics()

Combine the associated Legendre polynomials with the cos/sin(mφ) to compute the final spherical harmonics

Stores the results as an (Eigen)matrix, sized \((\ell_\text{max}+1)^2\). The index collects \(\ell\) and \(m\) quantum numbers stored in compact format ( \(m\) varies fastest, from \(-\ell\) to \(\ell\), and \(\ell\) from 0 to \(\ell_\text{max}\)).

void compute_spherical_harmonics_derivatives(double sin_theta, double cos_theta, double sin_phi, double cos_phi)

Compute a full set of spherical harmonics and their Cartesian gradients

Spherical harmonics are defined as described in compute_spherical_harmonics(). Gradients are defined with respect to motion of the neighbor atom, which is in accordance with the usual definition with respect to the arguments of the \(Y_\ell^m\). The actual Cartesian gradients include an extra factor of \(\frac{1}{r}\) that is not included here; the rest is independent of radius.

Results are stored as in compute_spherical_harmonics(), but with an extra (row) index for the x, y, and z Cartesian components.

class rascal::math::Hyp1f1

Computes the confluent hypergeometric function \({}_1F_1(a,b,z)\) for a given a and b and variable argument.

The class to bundles the two definitions of the 1F1 (Hyp1f1Asymptotic and Hyp1f1Series) and implements a switch rational (with bisection) to go between the two at construction. It works because we probe test at construction the domain of applicability of the two definitions.

Public Functions

inline double calc(double z, bool derivative = false)

Compute \({}_1F_1(a,b,z)\).

double calc(double z, double z2, double ez2, bool derivative = false)

Computes G(a,b,z)

Warning

the derivative outputed from this function is not \(dG/dz\) but \( \frac{\mathrm{d}\,{}_1F_1}{\mathrm{d}\,z} * \frac{\Gamma(a)}{\Gamma(b)} * \exp{-\alpha r_{ij}^2} \). We do this to avoid computing both \(d{}_1F_1/dz\) and \({}_1F_1\) when asking for gradients and perform this step in Hyp1f1SphericalExpansion.

Parameters

• z – -> \( pow(alpha * r_ij, 2) / (alpha + beta) \)

• z2 – -> argument of \( exp(-alpha*r_ij^2) \)

• ez2 – -> \( exp(-alpha*r_ij^2) \)

Index

namespace rascal

Typedefs

using LayerIncreaser_t = typename LayerIncreaser<std::index_sequence<LayersByOrder...>>::type

using LayerExtender_t = typename LayerExtender<std::index_sequence<LayersByOrder...>>::type

using Dim_t = int

typedef boost::mpl::list<MultipleStructureFixture<MultipleStructureManagerNLFixture>> multiple_fixtures

typedef boost::mpl::list<FilterFixture<StructureManagerCenters, 1>, FilterFixture<StructureManagerLammps, 2>> Fixtures

typedef boost::mpl::list<FilterFixture<StructureManagerCenters, 1>> FixturesMax1

typedef boost::mpl::list<FilterFixture<StructureManagerLammps, 2>> FixturesMax2

typedef boost::mpl::list<> FixturesMax3

using Fixtures_no_center = boost::mpl::list<MultipleStructureFixture<MultipleStructureManagerNLCCFixtureCenterMask>>

typedef boost::mpl::list<DemoTestFixture<2>, DemoTestFixture<3>> fixtures

using spherical_fixtures = boost::mpl::list<CalculatorFixture<MultipleStructureSphericalExpansion<MultipleStructureManagerNLCCStrictFixture>>, CalculatorFixture<MultipleStructureSphericalInvariants<MultipleStructureManagerNLCCStrictFixture>>>

using fixtures_ref_test = boost::mpl::list<CalculatorFixture<SortedCoulombTestData>, CalculatorFixture<SphericalExpansionTestData>, CalculatorFixture<SphericalInvariantsTestData>, CalculatorFixture<SphericalCovariantsTestData>>

using multiple_center_mask_fixtures = boost::mpl::list<CalculatorFixture<MultipleStructureSphericalExpansion<MultipleStructureManagerNLCCStrictFixtureCenterMask>>, CalculatorFixture<MultipleStructureSphericalCovariants<MultipleStructureManagerNLCCStrictFixtureCenterMask>>, CalculatorFixture<MultipleStructureSphericalInvariants<MultipleStructureManagerNLCCStrictFixtureCenterMask>>>

using grad_sparse_fixtures = boost::mpl::list<CalculatorFixture<ComplexHypersSphericalInvariants>>

using fixtures_with_gradients = boost::mpl::list<RadialIntegralHandlerFixture<MultipleHypersSphericalExpansion, internal::RadialBasisType::GTO, internal::AtomicSmearingType::Constant, internal::OptimizationType::None>, RadialIntegralHandlerFixture<MultipleHypersSphericalExpansion, internal::RadialBasisType::GTO, internal::AtomicSmearingType::Constant, internal::OptimizationType::Spline>, RadialIntegralHandlerFixture<MultipleHypersSphericalExpansion, internal::RadialBasisType::GTO, internal::AtomicSmearingType::Constant, internal::OptimizationType::RadialDimReductionSpline>, RadialIntegralHandlerFixture<MultipleHypersSphericalExpansion, internal::RadialBasisType::DVR, internal::AtomicSmearingType::Constant, internal::OptimizationType::None>, RadialIntegralHandlerFixture<MultipleHypersSphericalExpansion, internal::RadialBasisType::DVR, internal::AtomicSmearingType::Constant, internal::OptimizationType::Spline>, RadialIntegralHandlerFixture<MultipleHypersSphericalExpansion, internal::RadialBasisType::DVR, internal::AtomicSmearingType::Constant, internal::OptimizationType::RadialDimReductionSpline>>

using gradient_fixtures = boost::mpl::list<CalculatorFixture<SingleHypersSphericalExpansion<SimplePeriodicNLCCStrictFixture>>, CalculatorFixture<SingleHypersSphericalInvariants<SimplePeriodicNLCCStrictFixture>>>

using sparsification_fixtures = boost::mpl::list<CalculatorFixture<SparsificationSphericalInvariantsFixture>>

using gradient_half_fixtures = boost::mpl::list<MergeHalfAndFull<SimpleFullFixture, SimpleHalfFixture, CalculatorSphericalExpansion>, MergeHalfAndFull<SimpleFullFixture, SimpleHalfFixture, CalculatorSphericalInvariants>>

using multiple_ref_fixtures = boost::mpl::list<KernelFixture<DataSphericalInvariantsKernelFixture>>

using KeyFixtures = boost::mpl::list<KeyFixture<1, 2>, KeyFixture<2, 2>, KeyFixture<1, 3>, KeyFixture<2, 3>, KeyFixture<3, 3>, KeyFixture<7, 8>>

using Vec3_t = Eigen::Matrix<double, Dim, 1>

using Cell_t = typename AtomicStructure<Dim>::Cell_t

using fixtures_test = boost::mpl::list<CollectionFixture<StrictNLCCCollectionFixture>>

using IntpScalarUniformCubicSpline = math::InterpolatorScalarUniformCubicSpline<math::RefinementMethod_t::Exponential>

using IntpScalarUniformCubicSplineRelativeError = math::InterpolatorScalarUniformCubicSpline<math::RefinementMethod_t::Exponential, math::ErrorMethod<math::ErrorMetric_t::Relative>>

using IntpMatrixUniformCubicSpline = math::InterpolatorMatrixUniformCubicSpline<math::RefinementMethod_t::Exponential>

using interpolator_fixtures = boost::mpl::list<InterpolatorFixture<IntpScalarUniformCubicSpline>, InterpolatorFixture<IntpScalarUniformCubicSplineRelativeError>, InterpolatorFixture<IntpMatrixUniformCubicSpline>>

using Vector_t = math::Vector_t

using Matrix_t = math::Matrix_t

using Vector_Ref = math::Vector_Ref

using Matrix_Ref = math::Matrix_Ref

using AbsoluteErrorMethod = math::ErrorMethod<math::ErrorMetric_t::Absolute>

using RelativeErrorMethod = math::ErrorMethod<math::ErrorMetric_t::Relative>

using atom_vector_property_fixtures = OrderOnePropertyBoostList::type

using pair_property_fixtures = OrderTwoPropertyBoostList::type

using triple_property_fixtures = OrderThreePropertyBoostList::type

using ANLWithGhosts_SMC_StackFixture = AdaptorNeighbourListStackFixture<StructureManagerCentersStackFixture>

using ManagerCollection_t = ManagerCollection<StructureManagerCenters, AdaptorNeighbourList, AdaptorCenterContribution, AdaptorStrict>

using sparse_grad_fixtures = boost::mpl::list<SparseKernelGradFixture>

using pair_fixtures = boost::mpl::list<ManagerFixture<StructureManagerLammps>>

using PyCalculator = py::class_<Calculator, CalculatorBase>

using LayerByOrder = typename SMI::traits::LayerByOrder

using ClusterRefkey_t = ClusterRefKey<Order, HelperLayer<SMI, Order>::layer>

using ClusterRef_t = typename StructureManager<SMI>::template ClusterRef<Order>

using PyClusterRef = py::class_<ClusterRef_t<SMI, Order>, ClusterRefkey_t<SMI, Order>>

using PyManager = py::class_<StructureManagerImplementation, StructureManager<StructureManagerImplementation>, std::shared_ptr<StructureManagerImplementation>>

using ArrayConstRef_t = const Eigen::Ref<const Eigen::Array<T, Eigen::Dynamic, 1>>

Functions

constexpr std::size_t operator""_size_t(unsigned long long int n)

template<internal::KernelType Type, class Hypers>
std::shared_ptr<internal::KernelImplBase> make_kernel_impl(const Hypers &hypers)

template<internal::KernelType Type>
std::shared_ptr<internal::KernelImpl<Type>> downcast_kernel_impl(std::shared_ptr<internal::KernelImplBase> &kernel_impl)

template<class KernelImpl, class Calculator, class Manager, class SparsePoints>
math::Matrix_t compute_kernel_for_displaced_strain_tensor(KernelImpl &kernel, Calculator &calculator, Manager &manager, const SparsePoints &sparse_points, const int &alpha_spatial_dim, const int &beta_spatial_dim, const double &h_disp)

template<class KernelImpl, class Calculator, class Manager, class SparsePoints, typename Derived>
math::Matrix_t compute_displaced_kernel(KernelImpl &kernel, Calculator &calculator, Manager &manager, const SparsePoints &sparse_points, const size_t &i_atom, const Eigen::MatrixBase<Derived> &disp)

template<class KernelImpl, class Calculator, class Manager, class SparsePoints>
math::Matrix_t compute_numerical_kernel_gradient(KernelImpl &kernel, Calculator &calculator, Manager &manager, const SparsePoints &sparse_points, const double &h_disp)

template<class KernelImpl, class Calculator, class Manager, class SparsePoints>
math::Matrix_t compute_numerical_kernel_stress(KernelImpl &kernel, Calculator &calculator, Manager &manager, const SparsePoints &sparse_points, const double &h_disp)

template<class KernelImpl, class Calculator, class Managers, class SparsePoints>
math::Matrix_t compute_numerical_kernel_gradients(KernelImpl &kernel, Calculator &calculator, Managers &managers, const SparsePoints &sparse_points, double h_disp = 1e-5, const bool compute_stress = false)

template<class Property_t, class PropertyGradient_t, class StructureManager, class SparsePoints>
void compute_partial_gradients_gap(StructureManager &manager, SparsePoints &sparse_points, math::Vector_t &weights, const size_t zeta, const std::string &representation_name, const std::string &representation_grad_name, const std::string &pair_grad_atom_i_r_j_name)

template<class Calculator, class StructureManagers, class SparsePoints>
std::string compute_sparse_kernel_gradients(const Calculator &calculator, SparseKernel &kernel, StructureManagers &managers, SparsePoints &sparse_points, math::Vector_t &weights)

template<class Calculator, class StructureManagers, class SparsePoints>
std::string compute_sparse_kernel_neg_stress(const Calculator &calculator, SparseKernel &kernel, StructureManagers &managers, SparsePoints &sparse_points, math::Vector_t &weights)

template<internal::SparseKernelType Type, class Hypers>
std::shared_ptr<internal::KernelImplBase> make_sparse_kernel_impl(const Hypers &hypers)

template<internal::SparseKernelType Type>
std::shared_ptr<internal::SparseKernelImpl<Type>> downcast_sparse_kernel_impl(std::shared_ptr<internal::KernelImplBase> &kernel_impl)

template<class Calculator>
void to_json(json &j, const SparsePointsBlockSparse<Calculator> &sparse_points)

template<class Calculator>
void from_json(const json &j, SparsePointsBlockSparse<Calculator> &sparse_points)

template<internal::RadialBasisType Type, class Hypers>
auto make_radial_integral(const Hypers &basis_hypers)

template<internal::RadialBasisType Type>
auto downcast_radial_integral(const std::shared_ptr<internal::RadialContributionBase> &radial_integral)

template<internal::RadialBasisType RBT, internal::AtomicSmearingType AST, internal::OptimizationType OT, class Hypers>
auto make_radial_integral_handler(const Hypers &basis_hypers)

template<internal::RadialBasisType RBT, internal::AtomicSmearingType AST, internal::OptimizationType OT>
auto downcast_radial_integral_handler(const std::shared_ptr<internal::RadialContributionBase> &radial_integral)

template<internal::CutoffFunctionType Type, class Hypers>
auto make_cutoff_function(const Hypers &fc_hypers)

template<internal::CutoffFunctionType Type>
auto downcast_cutoff_function(std::shared_ptr<internal::CutoffFunctionBase> &cutoff_function)

template<int Dim>
void to_json(json &j, const AtomicStructure<Dim> &s)

template<int Dim>
void from_json(const json &j, AtomicStructure<Dim> &s)

template<size_t Index, size_t... Ints>
constexpr size_t get_index_from_sequence(const std::index_sequence<Ints...>&)

template<size_t Order, size_t... Ints>
constexpr size_t get_layer(const std::index_sequence<Ints...> &layers_by_order)

template<size_t MaxOrder, size_t... Ints>
constexpr size_t get_dyn_layer(size_t order, const std::index_sequence<Ints...> &layers_by_order)

template<size_t... Ints>
constexpr std::array<size_t, sizeof...(Ints)> index_sequence_to_array(const std::index_sequence<Ints...>&)

template<size_t ActiveMaxOrder, size_t... LayersByOrder>
constexpr size_t get_min_layer(const std::index_sequence<LayersByOrder...>&)

template<typename Manager>
std::shared_ptr<Manager> make_structure_manager()

template<template<class> class Adaptor, typename Manager, typename ...Args>
std::shared_ptr<Adaptor<Manager>> make_adapted_manager(std::shared_ptr<Manager> &arg, const Args&... args)

template<template<class> class Adaptor, typename Manager, typename Hypers_t>
std::shared_ptr<Adaptor<Manager>> make_adapted_manager_hypers(std::shared_ptr<Manager> &arg, const Hypers_t &adaptor_hypers)

template<typename Manager, template<class> class ...AdaptorImplementationPack, typename Hypers_t>
auto make_structure_manager_stack(const Hypers_t &structure_inputs, const Hypers_t &adaptor_inputs)

template<typename Manager, template<class> class ...AdaptorImplementationPack, typename Hypers_t>
auto stack_adaptors(std::shared_ptr<Manager> &manager_base, const Hypers_t &hypers)

template<int TargetLevel, typename StructureManager>
auto extract_underlying_manager(std::shared_ptr<StructureManager> manager)

template<typename T>
auto begin(std::shared_ptr<T> ptr) -> typename T::iterator

template<typename T>
auto end(std::shared_ptr<T> ptr) -> typename T::iterator

BOOST_AUTO_TEST_SUITE(adaptor_center_contribution_test)

BOOST_FIXTURE_TEST_CASE_TEMPLATE(constructor_test, Fix, multiple_fixtures, Fix)

BOOST_FIXTURE_TEST_CASE_TEMPLATE(update_test, Fix, multiple_fixtures, Fix)

BOOST_FIXTURE_TEST_CASE_TEMPLATE(iterator_test, Fix, multiple_fixtures, Fix)

BOOST_FIXTURE_TEST_CASE_TEMPLATE(get_atom_j_test, Fix, multiple_fixtures, Fix)

BOOST_FIXTURE_TEST_CASE_TEMPLATE(get_atom_ii_test, Fix, multiple_fixtures, Fix)

BOOST_FIXTURE_TEST_CASE_TEMPLATE(get_atom_jj_test, Fix, multiple_fixtures, Fix)

BOOST_FIXTURE_TEST_CASE_TEMPLATE(atom_ii_property_test, Fix, multiple_fixtures, Fix)

BOOST_AUTO_TEST_SUITE_END()

BOOST_AUTO_TEST_SUITE(test_adaptor_filter)

BOOST_FIXTURE_TEST_CASE_TEMPLATE(constructor_test, Fix, Fixtures, Fix)

BOOST_FIXTURE_TEST_CASE_TEMPLATE(filter_1_test, Fix, FixturesMax1, Fix)

BOOST_FIXTURE_TEST_CASE_TEMPLATE(filter_2_test, Fix, FixturesMax2, Fix)

BOOST_AUTO_TEST_SUITE(half_neighbourlist_adaptor_test)

BOOST_FIXTURE_TEST_CASE(constructor_test, ManagerFixture<StructureManagerLammps>)

BOOST_FIXTURE_TEST_CASE(iteration_and_distance_half_list, ManagerFixture<StructureManagerLammps>)

BOOST_FIXTURE_TEST_CASE(full_to_half_to_full_neighbour_list, ManagerFixture<StructureManagerLammps>)

BOOST_AUTO_TEST_SUITE(maxlevel_increase_adaptor_test)

BOOST_FIXTURE_TEST_CASE(constructor_test, PairFixtureFile<StructureManagerCenters>)

BOOST_FIXTURE_TEST_CASE(iterator_test, PairFixtureFile<StructureManagerCenters>)

BOOST_FIXTURE_TEST_CASE(pair_to_triplet_extension, ManagerFixture<StructureManagerLammps>)

BOOST_AUTO_TEST_SUITE(kspace_adaptor_test)

BOOST_FIXTURE_TEST_CASE(get_atom_j_test, ManagerFixture<StructureManagerCenters>)

BOOST_FIXTURE_TEST_CASE_TEMPLATE(test_build_neighbour_multiple, Fix, multiple_fixtures, Fix)

BOOST_FIXTURE_TEST_CASE_TEMPLATE(test_idx_consistency, Fix, multiple_fixtures, Fix)

BOOST_FIXTURE_TEST_CASE_TEMPLATE(test_index_completeness, Fix, multiple_fixtures, Fix)

BOOST_AUTO_TEST_SUITE(neighbour_list_adaptor_test)

BOOST_FIXTURE_TEST_CASE(simple_cubic_9_neighbour_list, PairFixtureSimple<StructureManagerCenters>)

BOOST_FIXTURE_TEST_CASE(constructor_test_hcp, ManagerFixtureTwoHcp)

BOOST_FIXTURE_TEST_CASE(constructor_test_fcc, ManagerFixtureTwoFcc)

BOOST_FIXTURE_TEST_CASE(test_build_neighbour_simple, PairFixtureSimple<StructureManagerCenters>)

BOOST_FIXTURE_TEST_CASE(neighbourlist_test_hcp, ManagerFixtureTwoHcp)

BOOST_FIXTURE_TEST_CASE(neighbourlist_test_fcc, ManagerFixtureTwoFcc)

BOOST_FIXTURE_TEST_CASE(test_neighbour_list_skewed, ManagerFixtureSkew)

BOOST_FIXTURE_TEST_CASE(neighbourlist_edge_case_epsilon_rcut, ManagerFixtureSkewDeltaRcut)

BOOST_AUTO_TEST_SUITE(adaptor_strict_test)

BOOST_FIXTURE_TEST_CASE_TEMPLATE(multiple_strict_test, Fix, multiple_fixtures, Fix)

BOOST_FIXTURE_TEST_CASE_TEMPLATE(multiple_no_center_test, Fix, Fixtures_no_center, Fix)

BOOST_FIXTURE_TEST_CASE(strict_test_hcp, ManagerFixtureTwoHcp)

BOOST_AUTO_TEST_SUITE(AtomicStructureTests)

BOOST_FIXTURE_TEST_CASE(atomic_structure_test, AtomicStructureFixture)

BOOST_FIXTURE_TEST_CASE(wrap_positions_test, AtomicStructureFixture)

BOOST_FIXTURE_TEST_CASE(empty_unit_cell_test, AtomicStructureFixture)

BOOST_AUTO_TEST_SUITE(base_tests)

BOOST_AUTO_TEST_CASE(base_test)

BOOST_FIXTURE_TEST_CASE_TEMPLATE(templated_basic_fixture_test, Fix, fixtures, Fix)

BOOST_AUTO_TEST_SUITE(representation_test)

double extract_interaction_cutoff_from_representation_hyper(json hyper)

BOOST_AUTO_TEST_CASE(rownorm_sort_test)

BOOST_AUTO_TEST_CASE(distance_sort_test)

BOOST_FIXTURE_TEST_CASE_TEMPLATE(multiple_constructor_test, Fix, multiple_fixtures, Fix)

BOOST_FIXTURE_TEST_CASE_TEMPLATE(multiple_dense_feature_comparison, Fix, multiple_fixtures, Fix)

BOOST_FIXTURE_TEST_CASE_TEMPLATE(spherical_number_feature_comparison, Fix, spherical_fixtures, Fix)

BOOST_FIXTURE_TEST_CASE_TEMPLATE(serialization_test, Fix, multiple_fixtures, Fix)

BOOST_FIXTURE_TEST_CASE_TEMPLATE(multiple_no_center_test, Fix, multiple_fixtures, Fix)

BOOST_FIXTURE_TEST_CASE_TEMPLATE(multiple_center_mask_test, Fix, multiple_center_mask_fixtures, Fix)

BOOST_FIXTURE_TEST_CASE_TEMPLATE(sparse_grad_test, Fix, grad_sparse_fixtures, Fix)

BOOST_FIXTURE_TEST_CASE_TEMPLATE(multiple_reference_test, Fix, fixtures_ref_test, Fix)

BOOST_FIXTURE_TEST_CASE_TEMPLATE(spherical_expansion_radial_derivative, Fix, fixtures_with_gradients, Fix)

BOOST_FIXTURE_TEST_CASE_TEMPLATE(spherical_representation_gradients, Fix, gradient_fixtures, Fix)

BOOST_FIXTURE_TEST_CASE_TEMPLATE(sparsification_test, Fix, sparsification_fixtures, Fix)

BOOST_FIXTURE_TEST_CASE_TEMPLATE(half_full_representation_test, Fix, gradient_half_fixtures, Fix)

BOOST_AUTO_TEST_SUITE(test_cluster_ref_key)

BOOST_AUTO_TEST_CASE(test_get_min_layer)

BOOST_FIXTURE_TEST_CASE(test_get_layer, LayerFixture)

BOOST_FIXTURE_TEST_CASE(test_index_sequence_to_array, LayerFixture)

BOOST_AUTO_TEST_CASE(test_layer_extender)

BOOST_AUTO_TEST_CASE(test_layer_increaser)

template<size_t... Ints>
void print_index_sequence(std::index_sequence<Ints...>)

template<size_t Length, size_t... Ints>
static void print_index_sequence(std::index_sequence<Ints...>)

BOOST_AUTO_TEST_SUITE(cutoff_tests)

BOOST_AUTO_TEST_CASE(shifted_cosine_gradient_test)

BOOST_AUTO_TEST_CASE(radial_scaling_gradient_test)

BOOST_AUTO_TEST_CASE(radial_scaling_exponent_zero_test)

BOOST_AUTO_TEST_SUITE(kernels_test)

BOOST_FIXTURE_TEST_CASE(kernel_target_type_test, KernelFixture<DataSphericalInvariantsKernelFixture>)

BOOST_FIXTURE_TEST_CASE_TEMPLATE(kernel_ref_data_test, Fix, multiple_ref_fixtures, Fix)

BOOST_FIXTURE_TEST_CASE_TEMPLATE(species_method_test, Fix, multiple_ref_fixtures, Fix)

BOOST_FIXTURE_TEST_CASE_TEMPLATE(multiple_kernel_compute_test, Fix, multiple_fixtures, Fix)

template<typename T, size_t Order>
std::ostream &operator<<(std::ostream &os, const KeyStandardisation<T, Order> &index)

BOOST_AUTO_TEST_SUITE(key_standardisation_test)

BOOST_FIXTURE_TEST_CASE_TEMPLATE(constructor_test, Fix, KeyFixtures, Fix)

BOOST_FIXTURE_TEST_CASE_TEMPLATE(iterator_test, Fix, KeyFixtures, Fix)

BOOST_AUTO_TEST_SUITE(LatticeTests)

BOOST_FIXTURE_TEST_CASE(lattice_constructor_test, ManagerFixtureLattice)

BOOST_FIXTURE_TEST_CASE(cell_length_test, ManagerFixtureLattice)

BOOST_FIXTURE_TEST_CASE(cell_angles_test, ManagerFixtureLattice)

BOOST_FIXTURE_TEST_CASE(transformation_matrix_test, ManagerFixtureLattice)

BOOST_FIXTURE_TEST_CASE(get_cartesian2scaled_test, ManagerFixtureLattice)

BOOST_FIXTURE_TEST_CASE(get_scaled2cartesian_test, ManagerFixtureLattice)

BOOST_FIXTURE_TEST_CASE(crossproduct_test, ManagerFixtureLattice)

BOOST_FIXTURE_TEST_CASE(set_reciprocal_vectors_test, ManagerFixtureLattice)

BOOST_AUTO_TEST_SUITE(manager_collection_test)

BOOST_FIXTURE_TEST_CASE_TEMPLATE(load_multiple_structures_test, Fix, fixtures_test, Fix)

BOOST_FIXTURE_TEST_CASE_TEMPLATE(iterate_structures_test, Fix, fixtures_test, Fix)

BOOST_FIXTURE_TEST_CASE_TEMPLATE(add_structures_test, Fix, fixtures_test, Fix)

template<typename FunctionProvider_t, typename TestFixture_t>
void test_gradients(FunctionProvider_t function_calculator, TestFixture_t params)

BOOST_AUTO_TEST_SUITE(MathGaussLegendreTests)

BOOST_FIXTURE_TEST_CASE(math_gauss_legendre_test, GaussLegendreRefFixture)

BOOST_AUTO_TEST_SUITE(MathHyp1f1Tests)

BOOST_FIXTURE_TEST_CASE(math_hyp1f1_test, Hyp1F1RefFixture)

BOOST_FIXTURE_TEST_CASE(math_hyp1f1_spherical_expansion_test, Hyp1f1SphericalExpansionFixture)

BOOST_AUTO_TEST_CASE(hyp1f1_gradient_test)

BOOST_AUTO_TEST_SUITE(MathInterpolatorTests)

BOOST_FIXTURE_TEST_CASE_TEMPLATE(interpolator_constructor_test, Fix, interpolator_fixtures, Fix)

BOOST_FIXTURE_TEST_CASE_TEMPLATE(functions_interpolator_test, Fix, interpolator_fixtures, Fix)

BOOST_FIXTURE_TEST_CASE_TEMPLATE(hyp1f1_interpolator_test, Fix, interpolator_fixtures, Fix)

BOOST_FIXTURE_TEST_CASE(radial_contribution_test, InterpolatorFixture<IntpScalarUniformCubicSpline>)

BOOST_FIXTURE_TEST_CASE_TEMPLATE(functions_derivative_interpolator_test, Fix, interpolator_fixtures, Fix)

BOOST_FIXTURE_TEST_CASE(radial_contribution_matrix_interpolator_test, InterpolatorFixture<IntpMatrixUniformCubicSpline>)

static double convert_to_scalar(const double x)

static double convert_to_scalar(const math::Matrix_t &mat)

template<class ErrorMethod, class Interpolator>
static double compute_intp_error(std::shared_ptr<Interpolator> &intp, std::function<double(double)> ref_func, const math::Vector_Ref &ref_points)

template<class ErrorMethod, class Interpolator>
static double compute_intp_derivative_error(const std::shared_ptr<Interpolator> &intp, std::function<double(double)> derivative_func, const math::Vector_Ref &ref_points)

template<class ErrorMethod, class Interpolator>
static double compute_intp_finite_diff_error(const std::shared_ptr<Interpolator> &intp, std::function<double(double)> derivative_func, const math::Vector_Ref &ref_points)

template<class ErrorMethod>
static double compute_finite_diff_error(std::function<double(double)> func, std::function<double(double)> derivative_func, const math::Vector_Ref &ref_points)

BOOST_AUTO_TEST_SUITE(test_kvecgenerator)

BOOST_AUTO_TEST_CASE(kvecgen_smallcells_test)

BOOST_FIXTURE_TEST_CASE(kvecgen_allvecs_in_ball_test, KvecgenRefFixture)

BOOST_FIXTURE_TEST_CASE(kvecgen_numvectors_reasonable_test, KvecgenRefFixture)

BOOST_FIXTURE_TEST_CASE(kvecgen_scaling_test, KvecgenRefFixture)

BOOST_AUTO_TEST_CASE(kvecgen_rotation_test)

BOOST_AUTO_TEST_SUITE(MathBesselFirstKindTests)

BOOST_FIXTURE_TEST_CASE(math_bessel_test, ModifiedBesselFirstKindRefFixture)

BOOST_AUTO_TEST_CASE(MBFs_gradient_test)

BOOST_AUTO_TEST_SUITE(MathSphericalHarmonicsTests)

BOOST_FIXTURE_TEST_CASE(math_spherical_harmonics_test, SphericalHarmonicsClassRefFixture)

BOOST_FIXTURE_TEST_CASE(math_associated_legendre_polynomial_test, SphericalHarmonicsClassRefFixture)

BOOST_AUTO_TEST_CASE(spherical_harmonics_gradient_test)

BOOST_AUTO_TEST_SUITE(property_tests)

BOOST_FIXTURE_TEST_CASE(atom_order_one_constructor_tests, AtomPropertyFixture<StructureManagerCentersStackFixture>)

BOOST_FIXTURE_TEST_CASE_TEMPLATE(atom_constructor_tests, Fix, atom_vector_property_fixtures, Fix)

BOOST_FIXTURE_TEST_CASE_TEMPLATE(pair_constructor_tests, Fix, pair_property_fixtures, Fix)

BOOST_FIXTURE_TEST_CASE_TEMPLATE(triple_constructor_tests, Fix, triple_property_fixtures, Fix)

BOOST_FIXTURE_TEST_CASE(property_typed_runtime_error, AtomPropertyFixture<StructureManagerCentersStackFixture>)

BOOST_FIXTURE_TEST_CASE(fill_atom_vector_property_order_one_test, AtomPropertyFixture<StructureManagerCentersStackFixture>)

BOOST_FIXTURE_TEST_CASE_TEMPLATE(structure_dynamic_property_test, Fix, atom_vector_property_fixtures, Fix)

BOOST_FIXTURE_TEST_CASE_TEMPLATE(fill_sequence_test, Fix, atom_vector_property_fixtures, Fix)

BOOST_FIXTURE_TEST_CASE_TEMPLATE(fill_atom_vector_property_test, Fix, atom_vector_property_fixtures, Fix)

BOOST_FIXTURE_TEST_CASE_TEMPLATE(fill_pair_property_test, Fix, pair_property_fixtures, Fix)

BOOST_FIXTURE_TEST_CASE_TEMPLATE(fill_triple_property_test, Fix, triple_property_fixtures, Fix)

BOOST_FIXTURE_TEST_CASE_TEMPLATE(atom_vector_property_fixtures_tests, Fix, atom_vector_property_fixtures, Fix)

BOOST_FIXTURE_TEST_CASE_TEMPLATE(atom_vector_property_access_with_pair_tests, Fix, pair_property_fixtures, Fix)

BOOST_FIXTURE_TEST_CASE_TEMPLATE(order_three_constructor_tests, Fix, triple_property_fixtures, Fix)

BOOST_FIXTURE_TEST_CASE_TEMPLATE(atom_vector_property_access_with_triple_tests, Fix, triple_property_fixtures, Fix)

BOOST_FIXTURE_TEST_CASE_TEMPLATE(fill_test_simple_order_one_property, Fix, pair_property_fixtures, Fix)

BOOST_FIXTURE_TEST_CASE_TEMPLATE(meta_data_test, Fix, atom_vector_property_fixtures, Fix)

BOOST_FIXTURE_TEST_CASE_TEMPLATE(fill_test_complex, Fix, pair_property_fixtures, Fix)

BOOST_FIXTURE_TEST_CASE_TEMPLATE(compute_distances, Fix, pair_property_fixtures, Fix)

BOOST_AUTO_TEST_SUITE(property_structure_manager_property_tests)

BOOST_FIXTURE_TEST_CASE(create_property, StructureManagerCentersStackFixture)

BOOST_FIXTURE_TEST_CASE(property_forwarding_two_layers, ANLWithGhosts_SMC_StackFixture)

BOOST_FIXTURE_TEST_CASE(property_forwarding_three_layers, AdaptorStrictStackFixture<ANLWithGhosts_SMC_StackFixture>)

BOOST_AUTO_TEST_SUITE(Property_partially_sparse_tests)

BOOST_FIXTURE_TEST_CASE(constructor_test, BlockSparsePropertyFixture<1>)

BOOST_FIXTURE_TEST_CASE_TEMPLATE(fill_test_simple, Fix, Fixtures, Fix)

BOOST_FIXTURE_TEST_CASE(meta_data_test, BlockSparsePropertyFixture<1>)

BOOST_AUTO_TEST_SUITE(tests_without_reference_data)

BOOST_FIXTURE_TEST_CASE(caller_layer_test, ManagerFixture<StructureManagerLammps>)

BOOST_AUTO_TEST_SUITE(sparse_points_test)

BOOST_FIXTURE_TEST_CASE_TEMPLATE(data_matching_test, Fix, multiple_fixtures, Fix)

BOOST_AUTO_TEST_SUITE(RascalUtilityTests)

BOOST_AUTO_TEST_CASE(combine_enums_test)

BOOST_AUTO_TEST_SUITE(sparse_kernels_test)

BOOST_FIXTURE_TEST_CASE_TEMPLATE(grad_test, Fix, sparse_grad_fixtures, Fix)

BOOST_FIXTURE_TEST_CASE_TEMPLATE(grad_stress_test, Fix, sparse_grad_fixtures, Fix)

BOOST_AUTO_TEST_SUITE(adaptor_filter_species_test)

BOOST_FIXTURE_TEST_CASE_TEMPLATE(atom_species_test, Fix, FixturesMax1, Fix)

BOOST_FIXTURE_TEST_CASE_TEMPLATE(pair_species_test, Fix, FixturesMax2, Fix)

BOOST_AUTO_TEST_SUITE(ManagerCentersTests)

BOOST_FIXTURE_TEST_CASE(manager_centers_constructor_test, ManagerFixture<StructureManagerCenters>)

BOOST_FIXTURE_TEST_CASE(iterator_test, ManagerFixture<StructureManagerCenters>)

BOOST_FIXTURE_TEST_CASE(atom_bound_test, ManagerFixture<StructureManagerCenters>)

BOOST_FIXTURE_TEST_CASE(simple_cubic_9_neighbour_list, ManagerFixtureFile<StructureManagerCenters>)

BOOST_FIXTURE_TEST_CASE(manager_update_test, ManagerFixture<StructureManagerCenters>)

BOOST_AUTO_TEST_SUITE(structure_managers_interface)

BOOST_FIXTURE_TEST_CASE_TEMPLATE(templated_constructor_test, Fix, fixtures, Fix)

BOOST_FIXTURE_TEST_CASE_TEMPLATE(templated_size_consistency, Fix, fixtures, Fix)

BOOST_FIXTURE_TEST_CASE_TEMPLATE(templated_atom_taging, Fix, fixtures, Fix)

BOOST_FIXTURE_TEST_CASE_TEMPLATE(templated_atom_global_indexing, Fix, fixtures, Fix)

BOOST_FIXTURE_TEST_CASE_TEMPLATE(templated_pair_global_indexing, Fix, pair_fixtures, Fix)

BOOST_AUTO_TEST_SUITE(ManagerTests)

BOOST_FIXTURE_TEST_CASE(iterator_test, ManagerFixture<StructureManagerLammps>)

BOOST_FIXTURE_TEST_CASE(interface_test, ManagerFixture<StructureManagerLammps>)

BOOST_AUTO_TEST_SUITE(test_utils)

BOOST_AUTO_TEST_CASE(type_demangling_test)

template<class Kernel>
static py::class_<Kernel> add_kernel(py::module &mod, py::module&)

template<internal::KernelType Type, class Calculator, class StructureManagers, class CalculatorBind>
void bind_kernel_compute_function(CalculatorBind &kernel)

template<internal::SparseKernelType Type, class Calculator, class StructureManagers, class SparsePoints, class CalculatorBind>
void bind_sparse_kernel_compute_function(CalculatorBind &kernel)

template<class SparsePoints>
static py::class_<SparsePoints> add_sparse_points(py::module &mod, py::module&)

template<class ManagerCollection, class Calculator, class SparsePoints>
void bind_sparse_points_push_back(py::class_<SparsePoints> &sparse_points)

template<class KernelImpl, class Calculator, class Managers, class SparsePoints>
void bind_compute_numerical_kernel_gradients(py::module &mod)

template<class ManagerCollection, class Calculator, class SparsePoints>
void bind_compute_gradients(py::module &mod, py::module&)

void add_models(py::module &mod, py::module &m_internal)

template<typename Calculator>
auto add_representation_calculator(py::module &mod, py::module&)

template<class Calculator, typename Manager, template<class> class ...Adaptor>
void bind_get_num_coefficients_function(PyCalculator<Calculator> &representation)

template<class Calculator, typename Manager, template<class> class ...Adaptor>
void bind_compute_function(PyCalculator<Calculator> &representation)

template<typename StructureManagerTypeHolder_, class Calculator>
void bind_compute_function_helper(PyCalculator<Calculator> &representation)

template<typename StructureManagerTypeHolder_, class Calculator>
void bind_get_num_coefficients_function_helper(PyCalculator<Calculator> &representation)

void add_representation_calculators(py::module &mod, py::module &m_internal)

template<size_t Order, size_t Layer>
void add_cluster_ref(py::module &m)

template<size_t Order, typename SMI>
auto add_cluster(py::module &m)

template<class StructureManagerImplementation, class PyCluterRef_t, size_t Order, size_t... Orders>
void add_iterators_helpers(py::module &m, PyCluterRef_t &py_cluster, std::index_sequence<Order, Orders...>)

template<class StructureManagerImplementation, class PyCluterRef_t>
void add_iterators_helpers(py::module&, PyCluterRef_t&, std::index_sequence<>)

template<class StructureManagerImplementation, class PyCluterRef_t>
void add_iterators(py::module &m, PyCluterRef_t &py_cluster)

template<typename Manager_t>
auto add_manager(py::module &mod)

template<typename Manager_t>
auto add_manager_safe(py::module &mod, const std::string &manager_name)

template<typename StructureManagerImplementation>
auto add_structure_manager_interface(py::module &m)

template<typename StructureManagerImplementation>
auto add_structure_manager_implementation(py::module &m, py::module &m_internal)

template<typename StructureManagerImplementation>
void bind_update_unpacked(PyManager<StructureManagerImplementation> &manager)

template<typename StructureManagerImplementation>
void bind_update_empty(PyManager<StructureManagerImplementation> &manager)

template<typename Manager_t>
void bind_make_structure_manager(py::module &m_str_mng)

template<template<class> class Adaptor, typename Manager_t>
void bind_make_adapted_manager(py::module &m_adaptor)

template<class Calculator, class ManagerCollection_t, class ManagerCollectionBinder>
void bind_feature_matrix_getter(ManagerCollectionBinder &manager_collection)

template<class ManagerCollection_t, class ManagerCollectionBinder, bool HasDistances, std::enable_if_t<HasDistances, int> = 0>
void bind_get_distance(ManagerCollectionBinder &manager_collection)

template<class ManagerCollection_t, class ManagerCollectionBinder, bool HasDirectionVector, std::enable_if_t<HasDirectionVector, int> = 0>
void bind_get_direction_vector(ManagerCollectionBinder &manager_collection)

template<class Calculator, class ManagerCollection_t, class ManagerCollectionBinder>
void bind_sparse_feature_matrix_getter(ManagerCollectionBinder &manager_collection)

template<typename Manager, template<class> class ...Adaptor>
void bind_structure_manager_collection(py::module &m_str_mng)

template<typename StructureManagerImplementation>
void bind_structure_manager(py::module &mod, py::module &m_internal)

void bind_cluster_refs(py::module &m_internal)

void bind_atomic_structure(py::module &mod)

void add_structure_managers(py::module &m_nl, py::module &m_internal)

Variables

constexpr int ThreeD = {3}

constexpr int AtomOrder = {1}

constexpr int PairOrder = {2}

constexpr int TripletOrder = {3}

constexpr int QuadrupletOrder = {4}

constexpr int MaxChemElements = {130}

static constexpr double lattice_tol = {1e-10 * 100}

static constexpr auto Dim = {3}

template<class ManagerImplementation>
class AdaptorCenterContribution : public rascal::StructureManager<AdaptorCenterContribution<ManagerImplementation>>, public std::enable_shared_from_this<AdaptorCenterContribution<ManagerImplementation>>

Public Functions

AdaptorCenterContribution() = delete

AdaptorCenterContribution(const AdaptorCenterContribution &other) = delete

AdaptorCenterContribution(AdaptorCenterContribution &&other) = default

virtual ~AdaptorCenterContribution() = default

AdaptorCenterContribution &operator=(const AdaptorCenterContribution &other) = delete

AdaptorCenterContribution &operator=(AdaptorCenterContribution &&other) = default

virtual void update_self()

template<class ...Args>
void update(Args&&... arguments)

inline double get_cutoff() const

template<size_t Order, size_t Layer>
inline int get_neighbour_atom_tag(const ClusterRefKey<Order, Layer> &cluster, int index) const

inline int get_neighbour_atom_tag(const Parent&, size_t index) const

inline size_t get_atom_index(const int atom_tag) const

inline int get_atom_type(const AtomRef_t &atom) const

inline int get_atom_type(int atom_id) const

template<size_t Order>
inline size_t get_offset_impl(const std::array<size_t, Order> &counters) const

template<size_t TargetOrder, size_t Order, size_t Layer>
inline size_t get_cluster_size_impl(const ClusterRefKey<Order, Layer> &cluster) const

inline ImplementationPtr_t get_previous_manager_impl()

inline ConstImplementationPtr_t get_previous_manager_impl() const

inline const std::vector<int> get_manager_atom_tag_list()

inline const std::vector<int> get_neighbours_atom_tag()

template<class ManagerImplementation, size_t MaxOrder>
class AdaptorFilter : public rascal::FilterBase, public rascal::StructureManager<AdaptorFilter<ManagerImplementation, MaxOrder>>, public std::enable_shared_from_this<AdaptorFilter<ManagerImplementation, MaxOrder>>

Subclassed by rascal::FilterFixture< ManagerImplementation, MaxOrder >::Filter_t

Public Functions

AdaptorFilter() = delete

inline explicit AdaptorFilter(ImplementationPtr_t manager)

AdaptorFilter(const AdaptorFilter &other) = delete

AdaptorFilter(AdaptorFilter &&other) = default

virtual ~AdaptorFilter() = default

AdaptorFilter &operator=(const AdaptorFilter &other) = delete

AdaptorFilter &operator=(AdaptorFilter &&other) = default

virtual void reset_initial_state()

inline virtual void update_self()

virtual void perform_filtering() = 0

inline size_t get_nb_clusters(int order) const

inline size_t get_size() const

inline Vector_ref get_position(int index)

inline size_t get_size_with_ghosts() const

template<size_t Order, size_t Layer>
inline int get_neighbour_atom_tag(const ClusterRefKey<Order, Layer> &cluster, int index) const

inline int get_neighbour_atom_tag(const Parent&, size_t index) const

inline int &get_atom_type(const AtomRef_t &atom)

inline int get_atom_type(const AtomRef_t &atom) const

inline int &get_atom_type(int atom_id)

inline int get_atom_type(int &atom_id) const

template<size_t Order>
inline size_t get_offset_impl(const std::array<size_t, Order> &counters) const

template<size_t TargetOrder, size_t Order, size_t Layer>
inline size_t get_cluster_size_impl(const ClusterRefKey<Order, Layer> &cluster) const

template<size_t Order>
void add_cluster(const InputClusterRef_t<Order> &cluster)

inline ImplementationPtr_t get_previous_manager_impl()

inline ConstImplementationPtr_t get_previous_manager_impl() const

template<class ManagerImplementation>
class AdaptorFullList : public rascal::StructureManager<AdaptorFullList<ManagerImplementation>>, public std::enable_shared_from_this<AdaptorFullList<ManagerImplementation>>

Public Functions

AdaptorFullList() = delete

explicit AdaptorFullList(ImplementationPtr_t manager)

AdaptorFullList(const AdaptorFullList &other) = delete

AdaptorFullList(AdaptorFullList &&other) = default

virtual ~AdaptorFullList() = default

AdaptorFullList &operator=(const AdaptorFullList &other) = delete

AdaptorFullList &operator=(AdaptorFullList &&other) = default

virtual void update_self()

template<class ...Args>
void update(Args&&... arguments)

inline double get_cutoff() const

inline size_t get_nb_clusters(int order) const

inline size_t get_size() const

inline size_t get_size_with_ghosts() const

inline Vector_ref get_position(int index)

inline Vector_ref get_position(const AtomRef_t &atom)

template<size_t Order, size_t Layer>
inline int get_neighbour_atom_tag(const ClusterRefKey<Order, Layer> &cluster, size_t index) const

inline int get_neighbour_atom_tag(const Parent&, size_t index) const

inline int &get_atom_type(const AtomRef_t &atom)

inline int get_atom_type(const AtomRef_t &atom) const

inline int &get_atom_type(int atom_id)

inline int get_atom_type(int atom_id) const

template<size_t Order>
inline size_t get_offset_impl(const std::array<size_t, Order> &counters) const

template<size_t TargetOrder, size_t Order, size_t Layer>
inline std::enable_if_t<TargetOrder == 2, size_t> get_cluster_size_impl(const ClusterRefKey<Order, Layer> &cluster) const

inline ImplementationPtr_t get_previous_manager_impl()

inline ConstImplementationPtr_t get_previous_manager_impl() const

template<class ManagerImplementation>
class AdaptorHalfList : public rascal::StructureManager<AdaptorHalfList<ManagerImplementation>>, public std::enable_shared_from_this<AdaptorHalfList<ManagerImplementation>>

Public Functions

AdaptorHalfList() = delete

explicit AdaptorHalfList(ImplementationPtr_t manager)

AdaptorHalfList(const AdaptorHalfList &other) = delete

AdaptorHalfList(AdaptorHalfList &&other) = default

virtual ~AdaptorHalfList() = default

AdaptorHalfList &operator=(const AdaptorHalfList &other) = delete

AdaptorHalfList &operator=(AdaptorHalfList &&other) = default

virtual void update_self()

template<class ...Args>
void update(Args&&... arguments)

inline double get_cutoff() const

inline size_t get_nb_clusters(int order) const

inline size_t get_size() const

inline size_t get_size_with_ghosts() const

inline Vector_ref get_position(int index)

inline Vector_ref get_position(const AtomRef_t &atom)

template<size_t Order, size_t Layer>
inline int get_neighbour_atom_tag(const ClusterRefKey<Order, Layer> &cluster, size_t index) const

inline int get_neighbour_atom_tag(const Parent&, size_t index) const

inline int get_atom_type(const AtomRef_t &atom)

inline int get_atom_type(const AtomRef_t &atom) const

inline int get_atom_type(int atom_id)

inline int get_atom_type(int atom_id) const

template<size_t Order>
inline size_t get_offset_impl(const std::array<size_t, Order> &counters) const

template<size_t TargetOrder, size_t Order, size_t Layer>
inline std::enable_if_t<TargetOrder == 2, size_t> get_cluster_size_impl(const ClusterRefKey<Order, Layer> &cluster) const

inline ImplementationPtr_t get_previous_manager_impl()

inline ConstImplementationPtr_t get_previous_manager_impl() const

template<class StackFixture>
struct AdaptorHalfListStackFixture : public StackFixture

template<class ManagerImplementation>
class AdaptorKspace : public rascal::StructureManager<AdaptorKspace<ManagerImplementation>>, public std::enable_shared_from_this<AdaptorKspace<ManagerImplementation>>

Public Functions

AdaptorKspace() = delete

explicit AdaptorKspace(ImplementationPtr_t manager)

AdaptorKspace(const AdaptorKspace &other) = delete

AdaptorKspace(AdaptorKspace &&other) = default

virtual ~AdaptorKspace() = default

AdaptorKspace &operator=(const AdaptorKspace &other) = delete

AdaptorKspace &operator=(AdaptorKspace &&other) = default

virtual void update_self()

template<class ...Args>
void update(Args&&... arguments)

template<size_t Order>
size_t get_offset_impl(const std::array<size_t, Order> &counters) const

inline size_t get_nb_clusters(size_t order) const

inline size_t get_size() const

inline Vector_ref get_position(size_t atom_tag)

inline Vector_ref get_position(const AtomRef_t &atom)

inline int get_neighbour_atom_tag(const Parent&, size_t iteration_index) const

template<size_t Order, size_t Layer>
inline int get_neighbour_atom_tag(const ClusterRefKey<Order, Layer> &cluster, size_t iteration_index) const

inline int get_atom_type(int atom_tag) const

inline size_t get_atom_index(const int atom_tag) const

template<size_t TargetOrder, size_t Order, size_t Layer>
inline std::enable_if_t<TargetOrder == 2, size_t> get_cluster_size_impl(const ClusterRefKey<Order, Layer> &cluster) const

inline ImplementationPtr_t get_previous_manager_impl()

inline ConstImplementationPtr_t get_previous_manager_impl() const

template<class ManagerImplementation>
class AdaptorMaxOrder : public rascal::StructureManager<AdaptorMaxOrder<ManagerImplementation>>, public std::enable_shared_from_this<AdaptorMaxOrder<ManagerImplementation>>

Public Functions

AdaptorMaxOrder() = delete

explicit AdaptorMaxOrder(ImplementationPtr_t manager)

AdaptorMaxOrder(const AdaptorMaxOrder &other) = delete

AdaptorMaxOrder(AdaptorMaxOrder &&other) = default

virtual ~AdaptorMaxOrder() = default

AdaptorMaxOrder &operator=(const AdaptorMaxOrder &other) = delete

AdaptorMaxOrder &operator=(AdaptorMaxOrder &&other) = default

virtual void update_self()

template<class ...Args>
void update(Args&&... arguments)

template<size_t Order, bool C = (Order < 2), std::enable_if_t<C, int> = 0>
inline size_t get_offset_impl(const std::array<size_t, Order> &counters) const

inline size_t get_nb_clusters(size_t order) const

inline size_t get_size() const

inline Vector_ref get_position(size_t atom_tag)

inline Vector_ref get_position(const AtomRef_t &atom)

inline int get_atom_type(int atom_tag) const

inline int get_atom_type(const AtomRef_t &atom) const

inline int get_neighbour_atom_tag(const Parent&, size_t index) const

template<size_t Layer>
inline int get_neighbour_atom_tag(const ClusterRefKey<1, Layer> &cluster, size_t index) const

template<size_t Layer>
inline std::array<int, AdditionalOrder - 1> get_neighbour_atom_tag_current(const ClusterRefKey<1, Layer> &cluster, size_t index) const

template<size_t TargetOrder, size_t Order, size_t Layer> std::enable_if_t< TargetOrder< traits::MaxOrder, size_t > get_cluster_size_impl(const ClusterRefKey< Order, Layer > &cluster) const { return this-> manager template get_cluster_size (cluster)

template<size_t TargetOrder, size_t Order, size_t Layer>
inline std::enable_if_t<TargetOrder == traits::MaxOrder, size_t> get_cluster_size_impl(const ClusterRefKey<Order, Layer> &cluster) const

inline ImplementationPtr_t get_previous_manager_impl()

inline ConstImplementationPtr_t get_previous_manager_impl() const

Public Static Attributes

static constexpr size_t AdditionalOrder = {traits::MaxOrder}

template<size_t Order, AdaptorTraits::NeighbourListType NeighbourListType, bool IsCompactCluster>
struct ForwardClusterIndices<Order, NeighbourListType, IsCompactCluster, false>

Public Static Functions

static inline void loop(AtomClusterRef_t&, AdaptorMaxOrder<ManagerImplementation>&)

template<class StackFixture>
struct AdaptorMaxOrderStackFixture : public StackFixture

template<class ManagerImplementation>
class AdaptorNeighbourList : public rascal::StructureManager<AdaptorNeighbourList<ManagerImplementation>>, public std::enable_shared_from_this<AdaptorNeighbourList<ManagerImplementation>>

Public Functions

AdaptorNeighbourList() = delete

AdaptorNeighbourList(ImplementationPtr_t manager, double cutoff, double skin = 0.)

AdaptorNeighbourList(const AdaptorNeighbourList &other) = delete

AdaptorNeighbourList(AdaptorNeighbourList &&other) = default

virtual ~AdaptorNeighbourList() = default

AdaptorNeighbourList &operator=(const AdaptorNeighbourList &other) = delete

AdaptorNeighbourList &operator=(AdaptorNeighbourList &&other) = default

virtual void update_self()

template<class ...Args>
void update(Args&&... arguments)

inline double get_cutoff() const

template<size_t Order>
size_t get_offset_impl(const std::array<size_t, Order> &counters) const

inline size_t get_nb_clusters(size_t order) const

inline size_t get_size() const

inline size_t get_size_with_ghosts() const

inline Vector_ref get_position(size_t atom_tag)

inline Vector_ref get_ghost_position(const size_t ghost_atom_index)

inline int get_ghost_type(size_t atom_tag) const

inline int &get_ghost_type(size_t atom_tag)

inline std::vector<int> &get_ghost_types()

inline const std::vector<int> &get_ghost_types() const

inline Vector_ref get_position(const AtomRef_t &atom)

inline int get_neighbour_atom_tag(const Parent&, size_t iteration_index) const

template<size_t Order, size_t Layer>
inline int get_neighbour_atom_tag(const ClusterRefKey<Order, Layer> &cluster, size_t iteration_index) const

inline int get_atom_type(int atom_tag) const

inline size_t get_atom_index(const int atom_tag) const

template<size_t TargetOrder, size_t Order, size_t Layer>
inline std::enable_if_t<TargetOrder == 2, size_t> get_cluster_size_impl(const ClusterRefKey<Order, Layer> &cluster) const

inline ImplementationPtr_t get_previous_manager_impl()

inline ConstImplementationPtr_t get_previous_manager_impl() const

template<class StackFixture>
struct AdaptorNeighbourListStackFixture : public StackFixture

template<class ManagerImplementation>
class AdaptorStrict : public rascal::StructureManager<AdaptorStrict<ManagerImplementation>>, public std::enable_shared_from_this<AdaptorStrict<ManagerImplementation>>

Public Functions

AdaptorStrict() = delete

AdaptorStrict(ImplementationPtr_t manager, double cutoff)

AdaptorStrict(const AdaptorStrict &other) = delete

AdaptorStrict(AdaptorStrict &&other) = default

virtual ~AdaptorStrict() = default

AdaptorStrict &operator=(const AdaptorStrict &other) = delete

AdaptorStrict &operator=(AdaptorStrict &&other) = default

virtual void update_self()

template<class ...Args>
void update(Args&&... arguments)

inline double get_cutoff() const

template<size_t Order, size_t Layer>
inline int get_neighbour_atom_tag(const ClusterRefKey<Order, Layer> &cluster, int index) const

inline int get_neighbour_atom_tag(const Parent&, size_t index) const

inline size_t get_atom_index(const int atom_tag) const

inline int get_atom_type(const AtomRef_t &atom) const

inline int get_atom_type(int atom_id) const

template<size_t Order>
inline size_t get_offset_impl(const std::array<size_t, Order> &counters) const

template<size_t TargetOrder, size_t Order, size_t Layer>
inline std::enable_if_t<TargetOrder == 2, size_t> get_cluster_size_impl(const ClusterRefKey<Order, Layer> &cluster) const

inline ImplementationPtr_t get_previous_manager_impl()

inline ConstImplementationPtr_t get_previous_manager_impl() const

template<size_t Order, size_t Layer>
inline const double &get_distance(const ClusterRefKey<Order, Layer> &pair) const

template<size_t Order, size_t Layer>
inline const Vector_ref get_direction_vector(const ClusterRefKey<Order, Layer> &pair) const

template<class StackFixture>
struct AdaptorStrictStackFixture : public StackFixture

template<template<class> class ...AdaptorImplementation>
struct AdaptorTypeHolder

template<size_t Order, size_t Layer, size_t LayerEnd>
struct add_cluster_refs

Public Static Functions

static inline void static_for(py::module &m)

template<size_t Order, size_t LayerEnd>
struct add_cluster_refs<Order, LayerEnd, LayerEnd>

template<class ClusterRef, size_t MaxOrder>
struct AddProperty

template<class ClusterRef>
struct AddProperty<ClusterRef, 1>

template<int Dim>
struct AtomicStructure

Public Functions

AtomicStructure() = default

template<typename Derived>
inline void displace_position(const size_t &i_atom, const Eigen::MatrixBase<Derived> &disp)

inline double get_volume()

inline void displace_strain_tensor(const int &alpha_spatial_dim, const int &beta_spatial_dim, const double &h_disp)

inline void wrap()

inline void set_structure(const PositionsInput_t &positions, const AtomTypesInput_t &atom_types, const CellInput_t cell, const PBCInput_t &pbc)

template<typename T>
inline void set_atom_property(std::string name, ArrayConstRef_t<T> array)

inline void set_structure(const PositionsInput_t &positions, const AtomTypesInput_t &atom_types, const CellInput_t cell, const PBCInput_t &pbc, const ArrayB_t &center_atoms_mask)

inline bool is_similar(double threshold2) const

Public Members

Positions_t positions = {}

AtomTypes_t atom_types = {}

Cell_t cell = {}

PBC_t pbc = {}

ArrayB_t center_atoms_mask = {}

struct AtomicStructureFixture

template<class StackFixture>
struct AtomPropertyFixture : public StackFixture

Subclassed by rascal::PairPropertyFixture< StackFixture >

template<template<class> class Adaptor, typename Implementation_t>
struct BindAdaptor

template<typename Implementation_t>
struct BindAdaptor<AdaptorCenterContribution, Implementation_t>

template<typename Implementation_t>
struct BindAdaptor<AdaptorFullList, Implementation_t>

template<typename Implementation_t>
struct BindAdaptor<AdaptorHalfList, Implementation_t>

template<typename Implementation_t>
struct BindAdaptor<AdaptorKspace, Implementation_t>

template<typename Implementation_t>
struct BindAdaptor<AdaptorMaxOrder, Implementation_t>

template<typename Implementation_t>
struct BindAdaptor<AdaptorNeighbourList, Implementation_t>

template<typename Implementation_t>
struct BindAdaptor<AdaptorStrict, Implementation_t>

template<typename ManagerImplementation, template<class> class AdaptorImplementation, template<class> class ...AdaptorImplementationPack>
struct BindAdaptorStack

template<typename ManagerImplementation, template<class> class AdaptorImplementation>
struct BindAdaptorStack<ManagerImplementation, AdaptorImplementation>

template<class StructureManagerImplementation, size_t Order>
struct BindIterator

Public Static Functions

template<class PyClusterRef_t>
static inline auto add_iterator(py::module &m, PyClusterRef_t &py_cluster)

template<class StructureManagerImplementation>
struct BindIterator<StructureManagerImplementation, 1>

Public Static Functions

template<class PyManager_t>
static inline auto add_iterator(py::module &m, PyManager_t &manager)

template<typename Precision_t, size_t Order_, class Manager, typename Key>
class BlockSparseProperty : public rascal::PropertyBase

Public Functions

inline BlockSparseProperty(Manager_t &manager, std::string metadata = "no metadata", bool exclude_ghosts = false)

BlockSparseProperty() = delete

BlockSparseProperty(const BlockSparseProperty &other) = delete

BlockSparseProperty(BlockSparseProperty &&other) = default

~BlockSparseProperty() = default

BlockSparseProperty &operator=(const BlockSparseProperty &other) = delete

BlockSparseProperty &operator=(BlockSparseProperty &&other) = default

inline virtual const std::string &get_type_info() const final

template<size_t Order__ = Order, std::enable_if_t<(Order__ > 1> inline void resize ()

template<size_t Order__ = Order, std::enable_if_t<(Order__ == 0), int> = 0>
inline void resize()

template<size_t Order__ = Order, std::enable_if_t<(Order__ == 1), int> = 0>
inline void resize()

template<template<typename...> class Keys_List, typename ...Args1, typename ...Args2>
inline void resize(const Keys_List<std::set<Args2...>, Args1...> &keys_list)

template<typename ...Args>
inline void resize(const std::set<Args...> &keys)

inline void check_for_uniform_keys()

inline void clear()

template<size_t CallerLayer>
inline InputData_t &operator[](const ClusterRefKey<Order, CallerLayer> &id)

template<size_t CallerOrder, size_t CallerLayer, bool C = (IsOrderOne and (CallerOrder == 2)), std::enable_if_t<C, int> = 0>
inline InputData_t &operator[](const ClusterRefKey<CallerOrder, CallerLayer> &id)

inline InputData_t &operator[](size_t index)

inline MatrixMap_Ref_t operator()(size_t index, const Key_t &key)

template<size_t CallerLayer>
inline Matrix_t get_dense_row(const ClusterRefKey<Order, CallerLayer> &id)

inline void fill_dense_feature_matrix(Eigen::Ref<Matrix_t> features, const Keys_t &all_keys) const

inline Matrix_t get_features()

inline void fill_dense_feature_matrix_gradient(Eigen::Ref<Matrix_t> features, const Keys_t &all_keys) const

inline Keys_t get_keys() const

inline size_t get_nb_item() const

inline MatrixMapConst_Ref_t get_raw_data_view() const

inline Matrix_t dot(Self_t &B)

inline Matrix_t dot()

template<size_t Order>
struct BlockSparsePropertyFixture : public rascal::MultipleStructureFixture<MultipleStructureManagerNLFixture>

class CalculatorBase

Subclassed by rascal::CalculatorSortedCoulomb, rascal::CalculatorSphericalCovariants, rascal::CalculatorSphericalExpansion, rascal::CalculatorSphericalInvariants

Public Types

using Hypers_t = json

using Precision_t = double

using ReferenceHypers_t = std::map<std::string, std::vector<std::string>>

Public Functions

CalculatorBase(const CalculatorBase &other) = delete

inline CalculatorBase(CalculatorBase &&other) noexcept

virtual ~CalculatorBase() = default

CalculatorBase &operator=(const CalculatorBase &other) = delete

CalculatorBase &operator=(CalculatorBase &&other) = default

virtual void set_hyperparameters(const Hypers_t&) = 0

inline const std::string &get_name() const

inline std::string get_gradient_name() const

inline void set_name(const std::string &name)

inline void set_default_prefix(const std::string &default_prefix)

inline void set_name(const Hypers_t &hyper)

inline virtual bool does_gradients() const

std::string get_options_string()

std::string get_hypers_string()

Public Members

std::string name = {""}

std::string default_prefix = {""}

Hypers_t hypers = {}

std::map<std::string, std::string> options = {}

template<class BaseFixture>
struct CalculatorFixture : public rascal::MultipleStructureFixture<BaseFixture>

Subclassed by rascal::KernelFixture< BaseFixture >, rascal::SparseKernelFixture< BaseFixture >

class CalculatorSortedCoulomb : public rascal::CalculatorBase

Public Functions

inline explicit CalculatorSortedCoulomb(const Hypers_t &hyper)

CalculatorSortedCoulomb(const CalculatorSortedCoulomb &other) = delete

inline CalculatorSortedCoulomb(CalculatorSortedCoulomb &&other) noexcept

virtual ~CalculatorSortedCoulomb() = default

CalculatorSortedCoulomb &operator=(const CalculatorSortedCoulomb &other) = delete

CalculatorSortedCoulomb &operator=(CalculatorSortedCoulomb &&other) = default

template<class StructureManager>
void compute(StructureManager &managers)

inline virtual void set_hyperparameters(const Hypers_t&) override

template<class StructureManager>
inline void check_size_compatibility(StructureManager &manager)

template<internal::CMSortAlgorithm AlgorithmType, class StructureManager, std::enable_if_t<internal::is_proper_iterator<StructureManager>::value, int> = 0>
inline void compute_loop(StructureManager &managers)

template<internal::CMSortAlgorithm AlgorithmType, class StructureManager, std::enable_if_t<not (internal::is_proper_iterator<StructureManager>::value), int> = 0>
inline void compute_loop(StructureManager &manager)

template<internal::CMSortAlgorithm AlgorithmType, class StructureManager>
inline void compute_impl(std::shared_ptr<StructureManager> &manager)

template<class StructureManager>
void get_distance_matrix(std::shared_ptr<StructureManager> &manager, ClusterRef_t<StructureManager, 1> &center, Eigen::Ref<Eigen::MatrixXd> distance_mat, Eigen::Ref<Eigen::MatrixXd> type_factor_mat)

template<typename DerivedA, typename DerivedB>
inline void sort_and_linearize_coulomb_matrix(const Eigen::DenseBase<DerivedA> &square_coulomb, Eigen::DenseBase<DerivedB> &linear_coulomb, const std::vector<std::pair<size_t, internal::distiter>> &order_coulomb)

inline double get_cutoff_factor(double distance, double cutoff, double decay)

inline size_t get_n_feature()

Public Members

ReferenceHypers_t reference_hypers{{"central_cutoff", {}}, {"central_decay", {}}, {"interaction_cutoff", {}}, {"interaction_decay", {}}, {"size", {}}, {"sorting_algorithm", {"distance", "row_norm"}},}

class CalculatorSphericalCovariants : public rascal::CalculatorBase

Public Functions

CalculatorSphericalCovariants(const CalculatorSphericalCovariants &other) = delete

inline CalculatorSphericalCovariants(CalculatorSphericalCovariants &&other) noexcept

virtual ~CalculatorSphericalCovariants() = default

CalculatorSphericalCovariants &operator=(const CalculatorSphericalCovariants &other) = delete

CalculatorSphericalCovariants &operator=(CalculatorSphericalCovariants &&other) = default

inline virtual void set_hyperparameters(const Hypers_t &hypers) override

template<class StructureManager>
void compute(StructureManager &managers)

template<internal::SphericalCovariantsType Type, class StructureManager, std::enable_if_t<internal::is_proper_iterator<StructureManager>::value, int> = 0>
inline void compute_loop(StructureManager &managers)

template<internal::SphericalCovariantsType Type, class StructureManager, std::enable_if_t<not (internal::is_proper_iterator<StructureManager>::value), int> = 0>
inline void compute_loop(StructureManager &manager)

template<internal::SphericalCovariantsType Type, std::enable_if_t<Type == internal::SphericalCovariantsType::LambdaSpectrum, int> = 0, class StructureManager>
void compute_impl(std::shared_ptr<StructureManager> manager)

class CalculatorSphericalExpansion : public rascal::CalculatorBase

Public Functions

inline virtual void set_hyperparameters(const Hypers_t &hypers) override

inline virtual bool does_gradients() const override

inline explicit CalculatorSphericalExpansion(const Hypers_t &hyper)

CalculatorSphericalExpansion(const CalculatorSphericalExpansion &other) = delete

inline CalculatorSphericalExpansion(CalculatorSphericalExpansion &&other) noexcept

virtual ~CalculatorSphericalExpansion() = default

CalculatorSphericalExpansion &operator=(const CalculatorSphericalExpansion &other) = delete

CalculatorSphericalExpansion &operator=(CalculatorSphericalExpansion &&other) = default

template<class StructureManager>
void compute(StructureManager &managers)

template<internal::CutoffFunctionType FcType, class StructureManager>
void compute_by_radial_contribution(StructureManager &managers)

template<internal::CutoffFunctionType FcType, internal::RadialBasisType RadialType, internal::AtomicSmearingType SmearingType, class StructureManager>
void compute_by_radial_contribution(StructureManager &managers)

template<internal::CutoffFunctionType FcType, internal::RadialBasisType RadialType, internal::AtomicSmearingType SmearingType, internal::OptimizationType OptType, class StructureManager, std::enable_if_t<internal::is_proper_iterator<StructureManager>::value, int> = 0>
inline void compute_loop(StructureManager &managers)

template<internal::CutoffFunctionType FcType, internal::RadialBasisType RadialType, internal::AtomicSmearingType SmearingType, internal::OptimizationType OptType, class StructureManager, std::enable_if_t<not (internal::is_proper_iterator<StructureManager>::value), int> = 0>
inline void compute_loop(StructureManager &manager)

template<internal::CutoffFunctionType FcType, internal::RadialBasisType RadialType, internal::AtomicSmearingType SmearingType, internal::OptimizationType OptType, class StructureManager>
void compute_impl(std::shared_ptr<StructureManager> manager)

class CalculatorSphericalInvariants : public rascal::CalculatorBase

Public Functions

CalculatorSphericalInvariants(const CalculatorSphericalInvariants &other) = delete

inline CalculatorSphericalInvariants(CalculatorSphericalInvariants &&other) noexcept

virtual ~CalculatorSphericalInvariants() = default

CalculatorSphericalInvariants &operator=(const CalculatorSphericalInvariants &other) = delete

CalculatorSphericalInvariants &operator=(CalculatorSphericalInvariants &&other) = default

inline virtual void set_hyperparameters(const Hypers_t &hypers) override

inline void set_hyperparameters_powerspectrum(const Hypers_t &hypers)

inline virtual bool does_gradients() const override

template<class StructureManager>
void compute(StructureManager &managers)

template<internal::SphericalInvariantsType BodyOrder, class StructureManager, std::enable_if_t<internal::is_proper_iterator<StructureManager>::value, int> = 0>
inline void compute_loop(StructureManager &managers)

template<internal::SphericalInvariantsType BodyOrder, class StructureManager, std::enable_if_t<not (internal::is_proper_iterator<StructureManager>::value), int> = 0>
inline void compute_loop(StructureManager &manager)

template<internal::SphericalInvariantsType BodyOrder, std::enable_if_t<BodyOrder == internal::SphericalInvariantsType::RadialSpectrum, int> = 0, class StructureManager>
void compute_impl(std::shared_ptr<StructureManager> manager)

template<internal::SphericalInvariantsType BodyOrder, std::enable_if_t<BodyOrder == internal::SphericalInvariantsType::PowerSpectrum, int> = 0, class StructureManager>
void compute_impl(std::shared_ptr<StructureManager> manager)

template<internal::SphericalInvariantsType BodyOrder, std::enable_if_t<BodyOrder == internal::SphericalInvariantsType::BiSpectrum, int> = 0, class StructureManager>
void compute_impl(std::shared_ptr<StructureManager> manager)

template<class StructureManager, class Invariants, class InvariantsDerivative, class ExpansionCoeff>
void initialize_per_center_powerspectrum_soap_vectors(Invariants &soap_vector, InvariantsDerivative &soap_vector_gradients, ExpansionCoeff &expansions_coefficients, std::shared_ptr<StructureManager> manager)

template<class StructureManager, class SpectrumNorm>
inline void update_gradients_for_normalization(Property_t<StructureManager> &soap_vectors, PropertyGradient_t<StructureManager> &soap_vector_gradients, std::shared_ptr<StructureManager> manager, SpectrumNorm &inv_norms, const size_t &grad_component_size)

Public Members

std::set<internal::SortedKey<Key_t>, internal::CompareSortedKeyLess> unique_pair_list = {}

std::map<internal::SortedKey<Key_t>, std::vector<PowerSpectrumCoeffIndex>, internal::CompareSortedKeyLess> coeff_indices_map = {}

std::map<internal::SortedKey<Key_t>, internal::SortedKey<Key_t>, internal::CompareSortedKeyLess> key_map = {}

std::vector<PowerSpectrumCoeffIndex> coeff_indices = {}

bool is_sparsified = {false}

struct PowerSpectrumCoeffIndex

class ClusterRefBase

Subclassed by rascal::ClusterRefKey< Order, ManagerImplementation::template cluster_layer_from_order< Order >()>, rascal::ClusterRefKey< Order, Layer >

Public Functions

ClusterRefBase() = delete

ClusterRefBase(const ClusterRefBase &other) = delete

ClusterRefBase(ClusterRefBase &&other) = default

virtual ~ClusterRefBase() = default

ClusterRefBase &operator=(const ClusterRefBase &other) = delete

ClusterRefBase &operator=(ClusterRefBase &&other) = delete

inline size_t get_order() const

inline size_t get_cluster_layer() const

template<size_t Order, size_t Layer>
class ClusterRefKey : public rascal::ClusterRefBase

Public Types

using Parent = ClusterRefBase

Public Functions

ClusterRefKey() = delete

inline ClusterRefKey(AtomIndex_t atom_tag_list, IndexConstArray cluster_indices)

inline ClusterRefKey(const ClusterRefKey &other)

inline ClusterRefKey(ClusterRefKey &&other)

virtual ~ClusterRefKey() = default

ClusterRefKey &operator=(const ClusterRefKey &other) = delete

inline ClusterRefKey &operator=(ClusterRefKey &&other)

inline const AtomIndex_t &get_atom_tag_list() const

inline int front() const

inline int back() const

inline size_t get_cluster_index(const size_t layer) const

inline size_t get_cluster_index() const

inline IndexConstArray get_cluster_indices() const

Public Static Functions

static inline constexpr size_t order()

static inline constexpr size_t cluster_layer()

template<class BaseFixture>
struct CollectionFixture : public BaseFixture

Subclassed by rascal::KernelFixture< BaseFixture >, rascal::SparseKernelFixture< BaseFixture >

struct ComplexHypersSphericalInvariants : public rascal::ComplexPeriodicNLCCStrictFixture

struct ComplexPeriodicNLCCStrictFixture

Subclassed by rascal::ComplexHypersSphericalInvariants

template<class CutoffFunction>
struct CutoffGradientProvider

struct DataSphericalInvariantsKernelFixture

template<int Dim>
struct DemoTestFixture

class FilterBase

Subclassed by rascal::AdaptorFilter< ManagerImplementation, Order >, rascal::AdaptorFilter< ManagerImplementation, MaxOrder >

Public Functions

FilterBase() = default

FilterBase(const FilterBase &other) = delete

FilterBase(FilterBase &&other) = default

virtual ~FilterBase() = default

FilterBase &operator=(const FilterBase &other) = delete

FilterBase &operator=(FilterBase &&other) = default

virtual void reset_initial_state() = 0

template<class ManagerImplementation, size_t MaxOrder>
struct FilterFixture

class Filter_t : public rascal::AdaptorFilter<ManagerImplementation, MaxOrder>

struct GaussLegendreRefFixture

class GradientTestFixture

Subclassed by rascal::RepresentationCalculatorGradientFixture< Calculator, StructureManager >

Public Types

enum VerbosityValue

Values:

enumerator NORMAL

enumerator INFO

enumerator DEBUG

Public Members

double fd_error_tol = {1E-6}

template<typename SMI, size_t Order>
struct HelperLayer

struct Hyp1f1GradientProvider

struct Hyp1F1RefFixture

struct Hyp1f1SphericalExpansionFixture

template<size_t Order>
struct IndexFixture

template<class Interpolator, bool ClampedBoundaryConditions = false>
struct InterpolatorFixture

class Kernel

Public Functions

inline Kernel(Kernel &&other) noexcept

Public Members

std::vector<std::string> identifiers = {}

Hypers_t parameters = {}

internal::TargetType target_type = {}

template<class BaseFixture>
struct KernelFixture : public rascal::CollectionFixture<BaseFixture>, public rascal::CalculatorFixture<BaseFixture>

template<size_t Order, size_t MaxOrder>
struct KeyFixture

template<typename T, size_t MaxOrder>
class KeyStandardisation

Public Functions

KeyStandardisation() = delete

KeyStandardisation(const KeyStandardisation &other) = default

KeyStandardisation(KeyStandardisation &&other) = default

virtual ~KeyStandardisation() = default

KeyStandardisation &operator=(const KeyStandardisation &other) = default

KeyStandardisation &operator=(KeyStandardisation &&other) = default

struct KvecgenRefFixture

template<size_t Dim>
class Lattice

Public Functions

Lattice() = default

inline explicit Lattice(const Cell_t &cell)

Lattice(const Lattice &other) = delete

Lattice(Lattice &&other) = default

virtual ~Lattice() = default

Lattice &operator=(const Lattice &other) = delete

Lattice &operator=(Lattice &&other) = default

inline void set_cell(const Cell_t &cell)

inline const Vec_t get_cell_lengths()

inline const Vec_t get_cell_angles()

inline const Cell_t get_cartesian2scaled_matrix()

inline const Cell_t get_scaled2cartesian_matrix()

inline const Cell_t get_reciprocal_vectors()

inline const Vec_t get_reciprocal_lengths()

inline void set_reciprocal_vectors()

inline void set_transformation_matrix()

template<typename DerivedA, typename DerivedB>
inline void get_cartesian2scaled(const Eigen::MatrixBase<DerivedA> &position, Eigen::MatrixBase<DerivedB> &position_sc)

template<typename DerivedA, typename DerivedB>
inline void get_scaled2cartesian(const Eigen::MatrixBase<DerivedA> &position_sc, Eigen::MatrixBase<DerivedB> &position)

template<class T>
struct LayerExtender

template<size_t... LayersByOrder> index_sequence< LayersByOrder... > >

struct LayerFixture

template<size_t MaxOrder, size_t Order, bool End, size_t... Ints>
struct LayerHelper

template<size_t MaxOrder, size_t Order, size_t... Ints>
struct LayerHelper<MaxOrder, Order, true, Ints...>

template<class T>
struct LayerIncreaser

template<size_t... LayersByOrder> index_sequence< LayersByOrder... > >

template<typename StructureManagerTypeHolder_>
struct make_structure_manager_stack_with_hypers_and_typeholder

template<typename... T> tuple< T... > >

template<typename Manager, template<class> class ...AdaptorImplementationPack>
class ManagerCollection

Public Types

using iterator = typename Data_t::iterator

Public Functions

ManagerCollection(const ManagerCollection &other) = delete

ManagerCollection(ManagerCollection &&other) = default

~ManagerCollection() = default

ManagerCollection &operator=(const ManagerCollection &other) = delete

ManagerCollection &operator=(ManagerCollection &&other) = default

template<typename Int>
inline Self_t get_subset(const std::vector<Int> &selected_ids)

inline void set_adaptor_parameters(const Hypers_t &adaptor_parameters)

inline Eigen::Matrix<int, Eigen::Dynamic, 5> get_gradients_info() const

inline void add_structure(const Hypers_t &structure, const Hypers_t &adaptor_parameters)

inline void add_structures(const std::vector<AtomicStructure<3>> &atomic_structures)

inline void add_structures(const std::string &filename, int start = 0, int length = -1)

inline size_t size() const

template<typename T>
inline ManagerPtr_t operator[](T index)

template<class Calculator>
inline Matrix_t get_features(const Calculator &calculator)

template<class Calculator>
inline std::string get_calculator_name(const Calculator &calculator, bool is_gradients)

template<class Calculator>
inline auto get_keys(const Calculator &calculator, bool is_gradients = false)

template<class Prop_t>
inline size_t get_number_of_elements(const std::string &property_name)

template<class ManagerImplementation>
struct ManagerFixture

Subclassed by rascal::ManagerFixtureFile< ManagerImplementation >

template<>
struct ManagerFixture<StructureManagerCenters>

Subclassed by rascal::ManagerFixtureSimple, rascal::ManagerFixtureSkewDeltaRcut

template<>
struct ManagerFixture<StructureManagerLammps>

template<class ManagerImplementation>
struct ManagerFixtureFile : public rascal::ManagerFixture<ManagerImplementation>

struct ManagerFixtureLattice

struct ManagerFixtureSimple : public rascal::ManagerFixture<StructureManagerCenters>

struct ManagerFixtureSkew

struct ManagerFixtureSkewDeltaRcut : public rascal::ManagerFixture<StructureManagerCenters>

template<class ManagerImplementation>
struct ManagerFixtureTwo

struct ManagerFixtureTwoFcc : public rascal::ManagerFixtureTwo<StructureManagerCenters>

struct ManagerFixtureTwoHcp : public rascal::ManagerFixtureTwo<StructureManagerCenters>

template<class FixtureFull, class FixtureHalf, class Calculator>
struct MergeHalfAndFull : public rascal::MultipleStructureFixture<FixtureFull>, public rascal::MultipleStructureFixture<FixtureHalf>

struct ModifiedBesselFirstKindGradientsProvider

struct ModifiedBesselFirstKindRefFixture

struct MultipleHypersSphericalExpansion : public rascal::SimpleStructureManagerNLCCStrictFixture

template<class BaseFixture>
struct MultipleStructureFixture : public BaseFixture

Subclassed by rascal::CalculatorFixture< BaseFixture >, rascal::MultipleStructureSortedCoulomb< MultipleStructureFixture >, rascal::MultipleStructureSphericalCovariants< MultipleStructureFixture >, rascal::MultipleStructureSphericalExpansion< MultipleStructureFixture >, rascal::MultipleStructureSphericalInvariants< MultipleStructureFixture >, rascal::RadialIntegralHandlerFixture< BaseFixture, RadialType, SmearingType, OptType >

struct MultipleStructureManagerCentersFixture

struct MultipleStructureManagerKspaceFixture

struct MultipleStructureManagerNLCCFixture

struct MultipleStructureManagerNLCCFixtureCenterMask

struct MultipleStructureManagerNLCCStrictFixture

Subclassed by rascal::StrictNLCCCollectionFixture

struct MultipleStructureManagerNLCCStrictFixtureCenterMask

struct MultipleStructureManagerNLFixture

Subclassed by rascal::MultipleStructureFixture< MultipleStructureManagerNLFixture >

struct MultipleStructureManagerNLRattleFixture

struct MultipleStructureManagerNLStrictFixture

template<class MultipleStructureFixture>
struct MultipleStructureSortedCoulomb : public rascal::MultipleStructureFixture<BaseFixture>

template<typename MultipleStructureFixture>
struct MultipleStructureSphericalCovariants : public rascal::MultipleStructureFixture<BaseFixture>

template<class MultipleStructureFixture>
struct MultipleStructureSphericalExpansion : public rascal::MultipleStructureFixture<BaseFixture>

template<typename MultipleStructureFixture>
struct MultipleStructureSphericalInvariants : public rascal::MultipleStructureFixture<BaseFixture>

struct OrderOnePropertyBoostList

struct OrderTwoFixtureStacksTuple

struct OrderThreePropertyBoostList

struct OrderTwoPropertyBoostList

struct OrderTwoFixtureStacksTuple

template<typename ta>
struct pack_into_list

template<typename... a> tuple< a... > >

template<class ManagerImplementation>
struct PairFixture

struct PairFixtureCenters

template<class ManagerImplementation>
struct PairFixtureFile

template<class ManagerImplementation>
struct PairFixtureSimple

template<class ManagerImplementation>
struct PairFixtureSimpleCenterPairs

template<class ManagerImplementation>
struct PairFixtureStrict

template<class ManagerImplementation>
struct PairFixtureStrictWithGhosts

template<class StackFixture>
struct PairPropertyFixture : public rascal::AtomPropertyFixture<StackFixture>

Subclassed by rascal::TriplePropertyFixture< StackFixture >

template<typename T, size_t Order, class Manager, Dim_t NbRow = 1, Dim_t NbCol = 1>
class Property : public rascal::TypedProperty<T, Order, Manager>

Public Functions

Property() = delete

inline explicit Property(Manager_t &manager, std::string metadata = "no metadata", const bool &exclude_ghosts = false)

Property(const Property &other) = delete

Property(Property &&other) = default

virtual ~Property() = default

Property &operator=(const Property &other) = delete

Property &operator=(Property &&other) = delete

inline virtual const std::string &get_type_info() const final

inline void push_back(reference ref)

template<typename Derived>
inline void push_back(const Eigen::DenseBase<Derived> &ref)

template<size_t CallerLayer>
inline reference operator[](const ClusterRefKey<Order, CallerLayer> &id)

inline reference operator[](size_t index)

Public Static Functions

static inline void check_compatibility(PropertyBase &other)

struct DynamicSize

struct StaticSize

class PropertyBase

Subclassed by rascal::BlockSparseProperty< Precision_t, Order_, Manager, Key >, rascal::TypedProperty< T, Order_, Manager >, rascal::TypedProperty< T, Order, Manager >

Public Functions

PropertyBase() = delete

PropertyBase(const PropertyBase &other) = delete

PropertyBase(PropertyBase &&other) = default

virtual ~PropertyBase() = default

PropertyBase &operator=(const PropertyBase &other) = delete

PropertyBase &operator=(PropertyBase &&other) = delete

virtual const std::string &get_type_info() const = 0

inline Dim_t get_nb_comp() const

inline void update_nb_comp()

inline Dim_t get_nb_row() const

inline void set_nb_row(const Dim_t &nb_row)

inline Dim_t get_nb_col() const

inline void set_nb_col(const Dim_t &nb_col)

inline Dim_t get_order() const

inline Dim_t get_property_layer() const

inline std::string get_metadata() const

inline bool is_updated() const

template<class BaseFixture, internal::RadialBasisType RadialType, internal::AtomicSmearingType SmearingType, internal::OptimizationType OptType>
struct RadialIntegralHandlerFixture : public rascal::MultipleStructureFixture<BaseFixture>

template<typename Calculator, class StructureManager>
class RepresentationCalculatorGradientFixture : public rascal::GradientTestFixture

Public Functions

inline RepresentationCalculatorGradientFixture(std::string filename, std::shared_ptr<StructureManager> structure, Provider_t &calc)

inline void advance_center()

Public Members

double fd_error_tol = {1E-4}

template<typename Calculator, class StructureManager>
class RepresentationCalculatorGradientProvider

struct SimpleFullFixture

struct SimpleHalfFixture

struct SimplePeriodicNLCCStrictFixture

struct SimplePeriodicNLHalfCCStrictFixture

struct SimpleStructureManagerNLCCStrictFixture

Subclassed by rascal::MultipleHypersSphericalExpansion

template<typename DataFixture>
struct SingleHypersSphericalExpansion : public DataFixture

template<typename DataFixture>
struct SingleHypersSphericalInvariants : public DataFixture

struct SortedCoulombTestData

class SparseKernel

Public Functions

inline SparseKernel(SparseKernel &&other) noexcept

template<class Calculator, class StructureManagers, class SparsePoints>
inline math::Matrix_t compute(const Calculator &calculator, const StructureManagers &managers, const SparsePoints &sparse_points)

template<class Calculator, class StructureManagers, class SparsePoints>
inline math::Matrix_t compute_derivative(const Calculator &calculator, const StructureManagers &managers, const SparsePoints &sparse_points, const bool compute_neg_stress)

Public Members

std::vector<std::string> identifiers = {}

Hypers_t parameters = {}

internal::TargetType target_type = {}

template<class BaseFixture>
struct SparseKernelFixture : public rascal::CollectionFixture<BaseFixture>, public rascal::CalculatorFixture<BaseFixture>

struct SparseKernelGradFixture

template<class Calculator>
class SparsePointsBlockSparse

Public Functions

SparsePointsBlockSparse(const SparsePointsBlockSparse &other) = default

SparsePointsBlockSparse(SparsePointsBlockSparse &&other) = default

inline size_t size() const

inline size_t size_by_species(const int &sp) const

inline const std::set<int> &species() const

inline std::vector<int> species_by_points() const

inline math::Matrix_t self_dot(const int &sp) const

template<class Val>
inline ColVector_t dot(const int &sp, internal::InternallySortedKeyMap<Key_t, Val> &representation) const

inline SparsePointsBlockSparse<Calculator> dot(const int &sp, math::Vector_t &vec) const

template<class Val>
inline ColVectorDer_t dot_derivative(const int &sp, internal::InternallySortedKeyMap<Key_t, Val> &representation_grad) const

inline std::map<int, int> get_offsets() const

template<class ManagerCollection>
inline void push_back(const Calculator &calculator, const ManagerCollection &collection, const std::vector<std::vector<int>> &selected_center_indices)

Public Members

Data_t values = {}

Indices_t indices = {}

Counters_t counters = {}

size_t inner_size = {0}

std::set<int> center_species = {}

Keys_t keys = {}

std::map<int, std::set<Key_t>> keys_sp = {}

template<class Representation, class ManagerCollection, template<class> class SparsePoints>
struct SparsePointsFixture

struct SparsificationSphericalInvariantsFixture

template<class ManagerImplementation, size_t MaxOrder>
class SpeciesManager : public rascal::Updateable, public std::enable_shared_from_this<SpeciesManager<ManagerImplementation, MaxOrder>>

Public Functions

SpeciesManager() = delete

SpeciesManager(const SpeciesManager &other) = delete

SpeciesManager(SpeciesManager &&other) = default

virtual ~SpeciesManager() = default

SpeciesManager &operator=(const SpeciesManager &other) = delete

SpeciesManager &operator=(SpeciesManager &&other) = default

virtual void update_self()

template<class ...Args>
inline void update(Args&&... arguments)

inline virtual void send_changed_structure_signal() final

inline virtual void update_children() final

template<size_t Order>
class Filter : public rascal::AdaptorFilter<ManagerImplementation, Order>

Public Functions

Filter() = delete

Filter(const Filter &other) = delete

Filter(Filter &&other) = delete

virtual ~Filter() = default

Filter &operator=(const Filter &other) = delete

Filter &operator=(Filter &&other) = delete

inline virtual void perform_filtering() final

template<class ManagerImplementation, size_t MaxOrder>
struct SpeciesManagerFixture

struct SphericalCovariantsTestData : public rascal::TestData

template<class RadialIntegral, class ClusterRef>
struct SphericalExpansionRadialDerivative

struct SphericalExpansionTestData : public rascal::TestData

struct SphericalHarmonicsClassRefFixture

template<size_t max_angular>
struct SphericalHarmonicsGradientsCalculator

struct SphericalHarmonicsRefFixture

struct SphericalInvariantsTestData : public rascal::TestData

struct StrictNLCCCollectionFixture : public rascal::MultipleStructureManagerNLCCStrictFixture

Subclassed by rascal::StrictNLKernelFixture, rascal::StrictNLSparseKernelFixture

struct StrictNLKernelFixture : public rascal::StrictNLCCCollectionFixture

struct StrictNLSparseKernelFixture : public rascal::StrictNLCCCollectionFixture

template<class ManagerImplementation>
class StructureManager : public rascal::StructureManagerBase

Public Types

using Vector_t = Eigen::Matrix<double, traits::Dim, 1>

using Property_t = Property<T, Order, StructureManager_t, NbRow, NbCol>

using TypedProperty_t = TypedProperty<T, Order, StructureManager_t>

using Key_t = std::vector<int>

using Hypers_t = json

Public Functions

inline StructureManager()

StructureManager(const StructureManager &other) = delete

StructureManager(StructureManager &&other) = default

virtual ~StructureManager() = default

StructureManager &operator=(const StructureManager &other) = delete

StructureManager &operator=(StructureManager &&other) = default

virtual void update_self() = 0

inline Iterator_t get_iterator_at(const size_t index, const size_t offset = 0)

inline Iterator_t begin()

inline Iterator_t end()

inline ProxyWithGhosts with_ghosts()

inline ProxyOnlyGhosts only_ghosts()

inline size_t size() const

template<size_t Layer>
inline bool is_center_atom(const ClusterRefKey<1, Layer> &cluster) const

template<size_t Layer>
inline bool is_center_atom(const ClusterRefKey<2, Layer> &cluster)

inline size_t size_with_ghosts() const

inline virtual size_t nb_clusters(size_t order) const final

inline Vector_ref position(int atom_tag)

inline Vector_ref position(const AtomRef &atom)

inline int atom_type(int atom_tag) const

inline bool is_property_in_current_level(const std::string &name) const

template<bool IsRoot = IsRootImplementation, std::enable_if_t<IsRoot, int> = 0>
inline bool is_property_in_stack(const std::string &name)

template<typename UserProperty_t>
inline UserProperty_t &create_property(const std::string &name, const bool exclude_ghosts = false, const std::string &metadata = "no metadata")

template<typename UserProperty_t>
inline bool check_property_t(const std::string &name) const

template<typename UserProperty_t>
inline void validate_property_t(std::shared_ptr<PropertyBase> property) const

template<typename UserProperty_t>
inline std::shared_ptr<UserProperty_t> get_property(const std::string &name, const bool validate_property = true, const bool force_creation = false, const bool exclude_ghosts = false, const std::string &metadata = "no metadata")

template<bool IsRoot = IsRootImplementation, std::enable_if_t<IsRoot, int> = 0>
inline void set_updated_property_status(const bool is_updated)

template<typename UserProperty_t, bool IsRoot = IsRootImplementation, std::enable_if_t<IsRoot, int> = 0>
inline std::shared_ptr<UserProperty_t> forward_get_property_request(const std::string &name, const bool validate_property)

template<typename UserProperty_t, bool IsRoot = IsRootImplementation, std::enable_if_t<not (IsRoot), int> = 0>
inline std::shared_ptr<UserProperty_t> forward_get_property_request(const std::string &name, bool validate_property)

inline Eigen::Matrix<int, Eigen::Dynamic, 5> get_gradients_info()

inline std::shared_ptr<ManagerImplementation> get_shared_ptr()

inline std::weak_ptr<ManagerImplementation> get_weak_ptr()

template<size_t TargetOrder, size_t Order, size_t Layer>
inline size_t get_cluster_size(const ClusterRefKey<Order, Layer> &cluster) const

template<size_t Order>
inline bool is_ghost_atom(const ClusterRef<Order> &cluster)

template<size_t Order, size_t Layer>
inline int get_neighbour_atom_tag(const ClusterRefKey<Order, Layer> &cluster, size_t index) const

inline int get_neighbour_atom_tag(const StructureManager &cluster, size_t &index) const

template<size_t Order, size_t Layer>
inline size_t get_offset(const ClusterRefKey<Order, Layer> &cluster) const

template<size_t Order>
inline size_t get_offset(const std::array<size_t, Order> &counters) const

inline virtual void send_changed_structure_signal() final

Public Static Functions

template<size_t TargetOrder>
static inline constexpr bool has_order()

static inline std::string get_name()

Public Static Attributes

static constexpr bool IsRootImplementation = std::is_same<PreviousManager_t, ManagerImplementation>::value

class AtomRef

Public Functions

AtomRef() = delete

inline AtomRef(Manager_t &manager, int id)

AtomRef(const AtomRef &other) = default

AtomRef(AtomRef &&other) = default

inline ~AtomRef()

AtomRef &operator=(const AtomRef &other) = delete

AtomRef &operator=(AtomRef &&other) = default

inline int get_index() const

inline Vector_ref get_position()

inline int get_atom_type() const

template<size_t Order>
class ClusterRef : public rascal::ClusterRefKey<Order, ManagerImplementation::template cluster_layer_from_order<Order>()>

Public Functions

ClusterRef() = delete

inline ClusterRef(ClusterRefKey<1, 0> &cluster, Manager_t &manager)

ClusterRef(const ClusterRef &other) = delete

ClusterRef(ClusterRef &&other) = default

virtual ~ClusterRef() = default

ClusterRef &operator=(const ClusterRef &other) = default

ClusterRef &operator=(ClusterRef &&other) = default

inline const std::array<AtomRef_t, Order> &get_atoms() const

template<size_t Order_ = Order, std::enable_if_t<Order_ == 2, int> = 0>
inline auto get_atom_j()

template<bool C = HasCenterPairAndIsOrderOne, std::enable_if_t<C, int> = 0>
inline auto get_atom_ii()

template<bool C = HasCenterPairAndIsOrderTwo, std::enable_if_t<C, int> = 0>
inline auto get_atom_jj()

inline auto get_position()

inline int get_atom_type() const

std::array<int, Order> get_atom_types() const

inline int get_atom_tag() const

inline Manager_t &get_manager()

inline const Manager_t &get_manager() const

inline size_t get_index() const

inline size_t get_global_index() const

inline const std::array<int, Order> &get_atom_tag_list() const

template<size_t Order_, bool C = IsOrderOne, std::enable_if_t<C, int> = 0>
inline CustomProxy<Order_> get_clusters_of_order(size_t start = 0)

template<bool C = IsOrderOneAndHasOrder<2>, std::enable_if_t<C, int> = 0>
inline CustomProxy<2> pairs()

template<bool C = IsOrderOneAndHasOrder<2>, std::enable_if_t<C, int> = 0>
inline CustomProxy<2> pairs_with_self_pair()

template<bool C = IsOrderOneAndHasOrder<3>, std::enable_if_t<C, int> = 0>
inline CustomProxy<3> triplets()

template<bool C = IsOrderOneAndHasOrder<4>, std::enable_if_t<C, int> = 0>
inline CustomProxy<4> quadruplets()

Public Static Attributes

static constexpr bool HasCenterPairAndIsOrderOne  {traits::HasCenterPair andIsOrderOne}

static constexpr bool HasCenterPairAndIsOrderTwo  {traits::HasCenterPair andOrder == 2}

template<size_t Order>
class Iterator

Public Functions

Iterator() = delete

Iterator(const Iterator &other) = default

Iterator(Iterator &&other) = default

virtual ~Iterator() = default

Iterator &operator=(const Iterator &other) = default

Iterator &operator=(Iterator &&other) = default

inline Iterator &operator++()

inline Iterator &operator--()

inline bool operator==(const Iterator &other) const

inline bool operator!=(const Iterator &other) const

inline const Container_t &get_container() const

class ProxyOnlyGhosts : public rascal::StructureManager<ManagerImplementation>::ProxyWithGhosts

Public Functions

ProxyOnlyGhosts() = delete

ProxyOnlyGhosts(const ProxyOnlyGhosts &other) = delete

ProxyOnlyGhosts(ProxyOnlyGhosts &&other) = default

virtual ~ProxyOnlyGhosts() = default

ProxyOnlyGhosts &operator=(const ProxyOnlyGhosts &other) = delete

ProxyOnlyGhosts &operator=(ProxyOnlyGhosts &&other) = default

inline Iterator_t begin()

class ProxyWithGhosts

Subclassed by rascal::StructureManager< ManagerImplementation >::ProxyOnlyGhosts

Public Functions

ProxyWithGhosts() = delete

inline ProxyWithGhosts(ManagerImplementation &manager)

ProxyWithGhosts(const ProxyWithGhosts &other) = delete

ProxyWithGhosts(ProxyWithGhosts &&other) = default

virtual ~ProxyWithGhosts() = default

ProxyWithGhosts &operator=(const ProxyWithGhosts &other) = delete

ProxyWithGhosts &operator=(ProxyWithGhosts &&other) = default

inline Iterator_t begin()

inline Iterator_t end()

template<class ManagerImplementation>
struct StructureManager_traits

template<class ManagerImplementation>
struct StructureManager_traits<AdaptorCenterContribution<ManagerImplementation>>

template<class ManagerImplementation, size_t MaxOrder_>
struct StructureManager_traits<AdaptorFilter<ManagerImplementation, MaxOrder_>>

Public Types

using LayerByOrder = typename LayerIncreaser<typename parent_traits::LayerByOrder>::type

Public Static Attributes

static constexpr size_t MaxOrder = {MaxOrder_}

template<class ManagerImplementation>
struct StructureManager_traits<AdaptorFullList<ManagerImplementation>>

template<class ManagerImplementation>
struct StructureManager_traits<AdaptorHalfList<ManagerImplementation>>

template<class ManagerImplementation>
struct StructureManager_traits<AdaptorKspace<ManagerImplementation>>

template<class ManagerImplementation>
struct StructureManager_traits<AdaptorMaxOrder<ManagerImplementation>>

template<class ManagerImplementation>
struct StructureManager_traits<AdaptorNeighbourList<ManagerImplementation>>

template<class ManagerImplementation>
struct StructureManager_traits<AdaptorStrict<ManagerImplementation>>

template<>
struct StructureManager_traits<StructureManagerCenters>

template<>
struct StructureManager_traits<StructureManagerLammps>

class StructureManagerBase : public rascal::Updateable

Subclassed by rascal::StructureManager< ManagerImplementation >, rascal::StructureManager< AdaptorCenterContribution< ManagerImplementation > >, rascal::StructureManager< AdaptorFilter< ManagerImplementation, MaxOrder > >, rascal::StructureManager< AdaptorFullList< ManagerImplementation > >, rascal::StructureManager< AdaptorHalfList< ManagerImplementation > >, rascal::StructureManager< AdaptorKspace< ManagerImplementation > >, rascal::StructureManager< AdaptorMaxOrder< ManagerImplementation > >, rascal::StructureManager< AdaptorNeighbourList< ManagerImplementation > >, rascal::StructureManager< AdaptorStrict< ManagerImplementation > >, rascal::StructureManager< StructureManagerCenters >, rascal::StructureManager< StructureManagerLammps >

Public Functions

virtual void update_self() = 0

class StructureManagerCenters : public rascal::StructureManager<StructureManagerCenters>, public std::enable_shared_from_this<StructureManagerCenters>

Public Types

using Cell_t = AtomicStructure<traits::Dim>::Cell_t

using ClusterRef_t = typename Parent::template ClusterRef<Order>

Public Functions

inline StructureManagerCenters()

StructureManagerCenters(const StructureManagerCenters &other) = delete

StructureManagerCenters(StructureManagerCenters &&other) = delete

virtual ~StructureManagerCenters() = default

StructureManagerCenters &operator=(const StructureManagerCenters &other) = delete

StructureManagerCenters &operator=(StructureManagerCenters &&other) = delete

template<class ...Args>
inline void update(Args&&... arguments)

inline Cell_ref get_cell()

inline int get_atom_type(int atom_tag) const

inline ConstAtomTypes_ref get_atom_types() const

inline PBC_ref get_periodic_boundary_conditions()

inline Vector_ref get_position(const AtomRef_t &atom)

inline Vector_ref get_position(int atom_tag)

inline Positions_ref get_positions()

inline size_t get_size() const

inline size_t get_size_with_ghosts() const

inline int get_neighbour_atom_tag(const Parent&, size_t index) const

template<size_t Order, size_t Layer>
inline int get_neighbour_atom_tag(const ClusterRefKey<Order, Layer>&, size_t) const

template<size_t Order>
size_t get_offset_impl(const std::array<size_t, Order> &counters) const

size_t get_nb_clusters(size_t order) const

Eigen::Matrix<int, Eigen::Dynamic, 5> get_gradients_info() const

inline virtual void update_self()

template<class ...Args>
inline void update_self(Args&&... arguments)

Public Static Functions

static inline constexpr int dim()

struct StructureManagerCentersStackFixture

class StructureManagerLammps : public rascal::StructureManager<StructureManagerLammps>, public std::enable_shared_from_this<StructureManagerLammps>

Public Functions

StructureManagerLammps() = default

StructureManagerLammps(const StructureManagerLammps &other) = delete

StructureManagerLammps(StructureManagerLammps &&other) = delete

virtual ~StructureManagerLammps() = default

StructureManagerLammps &operator=(const StructureManagerLammps &other) = delete

StructureManagerLammps &operator=(StructureManagerLammps &&other) = delete

template<class ...Args>
inline void update(Args&&... arguments)

inline Vector_ref get_position(int atom_tag)

inline Vector_ref get_position(const AtomRef_t &atom)

inline int get_atom_type(int atom_tag) const

inline size_t get_size() const

inline size_t get_size_with_ghosts() const

template<size_t TargetOrder, size_t Order, size_t Layer>
inline std::enable_if_t<TargetOrder == 2, size_t> get_cluster_size_impl(const ClusterRefKey<Order, Layer> &cluster) const

template<size_t Order, size_t Layer>
inline int get_neighbour_atom_tag(const ClusterRefKey<Order, Layer> &cluster, size_t index) const

inline int get_neighbour_atom_tag(const Parent&, size_t cluster_index) const

template<size_t Order>
size_t get_offset_impl(const std::array<size_t, Order> &counters) const

size_t get_nb_clusters(int order) const

inline virtual void update_self()

void update_self(int inum, int tot_num, int *ilist, int *numneigh, int **firstneigh, double **x, double **f, int *type, double *eatom, double **vatom)

template<typename Manager, template<class> class ...AdaptorImplementation>
struct StructureManagerTypeHolder

struct TestData

Subclassed by rascal::SphericalCovariantsTestData, rascal::SphericalExpansionTestData, rascal::SphericalInvariantsTestData

template<class StackFixture>
struct TriplePropertyFixture : public rascal::PairPropertyFixture<StackFixture>

template<typename ta, typename tb>
struct tuple_cat

template<typename... a, typename... b> tuple< b... > >

template<typename T, size_t Order_, class Manager>
class TypedProperty : public rascal::PropertyBase

Public Functions

TypedProperty() = delete

TypedProperty(const TypedProperty &other) = delete

TypedProperty(TypedProperty &&other) = default

~TypedProperty() = default

TypedProperty &operator=(const TypedProperty &other) = delete

TypedProperty &operator=(TypedProperty &&other) = default

inline virtual const std::string &get_type_info() const

template<size_t Order__ = Order, std::enable_if_t<(Order__ > 1> inline void resize ()

template<size_t Order__ = Order, std::enable_if_t<(Order__ == 0), int> = 0>
inline void resize()

template<size_t Order__ = Order, std::enable_if_t<(Order__ == 1), int> = 0>
inline void resize()

inline void fill_sequence()

template<size_t Order__ = Order, std::enable_if_t<(Order__ == 0), int> = 0>
inline size_t size() const

template<size_t Order__ = Order, std::enable_if_t<(Order__ > 0> inline size_t size () const

inline void clear()

template<size_t CallerLayer, size_t Order__ = Order>
inline std::enable_if_t<(Order__ > 0), reference> operator[](const ClusterRefKey<Order, CallerLayer> &id)

inline reference operator[](size_t index)

template<size_t Order__ = Order, std::enable_if_t<(Order__ == 0), int> = 0>
inline T &operator()(int i_row, int i_col = 0)

inline size_t get_nb_item() const

inline reference back()

inline const Eigen::Map<const Matrix_t> view()

template<template<typename Manager, template<class> class ...AdaptorImplementation> class Collection, typename StructureManagerTypeHolder_>
struct TypeHolderInjector

class Updateable

Subclassed by rascal::SpeciesManager< ManagerImplementation, MaxOrder >, rascal::StructureManagerBase

Public Functions

inline Updateable()

Updateable(const Updateable &other) = delete

Updateable(Updateable &&other) = default

virtual ~Updateable() = default

Updateable &operator=(const Updateable &other) = delete

Updateable &operator=(Updateable &&other) = default

virtual void update_children() = 0

inline void add_child(Children_t child)

virtual void update_self() = 0

virtual void send_changed_structure_signal() = 0

inline void set_update_status(const bool sig)

inline bool get_update_status() const

namespace AdaptorTraits

Enums

enum SortedByDistance

Values:

enumerator yes

enumerator no

enum NeighbourListType

Values:

enumerator full

enumerator half

enum Strict

Values:

enumerator yes

enumerator no

namespace detail

template<template<typename Manager, template<class> class ...AdaptorImplementation> class Collection, typename SM, typename AdaptorTypeHolder_>
struct InjectTypeHolderHelper

template<template<typename Manager, template<class> class ...AdaptorImplementation> class Collection, typename SM, template<class> class ...Ti>
struct InjectTypeHolderHelper<Collection, SM, AdaptorTypeHolder<Ti...>>

template<template<typename Manager, template<class> class ...AdaptorImplementation> class Collection, typename StructureManagerTypeHolder_>
struct InjectTypeHolderUtil

template<template< typename Manager, template< class > class... AdaptorImplementation > class Collection, typename... T> tuple< T... > >

namespace internal

Typedefs

using distiter = typename std::vector<double>::const_iterator

using void_t = typename make_void<Ts...>::type

using make_index_range = decltype(add_to_sequence<Min>(std::make_index_sequence<Max - Min + 1>()))

Enums

enum KernelType

Values:

enumerator Cosine

enum TargetType

Values:

enumerator Structure

enumerator Atom

enum SparseKernelType

Values:

enumerator GAP

enum CMSortAlgorithm

Values:

enumerator Distance

enumerator RowNorm

enum SphericalCovariantsType

Values:

enumerator LambdaSpectrum

enum RadialBasisType

Values:

enumerator GTO

enumerator DVR

enumerator End_

enum AtomicSmearingType

Values:

enumerator Constant

enumerator PerSpecies

enumerator Radial

enumerator End_

enum OptimizationType

Values:

enumerator None

enumerator Spline

enumerator RadialDimReductionSpline

enumerator End_

enum SphericalInvariantsType

Values:

enumerator RadialSpectrum

enumerator PowerSpectrum

enumerator BiSpectrum

enum CutoffFunctionType

Values:

enumerator ShiftedCosine

enumerator RadialScaling

Functions

inline math::Matrix_t pow_zeta(math::Matrix_t &&kernel, const size_t &zeta)

inline Eigen::ArrayXd precompute_wigner_3js(size_t max_angular, bool inversion_symmetry, size_t lambda)

template<AtomicSmearingType Type, class Hypers>
auto make_atomic_smearing(const Hypers &sigma_hypers)

template<AtomicSmearingType Type>
auto downcast_atomic_smearing(const std::shared_ptr<AtomicSmearingSpecificationBase> &atomic_smearing)

inline Eigen::VectorXd precompute_l_factors(size_t max_angular)

inline Eigen::ArrayXd precompute_wigner_w3js(size_t max_angular, bool inversion_symmetry)

inline double switching_function_cosine(double r, double cutoff, double smooth_width)

inline double derivative_switching_funtion_cosine(double r, double cutoff, double smooth_width)

template<typename R, typename I>
constexpr R ipow(R base, I exponent)

template<size_t Dim, class Container_t>
void fill_neighbours_atom_tag(const int current_atom_tag, const std::array<int, Dim> &ccoord, const Container_t &boxes, std::vector<int> &neighbours_atom_tag)

template<class Vector_t>
std::array<int, Vector_t::SizeAtCompileTime> get_box_index(const Vector_t &position, double rc)

template<size_t Dim>
constexpr Dim_t get_index(const std::array<int, Dim> &sizes, const std::array<int, Dim> &ccoord)

template<int Dim>
bool position_in_bounds(const Eigen::Matrix<double, Dim, 1> &min, const Eigen::Matrix<double, Dim, 1> &max, const Eigen::Matrix<double, Dim, 1> &pos, const double epsilon = 1e-4)

template<class ManagerImplementation>
bool check_cutoff(const std::shared_ptr<ManagerImplementation> &manager, double cutoff)

template<typename PropertyType, typename Manager>
PropertyType make_individual_property(Manager &manager)

template<typename T, size_t Size, int... Indices>
std::array<T, Size + 1> append_array_helper(const std::array<T, Size> &arr, T &&t, std::integer_sequence<int, Indices...>)

template<typename T, size_t Size>
std::array<T, Size + 1> append_array(const std::array<T, Size> &arr, T &&t)

template<typename T, size_t Size1, int... Indices1, size_t Size2, int... Indices2>
std::array<T, Size1 + Size2> concat_array_helper(const std::array<T, Size1> &arr1, const std::array<T, Size2> &arr2, std::integer_sequence<int, Indices1...>, std::integer_sequence<int, Indices2...>)

template<typename T, size_t Size1, size_t Size2>
std::array<T, Size1 + Size2> concat_array(const std::array<T, Size1> &arr1, const std::array<T, Size2> &arr2)

template<class Manager, size_t Order, size_t... Indices>
std::array<int, Order> species_aggregator_helper(const std::array<int, Order> &array, const Manager &manager, std::index_sequence<Indices...>)

template<class Manager, size_t Order, size_t... Indices>
std::array<int, Order> species_aggregator(const std::array<int, Order> &index_array, const Manager &manager)

template<class T, class Vec>
bool is_element_in(const T &element, const Vec &vector)

template<size_t TargetOrder, size_t... Orders>
static constexpr bool is_order_available(std::index_sequence<Orders...>)

template<size_t... Orders>
constexpr size_t get_last_element_in_sequence(std::index_sequence<Orders...>)

template<typename Enum>
constexpr size_t enum_value(Enum e)

template<typename Enum>
constexpr size_t enum_size()

template<typename Enum1, typename Enum2>
constexpr size_t combine_enums(Enum1 e1, Enum2 e2)

template<typename Enum1, typename Enum2, typename Enum3>
constexpr size_t combine_enums(Enum1 e1, Enum2 e2, Enum3 e3)

template<size_t N, size_t... Seq>
constexpr std::index_sequence<N + Seq...> add_to_sequence(std::index_sequence<Seq...>)

template<class F, size_t... Is>
constexpr auto index_apply_impl(F func, std::index_sequence<Is...>)

template<size_t Min, size_t Max, class F>
constexpr auto index_apply(F func)

template<size_t Min, size_t Max, class Tuple>
constexpr auto take_range(Tuple t)

template<class Tuple, class F>
constexpr auto apply(F func, Tuple t)

template<typename Func, typename Last>
inline void for_each_impl(Func &&f, Last &&last)

template<typename Func, typename Head, typename ...Tail>
inline void for_each_impl(Func &&f, Head &&head, Tail&&... tail)

template<typename Func, size_t... Indices, typename ...Args>
inline void for_each_helper(Func &&f, std::index_sequence<Indices...>, std::tuple<Args...> &&tup)

template<typename Func, typename ...Args>
inline void for_each(std::tuple<Args...> &tup, Func &&f)

template<class Set_a, class Set_b>
auto set_intersection(const Set_a &keys_a, const Set_b &keys_b)

std::string type_name_demangled(const char *name)

void replace(std::string &string, const std::string &pattern, const std::string &replacement)

template<typename T>
std::string type_name()

std::vector<uint8_t> read_binary_file(const std::string &filename)

std::string get_filename_extension(const std::string &filename)

template<class Object, class ...Bases>
void bind_dict_representation(py::class_<Object, Bases...> &obj)

template<typename T>
std::string GetBindingTypeName()

template<size_t CurrentPosition, typename ManagerImplementation, template<class> class AdaptorImplementation, template<class> class ...AdaptorImplementationPack>
struct AdaptorFactory_hypers

Public Functions

template<typename ...Args, typename Hypers_t>
inline AdaptorFactory_hypers(ImplementationPtr_t &m, const Hypers_t &adaptors_hypers)

template<size_t CurrentPosition, typename ManagerImplementation, template<class> class AdaptorImplementation>
struct AdaptorFactory_hypers<CurrentPosition, ManagerImplementation, AdaptorImplementation>

template<typename ManagerImplementation, template<class> class AdaptorImplementation, template<class> class ...AdaptorImplementationPack>
struct AdaptorTypeStacker

template<typename ManagerImplementation, template<class> class AdaptorImplementation>
struct AdaptorTypeStacker<ManagerImplementation, AdaptorImplementation>

template<typename Calculator_t, typename = void>
struct Argument_t

template<typename Calculator_t> value > >

template<AtomicSmearingType SigmaType>
struct AtomicSmearingSpecification

template<> Constant > : public rascal::internal::AtomicSmearingSpecificationBase

template<> PerSpecies > : public rascal::internal::AtomicSmearingSpecificationBase

template<> Radial > : public rascal::internal::AtomicSmearingSpecificationBase

struct AtomicSmearingSpecificationBase

Subclassed by rascal::internal::AtomicSmearingSpecification< AtomicSmearingType::Constant >, rascal::internal::AtomicSmearingSpecification< AtomicSmearingType::PerSpecies >, rascal::internal::AtomicSmearingSpecification< AtomicSmearingType::Radial >

Public Functions

AtomicSmearingSpecificationBase() = default

virtual ~AtomicSmearingSpecificationBase() = default

AtomicSmearingSpecificationBase(const AtomicSmearingSpecificationBase &other) = delete

AtomicSmearingSpecificationBase(AtomicSmearingSpecificationBase &&other) = default

AtomicSmearingSpecificationBase &operator=(const AtomicSmearingSpecificationBase &other) = delete

AtomicSmearingSpecificationBase &operator=(AtomicSmearingSpecificationBase &&other) = default

template<size_t Order, class ManagerImplementation, size_t MaxOrder>
struct ClusterAdder

template<class ManagerImplementation, size_t MaxOrder>
struct ClusterAdder<1, ManagerImplementation, MaxOrder>

template<typename Tup, typename Manager>
struct ClusterIndexConstructor

template<typename... PropertyTypes, typename Manager> tuple< PropertyTypes... >, Manager >

template<typename Manager, typename sequence>
struct ClusterIndexPropertyComputer

template<typename Manager, size_t... Layers> index_sequence< Layers... > >

template<typename Manager, size_t Order, typename sequence, typename Tup>
struct ClusterIndexPropertyComputer_Helper

template<typename Manager, size_t Order, size_t LayersHead, typename... TupComp> tuple< TupComp... > >

template<typename Manager, size_t Order, size_t LayersHead, size_t... LayersTail, typename... TupComp> tuple< TupComp... > >

template<class ParentClass, typename ClusterIndicesType, size_t Layer>
struct ClusterIndicesConstCaster

struct CompareSortedKeyLess

template<bool IsStrict, class ManagerImplementation>
struct CutOffChecker

template<class ManagerImplementation>
struct CutOffChecker<false, ManagerImplementation>

template<CutoffFunctionType Type>
struct CutoffFunction : public rascal::internal::CutoffFunctionBase

template<> RadialScaling > : public rascal::internal::CutoffFunctionBase

Public Functions

inline virtual void set_hyperparameters(const Hypers_t &hypers) override

Public Members

Hypers_t hypers = {}

double cutoff = {0.}

double smooth_width = {0.}

double rate = {0.}

double exponent = {0}

double scale = {1.}

template<> ShiftedCosine > : public rascal::internal::CutoffFunctionBase

Public Functions

inline virtual void set_hyperparameters(const Hypers_t &hypers) override

Public Members

Hypers_t hypers = {}

double cutoff = {0.}

double smooth_width = {0.}

struct CutoffFunctionBase

Subclassed by rascal::internal::CutoffFunction< Type >, rascal::internal::CutoffFunction< internal::CutoffFunctionType::RadialScaling >, rascal::internal::CutoffFunction< internal::CutoffFunctionType::ShiftedCosine >

Public Functions

CutoffFunctionBase() = default

virtual ~CutoffFunctionBase() = default

CutoffFunctionBase(const CutoffFunctionBase &other) = delete

CutoffFunctionBase(CutoffFunctionBase &&other) = default

CutoffFunctionBase &operator=(const CutoffFunctionBase &other) = delete

CutoffFunctionBase &operator=(CutoffFunctionBase &&other) = default

virtual void set_hyperparameters(const Hypers_t&) = 0

template<class ManagerImplementation, size_t MaxOrder, size_t CurrentOrder = 2, bool Stop = false>
struct FilterSpeciesLoop

template<class ManagerImplementation, size_t MaxOrder, size_t CurrentOrder>
struct FilterSpeciesLoop<ManagerImplementation, MaxOrder, CurrentOrder, true>

template<class KeyType, typename T = int>
struct Hash

template<bool AtMaxOrder>
struct IncreaseHelper

template<>
struct IncreaseHelper<false>

template<int Dim>
class IndexContainer

Public Functions

IndexContainer() = delete

inline explicit IndexContainer(const std::array<int, Dim> &nboxes)

IndexContainer(const IndexContainer &other) = delete

IndexContainer(IndexContainer &&other) = delete

inline ~IndexContainer()

IndexContainer &operator=(const IndexContainer &other) = delete

IndexContainer &operator=(IndexContainer &&other) = default

inline std::vector<int> &operator[](const std::array<int, Dim> &ccoord)

template<class K, class V>
class InternallySortedKeyMap

Public Functions

inline explicit InternallySortedKeyMap(Array_t &data, const size_t &global_offset = 0)

InternallySortedKeyMap(const InternallySortedKeyMap &other) = default

InternallySortedKeyMap(InternallySortedKeyMap &&other) = default

~InternallySortedKeyMap() = default

inline Self_t &operator=(const Self_t &other)

inline Self_t &operator=(Self_t &&other)

inline reference at(const key_type &key)

inline reference operator[](const key_type &key)

inline reference at(const SortedKey_t &skey)

inline reference operator[](const SortedKey_t &skey)

template<template<typename...> class Key_List, typename ...Args>
inline void resize_view(const Key_List<key_type, Args...> &keys, int n_row, int n_col, const size_t &global_offset)

inline size_t count(const key_type &key) const

inline void clear() noexcept

inline size_t get_key_hash() const

inline std::vector<key_type> get_keys() const

inline Precision_t norm() const

inline double normalize_and_get_norm()

inline void multiply_off_diagonal_elements_by(double fac)

inline Precision_t dot(Self_t &B)

template<typename Derived>
inline void lhs_dot(const Eigen::EigenBase<Derived> &left_side_mat)

Public Members

Array_t &data

Map_t map = {}

size_t global_offset

size_t total_length = {0}

bool normalized = {false}

size_t key_hash = {0}

template<typename Value>
class Iterator : public std::iterator<std::bidirectional_iterator_tag, std::pair<K, std::remove_const<Value>::type>>

template<class, class = void_t<>>
struct is_iterable : public false_type

template<class T> const_iterator > > : public true_type

template<class, class = void_t<>>
struct is_map : public false_type

template<class T> key_type > > : public true_type

template<class T>
struct is_proper_iterator

template<internal::KernelType Type>
struct KernelImpl

template<> Cosine > : public rascal::internal::KernelImplBase

Public Functions

template<class Property_t, internal::TargetType Type, std::enable_if_t<Type == internal::TargetType::Structure, int> = 0, class StructureManagers>
inline math::Matrix_t compute(StructureManagers &managers_a, StructureManagers &managers_b, const std::string &representation_name)

template<class Property_t, internal::TargetType Type, std::enable_if_t<Type == internal::TargetType::Structure, int> = 0, class StructureManagers>
inline math::Matrix_t compute(StructureManagers &managers_a, const std::string &representation_name)

template<class Property_t, internal::TargetType Type, std::enable_if_t<Type == internal::TargetType::Atom, int> = 0, class StructureManagers>
inline math::Matrix_t compute(const StructureManagers &managers_a, const StructureManagers &managers_b, const std::string &representation_name)

template<class Property_t, internal::TargetType Type, std::enable_if_t<Type == internal::TargetType::Atom, int> = 0, class StructureManagers>
inline math::Matrix_t compute(const StructureManagers &managers_a, const std::string &representation_name)

Public Members

size_t zeta = {1}

struct KernelImplBase

Subclassed by rascal::internal::KernelImpl< internal::KernelType::Cosine >, rascal::internal::SparseKernelImpl< internal::SparseKernelType::GAP >

template<template<class> class Adaptor, size_t HyperPos>
struct make_adapted_manager_hypers_util

template<typename SM, typename AdaptorTypeHolder_>
struct make_structure_manager_stack_with_hypers_util

template<typename SM, template<class> class ...Ti>
struct make_structure_manager_stack_with_hypers_util<SM, AdaptorTypeHolder<Ti...>>

template<typename ...Ts>
struct make_void

template<size_t Dim>
class MeshBounds

Public Functions

inline explicit MeshBounds(const std::array<double, 2 * Dim> &extent)

MeshBounds(const MeshBounds &other) = default

MeshBounds &operator=(const MeshBounds &other) = default

inline iterator begin() const

inline iterator end() const

inline size_t size() const

class iterator

Public Types

using value_type = std::array<double, Dim>

using const_value_type = const value_type

using pointer = value_type*

using iterator_category = std::forward_iterator_tag

Public Functions

inline explicit iterator(const MeshBounds &mesh_bounds, bool begin = true)

inline ~iterator()

inline value_type operator*() const

inline iterator &operator++()

inline bool operator!=(const iterator &other) const

struct ordering

template<size_t Dim>
class PeriodicImages

Public Functions

inline PeriodicImages(const std::array<int, Dim> &origin, const std::array<int, Dim> &nrepetitions, size_t ntot)

PeriodicImages(const PeriodicImages &other) = default

PeriodicImages &operator=(const PeriodicImages &other) = default

inline iterator begin() const

inline iterator end() const

inline size_t size() const

class iterator

Public Types

using const_value_type = const value_type

using pointer = value_type*

using iterator_category = std::forward_iterator_tag

Public Functions

inline explicit iterator(const PeriodicImages &periodic_images, bool begin = true)

inline value_type operator*() const

inline iterator &operator++()

inline bool operator!=(const iterator &other) const

template<RadialBasisType RBT>
struct RadialContribution

Subclassed by rascal::internal::RadialContributionHandler< RBT, AtomicSmearingType::Constant, OptimizationType::None >, rascal::internal::RadialContributionHandler< RBT, AtomicSmearingType::Constant, OptimizationType::RadialDimReductionSpline >, rascal::internal::RadialContributionHandler< RBT, AtomicSmearingType::Constant, OptimizationType::Spline >

template<> DVR > : public rascal::internal::RadialContributionBase

Public Functions

inline explicit RadialContribution(const Hypers_t &hypers)

virtual ~RadialContribution() = default

RadialContribution(const RadialContribution &other) = delete

RadialContribution(RadialContribution &&other) = default

RadialContribution &operator=(const RadialContribution &other) = delete

RadialContribution &operator=(RadialContribution &&other) = default

inline virtual void set_hyperparameters(const Hypers_t &hypers) override

inline Vector_Ref compute_center_contribution(const double fac_a)

template<AtomicSmearingType AST, size_t Order, size_t Layer>
inline Matrix_Ref compute_neighbour_contribution(const double distance, const ClusterRefKey<Order, Layer> &pair)

template<size_t Order, size_t Layer>
inline Matrix_Ref compute_neighbour_derivative(const double, const ClusterRefKey<Order, Layer>&, int)

template<> GTO > : public rascal::internal::RadialContributionBase

Public Functions

inline virtual void set_hyperparameters(const Hypers_t &hypers) override

template<AtomicSmearingType AST>
inline Matrix_t compute_contribution(const double distance, const double sigma)

template<AtomicSmearingType AST, size_t Order, size_t Layer>
inline Vector_Ref compute_center_contribution(ClusterRefKey<Order, Layer> &center, int)

inline Vector_Ref compute_center_contribution(double fac_a)

template<AtomicSmearingType AST, size_t Order, size_t Layer>
inline Matrix_Ref compute_neighbour_contribution(const double distance, const ClusterRefKey<Order, Layer> &pair)

template<size_t Order, size_t Layer>
inline Matrix_Ref compute_neighbour_derivative(const double distance, const ClusterRefKey<Order, Layer>&, int)

inline void finalize_radial_integral_neighbour()

inline void precompute_radial_sigmas()

inline void precompute_radial_overlap()

Public Members

Vector_t radial_norm_factors = {}

Matrix_t radial_ortho_matrix = {}

Matrix_t ortho_norm_matrix = {}

struct RadialContributionBase

Subclassed by rascal::internal::RadialContribution< RadialBasisType::DVR >, rascal::internal::RadialContribution< RadialBasisType::GTO >

Public Functions

RadialContributionBase() = default

virtual ~RadialContributionBase() = default

RadialContributionBase(const RadialContributionBase &other) = delete

RadialContributionBase(RadialContributionBase &&other) = default

RadialContributionBase &operator=(const RadialContributionBase &other) = delete

RadialContributionBase &operator=(RadialContributionBase &&other) = default

virtual void set_hyperparameters(const Hypers_t&) = 0

template<AtomicSmearingType AST, size_t Order, size_t Layer>
inline Vector_Ref compute_center_contribution(ClusterRefKey<Order, Layer>&, int)

template<AtomicSmearingType AST, size_t Order, size_t Layer>
inline Matrix_Ref compute_neighbour_contribution(const double, const ClusterRefKey<Order, Layer>&, int)

template<size_t Order, size_t Layer>
inline Matrix_Ref compute_neighbour_derivative(const double, const ClusterRefKey<Order, Layer>&, int)

template<RadialBasisType RBT, AtomicSmearingType AST, OptimizationType OT>
struct RadialContributionHandler

template<RadialBasisType RBT> None > : public rascal::internal::RadialContribution< RBT >

template<RadialBasisType RBT> RadialDimReductionSpline > : public rascal::internal::RadialContribution< RBT >

template<RadialBasisType RBT> Spline > : public rascal::internal::RadialContribution< RBT >

struct ResizePropertyToZero

template<CMSortAlgorithm Method>
struct SortCoulomMatrix

template<> Distance >

Public Static Functions

static inline std::vector<std::pair<size_t, distiter>> get_coulomb_matrix_sorting_order(const Eigen::Ref<const Eigen::MatrixXd> &distance_mat, const Eigen::Ref<const Eigen::MatrixXd>&)

template<> RowNorm >

Public Static Functions

static inline std::vector<std::pair<size_t, distiter>> get_coulomb_matrix_sorting_order(const Eigen::Ref<const Eigen::MatrixXd>&, const Eigen::Ref<const Eigen::MatrixXd> &coulomb_mat)

template<bool IsSorted>
struct Sorted

template<class KeyType>
struct SortedKey

Public Functions

template<class Int>
inline Value_t &operator[](const Int &id)

template<internal::SparseKernelType Type>
struct SparseKernelImpl

template<> GAP > : public rascal::internal::KernelImplBase

Public Functions

template<class Property_t, internal::TargetType Type, std::enable_if_t<Type == internal::TargetType::Structure, int> = 0, class StructureManagers, class SparsePoints>
inline math::Matrix_t compute(StructureManagers &managers, SparsePoints &sparse_points, const std::string &representation_name)

template<class SparsePoints>
inline math::Matrix_t compute(SparsePoints &sparse_points)

template<class Property_t, internal::TargetType Type, std::enable_if_t<Type == internal::TargetType::Atom, int> = 0, class StructureManagers, class SparsePoints>
inline math::Matrix_t compute(const StructureManagers &managers, const SparsePoints &sparse_points, const std::string &representation_name)

template<class Property_t, class PropertyGradient_t, internal::TargetType Type, std::enable_if_t<Type == internal::TargetType::Atom, int> = 0, class StructureManagers, class SparsePoints>
inline math::Matrix_t compute_derivative(StructureManagers &managers, SparsePoints &sparse_points, const std::string &representation_name, const std::string &representation_grad_name, const bool compute_neg_stress)

Public Members

size_t zeta = {1}

template<size_t Dim>
class Stencil

Public Functions

inline explicit Stencil(const std::array<int, Dim> &origin)

Stencil(const Stencil &other) = default

Stencil &operator=(const Stencil &other) = default

~Stencil() = default

inline iterator begin() const

inline iterator end() const

inline size_t size() const

class iterator

Public Types

using value_type = std::array<int, Dim>

using const_value_type = const value_type

using pointer = value_type*

using iterator_category = std::forward_iterator_tag

Public Functions

inline explicit iterator(const Stencil &stencil, bool begin = true)

inline ~iterator()

inline value_type operator*() const

inline iterator &operator++()

inline bool operator!=(const iterator &other) const

template<typename StructureManager, int TargetLevel>
struct UnderlyingManagerExtractor

template<typename StructureManager>
struct UnderlyingManagerExtractor<StructureManager, 0>

template<typename T, Dim_t NbRow, Dim_t NbCol>
struct Value

Public Static Functions

static inline reference get_ref(T &value, int nb_row, int nb_col)

static inline reference get_ref(T &value)

static inline void push_in_vector(std::vector<T> &vec, reference ref)

static inline void push_in_vector(std::vector<T> &vec, reference ref, Dim_t &nb_row, Dim_t &nb_col)

template<typename Derived>
static inline void push_in_vector(std::vector<T> &vec, const Eigen::DenseBase<Derived> &ref)

template<typename Derived>
static inline void push_in_vector(std::vector<T> &vec, const Eigen::DenseBase<Derived> &ref, const Dim_t &nb_row, const Dim_t &nb_col)

template<typename T>
struct Value<T, 1, 1>

Public Static Functions

static inline reference get_ref(T &value)

static inline const_reference get_ref(const T &value)

static inline void push_in_vector(std::vector<T> &vec, reference ref)

template<typename Derived>
static inline void push_in_vector(std::vector<T> &vec, const Eigen::DenseBase<Derived> &ref)

namespace detail

Typedefs

using Key_t = KeyStandardisation<int, Order>

using Value_t = std::unique_ptr<FilterBase>

using Map_t = std::map<Key_t<Order>, Value_t>

namespace details

template<size_t TargetOrder, size_t Order, size_t... Orders>
struct IsOrderAvailableHelper

template<size_t TargetOrder, size_t Order>
struct IsOrderAvailableHelper<TargetOrder, Order>

namespace json_io

Functions

json load(const std::string &filename)

json load_txt(const std::string &filename)

json load_bin(const std::string &filename)

void to_json(json &j, AtomicJsonData &s)

void from_json(const json &j, AtomicJsonData &s)

double check_units(const std::string &expected_unit, const json &parameter)

struct AtomicJsonData

Public Members

std::vector<std::vector<double>> cell = {}

std::vector<int> type = {}

std::vector<int> pbc = {}

std::vector<std::vector<double>> position = {}

namespace math

Typedefs

using Matrix_t = Eigen::Matrix<double, Eigen::Dynamic, Eigen::Dynamic, Eigen::RowMajor>

using MatrixX2_t = Eigen::Matrix<double, Eigen::Dynamic, 2>

using Vector_t = Eigen::Matrix<double, 1, Eigen::Dynamic>

using Matrix_Ref = typename Eigen::Ref<const Matrix_t>

using MatrixX2_Ref = typename Eigen::Ref<const MatrixX2_t>

using Vector_Ref = typename Eigen::Ref<const Vector_t>

Enums

enum RefinementMethod_t

Values:

enumerator Exponential

enumerator Linear

enum InterpolationMethod_t

Values:

enumerator CubicSplineScalarUniform

enumerator CubicSplineVectorUniform

enum ErrorMetric_t

Values:

enumerator Absolute

enumerator Relative

enumerator AbsoluteRelative

Functions

MatrixX2_t compute_gauss_legendre_points_weights(double r_st, double r_nd, int order_n)

bool is_grid_uniform(const Vector_Ref &grid)

inline double pow(double x, int n)

inline double pow(int x, int n)

inline double pow(size_t x, int n)

inline double pow(double x, size_t n)

inline int pow(int x, size_t n)

inline size_t pow(size_t x, size_t n)

inline double pow(double x, double n)

template<typename Derived>
Matrix_t relative_error(const Eigen::MatrixBase<Derived> &reference, const Eigen::MatrixBase<Derived> &test, const double &delta = 1e-10, const double &epsilon = DBL_FTOL, const bool &verbose = true)

inline double relative_error(const double &reference, const double &test, const double &delta = 1e-10, const double &epsilon = DBL_FTOL, const bool &verbose = true)

Variables

constexpr double SPHERICAL_BESSEL_FUNCTION_FTOL = 1e-5

constexpr double PI = 3.14159265358979323846264338327950288

constexpr double SQRT_PI = 1.772453850905516027298167483341145182

constexpr double SQRT_TWO = 1.41421356237309504880168872420969808

constexpr double INV_SQRT_TWO = 0.707106781186547524400844362104849039

constexpr double SQRT_THREE = 1.7320508075688772935274463415058723

constexpr double DBL_FTOL = 100.0 * std::numeric_limits<double>::epsilon()

constexpr double DOVERFLOW = std::numeric_limits<double>::infinity()

template<ErrorMetric_t Metric>
struct ErrorMethod

Public Static Functions

template<class Eigen_Ref>
static bool is_error_below_bound(const Eigen_Ref &values, const Eigen_Ref &references, double error_bound)

template<> Absolute >

Public Static Functions

template<class Eigen_Ref>
static inline double compute_global_error(const Eigen_Ref &values, const Eigen_Ref &references)

static inline Vector_t compute_pointwise_error(const Vector_Ref &values, const Vector_Ref &references)

static inline Matrix_t compute_pointwise_error(const Matrix_Ref &values, const Matrix_Ref &references)

template<> AbsoluteRelative >

template<> Relative >

Public Static Functions

template<class Eigen_Ref>
static inline double compute_global_error(const Eigen_Ref &values, const Eigen_Ref &references)

static inline Vector_t compute_pointwise_error(const Vector_Ref &values, const Vector_Ref &references)

static inline Matrix_t compute_pointwise_error(const Matrix_Ref &values, const Matrix_Ref &references)

class Hyp1f1

Public Functions

inline double calc(double z, bool derivative = false)

double calc(double z, double z2, double ez2, bool derivative = false)

class Hyp1f1SphericalExpansion

Public Functions

void precompute(size_t max_radial, size_t max_angular)

inline double calc(size_t n_radial, size_t l_angular, double z)

double calc(size_t n_radial, size_t l_angular, double r_ij, double alpha, double beta)

void calc(double r_ij, double alpha, const Vector_Ref &fac_b, bool derivative = false)

void calc_recursion(double r_ij, double alpha, const Vector_Ref &fac_b)

void calc_direct(double r_ij, double alpha, const Vector_Ref &fac_b, bool derivative)

inline Matrix_Ref get_values()

inline Matrix_Ref get_derivatives()

template<InterpolationMethod_t Type>
struct InterpolationMethod

Public Functions

void initialize(const Vector_Ref &grid, const Vector_Ref &evaluated_grid)

void initialize(const Vector_Ref &grid, const Matrix_Ref &evaluated_grid)

inline double interpolate(const Vector_Ref &grid, const Vector_Ref &evaluated_grid, double x, int nearest_grid_index_to_x)

inline double interpolate(const Vector_Ref &grid, const Matrix_Ref &evaluated_grid, double x, int nearest_grid_index_to_x)

template<> CubicSplineScalarUniform >

Public Functions

inline double interpolate(const Vector_Ref &grid, const Vector_Ref &evaluated_grid, double x, int nearest_grid_index_to_x) const

inline double interpolate_derivative(const Vector_Ref &grid, const Vector_Ref &evaluated_grid, double x, int nearest_grid_index_to_x) const

template<> CubicSplineVectorUniform >

Public Functions

inline Vector_t interpolate(const Vector_Ref &grid, const Matrix_Ref &evaluated_grid, double x, int nearest_grid_index_to_x) const

inline Vector_t interpolate_derivative(const Vector_Ref &grid, const Matrix_Ref &evaluated_grid, double x, int nearest_grid_index_to_x) const

template<class InterpolationMethod, class UniformGridRational, class ErrorMethod>
class Interpolator

Public Functions

inline Interpolator(double x1, double x2, double error_bound, int max_grid_points, int initial_degree_of_fineness)

inline explicit Interpolator(Vector_t grid)

template<RefinementMethod_t RefinementMethod, class ErrorMethod_t = ErrorMethod<ErrorMetric_t::Absolute>>
class InterpolatorMatrixUniformCubicSpline : public rascal::math::Interpolator<InterpolationMethod<InterpolationMethod_t::CubicSplineVectorUniform>, UniformGridRational<RefinementMethod>, ErrorMethod_t>

Public Functions

inline InterpolatorMatrixUniformCubicSpline(std::function<Matrix_t(double)> function, double x1, double x2, double error_bound, int cols, int rows, int max_grid_points = 100000, int initial_degree_of_fineness = 5, bool clamped_boundary_conditions = false, double dfx1 = 0, double dfx2 = 0)

inline InterpolatorMatrixUniformCubicSpline(std::function<double(double)> function, double x1, double x2, double error_bound, int max_grid_points = 100000, int initial_degree_of_fineness = 5, bool clamped_boundary_conditions = false, double dfx1 = 0, double dfx2 = 0)

inline InterpolatorMatrixUniformCubicSpline(Vector_t grid, Matrix_t evaluated_grid, int cols, int rows)

inline Matrix_t interpolate(double x)

inline Matrix_t interpolate_derivative(double x)

inline Vector_t interpolate_to_vector(double x)

inline Matrix_t interpolate_to_vector(const Vector_Ref &points)

inline Vector_t interpolate_to_vector_derivative(const double x)

inline Matrix_t interpolate_to_vector_derivative(const Vector_Ref &points)

inline Matrix_t interpolate_dummy(const double x) const

inline Vector_t eval(const double x)

inline Matrix_t eval(const Vector_Ref &grid)

template<RefinementMethod_t RefinementMethod, class ErrorMethod_t = ErrorMethod<ErrorMetric_t::Absolute>>
class InterpolatorScalarUniformCubicSpline : public rascal::math::Interpolator<InterpolationMethod<InterpolationMethod_t::CubicSplineScalarUniform>, UniformGridRational<RefinementMethod>, ErrorMethod_t>

Public Functions

inline InterpolatorScalarUniformCubicSpline(std::function<double(double)> function, double x1, double x2, double error_bound, int max_grid_points = 100000, int initial_degree_of_fineness = 5, bool clamped_boundary_conditions = false, double dfx1 = 0, double dfx2 = 0)

inline InterpolatorScalarUniformCubicSpline(Vector_t grid, Vector_t evaluated_grid)

inline double interpolate(double x)

inline double interpolate_derivative(double x)

class Kvectors

Public Functions

Kvectors(double cutoff, Eigen::Matrix3d basisvectors, bool is_reciprocal_cell = false, bool need_origin = false)

inline size_t get_numvectors() const

inline Eigen::Ref<Matrix_t> get_kvectors()

inline Eigen::Ref<const Vector_t> const get_kvector_norms()

class ModifiedSphericalBessel

Public Functions

void calc(double distance, double fac_a)

void precompute(size_t l_max, const Eigen::Ref<const Eigen::VectorXd> &x_v, bool compute_gradients = false)

inline ArrayConstRef_t get_values()

inline ArrayConstRef_t get_gradients()

class SphericalHarmonics

Public Functions

inline explicit SphericalHarmonics(bool calculate_derivatives = false)

void precompute(size_t max_angular, bool calculate_derivatives = false)

void calc(const Eigen::Ref<const Eigen::Vector3d> &direction, bool calculate_derivatives, bool conjugate = false)

inline void calc(const Eigen::Ref<const Eigen::Vector3d> &direction, bool conjugate = false)

inline const Matrix_Ref get_assoc_legendre_polynom_raw()

inline const Vector_Ref get_harmonics()

inline const Matrix_Ref get_harmonics_derivatives()

template<RefinementMethod_t Method>
struct UniformGridRational

Public Functions

Vector_t compute_grid(double x1, double x2, int degree_of_fineness)

Vector_t compute_test_grid(double x1, double x2, int degree_of_fineness)

template<> Exponential >

template<> Linear >

class UniformSearchMethod

Public Functions

void initialize(const Vector_Ref &grid, size_t nb_support_points)

int search(double x, const Vector_Ref&) const

namespace details

Functions

inline double pow_u(double x, size_t n)

inline double pow_i(double x, int n)

namespace internal

class Hyp1f1Asymptotic

Public Functions

double calc(double z, double z2, bool derivative = false, int n_terms = -1)

double calc(double z, bool derivative = false, int n_terms = -1)

double hyp2f0(double z, bool derivative, int n_terms)

class Hyp1f1Series

Public Functions

double calc(double z, double z2, double ez2, bool derivative = false, int n_terms = -1)

double hyp1f1(double z, bool derivative, int n_terms)

namespace py_internal

template<typename SM, typename AdaptorTypeHolder_>
struct bind_compute_function_helper

template<typename SM, template<class> class ...Ti>
struct bind_compute_function_helper<SM, AdaptorTypeHolder<Ti...>>

template<typename StructureManagerTypeHolder_>
struct bind_compute_function_util

template<typename... T> tuple< T... > >

template<typename SM, typename AdaptorTypeHolder_>
struct bind_get_num_coefficients_function_helper

template<typename SM, template<class> class ...Ti>
struct bind_get_num_coefficients_function_helper<SM, AdaptorTypeHolder<Ti...>>

template<typename StructureManagerTypeHolder_>
struct bind_get_num_coefficients_function_util

template<typename... T> tuple< T... > >

namespace units

Variables

static const std::string undefined = {"undefined"}

const UnitStyle metal{"(g/mol)", "Å", "ps", "eV", "(Å/ps)", "(eV/Å)", "eV", "K", "bar", "P", "e", "(e*Å)", "(V/Å)", "((g/cm)^(3))"}

const UnitStyle electron{"u", "rBohr", "fs", "Ha", "(rBohr/atu)", "(Ha/rBohr)", undefined, "K", "Pa", undefined, "e", "D", "(V/cm)", undefined}

class UnitStyle

Public Functions

UnitStyle() = delete

UnitStyle(const std::string &mass, const std::string &distance, const std::string &time, const std::string &energy, const std::string &velocity, const std::string &force, const std::string &torque, const std::string &temperature, const std::string &pressure, const std::string &dynamic_viscosity, const std::string &charge, const std::string &dipole, const std::string &electric_field, const std::string &density)

UnitStyle(const UnitStyle &other) = default

UnitStyle(UnitStyle &&other) = default

virtual ~UnitStyle() = default

UnitStyle &operator=(const UnitStyle &other) = delete

UnitStyle &operator=(UnitStyle &&other) = delete

const std::string mass(int numerator = 1, int denominator = 1) const