Secure your code as it's written. Use Snyk Code to scan source code in minutes - no build needed - and fix issues immediately.
# Encoders, to be deprecated
ndarray_encoder = {np.ndarray: lambda v: v.flatten().tolist()}
class Provenance(ProtoModel):
"""
Provenance information.
"""
creator: str = Field(..., description="The creator of the object.")
version: Optional[str] = Field(None, description="The version of the creator.")
routine: Optional[str] = Field(None, description="The routine of the creator.")
class Config(ProtoModel.Config):
canonical_repr = True
extra = "allow"
class Model(ProtoModel):
"""
The quantum chemistry model specification for a given operation to compute against
"""
method: str = Field( # type: ignore
..., description="The quantum chemistry method to evaluate (e.g., B3LYP, PBE, ...)."
)
basis: Optional[str] = Field( # type: ignore
None,
description="The quantum chemistry basis set to evaluate (e.g., 6-31g, cc-pVDZ, ...). Can be ``None`` for "
"methods without basis sets.",
True, description="Whether to allow error corrections to be used " "if not directly specified in `policies`"
)
# TODO (wardlt): Consider support for common policies (e.g., 'only increase iterations') as strings (see #182)
policies: Optional[Dict[str, bool]] = Field(
None,
description="Settings that define whether specific error corrections are allowed. "
"Keys are the name of a known error and values are whether it is allowed to be used.",
)
def allows(self, policy: str):
if self.policies is None:
return self.default_policy
return self.policies.get(policy, self.default_policy)
class AtomicResultProtocols(ProtoModel):
"""
Protocols regarding the manipulation of a Result output data.
"""
wavefunction: WavefunctionProtocolEnum = Field(
WavefunctionProtocolEnum.none, description=str(WavefunctionProtocolEnum.__doc__)
)
stdout: bool = Field(True, description="Primary output file to keep from a Result computation")
error_correction: ErrorCorrectionProtocol = Field(
ErrorCorrectionProtocol(), description="Policies for error correction"
)
class Config:
force_skip_defaults = True
provenance: Provenance = Field( # type: ignore
provenance_stamp(__name__),
description="The provenance information about how this Molecule (and its attributes) were generated, "
"provided, and manipulated.",
)
id: Optional[Any] = Field( # type: ignore
None,
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: Dict[str, Any] = Field( # type: ignore
None, description="Extra information to associate with this Molecule."
)
class Config(ProtoModel.Config):
serialize_skip_defaults = True
repr_style = lambda self: [
("name", self.name),
("formula", self.get_molecular_formula()),
("hash", self.get_hash()[:7]),
]
fields = {
"masses_": "masses",
"real_": "real",
"atom_labels_": "atom_labels",
"atomic_numbers_": "atomic_numbers",
"mass_numbers_": "mass_numbers",
"connectivity_": "connectivity",
"fragments_": "fragments",
"fragment_charges_": "fragment_charges",
"fragment_multiplicities_": "fragment_multiplicities",
...,
description="Text associated with the thrown error, often the backtrace, but can contain additional "
"information as well.",
)
extras: Optional[Dict[str, Any]] = Field( # type: ignore
None, description="Additional data to ship with the ComputeError object."
)
class Config:
repr_style = ["error_type", "error_message"]
def __repr_args__(self) -> "ReprArgs":
return [("error_type", self.error_type), ("error_message", self.error_message)]
class FailedOperation(ProtoModel):
"""
A record indicating that a given operation (compute, procedure, etc.) has failed and contains the reason and
input data which generated the failure.
"""
id: str = Field( # type: ignore
None,
description="A unique identifier which links this FailedOperation, often of the same Id of the operation "
"should it have been successful. This will often be set programmatically by a database such as "
"Fractal.",
)
input_data: Any = Field( # type: ignore
None,
description="The input data which was passed in that generated this failure. This should be the complete "
"input which when attempted to be run, caused the operation to fail.",
class Provenance(ProtoModel):
"""
Provenance information.
"""
creator: str = Field(..., description="The creator of the object.")
version: Optional[str] = Field(None, description="The version of the creator.")
routine: Optional[str] = Field(None, description="The routine of the creator.")
class Config(ProtoModel.Config):
canonical_repr = True
extra = "allow"
class Model(ProtoModel):
"""
The quantum chemistry model specification for a given operation to compute against
"""
method: str = Field( # type: ignore
..., description="The quantum chemistry method to evaluate (e.g., B3LYP, PBE, ...)."
)
basis: Optional[str] = Field( # type: ignore
None,
description="The quantum chemistry basis set to evaluate (e.g., 6-31g, cc-pVDZ, ...). Can be ``None`` for "
"methods without basis sets.",
)
# basis_spec: BasisSpec = None # This should be exclusive with basis, but for now will be omitted
class Config(ProtoModel.Config):
# Round array
array = np.around(array, around)
# Flip zeros
array[np.abs(array) < 5 ** (-(around + 1))] = 0
elif isinstance(array, (float, int)):
array = round(array, around)
if array == -0.0:
array = 0.0
else:
raise TypeError("Type '{}' not recognized".format(type(array).__name__))
return array
class Identifiers(ProtoModel):
"""Canonical chemical identifiers"""
molecule_hash: Optional[str] = None
molecular_formula: Optional[str] = None
smiles: Optional[str] = None
inchi: Optional[str] = None
inchikey: Optional[str] = None
canonical_explicit_hydrogen_smiles: Optional[str] = None
canonical_isomeric_explicit_hydrogen_mapped_smiles: Optional[str] = None
canonical_isomeric_explicit_hydrogen_smiles: Optional[str] = None
canonical_isomeric_smiles: Optional[str] = None
canonical_smiles: Optional[str] = None
pubchem_cid: Optional[str] = Field(None, description="PubChem Compound ID")
pubchem_sid: Optional[str] = Field(None, description="PubChem Substance ID")
pubchem_conformerid: Optional[str] = Field(None, description="PubChem Conformer ID")
from .molecule import Molecule
from .results import AtomicResult
class TrajectoryProtocolEnum(str, Enum):
"""
Which gradient evaluations to keep in an optimization trajectory.
"""
all = "all"
initial_and_final = "initial_and_final"
final = "final"
none = "none"
class OptimizationProtocols(ProtoModel):
"""
Protocols regarding the manipulation of a Optimization output data.
"""
trajectory: TrajectoryProtocolEnum = Field(
TrajectoryProtocolEnum.all, description=str(TrajectoryProtocolEnum.__doc__)
)
class Config:
force_skip_defaults = True
class QCInputSpecification(ProtoModel):
"""
A compute description for energy, gradient, and Hessian computations used in a geometry optimization.
"""
if len(v) != len_exp:
raise ValueError("The length of gaussian_exponents does not match the length of `r` exponents.")
return v
@validator("coefficients")
def _check_coefficient_length(cls, v, values):
len_exp = len(values["r_exponents"])
for row in v:
if len(row) != len_exp:
raise ValueError("The length of coefficients does not match the length of `r` exponents.")
return v
class BasisCenter(ProtoModel):
"""
Data for a single atom/center in a basis set.
"""
electron_shells: List[ElectronShell] = Field(..., description="Electronic shells for this center.")
ecp_electrons: int = Field(0, description="Number of electrons replace by ECP potentials.")
ecp_potentials: Optional[List[ECPPotential]] = Field(None, description="ECPs for this center.")
class BasisSet(ProtoModel):
"""
A quantum chemistry basis description.
"""
schema_name: constr(strip_whitespace=True, regex="qcschema_basis") = "qcschema_basis"
schema_version: int = 1
"""
The quantum chemistry model specification for a given operation to compute against
"""
method: str = Field( # type: ignore
..., description="The quantum chemistry method to evaluate (e.g., B3LYP, PBE, ...)."
)
basis: Optional[str] = Field( # type: ignore
None,
description="The quantum chemistry basis set to evaluate (e.g., 6-31g, cc-pVDZ, ...). Can be ``None`` for "
"methods without basis sets.",
)
# basis_spec: BasisSpec = None # This should be exclusive with basis, but for now will be omitted
class Config(ProtoModel.Config):
canonical_repr = True
extra = "allow"
class DriverEnum(str, Enum):
"""Allowed quantum chemistry driver values.
"""
energy = "energy"
gradient = "gradient"
hessian = "hessian"
properties = "properties"
def derivative_int(self):
egh = ["energy", "gradient", "hessian", "third", "fourth", "fifth"]
if self == "properties":
orbitals_a: Optional[str] = Field(None, description="Index to the alpha-spin orbitals of the primary return.")
orbitals_b: Optional[str] = Field(None, description="Index to the beta-spin orbitals of the primary return.")
density_a: Optional[str] = Field(None, description="Index to the alpha-spin density of the primary return.")
density_b: Optional[str] = Field(None, description="Index to the beta-spin density of the primary return.")
fock_a: Optional[str] = Field(None, description="Index to the alpha-spin Fock matrix of the primary return.")
fock_b: Optional[str] = Field(None, description="Index to the beta-spin Fock matrix of the primary return.")
eigenvalues_a: Optional[str] = Field(None, description="Index to the alpha-spin eigenvalues of the primary return.")
eigenvalues_b: Optional[str] = Field(None, description="Index to the beta-spin eigenvalues of the primary return.")
occupations_a: Optional[str] = Field(
None, description="Index to the alpha-spin orbital eigenvalues of the primary return."
)
occupations_b: Optional[str] = Field(
None, description="Index to the beta-spin orbital eigenvalues of the primary return."
)
class Config(ProtoModel.Config):
force_skip_defaults = True
@validator("scf_eigenvalues_a", "scf_eigenvalues_b", "scf_occupations_a", "scf_occupations_b")
def _assert1d(cls, v, values):
try:
v = v.reshape(-1)
except (ValueError, AttributeError):
raise ValueError("Vector must be castable to shape (-1, )!")
return v
@validator("scf_orbitals_a", "scf_orbitals_b")
def _assert2d_nao_x(cls, v, values):
bas = values.get("basis", None)
# Do not raise multiple errors