Add mace as another test

.ci_support/environment-mace.yml

@@ -0,0 +1,4 @@
+channels:
+- conda-forge
+dependencies:
+- pymace =0.3.4

.github/workflows/unittests_mace.yml

@@ -0,0 +1,36 @@
+name: MACE Unittest Linux 3.11
+
+on:
+  push:
+    branches: [ main ]
+  pull_request:
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    steps:
+    - uses: actions/checkout@v4
+    - name: Merge Notebook environment
+      run: |
+        cp .ci_support/environment.yml environment.yml
+        tail --lines=+4 .ci_support/environment-mace.yml >> environment.yml
+    - name: Setup Mambaforge
+      uses: conda-incubator/setup-miniconda@v2
+      with:
+        python-version: '3.11'
+        miniforge-variant: Mambaforge
+        channels: conda-forge
+        channel-priority: strict
+        activate-environment: my-env
+        environment-file: environment.yml
+        use-mamba: true
+    - name: Test
+      shell: bash -l {0}
+      timeout-minutes: 60
+      run: |
+        pip install versioneer[toml]==0.29
+        pip install . --no-deps --no-build-isolation
+        python -m unittest tests/test_evcurve_ase_mace.py
+        python -m unittest tests/test_phonons_ase_mace.py
+        python -m unittest tests/test_quasiharmonic_ase_mace.py
+        python -m unittest tests/test_ase_md_mace.py

tests/test_ase_md_mace.py

@@ -0,0 +1,45 @@
+from ase import units
+from ase.build import bulk
+from atomistics.calculators import calc_molecular_dynamics_langevin_with_ase
+import unittest
+
+
+try:
+    from mace.calculators import mace_mp
+
+    skip_mace_test = False
+except ImportError:
+    skip_mace_test = True
+
+
+@unittest.skipIf(
+    skip_mace_test, "mace is not installed, so the mace tests are skipped."
+)
+class TestASEMD(unittest.TestCase):
+    def test_ase_langevin(self):
+        structure = bulk("Al", cubic=True).repeat([2, 2, 2])
+        ase_calculator = mace_mp(
+            model="medium",
+            dispersion=False,
+            default_dtype="float32",
+            device='cpu'
+        )
+        result_dict = calc_molecular_dynamics_langevin_with_ase(
+            structure=structure,
+            ase_calculator=ase_calculator,
+            run=100,
+            thermo=10,
+            timestep=1 * units.fs,
+            temperature=100,
+            friction=0.002,
+        )
+        self.assertEqual(result_dict["positions"].shape, (10, 32, 3))
+        self.assertEqual(result_dict["velocities"].shape, (10, 32, 3))
+        self.assertEqual(result_dict["cell"].shape, (10, 3, 3))
+        self.assertEqual(result_dict["forces"].shape, (10, 32, 3))
+        self.assertEqual(result_dict["temperature"].shape, (10, ))
+        self.assertEqual(result_dict["energy_pot"].shape, (10, ))
+        self.assertEqual(result_dict["energy_tot"].shape, (10, ))
+        self.assertEqual(result_dict["pressure"].shape, (10, 3, 3))
+        self.assertTrue(result_dict["temperature"][-1] > 25)
+        self.assertTrue(result_dict["temperature"][-1] < 75)

tests/test_evcurve_ase_mace.py

