kim-tools 0.3.6__py3-none-any.whl → 0.4.2__py3-none-any.whl

kim_tools/test_driver/core.py

@@ -30,12 +30,16 @@
 Helper classes for KIM Test Drivers
 
 """
+import glob
+import json
 import logging
 import os
 import shutil
+import tarfile
 from abc import ABC, abstractmethod
 from copy import deepcopy
 from pathlib import Path
+from secrets import token_bytes
 from tempfile import NamedTemporaryFile, TemporaryDirectory
 from typing import IO, Any, Dict, List, Optional, Union
 
@@ -44,7 +48,9 @@ import kim_edn
 import numpy as np
 import numpy.typing as npt
 from ase import Atoms
+from ase.build import bulk
 from ase.calculators.calculator import Calculator
+from ase.calculators.kim import get_model_supported_species
 from ase.constraints import FixSymmetry
 from ase.data import atomic_masses
 from ase.filters import FrechetCellFilter, UnitCellFilter
@@ -63,6 +69,7 @@ from kim_query import raw_query
 from ..aflow_util import (
     AFLOW,
     get_space_group_number_from_prototype,
+    get_stoich_reduced_list_from_prototype,
     prototype_labels_are_equivalent,
 )
 from ..aflow_util.core import AFLOW_EXECUTABLE, get_atom_indices_for_each_wyckoff_orb
@@ -91,6 +98,8 @@ __all__ = [
     "detect_unique_crystal_structures",
     "get_deduplicated_property_instances",
     "minimize_wrapper",
+    "crystal_input_from_test_generator_line",
+    "get_supported_lammps_atom_style",
 ]
 
 # Force tolerance for the optional initial relaxation of the provided cell
@@ -102,6 +111,50 @@ PROP_SEARCH_PATHS_INFO = (
     "- $PWD/local-props/**/\n"
     "- $PWD/local_props/**/"
 )
+TOKEN_NAME = "kim-tools.token"
+TOKENPATH = os.path.join("output", TOKEN_NAME)
+
+
+def get_supported_lammps_atom_style(model: str) -> str:
+    """
+    Get the supported LAMMPS atom_style of a KIM model
+    """
+    from lammps import lammps
+
+    candidate_atom_styles = ("atomic", "charge", "full")
+    banned_species = "electron"  # Species in KIM models not understood by ASE
+    supported_species = get_model_supported_species(model)
+    test_species = None
+    for species in supported_species:
+        if species not in banned_species:
+            test_species = species
+            break
+    if test_species is None:
+        raise RuntimeError(
+            "Model appears to only support species not understood by ASE:\n"
+            + str(supported_species)
+        )
+    atoms = bulk(test_species, "fcc", 10.0)  # Very low-density FCC lattice
+    for atom_style in candidate_atom_styles:
+        with lammps(cmdargs=["-sc", "none"]) as lmp, NamedTemporaryFile() as f:
+            lmp.command(f"kim init {model} metal unit_conversion_mode")
+            atoms.write(f.name, format="lammps-data", atom_style=atom_style)
+            try:
+                lmp.command(f"read_data {f.name}")
+                return atom_style
+            except Exception as e:
+                if str(e).startswith(
+                    "ERROR: Incorrect format in Atoms section of data file:"
+                ):
+                    continue
+                else:
+                    msg = (
+                        "The following unexpected exception was encountered when trying"
+                        " to determine atom_style:\n" + repr(e)
+                    )
+                    print(msg)
+                    raise e
+    raise RuntimeError("Unable to determine supported atom type")
 
 
 def _get_optional_source_value(property_instance: Dict, key: str) -> Any:
@@ -137,8 +190,8 @@ def minimize_wrapper(
     steps: int = MAXSTEPS_INITIAL,
     variable_cell: bool = True,
     logfile: Optional[Union[str, IO]] = "kim-tools.log",
-    algorithm: Optimizer = LBFGSLineSearch,
-    cell_filter: UnitCellFilter = FrechetCellFilter,
+    algorithm: type[Optimizer] = LBFGSLineSearch,
+    cell_filter: type[UnitCellFilter] = FrechetCellFilter,
     fix_symmetry: Union[bool, FixSymmetry] = False,
     opt_kwargs: Dict = {},
     flt_kwargs: Dict = {},
@@ -189,12 +242,13 @@ def minimize_wrapper(
     Returns:
         Whether the minimization succeeded
     """
