stjames 0.0.45__tar.gz → 0.0.47__tar.gz

{stjames-0.0.45/stjames.egg-info → stjames-0.0.47}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: stjames
-Version: 0.0.45
+Version: 0.0.47
 Summary: standardized JSON atom/molecule encoding scheme
 Author-email: Corin Wagen <corin@rowansci.com>
 Project-URL: Homepage, https://github.com/rowansci/stjames

{stjames-0.0.45 → stjames-0.0.47}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "stjames"
-version = "0.0.45"
+version = "0.0.47"
 description = "standardized JSON atom/molecule encoding scheme"
 readme = "README.md"
 requires-python = ">=3.11"

{stjames-0.0.45 → stjames-0.0.47}/stjames/base.py

@@ -12,7 +12,7 @@ class Base(pydantic.BaseModel):
     @classmethod
     def coerce_numpy(cls, val: _T) -> _T | list[Any]:
         if isinstance(val, np.ndarray):
-            return val.tolist()  # type: ignore [no-any-return, unused-ignore]
+            return val.tolist()  # type: ignore [no-any-return, unused-ignore, return-value]
 
         return val
 

{stjames-0.0.45 → stjames-0.0.47}/stjames/constraint.py

@@ -11,6 +11,7 @@ class ConstraintType(LowercaseStrEnum):
     BOND = "bond"
     ANGLE = "angle"
     DIHEDRAL = "dihedral"
+    FREEZE_ATOMS = "freeze_atoms"
 
 
 class Constraint(Base):
@@ -18,7 +19,7 @@ class Constraint(Base):
     Represents a single (absolute) constraint.
 
     :param constraint_type: which type
-    :param atoms: the atoms in question
+    :param atoms: the atoms in question. n.b. - these are 1-indexed!
     :param value: the value to constrain this to, leaving this blank sets the current value
     """
 
@@ -38,6 +39,9 @@ class Constraint(Base):
             case ConstraintType.DIHEDRAL:
                 if len(self.atoms) != 4:
                     raise ValueError("Dihedral constraint needs four atom indices!")
+            case ConstraintType.FREEZE_ATOMS:
+                if len(self.atoms) == 0:
+                    raise ValueError("Can't freeze atoms without any atoms to freeze!")
             case _:
                 raise ValueError("Unknown constraint_type!")
 
@@ -48,7 +52,7 @@ class PairwiseHarmonicConstraint(Base):
     """
     Represents a harmonic constraint, with a characteristic spring constant.
 
