IMLCV.implementations.CV

IMLCV.implementations.CV#

Attributes#

`identity_trans`
`zero_trans`
`zero_flow`
`Volume`
`LatticeInvariants`
`LatticeInvariants2`
`un_atomize`

Functions#

`_identity_trans`(x, nl, shmap, shmap_kwargs)
`_zero_cv_trans`(x, nl, shmap, shmap_kwargs)
`_zero_cv_flow`(x, nl, shmap, shmap_kwargs)
`_Volume`(sp, _nl, shmap, shmap_kwargs)
`_lattice_invariants`(sp, nl, shmap, shmap_kwargs)
`_lattice_invariants_2`(sp, nl, shmap, shmap_kwargs)
`_distance`(x, *_)
`distance_descriptor`()
`_position_index`(sp, _nl, shmap, shmap_kwargs, idx)
`position_index`(indices, sp)
`_dihedral`(sp, _nl, shmap, shmap_kwargs, numbers)
`dihedral`(numbers)	from https://stackoverflow.com/questions/20305272/dihedral-torsion-
`_sb_descriptor`(sp, nl, shmap, shmap_kwargs, r_cut, ...)
`sb_descriptor`(→ IMLCV.base.CV.CvTrans)
`_soap_descriptor`(sp, nl, shmap, shmap_kwargs, r_cut, ...)
`soap_descriptor`(→ IMLCV.base.CV.CvTrans)
`NoneCV`(→ IMLCV.base.CV.CollectiveVariable)
`_rotate_2d`(cv, _nl, shmap, shmap_kwargs, alpha)
`rotate_2d`(alpha)
`_project_distances`(cvs, nl, shmap, shmap_kwargs, a)	projects the distances to a reaction coordinate
`project_distances`(a)
`_scale_cv_trans`(x, nl, shmap, shmap_kwargs, upper, ...)
`scale_cv_trans`(array[, lower, upper])	axis 0 is batch axis
`_trunc_svd`(x, nl, shmap, shmap_kwargs, m_atomic, v, ...)
`trunc_svd`(→ tuple[IMLCV.base.CV.CV, IMLCV.base.CV.CvTrans])
`_inv_sigma_weighing`(x, nl, shmap, shmap_kwargs, mu, ...)
`get_inv_sigma_weighing`(cv_0, nli[, remove_mean])
`kernel_dist`(p1, p2[, xi])
`sinkhorn_divergence_2`(→ IMLCV.base.CV.CV)	caluculates the sinkhorn divergence between two CVs. If x2 is batched, the resulting divergences are stacked
`_sinkhorn_divergence_trans_2`(cv, nl, shmap, ...[, ...])
`get_sinkhorn_divergence_2`(→ IMLCV.base.CV.CvTrans)	Get a function that computes the sinkhorn divergence between two point clouds. p_i and nli are the points to match against.
`_un_atomize`(x, nl, shmap, shmap_kwargs)
`_append_trans`(x, nl, shmap, shmap_kwargs, v)
`append_trans`(v)
`_stack_reduce`(cv, nl, shmap, shmap_kwargs, op)
`stack_reduce`([op])
`_affine_trans`(x, nl, shmap, shmap_kwargs, C)
`affine_2d`(old, new)	old: set of coordinates in the original space, new: set of coordinates in the new space
`_remove_mean`(cv, nl, shmap, shmap_kwargs, mean)
`get_remove_mean_trans`(c[, range])
`_normalize`(cv, nl, shmap, shmap_kwargs, mu, std_inv)
`get_normalize_trans`(c[, remove_mu, range])
`_cv_slice`(cv, nl, shmap, shmap_kwargs, indices)
`_cv_index`(cv, nl, shmap, shmap_kwargs, indices)
`get_non_constant_trans`(c[, c_t, nl, nl_t, w, epsilon, ...])
`get_feature_cov`(→ IMLCV.base.CV.CvTrans)

Module Contents#

IMLCV.implementations.CV._identity_trans(x, nl, shmap, shmap_kwargs)#

IMLCV.implementations.CV._zero_cv_trans(x: IMLCV.base.CV.CV, nl, shmap, shmap_kwargs)#

IMLCV.implementations.CV._zero_cv_flow(x: IMLCV.base.CV.SystemParams, nl, shmap, shmap_kwargs)#

IMLCV.implementations.CV.identity_trans#

IMLCV.implementations.CV.zero_trans#

IMLCV.implementations.CV.zero_flow#

IMLCV.implementations.CV._Volume(sp: IMLCV.base.CV.SystemParams, _nl, shmap, shmap_kwargs)#

