Singlepoint calculations#

Stuff

Singlepoint Record#

Stuff

Singlepoint Dataset#

Stuff

Singlepoint QCPortal API#

class SinglepointRecord(client=None, *, id, record_type='singlepoint', is_service, properties=None, extras={}, 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, molecule_id, molecule=None, wavefunction=None)[source]#

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['singlepoint'])

  • is_service (bool)

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

  • extras (Dict[str, Any])

  • 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 (QCSpecification)

  • molecule_id (int)

  • molecule (Molecule | None)

  • wavefunction (Wavefunction | None)

field record_type: Literal['singlepoint'] = 'singlepoint'#
field specification: QCSpecification [Required]#
field molecule_id: int [Required]#
field molecule_: Molecule | None = None (alias 'molecule')#
field wavefunction_: Wavefunction | None = None (alias 'wavefunction')#
propagate_client(client)[source]#

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 return_result: Any#
property molecule: Molecule#
property wavefunction: WavefunctionProperties | None#
to_qcschema_result()[source]#
Return type:

AtomicResult

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] = {}#
Validated by:

  • _validate_extras

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 QCSpecification(*, program, driver, method, basis, keywords={}, protocols=AtomicResultProtocols(wavefunction=<WavefunctionProtocolEnum.none: 'none'>, stdout=True, error_correction=ErrorCorrectionProtocol(default_policy=True, policies=None), native_files=<NativeFilesProtocolEnum.none: 'none'>))[source]#

Bases: BaseModel

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)

  • driver (SinglepointDriver)

  • method (ConstrainedStrValue)

  • basis (ConstrainedStrValue | None)

  • keywords (Dict[str, Any])

  • protocols (AtomicResultProtocols)

model Config[source]#

Bases: object

extra = 'forbid'#
field program: ConstrainedStrValue [Required]#

The quantum chemistry program to evaluate the computation with. Not all quantum chemistry programs support all combinations of driver/method/basis.

field driver: SinglepointDriver [Required]#
field method: ConstrainedStrValue [Required]#

The quantum chemistry method to evaluate (e.g., B3LYP, PBE, …).

field basis: ConstrainedStrValue | None [Required]#

The quantum chemistry basis set to evaluate (e.g., 6-31g, cc-pVDZ, …). Can be None for methods without basis sets.

Validated by:

  • _convert_basis

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

Program-specific keywords to use for the computation

field protocols: AtomicResultProtocols = AtomicResultProtocols(wavefunction=<WavefunctionProtocolEnum.none: 'none'>, stdout=True, error_correction=ErrorCorrectionProtocol(default_policy=True, policies=None), native_files=<NativeFilesProtocolEnum.none: 'none'>)#
On this page
Show Source