-    :param atoms: whch atoms to apply to
+    :param atoms: which atoms to apply to
     :param force_constant: the strength of the attraction, in kcal/mol/Å
     :param equilibrium: the distance at which force is zero
     """

{stjames-0.0.45 → stjames-0.0.47}/stjames/diis_settings.py

@@ -4,7 +4,7 @@ from .base import Base, LowercaseStrEnum
 
 
 class DIISStrategy(LowercaseStrEnum):
-    # regular pulay DIIS
+    # regular Pulay DIIS
     DIIS = "diis"
 
     # Hu/Yang JCP 2010 - ADIIS

{stjames-0.0.45 → stjames-0.0.47}/stjames/method.py

@@ -43,6 +43,8 @@ class Method(LowercaseStrEnum):
     # this was going to be removed, but Jonathon wrote such a nice basis set test... it's off the front end.
     BP86 = "bp86"
 
+    OFF_SAGE_2_2_1 = "off_sage_2_2_1"
+
 
 NNPMethod = Literal[Method.AIMNET2_WB97MD3]
 NNP_METHODS = [Method.AIMNET2_WB97MD3]
@@ -53,8 +55,11 @@ XTB_METHODS = [Method.GFN_FF, Method.GFN0_XTB, Method.GFN1_XTB, Method.GFN2_XTB]
 CompositeMethod = Literal[Method.HF3C, Method.B973C, Method.R2SCAN3C, Method.WB97X3C]
 COMPOSITE_METHODS = [Method.HF3C, Method.B973C, Method.R2SCAN3C, Method.WB97X3C]
 
-PrepackagedMethod = XTBMethod | CompositeMethod | NNPMethod
-PREPACKAGED_METHODS = [*XTB_METHODS, *COMPOSITE_METHODS]
+FFMethod = Literal[Method.OFF_SAGE_2_2_1]
+FF_METHODS = [Method.OFF_SAGE_2_2_1]
+
+PrepackagedMethod = XTBMethod | CompositeMethod | NNPMethod | FFMethod
+PREPACKAGED_METHODS = [*XTB_METHODS, *COMPOSITE_METHODS, *NNP_METHODS, *FF_METHODS]
 
 MethodWithCorrection = Literal[Method.WB97XD3, Method.WB97XV, Method.WB97MV, Method.WB97MD3BJ, Method.DSDBLYPD3BJ]
 METHODS_WITH_CORRECTION = [Method.WB97XD3, Method.WB97XV, Method.WB97MV, Method.WB97MD3BJ, Method.DSDBLYPD3BJ, Method.B97D3BJ]

{stjames-0.0.45 → stjames-0.0.47}/stjames/scf_settings.py

@@ -20,7 +20,7 @@ class SCFInitMethod(LowercaseStrEnum):
 class OrthonormalizationMethod(LowercaseStrEnum):
     SYMMETRIC = "symmetric"
     CANONICAL = "canonical"
-    # cholesky, in future?
+    # Cholesky, in future?
 
 
 class SCFSettings(Base):

stjames-0.0.47/stjames/workflows/__init__.py

@@ -0,0 +1,58 @@
+# ruff: noqa: F405
+from typing import Literal
+
+from .admet import *
+from .basic_calculation import *
+from .bde import *
+from .conformer import *
+from .conformer_search import *
+from .descriptors import *
+from .electronic_properties import *
+from .fukui import *
+from .hydrogen_bond_basicity import *
+from .molecular_dynamics import *
+from .multistage_opt import *
+from .pka import *
+from .redox_potential import *
+from .scan import *
+from .spin_states import *
+from .tautomer import *
+from .workflow import Workflow
+
+WORKFLOW_NAME = Literal[
+    "admet",
+    "basic_calculation",
+    "bde",
+    "conformers",
+    "conformer_search",
+    "descriptors",
+    "electronic_properties",
+    "fukui",
+    "hydrogen_bond_basicity",
+    "molecular_dynamics",
+    "multistage_opt",
+    "pka",
+    "redox_potential",
+    "scan",
+    "spin_states",
+    "tautomers",
+]
+
+WORKFLOW_MAPPING: dict[str, Workflow] = {
+    "admet": ADMETWorkflow,  # type: ignore [dict-item]
+    "basic_calculation": BasicCalculationWorkflow,  # type: ignore [dict-item]
+    "bde": BDEWorkflow,  # type: ignore [dict-item]
+    "conformers": ConformerWorkflow,  # type: ignore [dict-item]
+    "conformer_search": ConformerSearchWorkflow,  # type: ignore [dict-item]
+    "descriptors": DescriptorsWorkflow,  # type: ignore [dict-item]
+    "electronic_properties": ElectronicPropertiesWorkflow,  # type: ignore [dict-item]
+    "fukui": FukuiIndexWorkflow,  # type: ignore [dict-item]
+    "hydrogen_bond_basicity": HydrogenBondBasicityWorkflow,  # type: ignore [dict-item]
+    "molecular_dynamics": MolecularDynamicsWorkflow,  # type: ignore [dict-item]
+    "multistage_opt": MultiStageOptWorkflow,  # type: ignore [dict-item]
+    "pka": pKaWorkflow,  # type: ignore [dict-item]
+    "redox_potential": RedoxPotentialWorkflow,  # type: ignore [dict-item]
+    "scan": ScanWorkflow,  # type: ignore [dict-item]
+    "spin_states": SpinStatesWorkflow,  # type: ignore [dict-item]
+    "tautomers": TautomerWorkflow,  # type: ignore [dict-item]
+}

{stjames-0.0.45 → stjames-0.0.47}/stjames/workflows/bde.py

@@ -60,10 +60,10 @@ class BDEWorkflow(Workflow, MultiStageOptMixin):
     :param multistage_opt_settings: set by mode unless mode=MANUAL (ignores additional settings if set)
     :param solvent: solvent to use for singlepoint
     :param xtb_preopt: pre-optimize with xtb (sets based on mode when None)
+    :param frequencies: whether to calculate frequencies
 
     Overridden:
     :param mso_mode: Mode for MultiStageOptSettings
-    :param frequencies: whether to calculate frequencies
 
     Turned off:
     :param constraints: constraints to add (not supported)
@@ -81,7 +81,6 @@ class BDEWorkflow(Workflow, MultiStageOptMixin):
     """
 
     mso_mode: Mode = _sentinel_mso_mode  # type: ignore [assignment]
-    frequencies: bool = False
     optimize_fragments: bool = None  # type: ignore [assignment]
 
     atoms: tuple[PositiveInt, ...] = Field(default_factory=tuple)

{stjames-0.0.45 → stjames-0.0.47}/stjames/workflows/conformer_search.py

@@ -9,6 +9,7 @@ from ..base import LowercaseStrEnum
 from ..constraint import Constraint
 from ..method import Method, XTBMethod
 from ..mode import Mode
+from ..task import Task
 from ..types import UUID
 from .multistage_opt import MultiStageOptMixin
 from .workflow import Workflow