IMLCV.implementations.CV.Volume#

IMLCV.implementations.CV._lattice_invariants(sp: IMLCV.base.CV.SystemParams, nl, shmap, shmap_kwargs)#

IMLCV.implementations.CV.LatticeInvariants#

IMLCV.implementations.CV._lattice_invariants_2(sp: IMLCV.base.CV.SystemParams, nl, shmap, shmap_kwargs)#

IMLCV.implementations.CV.LatticeInvariants2#

IMLCV.implementations.CV._distance(x: IMLCV.base.CV.SystemParams, *_)#

IMLCV.implementations.CV.distance_descriptor()#

IMLCV.implementations.CV._position_index(sp: IMLCV.base.CV.SystemParams, _nl, shmap, shmap_kwargs, idx)#

IMLCV.implementations.CV.position_index(indices, sp)#

IMLCV.implementations.CV._dihedral(sp: IMLCV.base.CV.SystemParams, _nl, shmap, shmap_kwargs, numbers)#

IMLCV.implementations.CV.dihedral(numbers: tuple[int, int, int, int] | jax.Array)#

from https://stackoverflow.com/questions/20305272/dihedral-torsion- angle-from-four-points-in-cartesian- coordinates-in-python.

Parameters:: numbers – list with index of 4 atoms that form dihedral

IMLCV.implementations.CV._sb_descriptor(sp: IMLCV.base.CV.SystemParams, nl: IMLCV.base.CV.NeighbourList, shmap, shmap_kwargs, r_cut, chunk_size_atoms, chunk_size_neigbourgs, reduce, reshape, n_max, l_max, bessel_fun='jax', mul_Z=False)#

IMLCV.implementations.CV.sb_descriptor(r_cut, n_max: int, l_max: int, reduce=True, reshape=True, chunk_size_atoms=None, chunk_size_neigbourgs=None, bessel_fun='jax', mul_Z=True) → IMLCV.base.CV.CvTrans#

IMLCV.implementations.CV._soap_descriptor(sp: IMLCV.base.CV.SystemParams, nl: IMLCV.base.CV.NeighbourList, shmap, shmap_kwargs, r_cut, reduce, reshape, n_max, l_max, sigma_a, r_delta, num, basis, mul_Z=True)#

IMLCV.implementations.CV.soap_descriptor(r_cut, n_max: int, l_max: int, sigma_a: float, r_delta: float, reduce=True, reshape=True, num=50, basis='cos', mul_Z=True) → IMLCV.base.CV.CvTrans#

IMLCV.implementations.CV.NoneCV() → IMLCV.base.CV.CollectiveVariable#

IMLCV.implementations.CV._rotate_2d(cv: IMLCV.base.CV.CV, _nl: IMLCV.base.CV.NeighbourList, shmap, shmap_kwargs, alpha)#

IMLCV.implementations.CV.rotate_2d(alpha)#

IMLCV.implementations.CV._project_distances(cvs: IMLCV.base.CV.CV, nl, shmap, shmap_kwargs, a: float)#: projects the distances to a reaction coordinate

IMLCV.implementations.CV.project_distances(a)#

IMLCV.implementations.CV._scale_cv_trans(x, nl, shmap, shmap_kwargs, upper, lower, mini, diff)#

IMLCV.implementations.CV.scale_cv_trans(array: IMLCV.base.CV.CV, lower: float = 0.0, upper: float = 1.0)#: axis 0 is batch axis

IMLCV.implementations.CV._trunc_svd(x: IMLCV.base.CV.CV, nl: IMLCV.base.CV.NeighbourList | None, shmap, shmap_kwargs, m_atomic, v, cvi_shape)#

IMLCV.implementations.CV.trunc_svd(m: IMLCV.base.CV.CV, range=Ellipsis) → tuple[IMLCV.base.CV.CV, IMLCV.base.CV.CvTrans]#

IMLCV.implementations.CV._inv_sigma_weighing(x: IMLCV.base.CV.CV, nl: IMLCV.base.CV.NeighbourList, shmap, shmap_kwargs, mu: list[jax.Array] | None, sigma: list[jax.Array], norm: list[jax.Array], info: IMLCV.base.CV.NeighbourListInfo | None = None)#

IMLCV.implementations.CV.get_inv_sigma_weighing(cv_0: list[IMLCV.base.CV.CV], nli: IMLCV.base.CV.NeighbourListInfo, remove_mean=True)#

IMLCV.implementations.CV.kernel_dist(p1: jax.Array, p2: jax.Array, xi=2.0)#

