qupled 0.0.2__tar.gz

qupled-0.0.2/MANIFEST.in

@@ -0,0 +1,2 @@
+include qupled/Darwin/qupled.so
+include qupled/Linux/qupled.so

qupled-0.0.2/PKG-INFO

@@ -0,0 +1,27 @@
+Metadata-Version: 2.1
+Name: qupled
+Version: 0.0.2
+Summary: qupled: a package to investigate quantum plasmas via the dielectric formalism
+Author-email: Federico Lucco Castello <federico.luccocastello@gmail.com>
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Operating System :: MacOS
+Classifier: Operating System :: POSIX :: Linux
+Classifier: License :: OSI Approved :: GNU General Public License v3 (GPLv3)
+Requires-Python: <3.13,>=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: matplotlib~=3.7
+Requires-Dist: numpy<2.0
+Requires-Dist: pandas~=2.0
+Requires-Dist: tables~=3.10
+Provides-Extra: testing
+Requires-Dist: pytest~=8.0; extra == "testing"
+Requires-Dist: pytest-mock~=3.12; extra == "testing"
+Provides-Extra: docs
+Requires-Dist: sphinx-rtd-theme~=2.0.0; extra == "docs"
+Requires-Dist: sphinxcontrib-applehelp~=2.0.0; extra == "docs"
+Requires-Dist: sphinxcontrib-devhelp~=2.0.0; extra == "docs"
+Requires-Dist: sphinxcontrib-htmlhelp~=2.1.0; extra == "docs"
+Requires-Dist: sphinxcontrib-jquery~=4.1; extra == "docs"
+Requires-Dist: sphinxcontrib-jsmath~=1.0.1; extra == "docs"
+Requires-Dist: sphinxcontrib-qthelp~=2.0.0; extra == "docs"
+Requires-Dist: sphinxcontrib-serializinghtml~=2.0.0; extra == "docs"

qupled-0.0.2/pyproject.toml

@@ -0,0 +1,40 @@
+[project]
+name = "qupled"
+version = "0.0.2"
+description = "qupled: a package to investigate quantum plasmas via the dielectric formalism"
+readme = "README.md"
+requires-python = ">=3.10, <3.13"
+authors = [
+    { name = "Federico Lucco Castello", email = "federico.luccocastello@gmail.com" }
+]
+classifiers = [
+    "Programming Language :: Python :: 3.10",
+    "Operating System :: MacOS",
+    "Operating System :: POSIX :: Linux",
+    "License :: OSI Approved :: GNU General Public License v3 (GPLv3)"
+]
+dependencies = [
+    "matplotlib~=3.7",
+    "numpy<2.0",
+    "pandas~=2.0",
+    "tables~=3.10"
+]
+
+[project.optional-dependencies]
+testing = [
+    "pytest~=8.0",
+    "pytest-mock~=3.12"
+]
+docs = [
+    "sphinx-rtd-theme~=2.0.0",
+    "sphinxcontrib-applehelp~=2.0.0",
+    "sphinxcontrib-devhelp~=2.0.0",
+    "sphinxcontrib-htmlhelp~=2.1.0",
+    "sphinxcontrib-jquery~=4.1",
+    "sphinxcontrib-jsmath~=1.0.1",
+    "sphinxcontrib-qthelp~=2.0.0",
+    "sphinxcontrib-serializinghtml~=2.0.0"
+]
+
+[tool.setuptools]
+include-package-data = true

qupled-0.0.2/qupled/__init__.py

@@ -0,0 +1,9 @@
+import platform
+
+system = platform.system()
+if system == "Linux":
+    import qupled.Linux.qupled as native
+elif system == "Darwin":
+    import qupled.Darwin.qupled as native
+else:
+    raise ImportError(f"Platform {system} is not supported")

qupled-0.0.2/qupled/classic.py