+    existing_constraints = atoms.constraints
     if fix_symmetry is not False:
         if fix_symmetry is True:
             symmetry = FixSymmetry(atoms)
         else:
             symmetry = fix_symmetry
-        atoms.set_constraint(symmetry)
+        atoms.set_constraint([symmetry] + existing_constraints)
     if variable_cell:
         supercell_wrapped = cell_filter(atoms, **flt_kwargs)
         opt = algorithm(supercell_wrapped, logfile=logfile, **opt_kwargs)
@@ -226,7 +280,7 @@ def minimize_wrapper(
         + " steps."
     )
 
-    del atoms.constraints
+    atoms.set_constraint(existing_constraints)
 
     if minimization_stalled or iteration_limits_reached:
         try:
@@ -240,7 +294,7 @@ def minimize_wrapper(
                 "trying to evaluate final forces and stress:"
             )
             logger.info(repr(e))
-            return False
+        return False
     else:
         return True
 
@@ -345,8 +399,15 @@ def _add_property_instance(
                                 property_name = path_str
                                 found_custom_property = True
                                 break
-                    except Exception:
-                        pass
+                    except Exception as e:
+                        msg = (
+                            "MESSAGE: Trying to load a property from the .edn file at\n"
+                            f"{path}\n"
+                            "failed with the following exception:\n"
+                            f"{repr(e)}"
+                        )
+                        logger.info(msg)
+                        print(msg)
 
         if not found_custom_property:
             raise KIMTestDriverError(
@@ -500,6 +561,14 @@ class KIMTestDriver(ABC):
         __output_property_instances (str):
             Property instances, possibly accumulated over multiple invocations of
             the Test Driver
+        __files_to_keep_in_output (List[PathLike]):
+            List of files that were written by this class explicitly, that we won't
+            touch when cleaning and backing up the output directory. Specified
+            relative to 'output' directory.
+        __token (Optional[bytes]):
+            Token that is written to TOKENPATH upon first evaluation. This
+            is used to check that multiple Test Drivers are not being called
+            concurrently, causing potential conflicts in the output directory
     """
 
     class NonKIMModelError(Exception):
@@ -509,11 +578,15 @@ class KIMTestDriver(ABC):
         requires a KIM model (e.g. a LAMMPS TD) with a non-KIM Calculator
         """
 
-    def __init__(self, model: Union[str, Calculator]) -> None:
+    def __init__(
+        self, model: Union[str, Calculator], suppr_sm_lmp_log: bool = False
+    ) -> None:
         """
         Args:
             model:
                 ASE calculator or KIM model name to use
+            suppr_sm_lmp_log:
+                Suppress writing a lammps.log
         """
         if isinstance(model, Calculator):
             self.__calc = model
@@ -523,8 +596,13 @@ class KIMTestDriver(ABC):
 
             self.__kim_model_name = model
             self.__calc = KIM(self.__kim_model_name)
+            if suppr_sm_lmp_log:
+                if hasattr(self.__calc.parameters, "log_file"):
+                    self.__calc.parameters.log_file = None
 
         self.__output_property_instances = "[]"
+        self.__files_to_keep_in_output = []
+        self.__token = None
 
     def _setup(self, material, **kwargs) -> None:
         """
@@ -532,6 +610,106 @@ class KIMTestDriver(ABC):
         """
         pass
 
+    def _init_output_dir(self) -> None:
+        """
+        Initialize the output directory
+        """
+        if self.__token is None:
+            # First time we've called this instance of the class
+            assert len(self.property_instances) == 0
+
+            os.makedirs("output", exist_ok=True)
+
+            # Move all top-level non-hidden files and directories
+            # to backup
+            output_glob = glob.glob("output/*")
+            if len(output_glob) > 0:
+                i = 0
+                while os.path.exists(f"output.{i}"):
+                    i += 1
+                output_bak_name = f"output.{i}"
+                msg = (
+                    "'output' directory is non-empty, backing up all "
+                    f"non-hidden files and directories to {output_bak_name}"
+                )
+                print(msg)
+                logger.info(msg)
+                os.mkdir(output_bak_name)
+                for file_in_output in output_glob:
+                    shutil.move(file_in_output, output_bak_name)
+
+            # Create token
+            self.__token = token_bytes(16)
+            with open(TOKENPATH, "wb") as f:
+                f.write(self.__token)
+            self.__files_to_keep_in_output.append(TOKEN_NAME)
+        else:
+            # Token is stored, check that it matches the token file
+            if not os.path.isfile(TOKENPATH):
+                raise KIMTestDriverError(
+                    f"Token file at {TOKENPATH} was not found,"
+                    "can't confirm non-interference of Test Drivers. Did something "
+                    "edit the 'output' directory between calls to this Test Driver?"
+                )
+            else:
+                with open(TOKENPATH, "rb") as f:
+                    if self.__token != f.read():
+                        raise KIMTestDriverError(
+                            f"Token file at {TOKENPATH} does not match this object's "
+                            "token. This likely means that a different KIMTestDriver "
+                            "instance was called between calls to this one. In order to"
+                            " prevent conflicts in the output directory, this is not "
+                            "allowed."
+                        )
+
+        # We should have a record of all non-hidden files in output. If any
+        # untracked files are present, raise an error
+        output_glob = glob.glob("output/**", recursive=True)
+        for filepath in output_glob:
+            if os.path.isfile(filepath):  # not tracking directories
+                if (
+                    os.path.relpath(filepath, "output")
+                    not in self.__files_to_keep_in_output
+                ):
+                    raise KIMTestDriverError(
+                        f"Unknown file {filepath} in 'output' directory appeared "
+                        "between calls to this Test Driver. This is not allowed "
+                        "because stray files can cause issues."
+                    )
+
+    def _archive_aux_files(self) -> None:
+        """
+        Archive aux files after a run
+        """
+        # Archive untracked files as aux files
+        i = 0
+        while f"aux_files.{i}.txz" in self.__files_to_keep_in_output:
+            assert os.path.isfile(f"output/aux_files.{i}.txz")
+            i += 1
+        tar_prefix = f"aux_files.{i}"
+        output_glob = glob.glob("output/**", recursive=True)
+        archived_files = []  # For deleting them later
+        with tarfile.open(f"output/{tar_prefix}.txz", "w:xz") as tar:
+            for filepath in output_glob:
+                if os.path.isfile(filepath):  # not tracking directories
+                    output_relpath = os.path.relpath(filepath, "output")
+                    if output_relpath not in self.__files_to_keep_in_output:
+                        tar.add(
+                            os.path.join(filepath),
+                            os.path.join(tar_prefix, output_relpath),
+                        )
+                        archived_files.append(filepath)
+        self.__files_to_keep_in_output.append(f"{tar_prefix}.txz")
+        for filepath in archived_files:
+            os.remove(filepath)
+            try:
+                os.removedirs(os.path.dirname(filepath))
+            except OSError:
+                pass  # might not be empty yet
+
+        # should not have removed output dir in any situation
+        assert os.path.isdir("output")
+
     @abstractmethod
     def _calculate(self, **kwargs) -> None:
         """
@@ -546,8 +724,10 @@ class KIMTestDriver(ABC):
 
             * Run :func:`~KIMTestDriver._setup` (the base class provides a barebones
               version, derived classes may override)
+            * Call :func:`~KIMTestDriver._init_output_dir`
             * Call :func:`~KIMTestDriver._calculate` (implemented by each individual
               Test Driver)
+            * Call :func:`~KIMTestDriver._archive_aux_files`
 
         Args:
             material:
@@ -557,8 +737,12 @@ class KIMTestDriver(ABC):
         Returns:
             The property instances calculated during the current run
         """
+
         # count how many instances we had before we started
-        previous_properties_end = len(kim_edn.loads(self.__output_property_instances))
+        previous_properties_end = len(self.property_instances)
+
+        # Set up the output directory
+        self._init_output_dir()
 
         # _setup is likely overridden by an derived class
         self._setup(material, **kwargs)
@@ -566,9 +750,12 @@ class KIMTestDriver(ABC):
         # implemented by each individual Test Driver
         self._calculate(**kwargs)
 
+        # Postprocess output directory for this invocation
+        self._archive_aux_files()
+
         # The current invocation returns a Python list of dictionaries containing all
         # properties computed during this run
-        return kim_edn.loads(self.__output_property_instances)[previous_properties_end:]
+        return self.property_instances[previous_properties_end:]
 
     def _add_property_instance(
         self, property_name: str, disclaimer: Optional[str] = None
@@ -686,7 +873,7 @@ class KIMTestDriver(ABC):
 
         input_name = filename_path.name
         if add_instance_id:
-            current_instance_id = len(kim_edn.loads(self.__output_property_instances))
+            current_instance_id = len(self.property_instances)
             root, ext = os.path.splitext(input_name)
             root = root + "-" + str(current_instance_id)
             final_name = root + ext
@@ -699,10 +886,18 @@ class KIMTestDriver(ABC):
 
         shutil.move(filename, final_path)
 
+        output_relpath = os.path.relpath(final_path, output_path)
         # Filenames are reported relative to $CWD/output
-        self._add_key_to_current_property_instance(
-            name, os.path.relpath(final_path, output_path)
-        )
+        self._add_key_to_current_property_instance(name, output_relpath)
+        self.__files_to_keep_in_output.append(output_relpath)
+
+    def _get_supported_lammps_atom_style(self) -> str:
+        """
+        Return the atom_style that should be used when writing LAMMPS data files.
+        This atom_style will be compatible with the KIM model this object
+        was instantiated with.
+        """
+        return get_supported_lammps_atom_style(self.kim_model_name)
 
     @property
     def kim_model_name(self) -> Optional[str]:
@@ -727,8 +922,20 @@ class KIMTestDriver(ABC):
     @property
     def _calc(self) -> Optional[Calculator]:
         """
-        Get the ASE calculator
+        Get the ASE calculator. Reinstantiate it if it's a KIM SM
         """
+        if self.__kim_model_name is not None:
+            reinst = False
+            if hasattr(self.__calc, "clean"):
+                self.__calc.clean()
+                reinst = True
+            if hasattr(self.__calc, "__del__"):
+                self.__calc.__del__()
+                reinst = True
+            if reinst:
+                from ase.calculators.kim.kim import KIM
+
+                self.__calc = KIM(self.__kim_model_name)
         return self.__calc
 
     def _get_serialized_property_instances(self) -> str:
@@ -746,17 +953,23 @@ class KIMTestDriver(ABC):
     def write_property_instances_to_file(self, filename="output/results.edn") -> None:
         """
         Write internal property instances (possibly accumulated over several calls to
-        the Test Driver) to a file at the requested path. Also dumps any cached files to
-        the same directory.
+        the Test Driver) to a file at the requested path.
 
         Args:
             filename: path to write the file
         """
-
-        with open(filename, "w") as f:
-            kim_property_dump(
-                self.__output_property_instances, f
-            )  # serialize the dictionary to string first
+        filename_parent = Path(filename).parent.resolve()
+        os.makedirs(filename_parent, exist_ok=True)
+        kim_property_dump(self._get_serialized_property_instances(), filename)
+        if filename_parent != Path("output").resolve():
+            msg = (
+                f"Writing properties .edn file to non-standard location {filename}. "
+                "note that all other files remain in 'output' directory."
+            )
+            print(msg)
+            logger.info(msg)
+        else:
+            self.__files_to_keep_in_output.append(os.path.relpath(filename, "output"))
 
     def get_isolated_energy_per_atom(self, symbol: str) -> float:
         """
@@ -791,6 +1004,7 @@ def _add_common_crystal_genome_keys_to_current_property_instance(
     temperature_unit: Optional[str] = "K",
     crystal_genome_source_structure_id: Optional[List[List[str]]] = None,
     aflow_executable: str = AFLOW_EXECUTABLE,
+    omit_keys: Optional[List[str]] = None,
 ) -> str:
     """
     Write common Crystal Genome keys to the last element of ``property_instances``. See
@@ -804,19 +1018,26 @@ def _add_common_crystal_genome_keys_to_current_property_instance(
             The key will be added to the last dictionary in the list
         aflow_executable:
             Path to the AFLOW executable
+        omit_keys:
+            Which keys to omit writing
 
     Returns:
         Updated EDN-serialized list of property instances
     """
-    property_instances = _add_key_to_current_property_instance(
-        property_instances, "prototype-label", prototype_label
-    )
-    property_instances = _add_key_to_current_property_instance(
-        property_instances, "stoichiometric-species", stoichiometric_species
-    )
-    property_instances = _add_key_to_current_property_instance(
-        property_instances, "a", a, a_unit
-    )
+    if omit_keys is None:
+        omit_keys = []
+    if "prototype-label" not in omit_keys:
+        property_instances = _add_key_to_current_property_instance(
+            property_instances, "prototype-label", prototype_label
+        )
+    if "stoichiometric-species" not in omit_keys:
+        property_instances = _add_key_to_current_property_instance(
+            property_instances, "stoichiometric-species", stoichiometric_species
+        )
+    if "a" not in omit_keys:
+        property_instances = _add_key_to_current_property_instance(
+            property_instances, "a", a, a_unit
+        )
 
     # get parameter names
     aflow = AFLOW(aflow_executable=aflow_executable)
@@ -833,24 +1054,28 @@ def _add_common_crystal_genome_keys_to_current_property_instance(
                 "Incorrect number of parameter_values (i.e. dimensionless parameters "
                 "besides a) for the provided prototype"
             )
-        property_instances = _add_key_to_current_property_instance(
-            property_instances, "parameter-names", aflow_parameter_names[1:]
-        )
-        property_instances = _add_key_to_current_property_instance(
-            property_instances, "parameter-values", parameter_values
-        )
+        if "parameter-names" not in omit_keys:
+            property_instances = _add_key_to_current_property_instance(
+                property_instances, "parameter-names", aflow_parameter_names[1:]
+            )
+        if "parameter-values" not in omit_keys:
+            property_instances = _add_key_to_current_property_instance(
+                property_instances, "parameter-values", parameter_values
+            )
 
     if short_name is not None:
         if not isinstance(short_name, list):
             short_name = [short_name]
-        property_instances = _add_key_to_current_property_instance(
-            property_instances, "short-name", short_name
-        )
+        if "short-name" not in omit_keys:
+            property_instances = _add_key_to_current_property_instance(
+                property_instances, "short-name", short_name
+            )
 
     if library_prototype_label is not None:
-        property_instances = _add_key_to_current_property_instance(
-            property_instances, "library-prototype-label", library_prototype_label
-        )
+        if "library-prototype-label" not in omit_keys:
+            property_instances = _add_key_to_current_property_instance(
+                property_instances, "library-prototype-label", library_prototype_label
+            )
 
     if cell_cauchy_stress is not None:
         if len(cell_cauchy_stress) != 6:
@@ -859,27 +1084,30 @@ def _add_common_crystal_genome_keys_to_current_property_instance(
                 "order [xx, yy, zz, yz, xz, xy]"
             )
         if cell_cauchy_stress_unit is None:
-            raise KIMTestDriver("Please provide a `cell_cauchy_stress_unit`")
-        property_instances = _add_key_to_current_property_instance(
-            property_instances,
-            "cell-cauchy-stress",
-            cell_cauchy_stress,
-            cell_cauchy_stress_unit,
-        )
+            raise KIMTestDriverError("Please provide a `cell_cauchy_stress_unit`")
+        if "cell-cauchy-stress" not in omit_keys:
+            property_instances = _add_key_to_current_property_instance(
+                property_instances,
+                "cell-cauchy-stress",
+                cell_cauchy_stress,
+                cell_cauchy_stress_unit,
+            )
 
     if temperature is not None:
         if temperature_unit is None:
-            raise KIMTestDriver("Please provide a `temperature_unit`")
-        property_instances = _add_key_to_current_property_instance(
-            property_instances, "temperature", temperature, temperature_unit
-        )
+            raise KIMTestDriverError("Please provide a `temperature_unit`")
+        if "temperature" not in omit_keys:
+            property_instances = _add_key_to_current_property_instance(
+                property_instances, "temperature", temperature, temperature_unit
+            )
 
     if crystal_genome_source_structure_id is not None:
-        property_instances = _add_key_to_current_property_instance(
-            property_instances,
-            "crystal-genome-source-structure-id",
-            crystal_genome_source_structure_id,
-        )
+        if "crystal-genome-source-structure-id" not in omit_keys:
+            property_instances = _add_key_to_current_property_instance(
+                property_instances,
+                "crystal-genome-source-structure-id",
+                crystal_genome_source_structure_id,
+            )
 
     return property_instances
 
@@ -901,6 +1129,7 @@ def _add_property_instance_and_common_crystal_genome_keys(
     disclaimer: Optional[str] = None,
     property_instances: Optional[str] = None,
     aflow_executable: str = AFLOW_EXECUTABLE,
+    omit_keys: Optional[List[str]] = None,
 ) -> str:
     """
     Initialize a new property instance to ``property_instances`` (an empty
@@ -923,6 +1152,8 @@ def _add_property_instance_and_common_crystal_genome_keys(
             A pre-existing EDN-serialized list of KIM Property instances to add to
         aflow_executable:
             Path to the AFLOW executable
+        omit_keys:
+            Which keys to omit writing
 
     Returns:
             Updated EDN-serialized list of property instances
@@ -945,6 +1176,7 @@ def _add_property_instance_and_common_crystal_genome_keys(
         cell_cauchy_stress_unit=cell_cauchy_stress_unit,
         cell_cauchy_stress=cell_cauchy_stress,
         aflow_executable=aflow_executable,
+        omit_keys=omit_keys,
     )
 
 
@@ -1193,17 +1425,22 @@ class SingleCrystalTestDriver(KIMTestDriver):
     """
 
     def __init__(
-        self, model: Union[str, Calculator], aflow_executable: str = AFLOW_EXECUTABLE
+        self,
+        model: Union[str, Calculator],
+        suppr_sm_lmp_log: bool = False,
+        aflow_executable: str = AFLOW_EXECUTABLE,
     ) -> None:
         """
         Args:
             model:
                 ASE calculator or KIM model name to use
+            suppr_sm_lmp_log:
+                Suppress writing a lammps.log
             aflow_executable:
                 Path to AFLOW executable
         """
         self.aflow_executable = aflow_executable
-        super().__init__(model)
+        super().__init__(model, suppr_sm_lmp_log=suppr_sm_lmp_log)
 
     def _setup(
         self,
@@ -1273,17 +1510,28 @@ class SingleCrystalTestDriver(KIMTestDriver):
             crystal_structure = get_crystal_structure_from_atoms(
                 atoms=material, aflow_executable=self.aflow_executable
             )
+            aflow = AFLOW()
+            atoms_rebuilt = get_atoms_from_crystal_structure(crystal_structure)
+            _, self.__input_rotation, _, _ = (
+                aflow.get_basistransformation_rotation_originshift_atom_map_from_atoms(
+                    atoms_rebuilt,
+                    material,
+                )
+            )
             msg = (
-                "Rebuilding atoms object in a standard setting defined by "
+                "Rebuilding Atoms object in a standard setting defined by "
                 "doi.org/10.1016/j.commatsci.2017.01.017. See log file or computed "
                 "properties for the (possibly re-oriented) primitive cell that "
-                "computations will be based on."
+                "computations will be based on. To obtain the rotation of this "
+                "cell relative to the Atoms object you provided, use "
+                f"{self.__class__.__name__}.get_input_rotation()"
             )
             logger.info(msg)
             print()
             print(msg)
             print()
         else:
+            self.__input_rotation = None
             crystal_structure = material
 
         # Pop the temperature and stress keys in case they came along with a query
@@ -1337,6 +1585,7 @@ class SingleCrystalTestDriver(KIMTestDriver):
         cell_rtol: float = 0.01,
         rot_rtol: float = 0.01,
         rot_atol: float = 0.01,
+        match_library_proto: bool = True,
     ) -> None:
         """
         Update the nominal parameter values of the nominal crystal structure from the
@@ -1381,6 +1630,8 @@ class SingleCrystalTestDriver(KIMTestDriver):
                 Parameter to pass to :func:`numpy.allclose` for compariong fractional
                 rotations. Default value chosen to be commensurate with AFLOW
                 default distance tolerance of 0.01*(NN distance)
+            match_library_proto:
+                Whether to match to library prototypes
 
         Raises:
             AFLOW.FailedToMatchException:
@@ -1393,18 +1644,29 @@ class SingleCrystalTestDriver(KIMTestDriver):
         """
         aflow = AFLOW(aflow_executable=self.aflow_executable)
         try:
-            (aflow_parameter_values, library_prototype_label, short_name) = (
-                aflow.solve_for_params_of_known_prototype(
+            if match_library_proto:
+                (aflow_parameter_values, library_prototype_label, short_name) = (
+                    aflow.solve_for_params_of_known_prototype(
+                        atoms=atoms,
+                        prototype_label=self.get_nominal_prototype_label(),
+                        max_resid=max_resid,
+                        cell_rtol=cell_rtol,
+                        rot_rtol=rot_rtol,
+                        rot_atol=rot_atol,
+                    )
+                )
+            else:
+                aflow_parameter_values = aflow.solve_for_params_of_known_prototype(
                     atoms=atoms,
-                    prototype_label=self.__nominal_crystal_structure_npt[
-                        "prototype-label"
-                    ]["source-value"],
+                    prototype_label=self.get_nominal_prototype_label(),
                     max_resid=max_resid,
                     cell_rtol=cell_rtol,
                     rot_rtol=rot_rtol,
                     rot_atol=rot_atol,
+                    match_library_proto=False,
                 )
-            )
+                library_prototype_label = None
+                short_name = None
         except (AFLOW.FailedToMatchException, AFLOW.ChangedSymmetryException) as e:
             raise type(e)(
                 "Encountered an error that MAY be the result of the nominal crystal "
@@ -1498,6 +1760,7 @@ class SingleCrystalTestDriver(KIMTestDriver):
         stress_unit: Optional[str] = None,
         temp_unit: str = "K",
         disclaimer: Optional[str] = None,
+        omit_keys: Optional[List[str]] = None,
     ) -> None:
         """
         Initialize a new property instance to ``self.property_instances``. It will
@@ -1528,6 +1791,8 @@ class SingleCrystalTestDriver(KIMTestDriver):
             disclaimer:
                 An optional disclaimer commenting on the applicability of this result,
                 e.g. "This relaxation did not reach the desired tolerance."
+            omit_keys:
+                Which keys to omit writing
         """
         crystal_structure = self.__nominal_crystal_structure_npt
 
@@ -1626,17 +1891,22 @@ class SingleCrystalTestDriver(KIMTestDriver):
                 disclaimer=disclaimer,
                 property_instances=super()._get_serialized_property_instances(),
                 aflow_executable=self.aflow_executable,
+                omit_keys=omit_keys,
             )
         )
 
-        self.__add_poscar_to_curr_prop_inst(
-            "primitive", "instance.poscar", "coordinates-file"
-        )
-        self.__add_poscar_to_curr_prop_inst(
-            "conventional",
-            "conventional.instance.poscar",
-            "coordinates-file-conventional",
-        )
+        if omit_keys is None:
+            omit_keys = []
+        if "coordinates-file" not in omit_keys:
+            self.__add_poscar_to_curr_prop_inst(
+                "primitive", "instance.poscar", "coordinates-file"
+            )
+        if "coordinates-file-conventional" not in omit_keys:
+            self.__add_poscar_to_curr_prop_inst(
+                "conventional",
+                "conventional.instance.poscar",
+                "coordinates-file-conventional",
+            )
 
     def _get_temperature(self, unit: str = "K") -> float:
         """
@@ -1872,18 +2142,65 @@ class SingleCrystalTestDriver(KIMTestDriver):
             "source-value"
         ]
 
+    def get_nominal_space_group_number(self) -> int:
+        return get_space_group_number_from_prototype(self.get_nominal_prototype_label())
+
+    def get_nominal_stoichiometric_species(self) -> List[str]:
+        return self._get_nominal_crystal_structure_npt()["stoichiometric-species"][
+            "source-value"
+        ]
+
+    def get_nominal_stoichiometry(self) -> List[int]:
+        return get_stoich_reduced_list_from_prototype(
+            self.get_nominal_prototype_label()
+        )
+
+    def get_nominal_a(self) -> float:
+        return self._get_nominal_crystal_structure_npt()["a"]["source-value"]
+
+    def get_nominal_parameter_names(self) -> List[str]:
+        return _get_optional_source_value(
+            self._get_nominal_crystal_structure_npt(), "parameter-names"
+        )
+
+    def get_nominal_parameter_values(self) -> List[float]:
+        return _get_optional_source_value(
+            self._get_nominal_crystal_structure_npt(), "parameter-values"
+        )
+
+    def get_nominal_short_name(self) -> List[str]:
+        return _get_optional_source_value(
+            self._get_nominal_crystal_structure_npt(), "short-name"
+        )
+
+    def get_nominal_library_prototype_label(self) -> str:
+        return _get_optional_source_value(
+            self._get_nominal_crystal_structure_npt(), "library-prototype-label"
+        )
+
     def get_atom_indices_for_each_wyckoff_orb(self) -> List[Dict]:
         """
         Get a list of dictionaries containing the atom indices of each Wyckoff
         orbit.
 
         Returns:
-            The information is in this format:
-
-            [{"letter":"a", "indices":[0,1]}, ... ]
+            The information is in this format --
+            ``[{"letter":"a", "indices":[0,1]}, ... ]``
         """
         return get_atom_indices_for_each_wyckoff_orb(self.get_nominal_prototype_label())
 
+    def get_input_rotation(self) -> Optional[npt.ArrayLike]:
+        """
+        Returns:
+            If the Test Driver was called with an Atoms object, the nominal crystal
+            structure may be rotated w.r.t. the input.
+            This returns the Cartesian rotation to transform the Atoms input to the
+            internal nominal crystal structure. I.e., if you want to get computed
+            tensor properties in the same orientation as your input, you should
+            rotate the reported tensors by the transpose of this rotation.
+        """
+        return self.__input_rotation
+
 
 def query_crystal_structures(
     stoichiometric_species: List[str],
@@ -2236,3 +2553,42 @@ def get_deduplicated_property_instances(
     property_instances_deduplicated.sort(key=lambda a: a["instance-id"])
 
     return property_instances_deduplicated
+
+
+def crystal_input_from_test_generator_line(
+    test_generator_line: str, kim_model_name: str
+) -> List[Dict]:
+    """
+    Produce a list of dictionaries of kwargs for a Crystal Genome Test Driver invocation
+    from a line in its ``test_generator.json``
+    """
+    test_generator_dict = json.loads(test_generator_line)
+    stoichiometric_species = test_generator_dict["stoichiometric_species"]
+    prototype_label = test_generator_dict["prototype_label"]
+    cell_cauchy_stress_eV_angstrom3 = test_generator_dict.get(
+        "cell_cauchy_stress_eV_angstrom3"
+    )
+    temperature_K = test_generator_dict.get("temperature_K")
+    crystal_genome_test_args = test_generator_dict.get("crystal_genome_test_args")
+    equilibria = query_crystal_structures(
+        stoichiometric_species=stoichiometric_species,
+        prototype_label=prototype_label,
+        kim_model_name=kim_model_name,
+    )
+    inputs = []
+    for equilibrium in equilibria:
+        inputs.append(
+            {
+                "material": equilibrium,
+            }
+        )
+        if cell_cauchy_stress_eV_angstrom3 is not None:
+            inputs[-1][
+                "cell_cauchy_stress_eV_angstrom3"
+            ] = cell_cauchy_stress_eV_angstrom3
+        if temperature_K is not None:
+            inputs[-1]["temperature_K"] = temperature_K
+        if crystal_genome_test_args is not None:
+            inputs[-1].update(crystal_genome_test_args)
+
+    return inputs