ipyvasp 1.0.9__py2.py3-none-any.whl → 1.1.1__py2.py3-none-any.whl

ipyvasp/_lattice.py

@@ -231,6 +231,21 @@ def periodic_table(selection=None):
     ax.set(xlim=[-0.6,17.6],ylim=[9.6,-0.6]) # to show borders correctly
     return ax
 
+def _write_text(dest, text: str, *, encoding: str = "utf-8") -> None:
+    "Write unicode text either to a path-like destination or to a writable text stream."
+    # Treat file-like objects (streams) first (avoid Path("CON") / weird Windows devices, etc.)
+    if hasattr(dest, "write") and callable(getattr(dest, "write")):
+        dest.write(text)
+        # Best-effort flush (sys.stdout has it, StringIO doesn't need it)
+        flush = getattr(dest, "flush", None)
+        if callable(flush):
+            flush()
+        return
+
+    # Otherwise treat as a filesystem path
+    path = Path(dest)
+    with path.open("w", encoding=encoding) as f:
+        f.write(text)
 
 def write_poscar(poscar_data, outfile=None, selective_dynamics=None, overwrite=False, comment="", scale=None, system=None):
     """Writes POSCAR data to a file or returns string
@@ -285,19 +300,18 @@ def write_poscar(poscar_data, outfile=None, selective_dynamics=None, overwrite=F
         pos_list = [f"{p}   {s}" for p, s in zip(pos_list, sd)]
 
     out_str += "\n".join(pos_list)
-    if outfile:
-        path = Path(outfile)
-        if not path.is_file():
-            with path.open("w", encoding="utf-8") as f:
-                f.write(out_str)
-
-        elif overwrite and path.is_file():
-            with path.open("w", encoding="utf-8") as f:
-                f.write(out_str)
+    if outfile is not None:
+        # If it's a writable stream (sys.stdout, StringIO, open file handle), write directly.
+        if hasattr(outfile, "write") and callable(getattr(outfile, "write")):
+            _write_text(outfile, out_str)
         else:
-            raise FileExistsError(
-                f"{outfile!r} exists, can not overwrite, \nuse overwrite=True if you want to change."
-            )
+            # Otherwise treat as path-like with overwrite protection.
+            path = Path(outfile)
+            if path.exists() and not overwrite:
+                raise FileExistsError(
+                    f"{str(path)!r} exists, can not overwrite; use overwrite=True."
+                )
+            _write_text(path, out_str)
     else:
         print(out_str)
 
@@ -555,9 +569,8 @@ class InvokeMaterialsProject:
                 return f"Structure(unit={self.unit},mp_id={self.mp_id!r},symbol={self.symbol!r},crystal={self.crystal!r},cif='{self._cif[:10]}...')"
 
             def write_cif(self, outfile=None):
-                if isinstance(outfile, str):
-                    with open(outfile, "w") as f:
-                        f.write(self._cif)
+                if outfile is not None:
+                    _write_text(outfile, self._cif)
                 else:
                     print(self._cif)
 
@@ -640,12 +653,12 @@ def get_kpath(
     ibzkpt : PathLike
         Path to ibzkpt file, required for HSE calculations.
     outfile : PathLike
-        Path/to/file to write kpoints.
+        Path/to/file to write kpoints. Use sys.stdout to print to console.
     rec_basis : array_like
         Reciprocal basis 3x3 array to use for calculating uniform points.
 
 
-    If `outfile = None`, a tuple of header and kpoints array (Nx3) is returned.
+    If `outfile = None`, kpoints array (Nx3) is returned.
     """
     if isinstance(kpoints, str):
         kpoints = _str2kpoints(kpoints)
@@ -766,10 +779,9 @@ def get_kpath(
     )
     out_str = "{}\n{}".format(top_str, out_str)
     if outfile != None:
-        with open(outfile, "w", encoding="utf-8") as f:  # allow unicode
-            f.write(out_str)
+        _write_text(outfile, out_str)
     else:
-        return top_str, points  # return points as well for any processing by user.
+        return points  # return points for any processing by user.
 
 
 # Cell