@@ -0,0 +1,489 @@
+from __future__ import annotations
+import sys
+import os
+import numpy as np
+import pandas as pd
+from qupled import native
+import qupled.util as qu
+
+
+# -----------------------------------------------------------------------
+# _ClassicScheme class
+# -----------------------------------------------------------------------
+
+
+class _ClassicScheme:
+
+    def __init__(self):
+        # File to store output on disk
+        self.hdfFileName: str = None  #: Name of the output file.
+
+    # Compute the scheme
+    def _compute(self, scheme) -> None:
+        self.hdfFileName = self._getHdfFile(scheme.inputs)
+        status = scheme.compute()
+        self._checkStatusAndClean(status, scheme.recovery)
+
+    # Check that the dielectric scheme was solved without errors
+    @qu.MPI.runOnlyOnRoot
+    def _checkStatusAndClean(self, status: bool, recovery: str) -> None:
+        """Checks that the scheme was solved correctly and removes temporarary files generated at run-time
+
+        Args:
+            status: status obtained from the native code. If status == 0 the scheme was solved correctly.
+            recovery: name of the recovery file.
+        """
+        if status == 0:
+            if os.path.isfile(recovery):
+                os.remove(recovery)
+            print("Dielectric theory solved successfully!")
+        else:
+            sys.exit("Error while solving the dielectric theory")
+
+    # Save results to disk
+    def _getHdfFile(self, inputs) -> str:
+        """Sets the name of the hdf file used to store the output
+
+        Args:
+            inputs: input parameters
+        """
+        coupling = inputs.coupling
+        degeneracy = inputs.degeneracy
+        theory = inputs.theory
+        return f"rs{coupling:5.3f}_theta{degeneracy:5.3f}_{theory}.h5"
+
+    @qu.MPI.runOnlyOnRoot
+    def _save(self, scheme) -> None:
+        inputs = scheme.inputs
+        """Stores the results obtained by solving the scheme."""
+        pd.DataFrame(
+            {
+                "coupling": inputs.coupling,
+                "degeneracy": inputs.degeneracy,
+                "theory": inputs.theory,
+                "resolution": inputs.resolution,
+                "cutoff": inputs.cutoff,
+                "matsubara": inputs.matsubara,
+            },
+            index=["info"],
+        ).to_hdf(self.hdfFileName, key="info", mode="w")
+        pd.DataFrame(scheme.idr).to_hdf(self.hdfFileName, key="idr")
+        pd.DataFrame(scheme.sdr).to_hdf(self.hdfFileName, key="sdr")
+        pd.DataFrame(scheme.slfc).to_hdf(self.hdfFileName, key="slfc")
+        pd.DataFrame(scheme.ssf).to_hdf(self.hdfFileName, key="ssf")
+        pd.DataFrame(scheme.ssfHF).to_hdf(self.hdfFileName, key="ssfHF")
+        pd.DataFrame(scheme.wvg).to_hdf(self.hdfFileName, key="wvg")
+
+    # Compute radial distribution function
+    def computeRdf(
+        self, rdfGrid: np.ndarray = None, writeToHdf: bool = True
+    ) -> np.array:
+        """Computes the radial distribution function from the data stored in the output file.
+
+        Args:
+            rdfGrid: The grid used to compute the radial distribution function.
+                Default = ``None`` (see :func:`qupled.util.Hdf.computeRdf`)
+            writeToHdf: Flag marking whether the rdf data should be added to the output hdf file, default to True
+
+        Returns:
+            The radial distribution function
+
+        """
+        if qu.MPI().getRank() > 0:
+            writeToHdf = False
+        return qu.Hdf().computeRdf(self.hdfFileName, rdfGrid, writeToHdf)
+
+    # Compute the internal energy
+    def computeInternalEnergy(self) -> float:
+        """Computes the internal energy from the data stored in the output file.
+
+        Returns:
+            The internal energy
+
+        """
+        return qu.Hdf().computeInternalEnergy(self.hdfFileName)
+
+    # Plot results
+    @qu.MPI.runOnlyOnRoot
+    def plot(
+        self,
+        toPlot: list[str],
+        matsubara: np.ndarray = None,
+        rdfGrid: np.ndarray = None,
+    ) -> None:
+        """Plots the results stored in the output file.
+
+        Args:
+            toPlot: A list of quantities to plot. This list can include all the values written to the
+                 output hdf file. The radial distribution funciton is computed and added to the output
+                 file if necessary
+            matsubara: A list of matsubara frequencies to plot. Applies only when the idr is plotted.
+                (Default = None, all matsubara frequencies are plotted)
+            rdfGrid: The grid used to compute the radial distribution function. Applies only when the radial
+                distribution function is plotted. Default = ``None`` (see :func:`qupled.util.Hdf.computeRdf`).
+
+        """
+        if "rdf" in toPlot:
+            self.computeRdf(rdfGrid)
+        qu.Hdf().plot(self.hdfFileName, toPlot, matsubara)
+
+
+# -----------------------------------------------------------------------
+# RPA class
+# -----------------------------------------------------------------------
+
+
+class Rpa(_ClassicScheme):
+
+    # Compute
+    @qu.MPI.recordTime
+    @qu.MPI.synchronizeRanks
+    def compute(self, inputs: Rpa.Input) -> None:
+        """
+        Solves the scheme and saves the results.
+
+        Args:
+            inputs: Input parameters.
+        """
+        scheme = native.Rpa(inputs.toNative())
+        self._compute(scheme)
+        self._save(scheme)
+
+    # Input class
+    class Input:
+        """
+        Class used to manage the input for the :obj:`qupled.classic.Rpa` class.
+        """
+
+        def __init__(self, coupling: float, degeneracy: float):
+            self.coupling: float = coupling
+            """Coupling parameter."""
+            self.degeneracy: float = degeneracy
+            """Degeneracy parameter."""
+            self.chemicalPotential: list[float] = [-10.0, 10.0]
+            """Initial guess for the chemical potential. Default = ``[-10, 10]``"""
+            self.matsubara: int = 128
+            """Number of Matsubara frequencies. Default = ``128``"""
+            self.resolution: float = 0.1
+            """Resolution of the wave-vector grid. Default =  ``0.1``"""
+            self.cutoff: float = 10.0
+            """Cutoff for the wave-vector grid. Default =  ``10.0``"""
+            self.intError: float = 1.0e-5
+            """Accuracy (relative error) in the computation of integrals. Default = ``1.0e-5``"""
+            self.int2DScheme: str = "full"
+            """
+            Scheme used to solve two-dimensional integrals
+            allowed options include:
+
+            - full: the inner integral is evaluated at arbitrary points
+              selected automatically by the quadrature rule
+
+            - segregated: the inner integral is evaluated on a fixed
+              grid that depends on the integrand that is being processed
+
+            Segregated is usually faster than full but it could become
+            less accurate if the fixed points are not chosen correctly. Default =  ``'full'``
+            """
+            self.threads: int = 1
+            """Number of OMP threads for parallel calculations. Default =  ``1``"""
+            self.theory: str = "RPA"
+
+        def toNative(self) -> native.RpaInput:
+            native_input = native.RpaInput()
+            for attr, value in self.__dict__.items():
+                setattr(native_input, attr, value)
+            return native_input
+
+
+# -----------------------------------------------------------------------
+# ESA class
+# -----------------------------------------------------------------------
+
+
+class ESA(_ClassicScheme):
+    """
+    Args:
+        inputs: Input parameters.
+    """
+
+    # Compute
+    @qu.MPI.recordTime
+    @qu.MPI.synchronizeRanks
+    def compute(self, inputs: ESA.Input) -> None:
+        """
+        Solves the scheme and saves the results.
+
+        Args:
+            inputs: Input parameters.
+        """
+        scheme = native.ESA(inputs.toNative())
+        self._compute(scheme)
+        self._save(scheme)
+
+    # Input class
+    class Input(Rpa.Input):
+        """
+        Class used to manage the input for the :obj:`qupled.classic.ESA` class.
+        """
+
+        def __init__(self, coupling: float, degeneracy: float):
+            super().__init__(coupling, degeneracy)
+            # Undocumented default values
+            self.theory = "ESA"
+
+
+# -----------------------------------------------------------------------
+# _IterativeScheme class
+# -----------------------------------------------------------------------
+
+
+class _IterativeScheme(_ClassicScheme):
+
+    # Set the initial guess from a dataframe produced in output
+    @staticmethod
+    def getInitialGuess(fileName: str) -> _IterativeScheme.Guess:
+        """Constructs an initial guess object by extracting the information from an output file.
+
+        Args:
+            fileName : name of the file used to extract the information for the initial guess.
+        """
+        hdfData = qu.Hdf().read(fileName, ["wvg", "slfc"])
+        return _IterativeScheme.Guess(hdfData["wvg"], hdfData["slfc"])
+
+    # Save results to disk
+    @qu.MPI.runOnlyOnRoot
+    def _save(self, scheme) -> None:
+        """Stores the results obtained by solving the scheme."""
+        super()._save(scheme)
+        inputs = scheme.inputs
+        pd.DataFrame(
+            {
+                "coupling": inputs.coupling,
+                "degeneracy": inputs.degeneracy,
+                "error": scheme.error,
+                "theory": inputs.theory,
+                "resolution": inputs.resolution,
+                "cutoff": inputs.cutoff,
+                "matsubara": inputs.matsubara,
+            },
+            index=["info"],
+        ).to_hdf(self.hdfFileName, key="info")
+
+    # Initial guess
+    class Guess:
+
+        def __init__(self, wvg: np.ndarray = None, slfc: np.ndarray = None):
+            self.wvg = wvg
+            """ Wave-vector grid. Default = ``None``"""
+            self.slfc = slfc
+            """ Static local field correction. Default = ``None``"""
+
+        def toNative(self) -> native.StlsGuess:
+            native_guess = native.StlsGuess()
+            for attr, value in self.__dict__.items():
+                native_value = value if value is not None else np.empty(0)
+                setattr(native_guess, attr, native_value)
+            return native_guess
+
+
+# -----------------------------------------------------------------------
+# Stls class
+# -----------------------------------------------------------------------
+
+
+class Stls(_IterativeScheme):
+
+    # Compute
+    @qu.MPI.recordTime
+    @qu.MPI.synchronizeRanks
+    def compute(self, inputs: Stls.Input) -> None:
+        """
+        Solves the scheme and saves the results.
+
+        Args:
+            inputs: Input parameters.
+        """
+        scheme = native.Stls(inputs.toNative())
+        self._compute(scheme)
+        self._save(scheme)
+
+    # Input class
+    class Input(Rpa.Input):
+        """
+        Class used to manage the input for the :obj:`qupled.classic.Stls` class.
+        """
+
+        def __init__(self, coupling: float, degeneracy: float):
+            super().__init__(coupling, degeneracy)
+            self.error: float = 1.0e-5
+            """Minimum error for convergence. Default = ``1.0e-5``"""
+            self.mixing: float = 1.0
+            """Mixing parameter. Default = ``1.0``"""
+            self.iterations: int = 1000
+            """Maximum number of iterations. Default = ``1000``"""
+            self.outputFrequency: int = 10
+            """Output frequency to write the recovery file. Default = ``10``"""
+            self.recoveryFile: str = ""
+            """Name of the recovery file. Default = ``""``"""
+            self.guess: Stls.Guess = Stls.Guess()
+            """Initial guess. Default = ``Stls.Guess()``"""
+            # Undocumented default values
+            self.theory: str = "STLS"
+
+        def toNative(self) -> native.StlsInput:
+            native_input = native.StlsInput()
+            for attr, value in self.__dict__.items():
+                if attr == "guess":
+                    setattr(native_input, attr, value.toNative())
+                else:
+                    setattr(native_input, attr, value)
+            return native_input
+
+
+# -----------------------------------------------------------------------
+# StlsIet class
+# -----------------------------------------------------------------------
+
+
+class StlsIet(_IterativeScheme):
+
+    # Compute
+    @qu.MPI.recordTime
+    @qu.MPI.synchronizeRanks
+    def compute(self, inputs: StlsIet.Input) -> None:
+        """
+        Solves the scheme and saves the results.
+
+        Args:
+            inputs: Input parameters.
+        """
+        scheme = native.Stls(inputs.toNative())
+        self._compute(scheme)
+        self._save(scheme)
+
+    # Save results to disk
+    @qu.MPI.runOnlyOnRoot
+    def _save(self, scheme) -> None:
+        """Stores the results obtained by solving the scheme."""
+        super()._save(scheme)
+        pd.DataFrame(scheme.bf).to_hdf(self.hdfFileName, key="bf")
+
+    # Input class
+    class Input(Stls.Input):
+        """
+        Class used to manage the input for the :obj:`qupled.classic.StlsIet` class.
+        Accepted theories: ``STLS-HNC``, ``STLS-IOI`` and ``STLS-LCT``.
+        """
+
+        def __init__(self, coupling: float, degeneracy: float, theory: str):
+            super().__init__(coupling, degeneracy)
+            if theory not in {"STLS-HNC", "STLS-IOI", "STLS-LCT"}:
+                sys.exit("Invalid dielectric theory")
+            self.theory = theory
+            self.mapping = "standard"
+            r"""
+            Mapping for the classical-to-quantum coupling parameter
+            :math:`\Gamma` used in the iet schemes. Allowed options include:
+
+            - standard: :math:`\Gamma \propto \Theta^{-1}`
+
+            - sqrt: :math:`\Gamma \propto (1 + \Theta)^{-1/2}`
+
+            - linear: :math:`\Gamma \propto (1 + \Theta)^{-1}`
+
+            where :math:`\Theta` is the degeneracy parameter. Far from the ground state
+            (i.e. :math:`\Theta\gg1`) all mappings lead identical results, but at
+            the ground state they can differ significantly (the standard
+            mapping diverges). Default = ``standard``.
+            """
+
+        def toNative(self) -> native.StlsInput:
+            native_input = native.StlsInput()
+            for attr, value in self.__dict__.items():
+                if attr == "guess":
+                    setattr(native_input, attr, value.toNative())
+                else:
+                    setattr(native_input, attr, value)
+            return native_input
+
+
+# -----------------------------------------------------------------------
+# VSStls class
+# -----------------------------------------------------------------------
+
+
+class VSStls(_IterativeScheme):
+
+    # Compute
+    @qu.MPI.recordTime
+    @qu.MPI.synchronizeRanks
+    def compute(self, inputs: VSStls.Input) -> None:
+        """
+        Solves the scheme and saves the results.
+
+        Args:
+            inputs: Input parameters.
+        """
+        scheme = native.VSStls(inputs.toNative())
+        self._compute(scheme)
+        self._save(scheme)
+
+    # Save results
+    @qu.MPI.runOnlyOnRoot
+    def _save(self, scheme) -> None:
+        """Stores the results obtained by solving the scheme."""
+        super()._save(scheme)
+        pd.DataFrame(scheme.freeEnergyGrid).to_hdf(self.hdfFileName, key="fxcGrid")
+        pd.DataFrame(scheme.freeEnergyIntegrand).to_hdf(self.hdfFileName, key="fxci")
+        pd.DataFrame(scheme.alpha).to_hdf(self.hdfFileName, key="alpha")
+
+    # Set the free energy integrand from a dataframe produced in output
+    @staticmethod
+    def getFreeEnergyIntegrand(fileName: str) -> native.FreeEnergyIntegrand():
+        """Constructs the free energy integrand by extracting the information from an output file.
+
+        Args:
+            fileName : name of the file used to extract the information for the free energy integrand.
+        """
+        fxci = native.FreeEnergyIntegrand()
+        hdfData = qu.Hdf().read(fileName, ["fxcGrid", "fxci", "alpha"])
+        fxci.grid = hdfData["fxcGrid"]
+        fxci.integrand = np.ascontiguousarray(hdfData["fxci"])
+        fxci.alpha = hdfData["alpha"]
+        return fxci
+
+    # Input class
+    class Input(Stls.Input):
+        """
+        Class used to manage the input for the :obj:`qupled.classic.VSStls` class.
+        """
+
+        def __init__(self, coupling: float, degeneracy: float):
+            super().__init__(coupling, degeneracy)
+            self.alpha: list[float] = [0.5, 1.0]
+            """Initial guess for the free parameter. Default = ``[0.5, 1.0]``"""
+            self.couplingResolution: float = 0.1
+            """Resolution of the coupling parameter grid. Default = ``0.1``"""
+            self.degeneracyResolution: float = 0.1
+            """Resolution of the degeneracy parameter grid. Default = ``0.1``"""
+            self.errorAlpha: float = 1.0e-3
+            """Minimum error for convergence in the free parameter. Default = ``1.0e-3``"""
+            self.iterationsAlpha: int = 50
+            """Maximum number of iterations to determine the free parameter. Default = ``50``"""
+            self.freeEnergyIntegrand: qupled.FreeEnergyIntegrand = (
+                native.FreeEnergyIntegrand()
+            )
+            """Pre-computed free energy integrand."""
+            self.threads: int = 9
+            """Number of threads. Default = ``9``"""
+            # Undocumented default values
+            self.theory: str = "VSSTLS"
+
+        def toNative(self) -> native.VSStlsInput:
+            native_input = native.VSStlsInput()
+            for attr, value in self.__dict__.items():
+                if attr == "guess":
+                    setattr(native_input, attr, value.toNative())
+                else:
+                    setattr(native_input, attr, value)
+            return native_input