@@ -26,16 +27,16 @@ def check_sentinel(value: _T, default: _U) -> _T | _U:
 
 class ScreeningSettings(BaseModel):
     """
-    Settings for determing unique and useful conformers.
+    Settings for determining unique and useful conformers.
 
-    :param energy_threshhold: maximum relative energy for screening
-    :param rotational_constants_threshhold: maximum difference in rotational constants for screening
-    :param rmsd: cartesian RMSD for screening
+    :param energy_threshold: maximum relative energy for screening
+    :param rotational_constants_threshold: maximum difference in rotational constants for screening
+    :param rmsd: Cartesian RMSD for screening
     :param max_confs: maximum number of conformers to keep
     """
 
-    energy_threshhold: float | None = None  # kcal/mol
-    rotational_constants_threshhold: float | None = 0.02
+    energy_threshold: float | None = None  # kcal/mol
+    rotational_constants_threshold: float | None = 0.02
     rmsd: float | None = 0.25
     max_confs: int | None = None
 
@@ -76,10 +77,11 @@ class ETKDGSettings(ConformerGenSettings):
 
     Inherited:
     :param mode: Mode for calculations
+    :param conf_opt_method: method for the optimization
     :param screening: post-generation screening settings
     :param constraints: constraints for conformer generation
     :param nci: add a constraining potential for non-covalent interactions (not supported in ETKDG)
-    :param conf_opt_method: method for the optimization
+    :param max_confs: maximum number of conformers to keep
 
     New:
     :param num_initial_confs: number of initial conformers to generate
@@ -87,7 +89,6 @@ class ETKDGSettings(ConformerGenSettings):
     :param num_confs_taken: number of final conformers to take
     :param max_mmff_energy: MMFF energy cutoff
     :param max_mmff_iterations: MMFF optimization iterations
-    :param max_confs: maximum number of conformers to keep
     """
 
     num_initial_confs: int = 300
@@ -117,10 +118,10 @@ class ETKDGSettings(ConformerGenSettings):
             case Mode.RECKLESS:
                 self.num_initial_confs = 200
                 self.num_confs_considered = 50
-                self.max_confs = 20 if self.max_confs is _sentinel else self.max_confs
+                self.max_confs = 20 if self.max_confs is None else self.max_confs
                 self.max_mmff_energy = 20
             case Mode.RAPID:
-                self.max_confs = 50 if self.max_confs is _sentinel else self.max_confs
+                self.max_confs = 50 if self.max_confs is None else self.max_confs
                 self.conf_opt_method = Method.GFN0_XTB
             case _:
                 raise NotImplementedError(f"Unsupported mode: {self.mode}")
@@ -194,6 +195,7 @@ class iMTDSettings(ConformerGenSettings, ABC):
     :param screening: post-generation screening settings (not used)
     :param constraints: constraints to add
     :param nci: add an ellipsoide potential around the input structure
+    :param max_confs: maximum number of conformers to keep
 
     New:
     :param mtd_method: method for the metadynamics
@@ -216,11 +218,11 @@ class iMTDSettings(ConformerGenSettings, ABC):
                 if self.reopt is _sentinel:
                     raise ValueError("Must specify reopt with MANUAL mode")
             case Mode.RECKLESS:  # GFN-FF//MTD(GFN-FF)
-                self.max_confs = 20 if self.max_confs is _sentinel else self.max_confs
+                self.max_confs = 20 if self.max_confs is None else self.max_confs
                 self.speed = iMTDSpeeds.MEGAQUICK
                 self.reopt = check_sentinel(self.reopt, True)
             case Mode.RAPID:  # GFN0//MTD(GFN-FF)
-                self.max_confs = 50 if self.max_confs is _sentinel else self.max_confs
+                self.max_confs = 50 if self.max_confs is None else self.max_confs
                 self.speed = iMTDSpeeds.SUPERQUICK
                 self.conf_opt_method = Method.GFN0_XTB
                 self.reopt = check_sentinel(self.reopt, True)
@@ -258,11 +260,16 @@ class ConformerGenMixin(BaseModel):
 
     :param conf_gen_mode: Mode for calculations
     :param conf_gen_settings: settings for conformer generation
+    :param constraints: constraints to add
+    :param nci: add a constraining potential for non-covalent interactions
+    :param max_confs: maximum number of conformers to keep
     """
 
     conf_gen_mode: Mode = Mode.RAPID
     conf_gen_settings: ConformerGenSettings = _sentinel  # type: ignore [assignment]
     constraints: Sequence[Constraint] = tuple()
+    nci: bool = False
+    max_confs: int | None = None
 
     @model_validator(mode="after")
     def validate_and_build_conf_gen_settings(self) -> Self:
@@ -276,10 +283,10 @@ class ConformerGenMixin(BaseModel):
                     raise ValueError("Must specify conf_gen_settings with MANUAL mode")
 
             case Mode.RECKLESS | Mode.RAPID:
-                # ETKDGSettings will error if constraints added
-                self.conf_gen_settings = ETKDGSettings(mode=self.conf_gen_mode, constraints=self.constraints)
+                # ETKDGSettings will error if constraints or nci are set
+                self.conf_gen_settings = ETKDGSettings(mode=self.conf_gen_mode, constraints=self.constraints, nci=self.nci, max_confs=self.max_confs)
             case Mode.CAREFUL | Mode.METICULOUS:
-                self.conf_gen_settings = iMTDSettings(mode=self.conf_gen_mode, constraints=self.constraints)
+                self.conf_gen_settings = iMTDSettings(mode=self.conf_gen_mode, constraints=self.constraints, nci=self.nci, max_confs=self.max_confs)
 
             case _:
                 raise NotImplementedError(f"Unsupported mode: {self.conf_gen_mode}")
@@ -291,22 +298,23 @@ class ConformerSearchMixin(ConformerGenMixin, MultiStageOptMixin):
     """
     Mixin for workflows that need conformer search—a combination of conformer generation and optimization.
 
-    Inherited:
+    Inherited (ConformerGenMixin):
     :param conf_gen_mode: Mode for conformer generation
     :param mso_mode: Mode for MultiStageOptSettings
     :param conf_gen_settings: settings for conformer generation
+    :param nci: add a constraining potential for non-covalent interactions
+
+    Inherited (MultiStageOptMixin):
     :param multistage_opt_settings: set by mso_mode unless mode=MANUAL (ignores additional settings if set)
     :param solvent: solvent to use
     :param xtb_preopt: pre-optimize with xtb (sets based on mode when None)
-    :param constraints: constraints to add (diamond inheritance, works as expected)
     :param transition_state: whether this is a transition state
+    :param frequencies: whether to calculate frequencies
 
-    Overridden:
-    :param frequencies: whether to calculate frequencies (turned off)
+    Inherited (Both):
+    :param constraints: constraints to add (diamond inheritance, works as expected)
     """
 
-    frequencies: bool = False
-
     def __str__(self) -> str:
         """Return a string representation of the ConformerSearch workflow."""
         return repr(self)
@@ -315,6 +323,45 @@ class ConformerSearchMixin(ConformerGenMixin, MultiStageOptMixin):
         """Return a string representation of the ConformerSearch workflow."""
         return f"<{type(self).__name__} {self.conf_gen_mode.name} {self.mso_mode.name}>"
 
