qupled 1.3.3__cp310-cp310-macosx_14_0_arm64.whl → 1.3.4__cp310-cp310-macosx_14_0_arm64.whl

qupled/mpi.py

@@ -1,69 +1,104 @@
-import functools
-
-from qupled import native
-
-
-class MPI:
-    """Class to handle the calls to the MPI API"""
-
-    def rank(self):
-        """Get rank of the process"""
-        return native.MPI.rank()
-
-    def is_root(self):
-        """Check if the current process is root (rank 0)"""
-        return native.MPI.is_root()
-
-    def barrier(self):
-        """Setup an MPI barrier"""
-        native.MPI.barrier()
-
-    def timer(self):
-        """Get wall time"""
-        return native.MPI.timer()
-
-    @staticmethod
-    def run_only_on_root(func):
-        """Python decorator for all methods that have to be run only by root"""
-
-        @functools.wraps(func)
-        def wrapper(*args, **kwargs):
-            if native.MPI.is_root():
-                return func(*args, **kwargs)
-
-        return wrapper
-
-    @staticmethod
-    def synchronize_ranks(func):
-        """Python decorator for all methods that need rank synchronization"""
-
-        @functools.wraps(func)
-        def wrapper(*args, **kwargs):
-            func(*args, **kwargs)
-            native.MPI.barrier()
-
-        return wrapper
-
-    @staticmethod
-    def record_time(func):
-        """Python decorator for all methods that have to be timed"""
-
-        @functools.wraps(func)
-        def wrapper(*args, **kwargs):
-            mpi = native.MPI
-            tic = mpi.timer()
-            func(*args, **kwargs)
-            toc = mpi.timer()
-            dt = toc - tic
-            hours = dt // 3600
-            minutes = (dt % 3600) // 60
-            seconds = dt % 60
-            if mpi.is_root():
-                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
+import json
+import subprocess
+import shutil
+
+from pathlib import Path
+from . import native
+
+# MPI command
+MPI_COMMAND = "mpiexec"
+
+# Temporary files used for MPI executions
+INPUT_FILE = Path("input.json")
+RESULT_FILE = Path("results.json")
+STATUS_FILE = Path("status.json")
+
+
+def launch_mpi_execution(module, nproc):
+    """
+    Launches the execution of a Python module using MPI if available, otherwise defaults to serial execution.
+
+    Args:
+        module (str): The name of the Python module to execute (as used with the '-m' flag).
+        nproc (int): The number of processes to use for MPI execution.
+
+    Behavior:
+        - Checks if the MPI command is available and if native MPI usage is enabled.
+        - If MPI is available, runs the module with the specified number of processes using MPI.
+        - If MPI is not available, prints a warning and runs the module in serial mode.
+
+    Raises:
+        subprocess.CalledProcessError: If the subprocess execution fails.
+    """
+    call_mpi = shutil.which(MPI_COMMAND) is not None and native.uses_mpi
+    if call_mpi:
+        subprocess.run(
+            [MPI_COMMAND, "-n", str(nproc), "python", "-m", module], check=True
+        )
+    else:
+        print("WARNING: Could not call MPI, defaulting to serial execution.")
+        subprocess.run(["python", "-m", module], check=True)
+
+
+def write_inputs(inputs):
+    """
+    Writes the input data to the INPUT_FILE in JSON format.
+    """
+    with INPUT_FILE.open("w") as f:
+        json.dump(inputs.to_dict(), f)
+
+
+def read_inputs(InputCls):
+    """
+    Reads input data from a predefined input file and constructs an instance of the specified input class.
+    """
+    with INPUT_FILE.open() as f:
+        input_dict = json.load(f)
+    return InputCls.from_dict(input_dict)
+
+
+def write_results(scheme, ResultCls):
+    """
+    Writes the results of a computation to a JSON file if the current process is the root.
+    """
+    if scheme.is_root:
+        results = ResultCls()
+        results.from_native(scheme)
+        with RESULT_FILE.open("w") as f:
+            json.dump(results.to_dict(), f)
+
+
+def read_results(ResultsCls):
+    """
+    Reads results from a JSON file and returns an instance of the specified ResultsCls.
+    """
+    with RESULT_FILE.open() as f:
+        result_dict = json.load(f)
+    return ResultsCls.from_dict(result_dict)
+
+
+def write_status(scheme, status):
+    """
+    Writes the status of a computation to a JSON file if the current process is the root.
+    """
+    if scheme.is_root:
+        with STATUS_FILE.open("w") as f:
+            json.dump(status, f)
+
+
+def read_status():
+    """
+    Reads status from a JSON file and returns an instance of the specified ResultsCls.
+    """
+    with STATUS_FILE.open() as f:
+        status = json.load(f)
+    return status
+
+
+def clean_files():
+    """
+    Removes the input and result files if they exist.
+    """
+    for file in [INPUT_FILE, RESULT_FILE, STATUS_FILE]:
+        if file.exists():
+            file.unlink()

