Merge branch 'master' into new/flare-interface

Author: mesonepigreco

.github/workflows/build.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

@@ -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

@@ -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

tests/conftest.py

@@ -42,7 +42,7 @@ def compare_gradients(self, dyn_grad, struct_grad):
             ka = self.ka
 
             if not os.path.exists("grad_{}.dat".format(ka)):
-                np.savetxt("grad_{}.dat".format(ka), dyn_grad[0,:,:])
+                np.savetxt("grad_{}.dat".format(ka), np.real(dyn_grad[0,:,:]))
             else:
                 correct_grad = np.loadtxt("grad_{}.dat".format(ka))
                 diff = np.max(np.abs(dyn_grad - correct_grad))

tests/test_gradient_evolution/test_cmp_gradients.py

@@ -0,0 +1,65 @@
+# -*- coding: utf-8 -*-
+from __future__ import print_function
+from __future__ import division
+
+import os
+import tempfile
+import threading
+
+import cellconstructor as CC
+import cellconstructor.Phonons
+
+import sscha
+import sscha.Cluster
+import sscha.Ensemble
+import sscha.Relax
+import sscha.SchaMinimizer
+import sscha.Utilities
+
+"""
+Regression test for issue #114: save_binary failed with
+TypeError: cannot pickle '_thread.lock' object
+when the relax object holds a cluster that already ran a calculation
+(Cluster.compute_ensemble_batch stores a threading.Lock on the cluster).
+"""
+
+
+def test_save_binary_relax_with_cluster(verbose=False):
+    total_path = os.path.dirname(os.path.abspath(__file__))
+    os.chdir(total_path)
+
+    DATA_PATH = "../../Examples/ensemble_data_test/"
+
+    dyn = CC.Phonons.Phonons(os.path.join(DATA_PATH, "dyn"))
+
+    ens = sscha.Ensemble.Ensemble(dyn, 0, dyn.GetSupercell())
+    ens.load(DATA_PATH, 2, 10)
+
+    minim = sscha.SchaMinimizer.SSCHA_Minimizer(ens)
+
+    cluster = sscha.Cluster.Cluster(hostname="localhost")
+    relax = sscha.Relax.SSCHA(minim, N_configs=10, max_pop=2,
+                              cluster=cluster)
+
+    # Cluster.compute_ensemble_batch leaves a threading.Lock on the
+    # cluster after the ensemble calculation; reproduce that state.
+    relax.cluster.lock = threading.Lock()
+
+    with tempfile.TemporaryDirectory() as tmpdir:
+        filename = os.path.join(tmpdir, "relax.bin")
+        sscha.Utilities.save_binary(relax, filename)
+
+        loaded = sscha.Utilities.load_binary(filename)
+
+    # The lock is transient runtime state and must come back unset.
+    assert loaded.cluster.lock is None
+    assert loaded.cluster.hostname == "localhost"
+    assert loaded.N_configs == relax.N_configs
+    assert loaded.minim.ensemble.N == ens.N
+
+    if verbose:
+        print("save_binary/load_binary round trip succeeded")
+
+
+if __name__ == "__main__":
+    test_save_binary_relax_with_cluster(True)