+    @model_validator(mode="after")
+    def deduplicate(self) -> Self:
+        """
+        Deduplicate optimizations between conf_gen and multistage_opt.
+
+        Also affects Manual Mode.
+        """
+        cgs = self.conf_gen_settings
+        msos = self.multistage_opt_settings
+
+        if self.transition_state or not msos.optimization_settings:
+            return self
+
+        first_opt = msos.optimization_settings[0]
+        if cgs.conf_opt_method != first_opt.method or "optimize" not in first_opt.tasks:
+            return self
+
+        first_opt.tasks.remove(Task.OPTIMIZE)
+        if msos.singlepoint_settings or len(msos.optimization_settings) > 1:
+            if (not first_opt.tasks) or first_opt.tasks == ["singlepoint"]:
+                msos.optimization_settings = msos.optimization_settings[1:]
+
+        return self
+
+    @model_validator(mode="after")
+    def remove_ts_constraints(self) -> Self:
+        """
+        Remove constraints from optimization if a TS.
+
+        Also affects Manual Mode.
+        """
+        msos = self.multistage_opt_settings
+        if msos.transition_state and msos.constraints:
+            msos.constraints = []
+            for opt_set in msos.optimization_settings:
+                opt_set.opt_settings.constraints = []
+
+        return self
+
 
 class ConformerSearchWorkflow(ConformerSearchMixin, Workflow):
     """
@@ -330,7 +377,7 @@ class ConformerSearchWorkflow(ConformerSearchMixin, Workflow):
     :param xtb_preopt: pre-optimize with xtb (sets based on mode when None)
     :param constraints: constraints to add
     :param transition_state: whether this is a transition state
-    :param frequencies: whether to calculate frequencies (turned off)
+    :param frequencies: whether to calculate frequencies
 
     Ignored:
     :param mode: Mode to use (not used)

{stjames-0.0.45 → stjames-0.0.47}/stjames/workflows/descriptors.py

@@ -5,7 +5,7 @@ Descriptors = dict[str, dict[str, float] | tuple[float | None, ...] | float]
 
 
 class DescriptorsWorkflow(Workflow):
-    # uuid of optimization
+    # UUID of optimization
     optimization: UUID | None = None
 
     descriptors: Descriptors | None = None

stjames-0.0.47/stjames/workflows/electronic_properties.py

@@ -0,0 +1,109 @@
+from typing import Annotated, Callable
+
+from pydantic import AfterValidator, NonNegativeFloat, NonNegativeInt
+
+from ..base import Base
+from ..settings import Settings
+from ..types import UUID, FloatPerAtom, Matrix3x3, Vector3D
+from .workflow import Workflow
+
+
+def round_float(round_to: int) -> Callable[[float], float]:
+    """Return a function that rounds a float to a given number of decimal places."""
+
+    def inner_round(v: float) -> float:
+        return round(v, round_to)
+
+    return inner_round
+
+
+class PropertyCubePoint(Base):
+    """A point in a cube file, all values rounded to 6 decimal places."""
+
+    x: Annotated[float, AfterValidator(round_float(3))]
+    y: Annotated[float, AfterValidator(round_float(3))]
+    z: Annotated[float, AfterValidator(round_float(3))]
+    val: Annotated[float, AfterValidator(round_float(6))]
+
+
+class PropertyCube(Base):
+    """Represents a "cubefile" of some property."""
+
+    cube_points: list[PropertyCubePoint]
+
+
+class MolecularOrbitalCube(PropertyCube):
+    """
+    Cube of a molecular orbital.
+
+    Inherits `cube_data`.
+    """
+
+    occupation: NonNegativeInt
+    energy: float
+
+
+class ElectronicPropertiesWorkflow(Workflow):
+    """
+    Workflow for computing electronic properties.
+
+    Inherited
+    :param initial_molecule: Molecule of interest
+
+    Config settings:
+    :param settings: settings for the calculation
+    :param compute_density_cube: whether to compute the density cube
+    :param compute_electrostatic_potential_cube: whether to compute the electrostatic potential cube
+    :param compute_num_occupied_orbitals: number of occupied orbitals to save
+    :param compute_num_virtual_orbitals: number of virtual orbitals to save
+
+    Populated while running:
+    :param calc_uuid: UUID of the calculation
+    :param dipole: dipole moment
+    :param quadrupole: quadrupole moment
+    :param lowdin_charges: Löwdin charges
+    :param mulliken_charges: Mulliken charges
+    :param wiberg_bond_orders: Wiberg bond orders (`atom1`, `atom2`, `order`)
+    :param mayer_bond_orders: Mayer bond orders (`atom1`, `atom2`, `order`)
+
+    :param density_cube: electron density, as a cube
+    :param density_cube_alpha: α electron density, as a cube
+    :param density_cube_beta: β electron density, as a cube
+    :param density_cube_difference: difference spin densities, as a cube
+
+    :param electrostatic_potential_cube: electrostatic potential, as a cube
+
+    :param molecular_orbitals: MOs, key is absolute orbital index (for closed-shell species (RHF))
+    :param molecular_orbitals_alpha: α MOs, key is absolute orbital index (for open-shell species (UHF/ROHF))
+    :param molecular_orbitals_beta: β MOs, key is absolute orbital index (for open-shell species (UHF/ROHF))
+    """
+
+    # Config settings
+    settings: Settings
+    compute_density_cube: bool = True
+    compute_electrostatic_potential_cube: bool = True
+    compute_num_occupied_orbitals: NonNegativeInt = 1
+    compute_num_virtual_orbitals: NonNegativeInt = 1
+
+    # Results
+    calc_uuid: UUID | None = None
+
+    dipole: Vector3D | None = None
+    quadrupole: Matrix3x3 | None = None
+
+    mulliken_charges: FloatPerAtom | None = None
+    lowdin_charges: FloatPerAtom | None = None
+
+    wiberg_bond_orders: list[tuple[NonNegativeInt, NonNegativeInt, NonNegativeFloat]] = []
+    mayer_bond_orders: list[tuple[NonNegativeInt, NonNegativeInt, NonNegativeFloat]] = []
+
+    density_cube: PropertyCube | None = None
+    density_cube_alpha: PropertyCube | None = None
+    density_cube_beta: PropertyCube | None = None
+    density_cube_difference: PropertyCube | None = None
+
+    electrostatic_potential_cube: PropertyCube | None = None
+
+    molecular_orbitals: dict[NonNegativeInt, MolecularOrbitalCube] = {}
+    molecular_orbitals_alpha: dict[NonNegativeInt, MolecularOrbitalCube] = {}
+    molecular_orbitals_beta: dict[NonNegativeInt, MolecularOrbitalCube] = {}

{stjames-0.0.45 → stjames-0.0.47}/stjames/workflows/fukui.py

@@ -3,7 +3,7 @@ from .workflow import Workflow
 
 
 class FukuiIndexWorkflow(Workflow):
-    # uuid of optimization
+    # UUID of optimization
     optimization: UUID | None = None
 
     global_electrophilicity_index: float | None = None

stjames-0.0.47/stjames/workflows/hydrogen_bond_basicity.py

@@ -0,0 +1,18 @@
+from ..base import Base
+from ..types import UUID
+from .workflow import Workflow
+
+
+class HydrogenBondAcceptorSite(Base):
+    atom_idx: int  # zero-indexed
+    pkbhx: float
+    position: tuple[float, float, float]
+    name: str | None = None
+
+
+class HydrogenBondBasicityWorkflow(Workflow):
+    # UUID of optimization
+    optimization: UUID | None = None
+
+    # hydrogen-bond-acceptor sites
+    hba_sites: list[HydrogenBondAcceptorSite] = []  # noqa: RUF012

{stjames-0.0.45 → stjames-0.0.47}/stjames/workflows/molecular_dynamics.py

@@ -1,6 +1,6 @@
 from typing import Self
 
-from pydantic import PositiveFloat, PositiveInt, model_validator
+from pydantic import PositiveFloat, PositiveInt, computed_field, model_validator
 
 from ..base import Base, LowercaseStrEnum
 from ..constraint import PairwiseHarmonicConstraint, SphericalHarmonicConstraint
@@ -12,6 +12,7 @@ from .workflow import Workflow
 class MolecularDynamicsInitialization(LowercaseStrEnum):
     RANDOM = "random"
     QUASICLASSICAL = "quasiclassical"
+    READ = "read"
 
 
 class ThermodynamicEnsemble(LowercaseStrEnum):
@@ -28,7 +29,13 @@ class Frame(Base):
     pressure: float
     temperature: float
     volume: float
-    energy: float
+    potential_energy: float  # kcal/mol
+    kinetic_energy: float  # kcal/mol
+
+    @computed_field  # type: ignore[misc, prop-decorator, unused-ignore]
+    @property
+    def energy(self) -> float:
+        return self.potential_energy + self.kinetic_energy
 
 
 class MolecularDynamicsSettings(Base):
@@ -37,6 +44,7 @@ class MolecularDynamicsSettings(Base):
 
     timestep: PositiveFloat = 1.0  # fs
     num_steps: PositiveInt = 500
+    save_interval: PositiveInt = 10
 
     confining_constraint: SphericalHarmonicConstraint | None = None
 
@@ -63,7 +71,5 @@ class MolecularDynamicsWorkflow(Workflow):
     calc_settings: Settings
     calc_engine: str | None = None
 
-    save_interval: PositiveInt = 10
-
-    # uuids of scan points
+    # UUIDs of scan points
     frames: list[Frame] = []

{stjames-0.0.45 → stjames-0.0.47}/stjames/workflows/multistage_opt.py

@@ -51,10 +51,10 @@ class MultiStageOptSettings(BaseModel):
     optimization_settings: Sequence[Settings] = tuple()
     singlepoint_settings: Settings | None = None
     solvent: Solvent | None = None
-    xtb_preopt: bool | None = None
+    xtb_preopt: bool = False
     constraints: Sequence[Constraint] = tuple()
     transition_state: bool = False
-    frequencies: bool = True
+    frequencies: bool = False
 
     def __str__(self) -> str:
         return repr(self)
@@ -152,7 +152,6 @@ class MultiStageOptSettings(BaseModel):
                 self.singlepoint_settings = sp(Method.GFN2_XTB, solvent=self.solvent)
 
             case Mode.RAPID:
-                self.xtb_preopt = bool(self.xtb_preopt)
                 self.optimization_settings = [
                     *gfn0_pre_opt * self.xtb_preopt,
                     opt(Method.GFN2_XTB, freq=self.frequencies),
@@ -160,7 +159,6 @@ class MultiStageOptSettings(BaseModel):
                 self.singlepoint_settings = sp(Method.R2SCAN3C, solvent=self.solvent)
 
             case Mode.CAREFUL:
-                self.xtb_preopt = (self.xtb_preopt is None) or self.xtb_preopt
                 self.optimization_settings = [
                     *gfn2_pre_opt * self.xtb_preopt,
                     opt(Method.R2SCAN3C, freq=self.frequencies),
@@ -168,7 +166,6 @@ class MultiStageOptSettings(BaseModel):
                 self.singlepoint_settings = sp(Method.WB97X3C, solvent=self.solvent)
 
             case Mode.METICULOUS:
-                self.xtb_preopt = (self.xtb_preopt is None) or self.xtb_preopt
                 self.optimization_settings = [
                     *gfn2_pre_opt * self.xtb_preopt,
                     opt(Method.R2SCAN3C),
@@ -179,8 +176,6 @@ class MultiStageOptSettings(BaseModel):
             case mode:
                 raise NotImplementedError(f"Cannot assign settings for {mode=}")
 
-        assert self.xtb_preopt is not None
-
 
 class MultiStageOptWorkflow(Workflow, MultiStageOptSettings):
     """