qupled-0.0.2/qupled/quantum.py

@@ -0,0 +1,300 @@
+from __future__ import annotations
+
+import sys
+import os
+from shutil import rmtree
+from glob import glob
+import zipfile as zf
+import numpy as np
+import pandas as pd
+from qupled import native
+import qupled.util as qu
+import qupled.classic as qc
+
+# -----------------------------------------------------------------------
+# _QuantumIterativeScheme class
+# -----------------------------------------------------------------------
+
+
+class _QuantumIterativeScheme(qc._IterativeScheme):
+
+    # Set the initial guess from a dataframe produced in output
+    @staticmethod
+    def getInitialGuess(fileName: str) -> _QuantumIterativeScheme.Guess:
+        """Constructs an initial guess object by extracting the information from an output file.
+
+        Args:
+            fileName : name of the file used to extract the information for the initial guess.
+        """
+        hdfData = qu.Hdf().read(fileName, ["wvg", "ssf", "adr", "matsubara"])
+        return _QuantumIterativeScheme.Guess(
+            hdfData["wvg"],
+            hdfData["ssf"],
+            np.ascontiguousarray(hdfData["adr"]),
+            hdfData["matsubara"],
+        )
+
+    # Save results to disk
+    @qu.MPI.runOnlyOnRoot
+    def _save(self, scheme) -> None:
+        """Stores the results obtained by solving the scheme."""
+        super()._save(scheme)
+        pd.DataFrame(scheme.adr).to_hdf(self.hdfFileName, key="adr")
+
+    # Initial guess
+    class Guess:
+
+        def __init__(
+            self,
+            wvg: np.ndarray = None,
+            ssf: np.ndarray = None,
+            adr: np.ndarray = None,
+            matsubara: int = 0,
+        ):
+            self.wvg = wvg
+            """ Wave-vector grid. Default = ``None``"""
+            self.ssf = ssf
+            """ Static structure factor. Default = ``None``"""
+            self.adr = adr
+            """ Auxiliary density response. Default = ``None``"""
+            self.matsubara = matsubara
+            """ Number of matsubara frequencies. Default = ``0``"""
+
+        def toNative(self) -> native.QStlsGuess:
+            native_guess = native.QstlsGuess()
+            for attr, value in self.__dict__.items():
+                native_value = value if value is not None else np.empty(0)
+                setattr(native_guess, attr, native_value)
+            return native_guess
+
+
+# -----------------------------------------------------------------------
+# Qstls class
+# -----------------------------------------------------------------------
+
+
+class Qstls(_QuantumIterativeScheme):
+
+    # Compute
+    @qu.MPI.recordTime
+    @qu.MPI.synchronizeRanks
+    def compute(self, inputs: Qstls.Input) -> None:
+        """
+        Solves the scheme and saves the results.
+
+        Args:
+            inputs: Input parameters.
+        """
+        scheme = native.Qstls(inputs.toNative())
+        self._compute(scheme)
+        self._save(scheme)
+
+    # Input class
+    class Input(qc.Stls.Input):
+        """
+        Class used to manage the input for the :obj:`qupled.quantum.Qstls` class.
+        """
+
+        def __init__(self, coupling: float, degeneracy: float):
+            super().__init__(coupling, degeneracy)
+            self.fixed: str = ""
+            """ Name of the file storing the fixed component of the auxiliary density 
+	    response in the QSTLS scheme. """
+            self.guess: Qstls.Guess = Qstls.Guess()
+            """Initial guess. Default = ``Qstls.Guess()``"""
+            # Undocumented default values
+            self.theory = "QSTLS"
+
+        def toNative(self) -> native.QstlsInput:
+            native_input = native.QstlsInput()
+            for attr, value in self.__dict__.items():
+                if attr == "guess":
+                    setattr(native_input, attr, value.toNative())
+                else:
+                    setattr(native_input, attr, value)
+            return native_input
+
+
+# -----------------------------------------------------------------------
+# QstlsIet class
+# -----------------------------------------------------------------------
+
+
+class QstlsIet(_QuantumIterativeScheme):
+    """
+    Args:
+        inputs: Input parameters.
+    """
+
+    # Compute
+    @qu.MPI.recordTime
+    @qu.MPI.synchronizeRanks
+    def compute(self, inputs: QsltsIet.Input) -> None:
+        """
+        Solves the scheme and saves the results.
+
+        Args:
+            inputs: Input parameters.
+        """
+        self._unpackFixedAdrFiles(inputs)
+        scheme = native.Qstls(inputs.toNative())
+        self._compute(scheme)
+        self._save(scheme)
+        self._zipFixedAdrFiles(inputs)
+        self._cleanFixedAdrFiles(scheme.inputs)
+
+    # Unpack zip folder with fixed component of the auxiliary density response
+    @qu.MPI.runOnlyOnRoot
+    def _unpackFixedAdrFiles(self, inputs) -> None:
+        fixedIetSourceFile = inputs.fixediet
+        if inputs.fixediet != "":
+            inputs.fixediet = "qupled_tmp_run_directory"
+        if fixedIetSourceFile != "":
+            with zf.ZipFile(fixedIetSourceFile, "r") as zipFile:
+                zipFile.extractall(inputs.fixediet)
+
+    # Save results to disk
+    @qu.MPI.runOnlyOnRoot
+    def _save(self, scheme) -> None:
+        super()._save(scheme)
+        pd.DataFrame(scheme.bf).to_hdf(self.hdfFileName, key="bf")
+
+    # Zip all files for the fixed component of the auxiliary density response
+    @qu.MPI.runOnlyOnRoot
+    def _zipFixedAdrFiles(self, inputs) -> None:
+        if inputs.fixediet == "":
+            degeneracy = inputs.degeneracy
+            matsubara = inputs.matsubara
+            theory = inputs.theory
+            adrFile = f"adr_fixed_theta{degeneracy:5.3f}_matsubara{matsubara}_{theory}"
+            adrFileZip = f"{adrFile}.zip"
+            adrFileBin = f"{adrFile}_wv*.bin"
+            with zf.ZipFile(adrFileZip, "w") as zipFile:
+                for binFile in glob(adrFileBin):
+                    zipFile.write(binFile)
+                    os.remove(binFile)
+
+    # Remove temporaray run directory
+    @qu.MPI.runOnlyOnRoot
+    def _cleanFixedAdrFiles(self, inputs) -> None:
+        if os.path.isdir(inputs.fixediet):
+            rmtree(inputs.fixediet)
+
+    # Input class
+    class Input(qc.StlsIet.Input, Qstls.Input):
+        """
+        Class used to manage the input for the :obj:`qupled.classic.QStlsIet` class.
+        Accepted theories: ``QSTLS-HNC``, ``QSTLS-IOI`` and ``QSTLS-LCT``.
+        """
+
+        def __init__(self, coupling: float, degeneracy: float, theory: str):
+            qc.StlsIet.Input.__init__(self, coupling, degeneracy, "STLS-HNC")
+            Qstls.Input.__init__(self, coupling, degeneracy)
+            if theory not in {"QSTLS-HNC", "QSTLS-IOI", "QSTLS-LCT"}:
+                sys.exit("Invalid dielectric theory")
+            self.theory = theory
+            self.fixediet = ""
+            """
+            Name of the zip file storing the iet part of the fixed components
+            of the auxiliary density response. Default = ``""``
+            """
+
+        def toNative(self) -> native.QstlsInput:
+            native_input = native.QstlsInput()
+            for attr, value in self.__dict__.items():
+                if attr == "guess":
+                    setattr(native_input, attr, value.toNative())
+                else:
+                    setattr(native_input, attr, value)
+            return native_input
+
+
+# -----------------------------------------------------------------------
+# QVSStls class
+# -----------------------------------------------------------------------
+
+
+class QVSStls(_QuantumIterativeScheme):
+
+    # Compute
+    @qu.MPI.recordTime
+    @qu.MPI.synchronizeRanks
+    def compute(self, inputs: QVSStls.Input) -> None:
+        """
+        Solves the scheme and saves the results.
+
+        Args:
+            inputs: Input parameters.
+        """
+        self._unpackFixedAdrFiles(inputs)
+        scheme = native.QVSStls(inputs.toNative())
+        self._compute(scheme)
+        self._save(scheme)
+        self._zipFixedAdrFiles(inputs)
+        self._cleanFixedAdrFiles(scheme.inputs)
+
+    # Unpack zip folder with fixed component of the auxiliary density response
+    @qu.MPI.runOnlyOnRoot
+    def _unpackFixedAdrFiles(self, inputs) -> None:
+        fixedSourceFile = inputs.fixed
+        if inputs.fixed != "":
+            inputs.fixed = "qupled_tmp_run_directory"
+        if fixedSourceFile != "":
+            with zf.ZipFile(fixedSourceFile, "r") as zipFile:
+                zipFile.extractall(inputs.fixed)
+
+    # Save results to disk
+    @qu.MPI.runOnlyOnRoot
+    def _save(self, scheme) -> None:
+        super()._save(scheme)
+        pd.DataFrame(scheme.freeEnergyGrid).to_hdf(self.hdfFileName, key="fxcGrid")
+        pd.DataFrame(scheme.freeEnergyIntegrand).to_hdf(self.hdfFileName, key="fxci")
+        pd.DataFrame(scheme.alpha).to_hdf(self.hdfFileName, key="alpha")
+
+    # Zip all files for the fixed component of the auxiliary density response
+    @qu.MPI.runOnlyOnRoot
+    def _zipFixedAdrFiles(self, inputs) -> None:
+        if inputs.fixed == "":
+            degeneracy = inputs.degeneracy
+            matsubara = inputs.matsubara
+            theory = inputs.theory
+            adrFileZip = (
+                f"adr_fixed_theta{degeneracy:5.3f}_matsubara{matsubara}_{theory}.zip"
+            )
+            adrFileBin = "THETA*.bin"
+            with zf.ZipFile(adrFileZip, "w") as zipFile:
+                for binFile in glob(adrFileBin):
+                    zipFile.write(binFile)
+                    os.remove(binFile)
+
+    # Remove the temporary run directory
+    @qu.MPI.runOnlyOnRoot
+    def _cleanFixedAdrFiles(self, inputs) -> None:
+        if os.path.isdir(inputs.fixed):
+            rmtree(inputs.fixed)
+
+    # Set the free energy integrand from a dataframe produced in output
+    @staticmethod
+    def getFreeEnergyIntegrand(fileName: str) -> native.FreeEnergyIntegrand():
+        return qc.VSStls.getFreeEnergyIntegrand(fileName)
+
+    # Input class
+    class Input(qc.VSStls.Input, Qstls.Input):
+        """
+        Class used to manage the input for the :obj:`qupled.classic.QVSStls` class.
+        """
+
+        def __init__(self, coupling: float, degeneracy: float):
+            qc.VSStls.Input.__init__(self, coupling, degeneracy)
+            Qstls.Input.__init__(self, coupling, degeneracy)
+            # Undocumented default values
+            self.theory: str = "QVSSTLS"
+
+        def toNative(self) -> native.QVSStlsInput:
+            native_input = native.QVSStlsInput()
+            for attr, value in self.__dict__.items():
+                if attr == "guess":
+                    setattr(native_input, attr, value.toNative())
+                else:
+                    setattr(native_input, attr, value)
+            return native_input

