Merge branch 'master' into remove-unused-q-start-current-q-arrays

Author: mesonepigreco

.github/workflows/build.yml

@@ -20,7 +20,7 @@ jobs:
 
     services:
       rabbitmq:
-          image: rabbitmq:latest
+          image: rabbitmq:3.12-management
           ports:
           -   5672:5672
 

.github/workflows/python-testsuite.yml

@@ -333,6 +333,30 @@ def __setattr__(self, name, value):
             super(Cluster, self).__setattr__(name, value)
 
 
+    def __getstate__(self):
+        """
+        Return the picklable state of the cluster.
+
+        The thread lock created by compute_ensemble_batch cannot be pickled,
+        so it is dropped here. This allows sscha.Utilities.save_binary to
+        store objects holding a cluster after a calculation has run.
+        """
+        state = self.__dict__.copy()
+        state["lock"] = None
+        return state
+
+
+    def __setstate__(self, state):
+        """
+        Restore the cluster from a pickled state.
+
+        The thread lock is transient runtime state and is reset to None,
+        as after __init__; compute_ensemble_batch recreates it when needed.
+        """
+        state["lock"] = None
+        self.__dict__.update(state)
+
+
 
     def copy_file(self, source, destination, server_source = False, server_dest = True, raise_error=False, **kwargs):
         """

Modules/Cluster.py

@@ -634,7 +634,7 @@ def minimization_step(self, custom_function_gradient = None, timer=None):
 
             # Update the structure
             if self.minim_struct:
-                self.dyn.structure.coords[:,:] = new_struct
+                self.dyn.structure.coords[:,:] = np.real(new_struct)
 
             # Check if we must enforce the symmetries and the sum rule:
             if self.enforce_sum_rule and (not self.neglect_symmetries):
@@ -643,6 +643,11 @@ def minimization_step(self, custom_function_gradient = None, timer=None):
                 else:
                     self.dyn.Symmetrize(use_spglib = self.use_spglib)
 
+                # Enforce the dynamical matrix to be real at q = -q + G (time-reversal symmetry)
+                bg = self.dyn.structure.get_reciprocal_vectors() / (2 * np.pi)
+                for iq, q in enumerate(self.dyn.q_tot):
+                    if CC.Methods.get_min_dist_into_cell(bg, q, -q) < 1e-6:
+                        self.dyn.dynmats[iq] = np.real(self.dyn.dynmats[iq])
 
             # If we have imaginary frequencies, force the kl ratio to zero
 

Modules/SchaMinimizer.py

@@ -1197,21 +1197,21 @@
  ],
  "metadata": {
   "kernelspec": {
-   "display_name": "Python 3",
+   "display_name": "Python 3 (ipykernel)",
    "language": "python",
    "name": "python3"
   },
   "language_info": {
    "codemirror_mode": {
     "name": "ipython",
-    "version": 2
+    "version": 3
    },
    "file_extension": ".py",
    "mimetype": "text/x-python",
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.7.6"
+   "version": "3.13.7"
   }
  },
  "nbformat": 4,

Tutorials/H3S/Automatic_Calculations.ipynb

@@ -1,6 +1,6 @@
 project('python-sscha',
   ['c','fortran'],
-  version : '1.6.0',
+  version : '1.6.1',
   license: 'GPL',
   meson_version: '>= 1.1.0', # <- set min version of meson.
   default_options : [
@@ -34,8 +34,18 @@ project('python-sscha',
     blas_dep = mkl_dep
     lapack_dep = mkl_dep
   else
-    lapack_dep = dependency('lapack', required: true)
-    blas_dep = dependency('blas', required: true)
+    lapack_dep = dependency('lapack', required: false)
+    blas_dep = dependency('blas', required: false)
+
+    if not lapack_dep.found()
+      lapack_lib = fc.find_library('lapack', required: true)
+      lapack_dep = declare_dependency(dependencies: lapack_lib)
+    endif
+
+    if not blas_dep.found()
+      blas_lib = fc.find_library('blas', required: true)
+      blas_dep = declare_dependency(dependencies: blas_lib)
+    endif
   endif
 
   # Look for the OpenMP library if it is needed for parallelization.

meson.build

@@ -4,7 +4,7 @@ build-backend = "mesonpy"
 
 [project]
 name = "python-sscha"
-version = "1.6.0"
+version = "1.6.1"
 description = "Python implementation of the sscha code"
 authors = [{name = "Lorenzo Monacelli"}] # Put here email
 readme = "README.md"

pyproject.toml

@@ -0,0 +1,4 @@
+[pytest]
+markers =
+    julia: tests requiring the Julia Fourier backend
+    release: long-running tests excluded from normal CI

pytest.ini

@@ -2,8 +2,16 @@
 import pytest
 import numpy as np
 
+try:
+    import aiida
+    HAVE_AIIDA = True
+except ImportError:
+    HAVE_AIIDA = False
+
 from sscha.aiida_ensemble import AiiDAEnsemble
 
+aiida_required = pytest.mark.skipif(not HAVE_AIIDA, reason='aiida not installed')
+
 
 def get_ensemble() -> AiiDAEnsemble:
     """Return an AiiDAEnsemble instance."""
@@ -34,6 +42,7 @@ def test_clean_runs():
     assert np.all(np.isclose(ensemble.forces, np.ones((num_configs-1, num_atoms, 3))))
 
 
+@aiida_required
 @pytest.mark.usefixtures('aiida_profile')
 def test_get_running_workchains(generate_workchain_pw_node):
     """Test the :func:`sscha.aiida_ensemble.get_running_workchains` method."""
@@ -67,6 +76,7 @@ def test_get_running_workchains(generate_workchain_pw_node):
     assert success == [False, True, False]
 
 
+@aiida_required
 @pytest.mark.usefixtures('aiida_profile')
 def test_submit_and_get_workchains(fixture_code):
     """Test the :func:`sscha.aiida_ensemble.submit_and_get_workchains` method."""

tests/aiida_ensemble/test_aiida_ensemble.py

@@ -10,7 +10,17 @@
 
 import pytest
 
-pytest_plugins = ['aiida.manage.tests.pytest_fixtures']  # pylint: disable=invalid-name
+# Conditionally include aiida fixtures only if aiida is available
+try:
+    import aiida
+    HAVE_AIIDA = True
+except ImportError:
+    HAVE_AIIDA = False
+
+if HAVE_AIIDA:
+    pytest_plugins = ['aiida.manage.tests.pytest_fixtures']  # pylint: disable=invalid-name
+else:
+    pytest_plugins = []
 
 
 @pytest.fixture(scope='session')
@@ -25,25 +35,27 @@ def filepath_tests():
 
 
 @pytest.fixture
-def filepath_fixtures(filepath_tests):
-    """Return the absolute filepath to the directory containing the file `fixtures`."""
-    return os.path.join(filepath_tests, 'fixtures')
-
-
-@pytest.fixture(scope='function')
 def fixture_sandbox():
     """Return a `SandboxFolder`."""
+    if not HAVE_AIIDA:
+        pytest.skip("aiida not installed")
     from aiida.common.folders import SandboxFolder
     with SandboxFolder() as folder:
         yield folder
 
 
-@pytest.fixture
-def fixture_localhost(aiida_localhost):
-    """Return a localhost `Computer`."""
-    localhost = aiida_localhost
-    localhost.set_default_mpiprocs_per_machine(1)
-    return localhost
+if HAVE_AIIDA:
+    @pytest.fixture
+    def fixture_localhost(aiida_localhost):
+        """Return a localhost `Computer`."""
+        localhost = aiida_localhost
+        localhost.set_default_mpiprocs_per_machine(1)
+        return localhost
+else:
+    @pytest.fixture
+    def fixture_localhost():
+        """Dummy fixture when aiida is not installed."""
+        pytest.skip("aiida not installed")
 
 
 @pytest.fixture
@@ -131,49 +143,51 @@ def _serialize_builder(builder):
     return _serialize_builder
 
 
-@pytest.fixture(scope='session', autouse=True)
-def sssp(aiida_profile, generate_upf_data):
-    """Create an SSSP pseudo potential family from scratch."""
-    from aiida.common.constants import elements
-    from aiida.plugins import GroupFactory
+if HAVE_AIIDA:
 
-    aiida_profile.clear_profile()
+    @pytest.fixture(scope='session', autouse=True)
+    def sssp(aiida_profile, generate_upf_data):
+        """Create an SSSP pseudo potential family from scratch."""
+        from aiida.common.constants import elements
+        from aiida.plugins import GroupFactory
 
-    SsspFamily = GroupFactory('pseudo.family.sssp')
+        aiida_profile.clear_profile()
 
-    cutoffs = {}
-    stringency = 'standard'
+        SsspFamily = GroupFactory('pseudo.family.sssp')
 
-    with tempfile.TemporaryDirectory() as dirpath:
-        for values in elements.values():
+        cutoffs = {}
+        stringency = 'standard'
 
-            element = values['symbol']
+        with tempfile.TemporaryDirectory() as dirpath:
+            for values in elements.values():
 
-            actinides = ('Ac', 'Th', 'Pa', 'U', 'Np', 'Pu', 'Am', 'Cm', 'Bk', 'Cf', 'Es', 'Fm', 'Md', 'No', 'Lr')
+                element = values['symbol']
 
-            if element in actinides:
-                continue
+                actinides = ('Ac', 'Th', 'Pa', 'U', 'Np', 'Pu', 'Am', 'Cm', 'Bk', 'Cf', 'Es', 'Fm', 'Md', 'No', 'Lr')
 
-            upf = generate_upf_data(element)
-            dirpath = pathlib.Path(dirpath)
-            filename = dirpath / f'{element}.upf'
+                if element in actinides:
+                    continue
 
-            with open(filename, 'w+b') as handle:
-                with upf.open(mode='rb') as source:
-                    handle.write(source.read())
-                    handle.flush()
+                upf = generate_upf_data(element)
+                dirpath = pathlib.Path(dirpath)
+                filename = dirpath / f'{element}.upf'
 
-            cutoffs[element] = {
-                'cutoff_wfc': 30.0,
-                'cutoff_rho': 240.0,
-            }
+                with open(filename, 'w+b') as handle:
+                    with upf.open(mode='rb') as source:
+                        handle.write(source.read())
+                        handle.flush()
+
+                cutoffs[element] = {
+                    'cutoff_wfc': 30.0,
+                    'cutoff_rho': 240.0,
+                }
 
-        label = 'SSSP/1.3/PBEsol/efficiency'
-        family = SsspFamily.create_from_folder(dirpath, label)
+            label = 'SSSP/1.3/PBEsol/efficiency'
+            family = SsspFamily.create_from_folder(dirpath, label)
 
-    family.set_cutoffs(cutoffs, stringency, unit='Ry')
+        family.set_cutoffs(cutoffs, stringency, unit='Ry')
 
-    return family
+        return family
 
 
 @pytest.fixture