Merge branch 'develop' of github.com:abinit/abipy into factories

pull trunk develop

Author: VicTrqt

README.rst

@@ -74,12 +74,8 @@ The installation process is greatly simplified if you install the required
 python packages through `Anaconda <https://continuum.io/downloads>`_ (or conda).
 See `Installing conda`_ to install conda itself.
 We routinely use conda_ to test new developments with multiple Python versions and multiple virtual environments.
-The anaconda distribution already provides the most critical dependencies (matplotlib_, scipy_, numpy_, netcdf4-python_)
-in the form of pre-compiled packages that can be easily installed with e.g.::
 
-    conda install numpy scipy netcdf4
-
-Create a new conda_ environment (let's call it ``abienv``) with::
+Create a new conda_ environment based on python 3.11 (let's call it ``abienv``) with::
 
     conda create --name abienv python=3.11
 
@@ -89,15 +85,11 @@ and activate it with::
 
 You should see the name of the conda environment in the shell prompt.
 
-Now add ``conda-forge`` to your conda channels with::
-
-    conda config --add channels conda-forge
-
-This is the channel from which we will download pymatgen, abipy and abinit.
-
 Finally, install AbiPy with::
 
-    conda install abipy
+    conda install abipy -c conda-forge
+
+Please note that, at present, conda-forge does not provide executables 
 
 Additional information on the steps required to install AbiPy with anaconda are available
 in the `anaconda howto <http://abinit.github.io/abipy/installation#anaconda-howto>`_.
@@ -199,7 +191,6 @@ Otherwise, follow the usual abinit installation instructions, and make sure abin
 
     abinit --version
 
-
 Configuration files for Abipy
 =============================
 
@@ -379,6 +370,7 @@ The following scripts can be invoked directly from the terminal:
 * ``abirun.py``     Execute AbiPy flow from terminal.
 * ``abidoc.py``     Document Abinit input variables and Abipy configuration files.
 * ``abinp.py``      Build input files (simplified interface for the AbiPy factory functions).
+* ``abipsp.py``     Download pseudopotential tables from the PseudoDojo.
 
 Use ``SCRIPT --help`` to get the list of supported commands and
 ``SCRIPT COMMAND --help`` to get the documentation for ``COMMAND``.

abipy/abilab.py

@@ -28,7 +28,6 @@
 from abipy.flowtk import Pseudo, PseudoTable, Mrgscr, Mrgddb, Flow, Work, TaskManager, AbinitBuild, flow_main
 from abipy.core.release import __version__, min_abinit_version
 from abipy.core.globals import enable_notebook, in_notebook, disable_notebook
-#from abipy.core import restapi
 from abipy.core.structure import (Lattice, Structure, StructureModifier, dataframes_from_structures,
   mp_match_structure, mp_search, cod_search, display_structure)
 from abipy.core.mixins import TextFile, JsonFile, CubeFile
@@ -67,6 +66,7 @@
 from abipy.eph.a2f import A2fFile, A2fRobot
 from abipy.eph.sigeph import SigEPhFile, SigEPhRobot
 from abipy.eph.cumulant import CumulantEPhFile
+from abipy.eph.varpeq import VarpeqFile
 from abipy.eph.eph_plotter import EphPlotter
 from abipy.eph.v1sym import V1symFile
 from abipy.eph.gkq import GkqFile, GkqRobot
@@ -181,6 +181,7 @@ def _straceback():
     ("V1QAVG.nc", V1qAvgFile),
     ("ABIWAN.nc", AbiwanFile),
     ("EPH_CUMULANT.nc", CumulantEPhFile),
+    ("VARPEQ.nc", VarpeqFile),
 ])
 
 

abipy/abio/robots.py

@@ -21,6 +21,7 @@
 from monty.json import MontyEncoder
 from abipy.tools.serialization import pmg_serialize
 from abipy.tools.iotools import make_executable
+from abipy.core.structure import Structure
 from abipy.core.mixins import NotebookWriter
 from abipy.tools.numtools import sort_and_groupby
 from abipy.tools import duck
@@ -333,6 +334,30 @@ def from_flow(cls, flow, outdirs="all", nids=None, ext=None, task_class=None) ->
 
         return robot
 