qupled/qstls.py

@@ -2,20 +2,22 @@ from __future__ import annotations
 
 from . import database
 from . import native
+from . import serialize
 from . import stls
 
 
-class Qstls(stls.Stls):
+class Solver(stls.Solver):
     """
     Class used to solve the Qstls scheme.
     """
 
+    # Native classes used to solve the scheme
+    native_scheme_cls = native.Qstls
+    native_inputs_cls = native.QstlsInput
+
     def __init__(self):
         super().__init__()
         self.results: stls.Result = stls.Result()
-        # Undocumented properties
-        self.native_scheme_cls = native.Qstls
-        self.native_inputs_cls = native.QstlsInput
 
     def compute(self, inputs: Input):
         self.find_fixed_adr_in_database(inputs)
@@ -55,14 +57,15 @@ class Qstls(stls.Stls):
                 return
 
 
-# Input class
+@serialize.serializable_dataclass
 class Input(stls.Input):
     """
     Class used to manage the input for the :obj:`qupled.qstls.Qstls` class.
     """
 
-    def __init__(self, coupling: float, degeneracy: float):
-        super().__init__(coupling, degeneracy)
-        # Undocumented default values
-        self.fixed_run_id: int | None = None
-        self.theory = "QSTLS"
+    fixed_run_id: int | None = None
+    theory: str = "QSTLS"
+
+
+if __name__ == "__main__":
+    Solver.run_mpi_worker(Input, stls.Result)

qupled/qstlsiet.py

@@ -2,36 +2,39 @@ from __future__ import annotations
 
 from . import native
 from . import qstls
+from . import serialize
 from . import stlsiet
 
 
-class QstlsIet(qstls.Qstls):
+class Solver(qstls.Solver):
     """
     Class used to solve the Qstls-IET schemes.
     """
 
+    # Native classes used to solve the scheme
+    native_scheme_cls = native.QstlsIet
+    native_inputs_cls = native.QstlsIetInput
+
     def __init__(self):
         super().__init__()
         self.results: stlsiet.Result = stlsiet.Result()
-        self.native_scheme_cls = native.QstlsIet
-        self.native_inputs_cls = native.QstlsIetInput
 
     @staticmethod
     def get_initial_guess(
         run_id: str, database_name: str | None = None
     ) -> stlsiet.Guess:
-        return stlsiet.StlsIet.get_initial_guess(run_id, database_name)
+        return stlsiet.Solver.get_initial_guess(run_id, database_name)
 
 
-# Input class
+@serialize.serializable_dataclass
 class Input(stlsiet.Input, qstls.Input):
     """
     Class used to manage the input for the :obj:`qupled.qstlsiet.QStlsIet` class.
     Accepted theories: ``QSTLS-HNC``, ``QSTLS-IOI`` and ``QSTLS-LCT``.
     """
 
-    def __init__(self, coupling: float, degeneracy: float, theory: str):
-        super().__init__(coupling, degeneracy, "STLS-HNC")
-        if theory not in {"QSTLS-HNC", "QSTLS-IOI", "QSTLS-LCT"}:
-            raise ValueError("Invalid dielectric theory")
-        self.theory = theory
+    allowed_theories = {"QSTLS-HNC", "QSTLS-IOI", "QSTLS-LCT"}
+
+
+if __name__ == "__main__":
+    Solver.run_mpi_worker(Input, stlsiet.Result)

qupled/qvsstls.py

@@ -3,19 +3,21 @@ from __future__ import annotations
 from . import native
 from . import qstls
 from . import vsstls
+from . import serialize
 
 
-class QVSStls(vsstls.VSStls):
+class Solver(vsstls.Solver):
     """
     Class used to solve the QVStls scheme.
     """
 
+    # Native classes used to solve the scheme
+    native_scheme_cls = native.QVSStls
+    native_inputs_cls = native.QVSStlsInput
+
     def __init__(self):
         super().__init__()
         self.results: vsstls.Result = vsstls.Result()
