composite-step 2026.11.11__py2.py3-none-any.whl

composite_step/__init__.py

@@ -0,0 +1,26 @@
+# -*- coding: utf-8 -*-
+
+"""
+composite_step
+A SEAMM plug-in for composite methods: energies from recipes of ordinary calculations
+"""
+
+# Bring up the classes so that they appear to be directly in
+# the composite_step package.
+
+from .composite import Composite  # noqa: F401, E501
+from .composite_parameters import CompositeParameters  # noqa: F401, E501
+from .composite_step import CompositeStep  # noqa: F401, E501
+from .tk_composite import TkComposite  # noqa: F401, E501
+
+from .metadata import metadata  # noqa: F401
+
+# Handle versioneer
+from ._version import get_versions
+
+__author__ = "Paul Saxe"
+__email__ = "psaxe@molssi.org"
+versions = get_versions()
+__version__ = versions["version"]
+__git_revision__ = versions["full-revisionid"]
+del get_versions, versions

composite_step/_version.py

@@ -0,0 +1,21 @@
+
+# This file was generated by 'versioneer.py' (0.18) from
+# revision-control system data, or from the parent directory name of an
+# unpacked source archive. Distribution tarballs contain a pre-generated copy
+# of this file.
+
+import json
+
+version_json = '''
+{
+ "date": "2026-11-11T20:16:54-0500",
+ "dirty": false,
+ "error": null,
+ "full-revisionid": "bd87d3e0e8117b78603103c0d6b0de26ee0c75e7",
+ "version": "2026.11.11"
+}
+'''  # END VERSION_JSON
+
+
+def get_versions():
+    return json.loads(version_json)

composite_step/composite.py

@@ -0,0 +1,147 @@
+# -*- coding: utf-8 -*-
+
+"""Non-graphical part of the Composite step in a SEAMM flowchart"""
+
+import logging
+import importlib.resources
+import pprint  # noqa: F401
+
+import composite_step
+import molsystem
+import seamm
+from seamm_util import ureg, Q_  # noqa: F401
+import seamm_util.printing as printing
+from seamm_util.printing import FormattedText as __
+
+# In addition to the normal logger, two logger-like printing facilities are
+# defined: "job" and "printer". "job" send output to the main job.out file for
+# the job, and should be used very sparingly, typically to echo what this step
+# will do in the initial summary of the job.
+#
+# "printer" sends output to the file "step.out" in this steps working
+# directory, and is used for all normal output from this step.
+
+logger = logging.getLogger(__name__)
+job = printing.getPrinter()
+printer = printing.getPrinter("Composite")
+
+# Add this module's properties to the standard properties
+path = importlib.resources.files("composite_step") / "data"
+csv_file = path / "properties.csv"
+if path.exists():
+    molsystem.add_properties_from_file(csv_file)
+
+
+class Composite(seamm.Node):
+    """
+    The non-graphical part of a Composite step in a flowchart.
+
+    Attributes
+    ----------
+    parser : configargparse.ArgParser
+        The parser object.
+
+    options : tuple
+        It contains a two item tuple containing the populated namespace and the
+        list of remaining argument strings.
+
+    subflowchart : seamm.Flowchart
+        A SEAMM Flowchart object that represents a subflowchart, if needed.
+
+    parameters : CompositeParameters
+        The control parameters for Composite.
+
+    See Also
+    --------
+    TkComposite,
+    Composite, CompositeParameters
+    """
+
+    def __init__(
+        self, flowchart=None, title="Composite", extension=None, logger=logger
+    ):
+        """A step for Composite in a SEAMM flowchart.
+
+        You may wish to change the title above, which is the string displayed
+        in the box representing the step in the flowchart.
+
+        Parameters
+        ----------
+        flowchart: seamm.Flowchart
+            The non-graphical flowchart that contains this step.
+
+        title: str
+            The name displayed in the flowchart.
+        extension: None
+            Not yet implemented
+        logger : Logger = logger
+            The logger to use and pass to parent classes
+
+        Returns
+        -------
+        None
+        """
+        logger.debug(f"Creating Composite {self}")
+
+        super().__init__(
+            flowchart=flowchart,
+            title="Composite",
+            extension=extension,
+            module=__name__,
+            logger=logger,
+        )  # yapf: disable
+
+        self._metadata = composite_step.metadata
+        self.parameters = composite_step.CompositeParameters()
+
+    @property
+    def version(self):
+        """The semantic version of this module."""
+        return composite_step.__version__
+
+    @property
+    def git_revision(self):
+        """The git version of this module."""
+        return composite_step.__git_revision__
+
+    def description_text(self, P=None):
+        """Create the text description of what this step will do.
+        The dictionary of control values is passed in as P so that
+        the code can test values, etc.
+
+        Parameters
+        ----------
+        P: dict
+            An optional dictionary of the current values of the control
+            parameters.
+        Returns
+        -------
+        str
+            A description of the current step.
+        """
+        if not P:
+            P = self.parameters.values_to_dict()
+
+        text = (
+            "Composite methods are used through a Model Chemistry step, as "
+            "SEAMM:CMP@<recipe> (e.g. SEAMM:CMP@revDSD-r2SCAN-3c-HO), by the steps "
+            "that take a model chemistry, such as Thermochemistry. This step "
+            "itself does nothing yet."
+        )
+
+        return self.header + "\n" + __(text, **P, indent=4 * " ").__str__()
+
+    def run(self):
+        """Run a Composite step: print what it does, which is nothing yet.
+
+        Returns
+        -------
+        seamm.Node
+            The next node object in the flowchart.
+        """
+        next_node = super().run(printer)
+        printer.important(__(self.description_text({}), indent=self.indent))
+        return next_node
+
+    def analyze(self, indent="", **kwargs):
+        """Nothing to analyze yet."""

