ipyvasp 0.9.8__tar.gz → 0.9.82__tar.gz

{ipyvasp-0.9.8 → ipyvasp-0.9.82}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: ipyvasp
-Version: 0.9.8
+Version: 0.9.82
 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.8 → ipyvasp-0.9.82}/ipyvasp/_lattice.py

@@ -1572,6 +1572,7 @@ def _get_bond_length(poscar_data, bond_length=None):
 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
@@ -1590,14 +1591,14 @@ class _AtomLabel(str):
 
 def _validate_func(func):
     if not callable(func):
-        raise ValueError("`func` must be a callable function with single parameter `Atom(symbol,index,x,y,z)`.")
+        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 1 argument: `Atom(symbol,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))
+    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)}."
@@ -1611,7 +1612,7 @@ def _masked_data(poscar_data, func):
     pick = []
     for i, pos in enumerate(poscar_data.positions):
         idx = eqv_inds[i] if eqv_inds else i  # map to original index
-        if func(_Atom(poscar_data.symbols[i], idx, *pos)): # symbols based on i, not eqv_idx
+        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
 
@@ -1633,10 +1634,13 @@ def _filter_pairs(labels, pairs, dist, bond_length):
     return pairs  # None -> auto calculate bond_length, number -> use that number
 
 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()`. `p` is additional property to get array([x,y,z]) togther.
