qupled 1.3.3__tar.gz → 1.3.5__tar.gz

{qupled-1.3.3 → qupled-1.3.5}/.gitignore

@@ -1,5 +1,5 @@
 *.DS_Store
-*.db
+*.db*
 *.vscode
 *#
 *~

{qupled-1.3.3 → qupled-1.3.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: qupled
-Version: 1.3.3
+Version: 1.3.5
 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

{qupled-1.3.3 → qupled-1.3.5}/docs/examples.rst

@@ -90,11 +90,10 @@ The quantum schemes can have a significant computational cost. There are two str
 that can be employed to speed up the calculations:
 
 * *Parallelization*: qupled supports both multithreaded calculations with OpenMP and
-  multiprocessors computations with MPI. The number of OpenMP threads
-  can be specified in input (as shown in :ref:`this example<solvingQuantumSchemes>`).
-  Multiprocessor computations can be performed by running qupled as an MPI application:
-  ``mpirun -n <number_of_cores> python3 <script_using_qupled>``. OpenMP and MPI can be
-  used concurrently by setting both the number of threads and the number of cores.
+  multiprocessors computations with MPI. OpenMP and MPI can be
+  used concurrently by setting both the number of threads and the number of cores in the 
+  input dataclasses. Use `threads` to set the number of OMP threads and `processes` to
+  set the number of MPI processes.
  
 * *Pre-computation*: The calculations for the quantum schemes can be made significantly
   faster if part of the calculation of the auxiliary density response can be skipped.

{qupled-1.3.3 → qupled-1.3.5}/docs/qupled.rst

@@ -35,7 +35,7 @@ The solution parameters are specified with a dedicated class called :obj:`qupled
 After the solution is completed the results are stored in an object :obj:`qupled.hf.Result` 
 and written to the output database.
 
-.. autoclass:: qupled.hf.HF
+.. autoclass:: qupled.hf.Solver
     :members:
 
 .. autoclass:: qupled.hf.Input
@@ -55,7 +55,7 @@ The solution parameters are specified with a dedicated class called :obj:`qupled
 After the solution is completed the results are stored in an object :obj:`qupled.hf.Result` 
 and written to the output database.
 
-.. autoclass:: qupled.rpa.Rpa
+.. autoclass:: qupled.rpa.Solver
     :show-inheritance:
     :members:
 
@@ -72,7 +72,7 @@ The solution parameters are specified with a dedicated class called :obj:`qupled
 After the solution is completed the results are stored in an object :obj:`qupled.stls.Result` 
 and written to the output database.
 
-.. autoclass:: qupled.stls.Stls
+.. autoclass:: qupled.stls.Solver
     :show-inheritance:
     :members:
 
@@ -97,7 +97,7 @@ The solution parameters are specified with a dedicated class called :obj:`qupled
 After the solution is completed the results are stored in an object :obj:`qupled.stlsiet.Result` 
 and written to the output database.
 
-.. autoclass:: qupled.stlsiet.StlsIet
+.. autoclass:: qupled.stlsiet.Solver
     :show-inheritance:
     :members:
 
@@ -122,7 +122,7 @@ The solution parameters are specified with a dedicated class called :obj:`qupled
 After the solution is completed the results are stored in an object :obj:`qupled.vsstls.Result` 
 and written to the output database.
 
-.. autoclass:: qupled.vsstls.VSStls
+.. autoclass:: qupled.vsstls.Solver
     :show-inheritance:
     :members:
     :exclude-members: get_free_energy_integrand
@@ -151,7 +151,7 @@ The solution parameters are specified with a dedicated class called :obj:`qupled
 After the solution is completed the results are stored in an object :obj:`qupled.hf.Result` 
 and written to the output database.
 
-.. autoclass:: qupled.esa.ESA
+.. autoclass:: qupled.esa.Solver
     :show-inheritance:
     :members:
 
@@ -171,7 +171,7 @@ TThe solution parameters are specified with a dedicated class called :obj:`quple
 After the solution is completed the results are stored in an object :obj:`qupled.qstls.Result` 
 and written to the output database.
 
-.. autoclass:: qupled.qstls.Qstls
+.. autoclass:: qupled.qstls.Solver
     :show-inheritance:
     :members:
     :exclude-members: find_fixed_adr_in_database
@@ -190,7 +190,7 @@ The solution parameters are specified with a dedicated class called :obj:`qupled
 After the solution is completed the results are stored in an object :obj:`qupled.qstlsiet.Result` 
 and written to the output database.
 
-.. autoclass:: qupled.qstlsiet.QstlsIet
+.. autoclass:: qupled.qstlsiet.Solver
     :show-inheritance:
     :members:
     :exclude-members: find_fixed_adr_in_database
@@ -207,7 +207,7 @@ for the solution of the QVStls schemes. The solution parameters are specified wi
 called :obj:`qupled.qvsstls.Input`. After the solution is completed the results are stored in an 
 object :obj:`qupled.qvsstls.Result` and written to the output database.
 
-.. autoclass:: qupled.qvsstls.QVSStls
+.. autoclass:: qupled.qvsstls.Solver
     :show-inheritance:
     :members:
     :exclude-members: get_free_energy_integrand

{qupled-1.3.3 → qupled-1.3.5}/examples/docs/fixed_adr.py

@@ -1,13 +1,10 @@
 import qupled.qstls as qstls
 
 # Define the object used to solve the scheme
-scheme = qstls.Qstls()
+scheme = qstls.Solver()
 
 # Define the input parameters
-inputs = qstls.Input(10.0, 1.0)
-inputs.mixing = 0.5
-inputs.matsubara = 16
-inputs.threads = 16
+inputs = qstls.Input(10.0, 1.0, mixing=0.5, matsubara=16, threads=16)
 
 # Solve the QSTLS scheme and store the internal energy (v1 calculation)
 scheme.compute(inputs)

{qupled-1.3.3 → qupled-1.3.5}/examples/docs/initial_guess_stls.py

@@ -1,11 +1,10 @@
 import qupled.stls as stls
 
 # Define the object used to solve the scheme
-scheme = stls.Stls()
+scheme = stls.Solver()
 
 # Define the input parameters
-inputs = stls.Input(10.0, 1.0)
-inputs.mixing = 0.2
+inputs = stls.Input(10.0, 1.0, mixing=0.2)
 
 # Solve scheme
 scheme.compute(inputs)

{qupled-1.3.3 → qupled-1.3.5}/examples/docs/solve_quantum_schemes.py

@@ -2,27 +2,28 @@ import qupled.qstls as qstls
 import qupled.qstlsiet as qstlsiet
 
 # Define a Qstls object to solve the QSTLS scheme
-scheme = qstls.Qstls()
+scheme = qstls.Solver()
 
 # Define the input parameters
-inputs = qstls.Input(10.0, 1.0)
-inputs.mixing = 0.5
-inputs.matsubara = 16
-inputs.threads = 16
+inputs = qstls.Input(10.0, 1.0, mixing=0.5, matsubara=16, threads=16)
 
 # Solve the QSTLS scheme
 scheme.compute(inputs)
 print(scheme.results.uint)
 
 # Define a QstlsIet object to solve the QSTLS-IET scheme
-scheme = qstlsiet.QstlsIet()
+scheme = qstlsiet.Solver()
 
 # Define the input parameters for one of the QSTLS-IET schemes
-inputs = qstlsiet.Input(10.0, 1.0, "QSTLS-LCT")
-inputs.mixing = 0.5
-inputs.matsubara = 16
-inputs.threads = 16
-inputs.integral_strategy = "segregated"
+inputs = qstlsiet.Input(
+    10.0,
+    1.0,
+    theory="QSTLS-LCT",
+    mixing=0.5,
+    matsubara=16,
+    threads=16,
+    integral_strategy="segregated",
+)
 
 # solve the QSTLS-IET scheme
 scheme.compute(inputs)

{qupled-1.3.3 → qupled-1.3.5}/examples/docs/solve_qvsstls.py

@@ -1,15 +1,12 @@
 import qupled.qvsstls as qvsstls
 
 # Define the object used to solve the scheme
-scheme = qvsstls.QVSStls()
+scheme = qvsstls.Solver()
 
 # Define the input parameters
-inputs = qvsstls.Input(1.0, 1.0)
-inputs.mixing = 0.5
-inputs.matsubara = 16
-inputs.alpha = [-0.2, 0.4]
-inputs.iterations = 100
-inputs.threads = 16
+inputs = qvsstls.Input(
+    1.0, 1.0, mixing=0.5, matsubara=16, alpha=[-0.2, 0.4], iterations=100, threads=16
+)
 
 # Solve scheme for rs = 1.0
 scheme.compute(inputs)

{qupled-1.3.3 → qupled-1.3.5}/examples/docs/solve_rpa_and_esa.py

@@ -5,12 +5,12 @@ from qupled.output import DataBase
 
 # Define an Rpa object to solve the RPA scheme
 print("######### Solving the RPA scheme #########")
-rpa_scheme = rpa.Rpa()
+rpa_scheme = rpa.Solver()
 rpa_scheme.compute(rpa.Input(10.0, 1.0))
 
 # Define an ESA object to solve the ESA scheme
 print("######### Solving the ESA scheme #########")
-esa_scheme = esa.ESA()
+esa_scheme = esa.Solver()
 esa_scheme.compute(esa.Input(10.0, 1.0))
 
 # Retrieve information from the output files

{qupled-1.3.3 → qupled-1.3.5}/examples/docs/solve_stls.py

@@ -2,11 +2,10 @@ import qupled.stls as stls
 from qupled.output import DataBase
 
 # Define the object used to solve the scheme
-scheme = stls.Stls()
+scheme = stls.Solver()
 
 # Define the input parameters
-inputs = stls.Input(10.0, 1.0)
-inputs.mixing = 0.5
+inputs = stls.Input(10.0, 1.0, mixing=0.5)
 
 # Solve scheme
 scheme.compute(inputs)

{qupled-1.3.3 → qupled-1.3.5}/examples/docs/solve_stls_iet.py

@@ -1,12 +1,10 @@
 import qupled.stlsiet as stlsiet
 
 # Define the object used to solve the scheme
-scheme = stlsiet.StlsIet()
+scheme = stlsiet.Solver()
 
 # Define the input parameters
-inputs = stlsiet.Input(10.0, 1.0, "STLS-HNC")
-inputs.mixing = 0.5
-
+inputs = stlsiet.Input(10.0, 1.0, theory="STLS-HNC", mixing=0.5)
 # Solve scheme with HNC bridge function
 scheme.compute(inputs)
 

{qupled-1.3.3 → qupled-1.3.5}/examples/docs/solve_vsstls.py

@@ -1,12 +1,10 @@
 import qupled.vsstls as vsstls
 
 # Define the object used to solve the scheme
-scheme = vsstls.VSStls()
+scheme = vsstls.Solver()
 
 # Define the input parameters
-inputs = vsstls.Input(2.0, 1.0)
-inputs.mixing = 0.5
-inputs.alpha = [-0.2, 0.2]
+inputs = vsstls.Input(2.0, 1.0, mixing=0.5, alpha=[-0.2, 0.2])
 
 # Compute
 scheme.compute(inputs)

{qupled-1.3.3 → qupled-1.3.5}/examples/readme/create_cover.py

@@ -49,7 +49,7 @@ def create_svg_files():
 
 
 def get_plot_data():
-    scheme: qstls.Qstls = None
+    scheme: qstls.Solver = None
     error: list[float] = []
     while scheme is None or scheme.results.error > 1e-5:
         scheme = solve_qstls(scheme.run_id if scheme is not None else scheme)
@@ -57,7 +57,7 @@ def get_plot_data():
     return scheme, error
 
 
-def create_one_svg_file(darkmode: bool, scheme: qstls.Qstls, error: np.array):
+def create_one_svg_file(darkmode: bool, scheme: qstls.Solver, error: np.array):
     # Get plot settings
     settings = PlotSettings(darkmode)
     # Set style
@@ -80,7 +80,7 @@ def create_one_svg_file(darkmode: bool, scheme: qstls.Qstls, error: np.array):
 
 
 def solve_qstls(guess_run_id: int):
-    scheme = qstls.Qstls()
+    scheme = qstls.Solver()
     inputs = qstls.Input(coupling=15.0, degeneracy=1.0)
     inputs.mixing = 0.3
     inputs.resolution = 0.1
@@ -97,7 +97,7 @@ def solve_qstls(guess_run_id: int):
     return scheme
 
 
-def plot_density_response(plt: plt, scheme: qstls.Qstls, settings: PlotSettings):
+def plot_density_response(plt: plt, scheme: qstls.Solver, settings: PlotSettings):
     results = scheme.results
     inputs = scheme.inputs
     wvg_squared = results.wvg[:, np.newaxis] ** 2
@@ -127,7 +127,7 @@ def plot_density_response(plt: plt, scheme: qstls.Qstls, settings: PlotSettings)
     plt.yticks(fontsize=settings.ticksz)
 
 
-def plot_ssf(plt: plt, scheme: qstls.Qstls, settings: PlotSettings):
+def plot_ssf(plt: plt, scheme: qstls.Solver, settings: PlotSettings):
     results = scheme.results
     plt.subplot(2, 2, 4)
     plt.plot(results.wvg, results.ssf, color=settings.color, linewidth=settings.width)

{qupled-1.3.3 → qupled-1.3.5}/examples/tests/test_examples.py

@@ -1,5 +1,6 @@
 import importlib
 import os
+import shutil
 import sys
 
 import matplotlib.pyplot as plt
@@ -21,9 +22,9 @@ def run_before_each_test():
 @pytest.fixture(autouse=True)
 def run_after_each_test():
     yield
-    database_name = DataBaseHandler.DEFAULT_DATABASE_NAME
-    if os.path.exists(database_name):
-        os.remove(database_name)
+    output_dir = DataBaseHandler.DATABASE_DIRECTORY
+    if os.path.exists(output_dir):
+        shutil.rmtree(output_dir)
 
 
 @pytest.fixture(autouse=True)

{qupled-1.3.3 → qupled-1.3.5}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "qupled"
-version = "v1.3.3"
+version = "v1.3.5"
 description = "qupled: a package to investigate quantum plasmas via the dielectric formalism"
 readme = "README.md"
 requires-python = ">=3.10, <3.14"

{qupled-1.3.3 → qupled-1.3.5}/src/qupled/database.py

@@ -4,13 +4,14 @@ import struct
 from datetime import datetime
 from enum import Enum
 from collections.abc import Callable
+from pathlib import Path
 
 import numpy as np
 import sqlalchemy as sql
 from sqlalchemy.dialects.sqlite import insert as sqlite_insert
 import blosc2
 
-from . import mpi
+from . import native
 
 
 class DataBaseHandler:
@@ -20,10 +21,13 @@ class DataBaseHandler:
     and deleting data, as well as managing the database schema."
     """
 
+    BLOB_STORAGE_DIRECTORY = "blob_data"
+    DATABASE_DIRECTORY = "qupled_store"
     DEFAULT_DATABASE_NAME = "qupled.db"
-    RUN_TABLE_NAME = "runs"
+    FIXED_TABLE_NAME = "fixed"
     INPUT_TABLE_NAME = "inputs"
     RESULT_TABLE_NAME = "results"
+    RUN_TABLE_NAME = "runs"
 
     class TableKeys(Enum):
         COUPLING = "coupling"
@@ -42,10 +46,9 @@ class DataBaseHandler:
         SUCCESS = "SUCCESS"
         FAILED = "FAILED"
 
-    INT_TO_RUN_STATUS = {
-        0: RunStatus.SUCCESS,
-        1: RunStatus.FAILED,
-    }
+    class ConflictMode(Enum):
+        FAIL = "FAIL"
+        UPDATE = "UPDATE"
 
     def __init__(self, database_name: str | None = None):
         """
@@ -64,19 +67,29 @@ class DataBaseHandler:
             result_table (sqlalchemy.Table): The table schema for storing result data.
             run_id (int | None): The ID of the current run, or None if no run is active.
         """
-        self.database_name = (
-            database_name if database_name is not None else self.DEFAULT_DATABASE_NAME
+        # Database path
+        database_name = (
+            self.DEFAULT_DATABASE_NAME if database_name is None else database_name
         )
-        self.engine = sql.create_engine(f"sqlite:///{self.database_name}")
-        # Enforce foreign keys in sqlite
+        database_path = Path(self.DATABASE_DIRECTORY) / database_name
+        database_path.parent.mkdir(parents=True, exist_ok=True)
+        # Blob data storage
+        self.blob_storage = (
+            Path(self.DATABASE_DIRECTORY) / self.BLOB_STORAGE_DIRECTORY / database_name
+        )
+        self.blob_storage.mkdir(parents=True, exist_ok=True)
+        self.blob_storage = str(self.blob_storage)
+        # Create database
+        self.engine = sql.create_engine(f"sqlite:///{database_path}")
+        # Set sqlite properties
         DataBaseHandler._set_sqlite_pragma(self.engine)
+        # Create tables
         self.table_metadata = sql.MetaData()
         self.run_table = self._build_run_table()
         self.input_table = self._build_inputs_table()
         self.result_table = self._build_results_table()
         self.run_id: int | None = None
 
-    @mpi.MPI.run_only_on_root
     def insert_run(self, inputs):
         """
         Inserts a new run into the database by storing the provided inputs and results.
@@ -91,7 +104,6 @@ class DataBaseHandler:
         self._insert_run(inputs, self.RunStatus.RUNNING)
         self.insert_inputs(inputs.__dict__)
 
-    @mpi.MPI.run_only_on_root
     def insert_inputs(self, inputs: dict[str, any]):
         """
         Inserts input data into the database for the current run.
@@ -114,8 +126,11 @@ class DataBaseHandler:
             sql_mapping = lambda value: (self._to_json(value))
             self._insert_from_dict(self.input_table, inputs, sql_mapping)
 
-    @mpi.MPI.run_only_on_root
-    def insert_results(self, results: dict[str, any]):
+    def insert_results(
+        self,
+        results: dict[str, any],
+        conflict_mode: ConflictMode = ConflictMode.FAIL,
+    ):
         """
         Inserts the given results into the database table associated with this instance.
 
@@ -130,7 +145,9 @@ class DataBaseHandler:
         """
         if self.run_id is not None:
             sql_mapping = lambda value: (self._to_bytes(value))
-            self._insert_from_dict(self.result_table, results, sql_mapping)
+            self._insert_from_dict(
+                self.result_table, results, sql_mapping, conflict_mode
+            )
 
     def inspect_runs(self) -> list[dict[str, any]]:
         """
@@ -149,26 +166,27 @@ class DataBaseHandler:
         rows = self._execute(statement).mappings().all()
         return [{key: row[key] for key in row.keys()} for row in rows]
 
-    def update_run_status(self, status: int) -> None:
+    def update_run_status(self, status: RunStatus) -> None:
         """
-        Updates the status of a run in the database.
+        Update the status of a run in the database.
 
         Args:
-            status (int): The new status code to update the run with. If the status
-                          code is not found in the INT_TO_RUN_STATUS mapping, the
-                          status will default to RunStatus.FAILED.
+            status (RunStatus): The new status to set for the run.
 
         Returns:
             None
+
+        Notes:
+            This method updates the status of the run identified by `self.run_id` in the run table.
+            If `self.run_id` is None, no update is performed.
         """
         if self.run_id is not None:
-            new_status = self.INT_TO_RUN_STATUS.get(status, self.RunStatus.FAILED)
             statement = (
                 sql.update(self.run_table)
                 .where(
                     self.run_table.c[self.TableKeys.PRIMARY_KEY.value] == self.run_id
                 )
-                .values({self.TableKeys.STATUS.value: new_status.value})
+                .values({self.TableKeys.STATUS.value: status.value})
             )
             self._execute(statement)
 
@@ -241,8 +259,6 @@ class DataBaseHandler:
         sql_mapping = lambda value: (self._from_bytes(value))
         return self._get(self.result_table, run_id, names, sql_mapping)
 
-    @mpi.MPI.synchronize_ranks
-    @mpi.MPI.run_only_on_root
     def delete_run(self, run_id: int) -> None:
         """
         Deletes a run entry from the database based on the provided run ID.
@@ -253,6 +269,7 @@ class DataBaseHandler:
         Returns:
             None
         """
+        self._delete_blob_data_on_disk(run_id)
         condition = self.run_table.c[self.TableKeys.PRIMARY_KEY.value] == run_id
         statement = sql.delete(self.run_table).where(condition)
         self._execute(statement)
@@ -390,16 +407,15 @@ class DataBaseHandler:
             sql.PrimaryKeyConstraint(
                 self.TableKeys.RUN_ID.value, self.TableKeys.NAME.value
             ),
+            sql.Index(f"idx_{table_name}_run_id", self.TableKeys.RUN_ID.value),
+            sql.Index(f"idx_{table_name}_name", self.TableKeys.NAME.value),
         )
         self._create_table(table)
         return table
 
