stjames 0.0.44__py3-none-any.whl → 0.0.46__py3-none-any.whl

stjames/constraint.py

@@ -1,4 +1,6 @@
-from pydantic import PositiveFloat, PositiveInt
+from typing import Optional, Self
+
+from pydantic import PositiveFloat, PositiveInt, model_validator
 
 from .base import Base, LowercaseStrEnum
 
@@ -9,28 +11,64 @@ class ConstraintType(LowercaseStrEnum):
     BOND = "bond"
     ANGLE = "angle"
     DIHEDRAL = "dihedral"
+    FREEZE_ATOMS = "freeze_atoms"
 
 
 class Constraint(Base):
-    """Represents a single (absolute) constraint."""
+    """
+    Represents a single (absolute) constraint.
+
+    :param constraint_type: which type
+    :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
+    """
 
     constraint_type: ConstraintType
     atoms: list[PositiveInt]  # 1-indexed
+    value: Optional[float] = None
+
+    @model_validator(mode="after")
+    def check_atom_list_length(self) -> Self:
+        match self.constraint_type:
+            case ConstraintType.BOND:
+                if len(self.atoms) != 2:
+                    raise ValueError("Bond constraint needs two atom indices!")
+            case ConstraintType.ANGLE:
+                if len(self.atoms) != 3:
+                    raise ValueError("Angle constraint needs three atom indices!")
+            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!")
+
+        return self
 
 
 class PairwiseHarmonicConstraint(Base):
     """
     Represents a harmonic constraint, with a characteristic spring constant.
+
+    :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
     """
 
     atoms: tuple[PositiveInt, PositiveInt]  # 1-indexed
-    spring_constant: PositiveFloat  # kcal/mol / Å**2
+    force_constant: PositiveFloat  # kcal/mol / Å**2
+    equilibrium: PositiveFloat  # Å
 
 
 class SphericalHarmonicConstraint(Base):
     """
     Represents a spherical harmonic constraint to keep a system near the origin.
+
+    :param confining radius: the confining radius, in Å
+    :param force_constant: the strength of the confinement, in kcal/mol/Å
     """
 
     confining_radius: PositiveFloat
-    confining_force_constant: PositiveFloat = 10  # kcal/mol / Å**2
+    force_constant: PositiveFloat = 10  # kcal/mol / Å**2

stjames/correction.py

@@ -10,5 +10,8 @@ class Correction(LowercaseStrEnum):
     # Grimme's D3 dispersion correction, *without* Becke–Johnson damping
     D3 = "d3"
 
+    # Grimme's D4 dispersion correction
+    D4 = "d4"
+
     # Grimme's geometric counterpoise correction
     GCP = "gcp"

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/method.py

@@ -1,3 +1,5 @@
+from typing import Literal
+
 from .base import LowercaseStrEnum
 
 
@@ -7,6 +9,7 @@ class Method(LowercaseStrEnum):
 
     PBE = "pbe"
     B973C = "b97_3c"
+    B97D3BJ = "b97_d3bj"
     R2SCAN = "r2scan"
     R2SCAN3C = "r2scan_3c"
     TPSS = "tpss"
@@ -28,6 +31,9 @@ class Method(LowercaseStrEnum):
     DSDBLYPD3BJ = "dsd_blyp_d3bj"
 
     AIMNET2_WB97MD3 = "aimnet2_wb97md3"
+    MACE_MP_0 = "mace_mp_0"
+    OCP24_S = "ocp24_s"
+    OCP24_L = "ocp24_l"
 
     GFN_FF = "gfn_ff"
     GFN0_XTB = "gfn0_xtb"
@@ -38,34 +44,17 @@ class Method(LowercaseStrEnum):
     BP86 = "bp86"
 
 
-MLFF = [
-    Method.AIMNET2_WB97MD3,
-]
-
-XTB_METHODS = [
-    Method.GFN_FF,
-    Method.GFN0_XTB,
-    Method.GFN1_XTB,
-    Method.GFN2_XTB,
-]
-
-COMPOSITE_METHODS = [
-    Method.HF3C,
-    Method.B973C,
-    Method.R2SCAN3C,
-    Method.WB97X3C,
-]
-
-PREPACKAGED_METHODS = [
-    *MLFF,
-    *XTB_METHODS,
-    *COMPOSITE_METHODS,
-]
-
-METHODS_WITH_CORRECTION = [
-    Method.WB97XD3,
-    Method.WB97XV,
-    Method.WB97MV,
-    Method.WB97MD3BJ,
-    Method.DSDBLYPD3BJ,
-]
+NNPMethod = Literal[Method.AIMNET2_WB97MD3]
+NNP_METHODS = [Method.AIMNET2_WB97MD3]
+
+XTBMethod = Literal[Method.GFN_FF, Method.GFN0_XTB, Method.GFN1_XTB, Method.GFN2_XTB]
+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]
+
+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/molecule.py

@@ -8,7 +8,7 @@ from pydantic import NonNegativeInt, PositiveInt, ValidationError
 from .atom import Atom
 from .base import Base
 from .periodic_cell import PeriodicCell
-from .types import Matrix3x3, Vector3D, Vector3DPerAtom
+from .types import FloatPerAtom, Matrix3x3, Vector3D, Vector3DPerAtom
 
 
 class MoleculeReadError(RuntimeError):