qupled-0.0.2/qupled/util.py

@@ -0,0 +1,330 @@
+import sys
+import os
+import numpy as np
+import pandas as pd
+import matplotlib.pyplot as plt
+from matplotlib import colormaps as cm
+import functools
+from qupled import native
+
+# -----------------------------------------------------------------------
+# Hdf class
+# -----------------------------------------------------------------------
+
+
+class Hdf:
+    """Class to manipulate the output hdf files produced when a scheme is solved."""
+
+    # Construct
+    def __init__(self):
+        # The first entry is a descriptive name of the
+        self.entries = {
+            "alpha": self.Entries("Free Parameter for VS schemes", "numpy"),
+            "adr": self.Entries("Auxiliary density response", "numpy2D"),
+            "bf": self.Entries("Bridge function adder", "numpy"),
+            "coupling": self.Entries("Coupling parameter", "number"),
+            "cutoff": self.Entries("Cutoff for the wave-vector grid", "number"),
+            "degeneracy": self.Entries("Degeneracy parameter", "number"),
+            "error": self.Entries("Residual error in the solution", "number"),
+            "fxcGrid": self.Entries("Coupling parameter", "numpy"),
+            "fxci": self.Entries("Free Energy integrand", "numpy2D"),
+            "matsubara": self.Entries("Number of matsubara frequencies", "number"),
+            "idr": self.Entries("Ideal density response", "numpy2D"),
+            "resolution": self.Entries("Resolution for the wave-vector grid", "number"),
+            "rdf": self.Entries("Radial distribution function", "numpy"),
+            "rdfGrid": self.Entries("Inter-particle distance", "numpy"),
+            "sdr": self.Entries("Static density response", "numpy"),
+            "slfc": self.Entries("Static local field correction", "numpy"),
+            "ssf": self.Entries("Static structure factor", "numpy"),
+            "ssfHF": self.Entries("Hartree-Fock static structure factor", "numpy"),
+            "theory": self.Entries("Theory that is being solved", "string"),
+            "wvg": self.Entries("Wave-vector", "numpy"),
+        }
+
+    # Structure used to cathegorize the entries stored in the hdf file
+    class Entries:
+        def __init__(self, description, entryType):
+            self.description = description  # Descriptive string of the entry
+            self.entryType = (
+                entryType  # Type of entry (numpy, numpy2, number or string)
+            )
+            assert (
+                self.entryType == "numpy"
+                or self.entryType == "numpy2D"
+                or self.entryType == "number"
+                or self.entryType == "string"
+            )
+
+    # Read data in hdf file
+    def read(self, hdf: str, toRead: list[str]) -> dict:
+        """Reads an hdf file produced by coupled and returns the content in the form of a dictionary
+
+        Args:
+            hdf: Name of the hdf file to read
+            toRead: A list of quantities to read. The list of quantities that can be extracted from
+                the hdf file can be obtained by running :func:`~qupled.util.Hdf.inspect`
+
+        Returns:
+            A dictionary whose entries are the quantities listed in toRead
+
+        """
+        output = dict.fromkeys(toRead)
+        for name in toRead:
+            if name not in self.entries:
+                sys.exit("Unknown entry")
+            if self.entries[name].entryType == "numpy":
+                output[name] = pd.read_hdf(hdf, name)[0].to_numpy()
+            elif self.entries[name].entryType == "numpy2D":
+                output[name] = pd.read_hdf(hdf, name).to_numpy()
+            elif self.entries[name].entryType == "number":
+                output[name] = pd.read_hdf(hdf, "info")[name].iloc[0].tolist()
+            elif self.entries[name].entryType == "string":
+                output[name] = pd.read_hdf(hdf, "info")[name].iloc[0]
+            else:
+                sys.exit("Unknown entry type")
+        return output
+
+    # Get all quantities stored in an hdf file
+    def inspect(self, hdf: str) -> dict:
+        """Allows to obtain a summary of the quantities stored in an hdf file
+
+        Args:
+            hdf: Name of the hdf file to inspect
+
+        Returns:
+            A dictionary containing all the quantities stored in the hdf file and a brief description for
+            each quantity
+
+        """
+        with pd.HDFStore(hdf, mode="r") as store:
+            datasetNames = [
+                name[1:] if name.startswith("/") else name for name in store.keys()
+            ]
+            if "info" in datasetNames:
+                datasetNames.remove("info")
+                for name in store["info"].keys():
+                    datasetNames.append(name)
+        output = dict.fromkeys(datasetNames)
+        for key in output.keys():
+            output[key] = self.entries[key].description
+        return output
+
+    # Plot from data in hdf file
+    def plot(self, hdf: str, toPlot: list[str], matsubara: np.array = None) -> None:
+        """Plots the results stored in an hdf file.
+
+        Args:
+            hdf: Name of the hdf file
+            toPlot: A list of quantities to plot. Allowed quantities include adr (auxiliary density response),
+                bf (bridge function adder), fxci (free energy integrand), idr (ideal density response), rdf
+                (radial distribution function), sdr (static density response), slfc (static local field correction)
+                ssf (static structure factor) and ssfHF (Hartree-Fock static structure factor).
+                If the hdf file does not contain the specified quantity, an error is thrown
+            matsubara: A list of matsubara frequencies to plot. Applies only when the idr is plotted.
+                (Defaults to  None, all matsubara frequencies are plotted)
+
+        """
+        for name in toPlot:
+            description = (
+                self.entries[name].description if name in self.entries.keys() else ""
+            )
+            if name == "rdf":
+                x = self.read(hdf, [name, "rdfGrid"])
+                Plot.plot1D(
+                    x["rdfGrid"],
+                    x[name],
+                    self.entries["rdfGrid"].description,
+                    description,
+                )
+            elif name in ["adr", "idr"]:
+                x = self.read(hdf, [name, "wvg", "matsubara"])
+                if matsubara is None:
+                    matsubara = np.arange(x["matsubara"])
+                Plot.plot1DParametric(
+                    x["wvg"],
+                    x[name],
+                    self.entries["wvg"].description,
+                    description,
+                    matsubara,
+                )
+            elif name == "fxci":
+                x = self.read(hdf, [name, "fxcGrid"])
+                Plot.plot1D(
+                    x["fxcGrid"],
+                    x[name][1, :],
+                    self.entries["fxcGrid"].description,
+                    description,
+                )
+            elif name in ["bf", "sdr", "slfc", "ssf", "ssfHF"]:
+                x = self.read(hdf, [name, "wvg"])
+                Plot.plot1D(
+                    x["wvg"],
+                    x[name],
+                    self.entries["wvg"].description,
+                    self.entries[name].description,
+                )
+            elif name == "alpha":
+                x = self.read(hdf, [name, "fxcGrid"])
+                Plot.plot1D(
+                    x["fxcGrid"][::2],
+                    x[name][::2],
+                    self.entries["fxcGrid"].description,
+                    self.entries[name].description,
+                )
+            else:
+                sys.exit("Unknown quantity to plot")
+
+    def computeRdf(
+        self, hdf: str, rdfGrid: np.array = None, saveRdf: bool = True
+    ) -> None:
+        """Computes the radial distribution function and returns it as a numpy array.
+
+        Args:
+            hdf: Name of the hdf file to load the structural properties from
+            rdfGrid: A numpy array specifing the grid used to compute the radial distribution function
+                (default = None, i.e. rdfGrid = np.arange(0.0, 10.0, 0.01))
+            saveRdf: Flag marking whether the rdf data should be added to the hdf file (default = True)
+
+        Returns:
+            The radial distribution function
+
+        """
+        hdfData = self.read(hdf, ["wvg", "ssf"])
+        if rdfGrid is None:
+            rdfGrid = np.arange(0.0, 10.0, 0.01)
+        rdf = native.computeRdf(rdfGrid, hdfData["wvg"], hdfData["ssf"])
+        if saveRdf:
+            pd.DataFrame(rdfGrid).to_hdf(hdf, key="rdfGrid", mode="r+")
+            pd.DataFrame(rdf).to_hdf(hdf, key="rdf", mode="r+")
+        return rdf
+
+    def computeInternalEnergy(self, hdf: str) -> float:
+        """Computes the internal energy and returns it to output.
+
+        Args:
+            hdf: Name of the hdf file to load the structural properties from
+
+        Returns:
+            The internal energy
+        """
+        hdfData = self.read(hdf, ["wvg", "ssf", "coupling"])
+        return native.computeInternalEnergy(
+            hdfData["wvg"], hdfData["ssf"], hdfData["coupling"]
+        )
+
+
+# -----------------------------------------------------------------------
+# Plot class
+# -----------------------------------------------------------------------
+
+
+class Plot:
+    """Class to collect methods used for plotting"""
+
+    # One dimensional plots
+    def plot1D(x, y, xlabel, ylabel):
+        """Produces the plot of a one-dimensional quantity.
+
+        Positional arguments:
+        x -- data for the x-axis (a numpy array)
+        y -- data for the y-axis (a numpy array)
+        xlabel -- label for the x-axis (a string)
+        ylabel -- label for the y-axis (a string)
+        """
+        plt.plot(x, y, "b")
+        plt.xlabel(xlabel)
+        plt.ylabel(ylabel)
+        plt.show()
+
+    # One dimensional plots with one parameter"
+    def plot1DParametric(x, y, xlabel, ylabel, parameters):
+        """Produces the plot of a one-dimensional quantity that depends on an external parameter.
+
+        Positional arguments:
+        x -- data for the x-axis (a numpy array)
+        y -- data for the y-axis (a two-dimensional numpy array)
+        xlabel -- label for the x-axis (a string)
+        ylabel -- label for the y-axis (a string)
+        parameters -- list of parameters for which the results should be plotted
+        """
+        numParameters = parameters.size
+        cmap = cm["viridis"]
+        for i in np.arange(numParameters):
+            color = cmap(1.0 * i / numParameters)
+            plt.plot(x, y[:, parameters[i]], color=color)
+        plt.xlabel(xlabel)
+        plt.ylabel(ylabel)
+        plt.show()
+
+
+# -----------------------------------------------------------------------
+# MPI class
+# -----------------------------------------------------------------------
+
+
+class MPI:
+    """Class to handle the calls to the MPI API"""
+
+    def __init__(self):
+        self.qpMPI = native.MPI
+
+    def getRank(self):
+        """Get rank of the process"""
+        return self.qpMPI.rank()
+
+    def isRoot(self):
+        """Check if the current process is root (rank 0)"""
+        return self.qpMPI.isRoot()
+
+    def barrier(self):
+        """Setup and MPI barrier"""
+        self.qpMPI.barrier()
+
+    def timer(self):
+        """Get wall time"""
+        return self.qpMPI.timer()
+
+    @staticmethod
+    def runOnlyOnRoot(func):
+        """Python decorator for all methods that have to be run only by root"""
+
+        @functools.wraps(func)
+        def wrapper(*args, **kwargs):
+            if MPI().isRoot():
+                return func(*args, **kwargs)
+
+        return wrapper
+
+    @staticmethod
+    def synchronizeRanks(func):
+        """Python decorator for all methods that need to rank synchronization"""
+
+        @functools.wraps(func)
+        def wrapper(*args, **kwargs):
+            func(*args, **kwargs)
+            MPI().barrier()
+
+        return wrapper
+
+    @staticmethod
+    def recordTime(func):
+        """Python decorator for all methods that have to be timed"""
+
+        @functools.wraps(func)
+        def wrapper(*args, **kwargs):
+            tic = MPI().timer()
+            func(*args, **kwargs)
+            toc = MPI().timer()
+            dt = toc - tic
+            hours = dt // 3600
+            minutes = (dt % 3600) // 60
+            seconds = dt % 60
+            if MPI().isRoot():
+                if hours > 0:
+                    print("Elapsed time: %d h, %d m, %d s." % (hours, minutes, seconds))
+                elif minutes > 0:
+                    print("Elapsed time: %d m, %d s." % (minutes, seconds))
+                else:
+                    print("Elapsed time: %.1f s." % seconds)
+
+        return wrapper

