OpenFF QCSubmit documentation

OptimizationEntry

pydantic model openff.qcsubmit.datasets.OptimizationEntry

An optimization dataset specific entry class which can handle constraints.

Show JSON schema

{
   "title": "OptimizationEntry",
   "description": "An optimization dataset specific entry class which can handle constraints.",
   "type": "object",
   "properties": {
      "index": {
         "title": "Index",
         "description": "The index name the molecule will be stored under in QCArchive. Note that if multipule geometries are provided the index will be augmented with a value indecating the conformer number so -0, -1.",
         "type": "string"
      },
      "initial_molecules": {
         "title": "Initial Molecules",
         "description": "A list of QCElemental Molecule objects which contain the geometries to be used as inputs for the calculation.",
         "type": "array",
         "items": {
            "$ref": "#/definitions/Molecule"
         }
      },
      "attributes": {
         "title": "Attributes",
         "description": "The complete set of required cmiles attributes for the molecule.",
         "allOf": [
            {
               "$ref": "#/definitions/MoleculeAttributes"
            }
         ]
      },
      "extras": {
         "title": "Extras",
         "description": "Any extra information that should be injected into the QCElemental models before being submited like the cmiles information.",
         "default": {},
         "type": "object"
      },
      "keywords": {
         "title": "Keywords",
         "description": "Any extra keywords that should be used in the QCArchive calculation should be passed here.",
         "default": {},
         "type": "object"
      },
      "constraints": {
         "title": "Constraints",
         "description": "Any constraints which should be used during an optimization.",
         "default": {},
         "allOf": [
            {
               "$ref": "#/definitions/Constraints"
            }
         ]
      }
   },
   "required": [
      "index",
      "initial_molecules",
      "attributes"
   ],
   "definitions": {
      "Identifiers": {
         "title": "Identifiers",
         "description": "Canonical chemical identifiers",
         "type": "object",
         "properties": {
            "molecule_hash": {
               "title": "Molecule Hash",
               "type": "string"
            },
            "molecular_formula": {
               "title": "Molecular Formula",
               "type": "string"
            },
            "smiles": {
               "title": "Smiles",
               "type": "string"
            },
            "inchi": {
               "title": "Inchi",
               "type": "string"
            },
            "inchikey": {
               "title": "Inchikey",
               "type": "string"
            },
            "canonical_explicit_hydrogen_smiles": {
               "title": "Canonical Explicit Hydrogen Smiles",
               "type": "string"
            },
            "canonical_isomeric_explicit_hydrogen_mapped_smiles": {
               "title": "Canonical Isomeric Explicit Hydrogen Mapped Smiles",
               "type": "string"
            },
            "canonical_isomeric_explicit_hydrogen_smiles": {
               "title": "Canonical Isomeric Explicit Hydrogen Smiles",
               "type": "string"
            },
            "canonical_isomeric_smiles": {
               "title": "Canonical Isomeric Smiles",
               "type": "string"
            },
            "canonical_smiles": {
               "title": "Canonical Smiles",
               "type": "string"
            },
            "pubchem_cid": {
               "title": "Pubchem Cid",
               "description": "PubChem Compound ID",
               "type": "string"
            },
            "pubchem_sid": {
               "title": "Pubchem Sid",
               "description": "PubChem Substance ID",
               "type": "string"
            },
            "pubchem_conformerid": {
               "title": "Pubchem Conformerid",
               "description": "PubChem Conformer ID",
               "type": "string"
            }
         },
         "additionalProperties": false
      },
      "Provenance": {
         "title": "Provenance",
         "description": "Provenance information.",
         "type": "object",
         "properties": {
            "creator": {
               "title": "Creator",
               "description": "The name of the program, library, or person who created the object.",
               "type": "string"
            },
            "version": {
               "title": "Version",
               "description": "The version of the creator, blank otherwise. This should be sortable by the very broad `PEP 440 <https://www.python.org/dev/peps/pep-0440/>`_.",
               "default": "",
               "type": "string"
            },
            "routine": {
               "title": "Routine",
               "description": "The name of the routine or function within the creator, blank otherwise.",
               "default": "",
               "type": "string"
            }
         },
         "required": [
            "creator"
         ],
         "$schema": "http://json-schema.org/draft-04/schema#"
      },
      "Molecule": {
         "title": "Molecule",
         "description": "The physical Cartesian representation of the molecular system.\n\nA QCSchema representation of a Molecule. This model contains\ndata for symbols, geometry, connectivity, charges, fragmentation, etc while also supporting a wide array of I/O and manipulation capabilities.\n\nMolecule objects geometry, masses, and charges are truncated to 8, 6, and 4 decimal places respectively to assist with duplicate detection.\n\nNotes\n-----\nAll arrays are stored flat but must be reshapable into the dimensions in attribute ``shape``, with abbreviations as follows:\n\n  * nat: number of atomic = calcinfo_natom\n  * nfr: number of fragments\n  * <varies>: irregular dimension not systematically reshapable",
         "type": "object",
         "properties": {
            "schema_name": {
               "title": "Schema Name",
               "description": "The QCSchema specification to which this model conforms. Explicitly fixed as qcschema_molecule.",
               "default": "qcschema_molecule",
               "pattern": "^(qcschema_molecule)$",
               "type": "string"
            },
            "schema_version": {
               "title": "Schema Version",
               "description": "The version number of :attr:`~qcelemental.models.Molecule.schema_name` to which this model conforms.",
               "default": 2,
               "type": "integer"
            },
            "validated": {
               "title": "Validated",
               "description": "A boolean indicator (for speed purposes) that the input Molecule data has been previously checked for schema (data layout and type) and physics (e.g., non-overlapping atoms, feasible multiplicity) compliance. This should be False in most cases. A ``True`` setting should only ever be set by the constructor for this class itself or other trusted sources such as a Fractal Server or previously serialized Molecules.",
               "default": false,
               "type": "boolean"
            },
            "symbols": {
               "title": "Symbols",
               "description": "The ordered array of atomic elemental symbols in title case. This field's index sets atomic order for all other per-atom fields like :attr:`~qcelemental.models.Molecule.real` and the first dimension of :attr:`~qcelemental.models.Molecule.geometry`. Ghost/virtual atoms must have an entry here in :attr:`~qcelemental.models.Molecule.symbols`; ghostedness is indicated through the :attr:`~qcelemental.models.Molecule.real` field.",
               "shape": [
                  "nat"
               ],
               "type": "array",
               "items": {
                  "type": "string"
               }
            },
            "geometry": {
               "title": "Geometry",
               "description": "The ordered array for Cartesian XYZ atomic coordinates [a0]. Atom ordering is fixed; that is, a consumer who shuffles atoms must not reattach the input (pre-shuffling) molecule schema instance to any output (post-shuffling) per-atom results (e.g., gradient). Index of the first dimension matches the 0-indexed indices of all other per-atom settings like :attr:`~qcelemental.models.Molecule.symbols` and :attr:`~qcelemental.models.Molecule.real`.\nSerialized storage is always flat, (3*nat,), but QCSchema implementations will want to reshape it. QCElemental can also accept array-likes which can be mapped to (nat,3) such as a 1-D list of length 3*nat, or the serialized version of the array in (3*nat,) shape; all forms will be reshaped to (nat,3) for this attribute.",
               "shape": [
                  "nat",
                  3
               ],
               "units": "a0",
               "type": "array",
               "items": {
                  "type": "number"
               }
            },
            "name": {
               "title": "Name",
               "description": "Common or human-readable name to assign to this molecule. This field can be arbitrary; see :attr:`~qcelemental.models.Molecule.identifiers` for well-defined labels.",
               "type": "string"
            },
            "identifiers": {
               "title": "Identifiers",
               "description": "An optional dictionary of additional identifiers by which this molecule can be referenced, such as INCHI, canonical SMILES, etc. See the :class:`~qcelemental.models.results.Identifiers` model for more details.",
               "allOf": [
                  {
                     "$ref": "#/definitions/Identifiers"
                  }
               ]
            },
            "comment": {
               "title": "Comment",
               "description": "Additional comments for this molecule. Intended for pure human/user consumption and clarity.",
               "type": "string"
            },
            "molecular_charge": {
               "title": "Molecular Charge",
               "description": "The net electrostatic charge of the molecule.",
               "default": 0.0,
               "type": "number"
            },
            "molecular_multiplicity": {
               "title": "Molecular Multiplicity",
               "description": "The total multiplicity of the molecule.",
               "default": 1,
               "type": "integer"
            },
            "masses": {
               "title": "Masses",
               "description": "The ordered array of atomic masses. Index order matches the 0-indexed indices of all other per-atom fields like :attr:`~qcelemental.models.Molecule.symbols` and :attr:`~qcelemental.models.Molecule.real`. If this is not provided, the mass of each atom is inferred from its most common isotope. If this is provided, it must be the same length as :attr:`~qcelemental.models.Molecule.symbols` but can accept ``None`` entries for standard masses to infer from the same index in the :attr:`~qcelemental.models.Molecule.symbols` field.",
               "shape": [
                  "nat"
               ],
               "units": "u",
               "type": "array",
               "items": {
                  "type": "number"
               }
            },
            "real": {
               "title": "Real",
               "description": "The ordered array indicating if each atom is real (``True``) or ghost/virtual (``False``). Index matches the 0-indexed indices of all other per-atom settings like :attr:`~qcelemental.models.Molecule.symbols` and the first dimension of :attr:`~qcelemental.models.Molecule.geometry`. If this is not provided, all atoms are assumed to be real (``True``).If this is provided, the reality or ghostedness of every atom must be specified.",
               "shape": [
                  "nat"
               ],
               "type": "array",
               "items": {
                  "type": "boolean"
               }
            },
            "atom_labels": {
               "title": "Atom Labels",
               "description": "Additional per-atom labels as an array of strings. Typical use is in model conversions, such as Elemental <-> Molpro and not typically something which should be user assigned. See the :attr:`~qcelemental.models.Molecule.comment` field for general human-consumable text to affix to the molecule.",
               "shape": [
                  "nat"
               ],
               "type": "array",
               "items": {
                  "type": "string"
               }
            },
            "atomic_numbers": {
               "title": "Atomic Numbers",
               "description": "An optional ordered 1-D array-like object of atomic numbers of shape (nat,). Index matches the 0-indexed indices of all other per-atom settings like :attr:`~qcelemental.models.Molecule.symbols` and :attr:`~qcelemental.models.Molecule.real`. Values are inferred from the :attr:`~qcelemental.models.Molecule.symbols` list if not explicitly set. Ghostedness should be indicated through :attr:`~qcelemental.models.Molecule.real` field, not zeros here.",
               "shape": [
                  "nat"
               ],
               "type": "array",
               "items": {
                  "type": "number",
                  "multipleOf": 1.0
               }
            },
            "mass_numbers": {
               "title": "Mass Numbers",
               "description": "An optional ordered 1-D array-like object of atomic *mass* numbers of shape (nat). Index matches the 0-indexed indices of all other per-atom settings like :attr:`~qcelemental.models.Molecule.symbols` and :attr:`~qcelemental.models.Molecule.real`. Values are inferred from the most common isotopes of the :attr:`~qcelemental.models.Molecule.symbols` list if not explicitly set. If single isotope not (yet) known for an atom, -1 is placeholder.",
               "shape": [
                  "nat"
               ],
               "type": "array",
               "items": {
                  "type": "number",
                  "multipleOf": 1.0
               }
            },
            "connectivity": {
               "title": "Connectivity",
               "description": "A list of bonds within the molecule. Each entry is a tuple of ``(atom_index_A, atom_index_B, bond_order)`` where the ``atom_index`` matches the 0-indexed indices of all other per-atom settings like :attr:`~qcelemental.models.Molecule.symbols` and :attr:`~qcelemental.models.Molecule.real`. Bonds may be freely reordered and inverted.",
               "minItems": 1,
               "type": "array",
               "items": {
                  "type": "array",
                  "minItems": 3,
                  "maxItems": 3,
                  "items": [
                     {
                        "type": "integer",
                        "minimum": 0
                     },
                     {
                        "type": "integer",
                        "minimum": 0
                     },
                     {
                        "type": "number",
                        "minimum": 0,
                        "maximum": 5
                     }
                  ]
               }
            },
            "fragments": {
               "title": "Fragments",
               "description": "List of indices grouping atoms (0-indexed) into molecular fragments within the molecule. Each entry in the outer list is a new fragment; index matches the ordering in :attr:`~qcelemental.models.Molecule.fragment_charges` and :attr:`~qcelemental.models.Molecule.fragment_multiplicities`. Inner lists are 0-indexed atoms which compose the fragment; every atom must be in exactly one inner list. Noncontiguous fragments are allowed, though no QM program is known to support them. Fragment ordering is fixed; that is, a consumer who shuffles fragments must not reattach the input (pre-shuffling) molecule schema instance to any output (post-shuffling) per-fragment results (e.g., n-body energy arrays).",
               "shape": [
                  "nfr",
                  "<varies>"
               ],
               "type": "array",
               "items": {
                  "type": "array",
                  "items": {
                     "type": "number",
                     "multipleOf": 1.0
                  }
               }
            },
            "fragment_charges": {
               "title": "Fragment Charges",
               "description": "The total charge of each fragment in the :attr:`~qcelemental.models.Molecule.fragments` list. The index of this list matches the 0-index indices of :attr:`~qcelemental.models.Molecule.fragments` list. Will be filled in based on a set of rules if not provided (and :attr:`~qcelemental.models.Molecule.fragments` are specified).",
               "shape": [
                  "nfr"
               ],
               "type": "array",
               "items": {
                  "type": "number"
               }
            },
            "fragment_multiplicities": {
               "title": "Fragment Multiplicities",
               "description": "The multiplicity of each fragment in the :attr:`~qcelemental.models.Molecule.fragments` list. The index of this list matches the 0-index indices of :attr:`~qcelemental.models.Molecule.fragments` list. Will be filled in based on a set of rules if not provided (and :attr:`~qcelemental.models.Molecule.fragments` are specified).",
               "shape": [
                  "nfr"
               ],
               "type": "array",
               "items": {
                  "type": "integer"
               }
            },
            "fix_com": {
               "title": "Fix Com",
               "description": "Whether translation of geometry is allowed (fix F) or disallowed (fix T).When False, QCElemental will pre-process the Molecule object to translate the center of mass to (0,0,0) in Euclidean coordinate space, resulting in a different :attr:`~qcelemental.models.Molecule.geometry` than the one provided. 'Fix' is used in the sense of 'specify': that is, `fix_com=True` signals that the origin in `geometry` is a deliberate part of the Molecule spec, whereas `fix_com=False` (default) allows that the origin is happenstance and may be adjusted. guidance: A consumer who translates the geometry must not reattach the input (pre-translation) molecule schema instance to any output (post-translation) origin-sensitive results (e.g., an ordinary energy when EFP present).",
               "default": false,
               "type": "boolean"
            },
            "fix_orientation": {
               "title": "Fix Orientation",
               "description": "Whether rotation of geometry is allowed (fix F) or disallowed (fix T). When False, QCElemental will pre-process the Molecule object to orient via the intertial tensor, resulting in a different :attr:`~qcelemental.models.Molecule.geometry` than the one provided. 'Fix' is used in the sense of 'specify': that is, `fix_orientation=True` signals that the frame orientation in `geometry` is a deliberate part of the Molecule spec, whereas `fix_orientation=False` (default) allows that the frame is happenstance and may be adjusted. guidance: A consumer who rotates the geometry must not reattach the input (pre-rotation) molecule schema instance to any output (post-rotation) frame-sensitive results (e.g., molecular vibrations).",
               "default": false,
               "type": "boolean"
            },
            "fix_symmetry": {
               "title": "Fix Symmetry",
               "description": "Maximal point group symmetry which :attr:`~qcelemental.models.Molecule.geometry` should be treated. Lowercase.",
               "type": "string"
            },
            "provenance": {
               "title": "Provenance",
               "description": "The provenance information about how this Molecule (and its attributes) were generated, provided, and manipulated.",
               "allOf": [
                  {
                     "$ref": "#/definitions/Provenance"
                  }
               ]
            },
            "id": {
               "title": "Id",
               "description": "A unique identifier for this Molecule object. This field exists primarily for Databases (e.g. Fractal's Server) to track and lookup this specific object and should virtually never need to be manually set."
            },
            "extras": {
               "title": "Extras",
               "description": "Additional information to bundle with the molecule. Use for schema development and scratch space.",
               "type": "object"
            }
         },
         "required": [
            "symbols",
            "geometry"
         ],
         "additionalProperties": false,
         "$schema": "http://json-schema.org/draft-04/schema#"
      },
      "MoleculeAttributes": {
         "title": "MoleculeAttributes",
         "description": "A class to hold and validate the molecule attributes associated with a QCArchive entry, All attributes are required\nto be entered into a dataset.\n\nNote:\n    The attributes here are not exhaustive but are based on those given by cmiles and can all be obtain through the openforcefield toolkit Molecule class.",
         "type": "object",
         "properties": {
            "canonical_smiles": {
               "title": "Canonical Smiles",
               "type": "string"
            },
            "canonical_isomeric_smiles": {
               "title": "Canonical Isomeric Smiles",
               "type": "string"
            },
            "canonical_explicit_hydrogen_smiles": {
               "title": "Canonical Explicit Hydrogen Smiles",
               "type": "string"
            },
            "canonical_isomeric_explicit_hydrogen_smiles": {
               "title": "Canonical Isomeric Explicit Hydrogen Smiles",
               "type": "string"
            },
            "canonical_isomeric_explicit_hydrogen_mapped_smiles": {
               "title": "Canonical Isomeric Explicit Hydrogen Mapped Smiles",
               "description": "The fully mapped smiles where every atom should have a numerical tag so that the molecule can be rebuilt to match the order of the coordinates.",
               "type": "string"
            },
            "molecular_formula": {
               "title": "Molecular Formula",
               "description": "The hill formula of the molecule as given by the openfftoolkit.",
               "type": "string"
            },
            "standard_inchi": {
               "title": "Standard Inchi",
               "description": "The standard inchi given by the inchi program ie not fixed hydrogen layer.",
               "type": "string"
            },
            "inchi_key": {
               "title": "Inchi Key",
               "description": "The standard inchi key given by the inchi program.",
               "type": "string"
            },
            "fixed_hydrogen_inchi": {
               "title": "Fixed Hydrogen Inchi",
               "description": "The non-standard inchi with a fixed hydrogen layer to distinguish tautomers.",
               "type": "string"
            },
            "fixed_hydrogen_inchi_key": {
               "title": "Fixed Hydrogen Inchi Key",
               "description": "The non-standard inchikey with a fixed hydrogen layer.",
               "type": "string"
            },
            "unique_fixed_hydrogen_inchi_keys": {
               "title": "Unique Fixed Hydrogen Inchi Keys",
               "description": "The list of unique non-standard inchikey with a fixed hydrogen layer.",
               "type": "array",
               "items": {
                  "type": "string"
               },
               "uniqueItems": true
            }
         },
         "required": [
            "canonical_smiles",
            "canonical_isomeric_smiles",
            "canonical_explicit_hydrogen_smiles",
            "canonical_isomeric_explicit_hydrogen_smiles",
            "canonical_isomeric_explicit_hydrogen_mapped_smiles",
            "molecular_formula",
            "standard_inchi",
            "inchi_key"
         ]
      },
      "DihedralConstraint": {
         "title": "DihedralConstraint",
         "description": "A basic config class for results structures.",
         "type": "object",
         "properties": {
            "type": {
               "title": "Type",
               "default": "dihedral",
               "enum": [
                  "dihedral"
               ],
               "type": "string"
            },
            "indices": {
               "title": "Indices",
               "type": "array",
               "minItems": 4,
               "maxItems": 4,
               "items": [
                  {
                     "type": "integer"
                  },
                  {
                     "type": "integer"
                  },
                  {
                     "type": "integer"
                  },
                  {
                     "type": "integer"
                  }
               ]
            },
            "bonded": {
               "title": "Bonded",
               "description": "If this is a bonded constraint, this will trigger a validation step to ensure all of the atoms are bonded.",
               "default": true,
               "type": "boolean"
            }
         },
         "required": [
            "indices"
         ]
      },
      "AngleConstraint": {
         "title": "AngleConstraint",
         "description": "A basic config class for results structures.",
         "type": "object",
         "properties": {
            "type": {
               "title": "Type",
               "default": "angle",
               "enum": [
                  "angle"
               ],
               "type": "string"
            },
            "indices": {
               "title": "Indices",
               "type": "array",
               "minItems": 3,
               "maxItems": 3,
               "items": [
                  {
                     "type": "integer"
                  },
                  {
                     "type": "integer"
                  },
                  {
                     "type": "integer"
                  }
               ]
            },
            "bonded": {
               "title": "Bonded",
               "description": "If this is a bonded constraint, this will trigger a validation step to ensure all of the atoms are bonded.",
               "default": true,
               "type": "boolean"
            }
         },
         "required": [
            "indices"
         ]
      },
      "DistanceConstraint": {
         "title": "DistanceConstraint",
         "description": "A basic config class for results structures.",
         "type": "object",
         "properties": {
            "type": {
               "title": "Type",
               "default": "distance",
               "enum": [
                  "distance"
               ],
               "type": "string"
            },
            "indices": {
               "title": "Indices",
               "type": "array",
               "minItems": 2,
               "maxItems": 2,
               "items": [
                  {
                     "type": "integer"
                  },
                  {
                     "type": "integer"
                  }
               ]
            },
            "bonded": {
               "title": "Bonded",
               "description": "If this is a bonded constraint, this will trigger a validation step to ensure all of the atoms are bonded.",
               "default": true,
               "type": "boolean"
            }
         },
         "required": [
            "indices"
         ]
      },
      "PositionConstraint": {
         "title": "PositionConstraint",
         "description": "A basic config class for results structures.",
         "type": "object",
         "properties": {
            "type": {
               "title": "Type",
               "default": "xyz",
               "enum": [
                  "xyz"
               ],
               "type": "string"
            },
            "indices": {
               "title": "Indices",
               "type": "array",
               "items": {
                  "type": "integer"
               }
            }
         },
         "required": [
            "indices"
         ]
      },
      "DihedralConstraintSet": {
         "title": "DihedralConstraintSet",
         "description": "A basic config class for results structures.",
         "type": "object",
         "properties": {
            "type": {
               "title": "Type",
               "default": "dihedral",
               "enum": [
                  "dihedral"
               ],
               "type": "string"
            },
            "indices": {
               "title": "Indices",
               "type": "array",
               "minItems": 4,
               "maxItems": 4,
               "items": [
                  {
                     "type": "integer"
                  },
                  {
                     "type": "integer"
                  },
                  {
                     "type": "integer"
                  },
                  {
                     "type": "integer"
                  }
               ]
            },
            "bonded": {
               "title": "Bonded",
               "description": "If this is a bonded constraint, this will trigger a validation step to ensure all of the atoms are bonded.",
               "default": true,
               "type": "boolean"
            },
            "value": {
               "title": "Value",
               "type": "number"
            }
         },
         "required": [
            "indices",
            "value"
         ]
      },
      "AngleConstraintSet": {
         "title": "AngleConstraintSet",
         "description": "A basic config class for results structures.",
         "type": "object",
         "properties": {
            "type": {
               "title": "Type",
               "default": "angle",
               "enum": [
                  "angle"
               ],
               "type": "string"
            },
            "indices": {
               "title": "Indices",
               "type": "array",
               "minItems": 3,
               "maxItems": 3,
               "items": [
                  {
                     "type": "integer"
                  },
                  {
                     "type": "integer"
                  },
                  {
                     "type": "integer"
                  }
               ]
            },
            "bonded": {
               "title": "Bonded",
               "description": "If this is a bonded constraint, this will trigger a validation step to ensure all of the atoms are bonded.",
               "default": true,
               "type": "boolean"
            },
            "value": {
               "title": "Value",
               "type": "number"
            }
         },
         "required": [
            "indices",
            "value"
         ]
      },
      "DistanceConstraintSet": {
         "title": "DistanceConstraintSet",
         "description": "A basic config class for results structures.",
         "type": "object",
         "properties": {
            "type": {
               "title": "Type",
               "default": "distance",
               "enum": [
                  "distance"
               ],
               "type": "string"
            },
            "indices": {
               "title": "Indices",
               "type": "array",
               "minItems": 2,
               "maxItems": 2,
               "items": [
                  {
                     "type": "integer"
                  },
                  {
                     "type": "integer"
                  }
               ]
            },
            "bonded": {
               "title": "Bonded",
               "description": "If this is a bonded constraint, this will trigger a validation step to ensure all of the atoms are bonded.",
               "default": true,
               "type": "boolean"
            },
            "value": {
               "title": "Value",
               "type": "number"
            }
         },
         "required": [
            "indices",
            "value"
         ]
      },
      "PositionConstraintSet": {
         "title": "PositionConstraintSet",
         "description": "A basic config class for results structures.",
         "type": "object",
         "properties": {
            "type": {
               "title": "Type",
               "default": "xyz",
               "enum": [
                  "xyz"
               ],
               "type": "string"
            },
            "indices": {
               "title": "Indices",
               "type": "array",
               "minItems": 1,
               "maxItems": 1,
               "items": [
                  {
                     "type": "integer"
                  }
               ]
            },
            "value": {
               "title": "Value",
               "description": "The value the constraint should be set to, a value or possition.",
               "anyOf": [
                  {
                     "type": "string"
                  },
                  {
                     "type": "array",
                     "minItems": 3,
                     "maxItems": 3,
                     "items": [
                        {
                           "type": "number"
                        },
                        {
                           "type": "number"
                        },
                        {
                           "type": "number"
                        }
                     ]
                  }
               ]
            }
         },
         "required": [
            "indices",
            "value"
         ]
      },
      "Constraints": {
         "title": "Constraints",
         "description": "A constraints holder which validates the constraints type and data structure however the indices are not checked for connection as this is not required.",
         "type": "object",
         "properties": {
            "freeze": {
               "title": "Freeze",
               "description": "The list of freeze type constraints.",
               "default": [],
               "type": "array",
               "items": {
                  "anyOf": [
                     {
                        "$ref": "#/definitions/DihedralConstraint"
                     },
                     {
                        "$ref": "#/definitions/AngleConstraint"
                     },
                     {
                        "$ref": "#/definitions/DistanceConstraint"
                     },
                     {
                        "$ref": "#/definitions/PositionConstraint"
                     }
                  ]
               }
            },
            "set": {
               "title": "Set",
               "description": "The list of set type constraints.",
               "default": [],
               "type": "array",
               "items": {
                  "anyOf": [
                     {
                        "$ref": "#/definitions/DihedralConstraintSet"
                     },
                     {
                        "$ref": "#/definitions/AngleConstraintSet"
                     },
                     {
                        "$ref": "#/definitions/DistanceConstraintSet"
                     },
                     {
                        "$ref": "#/definitions/PositionConstraintSet"
                     }
                  ]
               }
            }
         }
      }
   }
}

Config

• allow_mutation: bool = True

• arbitrary_types_allowed: bool = True

• json_encoders: dict = {<class ‘numpy.ndarray’>: <function DatasetConfig.Config.<lambda> at 0x7f458c1c88b0>, <enum ‘Enum’>: <function DatasetConfig.Config.<lambda> at 0x7f458c1c8940>}

• validate_assignment: bool = True

Fields

• constraints (openff.qcsubmit.constraints.Constraints)

field constraints: openff.qcsubmit.constraints.Constraints = Constraints(freeze=[], set=[])

Any constraints which should be used during an optimization.

add_constraint(constraint, constraint_type, indices, bonded=True, **kwargs)

Add new constraint of the given type.

Parameters

• constraint (Literal['set', 'freeze']) – The major type of constraint, freeze or set

• constraint_type (Literal['distance', 'angle', 'dihedral', 'xyz']) – the constraint sub type, angle, distance etc

• indices (List[int]) – The atom indices the constraint should be placed on

• bonded (bool) – If the constraint is intended to be put a bonded set of atoms

• kwargs – Any extra information needed by the constraint, for the set class they need a value value=float

Return type

None

property formatted_keywords: Dict[str, Any]

Format the keywords with the constraints values.