IMLCV.implementations.CV.sinkhorn_divergence_2(x1: IMLCV.base.CV.CV, x2: IMLCV.base.CV.CV, nl1: IMLCV.base.CV.NeighbourListInfo, nl2: IMLCV.base.CV.NeighbourListInfo, z_scale: jax.Array, alpha=0.01, jacobian=False, lse=True, exp_factor: jax.Array | None = None, mass_weight=True, dist_fun=kernel_dist, scale_std=True, xi=2.0) → IMLCV.base.CV.CV#: caluculates the sinkhorn divergence between two CVs. If x2 is batched, the resulting divergences are stacked

IMLCV.implementations.CV._sinkhorn_divergence_trans_2(cv: IMLCV.base.CV.CV, nl: IMLCV.base.CV.NeighbourList | None, shmap, shmap_kwargs, nli: IMLCV.base.CV.NeighbourListInfo, pi: IMLCV.base.CV.CV, alpha_rematch, z_scale: jax.Array, exp_factor: jax.Array | None = None, jacobian=False)#

IMLCV.implementations.CV.get_sinkhorn_divergence_2(nli: IMLCV.base.CV.NeighbourListInfo | IMLCV.base.CV.NeighbourList, pi: IMLCV.base.CV.CV, alpha_rematch: float | None = 0.1, jacobian=True, scale_z=False) → IMLCV.base.CV.CvTrans#: Get a function that computes the sinkhorn divergence between two point clouds. p_i and nli are the points to match against.

IMLCV.implementations.CV._un_atomize(x: IMLCV.base.CV.CV, nl, shmap, shmap_kwargs)#

IMLCV.implementations.CV.un_atomize#

IMLCV.implementations.CV._append_trans(x: IMLCV.base.CV.CV, nl, shmap, shmap_kwargs, v: jax.Array)#

IMLCV.implementations.CV.append_trans(v: jax.Array)#

IMLCV.implementations.CV._stack_reduce(cv: IMLCV.base.CV.CV, nl: IMLCV.base.CV.NeighbourList | None, shmap, shmap_kwargs, op)#

IMLCV.implementations.CV.stack_reduce(op=jnp.mean)#

IMLCV.implementations.CV._affine_trans(x: IMLCV.base.CV.CV, nl, shmap, shmap_kwargs, C)#

IMLCV.implementations.CV.affine_2d(old: jax.Array, new: jax.Array)#: old: set of coordinates in the original space, new: set of coordinates in the new space

IMLCV.implementations.CV._remove_mean(cv: IMLCV.base.CV.CV, nl: IMLCV.base.CV.NeighbourList | None, shmap, shmap_kwargs, mean)#

IMLCV.implementations.CV.get_remove_mean_trans(c: IMLCV.base.CV.CV, range=Ellipsis)#

IMLCV.implementations.CV._normalize(cv: IMLCV.base.CV.CV, nl: IMLCV.base.CV.NeighbourList | None, shmap, shmap_kwargs, mu, std_inv)#

IMLCV.implementations.CV.get_normalize_trans(c: IMLCV.base.CV.CV, remove_mu=True, range=Ellipsis)#

IMLCV.implementations.CV._cv_slice(cv: IMLCV.base.CV.CV, nl: IMLCV.base.CV.NeighbourList, shmap, shmap_kwargs, indices)#

IMLCV.implementations.CV._cv_index(cv: IMLCV.base.CV.CV, nl: IMLCV.base.CV.NeighbourList, shmap, shmap_kwargs, indices)#

IMLCV.implementations.CV.get_non_constant_trans(c: list[IMLCV.base.CV.CV], c_t: list[IMLCV.base.CV.CV] | None = None, nl: IMLCV.base.CV.NeighbourList | None = None, nl_t: IMLCV.base.CV.NeighbourList | None = None, w: list[jax.Array] | None = None, epsilon=1e-14, max_functions=None, tr: IMLCV.base.CV.CvTrans | None = None)#

IMLCV.implementations.CV.get_feature_cov(c_0: list[IMLCV.base.CV.CV], c_tau: list[IMLCV.base.CV.CV], nl: list[IMLCV.base.CV.NeighbourList] | IMLCV.base.CV.NeighbourList | None = None, nl_tau: list[IMLCV.base.CV.NeighbourList] | IMLCV.base.CV.NeighbourList | None = None, w: list[jax.Array] | None = None, trans: IMLCV.base.CV.CvTrans | None = None, epsilon=0.1, smallest_correlation=1e-12, max_functions=None) → IMLCV.base.CV.CvTrans#