@@ -232,10 +227,10 @@ class MultiStageOptMixin(BaseModel):
     # Need to use a sentinel object to make both mypy and pydantic happy
     multistage_opt_settings: MultiStageOptSettings = _sentinel_msos  # type: ignore [assignment]
     solvent: Solvent | None = None
-    xtb_preopt: bool | None = None
+    xtb_preopt: bool = False
     constraints: Sequence[Constraint] = tuple()
     transition_state: bool = False
-    frequencies: bool = True
+    frequencies: bool = False
 
     @model_validator(mode="after")
     def set_mso_settings(self) -> Self:
@@ -277,14 +272,14 @@ def build_mso_settings(
     use_solvent_for_opt: bool = False,
     constraints: list[Constraint] | None = None,
     transition_state: bool = False,
-    frequencies: bool = True,
+    frequencies: bool = False,
 ) -> MultiStageOptSettings:
     """
     Helper function to construct multi-stage opt settings objects manually.
 
     There's no xTB pre-optimization here - add that yourself!
 
-    :param optimization_settings: list of opt settings to apply successively
+    :param optimization_settings: optimization settings to apply successively
     :param singlepoint_settings: final single point settings
     :param mode: Mode for settings, defaults to `MANUAL`
     :param solvent: solvent to use
@@ -292,7 +287,7 @@ def build_mso_settings(
     :param constraints: constraints for optimization
     :param transition_state: whether this is a transition state
     :param frequencies: whether to calculate frequencies
-    :returns: the final multistage opt settings
+    :returns: MultiStageOptSettings
     """
     if constraints is None:
         constraints = []
