ipyvasp 0.9.7__tar.gz → 0.9.81__tar.gz

{ipyvasp-0.9.7 → ipyvasp-0.9.81}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: ipyvasp
-Version: 0.9.7
+Version: 0.9.81
 Summary: A processing tool for VASP DFT input/output processing in Jupyter Notebook.
 Home-page: https://github.com/massgh/ipyvasp
 Author: Abdul Saboor

{ipyvasp-0.9.7 → ipyvasp-0.9.81}/ipyvasp/_lattice.py

@@ -6,6 +6,7 @@ import requests as req
 import inspect
 from itertools import combinations, product
 from functools import lru_cache
+from typing import NamedTuple
 
 from scipy.spatial import ConvexHull, KDTree
 import plotly.graph_objects as go
@@ -238,7 +239,7 @@ def write_poscar(poscar_data, outfile=None, selective_dynamics=None, overwrite=F
     ----------
     outfile : PathLike
     selective_dynamics : callable
-        If given, should be a function like `f(index,x,y,z) -> (bool, bool, bool)`
+        If given, should be a function like `f(a) -> (a.p < 1/4)` or `f(a) -> (a.x < 1/4, a.y < 1/4, a.z < 1/4)` 
         which turns on/off selective dynamics for each atom based in each dimension.
         See `ipyvasp.POSCAR.data.get_selective_dynamics` for more info.
     overwrite: bool
@@ -1192,8 +1193,11 @@ def splot_kpath(
         labels = [
             "[{0:5.2f}, {1:5.2f}, {2:5.2f}]".format(x, y, z) for x, y, z in kpoints
         ]
+    
+    if fmt_label is None:
+        fmt_label = lambda x: (x, {"color": "blue"})
 
-    _validate_label_func(fmt_label, labels[0])
+    _validate_label_func(fmt_label,labels[0])
 
     coords = bz_data.to_cartesian(kpoints)
     if _zoffset and plane:
@@ -1565,25 +1569,50 @@ def _get_bond_length(poscar_data, bond_length=None):
         )  # Add 5% margin over mean distance, this covers same species too, and in multiple species, this will stop bonding between same species.
 
 
-def _masked_data(poscar_data, func):
-    "Returns indices of sites which satisfy the func."
-    if not callable(func):
-        raise TypeError("`func` should be a callable function.")
+class _Atom(NamedTuple):
+    "Object passed to POSCAR operations `func` where atomic sites are modified. Additinal property p -> array([x,y,z])."
+    symbol : str
+    number : int
+    index : int
+    x : float
+    y : float
+    z : float
 
-    if len(inspect.signature(func).parameters) != 4:
+    @property
+    def p(self): return np.array([self.x,self.y,self.z]) # for robust operations
+
+class _AtomLabel(str):
+    "Object passed to `fmt_label` in plotting. `number` and `symbol` are additional attributes and `to_latex` is a method."
+    @property
+    def number(self): return int(self.split()[1])
+    @property
+    def symbol(self): return self.split()[0]
+    def to_latex(self): return "{}$_{{{}}}$".format(*self.split())
+
+def _validate_func(func):
+    if not callable(func):
+        raise ValueError("`func` must be a callable function with single parameter `Atom(symbol,number, index,x,y,z)`.")
+    
+    if len(inspect.signature(func).parameters) != 1:
         raise ValueError(
-            "`func` takes exactly 4 arguments: (index,x,y,z) in fractional coordinates"
+            "`func` takes exactly 1 argument: `Atom(symbol, number, index,x,y,z)` in fractional coordinates"
+        )
+    
+    ret = func(_Atom('',0,0,0,0,0))
+    if not isinstance(ret, (bool, np.bool_)):
+        raise ValueError(
+            f"`func` must be a function that returns a bool, got {type(ret)}."
         )
 
-    if not isinstance(func(0, 0, 0, 0), bool):
-        raise TypeError("`func` should return a boolean value.")
-
+def _masked_data(poscar_data, func):
+    "Returns indices of sites which satisfy the func."
+    _validate_func(func)
     eqv_inds  = tuple(getattr(poscar_data.metadata, "eqv_indices",[]))
 
     pick = []
     for i, pos in enumerate(poscar_data.positions):
         idx = eqv_inds[i] if eqv_inds else i  # map to original index
-        if func(idx, *pos):
+        if func(_Atom(*poscar_data._sn[i], idx, *pos)): # labels based on i, not eqv_idx
             pick.append(i)
     return pick  # could be duplicate indices
 
@@ -1604,11 +1633,14 @@ def _filter_pairs(labels, pairs, dist, bond_length):
     # Return all pairs otherwise
     return pairs  # None -> auto calculate bond_length, number -> use that number
 
-def filter_sites(poscar_data, func, tol = 0.01):
-    """Filter sites based on a function that acts on index and fractional positions such as `lambda i,x,y,z: condition`. 
+def filter_atoms(poscar_data, func, tol = 0.01):
+    """Filter atomic sites based on a function that acts on an atom such as `lambda a: (a.p < 1/2).all()`. 
+    `atom` passed to function is a namedtuple like `Atom(symbol,number,index,x,y,z)` which has extra attribute `p = array([x,y,z])`.
     This may include equivalent sites, so it should be used for plotting purpose only, e.g. showing atoms on a plane.
     An attribute `source_indices` is added to metadata which is useful to pick other things such as `OUTCAR.ion_pot[POSCAR.filter(...).data.metadata.source_indices]`. 
 
+    >>> filter_atoms(..., lambda a: a.symbol=='Ga' or a.number in range(2)) # picks all Ga atoms and first two atoms of every other types.
+
     Note: If you are filtering a plane with more than one non-zero hkl like 110, you may first need to translate or set boundary on POSCAR to bring desired plane in full view to include all atoms.
     """
     if hasattr(poscar_data.metadata, 'source_indices'):
@@ -1804,13 +1836,13 @@ def iplot_lattice(
     return fig
 
 
-def _validate_label_func(fmt_label, parameter):
+def _validate_label_func(fmt_label,label):
     if not callable(fmt_label):
         raise ValueError("fmt_label must be a callable function.")
     if len(inspect.signature(fmt_label).parameters.values()) != 1:
-        raise ValueError("fmt_label must have only one argument.")
+        raise ValueError("fmt_label must have only one argument that accepts a str like 'Ga 1'.")
 
-    test_out = fmt_label(parameter)
+    test_out = fmt_label(_AtomLabel(label))
     if isinstance(test_out, (list, tuple)):
         if len(test_out) != 2:
             raise ValueError(
@@ -1903,7 +1935,8 @@ def splot_lattice(
     bond_kws : dict
         Keyword arguments to pass to `LineCollection`/`Line3DCollection` for plotting bonds.
     fmt_label : callable
-        If given, each site label is passed to it like fmt_label('Ga 1').
+        If given, each site label is passed to it as a subclass of str 'Ga 1' with extra attributes `symbol` and `number` and a method `to_latex`.
+        You can show specific labels based on condition, e.g. `lambda lab: lab.to_latex() if lab.number in [1,5] else ''` will show 1st and 5th atom of each types.
         It must return a string or a list/tuple of length 2 with first item as label and second item as dictionary of keywords to pass to `plt.text`.
     plot_cell : bool
         Default is True, plot unit cell with default settings.
@@ -1935,7 +1968,7 @@ def splot_lattice(
     pairs = _filter_pairs(labels, pairs, dist, bond_length)
 
     if fmt_label is not None:
-        _validate_label_func(fmt_label, labels[0])
+        _validate_label_func(fmt_label,labels[0])
 
     if plot_cell:
         bz_data = serializer.CellData(
@@ -2002,7 +2035,7 @@ def splot_lattice(
         )
         if fmt_label:
             for i, coord in enumerate(coords):
-                lab, textkws = fmt_label(labels[i]), {}
+                lab, textkws = fmt_label(_AtomLabel(labels[i])), {}
                 if isinstance(lab, (list, tuple)):
                     lab, textkws = lab
                 ax.text(*coord, lab, **textkws)
@@ -2027,7 +2060,7 @@ def splot_lattice(
         if fmt_label:
             labels = [labels[i] for i in zorder]  # Reorder labels
             for i, coord in enumerate(coords[zorder]):
-                lab, textkws = fmt_label(labels[i]), {}
+                lab, textkws = fmt_label(_AtomLabel(labels[i])), {}
                 if isinstance(lab, (list, tuple)):
                     lab, textkws = lab
                 ax.text(*coord[[ix, iy]], lab, **textkws)
@@ -2512,24 +2545,8 @@ def add_atoms(poscar_data, name, positions):
     return serializer.PoscarData(data)  # Return new POSCAR
 
 
-def _validate_func(func, nargs, return_type):
-    if not callable(func):
-        raise ValueError("`func` must be a callable function.")
-
-    if len(inspect.signature(func).parameters) != nargs:
-        raise ValueError(
-            f"`func` must be a function with {nargs} arguments, got {len(inspect.signature(func).parameters)}."
-        )
-    ret = func(*range(nargs))
-    if not isinstance(ret, return_type):
-        raise ValueError(
-            f"`func` must be a function that returns {return_type}, got {type(ret)}."
-        )
-
-
 def replace_atoms(poscar_data, func, name):
-    """Replace atoms satisfying a `func(i,x,y,z) -> bool` with a new `name`"""
-    _validate_func(func, 4, bool)
+    """Replace atoms satisfying a `func(atom) -> bool` with a new `name`. Like `lambda a: a.symbol == 'Ga'`"""
     data = poscar_data.to_dict()  # Copy data to avoid modifying original
     mask = _masked_data(poscar_data, func)
     new_types = {**{k: [] for k in poscar_data.types.keys()}, name: []}
@@ -2570,19 +2587,21 @@ def sort_poscar(poscar_data, new_order):
 
     return serializer.PoscarData(data)
 
-
 def remove_atoms(poscar_data, func, fillby=None):
-    """Remove atoms that satisfy `func(x,y,z) -> bool` on their fractional coordinates x,y,z.
+    """Remove atoms that satisfy `func(atom) -> bool` on their fractional coordinates like `lambda a: all(a.p < 1/2)`.
+    `atom` passed to function is a namedtuple like `Atom(symbol,number,index,x,y,z)` which has extra attribute `p = array([x,y,z])`.
     If `fillby` is given, it will fill the removed atoms with atoms from fillby POSCAR.
 
+    >>> remove_atoms(..., lambda a: sum((a.p - 0.5)**2) <= 0.25**2) # remove atoms in center of cell inside radius of 0.25
+
     .. note::
         The coordinates of fillby POSCAR are transformed to basis of given POSCAR, before filling.
         So a good filling is only guaranteed if both POSCARs have smaller lattice mismatch.
     """
-    _validate_func(func, 3, bool)
+    _validate_func(func) # need to validate for fillbay
     data = poscar_data.to_dict()  # Copy data to avoid modifying original
     positions = data["positions"]
-    mask = _masked_data(poscar_data, lambda i, x, y, z: not func(x, y, z))
+    mask = _masked_data(poscar_data, lambda s: not func(s))
 
     new_types = {k: [] for k in poscar_data.types.keys()}
     for k, vs in data["types"].items():
@@ -2601,7 +2620,7 @@ def remove_atoms(poscar_data, func, fillby=None):
 
         def keep_pos(i, x, y, z):  # keep positions in basis of given data
             u, v, w = to_basis(poscar_data.basis, to_R3(fillby.basis, [[x, y, z]]))[0]
-            return bool(func(u, v, w))
+            return bool(func(_Atom('', 0, 0, u, v, w)))
 
         mask = _masked_data(fillby, keep_pos)
         N_prev = len(data["positions"])  # before filling

ipyvasp-0.9.81/ipyvasp/_version.py

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

{ipyvasp-0.9.7 → ipyvasp-0.9.81}/ipyvasp/core/parser.py

@@ -204,7 +204,10 @@ class Vasprun(DataSource):
             else False
         )
         info_dict["EFERMI"] = float(
-            ET.fromstring(next(self.read("<i.*efermi", "</i>"))).text
+            ET.fromstring(next(chain(
+                self.read("<i.*efermi", "</i>"), # not always there but this is correct one
+                self.read("<i.*EFERMI", "</i>") # zero, always there in start
+            ))).text 
         )
         info_dict["NEDOS"] = int(
             ET.fromstring(next(self.read("<i.*NEDOS", "</i>"))).text

{ipyvasp-0.9.7 → ipyvasp-0.9.81}/ipyvasp/core/serializer.py

@@ -329,6 +329,15 @@ class PoscarData(Dict2Data):
         "Returns the symbols of the atoms in the poscar data without numbers"
         return np.array([lab.split()[0] for lab in self.labels])
     
+    @property
+    def _sn(self): # symbol and number 
+        return np.array([[f(v) for f,v in zip((str,int),lab.split())] for lab in self.labels],dtype=object)
+    
+    @property
+    def sites(self):
+        "Returns data with types mapped to their positions."
+        return Dict2Data({k: self.positions[v] for k,v in self.types.items()})
+
     @property
     def G(self):
         """Return metric tensor to be used with fractional coordinates.
@@ -488,26 +497,29 @@ class PoscarData(Dict2Data):
         """
         Returns a dictionary of {'Ga 1': 'T T T', 'As 1': 'T F F',...} for each atom in the poscar data.
 
-        `func` should be a callable like `f(index,x,y,z) -> (bool, bool, bool)` which turns on/off selective dynamics for each atom based in each dimension.
+        `func` should be a callable like `func(atom) -> (bool, bool, bool)` which turns on/off selective dynamics for each atom based in each dimension.
+        `atom` passed to function is a namedtuple like `Atom(symbol,number,index,x,y,z)` which has extra attribute `p = array([x,y,z])`.
 
         You can visualize selective dynamics sites by their labels as follows:
 
 
         >>> poscar = POSCAR.from_file('POSCAR')
-        >>> sd = poscar.data.get_selective_dynamics(lambda i,x,y,z: (True, False, True) if i % 2 == 0 else (False, True, False)) # Just an example
+        >>> sd = poscar.data.get_selective_dynamics(lambda a: (True, False, True) if a.index % 2 == 0 else (False, True, False)) # Just an example
         >>> poscar.splot_lattice(..., fmt_label = lambda lab: sd[lab]) # This will label sites as T T T, F F F, ... and so so on
         """
         if not callable(func):
             raise TypeError(
-                "`func` should be a callable function(index, [point in fractional coordinates])!"
+                "`func` should be a callable with one paramter `Atom(symbol,number, index, x,y,z)`"
             )
 
-        if len(inspect.signature(func).parameters) != 4:
+        if len(inspect.signature(func).parameters) != 1:
             raise ValueError(
-                "`func` should be a callable function with four paramters (index, x,y,z) in fractional coordinates."
+                "`func` should be a callable function with one paramter `Atom(symbol,number, index, x,y,z)` in fractional coordinates."
             )
+        
+        from .._lattice import _Atom # avoids circular import
 
-        test_output = func(0, 0, 0, 0)
+        test_output = func(_Atom('',0, 0, 0, 0, 0))
         if (
             not isinstance(test_output, (list, tuple, np.ndarray))
             or len(test_output) != 3
@@ -517,13 +529,13 @@ class PoscarData(Dict2Data):
             )
 
         for out in test_output:
-            if not isinstance(out, bool):
+            if not isinstance(out, (bool,np.bool_)):
                 raise ValueError(
                     "`func` should return boolean values in list/tuple/array like (True, False, True)"
                 )
 
         sd_list = [
-            "  ".join("T" if s else "F" for s in func(i, *p))
+            "  ".join("T" if s else "F" for s in func(_Atom(*self._sn[i],i, *p)))
             for i, p in enumerate(self.positions)
         ]
         labels = np.array(

{ipyvasp-0.9.7 → ipyvasp-0.9.81}/ipyvasp/lattice.py

@@ -313,13 +313,13 @@ class POSCAR:
 
         Prefrence order: data > content > path
 
-        Note: During chained operations where functions are acting on index of sites, use `self.last` instead of `self` to point to latest POSCAR in chain.
+        Note: POSCAR operations that need a `func` accept basis, atom tuple, label etc. Read their documentation.
         
         ```python
         pc = POSCAR()
-        pc.filter_sites(lambda i,x,y,z: i in pc.data.types.Ga) # FINE
-        pc.set_boundary([-2,2]).filter_sites(lambda i,x,y,z: i in pc.data.types.Ga) # INCORRECT sites may be picked
-        pc.set_boundary([-2,2]).filter_sites(lambda i,x,y,z: i in pc.last.data.types.Ga) # PERFECT, pc.last is output of set_boundary
+        pc.filter_atoms(lambda a: a.symbol == 'Ga') # a is namedtuple `Atom(symbol,number,index,x,y,z)` which has extra attribute `p = array([x,y,z])`.
+        pc.transform(lambda a,b,c: (a+b,a-b,c)) # basis or transform matrix
+        pc.splot_lattice(lambda lab: lab.to_latex()) # lab is str subclass like `AtomLabel('Ga 1')` with extra attributes `symbol,number, to_latex()` that can be used to show specific sites labels only.
         ```
 
         Tip: You can use `self.auto_renderer.on()` to keep doing opertions and visualize while last line of any cell is a POSCAR object.
@@ -354,13 +354,13 @@ class POSCAR:
     
     @property
     def last(self):
-        """Points to last created POSCAR instance during chained operations!
+        """Points to last created POSCAR instance during chained operations! You don't need to store results
         
         ```python
         pc = POSCAR()
-        pc.filter_sites(lambda i,x,y,z: i in pc.data.types.Ga) # FINE
-        pc.set_boundary([-2,2]).filter_sites(lambda i,x,y,z: i in pc.data.types.Ga) # INCORRECT sites may be picked
-        pc.set_boundary([-2,2]).filter_sites(lambda i,x,y,z: i in pc.last.data.types.Ga) # PERFECT, pc.last is output set_boundary
+        pc.filter_atoms(lambda a: a.index in pc.data.types.Ga) # FINE
+        pc.set_boundary([-2,2]).filter_atoms(lambda a: a.index in pc.data.types.Ga) # INCORRECT sites picked
+        pc.set_boundary([-2,2]).filter_atoms(lambda a: a.index in pc.last.data.types.Ga) # PERFECT, pc.last is output of set_boundary
         ```
         """
         return self._last
@@ -699,10 +699,10 @@ class POSCAR:
     def set_boundary(self, a = [0,1], b=[0,1],c=[0,1]):
         return self.__class__(data = plat.set_boundary(self.data, a=a,b=b,c=c))
     
-    @_sub_doc(plat.filter_sites)
-    @_sig_kwargs(plat.filter_sites,("poscar_data",))
-    def filter_sites(self, func, tol=0.01):
-        return self.__class__(data = plat.filter_sites(self.data, func,tol=tol))
+    @_sub_doc(plat.filter_atoms)
+    @_sig_kwargs(plat.filter_atoms,("poscar_data",))
+    def filter_atoms(self, func, tol=0.01):
+        return self.__class__(data = plat.filter_atoms(self.data, func,tol=tol))
 
     @_sub_doc(plat.rotate_poscar)
     def rotate(self, angle_deg, axis_vec):

{ipyvasp-0.9.7 → ipyvasp-0.9.81}/ipyvasp/widgets.py

@@ -181,7 +181,7 @@ class Files:
         return self.__class__(files, exclude=exclude,dirs_only=dirs_only,files_only=files_only)
 
     def summarize(self, func, **kwargs):
-        "Apply a func(apth) -> dict and create a dataframe."
+        "Apply a func(path) -> dict and create a dataframe."
         return summarize(self._files,func, **kwargs)
     
     def load_results(self):

{ipyvasp-0.9.7 → ipyvasp-0.9.81}/ipyvasp.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: ipyvasp
-Version: 0.9.7
+Version: 0.9.81
 Summary: A processing tool for VASP DFT input/output processing in Jupyter Notebook.
 Home-page: https://github.com/massgh/ipyvasp
 Author: Abdul Saboor

ipyvasp-0.9.7/ipyvasp/_version.py

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