@@ -18,10 +18,8 @@ class MoleculeReadError(RuntimeError):
 class VibrationalMode(Base):
     frequency: float  # in cm-1
     reduced_mass: float  # amu
-
-    # todo - check units here?
-    force_constant: float
-    displacements: Vector3DPerAtom
+    force_constant: float  # mDyne/Å
+    displacements: Vector3DPerAtom  # Å
 
 
 class Molecule(Base):
@@ -44,8 +42,8 @@ class Molecule(Base):
 
     velocities: Optional[Vector3DPerAtom] = None  # Å/fs
 
-    mulliken_charges: Optional[list[float]] = None
-    mulliken_spin_densities: Optional[list[float]] = None
+    mulliken_charges: FloatPerAtom | None = None
+    mulliken_spin_densities: FloatPerAtom | None = None
     dipole: Optional[Vector3D] = None  # in Debye
 
     vibrational_modes: Optional[list[VibrationalMode]] = None

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/types.py

@@ -5,4 +5,6 @@ UUID: TypeAlias = str
 Vector3D: TypeAlias = tuple[float, float, float]
 Vector3DPerAtom: TypeAlias = list[Vector3D]
 
+FloatPerAtom: TypeAlias = list[float]
+
 Matrix3x3: TypeAlias = tuple[Vector3D, Vector3D, Vector3D]

stjames/workflows/__init__.py

@@ -1,8 +1,13 @@
+# 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 .molecular_dynamics import *
 from .multistage_opt import *
@@ -11,3 +16,40 @@ 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",
+    "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]
+    "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/workflows/bde.py

@@ -58,12 +58,12 @@ class BDEWorkflow(Workflow, MultiStageOptMixin):
     :param initial_molecule: Molecule of interest
     :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
