gridmlip 0.2.3__tar.gz → 0.2.5__tar.gz

{gridmlip-0.2.3/gridmlip.egg-info → gridmlip-0.2.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: gridmlip
-Version: 0.2.3
+Version: 0.2.5
 Summary: gridmlip
 Home-page: https://github.com/dembart/gridmlip
 Author: Artem Dembitskiy
@@ -118,6 +118,59 @@ cfgs_vac= gen.generate_dataset(defect_type='vac')
 cfgs_frk = gen.generate_dataset(defect_type='frenkel')
 ```
 
+### Find voids
+
+```python
+from ase.io import read
+from gridmlip._void_search import clustered_local_minima
+
+atoms = read('file.cif')
+
+g = Grid(atoms, specie=3, empty_framework=False)
+g.generate_mesh()
+
+clusters = clustered_local_minima(
+    -g.min_distances_data, # can be any data computed for the generated grid
+    min_distance=2.0,
+    relative_max_value=0.5,
+    cell=g.atoms.cell,
+    coord_type='cart'
+)
+
+for (pos, energy, n) in clusters:
+    print('Site', pos)
+    print('Site energy', energy) # here, energy is the minimal distances
+    print('Number of points in a cluster', n)
+
+```
+
+### Bond valence site energy calculations
+
+```python
+from ase.io import read
+from ions.decorate import assign_oxidation_states
+from gridmlip.integrations.bvse import bvse_distribution
+
+atoms = read('LiFePO4.cif')
+atoms = assign_oxidation_states(atoms)
+
+PARAMS = {
+    "mobile_ion": "Li+",
+    "resolution": 0.2,
+    "r_min": 0.8,
+    "r_cut": 10.0,
+    "empty_framework": True,
+    "k": 100,
+    "f": 0.74,
+}
+
+grid, energies = bvse_distribution(atoms, **PARAMS)
+grid.percolation_barriers() # energies already loaded via grid.load_energies(energies)
+
+```
+
+
+
 ## Notebooks
 
 

{gridmlip-0.2.3 → gridmlip-0.2.5}/README.md

@@ -99,6 +99,59 @@ cfgs_vac= gen.generate_dataset(defect_type='vac')
 cfgs_frk = gen.generate_dataset(defect_type='frenkel')
 ```
 
+### Find voids
+
+```python
+from ase.io import read
+from gridmlip._void_search import clustered_local_minima
+
+atoms = read('file.cif')
+
+g = Grid(atoms, specie=3, empty_framework=False)
+g.generate_mesh()
+
+clusters = clustered_local_minima(
+    -g.min_distances_data, # can be any data computed for the generated grid
+    min_distance=2.0,
+    relative_max_value=0.5,
+    cell=g.atoms.cell,
+    coord_type='cart'
+)
+
+for (pos, energy, n) in clusters:
+    print('Site', pos)
+    print('Site energy', energy) # here, energy is the minimal distances
+    print('Number of points in a cluster', n)
+
+```
+
+### Bond valence site energy calculations
+
+```python
+from ase.io import read
+from ions.decorate import assign_oxidation_states
+from gridmlip.integrations.bvse import bvse_distribution
+
+atoms = read('LiFePO4.cif')
+atoms = assign_oxidation_states(atoms)
+
+PARAMS = {
+    "mobile_ion": "Li+",
+    "resolution": 0.2,
+    "r_min": 0.8,
+    "r_cut": 10.0,
+    "empty_framework": True,
+    "k": 100,
+    "f": 0.74,
+}
+
+grid, energies = bvse_distribution(atoms, **PARAMS)
+grid.percolation_barriers() # energies already loaded via grid.load_energies(energies)
+
+```
+
+
+
 ## Notebooks
 
 

gridmlip-0.2.5/gridmlip/_neighborhood.py

@@ -0,0 +1,77 @@
+import itertools
+import numpy as np
+from scipy.spatial import cKDTree
+
+
+def nn_list(atoms_pos, mesh_pos, r_cut, cell=None, k=1, return_orig_ids=False):
+    """
+    k nearest neighbors for each query point in `mesh_pos`.
+
+    Parameters
+    ----------
+    atoms_pos : (N, 3) ndarray
+        Atom positions.
+
+    mesh_pos : (M, 3) ndarray
+        Query points.
+
+    r_cut : float
+        Cutoff
+
+    cell : (3, 3) ndarray or None
+        Periodic cell. If given, periodic images within `r_cut` are added.
+
+    k : int
+        Number of neighbors.
+
+    Returns
+    -------
+    distances : (M, k) ndarray
+        Distances. `inf` where no neighbor was found within `r_cut`.
+    
+    indexes : (M, k) ndarray
+        Indices into the buffered array
+    
+    orig_indexes : (M, k) ndarray
+        Indices into the original `atoms_pos`
+    """
+    atoms_pos = np.asarray(atoms_pos)
+    n_atoms = len(atoms_pos)
+
+    if cell is not None and np.any(cell):
+        cell = np.asarray(cell)
+        volume = np.linalg.det(cell)
+        h1 = volume / np.linalg.norm(np.cross(cell[2, :], cell[1, :]))
+        h2 = volume / np.linalg.norm(np.cross(cell[0, :], cell[2, :]))
+        h3 = volume / np.linalg.norm(np.cross(cell[0, :], cell[1, :]))
+        scale = 2 * np.array(np.ceil(r_cut / np.array([h1, h2, h3])), dtype=int) + 1
+        scales = [np.arange(-(s // 2), s // 2 + 1) for s in scale]
+
+        translations = np.array(list(itertools.product(*scales)))  # (T, 3)
+        n_trans = len(translations)
+
+        # (n_atoms, n_trans, 3) -> (n_atoms * n_trans, 3), C-order:
+        # buffer row k = i * n_trans + t
+        buffer = (atoms_pos[:, None, :] + translations @ cell).reshape(-1, 3)
+
+        # Consistent with the C-order reshape above.
+        buffer_to_orig = np.repeat(np.arange(n_atoms), n_trans)
+    else:
+        buffer = atoms_pos
+        buffer_to_orig = np.arange(n_atoms)
+
+    tree = cKDTree(buffer)
+    distances, indexes = tree.query(
+        mesh_pos, workers=-1, k=k, distance_upper_bound=r_cut
+    )
+
+    if not return_orig_ids:
+        return distances, indexes
+
+    # cKDTree returns len(buffer) for "not found". Map valid entries back
+    # to original atom indices; leave "not found" as -1.
+    orig_indexes = np.full_like(indexes, -1)
+    valid = indexes < len(buffer)
+    orig_indexes[valid] = buffer_to_orig[indexes[valid]]
+
+    return distances, indexes, orig_indexes

gridmlip-0.2.5/gridmlip/_version.py

@@ -0,0 +1 @@
+__version__ = "0.2.5"

gridmlip-0.2.5/gridmlip/_void_search.py

@@ -0,0 +1,114 @@
+import numpy as np
+from scipy import ndimage
+from scipy.spatial import cKDTree
+from ase.cell import Cell
+ 
+ 
+def _find_local_minima(distribution, size=3):
+    E = distribution[:-1, :-1, :-1]
+    minf = ndimage.minimum_filter(E, size=size, mode='wrap')
+    mask = E == minf
+ 
+    padded = np.pad(mask, 1, mode='wrap')
+    labeled, _ = ndimage.label(padded, structure=np.ones((3, 3, 3), bool))
+    labeled = labeled[1:-1, 1:-1, 1:-1]
+ 
+    labels = np.unique(labeled)
+    labels = labels[labels != 0]
+    idx = np.array([np.argwhere(labeled == l)[0] for l in labels])
+    val = E[tuple(idx.T)]
+    return idx, val
+ 
+ 
+def _cluster_minima(idx, val, shape, cell, min_distance, max_value=None):
+    if max_value is not None:
+        m = val < max_value
+        idx, val = idx[m], val[m]
+ 
+    cell = np.asarray(cell, dtype=float)
+    frac = idx / np.array(shape, dtype=float)
+    cart = frac @ cell
+ 
+    shifts = np.array(np.meshgrid([-1, 0, 1], [-1, 0, 1], [-1, 0, 1], indexing='ij')).reshape(3, -1).T
+    n = len(idx)
+    rep_cart = ((shifts[:, None, :] + frac[None, :, :]).reshape(-1, 3)) @ cell
+    owner = np.tile(np.arange(n), len(shifts))
+    tree = cKDTree(rep_cart)
+ 
+    order = np.argsort(val)
+    alive = np.ones(n, bool)
+ 
+    clusters = []
+    for i in order:
+        if not alive[i]:
+            continue
+        neighbors = np.unique(owner[tree.query_ball_point(cart[i], min_distance)])
+        clusters.append((idx[i], val[i], len(neighbors)))
+        for j in neighbors:
+            alive[j] = False
+ 
+    return clusters
+
+
+def clustered_local_minima(
+        data: np.ndarray, 
+        min_distance: float, 
+        relative_max_value: float, 
+        cell: np.ndarray,
+        coord_type : str = 'cart',
+    ):
+    """
+    Find local minima for calculated data on a grid.
+
+    Parameters
+    ----------
+    data : np.ndarray of shape (N, M, K)
+        data calculated for the generated grid
+
+    min_distance : float
+        minimal distance between voids
+
+    relative_max_value : float
+        relative maximum value of the data to search for minima
+        `data.min() + relative_max_value`
+    
+    cell : np.ndarray of size (3,3)
+        lattice matrix
+
+    coord_type : str, "cart" by default
+        in what format minima coordinates will be return
+        allowed values are "cart", "frac", mesh"
+        "cart" - cartesian coordinates
+        "frac" - fractional coordinates
+        "mesh" - mesh posititions
+
+    Returns
+    -------
+    clusters : list of lists, 
+        each list contains position of a minimum,
+        energy value, and number of points clustered
+
+    """
+    assert coord_type in ("cart", "frac", "mesh")
+
+    idx, val = _find_local_minima(data)
+    core_shape = tuple(s - 1 for s in data.shape)
+    clusters = _cluster_minima(idx, val, core_shape,
+                              min_distance=min_distance,
+                              max_value=data.min() + relative_max_value,
+                              cell=cell,
+                             )
+
+    if coord_type == "mesh":
+        return clusters
+    else: 
+        cell_ase = Cell(cell)
+        clusters_new = []
+        for i, v, n in clusters:
+            scaled_site = i/(np.array(data.shape) - 1)
+            if coord_type == "cart":
+                cart_site = cell_ase.cartesian_positions(scaled_site)
+                clusters_new.append([cart_site, v, n])
+            else:
+                clusters_new.append([scaled_site, v, n])
+        return clusters_new

{gridmlip-0.2.3 → gridmlip-0.2.5}/gridmlip/core.py

@@ -132,7 +132,12 @@ class Grid:
         h3 = cell.volume/np.linalg.norm(np.cross(cell[0, :], cell[1, :]))
         scale = np.array(np.ceil(r_cut/np.array([h1, h2, h3])), dtype=int)
         return atoms.repeat(scale)
-    
+
+    @property
+    def min_distances_data(self):
+        return self.min_dists[self.mapping].reshape(self.mesh_shape)
+
+
     @classmethod
     def from_file(
         cls, 

gridmlip-0.2.5/gridmlip/integrations/bvse.py

@@ -0,0 +1,142 @@
+import re
+import numpy as np
+
+from ase.data import covalent_radii, atomic_numbers
+from ions.data import principle_number
+from ions.decorate import assign_bvse_params, assign_oxidation_states
+from ions.calculators.potential import BVFF
+
+from ..core import Grid
+from .._neighborhood import nn_list
+
+
+
+def _decompose(mobile_ion):
+
+    """ Decompose input string into chemical element and oxidation state"""
+
+    element = re.sub('\d', '', mobile_ion).replace("+","").replace("-","")
+    oxi_state = re.sub('\D', '', mobile_ion)
+
+    if '-' in mobile_ion:
+        sign = -1
+    else:
+        sign = 1
+    if len(oxi_state) > 0:
+        if sign > 0:
+            oxi_state = float(oxi_state)
+        else:
+            oxi_state = -float(oxi_state)
+    else:
+        oxi_state = sign
+
+    return element, atomic_numbers[element], int(oxi_state)
+
+
+def _get_array(atoms, name):
+    """ Helper function"""
+    arr = atoms.get_array(name)
+    arr = np.concatenate([arr, [np.nan]]) # np.nan is added to deal with kDTree upper bound
+    return arr
+
+
+
+def bvse_distribution(
+    atoms: object,
+    mobile_ion: str = None,
+    resolution: float = 0.25,            
+    r_cut: float = 10.0,
+    r_min: float = 0.8,
+    empty_framework: bool = True,
+    k: int = 100,
+    f: float = 0.74,
+    verbose: bool = False,
+):
+    
+    """
+    Compute the bond valence site energy (BVSE) distribution for a mobile ion.
+
+    Parameters
+    ----------
+    atoms : ase.Atoms
+        Structure containing the framework and mobile-ion species.
+    
+    mobile_ion : str
+        Chemical symbol of the mobile ion (e.g., "Li", "Na").
+    
+    resolution : float
+        Grid spacing in Å for the energy landscape. Default 0.25.
+    
+    r_cut : float
+        Cutoff radius in Å for bond-valence interactions. Default 10.0.
+    
+    r_min : float
+        Minimum interatomic distance in Å. Default 0.8.
+    
+    empty_framework : bool
+        If True, remove mobile ions before computing the landscape. Default True.
+    
+    k : int
+        Number of bins / grid points along each axis. Default 100.
+    
+    f : float
+        Screening factor (e.g., for the BVSE prefactor). Default 0.74.
+
+    verbose : bool
+        print out some info
+
+    Returns
+    -------
+    gridmlip.Grid, energies
+        grid with generated mesh and an array of calculated energies for irreducible mesh points
+    """
+
+    symbol, specie, q1 = _decompose(mobile_ion)
+    n1, rc1 = principle_number[specie], covalent_radii[specie]
+
+    atoms_decorated = assign_bvse_params(atoms, symbol, q1, self_interaction=True)
+    base = atoms_decorated.copy()
+    
+    if empty_framework:
+        base = atoms_decorated[atoms_decorated.numbers != specie]
+
+    grid = Grid(atoms, specie=specie, resolution=resolution,
+                r_cut=r_cut, r_min=r_min, empty_framework=empty_framework,
+                verbose=verbose)
+    grid.generate_mesh()
+    mesh_cart = grid.mesh_cart[grid.ir_grid_points]
+    mesh_cart = mesh_cart[grid.min_dists > grid.r_min]
+    
+    distances, _, ids = nn_list(base.positions, mesh_cart, r_cut=r_cut,
+                             cell=base.cell, k=k, return_orig_ids=True)
+
+    r_min = np.take(_get_array(base, 'r_min'), ids, axis = -1)
+    alpha = np.take(_get_array(base, 'alpha'), ids, axis = -1)
+    rc2 = np.take(_get_array(base, 'rc2'), ids, axis = -1)
+    d0 = np.take(_get_array(base, 'd0'), ids, axis = -1)
+    q2 = np.take(_get_array(base, 'oxi_states'), ids, axis = -1)
+    q2 = np.where(q2 * q1 > 0, q2, 0)
+    n2 = np.take(_get_array(base, 'n2'), ids, axis = -1)
+
+    morse = np.nan_to_num(BVFF.Morse(distances, r_min, d0, alpha),
+                    copy=False,
+                    nan=0.0,
+            ).sum(axis=1)
+
+    coulomb = np.nan_to_num(BVFF.Coulomb(
+                                         q1,
+                                         q2,
+                                         distances,
+                                         rc1,
+                                         rc2,
+                                         n1,
+                                         n2,
+                                         f=f),
+                    copy=False,
+                    nan=0.0,
+            ).sum(axis=1)
+    
+    energies = morse + coulomb
+    grid.load_energies(energies)
+    
+    return grid, energies

gridmlip-0.2.5/gridmlip/select.py

@@ -0,0 +1 @@
+# FPS sampling with/without relative distance

{gridmlip-0.2.3 → gridmlip-0.2.5/gridmlip.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: gridmlip
-Version: 0.2.3
+Version: 0.2.5
 Summary: gridmlip
 Home-page: https://github.com/dembart/gridmlip
 Author: Artem Dembitskiy
@@ -118,6 +118,59 @@ cfgs_vac= gen.generate_dataset(defect_type='vac')
 cfgs_frk = gen.generate_dataset(defect_type='frenkel')
 ```
 
+### Find voids
+
+```python
+from ase.io import read
+from gridmlip._void_search import clustered_local_minima
+
+atoms = read('file.cif')
+
+g = Grid(atoms, specie=3, empty_framework=False)
+g.generate_mesh()
+
+clusters = clustered_local_minima(
+    -g.min_distances_data, # can be any data computed for the generated grid
+    min_distance=2.0,
+    relative_max_value=0.5,
+    cell=g.atoms.cell,
+    coord_type='cart'
+)
+
+for (pos, energy, n) in clusters:
+    print('Site', pos)
+    print('Site energy', energy) # here, energy is the minimal distances
+    print('Number of points in a cluster', n)
+
+```
+
+### Bond valence site energy calculations
+
+```python
+from ase.io import read
+from ions.decorate import assign_oxidation_states
+from gridmlip.integrations.bvse import bvse_distribution
+
+atoms = read('LiFePO4.cif')
+atoms = assign_oxidation_states(atoms)
+
+PARAMS = {
+    "mobile_ion": "Li+",
+    "resolution": 0.2,
+    "r_min": 0.8,
+    "r_cut": 10.0,
+    "empty_framework": True,
+    "k": 100,
+    "f": 0.74,
+}
+
+grid, energies = bvse_distribution(atoms, **PARAMS)
+grid.percolation_barriers() # energies already loaded via grid.load_energies(energies)
+
+```
+
+
+
 ## Notebooks
 
 

{gridmlip-0.2.3 → gridmlip-0.2.5}/gridmlip.egg-info/SOURCES.txt

@@ -11,8 +11,10 @@ gridmlip/_mesh.py
 gridmlip/_neighborhood.py
 gridmlip/_percolation_analysis.py
 gridmlip/_version.py
+gridmlip/_void_search.py
 gridmlip/cli.py
 gridmlip/core.py
+gridmlip/select.py
 gridmlip/utils.py
 gridmlip.egg-info/PKG-INFO
 gridmlip.egg-info/SOURCES.txt
@@ -21,6 +23,7 @@ gridmlip.egg-info/requires.txt
 gridmlip.egg-info/top_level.txt
 gridmlip.egg-info/zip-safe
 gridmlip/integrations/__init__.py
+gridmlip/integrations/bvse.py
 gridmlip/integrations/gnn_lib.py
 gridmlip/integrations/mace.py
 gridmlip/integrations/sevennet.py

{gridmlip-0.2.3 → gridmlip-0.2.5}/scripts/_void_search.py

@@ -3,7 +3,7 @@ from scipy import ndimage
 from scipy.spatial import cKDTree
  
  
-def find_local_minima(distribution, size=3):
+def _find_local_minima(distribution, size=3):
     E = distribution[:-1, :-1, :-1]
     minf = ndimage.minimum_filter(E, size=size, mode='wrap')
     mask = E == minf
@@ -19,7 +19,7 @@ def find_local_minima(distribution, size=3):
     return idx, val
  
  
-def cluster_minima(idx, val, shape, cell, min_distance, max_value=None):
+def _cluster_minima(idx, val, shape, cell, min_distance, max_value=None):
     if max_value is not None:
         m = val < max_value
         idx, val = idx[m], val[m]
@@ -50,9 +50,25 @@ def cluster_minima(idx, val, shape, cell, min_distance, max_value=None):
 
 
 def clustered_local_minima(data, min_distance, relative_max_value, cell):
-    idx, val = find_local_minima(data)
+    """
+    Find local minima on a calculated grid distribution.
+
+    Parameters
+    ----------
+
+    data : np.ndarray of shape (N, M, K)
+        data calculated for the generated grid
+
+    min_distance : float
+        minimal distance between clusters
+
+    relative_max_value : float
+        relative maximum value of the data to search for minima
+        `data.min() + relative_max_value`
+    """
+    idx, val = _find_local_minima(data)
     core_shape = tuple(s - 1 for s in data.shape)
-    clusters = cluster_minima(idx, val, core_shape,
+    clusters = _cluster_minima(idx, val, core_shape,
                               min_distance=min_distance,
                               max_value=data.min() + relative_max_value,
                               cell = cell

gridmlip-0.2.3/gridmlip/_neighborhood.py

@@ -1,29 +0,0 @@
-import itertools 
-import numpy as np
-from scipy.spatial import cKDTree
-
-
-def nn_list(atoms_pos, mesh_pos, r_cut, cell=None):
-
-    if np.any(cell):
-        volume = np.linalg.det(cell)
-        h1 = volume/np.linalg.norm(np.cross(cell[2, :], cell[1, :]))
-        h2 = volume/np.linalg.norm(np.cross(cell[0, :], cell[2, :]))
-        h3 = volume/np.linalg.norm(np.cross(cell[0, :], cell[1, :]))
-        scale = 2 * np.array(np.ceil(r_cut/np.array([h1, h2, h3])), dtype=int) + 1
-        scales = []
-        for s in scale:
-            scales.append(np.arange(-(s // 2), s // 2 + 1))
-
-        translations = tuple(list(itertools.product(
-                                scales[0],
-                                scales[1],
-                                scales[2])))   
-        
-        buffer = (atoms_pos[:, None, :] + np.dot(translations, cell)).reshape(-1, 3, order='F')
-    else:
-        buffer = atoms_pos
-
-    tree = cKDTree(buffer)
-    distances, indexes = tree.query(mesh_pos, workers=-1, k=1, distance_upper_bound=r_cut)      
-    return distances, indexes

gridmlip-0.2.3/gridmlip/_version.py

@@ -1 +0,0 @@
-__version__ = "0.2.3"