aiida-chemshell 0.3.1__tar.gz → 0.3.2__tar.gz

{aiida_chemshell-0.3.1/src/aiida_chemshell.egg-info → aiida_chemshell-0.3.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: aiida-chemshell
-Version: 0.3.1
+Version: 0.3.2
 Summary: AiiDA workflow plugin for the ChemShell chemical modelling software package
 Author-email: "Dr. Benjamin T. Speake" <benjamin.speake@stfc.ac.uk>
 License: BSD 3-Clause License
@@ -42,6 +42,7 @@ Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: aiida-core>=2.5
+Requires-Dist: ase>=3.29
 Provides-Extra: dev
 Requires-Dist: aiida-core>=2.8; extra == "dev"
 Requires-Dist: pytest>=8.0; extra == "dev"

{aiida_chemshell-0.3.1 → aiida_chemshell-0.3.2}/pyproject.toml

@@ -3,13 +3,13 @@ requires = ["setuptools"]
 build-backend = "setuptools.build_meta"
 
 [project]
-version = "0.3.1"
+version = "0.3.2"
 name = "aiida-chemshell"
 description = "AiiDA workflow plugin for the ChemShell chemical modelling software package"
 authors = [
     { name = "Dr. Benjamin T. Speake", email = "benjamin.speake@stfc.ac.uk" },
 ]
-dependencies = ["aiida-core >= 2.5"]
+dependencies = ["aiida-core >= 2.5", "ase>=3.29"]
 readme = "README.md"
 license = { file = "LICENSE" }
 keywords = ["aiida", "workflows", "chemshell"]

{aiida_chemshell-0.3.1 → aiida_chemshell-0.3.2}/src/aiida_chemshell/calculations/base.py

@@ -236,7 +236,10 @@ class ChemShellCalculation(CalcJob):
             "vibrational_modes",
             valid_type=ArrayData,
             required=False,
-            help="The calculated vibrational modes of the system.",
+            help=(
+                "The calculated vibrational modes of the system. A negative "
+                "frequency indicates an imaginary frequency."
+            ),
         )
 
         # Validate inputs namespace
@@ -839,6 +842,8 @@ class ChemShellCalculation(CalcJob):
         if "optimisation_parameters" in node.inputs:
             if node.inputs.optimisation_parameters.get("thermal", False):
                 return "ChemShell_Vibrational_Frequencies" + theory_key
+            if node.inputs.optimisation_parameters.get("neb", "no") != "no":
+                return "ChemShell_NEB" + theory_key
             return "ChemShell_Geometry_Optimisation" + theory_key
 
         return "ChemShell_Single_Point_Calculation" + theory_key
@@ -888,7 +893,6 @@ class ChemShellCalculation(CalcJob):
                 fname = self.inputs.structure2.filename
             else:
                 fname = ChemShellCalculation.FILE_TMP_STRUCTURE2
-            print(fname)
             script += f"frg2 = Fragment(coords='{fname:s}')\n"
 
         ## Setup Theory objects
@@ -1016,8 +1020,9 @@ class ChemShellCalculation(CalcJob):
             node = self.inputs[port_name]
             if not node.label:
                 node.label = label