qupled-0.0.2/qupled.egg-info/PKG-INFO

@@ -0,0 +1,27 @@
+Metadata-Version: 2.1
+Name: qupled
+Version: 0.0.2
+Summary: qupled: a package to investigate quantum plasmas via the dielectric formalism
+Author-email: Federico Lucco Castello <federico.luccocastello@gmail.com>
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Operating System :: MacOS
+Classifier: Operating System :: POSIX :: Linux
+Classifier: License :: OSI Approved :: GNU General Public License v3 (GPLv3)
+Requires-Python: <3.13,>=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: matplotlib~=3.7
+Requires-Dist: numpy<2.0
+Requires-Dist: pandas~=2.0
+Requires-Dist: tables~=3.10
+Provides-Extra: testing
+Requires-Dist: pytest~=8.0; extra == "testing"
+Requires-Dist: pytest-mock~=3.12; extra == "testing"
+Provides-Extra: docs
+Requires-Dist: sphinx-rtd-theme~=2.0.0; extra == "docs"
+Requires-Dist: sphinxcontrib-applehelp~=2.0.0; extra == "docs"
+Requires-Dist: sphinxcontrib-devhelp~=2.0.0; extra == "docs"
+Requires-Dist: sphinxcontrib-htmlhelp~=2.1.0; extra == "docs"
+Requires-Dist: sphinxcontrib-jquery~=4.1; extra == "docs"
+Requires-Dist: sphinxcontrib-jsmath~=1.0.1; extra == "docs"
+Requires-Dist: sphinxcontrib-qthelp~=2.0.0; extra == "docs"
+Requires-Dist: sphinxcontrib-serializinghtml~=2.0.0; extra == "docs"

