Optimization calculations

Stuff

Optimization Record

Stuff

Optimization Dataset

Stuff

Optimization QCPortal API

class OptimizationRecord(client=None, *, id, record_type='optimization', is_service, properties=None, extras=None, status, manager_name=None, created_on, modified_on, owner_user=None, owner_group=None, compute_history=None, task=None, service=None, comments=None, native_files=None, specification, initial_molecule_id, final_molecule_id=None, energies=None, initial_molecule=None, final_molecule=None, trajectory_ids=None)

Bases: BaseRecord

Create a new model by parsing and validating input data from keyword arguments.

Raises ValidationError if the input data cannot be parsed to form a valid model.

Parameters:

• id (int)

• record_type (Literal['optimization'])

• is_service (bool)

• properties (Dict[str, Any] | None)

• extras (Dict[str, Any] | None)

• status (RecordStatusEnum)

• manager_name (str | None)

• created_on (datetime)

• modified_on (datetime)

• owner_user (str | None)

• owner_group (str | None)

• compute_history (List[ComputeHistory] | None)

• task (RecordTask | None)

• service (RecordService | None)

• comments (List[RecordComment] | None)

• native_files (Dict[str, NativeFile] | None)

• specification (OptimizationSpecification)

• initial_molecule_id (int)

• final_molecule_id (int | None)

• energies (List[float] | None)

• initial_molecule (Molecule | None)

• final_molecule (Molecule | None)

• trajectory_ids (List[int] | None)

field record_type: Literal['optimization'] = 'optimization'

field specification: OptimizationSpecification [Required]

field initial_molecule_id: int [Required]

field final_molecule_id: int | None = None

field energies: List[float] | None = None

field initial_molecule_: Molecule | None = None (alias 'initial_molecule')

field final_molecule_: Molecule | None = None (alias 'final_molecule')

field trajectory_ids_: List[int] | None = None (alias 'trajectory_ids')

propagate_client(client)

Propagates a client and related information to this record to any fields within this record that need it

This is expected to be called from derived class propagate_client functions as well

property initial_molecule: Molecule

property final_molecule: Molecule | None

property trajectory: List[SinglepointRecord] | None

trajectory_element(trajectory_index)

Parameters:

trajectory_index (int)

Return type:

SinglepointRecord

to_qcschema_result()

Return type:

OptimizationResult

model Config

Bases: object

allow_mutation = True

extra = 'forbid'

validate_assignment = True

property children_errors: List[BaseRecord]

Returns errored child records

property children_status: Dict[RecordStatusEnum, int]

Returns a dictionary of the status of all children of this record

property comments: List[RecordComment] | None

property compute_history: List[ComputeHistory]

property error: Dict[str, Any] | None

fetch_children(include=None, force_fetch=False)

Fetches all children of this record recursively

Parameters:

• include (Iterable[str] | None)

• force_fetch (bool)

classmethod fetch_children_multi(records, include=None, force_fetch=False)

Fetches all children of the given records

This tries to work efficiently, fetching larger batches of children that can span multiple records

Parameters:

• records (Iterable[BaseRecord | None])

• include (Iterable[str] | None)

• force_fetch (bool)

classmethod get_subclass(record_type)

Obtain a subclass of this class given its record_type

Parameters:

record_type (str)

Return type:

Type[BaseRecord]

get_waiting_reason()

Return type:

Dict[str, Any]

property native_files: Dict[str, NativeFile] | None

property offline: bool

property provenance: Provenance | None

property service: RecordService | None

property stderr: str | None

property stdout: str | None

sync_to_cache(detach=False)

Syncs this record to the cache

If detach is True, then the record will be removed from the cache

Parameters:

detach (bool)

property task: RecordTask | None

field id: int [Required]

field is_service: bool [Required]

field properties: Dict[str, Any] | None = None

field extras: Dict[str, Any] | None = None

field status: RecordStatusEnum [Required]

field manager_name: str | None = None

field created_on: datetime [Required]

field modified_on: datetime [Required]

field owner_user: str | None = None

field owner_group: str | None = None

field compute_history_: List[ComputeHistory] | None = None (alias 'compute_history')

field task_: RecordTask | None = None (alias 'task')

field service_: RecordService | None = None (alias 'service')

field comments_: List[RecordComment] | None = None (alias 'comments')

field native_files_: Dict[str, NativeFile] | None = None (alias 'native_files')

class OptimizationSpecification(*, program, qc_specification, keywords={}, protocols=OptimizationProtocols(trajectory=<TrajectoryProtocolEnum.all: 'all'>))

Bases: BaseModel

An OptimizationSpecification as stored on the server

This is the same as the input specification, with a few ids added

Create a new model by parsing and validating input data from keyword arguments.

Raises ValidationError if the input data cannot be parsed to form a valid model.

Parameters:

• program (ConstrainedStrValue)

• qc_specification (QCSpecification)

• keywords (Dict[str, Any])

• protocols (OptimizationProtocols)

model Config

Bases: object

extra = 'forbid'

field program: ConstrainedStrValue [Required]

The program to use for an optimization

field qc_specification: QCSpecification [Required]

Validated by:

• force_qcspec

field keywords: Dict[str, Any] = {}

field protocols: OptimizationProtocols = OptimizationProtocols(trajectory=<TrajectoryProtocolEnum.all: 'all'>)

validator force_qcspec  »  qc_specification