+    """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'):
@@ -1931,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 as a subclass of str 'Ga 1' with extra attributes `symbol` and `number` and a method `to_latex`, e.g. `lambda lab: lab.to_latex()`.
+        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.
@@ -2583,9 +2588,12 @@ def sort_poscar(poscar_data, new_order):
     return serializer.PoscarData(data)
 
 def remove_atoms(poscar_data, func, fillby=None):
-    """Remove atoms that satisfy `func(atom) -> bool` on their fractional coordinates like `lambda a: all(a.p < 1/2)`. `p` is additional property to get array([x,y,z]) togther.
+    """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.
@@ -2612,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(_Atom('', 0, 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.82/ipyvasp/_version.py

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

{ipyvasp-0.9.8 → ipyvasp-0.9.82}/ipyvasp/core/serializer.py

@@ -329,6 +329,10 @@ 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."
@@ -493,7 +497,8 @@ 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 `func(Atom(symbol,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:
 
@@ -504,17 +509,17 @@ class PoscarData(Dict2Data):
         """
         if not callable(func):
             raise TypeError(
-                "`func` should be a callable with one paramter `Atom(symbol,index, x,y,z)`"
+                "`func` should be a callable with one paramter `Atom(symbol,number, index, x,y,z)`"
             )
 
         if len(inspect.signature(func).parameters) != 1:
             raise ValueError(
-                "`func` should be a callable function with one paramter `Atom(symbol,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(_Atom('',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
@@ -530,7 +535,7 @@ class PoscarData(Dict2Data):
                 )
 
         sd_list = [
-            "  ".join("T" if s else "F" for s in func(_Atom(self.symbols[i],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.8 → ipyvasp-0.9.82}/ipyvasp/core/spatial_toolkit.py

@@ -315,6 +315,9 @@ def get_bz(basis, loop=True, primitive=False):
         "vertices": verts,
         "faces": idx_faces,
         "primitive": primitive,
+        "edges": np.unique(
+            np.sort([[i,j] for f in idx_faces for i,j in zip(f[:-1],f[1:])], axis=1),
+            axis=0)
     }
     from .serializer import BrZoneData  # to avoid circular import
 

{ipyvasp-0.9.8 → ipyvasp-0.9.82}/ipyvasp/lattice.py

@@ -18,11 +18,13 @@ from contextlib import suppress
 import numpy as np
 from pandas.io.clipboard import clipboard_get, clipboard_set
 import matplotlib.colors as mcolors
+from mpl_toolkits.mplot3d.art3d import Poly3DCollection
+import plotly.graph_objects as go 
 
 
 from .core import serializer
 from .core import spatial_toolkit as stk
-from .core.plot_toolkit import iplot2widget
+from .core.plot_toolkit import get_axes, iplot2widget
 from .utils import _sig_kwargs, _sub_doc
 from . import _lattice as plat
 from ._lattice import (
@@ -313,13 +315,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_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
+        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,11 +356,11 @@ 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_atoms(lambda a: a.index in pc.data.types.Ga) # FINE
+        pc.filter_atoms(lambda a: a.index in pc.data.types.Ga) # FINE, can use a.symbol == 'Ga' too, but we need to show a point below
         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
         ```
@@ -626,6 +628,57 @@ class POSCAR:
         if not hasattr(self, "_cell"):
             self._cell = self.get_cell()
         return self._cell
+    
+    def get_plane(self, hkl, d=1/2,tol=1e-2):
+        """Returns Nx3 vertices of a plane bound inside cell. .
+        hkl should be list of three miller indices. d is fractional distance in range 0,1 in direction of hkl. 
+        e.g. if there are 8 planes of atoms in a cubic cell, d = 0, 1/8,...7/8, 1 match position of those planes.
+        """
+        from sympy import Point3D, Line3D, Plane
+        V = self.data.rec_basis.dot(hkl)
+        normal = V/np.linalg.norm(V)
+        point = d*normal*np.linalg.norm(self.data.basis.dot(hkl)) # to make d 0-1
+        P = Plane(Point3D(*point),normal_vector=normal)
+
+        pts = []
+        for e in self.cell.vertices[self.cell.edges]:
+            L = Line3D(Point3D(*e[0]),Point3D(*e[1]))
+            if (isc := P.intersection(L)) and isinstance(isc[0],Point3D):
+                pts.append(isc[0])
+
+        pts = np.unique(np.array(pts,dtype=float),axis=0)
+        pts = pts[stk.order(pts,)]
+        qts = self.cell.to_fractional(pts)
+        qts = qts[(qts >= -tol).all(axis=1) & (qts <= 1 + tol).all(axis=1)]
+        pts = self.cell.to_cartesian(qts)
+        return pts
+    
+    def splot_plane(self, hkl, d=1/2,tol=1e-2,ax=None, **kwargs):
+        """Provide hkl and a 3D axes to plot plane. kwargs are passed to `mpl_toolkits.mplot3d.art3d.Poly3DCollection`
+        Note: You may get wrong plane if your basis are not aligned to axes. So you can use `transpose` or `set_zdir` methods before plottling cell.
+        """
+        P = self.get_plane(hkl,d=d,tol=tol)
+        if ax is None:
+            ax = get_axes(axes_3d=True)
+            ax.set( # it does not show otherwise
+                xlim=[P[:,0].min(),P[:,0].max()],
+                ylim=[P[:,1].min(),P[:,1].max()],
+                zlim=[P[:,2].min(),P[:,2].max()]
+            )
+        kwargs = {'alpha':0.5,'color':'#898','shade': False, **kwargs}
+        ax.add_collection(Poly3DCollection([P],**kwargs))
+        ax.autoscale_view()
+        return ax
+
+    def iplot_plane(self, hkl, d = 1/2, tol=1e-3, fig=None,**kwargs):
+        "Plot plane on a plotly Figure. kwargs are passed to `plotly.graph_objects.Mesh3d`."
+        if fig is None:
+            fig = go.Figure()
+
+        P = self.get_plane(hkl,d=d,tol=tol)
+        kwargs = {**dict(color='#8a8',opacity=0.7,alphahull=0, showlegend=True,name=str(hkl)),**kwargs}
+        fig.add_trace(go.Mesh3d({k:v for v,k in zip(P.T, 'xyz')},**kwargs))
+        return fig
 
     @_sub_doc(stk.get_bz, {"basis :.*loop :": "loop :"})
     @_sig_kwargs(stk.get_bz, ("basis",))

{ipyvasp-0.9.8 → ipyvasp-0.9.82}/ipyvasp.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: ipyvasp
-Version: 0.9.8
+Version: 0.9.82
 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.8/ipyvasp/_version.py

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