composite_step/composite_parameters.py

@@ -0,0 +1,101 @@
+# -*- coding: utf-8 -*-
+"""
+Control parameters for the Composite step in a SEAMM flowchart
+"""
+
+import logging
+import seamm
+import pprint  # noqa: F401
+
+logger = logging.getLogger(__name__)
+
+
+class CompositeParameters(seamm.Parameters):
+    """
+    The control parameters for Composite.
+
+    You need to replace the "time" entry in dictionary below these comments with the
+    definitions of parameters to control this step. The keys are parameters for the
+    current plugin,the values are dictionaries as outlined below.
+
+    Examples
+    --------
+    ::
+
+        parameters = {
+            "time": {
+                "default": 100.0,
+                "kind": "float",
+                "default_units": "ps",
+                "enumeration": tuple(),
+                "format_string": ".1f",
+                "description": "Simulation time:",
+                "help_text": ("The time to simulate in the dynamics run.")
+            },
+        }
+
+    parameters : {str: {str: str}}
+        A dictionary containing the parameters for the current step.
+        Each key of the dictionary is a dictionary that contains the
+        the following keys:
+
+    parameters["default"] :
+        The default value of the parameter, used to reset it.
+
+    parameters["kind"] : enum()
+        Specifies the kind of a variable. One of  "integer", "float", "string",
+        "boolean", or "enum"
+
+        While the "kind" of a variable might be a numeric value, it may still have
+        enumerated custom values meaningful to the user. For instance, if the parameter
+        is a convergence criterion for an optimizer, custom values like "normal",
+        "precise", etc, might be adequate. In addition, any parameter can be set to a
+        variable of expression, indicated by having "$" as the first character in the
+        field. For example, $OPTIMIZER_CONV.
+
+    parameters["default_units"] : str
+        The default units, used for resetting the value.
+
+    parameters["enumeration"] : tuple
+        A tuple of enumerated values.
+
+    parameters["format_string"] : str
+        A format string for "pretty" output.
+
+    parameters["description"] : str
+        A short string used as a prompt in the GUI.
+
+    parameters["help_text"] : str
+        A longer string to display as help for the user.
+
+    See Also
+    --------
+    Composite, TkComposite, Composite CompositeParameters, CompositeStep
+    """
+
+    #: No parameters yet: composites are used through a Model Chemistry step.
+    parameters = {}
+
+    def __init__(self, defaults={}, data=None):
+        """
+        Initialize the parameters, by default with the parameters defined above
+
+        Parameters
+        ----------
+        defaults: dict
+            A dictionary of parameters to initialize. The parameters
+            above are used first and any given will override/add to them.
+        data: dict
+            A dictionary of keys and a subdictionary with value and units
+            for updating the current, default values.
+
+        Returns
+        -------
+        None
+        """
+
+        logger.debug("CompositeParameters.__init__")
+
+        super().__init__(
+            defaults={**CompositeParameters.parameters, **defaults}, data=data
+        )

composite_step/composite_step.py