+    :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)
@@ -106,6 +105,10 @@ class BDEWorkflow(Workflow, MultiStageOptMixin):
         """
         return f"{type(self).__name__} {self.mode.name}\n" + "\n".join(map(str, self.fragment_indices))
 
+    @property
+    def level_of_theory(self) -> str:
+        return self.multistage_opt_settings.level_of_theory
+
     @property
     def energies(self) -> tuple[float | None, ...]:
         return tuple(bde.energy for bde in self.bdes)

stjames/workflows/conformer_search.py

@@ -0,0 +1,352 @@
+"""Conformer Search Workflow."""
+
+from abc import ABC
+from typing import Self, Sequence, TypeVar
+
+from pydantic import BaseModel, Field, field_validator, model_validator
+
+from ..base import LowercaseStrEnum
+from ..constraint import Constraint
+from ..method import Method, XTBMethod
+from ..mode import Mode
+from ..types import UUID
+from .multistage_opt import MultiStageOptMixin
+from .workflow import Workflow
+
+_sentinel = object()
+
+_T = TypeVar("_T")
+_U = TypeVar("_U")
+
+
+def check_sentinel(value: _T, default: _U) -> _T | _U:
+    """Return value unless _sentinel, then return default."""
+    return default if value is _sentinel else value
+
+
+class ScreeningSettings(BaseModel):
+    """
+    Settings for determining unique and useful conformers.
+
+    :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_threshold: float | None = None  # kcal/mol
+    rotational_constants_threshold: float | None = 0.02
+    rmsd: float | None = 0.25
+    max_confs: int | None = None
+
+
+class ConformerGenSettings(BaseModel):
+    """
+    Conformer generation settings.
+
+    Conformers are generated and an initial screening is performed to remove duplicates and high-energy conformers.
+
+    :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
+    :param max_confs: maximum number of conformers to keep
+    """
+
+    mode: Mode = Mode.RAPID
+    conf_opt_method: XTBMethod = Method.GFN_FF
+    screening: ScreeningSettings | None = None
+    constraints: Sequence[Constraint] = tuple()
+    nci: bool = False
+    max_confs: int | None = None
+
+    def __str__(self) -> str:
+        """Return a string representation of the ConformerGenSettings."""
+        return repr(self)
+
+    def __repr__(self) -> str:
+        """Return a string representation of the ConformerGenSettings."""
+        return f"<{type(self).__name__} {self.mode.name}>"
+
+
+class ETKDGSettings(ConformerGenSettings):
+    """
+    Settings for ETKDG conformer generation.
+
+    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 max_confs: maximum number of conformers to keep
+
+    New:
+    :param num_initial_confs: number of initial conformers to generate
+    :param num_confs_considered: number of conformers to consider for optimization
+    :param num_confs_taken: number of final conformers to take
+    :param max_mmff_energy: MMFF energy cutoff
+    :param max_mmff_iterations: MMFF optimization iterations
+    """
+
+    num_initial_confs: int = 300
+    num_confs_considered: int = 100
+    max_mmff_iterations: int = 500
+    max_mmff_energy: float | None = 30
+
+    @field_validator("constraints")
+    def check_constraints(cls, constraints: Sequence[Constraint]) -> Sequence[Constraint]:
+        if constraints:
+            raise ValueError("ETKDG does not support constraints")
+
+        return tuple(constraints)
+
+    @field_validator("nci")
+    def check_nci(cls, nci: bool) -> bool:
+        if nci:
+            raise ValueError("ETKDG does not support NCI")
+
+        return nci
+
+    @model_validator(mode="after")
+    def validate_and_build(self) -> Self:
+        match self.mode:
+            case Mode.MANUAL:
+                pass
+            case Mode.RECKLESS:
+                self.num_initial_confs = 200
+                self.num_confs_considered = 50
+                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 None else self.max_confs
+                self.conf_opt_method = Method.GFN0_XTB
+            case _:
+                raise NotImplementedError(f"Unsupported mode: {self.mode}")
+
+        return self
+
+
+class iMTDSpeeds(LowercaseStrEnum):
+    MEGAQUICK = "megaquick"
+    SUPERQUICK = "superquick"
+    QUICK = "quick"
+    NORMAL = "normal"
+    EXTENSIVE = "extensive"
+
+
+class iMTDSettings(ConformerGenSettings, ABC):
+    """
+    Settings for iMTD style conformer generation.
+
+    RECKLESS:
+        - GFN-FF//MTD(GFN-FF)
+        - Megaquick
+            - No GC
+            - No rotamer metadynamics
+            - Energy window = 5.0
+            - Run scaling factor = 0.5
+            - 6 MTD runs
+    RAPID:
+        - GFN0//MTD(GFN-FF)
+        - Superquick
+            - No GC
+            - No rotamer metadynamics
+            - Energy window = 5.0
+            - Run scaling factor = 0.5
+            - 6 MTD runs
+    CAREFUL:
+        - GFN2//MTD(GFN-FF)
+        - Quick
+            - GC (for iMTD-GC)
+            - Rotamer metadynamics (for iMTD-GC)
+            - Energy window = 5.0
+            - Run scaling factor = 0.5
+            - 6 MTD runs
+    METICULOUS:
+        - GFN2//MTD(GFN2)
+        - "Normal"
+            - GC (for iMTD-GC)
+            - Rotamer metadynamics (for iMTD-GC)
+            - Energy window = 6.0
+            - Run scaling factor = 1
+            - 14 MTD runs (2 with extreme values)
+
+
+    See https://github.com/crest-lab/crest/blob/5ca82feb2ec4df30a0129db957163c934f085952/src/choose_settings.f90#L202
+    and https://github.com/crest-lab/crest/blob/5ca82feb2ec4df30a0129db957163c934f085952/src/confparse.f90#L825
+    for how quick, superquick, and megaquick are defined.
+
+    Additional notes:
+        Extensive mode
+        - GC
+        - Rotamer metadynamics
+        - Energy window = 8.0
+        - Run scaling factor = 2
+        - 14 MTD runs (2 with extreme values)
+
+        --NCI may switch things to QUICK?
+
+    Inherited:
+    :param mode: Mode for calculations
+    :param conf_opt_method: method for the optimization
+    :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
+    :param speed: speed of the calculations (CREST specific setting)
+    :param reopt: re-optimize conformers (corrects for the lack of rotamer metadynamics and GC)
+    :param free_energy_weights: calculate frequencies and re-weight based on free energies
+    """
+
+    mtd_method: XTBMethod = Method.GFN_FF
+    mtd_runtype: str = "imtd-gc"
+
+    speed: iMTDSpeeds = iMTDSpeeds.QUICK
+    reopt: bool = _sentinel  # type: ignore [assignment]
+    free_energy_weights: bool = False
+
+    @model_validator(mode="after")
+    def validate_and_build_imtdgc_settings(self) -> Self:
+        match self.mode:
+            case Mode.MANUAL:
+                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 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 None else self.max_confs
+                self.speed = iMTDSpeeds.SUPERQUICK
+                self.conf_opt_method = Method.GFN0_XTB
+                self.reopt = check_sentinel(self.reopt, True)
+            case Mode.CAREFUL:  # GFN2//MTD(GFN-FF)
+                self.speed = iMTDSpeeds.QUICK
+                self.conf_opt_method = Method.GFN2_XTB
+                self.reopt = check_sentinel(self.reopt, False)
+            case Mode.METICULOUS:  # GFN2//MTD(GFN2)
+                self.speed = iMTDSpeeds.NORMAL
+                self.mtd_method = Method.GFN2_XTB
+                self.conf_opt_method = Method.GFN2_XTB
+                self.reopt = check_sentinel(self.reopt, False)
+            # case Mode.EXTREME: # GFN2//MTD(GFN2)
+            #     self.mtd_method = Method.GFN2_XTB
+            #     self.conf_opt_method = Method.GFN2_XTB
+            #     self.speed = iMTDSpeeds.EXTENSIVE
+            #     self.reopt = check_sentinel(self.reopt, False)
+            case _:
+                raise NotImplementedError(f"Unsupported mode: {self.mode}")
+
+        return self
+
+
+class iMTDGCSettings(iMTDSettings):
+    run_type: str = "imtdgc"
+
+
+class iMTDsMTDSettings(iMTDSettings):
+    run_type: str = "imtd-smtd"
+
+
+class ConformerGenMixin(BaseModel):
+    """
+    Mixin for workflows that need conformer generation.
+
+    :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:
+        """Validate and build the ConformerGenSettings."""
+        if self.conf_gen_settings is not _sentinel and self.conf_gen_mode != Mode.MANUAL:
+            raise ValueError("Cannot specify conf_gen_settings with non-MANUAL mode")
+
+        match self.conf_gen_mode:
+            case Mode.MANUAL:
+                if self.conf_gen_settings is _sentinel:
+                    raise ValueError("Must specify conf_gen_settings with MANUAL mode")
+
+            case Mode.RECKLESS | Mode.RAPID:
+                # 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, nci=self.nci, max_confs=self.max_confs)
+
+            case _:
+                raise NotImplementedError(f"Unsupported mode: {self.conf_gen_mode}")
+
+        return self
+
+
+class ConformerSearchMixin(ConformerGenMixin, MultiStageOptMixin):
+    """
+    Mixin for workflows that need conformer search—a combination of conformer generation and optimization.
+
+    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 transition_state: whether this is a transition state
+    :param frequencies: whether to calculate frequencies
+
+    Inherited (Both):
+    :param constraints: constraints to add (diamond inheritance, works as expected)
+    """
+
+    def __str__(self) -> str:
+        """Return a string representation of the ConformerSearch workflow."""
+        return repr(self)
+
+    def __repr__(self) -> str:
+        """Return a string representation of the ConformerSearch workflow."""
+        return f"<{type(self).__name__} {self.conf_gen_mode.name} {self.mso_mode.name}>"
+
+
+class ConformerSearchWorkflow(ConformerSearchMixin, Workflow):
+    """
+    ConformerSearch Workflow.
+
+    Inherited:
+    :param initial_molecule: Molecule of interest
+    :param conf_gen_mode: Mode for calculations
+    :param conf_gen_settings: settings for conformer generation
+    :param mso_mode: Mode for MultiStageOptSettings
+    :param multistage_opt_settings: set by 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
+    :param transition_state: whether this is a transition state
+    :param frequencies: whether to calculate frequencies
+
+    Ignored:
+    :param mode: Mode to use (not used)
+
+    New:
+    :param conformer_uuids: list of UUIDs of the Molecules generated
+    :param energies: energies of the molecules
+    """
+
+    # Results
+    conformer_uuids: list[list[UUID | None]] = Field(default_factory=list)
+    energies: list[float] = Field(default_factory=list)

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/workflows/electronic_properties.py

@@ -0,0 +1,96 @@
+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_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/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/workflows/molecular_dynamics.py

@@ -9,6 +9,12 @@ from ..types import UUID
 from .workflow import Workflow
 
 
+class MolecularDynamicsInitialization(LowercaseStrEnum):
+    RANDOM = "random"
+    QUASICLASSICAL = "quasiclassical"
+    READ = "read"
+
+
 class ThermodynamicEnsemble(LowercaseStrEnum):
     NPT = "npt"
     NVT = "nvt"
@@ -18,22 +24,25 @@ class ThermodynamicEnsemble(LowercaseStrEnum):
 class Frame(Base):
     index: int  # what number frame this is within the MD simulation
 
-    uuid: UUID | None = None  # UUID of molecule
+    calculation_uuid: UUID | None = None  # UUID of calculation
 
     pressure: float
     temperature: float
+    volume: float
     energy: float
 
 
 class MolecularDynamicsSettings(Base):
     ensemble: ThermodynamicEnsemble = ThermodynamicEnsemble.NVT
+    initialization: MolecularDynamicsInitialization = MolecularDynamicsInitialization.RANDOM
 
     timestep: PositiveFloat = 1.0  # fs
     num_steps: PositiveInt = 500
+    save_interval: PositiveInt = 10
 
     confining_constraint: SphericalHarmonicConstraint | None = None
 
-    temperature: PositiveFloat | None = 300  # K
+    temperature: PositiveFloat = 300  # K
     pressure: PositiveFloat | None = None  # atm
 
     langevin_thermostat_timescale: PositiveFloat = 100  # fs
@@ -46,7 +55,7 @@ class MolecularDynamicsSettings(Base):
         """Check that NVT ensemble always has temperature defined, and that NPT has temp and pressure defined."""
         if self.ensemble == ThermodynamicEnsemble.NVT and self.temperature is None:
             raise ValueError("NVT ensemble must have a temperature defined")
-        if self.ensemble == ThermodynamicEnsemble.NPT and (self.temperature is None or self.pressure is None):
+        elif self.ensemble == ThermodynamicEnsemble.NPT and (self.temperature is None or self.pressure is None):
             raise ValueError("NPT ensemble must have both temperature and pressure defined")
         return self
 
@@ -56,7 +65,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/workflows/multistage_opt.py

@@ -27,14 +27,14 @@ class MultiStageOptSettings(BaseModel):
         wB97M-D3BJ/def2-TZVPPD//wB97X-3c//r²SCAN-3c with GFN2-xTB pre-opt
 
     Notes:
-    - No solvent in pre-opt
+    - No solvent in any optimizations when using Modes
     - If solvent: xTB singlepoints use CPCMX, xTB optimizations use ALBP, all else use CPCM
     - Allows a single point to be called with no optimization
 
     :param mode: Mode for settings
     :param optimization_settings: list of opt settings to apply successively
     :param singlepoint_settings: final single point settings
-    :param solvent: solvent to use
+    :param solvent: solvent to use for singlepoint
     :param xtb_preopt: pre-optimize with xtb (sets based on mode when None)
     :param constraints: constraints for optimization
     :param transition_state: whether this is a transition state
@@ -44,17 +44,17 @@ class MultiStageOptSettings(BaseModel):
     >>> msos
     <MultiStageOptSettings RAPID>
     >>> msos.level_of_theory
-    'r2scan_3c/cpcm(water)//gfn2_xtb/alpb(water)'
+    'r2scan_3c/cpcm(water)//gfn2_xtb'
     """
 
     mode: Mode
     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)