@@ -336,3 +331,29 @@ def build_mso_settings(
         transition_state=transition_state,
         frequencies=frequencies,
     )
+
+
+def multi_stage_opt_settings_from_workflow(msow: MultiStageOptWorkflow) -> MultiStageOptSettings:
+    """
+    Helper function to convert a MultiStageOptWorkflow to MultiStageOptSettings.
+
+    :param msow: MultiStageOptWorkflow
+    :returns: MultiStageOptSettings
+
+    >>> from stjames.molecule import Atom, Molecule
+    >>> He = Molecule(charge=0, multiplicity=1, atoms=[Atom(atomic_number=2, position=[0, 0, 0])])
+    >>> msos = multi_stage_opt_settings_from_workflow(
+    ...     MultiStageOptWorkflow(initial_molecule=He, mode=Mode.RAPID, solvent="water")
+    ... )
+    >>> print(msos)
+    <MultiStageOptSettings RAPID>
+    >>> msos.level_of_theory
+    'r2scan_3c/cpcm(water)//gfn2_xtb'
+    >>> msos.solvent
+    <Solvent.WATER: 'water'>
+    >>> msos.xtb_preopt
+    False
+    """
+    data = dict(msow)
+    del data["calculations"]
+    return MultiStageOptSettings.construct(**data)

{stjames-0.0.45 → stjames-0.0.47}/stjames/workflows/redox_potential.py

@@ -53,7 +53,7 @@ class RedoxPotentialWorkflow(Workflow, MultiStageOptMixin):
     redox_type: str | None = None
     redox_potential: float | None = None
 
-    # uuids
+    # UUIDs
     neutral_molecule: UUID | None = None
     anion_molecule: UUID | None = None
     cation_molecule: UUID | None = None

{stjames-0.0.45 → stjames-0.0.47}/stjames/workflows/scan.py

@@ -23,7 +23,7 @@ class ScanSettings(Base):
     num: int
 
     def vals(self) -> NDArray[np.float64]:
-        return np.linspace(self.start, self.stop, self.num)
+        return np.linspace(self.start, self.stop, self.num)  # type: ignore [return-value, unused-ignore]
 
     class Config:
         from_attributes = True
@@ -34,5 +34,5 @@ class ScanWorkflow(Workflow):
     calc_settings: Settings
     calc_engine: str
 
-    # uuids of scan points
+    # UUIDs of scan points
     scan_points: list[UUID | None] = []

{stjames-0.0.45 → stjames-0.0.47}/stjames/workflows/spin_states.py

@@ -52,7 +52,7 @@ class SpinStatesWorkflow(Workflow, MultiStageOptMixin):
     :param mode: Mode for workflow
     :param multistage_opt_settings: set by mode unless mode=MANUAL (ignores additional settings if set)
     :param solvent: solvent to use for optimization
-    :param xtb_preopt: pre-optimize with xtb (sets based on mode when None)
+    :param xtb_preopt: pre-optimize with xtb
     :param constraints: constraints to add
     :param transition_state: whether this is a transition state
     :param frequencies: whether to calculate frequencies

{stjames-0.0.45 → stjames-0.0.47}/stjames/workflows/tautomer.py

@@ -10,7 +10,7 @@ class Tautomer(Base):
     weight: Optional[float] = None
     predicted_relative_energy: Optional[float] = None
 
-    # uuids, optionally
+    # UUIDs, optionally
     structures: list[DBCalculation] = []
 
 