+
+    def __len__(self):
+        return len(self._abifiles)
+
+    #def __iter__(self):
+    #    return iter(self._abifiles)
+
+    def __getitem__(self, key):
+        # self[key]
+        return self._abifiles.__getitem__(key)
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        """Activated at the end of the with statement."""
+        self.close()
+
+    def keys(self):
+        return self._abifiles.keys()
+
+    def items(self):
+        return self._abifiles.items()
+
     def add_extfile_of_node(self, node, nids=None, task_class=None) -> None:
         """
         Add the file produced by this node to the robot.
@@ -547,32 +572,6 @@ def exceptions(self) -> list:
         """List of exceptions."""
         return self._exceptions
 
-    def __len__(self):
-        return len(self._abifiles)
-
-    #def __iter__(self):
-    #    return iter(self._abifiles)
-
-    #def __contains__(self, item):
-    #    return item in self._abifiles
-
-    def __getitem__(self, key):
-        # self[key]
-        return self._abifiles.__getitem__(key)
-
-    def __enter__(self):
-        return self
-
-    def __exit__(self, exc_type, exc_val, exc_tb):
-        """Activated at the end of the with statement."""
-        self.close()
-
-    def keys(self):
-        return self._abifiles.keys()
-
-    def items(self):
-        return self._abifiles.items()
-
     @property
     def labels(self) -> list[str]:
         """
@@ -614,6 +613,24 @@ def _repr_html_(self) -> str:
         """Integration with jupyter_ notebooks."""
         return '<ol start="0">\n{}\n</ol>'.format("\n".join("<li>%s</li>" % label for label, abifile in self.items()))
 
+    def getattr_alleq(self, aname : str):
+        """
+        Return the value of attribute aname.
+        Raises ValueError if value is not the same across all the files in the robot.
+        """
+        val1 = getattr(self.abifiles[0], aname)
+
+        for abifile in self.abifiles[1:]:
+            val2 = getattr(abifile, aname)
+            if isinstance(val1, (str, int, float)):
+                eq = val1 == val2
+            elif isinstance(val1, np.ndarray):
+                eq = np.allclose(val1, val2)
+            if not eq:
+                raise ValueError(f"Different values of {aname=}, {val1=}, {val2=}")
+
+        return val1
+
     @property
     def abifiles(self) -> list:
         """List of netcdf files."""
@@ -639,22 +656,45 @@ def has_different_structures(self, rtol=1e-05, atol=1e-08) -> str:
 
         return "\n".join(lines)
 
-    #def apply(self, func_or_string, args=(), **kwargs):
-    #    """
-    #    Applies function to all ``abifiles`` available in the robot.
+    def _get_ref_abifile_from_basename(self, ref_basename: str | None):
+        """
+        Find reference abifile. If None, the first file in the robot is used.
+        """
+        ref_file = self.abifiles[0]
+        if ref_basename is None:
+            return ref_file
 
-    #    Args:
-    #        func_or_string: If callable, the output of func_or_string(abifile, ...) is used.
-    #            If string, the output of getattr(abifile, func_or_string)(...)
-    #        args (tuple): Positional arguments to pass to function in addition to the array/series
-    #        kwargs: Additional keyword arguments will be passed as keywords to the function
+        for i, abifile in enumerate(self.abifiles):
+            if abifile.basename == ref_basename:
+                return abifile
 
-    #    Return: List of results
-    #    """
-    #    if callable(func_or_string):
-    #        return [func_or_string(abifile, *args, *kwargs) for abifile in self.abifiles]
-    #    else:
-    #        return [duck.getattrd(abifile, func_or_string)(*args, **kwargs) for abifile in self.abifiles]
+        raise ValueError(f"Cannot find {ref_basename=}")
+
+    @staticmethod
+    def _compare_attr_name(aname: str, ref_abifile, other_abifile) -> None:
+        """
+        Compare the value of attribute `aname` in two files.
+        """
+        # Get attributes in abifile first, then in abifile.r, else raise.
+        if hasattr(ref_abifile, aname):
+            val1, val2 = getattr(ref_abifile, aname), getattr(other_abifile, aname)
+
+        elif hasattr(ref_abifile , "r") and hasattr(ref_abifile.r, aname):
+            val1, val2 = getattr(ref_abifile.r, aname), getattr(other_abifile.r, aname)
+
+        else:
+            raise AttributeError(f"Cannot find attribute `{aname =}`")
+
+        # Now compare val1 and val2 taking into account the type.
+        if isinstance(val1, (str, int, float, Structure)):
+            eq = val1 == val2
+        elif isinstance(val1, np.ndarray):
+            eq = np.allclose(val1, val2)
+        else:
+            raise TypeError(f"Don't know how to handle comparison for type: {type(val1)}")
+
+        if not eq:
+            raise ValueError(f"Different values of {aname=}, {val1=}, {val2=}")
 
     def is_sortable(self, aname: str, raise_exc: bool = False) -> bool:
         """
@@ -812,16 +852,6 @@ def close(self) -> None:
                     print("Exception while closing: ", abifile.filepath)
                     print(exc)
 
-    #def get_attributes(self, attr_name, obj=None, retdict=False):
-    #    od = OrderedDict()
-    #    for label, abifile in self.items():
-    #        obj = abifile if obj is None else getattr(abifile, obj)
-    #        od[label] = getattr(obj, attr_name)
-    #    if retdict:
-    #        return od
-    #    else:
-    #        return list(od.values())
-
     def _exec_funcs(self, funcs, arg) -> dict:
         """
         Execute list of callable functions. Each function receives arg as argument.