@@ -0,0 +1,198 @@
+# -*- coding: utf-8 -*-
+
+import logging
+from pathlib import Path
+
+import composite_step
+
+logger = logging.getLogger(__name__)
+
+
+class CompositeStep(object):
+    """Helper class needed for the stevedore integration.
+
+    This must provide a `description()` method that returns a dict containing a
+    description of this node, and `create_node()` and `create_tk_node()` methods
+    for creating the graphical and non-graphical nodes.
+
+    The dictionary for the description is the class variable just below these
+    comments. The felds are as follows:
+
+        my_description : {str, str}
+            A human-readable description of this step. It can be
+            several lines long, and needs to be clear to non-expert users.
+            It contains the following keys: description, group, name.
+
+        my_description["description"] : tuple
+            A description of the Composite step. It must be
+            clear to non-experts.
+
+        my_description["group"] : str
+            Which group in the menus to put this step. If the group does
+            not exist it will be created. Common groups are "Building",
+            "Control", "Custom", "Data", and "Simulations".
+
+        my_description["name"] : str
+            The name of this step, to be displayed in the menus.
+    """
+
+    my_description = {
+        "description": "An interface for Composite",
+        "group": "Simulations",
+        "name": "Composite",
+    }
+
+    def __init__(self, flowchart=None, gui=None):
+        """Initialize this helper class, which is used by
+        the application via stevedore to get information about
+        and create node objects for the flowchart
+        """
+        pass
+
+    @classmethod
+    def get_model_chemistry_options(
+        cls, periodic_only=False, mdi_only=False, data_path=None
+    ):
+        """The composite methods SEAMM provides: ``SEAMM:CMP@<recipe>`` for the
+        newest version of each recipe found.
+
+        The recipes are the shipped set plus those in a ``recipes/`` directory of
+        each ``data_path`` entry (a job's data, the user's). Composites are
+        molecular and have no MDI engine or gradients yet, so a periodic-only or
+        MDI-only request gets nothing.
+
+        Whether the codes for a recipe's components are installed is not checked
+        here: that needs the other steps' model chemistries, and asking for them
+        from inside model-chemistry discovery would recurse. The step checks it
+        before it runs anything (:func:`composite_step.recipes.check_capabilities`).
+        """
+        from .recipes import RecipeLibrary
+
+        if periodic_only or mdi_only:
+            return {}
+        extra = []
+        for directory in data_path or ():
+            extra.append(Path(directory) / "recipes")
+        library = RecipeLibrary(extra_directories=extra)
+        for problem in library.problems:
+            logger.warning("Composite recipes: %s", problem)
+        options = {}
+        for name in library.names():
+            recipe = library.get(name)
+            scale, source = recipe.zpe_scale
+            options[recipe.model_chemistry] = {
+                "model_chemistry": recipe.model_chemistry,
+                "type": "CMP",
+                "method": recipe.name,
+                "basis": None,
+                "description": recipe.description or recipe.name,
+                "periodic": False,
+                "mdi_capable": False,
+                "analytic_hessian": False,
+                "parallel_tasks": True,
+                "prefers_batch": True,
+                "recipe": recipe.name,
+                "recipe_version": recipe.version,
+                "recipe_source": recipe.source,
+                "geometry_level": recipe.geometry.get("level"),
+                "components": {k: v.get("level") for k, v in recipe.components.items()},
+                "zpe_scale": scale,
+                "zpe_scale_source": source,
+            }
+        return options
+
+    @classmethod
+    def can_run_task(cls, configuration, model_chemistry, **kwargs):
+        """Whether one task per structure can compute this composite: only when
+        E0 depends on one energy (the component's own task), for a molecule."""
+        from .evaluate import delegate
+        from .recipes import RecipeError
+
+        if int(getattr(configuration, "periodicity", 0) or 0) != 0:
+            return False
+        try:
+            _, _, mc, provider = delegate(model_chemistry)
+        except RecipeError:
+            return False
+        check = getattr(provider, "can_run_task", None)
+        return True if check is None else check(configuration, mc, **kwargs)
+
+    @classmethod
+    def get_task(cls, configuration, model_chemistry, **kwargs):
+        """The task of a one-energy recipe: its component's task. A recipe that
+        combines several calculations runs through
+        :func:`composite_step.evaluate.evaluate_recipe` instead."""
+        from .evaluate import delegated_get_task
+
+        return delegated_get_task(configuration, model_chemistry, **kwargs)
+
+    @classmethod
+    def analyze_task(cls, result, model_chemistry, configuration, **kwargs):
+        """The component's results with the energy replaced by the recipe's E0
+        (kJ/mol), and the composite described under ``composite``."""
+        from .evaluate import delegated_analyze_task
+
+        return delegated_analyze_task(result, model_chemistry, configuration, **kwargs)
+
+    @classmethod
+    def expected_fingerprints(cls, configuration, model_chemistry, **kwargs):
+        """The component's own expected fingerprints, for a one-energy recipe."""
+        from .evaluate import delegate
+        from .recipes import RecipeError
+
+        try:
+            _, _, mc, provider = delegate(model_chemistry)
+        except RecipeError:
+            return None
+        predict = getattr(provider, "expected_fingerprints", None)
+        return None if predict is None else predict(configuration, mc, **kwargs)
+
+    def create_node(self, flowchart=None, **kwargs):
+        """Create and return the new node object.
+
+        Parameters
+        ----------
+        flowchart: seamm.Node
+            A non-graphical SEAMM node
+
+        **kwargs : keyword arguments
+            Various keyword arguments such as title, namespace or
+            extension representing the title displayed in the flowchart,
+            the namespace for the plugins of a subflowchart and
+            the extension, respectively.
+
+        Returns
+        -------
+        Composite
+        """
+
+        return composite_step.Composite(flowchart=flowchart, **kwargs)
+
+    def create_tk_node(self, canvas=None, **kwargs):
+        """Create and return the graphical Tk node object.
+
+        Parameters
+        ----------
+        canvas : tk.Canvas
+            The Tk Canvas widget
+
+        **kwargs : keyword arguments
+            Various keyword arguments such as tk_flowchart, node, x, y, w, h
+            representing a graphical flowchart object, a non-graphical node for
+            a step, and dimensions of the graphical node.
+
+        Returns
+        -------
+        TkComposite
+        """
+
+        return composite_step.TkComposite(canvas=canvas, **kwargs)
+
+    def description(self):
+        """Return a description of what this step does.
+
+        Returns
+        -------
+        description : dict(str, str)
+        """
+        return CompositeStep.my_description

