feat: add fail-closed DPA4 PT2 runtime support

Author: Zikkying

.gitignore

@@ -49,6 +49,8 @@ confs
 # Generated MatMaster skill archive
 apex-flow.zip
 
-# Large DeePMD checkpoints (fetch with scripts/fetch_models.py; keep frozen *.pb in git)
+# Exclude arbitrary DeePMD training/source checkpoints, but keep the one
+# authoritative single-task DPA4 model bundled by apex-flow.
 apex/skills/apex-flow/models/**/*.pt
+!apex/skills/apex-flow/models/DPA4-alloytongqi/model.pt
 apex/skills/apex-flow/models/**/*.partial

CHANGELOG-1.3.0.md

@@ -15,6 +15,8 @@ Major additions include:
 - Finite-temperature lattice workflow improvements
 - Finite-temperature elasticity workflow support and example documentation
 - Annealing workflow support for LAMMPS
+- Melting-point workflow support for solid-liquid coexistence calculations
+- Image-resident DPA4/PT2 runtime support with a fail-closed T4 qualification profile
 - Shape-controlled automatic supercell generation
 - `req_calc`-based relaxation/property selection for joint workflows
 - GUI-side batched submission for large configuration sets
@@ -74,6 +76,21 @@ Major additions include:
 - Added LAMMPS annealing workflow support.
 - Improved generated annealing input scripts for heating, cooling, RDF output, and holding stages.
 
+### Melting Point Workflow
+
+- Added a LAMMPS solid-liquid coexistence workflow for estimating melting points across multiple temperatures and replicas.
+- Added restart-file staging, interface-axis controls, per-temperature restart validation, and generated skill templates.
+- Added input validation and regression coverage for melting-specific temperature, replica, restart, and backend constraints.
+
+### DPA4/PT2 Runtime and Qualification
+
+- Added image-resident DeePMD PT2 model handling so immutable runtime artifacts are not copied into task upload packages.
+- Added DPA4-aware LAMMPS input generation, including the required atom maps, runtime plugin auto-loading, and rejection of incompatible legacy plugin commands.
+- Added an audited `DPA4-alloytongqi` source checkpoint, container wrapper templates, runtime manifest template, and a reproducible CPU/GPU and phonoLAMMPS benchmark harness.
+- Added a single-source DPA4 runtime profile used by generation, recommendation, standalone validation, and submission. The bundled profile remains fail-closed until an immutable image `ref@digest` passes the recorded post-snapshot T4 qualification.
+- Restricted the qualified production contract to one MPI rank on one `c4_m15_1 * NVIDIA T4`, with exact image, wrapper, model hash, and dispatcher validation.
+- Added complete automatic `type_map` expansion across every resolved structure and every effective LAMMPS `overwrite_interaction`.
+
 ### Workflow Selection and Submission
 
 - Added `req_calc`-based workflow selection for relaxation and property calculations.
@@ -94,6 +111,7 @@ Major additions include:
   - `.debug.log`
   - `.debug.stdout`
   - `.debug.stderr`
+- Added bounded retries for transient LAMMPS remote-startup failures, including header-only logs, retry evidence preservation, and explicit retry classification in task status files.
 
 ### Reporting
 
@@ -126,4 +144,5 @@ Major additions include:
 - Added runnable examples for RSS, GammaSurface, and finite-temperature elasticity.
 - Added GUI developer documentation.
 - Added `monty` to the package dependencies and constrained supported Python versions to `<3.13`.
-- Added support for Phonopy v4 in terms of phonon calculation.
+- Added Phonopy v4-compatible setup, force-constant, and band-generation fallbacks.
+- Expanded the bundled `apex-flow` skill with backend-aware generation and validation for Bohrium, local debug, local cluster, VASP, LAMMPS, DPA4/PT2, melting-point, gamma, and finite-temperature workflows.

apex/core/calculator/Lammps.py