-    @mpi.MPI.synchronize_ranks
-    @mpi.MPI.run_only_on_root
     def _create_table(self, table):
         table.create(self.engine, checkfirst=True)
 
-    @mpi.MPI.run_only_on_root
     def _insert_run(self, inputs: any, status: RunStatus):
         """
         Inserts a new run entry into the database.
@@ -432,6 +448,9 @@ class DataBaseHandler:
         if run_id := result.inserted_primary_key:
             self.run_id = run_id[0]
 
+    def _delete_blob_data_on_disk(self, run_id: int):
+        native.delete_blob_data_on_disk(self.engine.url.database, run_id)
+
     @staticmethod
     def _set_sqlite_pragma(engine):
         """
@@ -454,11 +473,15 @@ class DataBaseHandler:
         def _set_pragma(dbapi_connection, connection_record):
             cursor = dbapi_connection.cursor()
             cursor.execute("PRAGMA foreign_keys=ON")
+            cursor.execute("PRAGMA journal_mode=WAL")
             cursor.close()
 
-    @mpi.MPI.run_only_on_root
     def _insert_from_dict(
-        self, table, data: dict[str, any], sql_mapping: Callable[[any], any]
+        self,
+        table,
+        data: dict[str, any],
+        sql_mapping: Callable[[any], any],
+        conflict_mode: ConflictMode = ConflictMode.FAIL,
     ) -> None:
         """
         Inserts data into a specified table by mapping values through a provided SQL mapping function.
@@ -473,10 +496,46 @@ class DataBaseHandler:
         """
         for name, value in data.items():
             if mapped_value := sql_mapping(value):