-            if not node.description:
-                node.description = description
+                if not node.description:
+                    node.description = description
+        return
 
     def prepare_for_submission(self, folder: Folder) -> CalcInfo:
         """
@@ -1101,7 +1106,7 @@ class ChemShellCalculation(CalcJob):
         # Copy data for second input fragment if required
         if "structure2" in self.inputs:
             if isinstance(self.inputs.structure2, StructureData):
-                with folder.open(ChemShellCalculation.FILE_TMP_STRUCTURE, "wb") as f:
+                with folder.open(ChemShellCalculation.FILE_TMP_STRUCTURE2, "wb") as f:
                     f.write(self.inputs.structure2._prepare_xyz()[0])
             else:
                 calc_info.local_copy_list.append(

{aiida_chemshell-0.3.1 → aiida_chemshell-0.3.2}/src/aiida_chemshell/calculations/utils.py

@@ -15,7 +15,88 @@ from aiida.orm import (
 
 
 @calcfunction
-def create_dictionary(atoms, energies) -> Dict:
+def create_isolated_atom_structures(structure) -> dict[str, StructureData]:
+    """
+    Create an isolated single-atom StructureData for each unique atom type.
+
+    The unique atom types present in ``structure`` are determined and, for each,
+    a non-periodic StructureData node containing a single atom at the origin is
+    created.
+
+    Parameters
+    ----------
+    structure : StructureData | SinglefileData
+        The input structure to extract isolated atomic species from. Either a
+        StructureData node or a SinglefileData node wrapping a structure file in
+        any format readable by ``ase.io.read``.
+
+    Returns
+    -------
+    dict[str, StructureData]
+        A mapping of atom type to its isolated single-atom StructureData node.
+        As a calcfunction return value, this is registered as a namespace of
+        output nodes, with the atom type used as the output link label.
+
+    Raises
+    ------
+    Exception
+        If the structure file format is not supported by the ASE reader.
+    """
+    unique_atoms = _determine_unique_atoms(structure)
+    structures = {}
+    for atom_symbol in unique_atoms:
+        atom = StructureData()
+        atom.append_atom(position=(0.0, 0.0, 0.0), symbols=atom_symbol)
+        atom.set_pbc((False, False, False))
+        atom.label = f"{atom_symbol} atom"
+        atom.description = (
+            f"Isolated {atom_symbol} atom extracted from Node: {structure.pk}"
+        )
+        structures[atom_symbol] = atom
+    return structures
+
+
+def _determine_unique_atoms(structure: SinglefileData | StructureData) -> list[str]:
+    """Determine all unique atom types within the given structure."""
+    if isinstance(structure, StructureData):
+        return _atom_types_from_structuredata(structure)
+    return _atom_types_from_file(structure)
+
+
+def _atom_types_from_structuredata(structure: StructureData) -> list[str]:
+    """Determine the unique atom types from a StructureData object."""
+    unique_atoms: list[str] = []
+    for site in structure.sites:
+        if site.kind_name not in unique_atoms:
+            unique_atoms.append(site.kind_name)
+    return unique_atoms
+
+
+def _atom_types_from_file(structure: SinglefileData) -> list[str]:
+    """Determine the unique atom types from a SinglefileData object using ASE."""
+    import os
+    import tempfile
+
+    from ase.io import read
+    from ase.io.formats import UnknownFileTypeError
+
+    suffix = os.path.splitext(structure.filename)[1]
+    with tempfile.NamedTemporaryFile(suffix=suffix) as tmp:
+        with structure.open(mode="rb") as f:
+            tmp.write(f.read())
+        tmp.flush()
+        try:
+            atoms = read(tmp.name)
+        except UnknownFileTypeError as e:
+            raise Exception(
+                f"Unsupported structure file format for isolated atom extraction: "
+                f"{structure.filename}"
+            ) from e
+    return list(dict.fromkeys(atoms.get_chemical_symbols()))
+
+
+@calcfunction
+def create_atomic_energy_dictionary(atoms, energies) -> Dict:
     """Collate a series of isolated atom energies into a dictionary output."""
     if len(atoms) != len(energies):
         raise ValueError(

{aiida_chemshell-0.3.1 → aiida_chemshell-0.3.2}/src/aiida_chemshell/parsers/base.py

@@ -163,8 +163,17 @@ class ChemShellParser(Parser):
                 elif "Mode" in line or "total" in line:
                     pass
                 else:
-                    # All remaining lines should be part of the modes table
-                    modes.append(numpy.array([float(x) for x in line_vals[2:]]))
+                    # All remaining lines should be part of the modes table.
+                    # Imaginary frequencies are printed with a trailing "i"
+                    # (e.g. "100.0i") and are stored as the negative value.
+                    modes.append(
+                        numpy.array(
+                            [
+                                -float(x[:-1]) if x.endswith("i") else float(x)
+                                for x in line_vals[2:]
+                            ]
+                        )
+                    )
 
             if "Thermochemical analysis" in line:
                 read = True

{aiida_chemshell-0.3.1 → aiida_chemshell-0.3.2}/src/aiida_chemshell/workflows/batch_calculation.py

@@ -113,16 +113,7 @@ class BatchProcessWorkChain(WorkChain):
     def apply_default_input_tags(self) -> None:
         """Apply default labels/descriptions to WorkChain specific input nodes."""
         apply_default_input_node_tags(self.inputs, self.DEFAULT_INPUT_TAGS)
-
-    # @classmethod
-    # def validate_combination_input_key(cls, key: str | None, _) -> str | None:
-    #     """Validate the combine_results input key."""
-    #     if key in ["xyz", "trajectory"]:
-    #         return None
-    #     return (
-    #         f"Invalid input for 'combine_results'. {key} must be either 'xyz' or "
-    #         "'trajectory'"
-    #     )
+        return
 
     def validate_inputs(self):
         """Validate the inputs provided to the WorkChain."""

{aiida_chemshell-0.3.1 → aiida_chemshell-0.3.2}/src/aiida_chemshell/workflows/isolated_atoms.py

@@ -4,8 +4,10 @@ from aiida.engine import ToContext, WorkChain
 from aiida.orm import Dict, StructureData
 from aiida.plugins.factories import CalculationFactory
 
-from aiida_chemshell.calculations.utils import create_dictionary
-from aiida_chemshell.periodic_table import PeriodicTable
+from aiida_chemshell.calculations.utils import (
+    create_atomic_energy_dictionary,
+    create_isolated_atom_structures,
+)
 from aiida_chemshell.workflows.utils import apply_default_input_node_tags
 
 ChemShellCalculation = CalculationFactory("chemshell")
@@ -46,7 +48,7 @@ class IsolatedAtomicEnergiesWorkChain(WorkChain):
 
         spec.outline(
             cls.apply_default_input_tags,
-            cls.determine_unique_atom_types,
+            cls.create_atom_structures,
             cls.atom_energies,
             cls.result,
         )
@@ -57,31 +59,21 @@ class IsolatedAtomicEnergiesWorkChain(WorkChain):
         """Apply default labels/descriptions to WorkChain specific input nodes."""
         apply_default_input_node_tags(self.inputs, self.DEFAULT_INPUT_TAGS)
 
-    def determine_unique_atom_types(self) -> None:
-        """Determine all unique atom types within the given structure."""
-        self.unique_atoms = []
-        if isinstance(self.inputs.structure, StructureData):
-            self._atom_types_from_structuredata(self.inputs.structure)
-        else:
-            self._atom_types_from_file()
+    def create_atom_structures(self) -> None:
+        """Create provenance-tracked isolated atom structures for each atom type."""
+        if self.inputs.qm_parameters["theory"] == "PySCF":
+            raise Exception(
+                "Isolated atom calculations not supported by PySCF QM backend."
+            )
+        self.ctx.atom_structures = create_isolated_atom_structures(
+            self.inputs.structure
+        )
         return
 
     def atom_energies(self):
         """Run ChemShell single point calculations for each atom type."""
         calculations = {}
-        if self.inputs.qm_parameters["theory"] == "PySCF":
-            raise Exception(
-                "Isolated atom calculations not supported by PySCF QM backend."
-            )
-        for atom_symbol in self.unique_atoms:
-            structure = StructureData()
-            structure.append_atom(position=(0.0, 0.0, 0.0), symbols=atom_symbol)
-            structure.set_pbc((False, False, False))
-            structure.label = f"{atom_symbol} atom"
-            structure.description = (
-                f"Isolated {atom_symbol} atom extracted from Node: "
-                f"{self.inputs.structure.pk}"
-            )
+        for atom_symbol, structure in self.ctx.atom_structures.items():
             inputs = {
                 "structure": structure,
                 "qm_parameters": self.inputs.qm_parameters,
@@ -95,9 +87,10 @@ class IsolatedAtomicEnergiesWorkChain(WorkChain):
 
     def result(self) -> None:
         """Collect the results into a dictionary."""
-        results_dict = create_dictionary(
-            list(self.unique_atoms),
-            [self.ctx.get(atom).outputs.energy for atom in self.unique_atoms],
+        unique_atoms = list(self.ctx.atom_structures.keys())
+        results_dict = create_atomic_energy_dictionary(
+            unique_atoms,
+            [self.ctx.get(atom).outputs.energy for atom in unique_atoms],
         )
         if isinstance(self.inputs.structure, StructureData):
             results_dict.label = (
@@ -111,47 +104,3 @@ class IsolatedAtomicEnergiesWorkChain(WorkChain):
             )
         self.out("atom_energies", results_dict)
         return
-
-    def _atom_types_from_structuredata(self, structure: StructureData) -> None:
-        """Determine the unique atom types from a StructureData object."""
-        self.unique_atoms = []
-        for site in structure.sites:
-            if site.kind_name not in self.unique_atoms:
-                self.unique_atoms.append(site.kind_name)
-        return
-
-    def _atom_types_from_file(self) -> None:
-        """Determine the unique atom types from a SinglefileData object."""
-        if self.inputs.structure.filename[-4:] == ".xyz":
-            self._atom_types_from_xyz()
-        elif self.inputs.structure.filename[-6:] == ".cjson":
-            self._atom_types_from_cjson()
-        elif self.inputs.structure.filename[-4:] == ".pun":
-            self._atom_types_from_pun()
-        return
-
-    def _atom_types_from_xyz(self) -> None:
-        """Determine the unique atom types from an xyz structure file."""
-        structure = StructureData()
-        structure._parse_xyz(self.inputs.structure.content.decode("utf-8"))
-        self._atom_types_from_structuredata(structure)
-        return
-
-    def _atom_types_from_cjson(self) -> None:
-        """Determine the unique atom types from a cjson structure file."""
-        import json
-
-        data = json.loads(self.inputs.structure.content).get("atoms").get("elements")
-        atom_symbols: list[str] = data.get("symbol", [])
-        atom_numbers: list[int] = data.get("number", [])
-        if len(atom_symbols) == 0:
-            self.unique_atoms = list(
-                {PeriodicTable.atom_z_to_symbol(number) for number in atom_numbers}
-            )
-        else:
-            self.unique_atoms = list(set(atom_symbols))
-        return
-
-    def _atom_types_from_pun(self) -> None:
-        """Determine the unique atom types from a .pun structure file."""
-        return

{aiida_chemshell-0.3.1 → aiida_chemshell-0.3.2}/src/aiida_chemshell/workflows/optimisation.py

@@ -1,17 +1,14 @@
 """Workflows for geometry optimisation based taks."""
 
-from aiida.common.exceptions import MissingEntryPointError
 from aiida.engine import ToContext, WorkChain
 from aiida.orm import (
     ArrayData,
     Bool,
-    Code,
     Dict,
     Float,
     SinglefileData,
     StructureData,
 )
-from aiida.plugins.factories import CalculationFactory
 
 from aiida_chemshell.calculations.base import ChemShellCalculation
 from aiida_chemshell.workflows.isolated_atoms import IsolatedAtomicEnergiesWorkChain
@@ -27,10 +24,6 @@ class GeometryOptimisationWorkChain(WorkChain):
             "Vibrational Analysis Flag",
             "Whether to calculate the vibrational modes of the optimised structure.",
         ),
-        "mlip_model": (
-            "MLIP Foundation Model",
-            "The MLIP foundation model to apply fine-tuning to.",
-        ),
     }
 
     @classmethod
@@ -71,48 +64,20 @@ class GeometryOptimisationWorkChain(WorkChain):
             "vibrational_modes",
             valid_type=ArrayData,
             required=False,
-            help="The calculated vibrational modes for the optimised structure.",
+            help=(
+                "The calculated vibrational modes for the optimised structure. A "
+                "negative frequency indicates an imaginary frequency."
+            ),
         )
 
-        # Optional inputs/outputs for using the results to fine tune a MLIP model
-        # using the janus-core project via the aiida-mlip plugin.
-        try:
-            CalculationFactory("mlip.train")
-        except MissingEntryPointError:
-            pass
-        else:
-            from aiida_mlip.data.model import ModelData
-
-            spec.input(
-                "mlip_model",
-                valid_type=ModelData,
-                required=False,
-                help="The MLIP foundation model to apply fine-tuning to.",
-            )
-            spec.input(
-                "mlip_code",
-                valid_type=Code,
-                required=False,
-                help="The Janus-core AiiDA code instance.",
-            )
-            spec.output(
-                "fine_tuned_model", valid_type=ModelData, required=False, help=""
-            )
-            spec.output(
-                "fine_tuned_model_compiled",
-                valid_type=SinglefileData,
-                required=False,
-                help="",
-            )
-
         ## Workflow ##
         spec.outline(
             cls.apply_default_input_tags,
             cls.optimise,
             cls.energy,
             cls.isolated_atom_energies,
-            cls.generate_mlip_training_inputs,
-            cls.train_mlip,
+            # cls.generate_mlip_training_inputs,
+            # cls.train_mlip,
             cls.result,
         )
 
@@ -146,6 +111,9 @@ class GeometryOptimisationWorkChain(WorkChain):
         if "mlip_model" in self.inputs:
             inputs["optimisation_parameters"]["save_path"] = True
 
+        if "maxcycle" not in inputs["optimisation_parameters"]:
+            inputs["optimisation_parameters"]["maxcycle"] = 300
+
         future = self.submit(ChemShellCalculation, **inputs)
         future.label = ChemShellCalculation.default_process_label(future)
         future.description = (
@@ -201,96 +169,6 @@ class GeometryOptimisationWorkChain(WorkChain):
             return ToContext(isolated_atoms=future)
         return None
 
-    def generate_mlip_training_inputs(self):
-        """Convert the optimisation path files to Janus compatible inputs."""
-        if "mlip_model" in self.inputs:
-            inputs = {
-                "path": self.ctx.optimise.outputs.trajectory_path,
-                "force": self.ctx.optimise.outputs.trajectory_force,
-                "energies": self.ctx.optimise.outputs.optimisation_path,
-                "atom_energies": self.ctx.isolated_atoms.outputs.atom_energies,
-                "code": self.inputs.chemsh.code,
-                "metadata": {
-                    "options": {
-                        "resources": {"num_mpiprocs_per_machine": 2, "num_machines": 1},
-                        # "withmpi": True,
-                    }
-                },
-            }
-            from aiida_chemshell.calculations.file_conversion import (
-                CreateJanusTrainingInputsCalcJob,
-            )
-
-            future = self.submit(CreateJanusTrainingInputsCalcJob, **inputs)
-            future.label = "Generate MLIP training data set from geometry optimisation."
-            future.description = (
-                f"Data extraction step from WorkChainNode pk: {self.node.pk}"
-            )
-            return ToContext(create_mlip_inputs=future)
-        return None
-
-    def train_mlip(self):
-        """Train a given MLIP model."""
-        try:
-            mlip_train_calc = CalculationFactory("mlip.train")
-        except MissingEntryPointError:
-            pass
-        else:
-            if "mlip_model" in self.inputs:
-                # This needs to be properly addressed within aiida-mlip
-                computer = self.inputs.get("mlip_code", None).computer
-                work_dir = computer.get_workdir()
-                with open("train.xyz", mode="wb") as f:
-                    f.write(self.ctx.create_mlip_inputs.outputs.training_input.content)
-                with open("test.xyz", mode="wb") as f:
-                    f.write(self.ctx.create_mlip_inputs.outputs.test_input.content)
-                with open("valid.xyz", mode="wb") as f:
-                    f.write(
-                        self.ctx.create_mlip_inputs.outputs.validation_input.content
-                    )
-                with computer.get_transport() as transport:
-                    from pathlib import Path
-
-                    transport.putfile(
-                        Path("train.xyz").absolute(), f"{work_dir}/train.xyz"
-                    )
-                    transport.putfile(
-                        Path("test.xyz").absolute(), f"{work_dir}/test.xyz"
-                    )
-                    transport.putfile(
-                        Path("valid.xyz").absolute(), f"{work_dir}/valid.xyz"
-                    )
-
-                import yaml
-                from aiida_mlip.data.config import JanusConfigfile
-
-                from aiida_chemshell.utils import generate_default_mlip_fine_tune_config
-
-                config_dict = generate_default_mlip_fine_tune_config()
-                config_dict["train_file"] = f"{work_dir}/train.xyz"
-                config_dict["test_file"] = f"{work_dir}/test.xyz"
-                config_dict["valid_file"] = f"{work_dir}/valid.xyz"
-                config_dict["name"] = "ChemShell_Workflow_Test"
-
-                with open("mlip_config.yml", "w+") as f:
-                    yaml.dump(config_dict, f, default_flow_style=False)
-
-                mlip_inputs = {
-                    "mlip_config": JanusConfigfile(Path("mlip_config.yml").absolute()),
-                    "code": self.inputs.get("mlip_code", None),
-                    "fine_tune": True,
-                    "foundation_model": self.inputs.get("mlip_model", None),
-                    "metadata": {"options": {"resources": {"num_machines": 1}}},
-                }
-                # Submit the mlip training job
-                future = self.submit(mlip_train_calc, **mlip_inputs)
-                future.label = "MLIP Fine-Tuning."
-                future.description = (
-                    f"MLIP fine-tuning step from WorkChainNode pk: {self.node.pk}"
-                )
-                return ToContext(mlip_training=future)
-        return None
-
     def result(self):
         """Extract the final workflow results."""
         if "mlip_model" in self.inputs:

{aiida_chemshell-0.3.1 → aiida_chemshell-0.3.2/src/aiida_chemshell.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: aiida-chemshell
-Version: 0.3.1
+Version: 0.3.2
 Summary: AiiDA workflow plugin for the ChemShell chemical modelling software package
 Author-email: "Dr. Benjamin T. Speake" <benjamin.speake@stfc.ac.uk>
 License: BSD 3-Clause License
@@ -42,6 +42,7 @@ Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: aiida-core>=2.5
+Requires-Dist: ase>=3.29
 Provides-Extra: dev
 Requires-Dist: aiida-core>=2.8; extra == "dev"
 Requires-Dist: pytest>=8.0; extra == "dev"

{aiida_chemshell-0.3.1 → aiida_chemshell-0.3.2}/src/aiida_chemshell.egg-info/SOURCES.txt

@@ -13,12 +13,9 @@ src/aiida_chemshell.egg-info/requires.txt
 src/aiida_chemshell.egg-info/top_level.txt
 src/aiida_chemshell/calculations/__init__.py
 src/aiida_chemshell/calculations/base.py
-src/aiida_chemshell/calculations/file_conversion.py
-src/aiida_chemshell/calculations/solvant_removal.py
 src/aiida_chemshell/calculations/utils.py
 src/aiida_chemshell/parsers/__init__.py
 src/aiida_chemshell/parsers/base.py
-src/aiida_chemshell/parsers/file_conversion.py
 src/aiida_chemshell/workflows/__init__.py
 src/aiida_chemshell/workflows/batch_calculation.py
 src/aiida_chemshell/workflows/isolated_atoms.py

{aiida_chemshell-0.3.1 → aiida_chemshell-0.3.2}/src/aiida_chemshell.egg-info/requires.txt

@@ -1,4 +1,5 @@
 aiida-core>=2.5
+ase>=3.29
 
 [dev]
 aiida-core>=2.8

{aiida_chemshell-0.3.1 → aiida_chemshell-0.3.2}/tests/test_inputs.py

@@ -154,6 +154,52 @@ H            0.7546064020       0.5900323550       0.0000000000"""
     assert ChemShellCalculation.FILE_TMP_STRUCTURE in script_txt
 
 