@@ -149,6 +149,24 @@ def __init__(self, inter_parameter, path_to_poscar):
         self.inter_type = inter_parameter["type"]
         self.type_map = inter_parameter["type_map"]
         self.in_lammps = inter_parameter.get("in_lammps", "auto")
+        self.model_in_image = inter_parameter.get("model_in_image", False)
+        if not isinstance(self.model_in_image, bool):
+            raise ValueError("interaction.model_in_image must be a boolean")
+        if self.model_in_image:
+            model = inter_parameter.get("model")
+            if not lammps_utils.is_deepmd_pt2(inter_parameter):
+                raise ValueError(
+                    "interaction.model_in_image is only supported with "
+                    "type=deepmd and deepmd_runtime=dpa4_pt2"
+                )
+            if (
+                not isinstance(model, str)
+                or not os.path.isabs(model)
+                or not model.lower().endswith(".pt2")
+            ):
+                raise ValueError(
+                    "an image-resident DPA4 model must be an absolute .pt2 path"
+                )
         if self.inter_type in MULTI_MODELS_INTER_TYPE:
             self.model = list(map(os.path.abspath, inter_parameter["model"]))
         else:
@@ -182,13 +200,17 @@ def set_inter_type_func(self):
     def set_model_param(self):
         deepmd_version = self.inter.get("deepmd_version", "2.1.1")
         if self.inter_type == "deepmd":
-            model_name = os.path.basename(self.model)
+            model_name = self.model if self.model_in_image else os.path.basename(self.model)
             self.model_param = {
                 "type": self.inter_type,
                 "model_name": [model_name],
                 "param_type": self.type_map,
                 "deepmd_version": deepmd_version,
             }
+            if "deepmd_runtime" in self.inter:
+                self.model_param["deepmd_runtime"] = self.inter["deepmd_runtime"]
+            if self.model_in_image:
+                self.model_param["model_in_image"] = True
         elif self.inter_type in ["meam", "snap"]:
             model_name = list(map(os.path.basename, self.model))
             self.model_param = {
@@ -231,6 +253,10 @@ def symlink_force(self, target, link_name):
         os.symlink(target, link_name)
 
     def make_potential_files(self, output_dir):
+        if self.model_in_image:
+            dumpfn(self.inter, os.path.join(output_dir, "inter.json"), indent=4)
+            return
+
         parent_dir = os.path.join(output_dir, "../../")
         if self.inter_type in MULTI_MODELS_INTER_TYPE:
             model_file = map(os.path.basename, self.model)
@@ -446,6 +472,9 @@ def make_input_file(self, output_dir, task_type, task_param):
         ):
             fc = _apply_gamma_fix_to_lammps_input(fc, task_param["add_fix"])
 
+        # This also covers user-supplied and property-specific LAMMPS inputs.
+        fc = lammps_utils.ensure_atom_map_before_read_data(fc, self.model_param)
+
         dumpfn(task_param, os.path.join(output_dir, "task.json"), indent=4)
 
         in_lammps_not_link_list = ["eos", "finite_t_elastic"]
@@ -717,7 +746,11 @@ def _prepare_result_dict(self, atom_numbs, type_map_list, type_list, box, coord,
         return result_dict
 
     def forward_files(self, property_type="relaxation", task_param=None):
-        model_files = list(map(os.path.basename, self.model)) if self.inter_type in MULTI_MODELS_INTER_TYPE else [os.path.basename(self.model)]
+        model_files = [] if self.model_in_image else (
+            list(map(os.path.basename, self.model))
+            if self.inter_type in MULTI_MODELS_INTER_TYPE
+            else [os.path.basename(self.model)]
+        )
         if property_type == "finite_t_latt":
             return ["in.lammps", "variable_FiniteTlatt.in"] + model_files
         elif property_type == "melting_point":
@@ -749,7 +782,11 @@ def forward_files(self, property_type="relaxation", task_param=None):
             return ["conf.lmp", "in.lammps"] + model_files
 
     def forward_common_files(self, property_type="relaxation"):
-        model_files = list(map(os.path.basename, self.model)) if self.inter_type in MULTI_MODELS_INTER_TYPE else [os.path.basename(self.model)]
+        model_files = [] if self.model_in_image else (
+            list(map(os.path.basename, self.model))
+            if self.inter_type in MULTI_MODELS_INTER_TYPE
+            else [os.path.basename(self.model)]
+        )
         if property_type not in ["eos"]:
             if property_type == "finite_t_latt":
                 return ["in.lammps", "variable_FiniteTlatt.in"] + model_files

apex/core/calculator/__init__.py

@@ -10,3 +10,19 @@
     'mace',
     'nep'
 ]