@@ -0,0 +1,62 @@
+from ase.build import bulk
+from ase.optimize import LBFGS
+import numpy as np
+import unittest
+
+from atomistics.calculators import evaluate_with_ase
+from atomistics.workflows import optimize_positions_and_volume, EnergyVolumeCurveWorkflow
+
+
+try:
+    from mace.calculators import mace_mp
+
+    skip_mace_test = False
+except ImportError:
+    skip_mace_test = True
+
+
+@unittest.skipIf(
+    skip_mace_test, "mace is not installed, so the mace tests are skipped."
+)
+class TestEvCurve(unittest.TestCase):
+    def test_calc_evcurve(self):
+        structure = bulk("Al", cubic=True)
+        ase_calculator = mace_mp(
+            model="medium",
+            dispersion=False,
+            default_dtype="float32",
+            device='cpu'
+        )
+        task_dict = optimize_positions_and_volume(structure=structure)
+        result_dict = evaluate_with_ase(
+            task_dict=task_dict,
+            ase_calculator=ase_calculator,
+            ase_optimizer=LBFGS,
+            ase_optimizer_kwargs={"fmax": 0.001}
+        )
+        workflow = EnergyVolumeCurveWorkflow(
+            structure=result_dict["structure_with_optimized_positions_and_volume"],
+            num_points=11,
+            fit_type='polynomial',
+            fit_order=3,
+            vol_range=0.05,
+            axes=('x', 'y', 'z'),
+            strains=None,
+        )
+        task_dict = workflow.generate_structures()
+        result_dict = evaluate_with_ase(
+            task_dict=task_dict,
+            ase_calculator=ase_calculator,
+        )
+        fit_dict = workflow.analyse_structures(output_dict=result_dict)
+        thermal_properties_dict = workflow.get_thermal_properties(
+            temperatures=[100, 1000],
+            output_keys=["temperatures", "volumes"]
+        )
+        temperatures_ev, volumes_ev = thermal_properties_dict["temperatures"], thermal_properties_dict["volumes"]
+        self.assertTrue(np.isclose(fit_dict['volume_eq'], 66.94655948308437, atol=1e-04))
+        self.assertTrue(np.isclose(fit_dict['bulkmodul_eq'], 64.40241949760645, atol=1e-02))
+        self.assertTrue(np.isclose(fit_dict['b_prime_eq'], 4.460574503792641, atol=1e-02))
+        self.assertEqual(len(temperatures_ev), 2)
+        self.assertEqual(len(volumes_ev), 2)
+        self.assertTrue(volumes_ev[0] < volumes_ev[-1])

tests/test_phonons_ase_mace.py

@@ -0,0 +1,60 @@
+from ase.build import bulk
+from ase.optimize import LBFGS
+from phonopy.units import VaspToTHz
+import unittest
+
+from atomistics.calculators import evaluate_with_ase
+from atomistics.workflows import optimize_positions_and_volume, PhonopyWorkflow
+
+
+try:
+    from mace.calculators import mace_mp
+
+    skip_mace_test = False
+except ImportError:
+    skip_mace_test = True
+
+
+@unittest.skipIf(
+    skip_mace_test, "mace is not installed, so the mace tests are skipped."
+)
+class TestPhonons(unittest.TestCase):
+    def test_calc_phonons(self):
+        structure = bulk("Al", cubic=True)
+        ase_calculator = mace_mp(
+            model="medium",
+            dispersion=False,
+            default_dtype="float32",
+            device='cpu'
+        )
+        task_dict = optimize_positions_and_volume(structure=structure)
+        result_dict = evaluate_with_ase(
+            task_dict=task_dict,
+            ase_calculator=ase_calculator,
+            ase_optimizer=LBFGS,
+            ase_optimizer_kwargs={"fmax": 0.001}
+        )
+        workflow = PhonopyWorkflow(
+            structure=result_dict["structure_with_optimized_positions_and_volume"],
+            interaction_range=10,
+            factor=VaspToTHz,
+            displacement=0.01,
+            dos_mesh=20,
+            primitive_matrix=None,
+            number_of_snapshots=None,
+        )
+        task_dict = workflow.generate_structures()
+        result_dict = evaluate_with_ase(
+            task_dict=task_dict,
+            ase_calculator=ase_calculator,
+        )
+        phonopy_dict = workflow.analyse_structures(output_dict=result_dict)
+        mesh_dict, dos_dict = phonopy_dict["mesh_dict"], phonopy_dict["total_dos_dict"]
+        self.assertEqual((324, 324), workflow.get_hesse_matrix().shape)
+        self.assertTrue('qpoints' in mesh_dict.keys())
+        self.assertTrue('weights' in mesh_dict.keys())
+        self.assertTrue('frequencies' in mesh_dict.keys())
+        self.assertTrue('eigenvectors' in mesh_dict.keys())
+        self.assertTrue('group_velocities' in mesh_dict.keys())
+        self.assertTrue('frequency_points' in dos_dict.keys())
+        self.assertTrue('total_dos' in dos_dict.keys())