-        # Undocumented properties
-        self.native_scheme_cls = native.QVSStls
-        self.native_inputs_cls = native.QVSStlsInput
 
     def compute(self, inputs: Input):
         """
@@ -24,7 +26,7 @@ class QVSStls(vsstls.VSStls):
         Args:
             inputs: Input parameters.
         """
-        qstls.Qstls.find_fixed_adr_in_database(self, inputs)
+        qstls.Solver.find_fixed_adr_in_database(self, inputs)
         super().compute(inputs)
 
     def _update_input_data(self, inputs: Input):
@@ -46,14 +48,14 @@ class QVSStls(vsstls.VSStls):
             inputs.fixed_run_id = self.run_id
 
 
-# Input class
+@serialize.serializable_dataclass
 class Input(vsstls.Input, qstls.Input):
     """
     Class used to manage the input for the :obj:`qupled.qvsstls.QVSStls` class.
     """
 
-    def __init__(self, coupling: float, degeneracy: float):
-        vsstls.Input.__init__(self, coupling, degeneracy)
-        qstls.Input.__init__(self, coupling, degeneracy)
-        # Undocumented default values
-        self.theory: str = "QVSSTLS"
+    theory: str = "QVSSTLS"
+
+
+if __name__ == "__main__":
+    Solver.run_mpi_worker(Input, vsstls.Result)

qupled/rpa.py

@@ -2,26 +2,30 @@ from __future__ import annotations
 
 from . import hf
 from . import native
+from . import serialize
 
 
-class Rpa(hf.HF):
+class Solver(hf.Solver):
     """
     Class used to solve the RPA scheme.
     """
 
+    # Native classes used to solve the scheme
+    native_scheme_cls = native.Rpa
+
     def __init__(self):
         super().__init__()
         self.results: hf.Result = hf.Result()
-        # Undocumented properties
-        self.native_scheme_cls = native.Rpa
 
 
+@serialize.serializable_dataclass
 class Input(hf.Input):
     """
     Class used to manage the input for the :obj:`qupled.rpa.Rpa` class.
     """
 
-    def __init__(self, coupling: float, degeneracy: float):
-        super().__init__(coupling, degeneracy)
-        # Undocumented default values
-        self.theory = "RPA"
+    theory: str = "RPA"
+
+
+if __name__ == "__main__":
+    Solver.run_mpi_worker(Input, hf.Result)

qupled/serialize.py

@@ -0,0 +1,43 @@
+import numpy as np
+
+from dataclasses import dataclass
+from typing import get_type_hints
+
+
+def serializable_dataclass(cls):
+
+    cls = dataclass(cls)
+
+    def to_dict(self):
+        result = {}
+        for key, value in self.__dict__.items():
+            if hasattr(value, "to_dict") and callable(value.to_dict):
+                result[key] = value.to_dict()
+            elif isinstance(value, np.ndarray):
+                result[key] = value.tolist()
+            else:
+                result[key] = value
+        return result
+
+    @classmethod
+    def from_dict(cls, d):
+        obj = cls.__new__(cls)
+        annotations = get_type_hints(cls)
+        for key, value in d.items():
+            expected_type = annotations.get(key)
+            from_dict_fn = getattr(expected_type, "from_dict", None)
+            convert_to_np_array = expected_type is np.ndarray and isinstance(
+                value, list
+            )
+            call_from_dict = callable(from_dict_fn) and isinstance(value, dict)
+            if convert_to_np_array:
+                setattr(obj, key, np.array(value))
+            elif call_from_dict:
+                setattr(obj, key, from_dict_fn(value))
+            else:
+                setattr(obj, key, value)
+        return obj
+
+    cls.to_dict = to_dict
+    cls.from_dict = from_dict
+    return cls

qupled/stls.py

@@ -1,24 +1,27 @@
 from __future__ import annotations
 
+from dataclasses import field
 import numpy as np
 
 from . import hf
 from . import native
 from . import output
 from . import rpa
+from . import serialize
 
 
-class Stls(rpa.Rpa):
+class Solver(rpa.Solver):
     """
     Class used to solve the Stls scheme.
     """
 
+    # Native classes used to solve the scheme
+    native_scheme_cls = native.Stls
+    native_inputs_cls = native.StlsInput
+
     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:
@@ -37,43 +40,39 @@ class Stls(rpa.Rpa):
         return Guess(data[names[0]], data[names[1]])
 
 