+
+
+def lammps_model_files_for_cleanup(inter_param):
+    """Return staged model paths that APEX may remove after retrieval.
+
+    Image-resident models are immutable runtime assets rather than staged task
+    files.  Never turn their absolute paths into cleanup commands.
+    """
+    if inter_param.get("model_in_image") is True:
+        return []
+    model = inter_param.get("model")
+    if isinstance(model, str):
+        return [model]
+    if isinstance(model, list):
+        return list(model)
+    return []

apex/core/calculator/lib/lammps_utils.py

@@ -14,6 +14,59 @@
 upload_packages.append(__file__)
 
 
+DEEPMD_RUNTIME_DPA4_PT2 = "dpa4_pt2"
+
+
+def is_deepmd_pt2(param):
+    """Return whether an interaction uses the DeepMD AOTI ``.pt2`` runtime."""
+    return (
+        param.get("type") == "deepmd"
+        and str(param.get("deepmd_runtime", "")).strip().lower()
+        == DEEPMD_RUNTIME_DPA4_PT2
+    )
+
+
+def ensure_atom_map_before_read_data(input_text, param):
+    """Enable a LAMMPS atom map before each PT2 box-loading command.
+
+    DPA4 AOTI inference consumes LAMMPS atom IDs through the DeepMD plugin.
+    Keep legacy DeepMD inputs byte-for-byte unchanged unless the interaction
+    explicitly opts into ``deepmd_runtime: dpa4_pt2``.
+    """
+    if not is_deepmd_pt2(param):
+        return input_text
+
+    lines = input_text.splitlines(keepends=True)
+    rewritten = []
+    previous_command = []
+    for line in lines:
+        command = line.split("#", 1)[0].strip().split()
+        if (
+            command[:2] == ["plugin", "load"]
+            and len(command) >= 3
+            and os.path.basename(command[2].strip("'\"")) == "libdeepmd_lmp.so"
+        ):
+            raise ValueError(
+                "DPA4/PT2 inputs must use LAMMPS_PLUGIN_PATH auto-loading; "
+                "explicitly loading legacy libdeepmd_lmp.so is not supported"
+            )
+        if (
+            command
+            and command[0] in {"read_data", "read_restart"}
+            and not (
+                previous_command[:2] == ["atom_modify", "map"]
+                and len(previous_command) >= 3
+                and previous_command[2].lower() in {"yes", "array", "hash"}
+            )
+        ):
+            newline = "\r\n" if line.endswith("\r\n") else "\n"
+            rewritten.append(f"atom_modify map yes{newline}")
+        rewritten.append(line)
+        if command:
+            previous_command = command
+    return "".join(rewritten)
+
+
 def cvt_lammps_conf(fin, fout, type_map, ofmt="lammps/data"):
     """
     Format convert from fin to fout, specify the output format by ofmt
@@ -298,7 +351,7 @@ def make_lammps_eval(conf, type_map, interaction, param):
     ret += 'print "Final volume per atoms = ${Vpa}"\n'
     ret += 'print "Final Base area = ${AA}"\n'
     ret += 'print "Final Stress (xx yy zz xy xz yz) = ${Pxx} ${Pyy} ${Pzz} ${Pxy} ${Pxz} ${Pyz}"\n'
-    return ret
+    return ensure_atom_map_before_read_data(ret, param)
 
 
 def make_lammps_equi(
@@ -320,10 +373,9 @@ def make_lammps_equi(
     make lammps input for equilibritation
     """
     deepmd_version = param.get("deepmd_version", None)