{stjames-0.0.45 → stjames-0.0.47/stjames.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: stjames
-Version: 0.0.45
+Version: 0.0.47
 Summary: standardized JSON atom/molecule encoding scheme
 Author-email: Corin Wagen <corin@rowansci.com>
 Project-URL: Homepage, https://github.com/rowansci/stjames

{stjames-0.0.45 → stjames-0.0.47}/stjames.egg-info/SOURCES.txt

@@ -47,6 +47,7 @@ stjames/workflows/conformer_search.py
 stjames/workflows/descriptors.py
 stjames/workflows/electronic_properties.py
 stjames/workflows/fukui.py
+stjames/workflows/hydrogen_bond_basicity.py
 stjames/workflows/molecular_dynamics.py
 stjames/workflows/multistage_opt.py
 stjames/workflows/pka.py

stjames-0.0.45/stjames/workflows/__init__.py

@@ -1,14 +0,0 @@
-from .admet import *
-from .basic_calculation import *
-from .bde import *
-from .conformer import *
-from .conformer_search import *
-from .descriptors import *
-from .fukui import *
-from .molecular_dynamics import *
-from .multistage_opt import *
-from .pka import *
-from .redox_potential import *
-from .scan import *
-from .spin_states import *
-from .tautomer import *

stjames-0.0.45/stjames/workflows/electronic_properties.py

@@ -1,86 +0,0 @@
-from pydantic import NonNegativeFloat, NonNegativeInt
-
-from ..base import Base
-from ..settings import Settings
-from ..types import UUID, FloatPerAtom, Matrix3x3, Vector3D
-from .workflow import Workflow
-
-
-class PropertyCubePoint(Base):
-    x: float
-    y: float
-    z: float
-    val: float
-
-
-class PropertyCube(Base):
-    """
-    Represents a "cubefile" of some property.
-    """
-
-    cube_data: list[PropertyCubePoint]
-
-
-class MolecularOrbitalCube(PropertyCube):
-    """
-    Inherits `cube_data`.
-    """
-
-    occupation: NonNegativeInt
-    energy: float
-
-
-class ElectronicPropertiesWorkflow(Workflow):
-    """
-    Workflow for computing electronic properties!
-
-    Inherited
-    :param initial_molecule: molecule of interest
-
-    Config settings:
-    :param settings: the level of theory to use
-    :param compute_density_cube: whether or not to compute the density on a cube
-    :param compute_electrostatic_potential_cube: whether or not to compute the electrostatic potential on a cube
-    :param compute_num_occupied_orbitals: how many occupied orbitals to save
-    :param compute_num_virtual_orbitals: how many virtual orbitals to save
-
-    Populated while running:
-    :param calculation: the UUID of the calculation
-    :param dipole: the dipole moment
-    :param quadrupole: the quadrupole moment
-    :param mulliken_charges: the Mulliken charges
-    :param lowdin_charges: the Lowdin charges
-    :param wiberg_bond_orders: the Wiberg bond orders (`atom1`, `atom2`, `order`)
-    :param mayer_bond_orders: the Mayer bond orders (`atom1`, `atom2`, `order`)
-    :param density_cube: the electron density, as a cube
-    :param electrostatic_potential_cube: the electrostatic potential, as a cube
-    :param molecular_orbitals_alpha: for open-shell species (UHF/ROHF), a dict containing the alpha MOs
-        (The key is the absolute orbital index.)
-    :param molecular_orbitals_beta: for open-shell species (UHF/ROHF), a dict containing the beta MOs
-        (The key is the absolute orbital index.)
-    :param molecular_orbitals: for closed-shell species (RHF), a dict containing the MOs
-        (The key is the absolute orbital index.)
-    """
-
-    settings: Settings
-    compute_density_cube: bool = True
-    compute_electrostatic_potential_cube: bool = True
-    compute_num_occupied_orbitals: NonNegativeInt = 1
-    compute_num_virtual_orbitals: NonNegativeInt = 1
-
-    calculation: UUID | None = None
-
-    dipole: Vector3D | None = None
-    quadrupole: Matrix3x3 | None = None
-
-    mulliken_charges: FloatPerAtom | None = None
-    lowdin_charges: FloatPerAtom | None = None
-
-    wiberg_bond_orders: list[tuple[NonNegativeInt, NonNegativeInt, NonNegativeFloat]] = []
-    mayer_bond_orders: list[tuple[NonNegativeInt, NonNegativeInt, NonNegativeFloat]] = []
-
-    density_cube: PropertyCube | None = None
-    electrostatic_potential_cube: PropertyCube | None = None
-    molecular_orbitals_alpha: dict[NonNegativeInt, MolecularOrbitalCube] = {}
-    molecular_orbitals_beta: dict[NonNegativeInt, MolecularOrbitalCube] = {}
-    molecular_orbitals: dict[NonNegativeInt, MolecularOrbitalCube] = {}