gridmlip 0.1__tar.gz

gridmlip-0.1/LICENSE

@@ -0,0 +1,20 @@
+
+Copyright (c) 2025 Artem Dembitskiy
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

gridmlip-0.1/MANIFEST.in

@@ -0,0 +1,3 @@
+include LICENSE
+include README.md
+

gridmlip-0.1/PKG-INFO

@@ -0,0 +1,94 @@
+Metadata-Version: 2.1
+Name: gridmlip
+Version: 0.1
+Summary: Grid-based method for calculating the percolation barrier of mobile species using machine learning interatomic potentials
+Home-page: https://github.com/dembart/gridmlip
+Author: Artem Dembitskiy
+Author-email: art.dembitskiy@gmail.com
+License: MIT
+Keywords: MLIP,percolation barrier
+Platform: UNKNOWN
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Description-Content-Type: text/markdown
+License-File: LICENSE
+
+## gridmlip
+<p align="left">
+<a href="https://github.com/dembart/gridmlip/blob/main/LICENSE"><img alt="License" src="https://img.shields.io/badge/license-MIT-darkred"></a>
+
+
+## Contents
+- [About](#about)
+- [Installation](#installation)
+- [How to use](#how-to-use)
+- [Notebooks](#notebooks)
+- [How to cite](#how-to-cite)
+
+
+## About
+
+**gridmlip** is a library for calculating percolation barriers of mobile species in solids using grid-based method with machine learning interatomic potentials (MLIPs).
+
+
+## Installation
+
+```
+pip install gridmlip
+```
+or
+
+```python
+git clone https://github.com/dembart/gridmlip
+cd gridmlip
+pip install .
+```
+
+## How to use
+Here we describe the pipeline in general. For a specific example, see [Notebooks](#notebooks).
+
+#### Step #1: Construct configurations for processing with your favorite MLIP
+```python
+from gridmlip import Grid
+
+atomic_types_mapper = {3:0, 31:1, 17:2}
+grig = Grid.from_file('your.cif', specie = 3, r_min = 1.8, 
+                    atomic_types_mapper=atomic_types_mapper # optional
+                  )
+cfgs = grid.construct_configurations('data.cfg')
+```
+
+#### Step #2: Evaluate the configurations with your favorite MLIP
+
+```
+mlp calculate_efs p.mtp data.cfg --output_filename=processed_data.cfg'
+```
+
+#### Step #3: Read processed configrations and calculate the percolation barriers
+
+```python
+from gridmlip import Grid
+
+grid = Grid.from_file('your.cif', specie = 3, r_min = 1.8)
+grid.read_processed_configurations('processed_data.cfg', format = 'cfg')
+grid.percolation_barriers()
+```
+
+#### Step #4: Write .grd or .cube file for visualization in VESTA 3.0
+
+```python
+g.write_grd('test.grd')
+```
+
+## Notebooks
+
+
+- [Using TensorNet model pre-trained on MatPES](notebooks/TensorNet_MatPES.ipynb) 
+
+
+### How to cite
+If you use the gridmlip library, please, consider citing this repository.
+
+
+

gridmlip-0.1/README.md

@@ -0,0 +1,76 @@
+## gridmlip
+<p align="left">
+<a href="https://github.com/dembart/gridmlip/blob/main/LICENSE"><img alt="License" src="https://img.shields.io/badge/license-MIT-darkred"></a>
+
+
+## Contents
+- [About](#about)
+- [Installation](#installation)
+- [How to use](#how-to-use)
+- [Notebooks](#notebooks)
+- [How to cite](#how-to-cite)
+
+
+## About
+
+**gridmlip** is a library for calculating percolation barriers of mobile species in solids using grid-based method with machine learning interatomic potentials (MLIPs).
+
+
+## Installation
+
+```
+pip install gridmlip
+```
+or
+
+```python
+git clone https://github.com/dembart/gridmlip
+cd gridmlip
+pip install .
+```
+
+## How to use
+Here we describe the pipeline in general. For a specific example, see [Notebooks](#notebooks).
+
+#### Step #1: Construct configurations for processing with your favorite MLIP
+```python
+from gridmlip import Grid
+
+atomic_types_mapper = {3:0, 31:1, 17:2}
+grig = Grid.from_file('your.cif', specie = 3, r_min = 1.8, 
+                    atomic_types_mapper=atomic_types_mapper # optional
+                  )
+cfgs = grid.construct_configurations('data.cfg')
+```
+
+#### Step #2: Evaluate the configurations with your favorite MLIP
+
+```
+mlp calculate_efs p.mtp data.cfg --output_filename=processed_data.cfg'
+```
+
+#### Step #3: Read processed configrations and calculate the percolation barriers
+
+```python
+from gridmlip import Grid
+
+grid = Grid.from_file('your.cif', specie = 3, r_min = 1.8)
+grid.read_processed_configurations('processed_data.cfg', format = 'cfg')
+grid.percolation_barriers()
+```
+
+#### Step #4: Write .grd or .cube file for visualization in VESTA 3.0
+
+```python
+g.write_grd('test.grd')
+```
+
+## Notebooks
+
+
+- [Using TensorNet model pre-trained on MatPES](notebooks/TensorNet_MatPES.ipynb) 
+
+
+### How to cite
+If you use the gridmlip library, please, consider citing this repository.
+

gridmlip-0.1/gridmlip/__init__.py

@@ -0,0 +1 @@
+from .core import Grid

gridmlip-0.1/gridmlip/_neighborhood.py

@@ -0,0 +1,34 @@
+import itertools 
+import numpy as np
+from scipy.spatial import cKDTree
+
+
+
+def _scale_cell(cell, r_cut):
+    volume = cell.volume
+    scale_a = 2 * np.ceil(r_cut/(volume/np.linalg.norm(np.cross(cell[2, :], cell[1, :])))) + 1
+    scale_b = 2 * np.ceil(r_cut/(volume/np.linalg.norm(np.cross(cell[0, :], cell[2, :])))) + 1
+    scale_c = 2 * np.ceil(r_cut/(volume/np.linalg.norm(np.cross(cell[0, :], cell[1, :])))) + 1
+    return scale_a, scale_b, scale_c
+
+
+
+def nn_list(atoms_pos, mesh_pos, r_cut, cell = None):
+    
+    if np.any(cell):
+        scale = _scale_cell(cell, r_cut)
+        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.1/gridmlip/_percolation_analysis.py

@@ -0,0 +1,247 @@
+import itertools
+import numpy as np
+from scipy.ndimage import measurements, generate_binary_structure
+from joblib import Parallel, delayed
+
+
+class Percolyze:
+
+    def __init__(self, data):
+        self.data = data
+        self.size = data.shape
+    
+    def _cross_boundary(self, coords, data_shape):
+        
+        """ 
+        Check if connected component crosses the boundary of unit cell
+
+        Parameters
+        ----------
+
+        coords: np.array
+            coordinates of points in connected component
+            
+        data_shape: list
+            shape of the mesh constructed over supercell
+        
+        Returns
+        ----------
+        
+        d: int
+            number of unit cells within a supercell that contains connected component
+        """
+
+        probe = coords[0, :]
+        cell_location = np.floor(probe / data_shape)
+        translations = np.array(list(itertools.product([0, 1],
+                                                       [0, 1],
+                                                       [0, 1])))
+        translations = translations - cell_location
+        test = probe + translations * data_shape
+        d = np.argwhere(abs(coords[:, None] - test).sum(axis = 2) == 0).shape[0]
+        return d
+
+
+
+    def _connected_components(self, data, tr): 
+
+        """ 
+        Find connected components
+
+        Parameters
+        ----------
+
+        data: np.array
+            BVSE distribution data
+            
+        tr: float
+            energy threshold to find components
+
+        task: str, either "bvse" or "void"
+            select type of calculation 
+         
+        Returns
+        ----------
+        
+        labels, features: np.array, number of components
+            labels are data points colored to features values
+        """
+
+        n = 2
+        lx, ly, lz = data.shape
+        superdata = np.zeros((n * lx, n * ly, n * lz))
+        for i in range(n):
+            for j in range(n):
+                for k in range(n):
+                    superdata[i*lx:(i+1)*lx, j*ly:(j+1)*ly, k*lz:(k+1)*lz] = data
+
+        region = superdata - superdata.min()
+        structure = generate_binary_structure(3,3)
+        
+        labels, features = measurements.label(region < tr, structure = structure)
+        
+        labels_with_pbc = self._apply_pbc(labels)
+        return labels_with_pbc, np.unique(labels_with_pbc)     # labels, features
+
+
+
+    def _apply_pbc(self, labels):
+        
+        """ 
+        Apply periodic boundary conditions to the NxMxL np.array of labeled points.
+
+        Parameters
+        ----------
+
+        labels: np.array of NxMxL size
+            array of labeles (connected components)
+        
+        Returns
+        ----------
+        
+        labels, features: np.array of NxMxL size and np.array of its unique labels
+            the array returned implies pbc conditions
+
+        """
+
+        faces_left = [labels[-1, :, :],
+                      labels[:, -1, :],
+                      labels[:, :, -1]
+                     ]
+        faces_right = [labels[0, :, :],
+                       labels[:, 0, :],
+                       labels[:, :, 0]
+                      ]
+        for f1, f2 in zip(faces_left, faces_right):
+            for s in np.unique(f1):
+                if s == 0:
+                    continue
+                else:
+                    connect = np.unique(f2[f1 == s])
+                    for c in connect:
+                        if c == 0:
+                            continue
+                        else:
+                            labels[labels == c] = s
+        return labels
+
+
+
+    def _percolation_dimension(self, labels, features):
+
+        """
+        Check percolation dimensionality
+
+        Parameters
+        ----------
+
+        labels: np.array
+            label from _connected_components method
+            
+        features: np.array
+            label from _connected_components method
+        
+        Returns
+        ----------
+        d: dimensionality of percolation
+            Note: can be from 2 to 8, which is the number of neighboring unit cells within 3x3x3 supercell
+        """
+
+        if len(features) < 1:
+            d = 0
+        else:
+            d = max(Parallel(n_jobs=self.n_jobs,
+                backend = self.backend)(delayed(self._percolation_dimension_parallel)(feature, labels) for feature in features))
+        return d
+    
+
+
+    def _percolation_dimension_parallel(self, feature, labels):
+
+        if feature == 0:
+            d = 0
+        else:
+            coords = np.argwhere(labels == feature)
+            d = self._cross_boundary(coords, np.array(labels.shape)/2)
+        return d
+
+
+    
+    def _percolation_energy(self, dim, encut = 10.0):
+
+        """
+        Get percolation energy fofr a given dimensionality of percolation
+
+        Parameters
+        ----------
+
+        dim: int
+            dimensionality of percolation. 2 -> 1D, 4 -> 2D, 8 - 3D percolation
+            
+        encut: float, 10.0 by default
+            stop criterion for the search of percolation energy
+        
+        Returns
+        ----------
+        barrier: float
+            percolation energy or np.inf if no percolation found
+        """
+        
+        data = self.data.reshape(self.size)
+        data = data - data.min()
+        emin = data.min()
+        emax = emin + encut
+        count = 0
+        barrier = np.inf
+        while (emax - emin) > 0.01:
+            count = count + 1
+            probe = (emin + emax) / 2
+            labels, features = self._connected_components(data, probe)
+            if len(features) > 0:
+                d = self._percolation_dimension(labels, features)
+                if d >= dim:
+                    emax = probe
+                    barrier = round(emax,4)
+                else:
+                    emin = probe
+            else:
+                emin = probe
+        return barrier
+
+
+
+    def percolation_barriers(self, encut = 10.0, n_jobs = 1, backend = 'threading'):
+
+        """
+        Find percolation energy and dimensionality of a migration network.
+
+        Parameters
+        ----------
+
+        encut: float, 5.0 by default
+            cutoff energy above which barriers supposed to be np.inf
+
+        n_jobs: int, 1 by default
+            number of jobs to run for percolation energy search
+
+        backend: str, 'threading' by default
+            see joblib's documentations for more details
+
+        Returns
+        ----------
+        
+        energies: dict
+            infromation about percolation {'E_1D': float, 'E_2D': float, 'E_3D': float}
+
+        """
+
+        self.n_jobs = n_jobs
+        self.backend = backend
+
+        energies = {}
+        for i, dim in enumerate([2, 4, 8]):
+            
+            energy = self._percolation_energy(encut = encut, dim = dim)
+            energies.update({f'E_{i+1}D': energy})
+        return energies
+    

gridmlip-0.1/gridmlip/cli.py

@@ -0,0 +1 @@
+# in progress

gridmlip-0.1/gridmlip/core.py

@@ -0,0 +1,274 @@
+import numpy as np
+from tqdm import tqdm
+from ase.io import read, write, cube
+from .utils import read_cfg, write_cfg
+from ._neighborhood import nn_list
+from ._percolation_analysis import Percolyze
+
+
+
+__version__ = "0.1"
+
+
+
+class Grid:
+
+    def __init__(self, atoms, specie = None, resolution = 0.25,
+                 r_cut = 5.0, r_min = 1.5, atomic_types_mapper = None):
+
+        """ 
+        Initialization. 
+
+        Parameters
+        ----------
+        
+        atoms: ASE's Atoms object
+            atomic structure
+
+        specie: int
+            atomic number of the mobile specie
+
+        resolution: float, 0.2 by default
+            spacing between points (in Angstroms)
+
+        r_cut: float
+            cutoff radius to find the first nearest neighbor for each grid point
+
+        r_min: float
+            blocking sphere radius
+
+        atomic_types_mapper: dict, optional
+            mapper of atomic numbers into species used by MLIP
+        """
+
+        if atomic_types_mapper:
+            numbers = self._map_atomic_types(atomic_types_mapper, atoms.numbers)
+            atoms = atoms.copy()
+            atoms.numbers = numbers
+            specie = atomic_types_mapper[specie]
+        self.atoms = atoms.copy()
+        self.specie = specie
+        self.resolution = resolution
+        self.cell = self.atoms.cell
+        self._mesh(resolution)
+        self.base = self.atoms[self.atoms.numbers != self.specie]
+        self.min_dists, _ = nn_list(self.base.positions, self.mesh_cart, r_cut, self.cell)
+        self.r_cut = r_cut
+        self.r_min = r_min
+
+
+
+    def _map_atomic_types(self, atomic_types_mapper, numbers):
+        u,inv = np.unique(numbers,return_inverse = True)
+        return np.array([atomic_types_mapper[x] for x in u])[inv].reshape(numbers.shape)
+
+
+
+    def _mesh(self, resolution):
+        
+        """ 
+        This method creates grid of equidistant points in 3D
+        with respect to the input resolution. 
+
+        Parameters
+        ----------
+        resolution: float, 0.2 by default
+            spacing between points (in Angstroms)
+
+        Returns
+        -------
+        mesh_cart: np.array
+            cartesian coordinates of meshgrid
+        
+        """
+        
+        a, b, c, _, _, _ = self.cell.cellpar()
+        nx, ny, nz = int(a // resolution), int(b // resolution), int(c // resolution)
+        x = np.linspace(0, 1, nx) 
+        y = np.linspace(0, 1, ny) 
+        z = np.linspace(0, 1, nz)
+        self.mesh_frac = np.stack(np.meshgrid(x, y, z, indexing='ij'), axis=-1).reshape(-1, 3)
+        self.mesh_cart = self.cell.cartesian_positions(self.mesh_frac)
+        self.size = (nx, ny, nz)
+        return self.mesh_cart
+
+
+
+    @classmethod
+    def from_file(cls, file, specie = None, resolution = 0.25,
+                  r_cut = 5.0, r_min = 1.5, atomic_types_mapper = None):
+        """ 
+        Create Grid object from the file.
+
+        Parameters
+        ----------
+        
+        file: string
+            .xyz of .cfg file representing atomic structure
+
+        specie: int
+            atomic number of the mobile specie
+
+        resolution: float, 0.2 by default
+            spacing between points (in Angstroms)
+
+        r_cut: float
+            cutoff radius to find the first nearest neighbor for each grid point
+
+        r_min: float
+            blocking sphere radius
+
+        atomic_types_mapper: dict, optional
+            mapper of the species into atomic numbers
+
+        Returns
+        -------
+        Grid object
+        """
+
+        if file.split('.')[-1] == 'cfg':
+            atoms = read_cfg(file)[0]
+        else:
+            atoms = read(file)
+        return cls(atoms, specie, resolution=resolution,
+                   r_cut = r_cut, r_min = r_min, atomic_types_mapper =  atomic_types_mapper)
+
+
+
+    def construct_configurations(self, filename = None):
+        """ 
+        Construct atomic configurations for further calculations.
+
+        Parameters
+        ----------
+        
+        filename: string (Optional)
+            path to save .xyz of .cfg file with atomic configurations
+        
+        Returns
+        -------
+        configurations: list of ASE's atoms object
+        """
+        
+        configurations = []
+        for p, d in tqdm(zip(self.mesh_cart, self.min_dists), desc = 'creating configurations'):
+            if d > self.r_min:
+                framework = self.base.copy()
+                framework.append(self.specie)
+                framework.positions[-1] = p
+                configurations.append(framework)
+
+        if filename:
+            if filename.split('.')[-1] == 'cfg':
+                write_cfg(filename, configurations)
+            else:
+                write(filename, configurations)
+        return configurations
+
+
+
+    def load_energies(self, energies):
+
+        """ 
+        Load energies obtained by any MLIP or structure-to-property model.
+        Should match order in created configurations.
+
+        Parameters
+        ----------
+        
+        energies: np.array
+            calculated energies for the created configurations
+        """
+
+        self.energies = energies
+        self.distribution = np.ones_like(self.min_dists) * np.inf
+        self.distribution[self.min_dists > self.r_min] = self.energies
+        self.distribution = np.nan_to_num(self.distribution, copy = False, nan = np.inf)
+        self.data = self.distribution.reshape(self.size)
+
+
+    def read_processed_configurations(self, filename, format = 'xyz'):
+
+        """ 
+        Read processed (by any MLIP) atomic configurations
+        with calculated energies.
+
+        Parameters
+        ----------
+        
+        filename: string
+            path to the processed .xyz of .cfg file
+        """
+
+        if format == 'cfg':
+            atoms_list = read_cfg(filename)
+        else:
+            atoms_list = read(filename, index = ':')
+        self.energies = np.array([atoms.get_potential_energy() for atoms in atoms_list])
+        del atoms_list
+        self.distribution = np.ones_like(self.min_dists) * np.inf
+        self.distribution[self.min_dists > self.r_min] = self.energies
+        self.distribution = np.nan_to_num(self.distribution, copy = False, nan = np.inf)
+        self.data = self.distribution.reshape(self.size)
+
+
+
+    def write_cube(self, filename):
+
+        """
+        Write .cube file containing structural and MLIP distribution data.
+
+        Parameters
+        ----------
+
+        filename: str
+            file name to write .cube
+        """
+
+        data = self.data
+        nx, ny, nz = data.shape
+        with open(f'{filename}.cube', 'w') as f:
+            cube.write_cube(f, self.atoms, data = data[:nx-1, :ny-1, :nz-1])
+    
+
+
+    def write_grd(self, filename):
+        
+        """
+        Write MLIP distribution volumetric file for VESTA 3.0.
+
+        Parameters
+        ----------
+
+        filename: str
+            file name to write .grd
+        """
+
+        
+        data = self.data
+        voxels = data.shape[0] - 1, data.shape[1] - 1, data.shape[2] - 1
+        cellpars = self.cell.cellpar()
+        with open(f'{filename}.grd' , 'w') as report:
+            comment = '# MLIP data made with gridmlip package: https://github.com/dembart/gridmlip'
+            report.write(comment + '\n')
+            report.write(''.join(str(p) + ' ' for p in cellpars).strip() + '\n')
+            report.write(''.join(str(v) + ' ' for v in voxels).strip() + '\n')
+            for i in range(voxels[0]):
+                for j in range(voxels[1]):
+                    for k in range(voxels[2]):
+                        val = data[i, j, k]
+                        report.write(str(val) + '\n')
+
+
+
+    def percolation_barriers(self, encut = 10.0):
+        """
+        Calculate percolation barriers.
+
+        Parameters
+        ----------
+        encut: float, 10.0 by default
+            upper bound for searching the barrier
+        """
+        pl = Percolyze(self.data)
+        return pl.percolation_barriers(encut = encut)

gridmlip-0.1/gridmlip/utils.py

@@ -0,0 +1,146 @@
+import numpy as np
+from tqdm import tqdm
+from ase import Atoms
+from ase.calculators.singlepoint import SinglePointCalculator
+
+
+
+def read_cfg(filename):
+
+    """
+    Read .cfg file format used in MLIP package
+
+    Parameters
+    ----------
+    file: str
+        path to the file
+    
+    Returns
+    ----------
+    list of ase's Atoms object with a SinglePointCalculator
+    """
+    with open(filename, 'r') as f:
+        text = f.readlines()
+    configurations = []
+    for i_s, i_e in tqdm(zip(np.where(np.array(text) == 'BEGIN_CFG\n')[0], np.where(np.array(text) == 'END_CFG\n')[0])):
+        subtext = text[i_s:i_e]
+        grade = None
+        results = {}
+        for i, line in enumerate(subtext):
+            if 'Size' in line:
+                size = int(subtext[i+1])
+            if 'Supercell' in line:
+                x = subtext[i+1]
+                y = subtext[i+2]
+                z = subtext[i+3]
+                cell = np.array([x.split(), y.split(), z.split()], dtype = float)
+            if 'AtomData' in line:
+                pos, forces, numbers = [], [], []
+                for n in range(size):
+                    if len(subtext[i+n+1].split()) == 8:
+                        id_, num, pos_x, pos_y, pos_z, f_x, f_y, f_z = subtext[i+n+1].split()
+                        pos.append(np.array([pos_x, pos_y, pos_z], dtype = float))
+                        forces.append(np.array([f_x, f_y, f_z], dtype = float))
+                        numbers.append(num)
+                    elif len(subtext[i+n+1].split()) == 5:
+                        id_, num, pos_x, pos_y, pos_z = subtext[i+n+1].split()
+                        pos.append(np.array([pos_x, pos_y, pos_z], dtype = float))
+                        forces.append(np.array([None, None, None], dtype = float))
+                        numbers.append(num)
+                results.update({'forces': forces})
+            if 'MV' in line: 
+                grade = float(line.split()[-1])
+            if 'Energy' in line:
+                energy =  float(subtext[i+1].split()[-1])
+                results.update({'energy': energy})
+            if 'PlusStress' in line:
+                stress = np.array(subtext[i+1].split(), dtype = float)
+                results.update({'stress': stress})
+        atoms = Atoms(cell = cell, positions = np.array(pos), numbers = numbers, pbc = True)
+        calc = SinglePointCalculator(atoms, **results)
+        atoms.calc = calc
+        configurations.append(atoms)
+    return configurations
+
+
+def write_cfg(filename, atoms_list):
+    
+    """
+    Write list of atoms into .cfg file used in MLIP package
+
+    Parameters
+    ----------
+    filename: str
+        path to the file
+    """
+
+    with open(filename, 'w') as text:
+        for atoms in tqdm(atoms_list):
+            
+            text.write('BEGIN_CFG\n')
+
+            # Size
+            text.write(' Size\n')
+            text.write('{:6}'.format(len(atoms)) + '\n')
+            
+            # Supercell
+            box = np.array(atoms.cell)
+            text.write(' Supercell\n')
+            text.write(''.join(map('{:16.6f}'.format, box[0, :])) + '\n')
+            text.write(''.join(map('{:16.6f}'.format, box[1, :])) + '\n')
+            text.write(''.join(map('{:16.6f}'.format, box[2, :])) + '\n')
+
+            
+            keys = []
+            keys.append('ids')
+            ids =  np.arange(1, len(atoms) + 1)
+            
+            keys.append('type')
+            types = atoms.numbers
+            
+            keys.append('cartes_x')
+            cartes_x = atoms.positions[:, 0]
+            keys.append('cartes_y')
+            cartes_y = atoms.positions[:, 1]
+            keys.append('cartes_z')
+            cartes_z = atoms.positions[:, 2]
+
+            # forces
+            try:
+                forces = atoms.get_forces()
+                keys.append('fx')
+                fx = forces[:, 0]
+                keys.append('fy')
+                fy = forces[:, 1]
+                keys.append('fz')
+                fz = forces[:, 2]
+                text.write(' AtomData:  id type       cartes_x      cartes_y      cartes_z           fx          fy          fz\n')
+                data = np.vstack([ids, types, cartes_x, cartes_y, cartes_z, fx, fy, fz]).T
+            except:
+                text.write(' AtomData:  id type       cartes_x      cartes_y      cartes_z\n')
+                data = np.vstack([ids, types, cartes_x, cartes_y, cartes_z]).T
+            
+            for i in range(len(data)):
+                row = list(data[i, :])
+                row[0] = int(row[0])
+                row[1] = int(row[1])
+                if len(row) == 5:
+                    text.write('{:13} {:2}     {:>13.6f}      {:>6.6f}     {:>9.6f}'.format(*row) + '\n')
+                elif len(row) == 8:
+                    text.write('{:13} {:2}     {:>13.6f}      {:>6.6f}      {:>9.6f}    {:>9.6f}   {:>9.6f}   {:>9.6f}\n'.format(*row))
+
+            try:
+                energy = atoms.get_potential_energy()
+                text.write(' Energy\n')
+                text.write('{:>13.6f}'.format(energy) + '\n')
+            except:
+                pass
+
+            try:
+                stress = atoms.get_stress()
+                text.write(' PlusStress:  xx          yy          zz          yz          xz          xy\n')
+                text.write(' {:>15.6f}        {:>4.6f}        {:>4.6f}        {:>4.6f}        {:>4.6f}        {:>4.6f}'.format(*stress) + '\n')
+            except: 
+                pass
+            text.write(' Feature   EFS_by no_info\n')
+            text.write('END_CFG\n\n')

gridmlip-0.1/gridmlip.egg-info/PKG-INFO

@@ -0,0 +1,94 @@
+Metadata-Version: 2.1
+Name: gridmlip
+Version: 0.1
+Summary: Grid-based method for calculating the percolation barrier of mobile species using machine learning interatomic potentials
+Home-page: https://github.com/dembart/gridmlip
+Author: Artem Dembitskiy
+Author-email: art.dembitskiy@gmail.com
+License: MIT
+Keywords: MLIP,percolation barrier
+Platform: UNKNOWN
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Description-Content-Type: text/markdown
+License-File: LICENSE
+
+## gridmlip
+<p align="left">
+<a href="https://github.com/dembart/gridmlip/blob/main/LICENSE"><img alt="License" src="https://img.shields.io/badge/license-MIT-darkred"></a>
+
+
+## Contents
+- [About](#about)
+- [Installation](#installation)
+- [How to use](#how-to-use)
+- [Notebooks](#notebooks)
+- [How to cite](#how-to-cite)
+
+
+## About
+
+**gridmlip** is a library for calculating percolation barriers of mobile species in solids using grid-based method with machine learning interatomic potentials (MLIPs).
+
+
+## Installation
+
+```
+pip install gridmlip
+```
+or
+
+```python
+git clone https://github.com/dembart/gridmlip
+cd gridmlip
+pip install .
+```
+
+## How to use
+Here we describe the pipeline in general. For a specific example, see [Notebooks](#notebooks).
+
+#### Step #1: Construct configurations for processing with your favorite MLIP
+```python
+from gridmlip import Grid
+
+atomic_types_mapper = {3:0, 31:1, 17:2}
+grig = Grid.from_file('your.cif', specie = 3, r_min = 1.8, 
+                    atomic_types_mapper=atomic_types_mapper # optional
+                  )
+cfgs = grid.construct_configurations('data.cfg')
+```
+
+#### Step #2: Evaluate the configurations with your favorite MLIP
+
+```
+mlp calculate_efs p.mtp data.cfg --output_filename=processed_data.cfg'
+```
+
+#### Step #3: Read processed configrations and calculate the percolation barriers
+
+```python
+from gridmlip import Grid
+
+grid = Grid.from_file('your.cif', specie = 3, r_min = 1.8)
+grid.read_processed_configurations('processed_data.cfg', format = 'cfg')
+grid.percolation_barriers()
+```
+
+#### Step #4: Write .grd or .cube file for visualization in VESTA 3.0
+
+```python
+g.write_grd('test.grd')
+```
+
+## Notebooks
+
+
+- [Using TensorNet model pre-trained on MatPES](notebooks/TensorNet_MatPES.ipynb) 
+
+
+### How to cite
+If you use the gridmlip library, please, consider citing this repository.
+
+
+

gridmlip-0.1/gridmlip.egg-info/SOURCES.txt

@@ -0,0 +1,18 @@
+LICENSE
+MANIFEST.in
+README.md
+pyproject.toml
+setup.cfg
+setup.py
+gridmlip/__init__.py
+gridmlip/_neighborhood.py
+gridmlip/_percolation_analysis.py
+gridmlip/cli.py
+gridmlip/core.py
+gridmlip/utils.py
+gridmlip.egg-info/PKG-INFO
+gridmlip.egg-info/SOURCES.txt
+gridmlip.egg-info/dependency_links.txt
+gridmlip.egg-info/requires.txt
+gridmlip.egg-info/top_level.txt
+gridmlip.egg-info/zip-safe

gridmlip-0.1/gridmlip.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

gridmlip-0.1/gridmlip.egg-info/requires.txt

@@ -0,0 +1,6 @@
+pandas
+numpy
+scipy
+ase
+tqdm
+joblib

gridmlip-0.1/gridmlip.egg-info/top_level.txt

@@ -0,0 +1 @@
+gridmlip

gridmlip-0.1/gridmlip.egg-info/zip-safe

@@ -0,0 +1 @@
+

gridmlip-0.1/pyproject.toml

@@ -0,0 +1,3 @@
+[build-system]
+requires = ["setuptools"]
+build-backend = "setuptools.build_meta"

gridmlip-0.1/setup.cfg

@@ -0,0 +1,31 @@
+[metadata]
+name = gridmlip
+version = attr: gridmlip.core.__version__
+author = Artem Dembitskiy and Alexey Maltsev
+author_email = art.dembitskiy@gmail.com
+url = https://github.com/dembart/gridmlip
+description = gridmlip
+long_description = file: README.md
+long_description_content_type = text/markdown
+keywords = MLIP, percolation barrier
+license = MIT
+classifiers = 
+	License :: OSI Approved :: BSD License
+	Programming Language :: Python :: 3
+
+[options]
+packages = find:
+zip_safe = True
+include_package_data = True
+install_requires = 
+	pandas
+	numpy
+	ase
+	tqdm
+	scipy
+	joblib
+
+[egg_info]
+tag_build = 
+tag_date = 0
+

gridmlip-0.1/setup.py

@@ -0,0 +1,35 @@
+import setuptools
+
+with open("README.md", "r") as fh:
+    long_description = fh.read()
+
+setuptools.setup(
+     name='gridmlip',  
+     version='0.1',
+     py_modules = ["gridmlip"],
+     install_requires = [
+                         "pandas",
+                         "numpy",
+                         "scipy",
+                         "ase",
+                         "tqdm",
+                         "joblib",
+                         ],
+     author="Artem Dembitskiy",
+     author_email="art.dembitskiy@gmail.com",
+     description="Grid-based method for calculating the percolation barrier of mobile species using machine learning interatomic potentials",
+     key_words = ['percolation-barrier', 'umlip', 'conductivity', 'diffusion'],
+     long_description=long_description,
+     long_description_content_type="text/markdown",
+     url="https://github.com/dembart/gridmlip",
+     package_data={"gridmlip": ["*.rst", '*.md'], 
+                    #'tests':['*'], 
+                    },
+     classifiers=[
+         "Programming Language :: Python :: 3",
+         "License :: OSI Approved :: MIT License",
+         "Operating System :: OS Independent",
+     ],
+    include_package_data=True,
+    packages=setuptools.find_packages(),
+)