@@ -78,7 +78,7 @@ class MultiStageOptSettings(BaseModel):
 
         >>> msos = MultiStageOptSettings(mode=Mode.RAPID, solvent="hexane")
         >>> msos.level_of_theory
-        'r2scan_3c/cpcm(hexane)//gfn2_xtb/alpb(hexane)'
+        'r2scan_3c/cpcm(hexane)//gfn2_xtb'
         """
         methods = [self.singlepoint_settings] if self.singlepoint_settings else []
         methods += reversed(self.optimization_settings)
@@ -148,39 +148,34 @@ class MultiStageOptSettings(BaseModel):
         match mode:
             case Mode.RECKLESS:
                 self.xtb_preopt = False
-                self.optimization_settings = [opt(Method.GFN_FF, solvent=self.solvent, freq=self.frequencies)]
+                self.optimization_settings = [opt(Method.GFN_FF, freq=self.frequencies)]
                 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, solvent=self.solvent, freq=self.frequencies),
+                    opt(Method.GFN2_XTB, freq=self.frequencies),
                 ]
                 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, solvent=self.solvent, freq=self.frequencies),
+                    opt(Method.R2SCAN3C, freq=self.frequencies),
                 ]
                 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, solvent=self.solvent),
-                    opt(Method.WB97X3C, solvent=self.solvent, freq=self.frequencies),
+                    opt(Method.R2SCAN3C),
+                    opt(Method.WB97X3C, freq=self.frequencies),
                 ]
                 self.singlepoint_settings = sp(Method.WB97MD3BJ, "def2-TZVPPD", solvent=self.solvent)
 
             case mode:
                 raise NotImplementedError(f"Cannot assign settings for {mode=}")
 
-        assert self.xtb_preopt is not None
-
 
 class MultiStageOptWorkflow(Workflow, MultiStageOptSettings):
     """