composite_step/data/properties.csv

@@ -0,0 +1 @@
+Property,Type,Units,Description,URL

composite_step/data/recipes/r2SCAN-3c-HO.yaml

@@ -0,0 +1,21 @@
+recipe: r2SCAN-3c-HO
+version: 1
+description: >-
+  r2SCAN-3c geometry, frequencies and energy (ORCA's own r2SCAN-3c composite),
+  with the ZPE scaled; HO = scaled harmonic thermal terms. The thermochemistry
+  step's 'quick' preset in 2026-11.
+reference: Grimme, Hansen, Ehlert, Mewes, J. Chem. Phys. 154, 064103 (2021)
+doi: 10.1063/5.0040021
+
+geometry:
+  level: ORCA:CMP@R2SCAN-3C
+frequencies:
+  scale_zpe: 0.9899
+  scale_source: >-
+    fitted to the anharmonic ZPVEs of 22 W4-2006 molecules (SEAMM, 2026-11);
+    seamm_thermochemistry's ZPE table for R2SCAN-3C
+
+components: {}
+
+combine: |
+  E0 = geometry

composite_step/data/recipes/revDSD-r2SCAN-3c-HO.yaml

@@ -0,0 +1,25 @@
+recipe: revDSD-r2SCAN-3c-HO
+version: 1
+description: >-
+  r2SCAN-3c geometry and frequencies (ZPE scaled), and the
+  revDSD-PBEP86-D4(2021)/def2-TZVPP energy at that geometry; HO = scaled
+  harmonic thermal terms. The thermochemistry step's 'default' preset in 2026-11.
+reference: >-
+  Grimme, Hansen, Ehlert, Mewes, J. Chem. Phys. 154, 064103 (2021);
+  Santra, Sylvetsky, Martin, J. Phys. Chem. A 123, 5129 (2019)
+doi: 10.1063/5.0040021
+
+geometry:
+  level: ORCA:CMP@R2SCAN-3C
+frequencies:
+  scale_zpe: 0.9899
+  scale_source: >-
+    fitted to the anharmonic ZPVEs of 22 W4-2006 molecules (SEAMM, 2026-11);
+    seamm_thermochemistry's ZPE table for R2SCAN-3C
+
+components:
+  revdsd:
+    level: ORCA:DFT@REVDSD-PBEP86-D4_2021/def2-TZVPP
+
+combine: |
+  E0 = revdsd

composite_step/data/references.bib

@@ -0,0 +1,40 @@
+This is an initial library of BibTex references for the composite_step plug-in for SEAMM,
+generated automatically by the cookiecutter. You may wish to edit the first entry to correct some
+of the information.
+
+Add other references to the end of the file and add code in the plug-in to cite the references as
+appropriate. This is done with code like this:
+
+        self.references.cite(
+            raw=self._bibliography['doi:10.1002/jcc.21224'],
+            alias='packmol',
+            module='packmol_step',
+            level=1,
+            note='The principle PACKMOL citation.'
+        )
+
+which is typically in the run() method of the plug-in.
+
+The base node class in SEAMM automatically reads this list of references into a dictionary in
+self._bibliography with the key being the key of the BibTex entry -- usually the name on the
+first line of the entry after the 'article' or 'misc' (for software) keyword.
+
+See the documentation for the Reference Handler for the other arguments to cite().
+
+# End of initial comments #
+
+# This is the citation for this plug-in, generated and used automatically.
+# You might need to edit the author, address, etc. The month, year and version fields
+# are automatically filled in with information about current version of the plug-in.
+# This is handled in seamm/nody.py, the run() method.
+
+@Misc{composite_step,
+	author = {Paul Saxe},
+	title = {Composite plug-in for SEAMM},
+	month = {$month},
+	year = {$year},
+	organization = {molssi-seamm},
+	url = {https://github.com/molssi-seamm/composite_step },
+	address = {USA},
+	version = {$version}
+}