+def test_structure2_as_structuredata_object(
+    generate_calcjob, generate_inputs, water_structure_object
+):
+    """Test that a StructureData 'structure2' input is written to its own file.
+
+    Regression test: 'structure2' was previously written to the primary
+    structure's temporary file (FILE_TMP_STRUCTURE), overwriting it, instead
+    of its own file (FILE_TMP_STRUCTURE2).
+    """
+    structure2 = StructureData()
+    structure2.pbc = [False, False, False]
+    structure2.append_atom(symbols="O", position=[0.0, 0.0, 1.0])
+
+    inputs = generate_inputs(structure_fname=water_structure_object)
+    inputs["structure2"] = structure2
+
+    tmp_pth, calc_info = generate_calcjob(ChemShellCalculation, inputs)
+
+    structure_file = tmp_pth / ChemShellCalculation.FILE_TMP_STRUCTURE
+    structure2_file = tmp_pth / ChemShellCalculation.FILE_TMP_STRUCTURE2
+    assert structure_file.exists()
+    assert structure2_file.exists()
+
+    # The primary structure file must not have been overwritten by structure2.
+    chk_str = """3
+Lattice="0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0" pbc="False False False"
+O            0.0000000000       0.0000000000       0.0000000000
+H           -0.7546064020       0.5900323550       0.0000000000
+H            0.7546064020       0.5900323550       0.0000000000"""
+    assert structure_file.read_text() == chk_str
+
+    chk_str2 = """1
+Lattice="0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0" pbc="False False False"
+O            0.0000000000       0.0000000000       1.0000000000"""
+    assert structure2_file.read_text() == chk_str2
+
+    script_file = tmp_pth / ChemShellCalculation.FILE_SCRIPT
+    assert script_file.exists()
+
+    script_txt = script_file.read_text()
+    assert (
+        f"frg2 = Fragment(coords='{ChemShellCalculation.FILE_TMP_STRUCTURE2:s}')\n"
+        in script_txt
+    )
+
+
 def test_cjson_to_structure_data(get_test_data_file):
     """Test parsing a ChemShell '.cjson' file into a StructureData node."""
     from aiida_chemshell.units import UnitsConverter