@@ -191,7 +186,7 @@ class MultiStageOptWorkflow(Workflow, MultiStageOptSettings):
     :param mode: Mode for workflow
     :param optimization_settings: list of opt settings to apply successively
     :param singlepoint_settings: final single point settings
-    :param solvent: solvent to use
+    :param solvent: solvent to use for singlepoint
     :param xtb_preopt: pre-optimize with xtb (sets based on mode when None)
     :param constraints: constraints for optimization
     :param transition_state: whether this is a transition state
@@ -206,7 +201,7 @@ class MultiStageOptWorkflow(Workflow, MultiStageOptSettings):
     >>> msow
     <MultiStageOptWorkflow RAPID>
     >>> msow.level_of_theory
-    'r2scan_3c/cpcm(water)//gfn2_xtb/alpb(water)'
+    'r2scan_3c/cpcm(water)//gfn2_xtb'
     """
 
     # Populated while running the workflow
@@ -228,14 +223,14 @@ class MultiStageOptMixin(BaseModel):
     Mixin for workflows that use MultiStageOptSettings.
     """
 
-    mso_mode: Mode
+    mso_mode: Mode = Mode.AUTO
     # 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:
@@ -265,3 +260,74 @@ class MultiStageOptMixin(BaseModel):
                 )
 
         return self