tests/test_quasiharmonic_ase_mace.py

@@ -0,0 +1,74 @@
+from ase.build import bulk
+from ase.optimize import LBFGS
+from phonopy.units import VaspToTHz
+import unittest
+
+from atomistics.calculators import evaluate_with_ase
+from atomistics.workflows import QuasiHarmonicWorkflow, optimize_positions_and_volume
+
+
+try:
+    from mace.calculators import mace_mp
+
+    skip_mace_test = False
+except ImportError:
+    skip_mace_test = True
+
+
+@unittest.skipIf(
+    skip_mace_test, "mace is not installed, so the mace tests are skipped."
+)
+class TestPhonons(unittest.TestCase):
+    def test_calc_phonons(self):
+        structure = bulk("Al", cubic=True)
+        ase_calculator = mace_mp(
+            model="medium",
+            dispersion=False,
+            default_dtype="float32",
+            device='cpu'
+        )
+        task_dict = optimize_positions_and_volume(structure=structure)
+        result_dict = evaluate_with_ase(
+            task_dict=task_dict,
+            ase_calculator=ase_calculator,
+            ase_optimizer=LBFGS,
+            ase_optimizer_kwargs={"fmax": 0.001}
+        )
+        workflow = QuasiHarmonicWorkflow(
+            structure=result_dict["structure_with_optimized_positions_and_volume"],
+            num_points=11,
+            vol_range=0.10,
+            interaction_range=10,
+            factor=VaspToTHz,
+            displacement=0.01,
+            dos_mesh=20,
+            primitive_matrix=None,
+            number_of_snapshots=None,
+        )
+        task_dict = workflow.generate_structures()
+        result_dict = evaluate_with_ase(
+            task_dict=task_dict,
+            ase_calculator=ase_calculator,
+        )
+        eng_internal_dict, phonopy_collect_dict = workflow.analyse_structures(output_dict=result_dict)
+        tp_collect_dict = workflow.get_thermal_properties(t_min=1, t_max=501, t_step=50, temperatures=None)
+        thermal_properties_dict = workflow.get_thermal_properties(
+            temperatures=[100, 500],
+            output_keys=["temperatures", "volumes"],
+            quantum_mechanical=True
+        )
+        temperatures_qh_qm, volumes_qh_qm = thermal_properties_dict["temperatures"], thermal_properties_dict["volumes"]
+        thermal_properties_dict = workflow.get_thermal_properties(
+            temperatures=[100, 500],
+            output_keys=["temperatures", "volumes"],
+            quantum_mechanical=False
+        )
+        temperatures_qh_cl, volumes_qh_cl = thermal_properties_dict["temperatures"], thermal_properties_dict["volumes"]
+        self.assertEqual(len(eng_internal_dict.keys()), 11)
+        self.assertEqual(len(tp_collect_dict.keys()), 5)
+        self.assertEqual(len(temperatures_qh_qm), 2)
+        self.assertEqual(len(volumes_qh_qm), 2)
+        self.assertTrue(volumes_qh_qm[0] < volumes_qh_qm[-1])
+        self.assertEqual(len(temperatures_qh_cl), 2)
+        self.assertEqual(len(volumes_qh_cl), 2)
+        self.assertTrue(volumes_qh_cl[0] < volumes_qh_cl[-1])