Merge branch 'openff-support' into v2.0

Adds the optional OpenFF (SMIRNOFF + NAGL) force field backend.

Author: Chenghao-Wu

AutoPoly/__init__.py

@@ -70,6 +70,7 @@
     "get_strategy",
     "Reactor",
     "ReactorResult",
+    "OpenFFTyper",
     "mc",
     "__version__",
     "__author__",
@@ -115,6 +116,10 @@
     )
     from .reactor import Reactor, ReactorResult
     from . import mc
+    # OpenFFTyper imports the openff packages lazily (only when used), so the
+    # class itself is always importable; parameterization without the optional
+    # openff-toolkit installed raises GenerationError with install hints.
+    from .forcefields.openff_typing import OpenFFTyper
 except ImportError as e:
     import warnings
     warnings.warn(
@@ -128,4 +133,5 @@
     generate = None
     Reactor = None
     ReactorResult = None
+    OpenFFTyper = None
     mc = None

AutoPoly/core/conf.py

@@ -43,6 +43,8 @@
     "gaff2": "GAFF2. Updated GAFF with improved parameters.",
     "dreiding": "DREIDING. Generic, element-based. Good for unusual chemistry.",
     "compass": "COMPASS. Optimized for condensed-phase properties.",
+    "openff": "OpenFF SMIRNOFF (Sage). Direct chemical perception; NAGL GNN "
+              "charges by default. Optional: requires openff-toolkit.",
 }
 
 # Central registry of per-force-field file/class mappings.
@@ -79,6 +81,15 @@
         "inherits": "COMPASS",
         "fdefn": "compass_lt.fdefn",
     },
+    # OpenFF is different in kind: no static .lt ships in extern/ and no
+    # .fdefn SMARTS table is used. Typing runs through the openff-toolkit
+    # (label_molecules) in pipeline/typing.py, which *generates* a per-system
+    # openff.lt into the build directory (see forcefields/openff_typing.py).
+    "openff": {
+        "lt_file": "openff.lt",
+        "inherits": "OPENFF",
+        "fdefn": None,
+    },
 }
 
 VALID_FORCE_FIELDS = list(FORCE_FIELD_REGISTRY.keys())

AutoPoly/forcefields/force_field.py

@@ -56,7 +56,8 @@ class ForceFieldManager:
         path_cwd (str): Current working directory for the project
         path_master (str): Path to external dependencies
         path_moltemplatesrc (str): Path to Moltemplate source
-        force_field (str): Force field type ("oplsaa", "gaff", "gaff2", or "lopls")
+        force_field (str): Force field type ("oplsaa", "gaff", "gaff2", "lopls",
+            "dreiding", "compass", or "openff")
         ff_modify_dihedral (np.ndarray): Modified dihedral parameters
         path_oplsaaprm (str): Path to OPLS-AA force field parameters
         gaff_analyzer (GAFFAnalyzer): GAFF analyzer instance (for GAFF/GAFF2 force field)
@@ -87,12 +88,20 @@ def __init__(self, path_cwd: str, path_master: str, path_moltemplatesrc: str,
 
         # Set force field parameter path based on force_field type
         # All force fields now use .lt files from moltemplate/force_fields/
+        # (openff excepted: its per-system openff.lt is generated at typing
+        # time, so no bundled file exists under force_fields/)
         self.path_oplsaaprm = str(
             Path(self.path_master) / "moltemplate" / "force_fields"
             / FORCE_FIELD_REGISTRY[force_field]["lt_file"]
         )
 
-        logger.info(f"\n'you are now using parameter set of {self.path_oplsaaprm}\n")
+        if force_field == "openff":
+            logger.info(
+                "\n'you are now using a generated SMIRNOFF parameter set "
+                "(openff.lt from the typing stage)\n"
+            )
+        else:
+            logger.info(f"\n'you are now using parameter set of {self.path_oplsaaprm}\n")
 
         # Initialize GAFF analyzer if using GAFF/GAFF2 force field
         self.gaff_analyzer = None
@@ -123,6 +132,8 @@ def make_force_field_lt(self) -> None:
 
         This is the main entry point for force field file generation. It delegates
         to the appropriate method based on the force field type:
+        - For OPENFF: verifies the per-system openff.lt generated by UnitTyper
+          is in place (nothing to subset — SMIRNOFF parameters are per-molecule)
         - For GAFF/GAFF2: creates a filtered subset using GAFFAnalyzer
         - For DREIDING/COMPASS: creates a filtered subset based on monomer topology
         - For OPLS-AA/LOPLS: copies .lt file directly (new moltemplate 2.22.5 format)
@@ -135,7 +146,9 @@ def make_force_field_lt(self) -> None:
             SystemExit: If force field file generation fails
         """
         try:
-            if self.force_field in ("gaff", "gaff2"):
+            if self.force_field == "openff":
+                self.make_openff_lt()
+            elif self.force_field in ("gaff", "gaff2"):
                 self.make_gaff_lt()
             elif self.force_field == "dreiding":
                 # DREIDING: create subset based on topology
@@ -150,6 +163,34 @@ def make_force_field_lt(self) -> None:
         except Exception as e:
             raise WorkflowError(f"Error in make_force_field_lt: {str(e)}") from e
 
+    def make_openff_lt(self) -> None:
+        """
+        Verify the generated openff.lt is in place (OpenFF path).
+
+        Unlike the static force fields, openff.lt is not a bundled parameter
+        file: SMIRNOFF assigns parameters per molecule, so the file is
+        generated by UnitTyper (stage 2) into the build directory and copied
+        here (the moltemplate working dir) by BoxPacker via the monomer_files
+        manifest. There is nothing to subset — this method only checks the
+        hand-off happened.
+
+        Raises:
+            GenerationError: If openff.lt is missing (e.g. the build dir was
+                not produced by UnitTyper(force_field='openff')).
+        """
+        dst = Path(self.path_cwd) / "openff.lt"
+        if not dst.exists():
+            raise GenerationError(
+                f"openff.lt not found in {self.path_cwd}. With "
+                "force_field='openff' the parameter file is generated during "
+                "typing (UnitTyper) and copied by BoxPacker — do not run the "
+                "force-field stage from a non-OpenFF build directory."
+            )
+        logger.info(
+            f"  Using generated OpenFF parameter file: {dst} "
+            f"({dst.stat().st_size} bytes)"
+        )
+
     def make_gaff_lt(self) -> None:
         """
         Create GAFF force field file using GAFFAnalyzer.