+@serialize.serializable_dataclass
 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"
+    error: float = 1.0e-5
+    """Minimum error for convergence. Default = ``1.0e-5``"""
+    mixing: float = 1.0
+    """Mixing parameter. Default = ``1.0``"""
+    iterations: int = 1000
+    """Maximum number of iterations. Default = ``1000``"""
+    guess: Guess = field(default_factory=lambda: Guess())
+    """Initial guess. Default = ``stls.Guess()``"""
+    theory: str = "STLS"
 
 
+@serialize.serializable_dataclass
 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"""
+    error: float = None
+    """Final error of the scheme. Default = ``None``"""
 
 
+@serialize.serializable_dataclass
 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``"""
+    wvg: np.ndarray = None
+    """Wave-vector grid. Default = ``None``"""
+    ssf: np.ndarray = None
+    """Static structure factor. Default = ``None``"""
 
     def to_native(self) -> native.Guess:
         """
@@ -92,3 +91,7 @@ class Guess:
             if value is not None:
                 setattr(native_guess, attr, value)
         return native_guess
+
+
+if __name__ == "__main__":
+    Solver.run_mpi_worker(Input, Result)

qupled/stlsiet.py

@@ -1,22 +1,26 @@
 from __future__ import annotations
 
+from dataclasses import field
 import numpy as np
 
 from . import native
 from . import output
 from . import stls
+from . import serialize
 
 
-class StlsIet(stls.Stls):
+class Solver(stls.Solver):
     """
     Class used to solve the StlsIet schemes.
     """
 
+    # Native classes used to solve the scheme
+    native_scheme_cls = native.StlsIet
+    native_inputs_cls = native.StlsIetInput
+
     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:
@@ -42,19 +46,15 @@ class StlsIet(stls.Stls):
         )
 
 
+@serialize.serializable_dataclass
 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: str = "standard"
+    r"""
         Mapping for the classical-to-quantum coupling parameter
         :math:`\Gamma` used in the iet schemes. Allowed options include:
 
@@ -69,29 +69,38 @@ class Input(stls.Input):
         the ground state they can differ significantly (the standard
         mapping diverges). Default = ``standard``.
         """
-        self.guess: Guess = Guess()
-        """Initial guess. Default = ``stlsiet.Guess()``"""
+    guess: Guess = field(default_factory=lambda: Guess())
+    allowed_theories = {"STLS-HNC", "STLS-IOI", "STLS-LCT"}
+
+    def __post_init__(self):
+        if self.is_default_theory():
+            raise ValueError(
+                f"Missing dielectric theory, choose among {self.allowed_theories} "
+            )
+        if self.theory not in self.allowed_theories:
+            raise ValueError(
+                f"Invalid dielectric theory {self.theory}, choose among {self.allowed_theories}"
+            )
+
+    def is_default_theory(self) -> bool:
+        return self.theory == Input.__dataclass_fields__["theory"].default
 
 
+@serialize.serializable_dataclass
 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"""
+    bf: np.ndarray = None
+    """Bridge function adder"""
 
 
+@serialize.serializable_dataclass
 class Guess(stls.Guess):
+    lfc: np.ndarray = None
+    """ Local field correction. Default = ``None``"""
+
 
-    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``"""
+if __name__ == "__main__":
+    Solver.run_mpi_worker(Input, Result)

qupled/timer.py

@@ -0,0 +1,33 @@
+import time
+
+
+def timer(func):
+    """
+    A decorator that measures and prints the execution time of the decorated function.
+
+    The elapsed time is displayed in hours, minutes, and seconds as appropriate.
+
+    Args:
+        func (callable): The function whose execution time is to be measured.
+
+    Returns:
+        callable: A wrapper function that executes the original function and prints the elapsed time.
+    """
+
+    def wrapper(*args, **kwargs):
+        tic = time.perf_counter()
+        result = func(*args, **kwargs)
+        toc = time.perf_counter()
+        dt = toc - tic
+        hours = int(dt // 3600)
+        minutes = int((dt % 3600) // 60)
+        seconds = dt % 60
+        if hours > 0:
+            print(f"Elapsed time: {hours} h, {minutes} m, {seconds:.1f} s.")
+        elif minutes > 0:
+            print(f"Elapsed time: {minutes} m, {seconds:.1f} s.")
+        else:
+            print(f"Elapsed time: {seconds:.1f} s.")
+        return result
+
+    return wrapper