-    is_new_dpmd = False
-    if deepmd_version:
-        split_v = deepmd_version.split('.')
-        is_new_dpmd = bool(int(split_v[0]) >= 2 and int(split_v[1]) >= 1 and int(split_v[2]) >= 5)
+    is_new_dpmd = bool(
+        deepmd_version and Version(deepmd_version) >= Version("2.1.5")
+    )
     prop_type = kwargs.get("prop_type", "others")
     dump_step = 100
     # detour sychronizing problem of dumping in new version of deepmd-kit >=2.1.5
@@ -385,7 +437,7 @@ def make_lammps_equi(
     ret += 'print "Final volume per atoms = ${Vpa}"\n'
     ret += 'print "Final Base area = ${AA}"\n'
     ret += 'print "Final Stress (xx yy zz xy xz yz) = ${Pxx} ${Pyy} ${Pzz} ${Pxy} ${Pxz} ${Pyz}"\n'
-    return ret
+    return ensure_atom_map_before_read_data(ret, param)
 
 
 def make_lammps_elastic(
@@ -435,7 +487,7 @@ def make_lammps_elastic(
     ret += 'print "Final energy per atoms = ${Epa}"\n'
     ret += 'print "Final volume per atoms = ${Vpa}"\n'
     ret += 'print "Final Stress (xx yy zz xy xz yz) = ${Pxx} ${Pyy} ${Pzz} ${Pxy} ${Pxz} ${Pyz}"\n'
-    return ret
+    return ensure_atom_map_before_read_data(ret, param)
 
 def make_lammps_FiniteTlatt(conf, type_map, interaction, param, cal_setting=None):
     type_map_list = element_list(type_map)
@@ -521,7 +573,7 @@ def make_lammps_FiniteTlatt(conf, type_map, interaction, param, cal_setting=None
     ret += 'print "Final Base area = ${AA}"\n'
     ret += 'print "Final Stress (xx yy zz xy xz yz) = ${Pxx} ${Pyy} ${Pzz} ${Pxy} ${Pxz} ${Pyz}"\n'
     ret += 'print "Final Length (box_x box_y box_z) = ${lx} ${ly} ${lz}"\n'
-    return ret
+    return ensure_atom_map_before_read_data(ret, param)
 
 def make_lammps_FiniteTelastic(conf, type_map, interaction, param, task_dir="."):
     type_map_list = element_list(type_map)
@@ -617,7 +669,7 @@ def force_field_setup():
     ret += "print \"Final energy per atoms = ${Epa}\"\n"
     ret += "print \"Final volume per atoms = ${Vpa}\"\n"
     ret += "print \"Final Stress (xx yy zz xy xz yz) = ${Pxx} ${Pyy} ${Pzz} ${Pxy} ${Pxz} ${Pyz}\"\n"
-    return ret
+    return ensure_atom_map_before_read_data(ret, param)
 
 def make_lammps_press_relax(
     conf,
@@ -690,7 +742,7 @@ def make_lammps_press_relax(
     ret += 'print "Final energy per atoms = ${Epa} eV"\n'
     ret += 'print "Final volume per atoms = ${Vpa} A^3"\n'
     ret += 'print "Final Stress (xx yy zz xy xz yz) = ${Pxx} ${Pyy} ${Pzz} ${Pxy} ${Pxz} ${Pyz}"\n'
-    return ret
+    return ensure_atom_map_before_read_data(ret, param)
 
 def make_lammps_annealing(conf, type_map, interaction, param, cal_setting):
     """LAMMPS input for annealing using the same stage controls as annealing/.
@@ -896,7 +948,7 @@ def _unfix_stage_analysis(stage):
 
     ret += 'print "__end_of_lmp_annealing_calculation__"\n'
     ret += 'label end_of_run\n'
-    return ret
+    return ensure_atom_map_before_read_data(ret, param)
 
 """
 def make_lammps_phonon(

apex/core/property/Phonon.py

@@ -18,6 +18,7 @@
 from apex.core.calculator.calculator import LAMMPS_INTER_TYPE
 from apex.core.calculator.lib import abacus_utils
 from apex.core.calculator.lib import vasp_utils
+from apex.core.calculator.lib.lammps_utils import is_deepmd_pt2
 from apex.core.property.Property import Property
 from apex.core.refine import make_refine
 from apex.core.reproduce import make_repro, post_repro

apex/op/RunLAMMPS.py

@@ -54,6 +54,9 @@ def _cleanup_model_links(cls, task_dir):
             logging.warning(f"Failed to load inter.json for symlink cleanup: {exc}")
             return
 
+        if inter_param.get("model_in_image") is True:
+            return
+
         model_spec = inter_param.get("model", [])
         if isinstance(model_spec, str):
             model_list = [model_spec]

apex/op/property_ops.py

@@ -12,7 +12,7 @@
 from monty.serialization import dumpfn
 from apex.utils import recursive_search, apex_task_succeeded
 from apex.core.lib.utils import create_path
-from apex.core.calculator import LAMMPS_INTER_TYPE
+from apex.core.calculator import LAMMPS_INTER_TYPE, lammps_model_files_for_cleanup
 from apex.task_failure import (
     REMOTE_LAMMPS_STARTUP_FAILURE,
     classify_apex_task_status,
@@ -377,11 +377,7 @@ def execute(self, op_in: OPIO) -> OPIO:
         # remove potential files in each task
         if inter_type in LAMMPS_INTER_TYPE:
             os.chdir(abs_path_to_prop)
-            inter_files_name = []
-            if type(inter_param["model"]) is str:
-                inter_files_name = [inter_param["model"]]
-            elif type(inter_param["model"]) is list:
-                inter_files_name.extend(inter_param["model"])
+            inter_files_name = lammps_model_files_for_cleanup(inter_param)
             for file in inter_files_name:
                 cmd = f"rm -f ../{file}"
                 subprocess.call(cmd, shell=True)

apex/op/relaxation_ops.py

@@ -9,7 +9,7 @@
     Artifact,
     upload_packages
 )
-from apex.core.calculator import LAMMPS_INTER_TYPE
+from apex.core.calculator import LAMMPS_INTER_TYPE, lammps_model_files_for_cleanup
 from apex.utils import recursive_search, apex_task_succeeded
 
 upload_packages.append(__file__)
@@ -199,23 +199,21 @@ def execute(self, op_in: OPIO) -> OPIO:
             # remove potential files
             inter_files_name = []
             if inter_type in LAMMPS_INTER_TYPE:
-                if type(inter_param["model"]) is str:
-                    inter_files_name = [inter_param["model"]]
-                elif type(inter_param["model"]) is list:
-                    inter_files_name.extend(inter_param["model"])
+                inter_files_name = lammps_model_files_for_cleanup(inter_param)
             elif inter_type == 'vasp':
                 inter_files_name = ['POTCAR']
 
-            for ii in conf_dirs:
-                cmd = 'rm -f'
-                for jj in inter_files_name:
-                    cmd += f' {jj}'
-                os.chdir(ii)
-                subprocess.call(cmd, shell=True)
-                os.chdir(op_in['input_all'])
-                os.chdir(os.path.join(ii, 'relaxation/relax_task'))
-                subprocess.call(cmd, shell=True)
-                os.chdir(op_in['input_all'])
+            if inter_files_name:
+                for ii in conf_dirs:
+                    cmd = 'rm -f'
+                    for jj in inter_files_name:
+                        cmd += f' {jj}'
+                    os.chdir(ii)
+                    subprocess.call(cmd, shell=True)
+                    os.chdir(op_in['input_all'])
+                    os.chdir(os.path.join(ii, 'relaxation/relax_task'))
+                    subprocess.call(cmd, shell=True)
+                    os.chdir(op_in['input_all'])
 
         os.chdir(cwd)
         for ii in copy_dir_list: