qupled 1.3.2__cp312-cp312-macosx_14_0_arm64.whl

qupled/stls.py

@@ -0,0 +1,94 @@
+from __future__ import annotations
+
+import numpy as np
+
+from . import hf
+from . import native
+from . import output
+from . import rpa
+
+
+class Stls(rpa.Rpa):
+    """
+    Class used to solve the Stls scheme.
+    """
+
+    def __init__(self):
+        super().__init__()
+        self.results: Result = Result()
+        # Undocumented properties
+        self.native_scheme_cls = native.Stls
+        self.native_inputs_cls = native.StlsInput
+
+    @staticmethod
+    def get_initial_guess(run_id: int, database_name: str | None = None) -> Guess:
+        """Constructs an initial guess object by extracting the information from a database.
+
+        Args:
+            run_id: The unique identifier for the run whose data is to be retrieved.
+            database_name: The name of the database to query.
+                If None, the default database will be used.
+
+        Returns:
+            An instance of Guess containing the initial guess data.
+        """
+        names = ["wvg", "ssf"]
+        data = output.DataBase.read_results(run_id, database_name, names)
+        return Guess(data[names[0]], data[names[1]])
+
+
+class Input(rpa.Input):
+    """
+    Class used to manage the input for the :obj:`qupled.stls.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.guess: Guess = Guess()
+        """Initial guess. Default = ``stls.Guess()``"""
+        # Undocumented default values
+        self.theory: str = "STLS"
+
+
+class Result(hf.Result):
+    """
+    Class used to store the results for the :obj:`qupled.stls.Stls` class.
+    """
+
+    def __init__(self):
+        super().__init__()
+        self.error: float = None
+        """Residual error in the solution"""
+
+
+class Guess:
+
+    def __init__(self, wvg: np.ndarray = None, ssf: np.ndarray = None):
+        self.wvg = wvg
+        """ Wave-vector grid. Default = ``None``"""
+        self.ssf = ssf
+        """ Static structure factor. Default = ``None``"""
+
+    def to_native(self) -> native.Guess:
+        """
+        Converts the current object to a native `Guess` object.
+
+        This method iterates over the attributes of the current object and
+        assigns their values to a new `Guess` object. If an attribute's
+        value is `None`, it is replaced with an empty NumPy array.
+
+        Returns:
+            native.StlsGuess: A new instance of `Guess` with attributes
+            copied from the current object.
+        """
+        native_guess = native.Guess()
+        for attr, value in self.__dict__.items():
+            if value is not None:
+                setattr(native_guess, attr, value)
+        return native_guess

qupled/stlsiet.py

@@ -0,0 +1,97 @@
+from __future__ import annotations
+
+import numpy as np
+
+from . import native
+from . import output
+from . import stls
+
+
+class StlsIet(stls.Stls):
+    """
+    Class used to solve the StlsIet schemes.
+    """
+
+    def __init__(self):
+        super().__init__()
+        self.results: Result = Result()
+        self.native_scheme_cls = native.StlsIet
+        self.native_inputs_cls = native.StlsIetInput
+
+    @staticmethod
+    def get_initial_guess(run_id: str, database_name: str | None = None) -> Guess:
+        """
+        Retrieves the initial guess for a computation based on a specific run ID
+        from a database.
+
+        Args:
+            run_id: The unique identifier for the run whose data is to be retrieved.
+            database_name: The name of the database to query.
+                If None, the default database is used.
+
+        Returns:
+            Guess: An object containing the initial guess values, including results
+            and inputs extracted from the database.
+        """
+        names = ["wvg", "ssf", "lfc"]
+        results = output.DataBase.read_results(run_id, database_name, names)
+        return Guess(
+            results[names[0]],
+            results[names[1]],
+            results[names[2]],
+        )
+
+
+class Input(stls.Input):
+    """
+    Class used to manage the input for the :obj:`qupled.stlsiet.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"}:
+            raise ValueError("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``.
+        """
+        self.guess: Guess = Guess()
+        """Initial guess. Default = ``stlsiet.Guess()``"""
+
+
+class Result(stls.Result):
+    """
+    Class used to store the results for the :obj:`qupled.stlsiet.StlsIet` class.
+    """
+
+    def __init__(self):
+        super().__init__()
+        self.bf: np.ndarray = None
+        """Bridge function adder"""
+
+
+class Guess(stls.Guess):
+
+    def __init__(
+        self,
+        wvg: np.ndarray = None,
+        ssf: np.ndarray = None,
+        lfc: np.ndarray = None,
+    ):
+        super().__init__(wvg, ssf)
+        self.lfc = lfc
+        """ Local field correction. Default = ``None``"""

qupled/vsstls.py

@@ -0,0 +1,203 @@
+from __future__ import annotations
+
+import numpy as np
+
+from . import native
+from . import output
+from . import stls
+
+
+class VSStls(stls.Stls):
+    """
+    Class used to solve the VSStls scheme.
+    """
+
+    def __init__(self):
+        super().__init__()
+        self.results: Result = Result()
+        # Undocumented properties
+        self.native_scheme_cls = native.VSStls
+        self.native_inputs_cls = native.VSStlsInput
+
+    def compute(self, inputs: Input):
+        """
+        Solves the scheme and saves the results.
+
+        Args:
+            inputs: Input parameters.
+        """
+        self._fill_free_energy_integrand(inputs)
+        super().compute(inputs)
+
+    def _fill_free_energy_integrand(self, inputs: Input):
+        """
+        Fills the free energy integrand by computing missing state points for a given input.
+
+        This method iterates over the missing state points (coupling values) for the given input,
+        computes the required data for each coupling value, and updates the input data accordingly.
+        After processing, it restores the original coupling value in the input.
+
+        Args:
+            inputs: Input parameters.
+
+        Behavior:
+            - Identifies the missing state points (coupling values) that need to be computed.
+            - For each missing coupling value:
+                - Prints a message indicating the current computation.
+                - Updates the input coupling value to the current coupling.
+                - Performs the computation using the `compute` method.
+                - Updates the input data with the results of the computation.
+            - Restores the original target coupling value in the input after processing.
+        """
+        target_coupling = inputs.coupling
+        missing_state_points = self._get_missing_state_points(inputs)
+        do_subcall = len(missing_state_points) > 0
+        for coupling in missing_state_points:
+            print("---------------------------------------------------------------")
+            print(f"Subcall: solving {inputs.theory} scheme for rs = {coupling:.5f}")
+            inputs.coupling = coupling
+            self.compute(inputs)
+            self._update_input_data(inputs)
+        if do_subcall:
+            print("---------------------------------------------------------------")
+            print("Subcalls completed.")
+        inputs.coupling = target_coupling
+
+    @staticmethod
+    def _get_missing_state_points(inputs: Input) -> np.ndarray:
+        """
+        Calculate the missing state points in a grid based on the expected and actual values.
+
+        This function determines the points in the expected grid that are not present
+        in the actual grid of the free energy integrand. The precision of the comparison
+        is determined by the resolution of the coupling parameter.
+
+        Args:
+            inputs (Input): The input parameters.
+
+        Returns:
+            np.ndarray: An array of missing state points in the grid. If the actual grid
+            is `None`, the function returns the entire expected grid.
+        """
+        rs = inputs.coupling
+        drs = inputs.coupling_resolution
+        expected_grid = np.arange(drs, rs - 0.1 * drs, 3 * drs)
+        actual_grid = inputs.free_energy_integrand.grid
+        precision = int(np.abs(np.log10(drs)))
+        return (
+            np.setdiff1d(
+                np.round(expected_grid, precision), np.round(actual_grid, precision)
+            )
+            if actual_grid is not None
+            else expected_grid
+        )
+
+    def _update_input_data(self, inputs: Input):
+        """
+        Updates the input data with a free energy integrand object.
+
+        This method creates a `FreeEnergyIntegrand` instance using the results
+        stored in the current object and assigns it to the `free_energy_integrand`
+        attribute of the provided `inputs` object.
+
+        Args:
+            inputs: Input parameters.
+        """
+        free_energy_integrand = FreeEnergyIntegrand(
+            self.results.free_energy_grid, self.results.free_energy_integrand
+        )
+        inputs.free_energy_integrand = free_energy_integrand
+
+    # Get the free energy integrand from database
+    @staticmethod
+    def get_free_energy_integrand(
+        run_id: int, database_name: str | None = None
+    ) -> FreeEnergyIntegrand:
+        """
+        Retrieve the free energy integrand for a given run ID from the database.
+
+        Args:
+            run_id: The unique identifier for the run whose data is to be retrieved.
+            database_name: The name of the database to query.
+                If None, the default database will be used.
+
+        Returns:
+            native.FreeEnergyIntegrand: An object containing the free energy grid,
+            and integrand values retrieved from the database.
+        """
+        names = ["free_energy_grid", "free_energy_integrand"]
+        data = output.DataBase.read_results(run_id, database_name, names)
+        return FreeEnergyIntegrand(data[names[0]], data[names[1]])
+
+
+# Input class
+class Input(stls.Input):
+    """
+    Class used to manage the input for the :obj:`qupled.vsstls.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.coupling_resolution: float = 0.1
+        """Resolution of the coupling parameter grid. Default = ``0.1``"""
+        self.degeneracy_resolution: float = 0.1
+        """Resolution of the degeneracy parameter grid. Default = ``0.1``"""
+        self.error_alpha: float = 1.0e-3
+        """Minimum error for convergence in the free parameter. Default = ``1.0e-3``"""
+        self.iterations_alpha: int = 50
+        """Maximum number of iterations to determine the free parameter. Default = ``50``"""
+        self.free_energy_integrand: FreeEnergyIntegrand = FreeEnergyIntegrand()
+        """Pre-computed free energy integrand."""
+        self.threads: int = 9
+        """Number of threads. Default = ``9``"""
+        # Undocumented default values
+        self.theory: str = "VSSTLS"
+
+
+class Result(stls.Result):
+    """
+    Class used to store the results for the :obj:`qupled.vsstls.VSStls` class.
+    """
+
+    def __init__(self):
+        super().__init__()
+        self.free_energy_grid = None
+        """Free energy grid"""
+        self.free_energy_integrand = None
+        """Free energy integrand"""
+        self.alpha = None
+        """Free parameter"""
+
+
+class FreeEnergyIntegrand:
+
+    def __init__(
+        self,
+        grid: np.ndarray | None = None,
+        integrand: np.ndarray | None = None,
+    ):
+        self.grid = grid
+        """ Coupling parameter grid. Default = ``None``"""
+        self.integrand = integrand
+        """ Free energy integrand. Default = ``None``"""
+
+    def to_native(self) -> native.FreeEnergyIntegrand:
+        """
+        Converts the current object to a native `FreeEnergyIntegrand` instance.
+
+        This method creates an instance of `native.FreeEnergyIntegrand` and maps
+        the attributes of the current object to the corresponding attributes of
+        the native instance. If an attribute's value is `None`, it is replaced
+        with an empty NumPy array.
+
+        Returns:
+            native.FreeEnergyIntegrand: A new instance of `FreeEnergyIntegrand`
+            with attributes copied from the current object.
+        """
+        native_guess = native.FreeEnergyIntegrand()
+        for attr, value in self.__dict__.items():
+            if value is not None:
+                setattr(native_guess, attr, value)
+        return native_guess

qupled-1.3.2.dist-info/METADATA

@@ -0,0 +1,81 @@
+Metadata-Version: 2.4
+Name: qupled
+Version: 1.3.2
+Summary: qupled: a package to investigate quantum plasmas via the dielectric formalism
+Author-email: Federico Lucco Castello <federico.luccocastello@gmail.com>
+License-Expression: GPL-3.0-or-later
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Operating System :: MacOS
+Classifier: Operating System :: POSIX :: Linux
+Requires-Python: <3.14,>=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: blosc2~=3.2
+Requires-Dist: matplotlib~=3.7
+Requires-Dist: numpy<2.0
+Requires-Dist: SQLAlchemy~=2.0
+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"
+Dynamic: license-file
+
+# Qupled
+
+Qupled is a Python package designed for calculating the properties of quantum plasmas using the dielectric formalism. By combining a straightforward Python interface with the speed of C++, it allows for efficient and accurate computations of quantum plasma properties.
+
+![](https://github.com/fedluc/qupled/blob/master/examples/readme/qupled_animation_light.svg#gh-light-mode-only)
+![](https://github.com/fedluc/qupled/blob/master/examples/readme/qupled_animation_dark.svg#gh-dark-mode-only)
+
+## Status
+[![Build & Test](https://github.com/fedluc/qupled/actions/workflows/build-and-test.yml/badge.svg)](https://github.com/fedluc/qupled/actions/workflows/build-and-test.yml)
+[![Code Formatting](https://github.com/fedluc/qupled/actions/workflows/formatting.yml/badge.svg)](https://github.com/fedluc/qupled/actions/workflows/formatting.yml)
+[![Docs](https://img.shields.io/readthedocs/qupled/latest.svg?color=blue&style=flat)](https://qupled.readthedocs.io/en/latest/)
+![PyPI version](https://img.shields.io/pypi/v/qupled.svg?color=blue&label=PyPI&style=flat)
+![OS](https://img.shields.io/badge/OS-macOS%20%7C%20Linux-blue?style=flat-square)
+
+
+## Running 
+
+After [installation](https://qupled.readthedocs.io/en/latest/introduction.html#installing-qupled) qupled can be used as a regular Python package.
+
+```python
+# Solve the stls dielectric scheme for coupling = 10 and degeneracy 1.0
+import qupled.stls as stls
+inputs = stls.Input(10.0, 1.0)
+stls.Stls().compute(inputs)
+```
+
+## Documentation
+
+More detailed information on the package together with a list of examples is available in the [documentation](http://qupled.readthedocs.io/).
+
+## Publications
+
+Qupled has been used in the following publications:
+
+<ol>
+  <li>
+   <a href="https://onlinelibrary.wiley.com/doi/10.1002/ctpp.70014">Tolias, P., Kalkavouras, F., Dornheim, T.  &#38; Lucco Castello, F. (2025). Dynamic Properties of the Warm Dense Uniform Electron Gas With the qSTLS Dielectric Scheme. <i>Contributions to Plasma Physics</i>, 0:e70014</a>
+  </li>
+  <li>
+    <a href="https://journals.aps.org/prb/abstract/10.1103/PhysRevB.109.125134">Tolias, P., Lucco Castello, F., Kalkavouras, F., &#38; Dornheim, T. (2024). Revisiting the Vashishta-Singwi dielectric scheme for the warm dense uniform electron fluid. <i>Physical Review B</i>, <i>109</i>(12)</a>
+  </li>
+  <li>
+    <a href="https://pubs.aip.org/aip/jcp/article/158/14/141102/2877795/Quantum-version-of-the-integral-equation-theory">Tolias, P., Lucco Castello, F., &#38; Dornheim, T. (2023). Quantum version of the integral equation theory-based dielectric scheme for strongly coupled electron liquids. <i>The Journal of Chemical Physics</i>, <i>158</i>(14)</a>
+  </li>
+  <li>
+    <a href="https://iopscience.iop.org/article/10.1209/0295-5075/ac7166/meta">Lucco Castello, F., Tolias, P., &#38; Dornheim, T. (2022). Classical bridge functions in classical and quantum plasma liquids. <i>Europhysics Letters</i>, <i>138</i>(4)</a>
+  </li>
+  <li>
+    <a href="https://pubs.aip.org/aip/jcp/article/155/13/134115/353165/Integral-equation-theory-based-dielectric-scheme">Tolias, P., Lucco Castello, F., &#38; Dornheim, T. (2021). Integral equation theory based dielectric scheme for strongly coupled electron liquids. <i>The Journal of Chemical Physics</i>, <i>155</i>(13)</a>
+  </li>
+</ol>

qupled-1.3.2.dist-info/RECORD

@@ -0,0 +1,24 @@
+qupled-1.3.2.dist-info/RECORD,,
+qupled-1.3.2.dist-info/WHEEL,sha256=VrhWOWJdu4wN9IKhAFBqWPMo6yuww-SFg9GbWc0qbmI,136
+qupled-1.3.2.dist-info/top_level.txt,sha256=HLJfvnCPZQVptCRuekWA_3Z98SMkCNCXViGiGh8VenA,7
+qupled-1.3.2.dist-info/METADATA,sha256=b6IvBcRlZAtzvKpYTbKw6EpASENUMvRTXQNlrDjF4wI,4559
+qupled-1.3.2.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
+qupled/qstls.py,sha256=m-8_81ZHzV9VKkckACGASqF0rx38ho3hSibK9FbVgXs,2465
+qupled/native.cpython-312-darwin.so,sha256=4N1Qg9hZJLqhmn_2dh9xQ9cI-YEd9JJ1_WmW_AUOxsQ,691696
+qupled/rpa.py,sha256=RQ5wUTwoRnDqRzWO877OHgG2rcgYbSGBqn0PR3E4Uxw,613
+qupled/database.py,sha256=IDgY6uvxdg5f5SVxnvWzgeB5Zi7mR6tHEFnU0m3Y_xI,25027
+qupled/__init__.py,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
+qupled/stlsiet.py,sha256=pYDCKh4wwfOvw7BanjfspNMAVp2xj4b2h09pm65jLgk,2982
+qupled/qstlsiet.py,sha256=W_N7HQ4538HKR37CxJpxfYlqGM-rarFbVmRkP60-N90,1112
+qupled/esa.py,sha256=ksFZJ3u7VF3OxffxAR7aGjZp8Zy2SeNQ8r2xFjjqQwc,613
+qupled/mpi.py,sha256=Gbu6OlHvgA4q54pdIxFS16vNTIiKuF9o7aMuXka0tlg,1892
+qupled/stls.py,sha256=B843hdgNAVr761Fo2lmzJSmdsPCu2LIoASNSh2UeKg4,2951
+qupled/vsstls.py,sha256=y83EPv_v3DLVyydWi2IPnzYPOP3qUKzrvc9MrwxIMgU,7723
+qupled/qvsstls.py,sha256=Jn98Ht9sK-dYIYvxhGfM5s-NIktjQcYGc7UD01hw0_8,1748
+qupled/output.py,sha256=VP_7oKPuULYa0UB-wX_J_cLnGd2mZZxrYeeTpNY-iwE,3602
+qupled/hf.py,sha256=2hKcYny6iLvVs5-M1NtmU6QAg_-u7RWZgS46OnhcWkc,10082
+qupled/.dylibs/libgsl.28.dylib,sha256=rcTB771UsiEC1W_E5mVMYKo6G91p0OD5GaUssM8gfk8,2241424
+qupled/.dylibs/libomp.dylib,sha256=Ic_m8yVNxvjHQ-51C9MX9Bzl0wJAEsBdkx4V0_P_z7Y,735616
+qupled/.dylibs/libgslcblas.0.dylib,sha256=3ATUzchJ3MFYqtB5KC07P7gu8g-GTlQ62fUwbNrZqMY,239760
+qupled/.dylibs/libSQLiteCpp.0.dylib,sha256=e2Cq30wVtP5ED40t6Rjj3mp1DfYh34mEO_fCsdt6QlQ,94368
+qupled/.dylibs/libsqlite3.3.50.1.dylib,sha256=Ha5JC9TLmJglwOd4iBR8PACdcEZ5DW_iJwfNAGWQHBw,1241152

qupled-1.3.2.dist-info/WHEEL

@@ -0,0 +1,6 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.9.0)
+Root-Is-Purelib: false
+Tag: cp312-cp312-macosx_14_0_arm64
+Generator: delocate 0.13.0
+