@@ -799,12 +811,12 @@ def get_kmesh(
     ibzkpt : PathLike
         Path to ibzkpt file, required for HSE calculations.
     outfile : PathLike
-        Path/to/file to write kpoints.
+        Path/to/file to write kpoints. Use sys.stdout to print to console.
     endpoint : bool
         Default True, include endpoints in mesh at edges away from origin.
 
 
-    If `outfile = None`, a tuple of header and kpoints array (Nx3) is returned.
+    If `outfile = None`, kpoints array (Nx3) is returned.
 
     """
     if len(args) not in [1, 3]:
@@ -879,10 +891,9 @@ def get_kmesh(
     )
     out_str = "{}\n{}".format(top_str, out_str)
     if outfile != None:
-        with open(outfile, "w", encoding="utf-8") as f:
-            f.write(out_str)
+        _write_text(outfile, out_str)
     else:
-        return top_str, points # return points as well for any processing by user.
+        return points # return points for any processing by user.
 
 
 # Cell
@@ -898,6 +909,7 @@ def splot_bz(
     shade=True,
     alpha=0.4,
     zoffset=0,
+    center=(0,0,0),
     **kwargs,
 ):
     """Plots matplotlib's static figure of BZ/Cell. You can also plot in 2D on a 3D axes.
@@ -926,8 +938,9 @@ def splot_bz(
     alpha : float
         Opacity of filling in range [0,1]. Increase for clear viewpoint.
     zoffset : float
-        Only used if plotting in 2D over a 3D axis. Default is 0. Any plane 'xy','yz' etc.
-
+        Only used if plotting in 2D over a 3D axis. Default is 0. Any plane 'xy','yz' etc can be offset to it's own normal.
+    center : (3,) array_like
+        Translation of origin in *basis coordinates* (fractional along the plotted basis). Use this to tile BZ with help of ``BrZoneData.tile`` fuction.
 
     kwargs are passed to `plt.plot` or `Poly3DCollection` if `fill=True`.
 
@@ -951,6 +964,17 @@ def splot_bz(
         if v not in [0, 1, 2]:
             raise ValueError(f"`vectors` expects values in [0,1,2], got {vectors!r}")
 
+    if not isinstance(center, (tuple, list, np.ndarray)) or len(center) != 3:
+        raise ValueError("`center` must be a 3-sequence like (0,0,0) in basis coordinates.")
+    try:
+        center = np.array(center, dtype=float).reshape(3)
+    except Exception as e:
+        raise ValueError(f"`center` must be numeric, got {center!r}") from e
+    
+    origin = to_R3(bz_data.basis, [center])[0]  # (3,) cartesian shift
+    bz_data = bz_data.copy()
+    bz_data.vertices[:,:] += origin # apply on view, assignment is restricted
+    
     name = kwargs.pop("label", None)  # will set only on single line
     kwargs.pop("zdir", None)  # remove , no need
     is_subzone = hasattr(bz_data, "_specials")  # For subzone
@@ -1020,13 +1044,14 @@ def splot_bz(
 
         if vectors and not is_subzone:
             s_basis = to_plane(normals[plane], bz_data.basis[(vectors,)])
+            s_origin = to_plane(normals[plane], [origin]*len(vectors))
 
             for k, b in zip(vectors, s_basis):
                 x, y = b[idxs[plane]]
                 l = r" ${}_{} $".format(_label, k + 1)
                 l = l + "\n" if y < 0 else "\n" + l
                 ha = "right" if x < 0 else "left"
-                xyz = 0.8 * b + z0 if is3d else np.array([0.8 * x, 0.8 * y])
+                xyz = 0.8 * b + z0 + s_origin[0] if is3d else np.array([0.8 * x, 0.8 * y]) + s_origin[0, idxs[plane]]
                 ax.text(
                     *xyz, l, va="center", ha=ha, clip_on=True
                 )  # must clip to have limits of axes working.
@@ -1034,7 +1059,7 @@ def splot_bz(
                     *(xyz / 0.8), color="w", s=0.0005
                 )  # Must be to scale below arrow.
             if is3d:
-                XYZ, UVW = (np.ones_like(s_basis) * z0).T, s_basis.T
+                XYZ, UVW = (np.ones_like(s_basis) * z0 + s_origin).T, s_basis.T
                 quiver3d(
                     *XYZ,
                     *UVW,
@@ -1045,10 +1070,8 @@ def splot_bz(
                     mutation_scale=7,
                 )
             else:
-                s_zero = [0 for _ in s_basis]  # either 3 or 2.
                 ax.quiver(
-                    s_zero,
-                    s_zero,
+                    *s_origin[:, idxs[plane]].T,
                     *s_basis[:, idxs[plane]].T,
                     lw=0.7,
                     color=color,
@@ -1115,9 +1138,9 @@ def splot_bz(
 
         if vectors and not is_subzone:
             for k, v in enumerate(0.35 * bz_data.basis):
-                ax.text(*v, r"${}_{}$".format(_label, k + 1), va="center", ha="center")
+                ax.text(*(v + origin), r"${}_{}$".format(_label, k + 1), va="center", ha="center")
 
-            XYZ, UVW = [[0, 0, 0], [0, 0, 0], [0, 0, 0]], 0.3 * bz_data.basis.T
+            XYZ, UVW = np.array([origin] * 3).T, 0.3 * bz_data.basis.T
             quiver3d(
                 *XYZ, *UVW, C="k", L=0.7, ax=ax, arrowstyle="-|>", mutation_scale=7
             )
@@ -1136,7 +1159,7 @@ def splot_bz(
         ax.set_zlabel(label.format("z"))
 
     if vname == "b":  # These needed for splot_kpath internally
-        type(bz_data)._splot_kws = dict(plane=plane, zoffset=zoffset, ax=ax)
+        type(bz_data)._splot_kws = dict(plane=plane, zoffset=zoffset, ax=ax, shift=origin)
 
     return ax
 
@@ -1144,7 +1167,7 @@ def splot_bz(
 def splot_kpath(
     bz_data, kpoints, labels=None, fmt_label=lambda x: (x, {"color": "blue"}), **kwargs
 ):
-    """Plot k-path over existing BZ. It will take ``ax``, ``plane`` and ``zoffset`` internally from most recent call to ``splot_bz``/``bz.splot``.
+    """Plot k-path over last plotted BZ. It will take ``ax``, ``plane`` and ``zoffset`` internally from most recent call to ``splot_bz``/``bz.splot``.
 
     Parameters
     ----------
@@ -1170,9 +1193,9 @@ def splot_kpath(
     if not np.ndim(kpoints) == 2 and np.shape(kpoints)[-1] == 3:
         raise ValueError("kpoints must be 2D array of shape (N,3)")
 
-    plane, ax, zoffset = [
+    plane, ax, zoffset, shift = [
         bz_data._splot_kws.get(attr, default)  # class level attributes
-        for attr, default in zip(["plane", "ax", "zoffset"], [None, None, 0])
+        for attr, default in zip(["plane", "ax", "zoffset", "shift"], [None, None, 0,np.array([0.0, 0.0, 0.0])])
     ]
 
     ijk = [0, 1, 2]
@@ -1208,9 +1231,9 @@ def splot_kpath(
     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)
+    coords = bz_data.to_cartesian(kpoints) + shift
     if _zoffset and plane:
         normal = (
             [0, 0, 1] if plane in "xyx" else [0, 1, 0] if plane in "xzx" else [1, 0, 0]

ipyvasp/_version.py

@@ -1 +1 @@
-__version__ = "1.0.9"
+__version__ = "1.1.1"

ipyvasp/core/serializer.py

@@ -765,10 +765,51 @@ class BrZoneData(Dict2Data):
         d = self.copy().to_dict()
         d.update({"faces": faces, "vertices": vertices, "_specials": specials})
         return self.__class__(d)
+    
+    def tile(self, nxyz, filter=None):
+        """Create a tiled array of BZ centers for visualization.
+    
+        Parameters
+        ----------
+        nxyz : list or tuple of 3 ints
+            Number of tiles along each cartesian direction [nx, ny, nz].
+            Must be 3 positive integers.
+        filter : callable, optional
+            Function filter(x,y,z) that takes cartesian coordinates and returns bool.
+            
+        Returns
+        -------
+        numpy.ndarray
+            Array of shape (N, 3) containing BZ center positions in fractional coordinates.
+            
+        Examples
+        --------
+        >>> centers = bz_data.tile([3, 3, 3])
+        >>> centers = bz_data.tile([5, 5, 1], filter=lambda x,y,z: x**2 + y**2 <= 2**2)
+        """
+        if not isinstance(nxyz, (list, tuple, np.ndarray)) or len(nxyz) != 3:
+            raise ValueError("nxyz must be a list/tuple/array of 3 integers")
+        
+        for i, n in enumerate(nxyz):
+            if not isinstance(n, int) or n < 1:
+                raise ValueError(f"nxyz[{i}] must be a positive integer")
+        
+        xyz = self.to_cartesian(np.indices(np.ceil(nxyz).astype(int)).reshape((3,-1)).T) 
+        # Apply filter if provided
+        if filter is not None:
+            if not callable(filter):
+                raise TypeError("filter must be callable")
+            
+            mask = np.array([filter(x, y, z) for x, y, z in xyz])
+            xyz = xyz[mask]
+        
+        # Convert to fractional coordinates and return
+        return self.to_fractional(xyz)
 
 
 class CellData(Dict2Data):
     splot, iplot = _methods_imported()
+    tile = BrZoneData.tile
     _req_keys = ("basis", "faces", "vertices")
 
     def __init__(self, d):

{ipyvasp-1.0.9.dist-info → ipyvasp-1.1.1.dist-info}/METADATA

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

{ipyvasp-1.0.9.dist-info → ipyvasp-1.1.1.dist-info}/RECORD

@@ -1,8 +1,8 @@
 ipyvasp/__init__.py,sha256=pzTqeKuf6sN2GQmaexmMgG677ggT3sxIFyQDXq_2whU,1422
 ipyvasp/__main__.py,sha256=eJV1TZSiT8mC_VqAeksNnBI2I8mKMiPkEIlwikbtOjI,216
 ipyvasp/_enplots.py,sha256=gJ7S9WBmrxvDEbmoccDRaJG01kpx9oNlRf7mozigbgY,37872
-ipyvasp/_lattice.py,sha256=6DRC_GZlsmdxn94ktULVCZDRHZKJwm5iZ6kEqg9Psk0,106579
-ipyvasp/_version.py,sha256=5fdKqtSBBDvdwuTWCGoh62x6-wR269e8DEQnOPkCHWg,23
+ipyvasp/_lattice.py,sha256=Lh-ip60M6APUckR4I0bQ6GMN2aaY7gpkA1Z0uuFt1A4,108117
+ipyvasp/_version.py,sha256=KGJQJ23MnEKMR2yQigWuN5Fj9B4JRjsenwhmGe0cwAA,23
 ipyvasp/bsdos.py,sha256=hVHpxkdT2ImRsxwFvMSMHxRSo4LqDM90DnUhwTP8vcs,32192
 ipyvasp/cli.py,sha256=-Lf-qdTvs7WyrA4ALNLaoqxMjLsZkXdPviyQps3ezqg,6880
 ipyvasp/evals_dataframe.py,sha256=n2iSH4D4ZbrxlAV4yDTVHbcl3ycfD0zfQYmTBcxjfkE,20789
@@ -15,11 +15,11 @@ ipyvasp/widgets.py,sha256=Bpa4Y3Eopk_ZPFsVetfysClZP2q_2ONvmOwUol9vVGI,53154
 ipyvasp/core/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 ipyvasp/core/parser.py,sha256=o-uHyL_w9W0pmxoSt3JmLwwmmT3WRHlHSs_NoiHO-hs,39401
 ipyvasp/core/plot_toolkit.py,sha256=aURiPAu0tWTNctuA9LMEL3CfraRgAOyTJURzDrrO0r0,36232
-ipyvasp/core/serializer.py,sha256=aEc7K5jVga8gxm9Tt2OgBw8wnsmWZGtODBnwRJ_5sf0,38423
+ipyvasp/core/serializer.py,sha256=9xuLfl9LtUXPxTX2_zRs7nvfZsZOZN00bnxErAxDA5w,40065
 ipyvasp/core/spatial_toolkit.py,sha256=dXowREhiFzBvvr5f_bApzFhf8IzjH2E2Ix90oCBUetY,14885
-ipyvasp-1.0.9.dist-info/LICENSE,sha256=F3SO5RiAZOMfmMGf1KOuk2g_c4ObvuBJhd9iBLDgXoQ,1263
-ipyvasp-1.0.9.dist-info/METADATA,sha256=E5y8hHvowwd5WtJRtlSotIgjLCkNEXp9DL7fgrHNCM4,3218
-ipyvasp-1.0.9.dist-info/WHEEL,sha256=Kh9pAotZVRFj97E15yTA4iADqXdQfIVTHcNaZTjxeGM,110
-ipyvasp-1.0.9.dist-info/entry_points.txt,sha256=aU-gGjQG2Q8XfxDlNc_8__cwfp8WG2K5ZgFPInTm2jg,45
-ipyvasp-1.0.9.dist-info/top_level.txt,sha256=ftziWlMWu_1VpDP1sRTFrkfBnWxAi393HYDVu4wRhUk,8
-ipyvasp-1.0.9.dist-info/RECORD,,
+ipyvasp-1.1.1.dist-info/LICENSE,sha256=F3SO5RiAZOMfmMGf1KOuk2g_c4ObvuBJhd9iBLDgXoQ,1263
+ipyvasp-1.1.1.dist-info/METADATA,sha256=WVjTyiCpM9SmXs2S9u6CTtwdrfWhSYaY8-S4fY7EiSU,3218
+ipyvasp-1.1.1.dist-info/WHEEL,sha256=Kh9pAotZVRFj97E15yTA4iADqXdQfIVTHcNaZTjxeGM,110
+ipyvasp-1.1.1.dist-info/entry_points.txt,sha256=aU-gGjQG2Q8XfxDlNc_8__cwfp8WG2K5ZgFPInTm2jg,45
+ipyvasp-1.1.1.dist-info/top_level.txt,sha256=ftziWlMWu_1VpDP1sRTFrkfBnWxAi393HYDVu4wRhUk,8
+ipyvasp-1.1.1.dist-info/RECORD,,