+
+
+def build_mso_settings(
+    sp_method: Method,
+    sp_basis_set: str | None,
+    opt_methods: list[Method],
+    opt_basis_sets: list[str | None],
+    mode: Mode = Mode.MANUAL,
+    solvent: Solvent | None = None,
+    use_solvent_for_opt: bool = False,
+    constraints: list[Constraint] | None = None,
+    transition_state: bool = False,
+    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: 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
+    :param use_solvent_for_opt: whether to conduct opts with solvent
+    :param constraints: constraints for optimization
+    :param transition_state: whether this is a transition state
+    :param frequencies: whether to calculate frequencies
+    :returns: MultiStageOptSettings
+    """
+    if constraints is None:
+        constraints = []
+
+    opt_settings = OptimizationSettings(constraints=constraints, transition_state=transition_state)
+
+    OPT = [Task.OPTIMIZE if not transition_state else Task.OPTIMIZE_TS]
+
+    def opt(method: Method, basis_set: str | None = None, solvent: Solvent | None = None, freq: bool = False) -> Settings:
+        """Generates optimization settings."""
+        model = "alpb" if method in XTB_METHODS else "cpcm"
+
+        return Settings(
+            method=method,
+            basis_set=basis_set,
+            tasks=OPT + [Task.FREQUENCIES] * freq,
+            solvent_settings=SolventSettings(solvent=solvent, model=model) if (solvent and use_solvent_for_opt) else None,
+            opt_settings=opt_settings,
+        )
+
+    def sp(method: Method, basis_set: str | None = None, solvent: Solvent | None = None) -> Settings:
+        """Generate singlepoint settings."""
+        model = "cpcmx" if method in XTB_METHODS else "cpcm"
+
+        return Settings(
+            method=method,
+            basis_set=basis_set,
+            tasks=[Task.ENERGY],
+            solvent_settings=SolventSettings(solvent=solvent, model=model) if solvent else None,
+        )
+
+    return MultiStageOptSettings(
+        mode=mode,
+        optimization_settings=[
+            opt(method=method, basis_set=basis_set, solvent=solvent, freq=frequencies) for method, basis_set in zip(opt_methods, opt_basis_sets, strict=True)
+        ],
+        singlepoint_settings=sp(method=sp_method, basis_set=sp_basis_set, solvent=solvent),
+        solvent=solvent,
+        xtb_preopt=False,
+        constraints=constraints,
+        transition_state=transition_state,
+        frequencies=frequencies,
+    )

stjames/workflows/redox_potential.py

@@ -1,22 +1,59 @@
-from typing import Any
+from typing import Any, TypeVar
+
+from pydantic import ValidationInfo, field_validator, model_validator
 
 from ..mode import Mode
 from ..solvent import Solvent
 from ..types import UUID
+from .multistage_opt import MultiStageOptMixin
 from .workflow import Workflow
 
+_T = TypeVar("_T")
+
+
+class RedoxPotentialWorkflow(Workflow, MultiStageOptMixin):
+    """
+    Workflow for computing spin states of molecules.
+
+    Uses the modes from MultiStageOptSettings.
+
+    Inherited
+    :param initial_molecule: Molecule of interest
+    :param mode: Mode for workflow
+    :param multistage_opt_settings: set by mode unless mode=MANUAL (ignores additional settings if set)
+    :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
+
+    Overridden:
+    :param mso_mode: Mode for MultiStageOptSettings
+    :param solvent: solvent to use for optimization
+
+    New:
+    :param reduction: whether or not to calculate the reduction half-reaction
+    :param oxidation: whether or not to calculate the oxidation half-reaction
+    :param neutral_molecule: UUID of the calculation for the neutral molecule
+    :param anion_molecule: UUID of the calculation for the anion molecule
+    :param cation_molecule: UUID of the calculation for the cation molecule
+    :param reduction_potential: the final potential, in V
+    :param oxidation_potential: the final potential, in V
+
+    Legacy:
+    :param redox_type: one of "reduction" or "oxidation"
+    :param redox_potential: the corresponding potential, in V
+    """
 
-class RedoxPotentialWorkflow(Workflow):
-    mode: Mode = Mode.RAPID
     solvent: Solvent = Solvent.ACETONITRILE
+
     reduction: bool = True
     oxidation: bool = True
 
     # legacy values - remove in future release!
-    redox_type: UUID | None = None
+    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
@@ -24,6 +61,33 @@ class RedoxPotentialWorkflow(Workflow):
     reduction_potential: float | None = None
     oxidation_potential: float | None = None
 
+    @field_validator("solvent", mode="before")
+    @classmethod
+    def only_mecn_please(cls, val: Solvent | None) -> Solvent:
+        """Only MeCN please!"""
+        if val != Solvent.ACETONITRILE:
+            raise ValueError("Only acetonitrile permitted!")
+
+        return val
+
+    @field_validator("constraints", "transition_state")
+    @classmethod
+    def turned_off(cls, value: _T, info: ValidationInfo) -> _T:
+        if value:
+            raise ValueError(f"{info.field_name} not supported in redox potential workflows.")
+
+        return value
+
+    @model_validator(mode="before")
+    @classmethod
+    def set_mode_and_mso_mode(cls, values: dict[str, Any]) -> dict[str, Any]:
+        """Set the MultiStageOptSettings mode to match current redox potential mode, and select mode if `Auto`."""
+        if ("mode" not in values) or (values["mode"] == Mode.AUTO):
+            values["mode"] = Mode.RAPID
+
+        values["mso_mode"] = values["mode"]
+        return values
+
     def model_post_init(self, __context: Any) -> None:
         """Keep back-compatible with old schema."""
         if self.redox_type == "oxidation":

stjames/workflows/scan.py

@@ -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/workflows/spin_states.py

@@ -51,8 +51,8 @@ class SpinStatesWorkflow(Workflow, MultiStageOptMixin):
     :param initial_molecule: Molecule of interest
     :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
-    :param xtb_preopt: pre-optimize with xtb (sets based on mode when None)
+    :param solvent: solvent to use for optimization
+    :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/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.44.dist-info → stjames-0.0.46.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: stjames
-Version: 0.0.44
+Version: 0.0.46
 Summary: standardized JSON atom/molecule encoding scheme
 Author-email: Corin Wagen <corin@rowansci.com>
 Project-URL: Homepage, https://github.com/rowansci/stjames
@@ -8,7 +8,7 @@ Project-URL: Bug Tracker, https://github.com/rowansci/stjames/issues
 Requires-Python: >=3.11
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: pydantic >=2.4
+Requires-Dist: pydantic>=2.4
 Requires-Dist: numpy
 
 # stjames

{stjames-0.0.44.dist-info → stjames-0.0.46.dist-info}/RECORD

@@ -4,25 +4,25 @@ stjames/atom.py,sha256=w7q-x9xpBw4sJ1WGrWt65WAaStxhz-m7dugXCYEOpq4,2064
 stjames/base.py,sha256=9PvUjBeVSkmA3TaruaB0uvjFMbWYTGKXECISNGAj_AU,1201
 stjames/basis_set.py,sha256=wI3M2q9uPf9jhKpAi4E2DrsyKzloDGLRjAlk7krdYgc,949
 stjames/calculation.py,sha256=O2LwwQ_cOLmDOGXTHA9J71YbUZXigUSbvbLA-fSVm3w,915
-stjames/constraint.py,sha256=IQsQPGbjaoWXZkAOPPBH0_-EGtWwGkkHBhuPg53v5-M,890
-stjames/correction.py,sha256=_pNG3qSylfx0iyUxqwx9HPU0m032YwP6wSPCjbJrD94,358
-stjames/diis_settings.py,sha256=QHc7L-hktkbOWBYr29byTdqL8lWJzKJiY9XW8ha4Qzo,552
+stjames/constraint.py,sha256=B6oV0rYjmAWr8gpi5f03gRy_uuqjUURVDVwoez5Cfbg,2442
+stjames/correction.py,sha256=ZVErCcj4TPyZeKrdvXVjHa0tFynsCaoy96QZUVxWFM8,413
+stjames/diis_settings.py,sha256=4m1EQQWBlpHhMnWopix8qOqJv7QCluvdnV9jSKJDFtE,552
 stjames/grid_settings.py,sha256=WrSNGc-8_f87YBZYt9Hh7RbhM4MweADoVzwBMcSqcsE,640
 stjames/int_settings.py,sha256=5HXp8opt5ZyY1UpmfaK7NVloWVLM5jkG0elEEqpVLUo,896
 stjames/message.py,sha256=Rq6QqmHZKecWxYH8fVyXmuoCCPZv8YinvgykSeorXSU,216
-stjames/method.py,sha256=xnfphxyiWZotxQcmgvpFMJDmGEM2B-_5cbPkgYZBIws,1245
+stjames/method.py,sha256=a6QQff-0YsutkOTuOcGrdDW76x9ZexiNLdKzzoE1Vcw,1698
 stjames/mode.py,sha256=xw46Cc7f3eTS8i35qECi-8DocAlANhayK3w4akD4HBU,496
-stjames/molecule.py,sha256=QV_8vscvF48wadWtnt_no5S7j0kHgUbbFr7EnlDnzfk,10558
+stjames/molecule.py,sha256=v8NikFHfwOahXSo4VKGSqeHKI2HIoRdNjGE0GkZgNS4,10554
 stjames/opt_settings.py,sha256=gxXGtjy9l-Q5Wen9eO6T6HHRCuS8rfOofdVQIJj0JcI,550
 stjames/periodic_cell.py,sha256=JDCyynpamggTNi_HnTnnotRbeSMBfYc-srhD-IwUnrg,996
 stjames/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-stjames/scf_settings.py,sha256=xMMCQ0hVB4nNFSiWesNQZUa_aLsozSZGYWweAPPDGBg,2356
+stjames/scf_settings.py,sha256=WotVgVrayQ_8PUHP39zVtG7iLT9PV41lpzruttFACP8,2356
 stjames/settings.py,sha256=tfgEYns6WdsheQ6wpR6uyI8O4s2iTqyH7YWtNQ36k74,8666
 stjames/solvent.py,sha256=u037tmu-9oa21s-WEDZ7VC7nuNVjkqR2ML4JWjWSME4,1158
 stjames/status.py,sha256=wTKNcNxStoEHrxxgr_zTyN90NITa3rxMQZzOgrCifEw,332
 stjames/task.py,sha256=OLINRqe66o7t8arffilwmggrF_7TH0L79u6DhGruxV8,329
 stjames/thermochem_settings.py,sha256=ZTLz31v8Ltutde5Nfm0vH5YahWjcfFWfr_R856KffxE,517
-stjames/types.py,sha256=2FBtEwpaqBIgN7fmVRORJfkv-am0Lssr8e7ho7Fui8w,206
+stjames/types.py,sha256=CPKR0g_kdFejMjGdKBjtuJRQqfmAZ-uIaSuGR1vBzCQ,245
 stjames/data/__init__.py,sha256=O59Ksp7AIqwOELCWymfCx7YeBzwNOGCMlGQi7tNLqiE,24
 stjames/data/bragg_radii.json,sha256=hhbn-xyZNSdmnULIjN2Cvq-_BGIZIqG243Ls_mey61w,1350
 stjames/data/elements.py,sha256=9BW01LZlyJ0H5s7Q26vUmjZIST41fwOYYrGvmPd7q0w,858
@@ -30,23 +30,25 @@ stjames/data/isotopes.json,sha256=5ba8QnLrHD_Ypv2xekv2cIRwYrX3MQ19-1FOFtt0RuU,83
 stjames/data/nist_isotopes.json,sha256=d5DNk1dX0iB1waEYIRR6JMHuA7AuYwSBEgBvb4EKyhM,14300
 stjames/data/read_nist_isotopes.py,sha256=y10FNjW43QpC45qib7VHsIghEwT7GG5rsNwHdc9osRI,3309
 stjames/data/symbol_element.json,sha256=vl_buFusTqBd-muYQtMLtTDLy2OtBI6KkBeqkaWRQrg,1186
-stjames/workflows/__init__.py,sha256=TQwTrX8hzUKBcCV4C05IvePjnEotsAWTbXv4-b8zDRk,331
+stjames/workflows/__init__.py,sha256=IRcfBNaFWVMmixQHjPKcBJkcUYWRnXNwrx2MUFNiQKM,1843
 stjames/workflows/admet.py,sha256=V8noO0Eb7h2bDFSnj6Pxv4ILm0lGxyVRCi13hE0zmEQ,149
 stjames/workflows/basic_calculation.py,sha256=q48bpab7ZqmRTR4PsGC6bWkuxqkVdJRM8gysevTYXP0,212
-stjames/workflows/bde.py,sha256=c_4gGDFSjHvw4CBW21i6ErSAK2Tpypvld2yair1KYXo,9568
+stjames/workflows/bde.py,sha256=iNrBiAUJA-VaAB-eFddApUO2xIc5PyPYXNtC2stQ_OU,9667
 stjames/workflows/conformer.py,sha256=YYwL3l7OaVeea4N9-ihghwa_ieKY6hia9LNbiTraMb0,2732
-stjames/workflows/descriptors.py,sha256=jQ3RuMi7xk799JZ_AL1ARL3yQfWLG03L_VVsK4KIMeY,281
-stjames/workflows/fukui.py,sha256=F5tw5jTqBimo_GiXuThhRpoxauZE5YadZjObLFDCba8,348
-stjames/workflows/molecular_dynamics.py,sha256=YsDGkpI_FbB02sVkF1xiUK141cMQaHBjYyvTJarjBaU,1954
-stjames/workflows/multistage_opt.py,sha256=aJGKqsTfVOyZk-dNsM9Z7IEOlpfYw7qvSmxo-u5IeEE,10252
+stjames/workflows/conformer_search.py,sha256=zmGaSuka0VClmX36AkKvJAN565-hyp2ZJQIjhkAMQRM,12924
+stjames/workflows/descriptors.py,sha256=lRRCsGzad3nIg0wI1090ffaXB0FVh0nRRb2lNxCY0kI,281
+stjames/workflows/electronic_properties.py,sha256=DFrzU49rux13Fy5q7pgvuYNjiyC2KwMtqU6FTAxg9jo,3339
+stjames/workflows/fukui.py,sha256=CsJ3_gvzqEqcxwYN7bnNIa37F3KlLm7obsU77TGmDgo,348
+stjames/workflows/molecular_dynamics.py,sha256=wx633IhPjRwEYvfyuRnSb0c84lN2WtZJET2q-SJv5DY,2211
+stjames/workflows/multistage_opt.py,sha256=FXSm-adv9TIiE6ftWPO50Yq9ypoJ7GSPkJKpnC0r4kQ,12686
 stjames/workflows/pka.py,sha256=zpR90Yv2L-D56o2mGArM8027DWpnFFnay31UR9Xh5Nc,774
-stjames/workflows/redox_potential.py,sha256=u6QThnqheJp6EDuWiJApJEh-fp0TKGfSyKfa8ykf85g,1211
-stjames/workflows/scan.py,sha256=hL4Hco3Ns0dntjh2G2HhhWmED1mbt0gA_hsglPQ5Vjg,814
-stjames/workflows/spin_states.py,sha256=hzxDG8pBlmae8EUEizl0sn6nsXYk4ClmeH-cFZ4bSIc,4606
-stjames/workflows/tautomer.py,sha256=kZSCHo2Q7LzqtQjF_WyyxjECkndG49T9QOM12hsUkx8,421
+stjames/workflows/redox_potential.py,sha256=e7WOyTIC_1NPfh7amvW7YzqQezcswX9YaXT-qPiePAo,3651
+stjames/workflows/scan.py,sha256=Wqimw1nMErKOYHcC7U1hNC8LZb5XPtS-nE1a-c_6_88,814
+stjames/workflows/spin_states.py,sha256=TXHqB7ClTkkCy1Yfcsv99v2woAhT8oG1-uaF20-oMbQ,4592
+stjames/workflows/tautomer.py,sha256=owZOOfGlohxlaOG1pGpx7dVPvas8ZEnl_9Ms5F0Kpms,421
 stjames/workflows/workflow.py,sha256=tIu5naADYgYS7kdW8quvGEWHWosBcrIdcD7L86v-uMQ,976
-stjames-0.0.44.dist-info/LICENSE,sha256=i7ehYBS-6gGmbTcgU4mgk28pyOx2kScJ0kcx8n7bWLM,1084
-stjames-0.0.44.dist-info/METADATA,sha256=WxNrF-JxZt7kqljgnu2Ou8i-1lSWefeX3q2GNFDe6Io,1628
-stjames-0.0.44.dist-info/WHEEL,sha256=GV9aMThwP_4oNCtvEC2ec3qUYutgWeAzklro_0m4WJQ,91
-stjames-0.0.44.dist-info/top_level.txt,sha256=FYCwxl6quhYOAgG-mnPQcCK8vsVM7B8rIUrO-WrQ_PI,8
-stjames-0.0.44.dist-info/RECORD,,
+stjames-0.0.46.dist-info/LICENSE,sha256=i7ehYBS-6gGmbTcgU4mgk28pyOx2kScJ0kcx8n7bWLM,1084
+stjames-0.0.46.dist-info/METADATA,sha256=sagkuDdeazTP1wvoGMsletsSSFzY_8Qjv0shhmcj17w,1627
+stjames-0.0.46.dist-info/WHEEL,sha256=PZUExdf71Ui_so67QXpySuHtCi3-J3wvF4ORK6k_S8U,91
+stjames-0.0.46.dist-info/top_level.txt,sha256=FYCwxl6quhYOAgG-mnPQcCK8vsVM7B8rIUrO-WrQ_PI,8
+stjames-0.0.46.dist-info/RECORD,,

{stjames-0.0.44.dist-info → stjames-0.0.46.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (75.1.0)
+Generator: setuptools (75.6.0)
 Root-Is-Purelib: true
 Tag: py3-none-any