@@ -1236,7 +1266,7 @@ def plot_abs_conv(ax1, ax2, xs, yvals, abs_conv, xlabel, fontsize, hatch, **kwar
         """
         y_xmax = yvals[-1]
         span_style = dict(alpha=0.2, color="green", hatch=hatch)
-        ax1.axhspan(y_xmax - abs_conv, y_xmax + abs_conv, label=r"$|y-y(x_{max})}| \leq %s$" % abs_conv, **span_style)
+        ax1.axhspan(y_xmax - abs_conv, y_xmax + abs_conv, label=r"$|y-y(x_{max})| \leq %s$" % abs_conv, **span_style)
 
         # Plot |y - y_xmax| in log scale on ax2.
         ax2.plot(xs, np.abs(yvals - y_xmax), **kwargs)

abipy/core/atom.py

@@ -11,7 +11,11 @@
 from monty.functools import lazy_property
 from monty.string import marquee  # is_string, list_strings,
 from scipy.interpolate import UnivariateSpline
-from scipy.integrate import cumtrapz
+try :
+    from scipy.integrate import cumulative_trapezoid as cumtrapz
+except ImportError:
+    from scipy.integrate import cumtrapz
+
 from abipy.data import nist_database
 from abipy.tools.serialization import pmg_serialize
 

abipy/core/func1d.py

@@ -282,7 +282,11 @@ def integral(self, start=0, stop=None) -> Function1D:
         """
         if stop is None: stop = len(self.values) + 1
         x, y = self.mesh[start:stop], self.values[start:stop]
-        from scipy.integrate import cumtrapz
+        try :
+            from scipy.integrate import cumulative_trapezoid as cumtrapz
+        except ImportError:
+            from scipy.integrate import cumtrapz
+
         integ = cumtrapz(y, x=x, initial=0.0)
 
         return self.__class__(x, integ)

abipy/core/kpoints.py

@@ -406,6 +406,39 @@ def map_kpoints(other_kpoints, other_lattice, ref_lattice, ref_kpoints, ref_symr
 #    #return irred_map
 
 
+def kpoints_indices(frac_coords, ngkpt, check_mesh=0) -> np.ndarray:
+    """
+    This function is used when we need to insert k-dependent quantities in a (nx, ny, nz) array.
+    It compute the indices of the k-points assuming these points belong to
+    a mesh with ngkpt divisions.
+
+    Args:
+        frac_coords
+        ngkpt:
+        check_mesh
+    """
+    # Transforms kpt in its corresponding reduced number in the interval [0,1[
+    k_indices = [np.round((kpt % 1) * ngkpt) for kpt in frac_coords]
+
+    k_indices = np.array(k_indices, dtype=int)
+    #k_indices = np.array(list(map(tuple, k_indices)))
+    #k_indices = list(map(tuple, k_indices))
+
+    if check_mesh:
+        print(f"kpoints_indices: Testing whether k-points belong to the {ngkpt =} mesh")
+        ierr = 0
+        for kpt, inds in zip(frac_coords, k_indices):
+            #print("kpt:", kpt, "inds:", inds)
+            same_k = np.array((inds[0]/ngkpt[0], inds[1]/ngkpt[1], inds[2]/ngkpt[2]))
+            if not issamek(kpt, same_k):
+                ierr += 1; print(kpt, "-->", same_k)
+        if ierr:
+            raise ValueError("Wrong mapping")
+        print("Check succesful!")
+
+    return k_indices
+
+
 def find_irred_kpoints_generic(structure, kfrac_coords, verbose=1):
     """
     Remove the k-points that are connected to each other by one of the
@@ -948,7 +981,7 @@ def __eq__(self, other):
     def __ne__(self, other):
         return not (self == other)
 
-    def index(self, kpoint):
+    def index(self, kpoint) -> int:
         """
         Returns: the first index of kpoint in self.
 
@@ -971,7 +1004,7 @@ def get_all_kindices(self, kpoint):
             if k == k0: kinds.append(ik)
         return np.array(kinds)
 
-    def find(self, kpoint):
+    def find(self, kpoint) -> int:
         """
         Returns: first index of kpoint. -1 if not found
         """

abipy/core/skw.py

@@ -217,7 +217,12 @@ def get_edos(self, kmesh, is_shift=None, method="gaussian", step=0.1, width=0.2,
                         values[spin] += wtk * gaussian(wmesh, width, center=eigens[spin, ik, band])
 
             # Compute IDOS
-            integral = scipy.integrate.cumtrapz(values, x=wmesh, initial=0.0)
+            try :
+                from scipy.integrate import cumulative_trapezoid as cumtrapz
+            except ImportError:
+                from scipy.integrate import cumtrapz
+
+            integral = cumtrapz(values, x=wmesh, initial=0.0)
 
         else:
             raise ValueError("Method %s is not supported" % method)