qupled-0.0.2/qupled.egg-info/SOURCES.txt

@@ -0,0 +1,13 @@
+MANIFEST.in
+pyproject.toml
+qupled/__init__.py
+qupled/classic.py
+qupled/quantum.py
+qupled/util.py
+qupled.egg-info/PKG-INFO
+qupled.egg-info/SOURCES.txt
+qupled.egg-info/dependency_links.txt
+qupled.egg-info/requires.txt
+qupled.egg-info/top_level.txt
+qupled/Darwin/qupled.so
+qupled/Linux/qupled.so

qupled-0.0.2/qupled.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

qupled-0.0.2/qupled.egg-info/requires.txt

@@ -0,0 +1,18 @@
+matplotlib~=3.7
+numpy<2.0
+pandas~=2.0
+tables~=3.10
+
+[docs]
+sphinx-rtd-theme~=2.0.0
+sphinxcontrib-applehelp~=2.0.0
+sphinxcontrib-devhelp~=2.0.0
+sphinxcontrib-htmlhelp~=2.1.0
+sphinxcontrib-jquery~=4.1
+sphinxcontrib-jsmath~=1.0.1
+sphinxcontrib-qthelp~=2.0.0
+sphinxcontrib-serializinghtml~=2.0.0
+
+[testing]
+pytest~=8.0
+pytest-mock~=3.12

qupled-0.0.2/qupled.egg-info/top_level.txt

@@ -0,0 +1 @@
+qupled

qupled-0.0.2/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+