{aiida_chemshell-0.3.1 → aiida_chemshell-0.3.2}/tests/test_isolated_atoms_workchain.py

@@ -2,7 +2,6 @@
 
 from unittest.mock import MagicMock
 
-import pytest
 from aiida.engine import run_get_node
 from aiida.engine.utils import instantiate_process
 from aiida.manage.manager import get_manager
@@ -59,7 +58,7 @@ def test_metadata_options_forwarded_to_subcalculations(
     # Skip the actual (slow) ChemShell calculations; only capture the submissions.
     process.submit = MagicMock(return_value=MagicMock())
 
-    process.determine_unique_atom_types()
+    process.create_atom_structures()
     process.atom_energies()
 
     # Water contains two unique atom types (O and H).
@@ -71,9 +70,47 @@ def test_metadata_options_forwarded_to_subcalculations(
         )
 
 
-@pytest.mark.xfail(reason="Will fail if NWChem not properly configured.")
-def test_geometry_optimisation_workflow(chemsh_code, get_test_data_file):
-    """Test a geometry optimisation workflow with vibrational analysis."""
+def test_isolated_atom_structures_are_provenance_tracked(
+    chemsh_code, water_structure_object
+):
+    """Isolated atom structures are created and correctly linked in provenance."""
+    from aiida.common.links import LinkType
+
+    inputs = {
+        "structure": water_structure_object,
+        "code": chemsh_code,
+        "qm_parameters": Dict({"theory": "NWChem"}),
+    }
+
+    runner = get_manager().get_runner()
+    process = instantiate_process(runner, IsolatedAtomicEnergiesWorkChain, **inputs)
+
+    process.create_atom_structures()
+
+    atom_structures = process.ctx.atom_structures
+    # Water contains two unique atom types (O and H).
+    assert set(atom_structures.keys()) == {"O", "H"}
+
+    for atom_structure in atom_structures.values():
+        assert atom_structure.is_stored, "Isolated atom structure was not stored."
+        creator = (
+            atom_structure.base.links.get_incoming(link_type=LinkType.CREATE).one().node
+        )
+        # The creator must be the calcfunction, which itself took the input
+        # structure as an input node.
+        input_pks = [
+            link.node.pk
+            for link in creator.base.links.get_incoming(
+                link_type=LinkType.INPUT_CALC
+            ).all()
+        ]
+        assert water_structure_object.pk in input_pks, (
+            "Isolated atom structure is not linked back to the input structure."
+        )
+
+
+def test_full_workflow(chemsh_code, get_test_data_file):
+    """End-to-end test for the isolated atomic energies workflow."""
     inputs = {
         "structure": get_test_data_file(),
         "code": chemsh_code,
@@ -81,7 +118,6 @@ def test_geometry_optimisation_workflow(chemsh_code, get_test_data_file):
     }
     results, node = run_get_node(IsolatedAtomicEnergiesWorkChain, **inputs)
 
-    # print(results)
     assert node.is_finished_ok, (
         "WorkChain node failed for IsolatedAtomicEnergiesWorkChain"
     )

aiida_chemshell-0.3.1/src/aiida_chemshell/calculations/file_conversion.py

@@ -1,206 +0,0 @@
-"""CalcJob to create individual extended XYZ files for steps in an optimisation."""
-
-from aiida.common import CalcInfo, CodeInfo
-from aiida.common.folders import Folder
-from aiida.engine import CalcJob, CalcJobProcessSpec, PortNamespace
-from aiida.orm import ArrayData, Dict, SinglefileData, Str
-
-from aiida_chemshell.units import UnitsConverter
-
-
-class CreateJanusTrainingInputsCalcJob(CalcJob):
-    """CalcJob to split an XYZ trajectory into individual ext XYZ files."""
-
-    @classmethod
-    def define(cls, spec: CalcJobProcessSpec) -> None:
-        """Define the inputs, outputs and metadata for the CalcJob."""
-        super().define(spec)
-        spec.input(
-            "path",
-            valid_type=SinglefileData,
-            required=True,
-            help="An XYZ trajectory file containing the positions of each step.",
-        )
-        spec.input(
-            "force",
-            valid_type=SinglefileData,
-            required=True,
-            help="An XYZ trajectory file containing the forces at each step.",
-        )
-        spec.input(
-            "energies",
-            valid_type=ArrayData,
-            required=True,
-            help="The calculated dft energy of each step in the data series in a.u.",
-        )
-        spec.input(
-            "atom_energies",
-            valid_type=Dict,
-            required=True,
-            help="The isolated atomic energies for the training set.",
-        )
-
-        spec.input(
-            "filename",
-            valid_type=Str,
-            required=False,
-            help="The name to give the directory of output files.",
-        )
-
-        spec.output(
-            "training_input",
-            valid_type=SinglefileData,
-            required=True,
-            help="The main training data set in extended XYZ format.",
-        )
-        spec.output(
-            "validation_input",
-            valid_type=SinglefileData,
-            required=True,
-            help="The validation data set in extended XYZ format.",
-        )
-        spec.output(
-            "test_input",
-            valid_type=SinglefileData,
-            required=True,
-            help="The testing data set in extended XYZ format.",
-        )
-
-        ## Metadata
-        spec.inputs["metadata"]["options"]["resources"].default = {
-            "num_machines": 1,
-            "num_mpiprocs_per_machine": 2,
-        }
-        spec.inputs["metadata"]["options"][
-            "parser_name"
-        ].default = "chemshell.file_conversion.mlip_training"
-
-        # Exit Codes
-        spec.exit_code(
-            300,
-            "ERROR_NO_TRAJECTORY_FILES",
-            message="No trajectory files have been produced.",
-        )
-
-        return
-
-    @classmethod
-    def validate_path_file(
-        cls, value: SinglefileData, namepsace: PortNamespace
-    ) -> str | None:
-        """Perform validation checks on the input path xyz files."""
-        if not isinstance(value, SinglefileData):
-            return "Input trajectory needs to be a SinglefileData node."
-        content = value.get_content("r")
-        lines = content.split("\n")
-        natoms = int(lines[0])
-        if len(lines) % (natoms + 2) != 0:
-            print(lines)
-            return "Invalid XYZ trajectory structure detected."
-        if len(lines) // (natoms + 2) < 5:
-            return "Not enough individual configurations within input trajectory."
-        return None
-
-    def create_isolated_atom_energy_xyz(self) -> str:
-        """Create the isolated atomistic energies in the required XYZ format."""
-        xyz_str = ""
-        zero = 0.0
-        for atom in self.inputs.atom_energies.keys():
-            xyz_str += "1\nProperties=species:S:1:pos:R:3:dft_forces:R:3 "
-            energy = UnitsConverter.hartree_to_ev(self.inputs.atom_energies[atom])
-            xyz_str += f"dft_energy={energy} "
-            xyz_str += 'config_type=IsolatedAtom pbc="F F F"\n'
-            xyz_str += f"{atom:8s} {zero:.4f} {zero:.4f} {zero:.4f} "
-            xyz_str += f"{zero:.4f} {zero:.4f} {zero:.4f}\n"
-        return xyz_str
-
-    def prepare_for_submission(self, folder: Folder) -> CalcInfo:
-        """Perform the python task to split the input trajectories."""
-        script = self.generate_script()
-        with folder.open("input.py", "w") as f:
-            f.write(script)
-
-        with folder.open("energies.txt", "w") as f:
-            for val in self.inputs.energies.get_array("energies"):
-                f.write(f"{UnitsConverter.hartree_to_ev(val):.10f}\n")
-
-        with folder.open("isolated_atoms.xyz", "w") as f:
-            f.write(self.create_isolated_atom_energy_xyz())
-
-        code_info = CodeInfo()
-        code_info.code_uuid = self.inputs.code.uuid
-        if "chemsh.x" in str(self.inputs.code.filepath_executable):
-            code_info.cmdline_params = [
-                "input.py",
-            ]
-        else:
-            n_machines = self.inputs.metadata.options.resources.get("num_machines")
-            n_mpi_pm = self.inputs.metadata.options.resources.get(
-                "num_mpiprocs_per_machine"
-            )
-            tot_mpi = n_machines * n_mpi_pm
-            code_info.cmdline_params = [
-                "-np",
-                self.inputs.metadata.options.resources.get("tot_num_mpiprocs", tot_mpi),
-                "input.py",
-            ]
-
-        calc_info = CalcInfo()
-        calc_info.codes_info = [code_info]
-        calc_info.provenance_exclude_list = []
-        calc_info.retrieve_temporary_list = ["train.xyz", "valid.xyz", "test.xyz"]
-        calc_info.local_copy_list = [
-            (
-                self.inputs.path.uuid,
-                self.inputs.path.filename,
-                self.inputs.path.filename,
-            ),
-            (
-                self.inputs.force.uuid,
-                self.inputs.force.filename,
-                self.inputs.force.filename,
-            ),
-        ]
-
-        return calc_info
-
-    def generate_script(self) -> str:
-        """Generate the python script for splitting the trajectory files."""
-        return """
-with open("path.xyz", "r") as f:
-    path = f.readlines()
-with open("path_force.xyz", "r") as f:
-    force = f.readlines()
-energies = []
-with open("energies.txt", 'r') as f:
-    for line in f:
-        energies.append(float(line))
-natms = int(path[0])
-nsteps = len(path) // (natms + 2)
-valid_interval = 5
-test_interval = 10
-if nsteps < test_interval:
-    test_interval = nsteps
-    valid_interval = (nsteps // 2) + 1
-for step in range(nsteps):
-    if (step + 1) % test_interval == 0:
-        fname = "test.xyz"
-    elif (step + 1) % valid_interval == 0:
-        fname = "valid.xyz"
-    else:
-        fname = "train.xyz"
-    with open(fname, "a") as f:
-        f.write(f"{natms}\\n")
-        f.write(f'Step={step}  ')
-        f.write(f'Properties=species:S:1:pos:R:3:dft_forces:R:3 pbc="F F F" ')
-        f.write(f'energy={energies[step]}\\n')
-        for i in range(2, natms + 2):
-            index = (step * (natms + 2)) + i
-            f.write(path[index].strip("\\n") + "   ")
-            f.write("   ".join(force[index].split()[1:]))
-            f.write("\\n")
-with open("isolated_atoms.xyz", "r") as f:
-    atoms = f.read()
-with open("train.xyz", "a") as f:
-    f.write(atoms)
-"""

aiida_chemshell-0.3.1/src/aiida_chemshell/calculations/solvant_removal.py

@@ -1,115 +0,0 @@
-"""Module for performing a solvant removal CalcJob."""
-
-from aiida.common import CalcInfo, CodeInfo
-from aiida.common.folders import Folder
-from aiida.engine import CalcJob, CalcJobProcessSpec
-from aiida.orm import Int, SinglefileData
-
-from aiida_chemshell.utils import xyz_file_validator
-
-
-class SolvantRemovalCalcJob(CalcJob):
-    """CalcJob to extract a solvant from a complex for NEB calculations."""
-
-    _SCRIPT_NAME = "separate_solvant.py"
-
-    @classmethod
-    def define(cls, spec: CalcJobProcessSpec) -> None:
-        """Define the CalcJob spec for solvant removal."""
-        super().define(spec)
-        spec.input(
-            "structure",
-            valid_type=SinglefileData,
-            required=True,
-            validator=xyz_file_validator,
-            help=(
-                "Input structure file containing ligand+solvant gas phase complex "
-                "in XYZ format."
-            ),
-        )
-        spec.input(
-            "num_ligand_atoms",
-            valid_type=Int,
-            required=True,
-            help="Number of atoms within the core ligand molecule.",
-        )
-        spec.output(
-            "unbound_structure",
-            valid_type=SinglefileData,
-            required=True,
-            help="Gas phase structure for the unboun ligand+solvant complex.",
-        )
-
-        spec.inputs["metadata"]["options"]["resources"].default = {
-            "num_machines": 1,
-            "num_mpiprocs_per_machine": 1,
-        }
-        spec.inputs["metadata"]["options"]["parser_name"].default = "chemshell.unbind"
-
-    def prepare_for_submission(self, folder: Folder) -> CalcInfo:
-        """Prepare the CalcJob for submission."""
-        py_scipt = self._generate_python_script()
-        with folder.open(SolvantRemovalCalcJob._SCRIPT_NAME, "w") as handle:
-            handle.write(py_scipt)
-
-        code_info = CodeInfo()
-        code_info.code_uuid = self.inputs.code.uuid
-        code_info.cmdline_params = [SolvantRemovalCalcJob._SCRIPT_NAME]
-
-        calc_info = CalcInfo()
-        calc_info.codes_info = [code_info]
-        calc_info.retrieve_temporary_list = []
-        calc_info.provenance_exclude_list = []
-        calc_info.retrieve_list = [self._generate_output_filename()]
-        calc_info.local_copy_list = [
-            (
-                self.inputs.structure.uuid,
-                self.inputs.structure.filename,
-                self.inputs.structure.filename,
-            ),
-        ]
-
-        return calc_info
-
-    @classmethod
-    def generate_output_filename(cls, input_filename) -> str:
-        """Generate a filename based on the name of the initial structure file."""
-        return input_filename.replace(".xyz", "_unbound.xyz")
-
-    def _generate_output_filename(self) -> str:
-        """Generate the output filename."""
-        return self.generate_output_filename(self.inputs.structure.filename)
-
-    def _generate_python_script(self) -> str:
-        """Generate the Python script to be executed."""
-        return f"""
-import numpy
-with open("{self.inputs.structure.filename}", "r") as f:
-    lines = f.readlines()
-natoms = int(lines[0].strip())
-ligand = []
-for i in range(2, {int(self.inputs.num_ligand_atoms)} + 2):
-    line = lines[i].split()
-    ligand.append(numpy.array([float(line[1]), float(line[2]), float(line[3])]))
-solvant = []
-for i in range({int(self.inputs.num_ligand_atoms)} + 2, natoms + 2):
-    line = lines[i].split()
-    solvant.append(numpy.array([float(line[1]), float(line[2]), float(line[3])]))
-ligand_center = numpy.mean(ligand, axis=0)
-solvant_center = numpy.mean(solvant, axis=0)
-vector = solvant_center - ligand_center
-distance = numpy.linalg.norm(vector)
-vector /= distance
-displacement = vector * 10.0  # Move solvant 10 Angstroms away
-with open("{self._generate_output_filename()}", "w") as f:
-    f.write(f"{{natoms}}\\n")
-    f.write("Unbound ligand+solvant complex\\n")
-    for i in range(2, {int(self.inputs.num_ligand_atoms)} + 2):
-        f.write(lines[i])
-    for i in range({int(self.inputs.num_ligand_atoms)} + 2, natoms + 2):
-        line = lines[i].split()
-        x = float(line[1]) + displacement[0]
-        y = float(line[2]) + displacement[1]
-        z = float(line[3]) + displacement[2]
-        f.write(f"{{line[0]}} {{x:.8f}} {{y:.8f}} {{z:.8f}}\\n")
-"""

aiida_chemshell-0.3.1/src/aiida_chemshell/parsers/file_conversion.py

@@ -1,54 +0,0 @@
-"""Defines the parser for the split trajectory CalcJob."""
-
-import os
-
-from aiida.engine import ExitCode
-from aiida.orm import SinglefileData
-from aiida.parsers.parser import Parser
-
-
-class CreateJanusTrainingInputsParser(Parser):
-    """AiiDA parser plugin for SplitTrajectory CalcJob."""
-
-    def parse(self, **kwargs):
-        """AiiDA parser plugin for SplitTrajectory CalcJob."""
-        description_str = "MLIP {} data set extracted from ChemShell calculation."
-        retrieved_temporary_folder = kwargs.get("retrieved_temporary_folder", None)
-
-        # with self.retrieved.open("train.xyz", "r") as f:
-        with open(os.path.join(retrieved_temporary_folder, "train.xyz"), "rb") as f:
-            self.out(
-                "training_input",
-                SinglefileData(
-                    file=f,
-                    filename="train.xyz",
-                    label="MLIP training data.",
-                    description=description_str.format("training"),
-                ),
-            )
-
-        # with self.retrieved.open("test.xyz", "r") as f:
-        with open(os.path.join(retrieved_temporary_folder, "test.xyz"), "rb") as f:
-            self.out(
-                "test_input",
-                SinglefileData(
-                    file=f,
-                    filename="test.xyz",
-                    label="MLIP test data.",
-                    description=description_str.format("testing"),
-                ),
-            )
-
-        # with self.retrieved.open("valid.xyz", "r") as f:
-        with open(os.path.join(retrieved_temporary_folder, "valid.xyz"), "rb") as f:
-            self.out(
-                "validation_input",
-                SinglefileData(
-                    file=f,
-                    filename="valid.xyz",
-                    label="MLIP validation data.",
-                    description=description_str.format("validation"),
-                ),
-            )
-
-        return ExitCode(0)