-                self._insert(table, name, mapped_value)
+                self._insert(table, name, mapped_value, conflict_mode)
+
+    def _insert(
+        self,
+        table: sql.Table,
+        name: str,
+        value: any,
+        conflict_mode: ConflictMode = ConflictMode.FAIL,
+    ):
+        """
+        Inserts a record into the specified SQL table with the given name and value, handling conflicts according to the specified mode.
+        Args:
+            table (sql.Table): The SQLAlchemy table object where the record will be inserted.
+            name (str): The name/key associated with the value to insert.
+            value (any): The value to be inserted into the table.
+            conflict_mode (ConflictMode, optional): Specifies how to handle conflicts on unique constraints.
+                Defaults to ConflictMode.FAIL. If set to ConflictMode.UPDATE, existing records with the same
+                run_id and name will be updated with the new value.
+        Returns:
+            None
+        Raises:
+            Any exceptions raised by the underlying database execution.
+        """
+        data = {
+            self.TableKeys.RUN_ID.value: self.run_id,
+            self.TableKeys.NAME.value: name,
+            self.TableKeys.VALUE.value: value,
+        }
+        statement = sqlite_insert(table).values(data)
+        if conflict_mode == self.ConflictMode.UPDATE:
+            statement = statement.on_conflict_do_update(
+                index_elements=[
+                    self.TableKeys.RUN_ID.value,
+                    self.TableKeys.NAME.value,
+                ],
+                set_={self.TableKeys.VALUE.value: value},
+            )
+        self._execute(statement)
 
-    @mpi.MPI.run_only_on_root
-    def _insert(self, table: sql.Table, name: str, value: any):
+    def _insert_with_update(self, table: sql.Table, name: str, value: any):
         """
         Inserts a record into the specified SQL table or updates it if a conflict occurs.
 

{qupled-1.3.3 → qupled-1.3.5}/src/qupled/esa.py

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