Steering Wheel

Data Structures

class scine_chemoton.steering_wheel.datastructures.ExplorationResult

Result of a single step in the exploration scheme. This is the base class for all results.

abstract classmethod from_split_results(split_results)

classmethod receive_from_pipe(pipe)

Return type:

Any

send_in_pipe(pipe)

Return type:

None

abstract to_split_results()

Return type:

List[Any]

class scine_chemoton.steering_wheel.datastructures.ExplorationSchemeStep(model, *args, **kwargs)

The base class for a step in an exploration protocol. It defines the common handling of status, model, result access, name handling, and the initialization of required collections of the DB.

class Options(model, *args, **kwargs)

Options for the exploration scheme step.

Construct it with a given model

Parameters:

modeldb.Model

The model given to all subclasses.

unset_collections()

Duplicate name to HoldCollections method to be triggered in pickling process, so infinite _parent loops are avoided.

Return type:

None

get_result()

Return type:

Optional[ExplorationResult]

initialize_collections(manager)

Return type:

None

property name: str

options: Options

static possible_attributes()

Return type:

List[str]

set_result(result)

Return type:

None

unset_collections()

Return type:

None

class scine_chemoton.steering_wheel.datastructures.GearOptions(gears_and_indices=None, model=None)

A container with additional sanity checks to hold and modify the options of each gear. The keys are the names of the gears and the values are a tuple of the gear’s options and the TrialGenerator’s options in case the gear holds a TrialGenerator, otherwise the second entry is None.

Notes

Currently does not support initialization from existing dictionary.

Convenience method to only plug-in gears and an optional for model, that is then already added to each option. This builds the respective dictionary based on the common API of the gears.

Parameters:

gears_and_indicesOptional[List[Tuple[Gear, Optional[int]]]], optional

List of gears to generate options for, by default None. The optional integer represents if this options should apply to all gears of this type (None) or only to the gear with the given index (starting at zero).

modelOptional[db.Model], optional

Optional model to add to the options, by default None.

apply_to_protocol(protocol)

Return type:

None

clear() → None.  Remove all items from D.

copy()

classmethod fromkeys(iterable, value=None)

static generate_value(gear)

Builds a single tuple value from a gear based on known Chemoton API.

Return type:

Tuple[Options, Optional[Options]]

get(k[, d]) → D[k] if k in D, else d.  d defaults to None.

items() → a set-like object providing a view on D's items

key_check(key)

Return type:

None

keys() → a set-like object providing a view on D's keys

pop(k[, d]) → v, remove specified key and return the corresponding value.

If key is not found, d is returned if given, otherwise KeyError is raised.

popitem() → (k, v), remove and return some (key, value) pair

as a 2-tuple; but raise KeyError if D is empty.

setdefault(k[, d]) → D.get(k,d), also set D[k]=d if k not in D

update([E, ]**F) → None.  Update D from mapping/iterable E and F.

If E present and has a .keys() method, does: for k in E: D[k] = E[k] If E present and lacks .keys() method, does: for (k, v) in E: D[k] = v In either case, this is followed by: for k, v in F.items(): D[k] = v

values() → an object providing a view on D's values

class scine_chemoton.steering_wheel.datastructures.LogicCoupling(value)

Signals how multiple selection are combined, helps to define this coupling in Heron.

AND = 'and'

OR = 'or'

class scine_chemoton.steering_wheel.datastructures.NetworkExpansionResult(reactions=<factory>, compounds=<factory>, flasks=<factory>, structures=<factory>)

The result of a network expansion step. It holds different list of database IDs, that were created / modified by the network expansion.

compounds: List[ID]

flasks: List[ID]

classmethod from_split_results(split_results)

reactions: List[ID]

classmethod receive_from_pipe(pipe)

Return type:

Any

send_in_pipe(pipe)

Return type:

None

structures: List[ID]

to_split_results()

Return type:

List[Any]

class scine_chemoton.steering_wheel.datastructures.NoRestartInfoPresent

class scine_chemoton.steering_wheel.datastructures.ProtocolEntry(credentials, gear, fork=True, n_runs=0, wait_for_calculation_finish=False)

A container for executions carried out by a network expansion. This holds the combined information about a gear, the database and how the gear should be executed.

Raises:

RuntimeError

If the specified execution behavior (forking and number of runs) does not make sense.

Notes

The default execution mode, if only credentials and a gear are given, is forking the gear and running it indefinitely.

credentials: Credentials

engine: Engine

fork: bool = True

gear: Gear

is_running()

Return type:

bool

limited_runs: bool

n_runs: int = 0

name: str

run()

Run the gear in the specified mode. Due to better flexibility, this class only holds the information about the number of runs, and this method still executes the gear only once.

Return type:

None

stop()

Return type:

None

terminate()

Return type:

None

wait_for_calculation_finish: bool = False

was_stopped: bool

class scine_chemoton.steering_wheel.datastructures.RestartPartialExpansionInfo(protocol_step_index, start_id, start_time)

n_already_executed_protocol_steps: int

protocol_step_index: int

start_id: Optional[ID]

start_time: datetime

class scine_chemoton.steering_wheel.datastructures.SelectionResult(aggregate_filter=<scine_chemoton.filters.aggregate_filters.AggregateFilter object>, reactive_site_filter=<scine_chemoton.filters.reactive_site_filters.ReactiveSiteFilter object>, further_exploration_filter=<scine_chemoton.filters.further_exploration_filters.FurtherExplorationFilter object>, structures=<factory>)

The result of a selection step. It holds varies filters to be taken over by the next step and / or individual structure IDs.

aggregate_filter: AggregateFilter = <scine_chemoton.filters.aggregate_filters.AggregateFilter object>

classmethod from_split_results(split_results)

further_exploration_filter: FurtherExplorationFilter = <scine_chemoton.filters.further_exploration_filters.FurtherExplorationFilter object>

reactive_site_filter: ReactiveSiteFilter = <scine_chemoton.filters.reactive_site_filters.ReactiveSiteFilter object>

classmethod receive_from_pipe(pipe)

Return type:

Any

send_in_pipe(pipe)

Return type:

None

structures: List[ID]

to_split_results()

Return type:

List[Tuple[Optional[AggregateFilter], Optional[ReactiveSiteFilter], Optional[FurtherExplorationFilter], List[ID]]]

class scine_chemoton.steering_wheel.datastructures.Status(value)

Member of each Exploration step to indicate the current status of the step.

CALCULATING = 'calculating'

FAILED = 'failed'

FINISHED = 'finished'

INTERACTION_REQUIRED = 'interaction required'

STALLING = 'stalling'

STOPPING = 'stopping'

WAITING = 'waiting'

class scine_chemoton.steering_wheel.datastructures.StopPreviousProtocolEntries

An instance can be put into a protocol of a Network Expansion to signal that all previous protocol entries should be stopped and waited for

stop()

Dummy method

class scine_chemoton.steering_wheel.datastructures.StopSplitCommunicationMethod

Signals in a Connection that a split-up communication is finished

class scine_chemoton.steering_wheel.datastructures.StructureInformation(geometry, charge, multiplicity)

Container to hold a chemical system with fully specified potential energy surface information. Common API to be generated by implementations of InputSelections, so that basic input behavior is deduplicated and specified in base class.

charge: int

geometry: Union[AtomCollection, PeriodicSystem]

multiplicity: int

Interfaces

class scine_chemoton.steering_wheel.SteeringWheel(credentials, exploration_scheme, global_selection=None, global_for_first_selection=False, restart_file=None, callable_input=<built-in function input>)

The class managing and executing an exploration protocol that allows an active steering of the exploration in a reproducible manner. The exploration scheme steps can already be given upon initialization or added afterwards with +=. Each addition is sanity checked by the class and might be altered based on that. In some cases the class will ask for user input via the provided callback

Initialize the steering wheel to a database with the given credentials and an exploration scheme. The exploration scheme can still be empty and added later with +=.

Parameters:

credentialsdb.Credentials

The credentials to connect to the database

exploration_schemeList[ExplorationSchemeStep]

The exploration scheme to be executed, will be sanity checked already

global_selectionOptional[Selection], optional

A selection to be applied on top of all selections in the scheme, by default None

global_for_first_selectionbool, optional

If the global selection should be applied to the first selection as well, by default False

restart_fileOptional[str], optional

The restart file, by default None

callable_inputCallable, optional

The function the steering wheel relies on to get user feedback, by default input

clear_cache()

Return type:

None

delete_results()

Delete all results. Also updates the holding steps and resets their statusD

Return type:

None

get_partial_restart_info()

Return type:

Optional[RestartPartialExpansionInfo]

get_results()

The results of the exploration protocol. This will also update the results of the holding exploration steps.

Return type:

Optional[List[ExplorationResult]]

Returns:

Optional[List[ExplorationResult]]

The results of the exploration protocol, None if no results are available.

get_status_report()

Update the status of the currently holding steps and return a status report. The report contains the step names prepended with their index (to ensure unique keys) and the values are the status of the step.

Return type:

Dict[str, Status]

Returns:

Dict[str, Status]

The status report.

is_running()

Whether we are currently running an exploration.

Return type:

bool

join()

Joins the exploring subprocess.

property name: str

pop(index, ignore_results=False)

Method to remove an exploration step from the scheme by indexing. Negative indices are supported, but slicing is not.

Return type:

ExplorationSchemeStep

Parameters:

indexint

The index of the step to be removed.

ignore_resultsbool, optional

If the results should be ignored, by default False

Returns:

ExplorationSchemeStep

The removed step.

Raises:

IndexError

The given index is out of range.

RuntimeError

The given index has already been explored and the results are not ignored.

remove_global_selection(to_remove)

Allows to remove a selection that has been added to all selections.

Return type:

None

Parameters:

to_removeSelection

The selection to be removed.

Notes

This will remove the given selection from all AndSelections in the scheme independently if the given selection was added as a global one or just regularly.

property restart_file: str

run(allow_restart=None, additional_steps=None, add_global_selection=False, ask_for_how_many_results=False)

Start the exploration protocol. Additional steps or selections can be added just before starting.

Return type:

None

Parameters:

allow_restartOptional[bool], optional

If the protocol may be restarted if a restart state exists, if None the input function defined upon initialization is used to ask if a restart state exists, by default None

additional_stepsOptional[List[ExplorationSchemeStep]], optional

The additional steps to be added before the run. They are sanity checked before the run, by default None

add_global_selectionbool, optional

Whether the existing global selection should be added to the additional steps, by default False

ask_for_how_many_resultsbool, optional

If the wheel should ask the user how many results it should take over from the restart if a restart state exists, by default False

Raises:

RuntimeError

The exploration protocol is already running.

save()

Save the current exploration progress.

set_global_selection(global_selection, global_for_first_selection=False)

Allows to add a global selection to the exploration protocol.

Return type:

None

Parameters:

global_selectionSelection

The global selection to be added.

global_for_first_selectionbool, optional

If the selection should be added to the first selection as well, by default False

Notes

This will stop a running protocol and restart it with the new global selection.

set_partial_restart_info(restart_info)

Return type:

None

start(allow_restart=None, additional_steps=None, add_global_selection=False, ask_for_how_many_results=False)

Start the exploration protocol. Additional steps or selections can be added just before starting.

Return type:

None

Parameters:

allow_restartOptional[bool], optional

If the protocol may be restarted if a restart state exists, if None the input function defined upon initialization is used to ask if a restart state exists, by default None

additional_stepsOptional[List[ExplorationSchemeStep]], optional

The additional steps to be added before the run. They are sanity checked before the run, by default None

add_global_selectionbool, optional

Whether the existing global selection should be added to the additional steps, by default False

ask_for_how_many_resultsbool, optional

If the wheel should ask the user how many results it should take over from the restart if a restart state exists, by default False

Raises:

RuntimeError

The exploration protocol is already running.

stop(save_progress=True)

If the protocol is running, stop it and save the progress depending on the input.

Parameters:

save_progressbool, optional

If the results should be saved to file, by default True

terminate(try_save_progress=True, suppress_warning=False)

Immediately terminate the exploring subprocess and don’t wait for the current step to finish.

Return type:

None

Parameters:

try_save_progressbool, optional

Whether we should still try to save the current state, by default True

suppress_warningbool, optional

Whether we should suppress the warning if the wheel was not running, by default False

class scine_chemoton.steering_wheel.selections.Selection(model, additional_aggregate_filters=None, additional_reactive_site_filters=None, logic_coupling=LogicCoupling.AND, *args, **kwargs)

The base class for selecting aggregates, individual structures, and/or reactive sites. It specifies the common __call__ execution and holds 1 abstract methods that must be implemented by each implementation. Additionally, it holds some common functionalities for querying to simplify future implementation of new selections.

Initialize the selection with the given parameters.

Parameters:

modeldb.Model

The model to use for the selection.

additional_aggregate_filtersOptional[List[AggregateFilter]], optional

An optional list of aggregate filters to further limit selection. They are combined by an ‘and’ logic step. By default, None.

additional_reactive_site_filtersOptional[List[ReactiveSiteFilter]], optional

An optional list of reactive site filters to further limit selection. They are combined by an ‘and’ logic step. By default, None

logic_couplingUnion[str, LogicCoupling], optional

Define how this selection may be coupled together with other selections, by default LogicCoupling.AND

class Options(model, *args, **kwargs)

Options for the exploration scheme step.

Construct it with a given model

Parameters:

modeldb.Model

The model given to all subclasses.

unset_collections()

Duplicate name to HoldCollections method to be triggered in pickling process, so infinite _parent loops are avoided.

Return type:

None

get_result()

Return type:

Optional[SelectionResult]

get_step_result()

Get the result of the previous expansion step.

Return type:

NetworkExpansionResult

Returns:

NetworkExpansionResult

The result of the previous expansion step.

Raises:

RuntimeError

If the selection did not receive a previous step result.

initialize_collections(manager)

Return type:

None

lowest_barrier_per_reaction(step_result, energy_type)

Convenience method to get the lowest barrier for each reaction in the given step result.

Return type:

List[Optional[float]]

Parameters:

step_resultNetworkExpansionResult

The step result to get the lowest barrier for.

energy_typestr

The energy type to use for the barrier lookup.

Returns:

List[Optional[float]]

A list of the lowest barrier for each reaction in the given step result.

property name: str

options: Options

static possible_attributes()

Return type:

List[str]

set_result(result)

set_step_result(step_result)

Return type:

None

unset_collections()

Return type:

None

class scine_chemoton.steering_wheel.selections.SelectionAndArray(selections, *args, **kwargs)

Combines multiple selections with a logical AND.

Initialize the selection with the given parameters.

Parameters:

modeldb.Model

The model to use for the selection.

additional_aggregate_filtersOptional[List[AggregateFilter]], optional

An optional list of aggregate filters to further limit selection. They are combined by an ‘and’ logic step. By default, None.

additional_reactive_site_filtersOptional[List[ReactiveSiteFilter]], optional

An optional list of reactive site filters to further limit selection. They are combined by an ‘and’ logic step. By default, None

logic_couplingUnion[str, LogicCoupling], optional

Define how this selection may be coupled together with other selections, by default LogicCoupling.AND

class Options(model, *args, **kwargs)

Options for the exploration scheme step.

Construct it with a given model

Parameters:

modeldb.Model

The model given to all subclasses.

unset_collections()

Duplicate name to HoldCollections method to be triggered in pickling process, so infinite _parent loops are avoided.

Return type:

None

get_result()

Return type:

Optional[SelectionResult]

get_step_result()

Get the result of the previous expansion step.

Return type:

NetworkExpansionResult

Returns:

NetworkExpansionResult

The result of the previous expansion step.

Raises:

RuntimeError

If the selection did not receive a previous step result.

initialize_collections(manager)

Return type:

None

lowest_barrier_per_reaction(step_result, energy_type)

Convenience method to get the lowest barrier for each reaction in the given step result.

Return type:

List[Optional[float]]

Parameters:

step_resultNetworkExpansionResult

The step result to get the lowest barrier for.

energy_typestr

The energy type to use for the barrier lookup.

Returns:

List[Optional[float]]

A list of the lowest barrier for each reaction in the given step result.

property name: str

options: Options

static possible_attributes()

Return type:

List[str]

set_result(result)

set_step_result(step_result)

Return type:

None

unset_collections()

Return type:

None

class scine_chemoton.steering_wheel.selections.SelectionOrArray(selections, *args, **kwargs)

Combines multiple selections with a logical OR.

Initialize the selection with the given parameters.

Parameters:

modeldb.Model

The model to use for the selection.

additional_aggregate_filtersOptional[List[AggregateFilter]], optional

An optional list of aggregate filters to further limit selection. They are combined by an ‘and’ logic step. By default, None.

additional_reactive_site_filtersOptional[List[ReactiveSiteFilter]], optional

An optional list of reactive site filters to further limit selection. They are combined by an ‘and’ logic step. By default, None

logic_couplingUnion[str, LogicCoupling], optional

Define how this selection may be coupled together with other selections, by default LogicCoupling.AND

class Options(model, *args, **kwargs)

Options for the exploration scheme step.

Construct it with a given model

Parameters:

modeldb.Model

The model given to all subclasses.

unset_collections()

Duplicate name to HoldCollections method to be triggered in pickling process, so infinite _parent loops are avoided.

Return type:

None

get_result()

Return type:

Optional[SelectionResult]

get_step_result()

Get the result of the previous expansion step.

Return type:

NetworkExpansionResult

Returns:

NetworkExpansionResult

The result of the previous expansion step.

Raises:

RuntimeError

If the selection did not receive a previous step result.

initialize_collections(manager)

Return type:

None

lowest_barrier_per_reaction(step_result, energy_type)

Convenience method to get the lowest barrier for each reaction in the given step result.

Return type:

List[Optional[float]]

Parameters:

step_resultNetworkExpansionResult

The step result to get the lowest barrier for.

energy_typestr

The energy type to use for the barrier lookup.

Returns:

List[Optional[float]]

A list of the lowest barrier for each reaction in the given step result.

property name: str

options: Options

static possible_attributes()

Return type:

List[str]

set_result(result)

set_step_result(step_result)

Return type:

None

unset_collections()

Return type:

None

class scine_chemoton.steering_wheel.network_expansions.NetworkExpansion(model, gear_options=None, status_cycle_time=1.0, include_thermochemistry=False, general_settings=None, *args, **kwargs)

The base class for operations to expand the network with new information. It specifies the common __call__ execution and holds 3 abstract methods that must be implemented by each implementation. Additionally, it holds some common functionalities for execution and querying to simplify future implementations of new expansions.

Generate a new network expansion with the most important options. Any detailed options can still be specified on gear-level in GearOptions.

Parameters:

modeldb.Model

The model of the network expansion.

status_cycle_timefloat, optional

How often the status of the individual gears and subsequently the own status should be updated. Small expansions on small networks benefit from shorter times, while the querying on larger database may become expensive and short expansion can cause race condition problems with the gears, hence longer times are safer, by default 1.0 (very short).

include_thermochemistrybool, optional

If thermochemistry calculations (require Hessian calculations) should be added, by default False

general_settingsOptional[Dict[str, Any]], optional

Settings to be added to each separate job (beside graph job), because this only accepts special options and is at time of writing not created anymore, because the graph is generated within the bond orders job, which also accepts calculator specific settings. Due to being added to many jobs, we recommend only calculator settings, such as ‘max_scf_iterations’, by default None.

add_default_chemoton_nt_settingsbool, optional

Whether the default react job setting of Chemoton should be added to all react jobs, by default False.

class Options(model, status_cycle_time, include_thermochemistry, gear_options, general_settings, *args, **kwargs)

Construct it with a given model

Parameters:

modeldb.Model

The model given to all subclasses.

unset_collections()

Duplicate name to HoldCollections method to be triggered in pickling process, so infinite _parent loops are avoided.

Return type:

None

current_gears()

The gears currently in the protocol. Allows ProtocolEntry agnostic access.

Return type:

List[Gear]

Returns:

List[Gear]

List of gears.

dry_setup_protocol(credentials, selection=None, n_already_executed_protocol_steps=0)

Sets up the protocol (individual gears) as currently specified in the options without running anything. This is useful to get some preemptive information about the gears to be run.

Return type:

None

Parameters:

credentialsdb.Credentials

The credentials of the database to connect to. Only used for retrieving collections, not manipulation.

selectionOptional[SelectionResult], optional

A selection to be given to the expansion, can manipulate the individual gears, by default None.

Notes

Protocol should be cleared afterward if the step is not immediately executed to avoid problems with multithreaded / multiprocessed code due to presence of potentially forked objects in the protocol.

get_result()

Return type:

Optional[NetworkExpansionResult]

initialize_collections(manager)

Return type:

None

property name: str

options: Options

static possible_attributes()

Return type:

List[str]

set_result(result)

Return type:

None

thermochemistry_gear

alias of BasicThermoDataCompletion

unset_collections()

Return type:

None

Implementations

Selections

class scine_chemoton.steering_wheel.selections.input_selections.FileInputSelection(model, structure_information_input, label_of_structure='user_guess', additional_aggregate_filters=None, additional_reactive_site_filters=None, logic_coupling=LogicCoupling.AND, *args, **kwargs)

Adds new structures with files

Base class of all Selections that enter new structures into the database

Parameters:

model: db.Model

The model

structure_information_input: list_or_single_valid_input_type

Specify a single valid input (dependent on implemented subclass, or a list of these inputs

additional_aggregate_filters: Optional[List[AggregateFilter]]

additional_reactive_site_filters: Optional[List[ReactiveSiteFilter]]

class Options(model, *args, **kwargs)

Options for the exploration scheme step.

Construct it with a given model

Parameters:

modeldb.Model

The model given to all subclasses.

unset_collections()

Duplicate name to HoldCollections method to be triggered in pickling process, so infinite _parent loops are avoided.

Return type:

None

get_result()

Return type:

Optional[SelectionResult]

get_step_result()

Ensures that the step_result member is not accessed.

Return type:

NetworkExpansionResult

initialize_collections(manager)

Return type:

None

list_valid_input_type

alias of List[Tuple[str, int, int, str]]

lowest_barrier_per_reaction(step_result, energy_type)

Convenience method to get the lowest barrier for each reaction in the given step result.

Return type:

List[Optional[float]]

Parameters:

step_resultNetworkExpansionResult

The step result to get the lowest barrier for.

energy_typestr

The energy type to use for the barrier lookup.

Returns:

List[Optional[float]]

A list of the lowest barrier for each reaction in the given step result.

property name: str

options: Selection.Options

static possible_attributes()

Return type:

List[str]

set_result(result)

set_step_result(step_result)

Return type:

None

unset_collections()

Return type:

None

valid_input_type

alias of Tuple[str, int, int, str]

class scine_chemoton.steering_wheel.selections.input_selections.InputSelection(model, structure_information_input, label_of_structure='user_guess', additional_aggregate_filters=None, additional_reactive_site_filters=None, logic_coupling=LogicCoupling.AND, *args, **kwargs)

Abstract selection for any selection that adds new structures to the database

Base class of all Selections that enter new structures into the database

Parameters:

model: db.Model

The model

structure_information_input: list_or_single_valid_input_type

Specify a single valid input (dependent on implemented subclass, or a list of these inputs

additional_aggregate_filters: Optional[List[AggregateFilter]]

additional_reactive_site_filters: Optional[List[ReactiveSiteFilter]]

class Options(model, *args, **kwargs)

Options for the exploration scheme step.

Construct it with a given model

Parameters:

modeldb.Model

The model given to all subclasses.

unset_collections()

Duplicate name to HoldCollections method to be triggered in pickling process, so infinite _parent loops are avoided.

Return type:

None

get_result()

Return type:

Optional[SelectionResult]

get_step_result()

Ensures that the step_result member is not accessed.

Return type:

NetworkExpansionResult

initialize_collections(manager)

Return type:

None

list_valid_input_type

alias of List[Any]

lowest_barrier_per_reaction(step_result, energy_type)

Convenience method to get the lowest barrier for each reaction in the given step result.

Return type:

List[Optional[float]]

Parameters:

step_resultNetworkExpansionResult

The step result to get the lowest barrier for.

energy_typestr

The energy type to use for the barrier lookup.

Returns:

List[Optional[float]]

A list of the lowest barrier for each reaction in the given step result.

property name: str

options: Selection.Options

static possible_attributes()

Return type:

List[str]

set_result(result)

set_step_result(step_result)

Return type:

None

unset_collections()

Return type:

None

valid_input_type: TypeAlias = typing.Any

class scine_chemoton.steering_wheel.selections.input_selections.ScineGeometryInputSelection(model, structure_information_input, label_of_structure='user_guess', additional_aggregate_filters=None, additional_reactive_site_filters=None, logic_coupling=LogicCoupling.AND, *args, **kwargs)

Add new structures with a Scine Calculator

Base class of all Selections that enter new structures into the database

Parameters:

model: db.Model

The model

structure_information_input: list_or_single_valid_input_type

Specify a single valid input (dependent on implemented subclass, or a list of these inputs

additional_aggregate_filters: Optional[List[AggregateFilter]]

additional_reactive_site_filters: Optional[List[ReactiveSiteFilter]]

class Options(model, *args, **kwargs)

Options for the exploration scheme step.

Construct it with a given model

Parameters:

modeldb.Model

The model given to all subclasses.

unset_collections()

Duplicate name to HoldCollections method to be triggered in pickling process, so infinite _parent loops are avoided.

Return type:

None

get_result()

Return type:

Optional[SelectionResult]

get_step_result()

Ensures that the step_result member is not accessed.

Return type:

NetworkExpansionResult

initialize_collections(manager)

Return type:

None

list_valid_input_type

alias of List[Union[Calculator, Tuple[Union[AtomCollection, PeriodicSystem], int, int]]]

lowest_barrier_per_reaction(step_result, energy_type)

Convenience method to get the lowest barrier for each reaction in the given step result.

Return type:

List[Optional[float]]

Parameters:

step_resultNetworkExpansionResult

The step result to get the lowest barrier for.

energy_typestr

The energy type to use for the barrier lookup.

Returns:

List[Optional[float]]

A list of the lowest barrier for each reaction in the given step result.

property name: str

options: Selection.Options

static possible_attributes()

Return type:

List[str]

set_result(result)

set_step_result(step_result)

Return type:

None

unset_collections()

Return type:

None

valid_input_type

alias of Union[Calculator, Tuple[Union[AtomCollection, PeriodicSystem], int, int]]

class scine_chemoton.steering_wheel.selections.basics.AllFromPreviousResultSelection(model, additional_aggregate_filters=None, additional_reactive_site_filters=None, logic_coupling=LogicCoupling.AND, *args, **kwargs)

Selects all aggregates and structures from the previous step result.

Initialize the selection with the given parameters.

Parameters:

modeldb.Model

The model to use for the selection.

additional_aggregate_filtersOptional[List[AggregateFilter]], optional

An optional list of aggregate filters to further limit selection. They are combined by an ‘and’ logic step. By default, None.

additional_reactive_site_filtersOptional[List[ReactiveSiteFilter]], optional

An optional list of reactive site filters to further limit selection. They are combined by an ‘and’ logic step. By default, None

logic_couplingUnion[str, LogicCoupling], optional

Define how this selection may be coupled together with other selections, by default LogicCoupling.AND

class Options(model, *args, **kwargs)

Options for the exploration scheme step.

Construct it with a given model

Parameters:

modeldb.Model

The model given to all subclasses.

unset_collections()

Duplicate name to HoldCollections method to be triggered in pickling process, so infinite _parent loops are avoided.

Return type:

None

get_result()

Return type:

Optional[SelectionResult]

get_step_result()

Get the result of the previous expansion step.

Return type:

NetworkExpansionResult

Returns:

NetworkExpansionResult

The result of the previous expansion step.

Raises:

RuntimeError

If the selection did not receive a previous step result.

initialize_collections(manager)

Return type:

None

lowest_barrier_per_reaction(step_result, energy_type)

Convenience method to get the lowest barrier for each reaction in the given step result.

Return type:

List[Optional[float]]

Parameters:

step_resultNetworkExpansionResult

The step result to get the lowest barrier for.

energy_typestr

The energy type to use for the barrier lookup.

Returns:

List[Optional[float]]

A list of the lowest barrier for each reaction in the given step result.

property name: str

options: AllFromPreviousResultSelection.Options

static possible_attributes()

Return type:

List[str]

set_result(result)

set_step_result(step_result)

Return type:

None

unset_collections()

Return type:

None

class scine_chemoton.steering_wheel.selections.basics.AllUserInputsSelection(model, additional_aggregate_filters=None, additional_reactive_site_filters=None, logic_coupling=LogicCoupling.AND, *args, **kwargs)

Selects all aggregates and structures that are user inputs.

Initialize the selection with the given parameters.

Parameters:

modeldb.Model

The model to use for the selection.

additional_aggregate_filtersOptional[List[AggregateFilter]], optional

An optional list of aggregate filters to further limit selection. They are combined by an ‘and’ logic step. By default, None.

additional_reactive_site_filtersOptional[List[ReactiveSiteFilter]], optional

An optional list of reactive site filters to further limit selection. They are combined by an ‘and’ logic step. By default, None

logic_couplingUnion[str, LogicCoupling], optional

Define how this selection may be coupled together with other selections, by default LogicCoupling.AND

class Options(model, *args, **kwargs)

Options for the exploration scheme step.

Construct it with a given model

Parameters:

modeldb.Model

The model given to all subclasses.

unset_collections()

Duplicate name to HoldCollections method to be triggered in pickling process, so infinite _parent loops are avoided.

Return type:

None

get_result()

Return type:

Optional[SelectionResult]

get_step_result()

Ensures that the step_result member is not accessed.

Return type:

NetworkExpansionResult

initialize_collections(manager)

Return type:

None

lowest_barrier_per_reaction(step_result, energy_type)

Convenience method to get the lowest barrier for each reaction in the given step result.

Return type:

List[Optional[float]]

Parameters:

step_resultNetworkExpansionResult

The step result to get the lowest barrier for.

energy_typestr

The energy type to use for the barrier lookup.

Returns:

List[Optional[float]]

A list of the lowest barrier for each reaction in the given step result.

property name: str

options: AllUserInputsSelection.Options

static possible_attributes()

Return type:

List[str]

set_result(result)

set_step_result(step_result)

Return type:

None

unset_collections()

Return type:

None

class scine_chemoton.steering_wheel.selections.basics.BarriersWithinRangeSelection(model, max_barrier, include_thermochemistry=False, additional_aggregate_filters=None, additional_reactive_site_filters=None, logic_coupling=LogicCoupling.AND, *args, **kwargs)

Selects all aggregates and structures that are products of the reactions in the previous step result and have a barrier lower than the given maximum barrier.

Initialize the selection with the given parameters.

Parameters:

modeldb.Model

The model to use for the selection.

additional_aggregate_filtersOptional[List[AggregateFilter]], optional

An optional list of aggregate filters to further limit selection. They are combined by an ‘and’ logic step. By default, None.

additional_reactive_site_filtersOptional[List[ReactiveSiteFilter]], optional

An optional list of reactive site filters to further limit selection. They are combined by an ‘and’ logic step. By default, None

logic_couplingUnion[str, LogicCoupling], optional

Define how this selection may be coupled together with other selections, by default LogicCoupling.AND

class Options(model, *args, **kwargs)

Options for the exploration scheme step.

Construct it with a given model

Parameters:

modeldb.Model

The model given to all subclasses.

unset_collections()

Duplicate name to HoldCollections method to be triggered in pickling process, so infinite _parent loops are avoided.

Return type:

None

get_result()

Return type:

Optional[SelectionResult]

get_step_result()

Get the result of the previous expansion step.

Return type:

NetworkExpansionResult

Returns:

NetworkExpansionResult

The result of the previous expansion step.

Raises:

RuntimeError

If the selection did not receive a previous step result.

initialize_collections(manager)

Return type:

None

lowest_barrier_per_reaction(step_result, energy_type)

Convenience method to get the lowest barrier for each reaction in the given step result.

Return type:

List[Optional[float]]

Parameters:

step_resultNetworkExpansionResult

The step result to get the lowest barrier for.

energy_typestr

The energy type to use for the barrier lookup.

Returns:

List[Optional[float]]

A list of the lowest barrier for each reaction in the given step result.

property name: str

options: BarriersWithinRangeSelection.Options

static possible_attributes()

Return type:

List[str]

set_result(result)

set_step_result(step_result)

Return type:

None

unset_collections()

Return type:

None

class scine_chemoton.steering_wheel.selections.basics.LowestBarrierSelection(model, n_lowest, include_thermochemistry=False, additional_aggregate_filters=None, additional_reactive_site_filters=None, logic_coupling=LogicCoupling.AND, *args, **kwargs)

Selects the n lowest barrier aggregates and structures from the previous step result.

Initialize the selection with the given parameters.

Parameters:

modeldb.Model

The model to use for the selection.

additional_aggregate_filtersOptional[List[AggregateFilter]], optional

An optional list of aggregate filters to further limit selection. They are combined by an ‘and’ logic step. By default, None.

additional_reactive_site_filtersOptional[List[ReactiveSiteFilter]], optional

An optional list of reactive site filters to further limit selection. They are combined by an ‘and’ logic step. By default, None

logic_couplingUnion[str, LogicCoupling], optional

Define how this selection may be coupled together with other selections, by default LogicCoupling.AND

class Options(model, *args, **kwargs)

Options for the exploration scheme step.

Construct it with a given model

Parameters:

modeldb.Model

The model given to all subclasses.

unset_collections()

Duplicate name to HoldCollections method to be triggered in pickling process, so infinite _parent loops are avoided.

Return type:

None

get_result()

Return type:

Optional[SelectionResult]

get_step_result()

Get the result of the previous expansion step.

Return type:

NetworkExpansionResult

Returns:

NetworkExpansionResult

The result of the previous expansion step.

Raises:

RuntimeError

If the selection did not receive a previous step result.

initialize_collections(manager)

Return type:

None

lowest_barrier_per_reaction(step_result, energy_type)

Convenience method to get the lowest barrier for each reaction in the given step result.

Return type:

List[Optional[float]]

Parameters:

step_resultNetworkExpansionResult

The step result to get the lowest barrier for.

energy_typestr

The energy type to use for the barrier lookup.

Returns:

List[Optional[float]]

A list of the lowest barrier for each reaction in the given step result.

property name: str

options: LowestBarrierSelection.Options

static possible_attributes()

Return type:

List[str]

set_result(result)

set_step_result(step_result)

Return type:

None

unset_collections()

Return type:

None

class scine_chemoton.steering_wheel.selections.basics.ProductsSelection(model, additional_aggregate_filters=None, additional_reactive_site_filters=None, logic_coupling=LogicCoupling.AND, *args, **kwargs)

Selects all aggregates and structures that are products of the reactions in the previous step result.

Initialize the selection with the given parameters.

Parameters:

modeldb.Model

The model to use for the selection.

additional_aggregate_filtersOptional[List[AggregateFilter]], optional

An optional list of aggregate filters to further limit selection. They are combined by an ‘and’ logic step. By default, None.

additional_reactive_site_filtersOptional[List[ReactiveSiteFilter]], optional

An optional list of reactive site filters to further limit selection. They are combined by an ‘and’ logic step. By default, None

logic_couplingUnion[str, LogicCoupling], optional

Define how this selection may be coupled together with other selections, by default LogicCoupling.AND

class Options(model, *args, **kwargs)

Options for the exploration scheme step.

Construct it with a given model

Parameters:

modeldb.Model

The model given to all subclasses.

unset_collections()

Duplicate name to HoldCollections method to be triggered in pickling process, so infinite _parent loops are avoided.

Return type:

None

get_result()

Return type:

Optional[SelectionResult]

get_step_result()

Get the result of the previous expansion step.

Return type:

NetworkExpansionResult

Returns:

NetworkExpansionResult

The result of the previous expansion step.

Raises:

RuntimeError

If the selection did not receive a previous step result.

initialize_collections(manager)

Return type:

None

lowest_barrier_per_reaction(step_result, energy_type)

Convenience method to get the lowest barrier for each reaction in the given step result.

Return type:

List[Optional[float]]

Parameters:

step_resultNetworkExpansionResult

The step result to get the lowest barrier for.

energy_typestr

The energy type to use for the barrier lookup.

Returns:

List[Optional[float]]

A list of the lowest barrier for each reaction in the given step result.

property name: str

options: ProductsSelection.Options

static possible_attributes()

Return type:

List[str]

set_result(result)

set_step_result(step_result)

Return type:

None

unset_collections()

Return type:

None

class scine_chemoton.steering_wheel.selections.conformers.CentroidConformerSelection(model, additional_aggregate_filters=None, additional_reactive_site_filters=None, logic_coupling=LogicCoupling.AND, *args, **kwargs)

Simply selects the centroid of each aggregate, which is the first structure that was found for that aggregate.

Initialize the selection with the given parameters.

Parameters:

modeldb.Model

The model to use for the selection.

additional_aggregate_filtersOptional[List[AggregateFilter]], optional

An optional list of aggregate filters to further limit selection. They are combined by an ‘and’ logic step. By default, None.

additional_reactive_site_filtersOptional[List[ReactiveSiteFilter]], optional

An optional list of reactive site filters to further limit selection. They are combined by an ‘and’ logic step. By default, None

logic_couplingUnion[str, LogicCoupling], optional

Define how this selection may be coupled together with other selections, by default LogicCoupling.AND

class Options(model, *args, **kwargs)

Construct it with a given model

Parameters:

modeldb.Model

The model given to all subclasses.

unset_collections()

Duplicate name to HoldCollections method to be triggered in pickling process, so infinite _parent loops are avoided.

Return type:

None

get_result()

Return type:

Optional[SelectionResult]

get_step_result()

Get the result of the previous expansion step.

Return type:

NetworkExpansionResult

Returns:

NetworkExpansionResult

The result of the previous expansion step.

Raises:

RuntimeError

If the selection did not receive a previous step result.

initialize_collections(manager)

Return type:

None

lowest_barrier_per_reaction(step_result, energy_type)

Convenience method to get the lowest barrier for each reaction in the given step result.

Return type:

List[Optional[float]]

Parameters:

step_resultNetworkExpansionResult

The step result to get the lowest barrier for.

energy_typestr

The energy type to use for the barrier lookup.

Returns:

List[Optional[float]]

A list of the lowest barrier for each reaction in the given step result.

property name: str

options: Options

static possible_attributes()

Return type:

List[str]

set_result(result)

set_step_result(step_result)

Return type:

None

unset_collections()

Return type:

None

class scine_chemoton.steering_wheel.selections.conformers.ClusterCentroidConformerSelection(model, additional_aggregate_filters=None, additional_reactive_site_filters=None, logic_coupling=LogicCoupling.AND, include_thermochemistry=False, n_clusters=None, cluster_rmsd_cutoff=None)

Initialize the selection with the given parameters.

Parameters:

modeldb.Model

The model to use for the selection.

additional_aggregate_filtersOptional[List[AggregateFilter]], optional

An optional list of aggregate filters to further limit selection. They are combined by an ‘and’ logic step. By default, None.

additional_reactive_site_filtersOptional[List[ReactiveSiteFilter]], optional

An optional list of reactive site filters to further limit selection. They are combined by an ‘and’ logic step. By default, None

logic_couplingUnion[str, LogicCoupling], optional

Define how this selection may be coupled together with other selections, by default LogicCoupling.AND

class Options(model, include_thermochemistry, n_clusters, cluster_rmsd_cutoff, *args, **kwargs)

Construct it with a given model

Parameters:

modeldb.Model

The model given to all subclasses.

unset_collections()

Duplicate name to HoldCollections method to be triggered in pickling process, so infinite _parent loops are avoided.

Return type:

None

get_result()

Return type:

Optional[SelectionResult]

get_step_result()

Get the result of the previous expansion step.

Return type:

NetworkExpansionResult

Returns:

NetworkExpansionResult

The result of the previous expansion step.

Raises:

RuntimeError

If the selection did not receive a previous step result.

initialize_collections(manager)

Return type:

None

lowest_barrier_per_reaction(step_result, energy_type)

Convenience method to get the lowest barrier for each reaction in the given step result.

Return type:

List[Optional[float]]

Parameters:

step_resultNetworkExpansionResult

The step result to get the lowest barrier for.

energy_typestr

The energy type to use for the barrier lookup.

Returns:

List[Optional[float]]

A list of the lowest barrier for each reaction in the given step result.

property name: str

options: Options

static possible_attributes()

Return type:

List[str]

set_result(result)

set_step_result(step_result)

Return type:

None

unset_collections()

Return type:

None

class scine_chemoton.steering_wheel.selections.conformers.ClusterSelection(model, additional_aggregate_filters=None, additional_reactive_site_filters=None, logic_coupling=LogicCoupling.AND, include_thermochemistry=False, n_clusters=None, cluster_rmsd_cutoff=None)

A base class for all conformer selections that rely on clustering. This class is not meant to be used directly, but rather as a base class for other conformer selections.

Initialize the selection with the given parameters.

Parameters:

modeldb.Model

The model to use for the selection.

additional_aggregate_filtersOptional[List[AggregateFilter]], optional

An optional list of aggregate filters to further limit selection. They are combined by an ‘and’ logic step. By default, None.

additional_reactive_site_filtersOptional[List[ReactiveSiteFilter]], optional

An optional list of reactive site filters to further limit selection. They are combined by an ‘and’ logic step. By default, None

logic_couplingUnion[str, LogicCoupling], optional

Define how this selection may be coupled together with other selections, by default LogicCoupling.AND

class Options(model, include_thermochemistry, n_clusters, cluster_rmsd_cutoff, *args, **kwargs)

Construct it with a given model

Parameters:

modeldb.Model

The model given to all subclasses.

unset_collections()

Duplicate name to HoldCollections method to be triggered in pickling process, so infinite _parent loops are avoided.

Return type:

None

get_result()

Return type:

Optional[SelectionResult]

get_step_result()

Get the result of the previous expansion step.

Return type:

NetworkExpansionResult

Returns:

NetworkExpansionResult

The result of the previous expansion step.

Raises:

RuntimeError

If the selection did not receive a previous step result.

initialize_collections(manager)

Return type:

None

lowest_barrier_per_reaction(step_result, energy_type)

Convenience method to get the lowest barrier for each reaction in the given step result.

Return type:

List[Optional[float]]

Parameters:

step_resultNetworkExpansionResult

The step result to get the lowest barrier for.

energy_typestr

The energy type to use for the barrier lookup.

Returns:

List[Optional[float]]

A list of the lowest barrier for each reaction in the given step result.

property name: str

options: Options

static possible_attributes()

Return type:

List[str]

set_result(result)

set_step_result(step_result)

Return type:

None

unset_collections()

Return type:

None

class scine_chemoton.steering_wheel.selections.conformers.ConformerSelection(model, additional_aggregate_filters=None, additional_reactive_site_filters=None, logic_coupling=LogicCoupling.AND, *args, **kwargs)

The base class for all conformer selections. This class is not meant to be used directly, but rather as a base class for other conformer selections.

Initialize the selection with the given parameters.

Parameters:

modeldb.Model

The model to use for the selection.

additional_aggregate_filtersOptional[List[AggregateFilter]], optional

An optional list of aggregate filters to further limit selection. They are combined by an ‘and’ logic step. By default, None.

additional_reactive_site_filtersOptional[List[ReactiveSiteFilter]], optional

An optional list of reactive site filters to further limit selection. They are combined by an ‘and’ logic step. By default, None

logic_couplingUnion[str, LogicCoupling], optional

Define how this selection may be coupled together with other selections, by default LogicCoupling.AND

class Options(model, include_thermochemistry, *args, **kwargs)

Construct it with a given model

Parameters:

modeldb.Model

The model given to all subclasses.

unset_collections()

Duplicate name to HoldCollections method to be triggered in pickling process, so infinite _parent loops are avoided.

Return type:

None

get_result()

Return type:

Optional[SelectionResult]

get_step_result()

Get the result of the previous expansion step.

Return type:

NetworkExpansionResult

Returns:

NetworkExpansionResult

The result of the previous expansion step.

Raises:

RuntimeError

If the selection did not receive a previous step result.

initialize_collections(manager)

Return type:

None

lowest_barrier_per_reaction(step_result, energy_type)

Convenience method to get the lowest barrier for each reaction in the given step result.

Return type:

List[Optional[float]]

Parameters:

step_resultNetworkExpansionResult

The step result to get the lowest barrier for.

energy_typestr

The energy type to use for the barrier lookup.

Returns:

List[Optional[float]]

A list of the lowest barrier for each reaction in the given step result.

property name: str

options: Options

static possible_attributes()

Return type:

List[str]

set_result(result)

set_step_result(step_result)

Return type:

None

unset_collections()

Return type:

None

class scine_chemoton.steering_wheel.selections.conformers.LowestEnergyConformerPerClusterSelection(model, additional_aggregate_filters=None, additional_reactive_site_filters=None, logic_coupling=LogicCoupling.AND, include_thermochemistry=False, n_clusters=None, cluster_rmsd_cutoff=None)

Initialize the selection with the given parameters.

Parameters:

modeldb.Model

The model to use for the selection.

additional_aggregate_filtersOptional[List[AggregateFilter]], optional

An optional list of aggregate filters to further limit selection. They are combined by an ‘and’ logic step. By default, None.

additional_reactive_site_filtersOptional[List[ReactiveSiteFilter]], optional

An optional list of reactive site filters to further limit selection. They are combined by an ‘and’ logic step. By default, None

logic_couplingUnion[str, LogicCoupling], optional

Define how this selection may be coupled together with other selections, by default LogicCoupling.AND

class Options(model, include_thermochemistry, n_clusters, cluster_rmsd_cutoff, *args, **kwargs)

Construct it with a given model

Parameters:

modeldb.Model

The model given to all subclasses.

unset_collections()

Duplicate name to HoldCollections method to be triggered in pickling process, so infinite _parent loops are avoided.

Return type:

None

get_result()

Return type:

Optional[SelectionResult]

get_step_result()

Get the result of the previous expansion step.

Return type:

NetworkExpansionResult

Returns:

NetworkExpansionResult

The result of the previous expansion step.

Raises:

RuntimeError

If the selection did not receive a previous step result.

initialize_collections(manager)

Return type:

None

lowest_barrier_per_reaction(step_result, energy_type)

Convenience method to get the lowest barrier for each reaction in the given step result.

Return type:

List[Optional[float]]

Parameters:

step_resultNetworkExpansionResult

The step result to get the lowest barrier for.

energy_typestr

The energy type to use for the barrier lookup.

Returns:

List[Optional[float]]

A list of the lowest barrier for each reaction in the given step result.

property name: str

options: Options

static possible_attributes()

Return type:

List[str]

set_result(result)

set_step_result(step_result)

Return type:

None

unset_collections()

Return type:

None

class scine_chemoton.steering_wheel.selections.conformers.LowestEnergyConformerSelection(model, additional_aggregate_filters=None, additional_reactive_site_filters=None, logic_coupling=LogicCoupling.AND, include_thermochemistry=False, *args, **kwargs)

Selects the lowest energy conformer of each aggregate.

Initialize the selection with the given parameters.

Parameters:

modeldb.Model

The model to use for the selection.

additional_aggregate_filtersOptional[List[AggregateFilter]], optional

An optional list of aggregate filters to further limit selection. They are combined by an ‘and’ logic step. By default, None.

additional_reactive_site_filtersOptional[List[ReactiveSiteFilter]], optional

An optional list of reactive site filters to further limit selection. They are combined by an ‘and’ logic step. By default, None

logic_couplingUnion[str, LogicCoupling], optional

Define how this selection may be coupled together with other selections, by default LogicCoupling.AND

class Options(model, include_thermochemistry, *args, **kwargs)

Construct it with a given model

Parameters:

modeldb.Model

The model given to all subclasses.

unset_collections()

Duplicate name to HoldCollections method to be triggered in pickling process, so infinite _parent loops are avoided.

Return type:

None

get_result()

Return type:

Optional[SelectionResult]

get_step_result()

Get the result of the previous expansion step.

Return type:

NetworkExpansionResult

Returns:

NetworkExpansionResult

The result of the previous expansion step.

Raises:

RuntimeError

If the selection did not receive a previous step result.

initialize_collections(manager)

Return type:

None

lowest_barrier_per_reaction(step_result, energy_type)

Convenience method to get the lowest barrier for each reaction in the given step result.

Return type:

List[Optional[float]]

Parameters:

step_resultNetworkExpansionResult

The step result to get the lowest barrier for.

energy_typestr

The energy type to use for the barrier lookup.

Returns:

List[Optional[float]]

A list of the lowest barrier for each reaction in the given step result.

property name: str

options: Options

static possible_attributes()

Return type:

List[str]

set_result(result)

set_step_result(step_result)

Return type:

None

unset_collections()

Return type:

None

class scine_chemoton.steering_wheel.selections.organometallic_complexes.CentralMetalSelection(model, central_metal_species, ligand_without_metal_reactive, additional_catalyst_elements=None, additional_aggregate_filters=None, additional_reactive_site_filters=None, logic_coupling=LogicCoupling.AND, *args, **kwargs)

Initialize the selection with the given parameters.

Parameters:

modeldb.Model

The model to use for the selection.

additional_aggregate_filtersOptional[List[AggregateFilter]], optional

An optional list of aggregate filters to further limit selection. They are combined by an ‘and’ logic step. By default, None.

additional_reactive_site_filtersOptional[List[ReactiveSiteFilter]], optional

An optional list of reactive site filters to further limit selection. They are combined by an ‘and’ logic step. By default, None

logic_couplingUnion[str, LogicCoupling], optional

Define how this selection may be coupled together with other selections, by default LogicCoupling.AND

class Options(model, metal, ligand_without_metal_reactive, additional_catalyst_elements, *args, **kwargs)

Construct it with a given model

Parameters:

modeldb.Model

The model given to all subclasses.

additional_catalyst_elements: Optional[Dict[str, int]]

ligand_without_metal_reactive: bool

metal: str

unset_collections()

Duplicate name to HoldCollections method to be triggered in pickling process, so infinite _parent loops are avoided.

Return type:

None

get_result()

Return type:

Optional[SelectionResult]

get_step_result()

Ensures that the step_result member is not accessed.

Return type:

NetworkExpansionResult

initialize_collections(manager)

Return type:

None

lowest_barrier_per_reaction(step_result, energy_type)

Convenience method to get the lowest barrier for each reaction in the given step result.

Return type:

List[Optional[float]]

Parameters:

step_resultNetworkExpansionResult

The step result to get the lowest barrier for.

energy_typestr

The energy type to use for the barrier lookup.

Returns:

List[Optional[float]]

A list of the lowest barrier for each reaction in the given step result.

property name: str

options: CentralMetalSelection.Options

static possible_attributes()

Return type:

List[str]

set_result(result)

set_step_result(step_result)

Return type:

None

unset_collections()

Return type:

None

Network Expansions

class scine_chemoton.steering_wheel.network_expansions.basics.SimpleOptimization(model, gear_options=None, status_cycle_time=60.0, include_thermochemistry=False, general_settings=None, minimization_job='scine_geometry_optimization', *args, **kwargs)

Carries out a structure optimization and aggregation of the given individual structures. Hence, it must receive a selection result that holds individual structures

Generate a new network expansion with the most important options. Any detailed options can still be specified on gear-level in GearOptions.

Parameters:

modeldb.Model

The model of the network expansion.

status_cycle_timefloat, optional

How often the status of the individual gears and subsequently the own status should be updated. Small expansions on small networks benefit from shorter times, while the querying on larger database may become expensive and short expansion can cause race condition problems with the gears, hence longer times are safer, by default 1.0 (very short).

include_thermochemistrybool, optional

If thermochemistry calculations (require Hessian calculations) should be added, by default False

general_settingsOptional[Dict[str, Any]], optional

Settings to be added to each separate job (beside graph job), because this only accepts special options and is at time of writing not created anymore, because the graph is generated within the bond orders job, which also accepts calculator specific settings. Due to being added to many jobs, we recommend only calculator settings, such as ‘max_scf_iterations’, by default None.

add_default_chemoton_nt_settingsbool, optional

Whether the default react job setting of Chemoton should be added to all react jobs, by default False.

class Options(model, status_cycle_time, include_thermochemistry, gear_options, general_settings, minimization_job_order, *args, **kwargs)

Construct it with a given model

Parameters:

modeldb.Model

The model given to all subclasses.

unset_collections()

Duplicate name to HoldCollections method to be triggered in pickling process, so infinite _parent loops are avoided.

Return type:

None

current_gears()

The gears currently in the protocol. Allows ProtocolEntry agnostic access.

Return type:

List[Gear]

Returns:

List[Gear]

List of gears.

dry_setup_protocol(credentials, selection=None, n_already_executed_protocol_steps=0)

Sets up the protocol (individual gears) as currently specified in the options without running anything. This is useful to get some preemptive information about the gears to be run.

Return type:

None

Parameters:

credentialsdb.Credentials

The credentials of the database to connect to. Only used for retrieving collections, not manipulation.

selectionOptional[SelectionResult], optional

A selection to be given to the expansion, can manipulate the individual gears, by default None.

Notes

Protocol should be cleared afterward if the step is not immediately executed to avoid problems with multithreaded / multiprocessed code due to presence of potentially forked objects in the protocol.

get_result()

Return type:

Optional[NetworkExpansionResult]

hardcoded_gear_options: GearOptions

initialize_collections(manager)

Return type:

None

property name: str

options: SimpleOptimization.Options

static possible_attributes()

Return type:

List[str]

protocol: List[Union[ProtocolEntry, StopPreviousProtocolEntries]]

set_result(result)

Return type:

None

thermochemistry_gear

alias of BasicThermoDataCompletion

unset_collections()

Return type:

None

class scine_chemoton.steering_wheel.network_expansions.basics.ThermochemistryGeneration(model, gear_options=None, status_cycle_time=60.0, include_thermochemistry=False, general_settings=None, hessian_job='scine_hessian', *args, **kwargs)

Produces thermochemistry results for the given selection result. Can be used to add thermochemistry after the fact after exploring faster without it.

Generate a new network expansion with the most important options. Any detailed options can still be specified on gear-level in GearOptions.

Parameters:

modeldb.Model

The model of the network expansion.

status_cycle_timefloat, optional

How often the status of the individual gears and subsequently the own status should be updated. Small expansions on small networks benefit from shorter times, while the querying on larger database may become expensive and short expansion can cause race condition problems with the gears, hence longer times are safer, by default 1.0 (very short).

include_thermochemistrybool, optional

If thermochemistry calculations (require Hessian calculations) should be added, by default False

general_settingsOptional[Dict[str, Any]], optional

Settings to be added to each separate job (beside graph job), because this only accepts special options and is at time of writing not created anymore, because the graph is generated within the bond orders job, which also accepts calculator specific settings. Due to being added to many jobs, we recommend only calculator settings, such as ‘max_scf_iterations’, by default None.

add_default_chemoton_nt_settingsbool, optional

Whether the default react job setting of Chemoton should be added to all react jobs, by default False.

class Options(model, status_cycle_time, include_thermochemistry, gear_options, general_settings, hessian_job_order, *args, **kwargs)

Construct it with a given model

Parameters:

modeldb.Model

The model given to all subclasses.

unset_collections()

Duplicate name to HoldCollections method to be triggered in pickling process, so infinite _parent loops are avoided.

Return type:

None

current_gears()

The gears currently in the protocol. Allows ProtocolEntry agnostic access.

Return type:

List[Gear]

Returns:

List[Gear]

List of gears.

dry_setup_protocol(credentials, selection=None, n_already_executed_protocol_steps=0)

Sets up the protocol (individual gears) as currently specified in the options without running anything. This is useful to get some preemptive information about the gears to be run.

Return type:

None

Parameters:

credentialsdb.Credentials

The credentials of the database to connect to. Only used for retrieving collections, not manipulation.

selectionOptional[SelectionResult], optional

A selection to be given to the expansion, can manipulate the individual gears, by default None.

Notes

Protocol should be cleared afterward if the step is not immediately executed to avoid problems with multithreaded / multiprocessed code due to presence of potentially forked objects in the protocol.

get_result()

Return type:

Optional[NetworkExpansionResult]

hardcoded_gear_options: GearOptions

initialize_collections(manager)

Return type:

None

property name: str

options: ThermochemistryGeneration.Options

static possible_attributes()

Return type:

List[str]

protocol: List[Union[ProtocolEntry, StopPreviousProtocolEntries]]

set_result(result)

Return type:

None

thermochemistry_gear

alias of BasicThermoDataCompletion

unset_collections()

Return type:

None

class scine_chemoton.steering_wheel.network_expansions.conformers.ConformerCreation(model, gear_options=None, status_cycle_time=1.0, include_thermochemistry=False, general_settings=None, *args, **kwargs)

Network expansion that adds conformers to the given selection result.

Generate a new network expansion with the most important options. Any detailed options can still be specified on gear-level in GearOptions.

Parameters:

modeldb.Model

The model of the network expansion.

status_cycle_timefloat, optional

How often the status of the individual gears and subsequently the own status should be updated. Small expansions on small networks benefit from shorter times, while the querying on larger database may become expensive and short expansion can cause race condition problems with the gears, hence longer times are safer, by default 1.0 (very short).

include_thermochemistrybool, optional

If thermochemistry calculations (require Hessian calculations) should be added, by default False

general_settingsOptional[Dict[str, Any]], optional

Settings to be added to each separate job (beside graph job), because this only accepts special options and is at time of writing not created anymore, because the graph is generated within the bond orders job, which also accepts calculator specific settings. Due to being added to many jobs, we recommend only calculator settings, such as ‘max_scf_iterations’, by default None.

add_default_chemoton_nt_settingsbool, optional

Whether the default react job setting of Chemoton should be added to all react jobs, by default False.

class Options(model, status_cycle_time, include_thermochemistry, gear_options, general_settings, *args, **kwargs)

Construct it with a given model

Parameters:

modeldb.Model

The model given to all subclasses.

unset_collections()

Duplicate name to HoldCollections method to be triggered in pickling process, so infinite _parent loops are avoided.

Return type:

None

current_gears()

The gears currently in the protocol. Allows ProtocolEntry agnostic access.

Return type:

List[Gear]

Returns:

List[Gear]

List of gears.

dry_setup_protocol(credentials, selection=None, n_already_executed_protocol_steps=0)

Sets up the protocol (individual gears) as currently specified in the options without running anything. This is useful to get some preemptive information about the gears to be run.

Return type:

None

Parameters:

credentialsdb.Credentials

The credentials of the database to connect to. Only used for retrieving collections, not manipulation.

selectionOptional[SelectionResult], optional

A selection to be given to the expansion, can manipulate the individual gears, by default None.

Notes

Protocol should be cleared afterward if the step is not immediately executed to avoid problems with multithreaded / multiprocessed code due to presence of potentially forked objects in the protocol.

get_result()

Return type:

Optional[NetworkExpansionResult]

hardcoded_gear_options: GearOptions

initialize_collections(manager)

Return type:

None

property name: str

options: ConformerCreation.Options

static possible_attributes()

Return type:

List[str]

protocol: List[Union[ProtocolEntry, StopPreviousProtocolEntries]]

set_result(result)

Return type:

None

thermochemistry_gear

alias of BasicThermoDataCompletion

unset_collections()

Return type:

None

class scine_chemoton.steering_wheel.network_expansions.reactions.Association(model, gear_options=None, status_cycle_time=60.0, include_thermochemistry=False, general_settings=None, add_default_chemoton_nt_settings=True, exact_settings_check=False, react_flasks=False, max_bond_associations=1, max_bond_dissociations=0, max_intra_associations=0, *args, **kwargs)

Represents the bimolecular association of two compounds.

Generate a new network expansion with the most important options. Any detailed options can still be specified on gear-level in GearOptions.

Parameters:

modeldb.Model

The model of the network expansion.

status_cycle_timefloat, optional

How often the status of the individual gears and subsequently the own status should be updated. Small expansions on small networks benefit from shorter times, while the querying on larger database may become expensive and short expansion can cause race condition problems with the gears, hence longer times are safer, by default 1.0 (very short).

include_thermochemistrybool, optional

If thermochemistry calculations (require Hessian calculations) should be added, by default False

general_settingsOptional[Dict[str, Any]], optional

Settings to be added to each separate job (beside graph job), because this only accepts special options and is at time of writing not created anymore, because the graph is generated within the bond orders job, which also accepts calculator specific settings. Due to being added to many jobs, we recommend only calculator settings, such as ‘max_scf_iterations’, by default None.

add_default_chemoton_nt_settingsbool, optional

Whether the default react job setting of Chemoton should be added to all react jobs, by default False.

class Options(model, status_cycle_time, include_thermochemistry, gear_options, general_settings, max_bond_dissociations, further_explore_dissociations_barrier, max_bond_associations, max_intra_associations, *args, **kwargs)

Construct it with a given model

Parameters:

modeldb.Model

The model given to all subclasses.

unset_collections()

Duplicate name to HoldCollections method to be triggered in pickling process, so infinite _parent loops are avoided.

Return type:

None

current_gears()

The gears currently in the protocol. Allows ProtocolEntry agnostic access.

Return type:

List[Gear]

Returns:

List[Gear]

List of gears.

dry_setup_protocol(credentials, selection=None, n_already_executed_protocol_steps=0)

Sets up the protocol (individual gears) as currently specified in the options without running anything. This is useful to get some preemptive information about the gears to be run.

Return type:

None

Parameters:

credentialsdb.Credentials

The credentials of the database to connect to. Only used for retrieving collections, not manipulation.

selectionOptional[SelectionResult], optional

A selection to be given to the expansion, can manipulate the individual gears, by default None.

Notes

Protocol should be cleared afterward if the step is not immediately executed to avoid problems with multithreaded / multiprocessed code due to presence of potentially forked objects in the protocol.

get_result()

Return type:

Optional[NetworkExpansionResult]

hardcoded_gear_options: GearOptions

initialize_collections(manager)

Return type:

None

property name: str

options: Association.Options

static possible_attributes()

Return type:

List[str]

protocol: List[Union[ProtocolEntry, StopPreviousProtocolEntries]]

set_result(result)

Return type:

None

thermochemistry_gear

alias of BasicThermoDataCompletion

unset_collections()

Return type:

None

class scine_chemoton.steering_wheel.network_expansions.reactions.ChemicalReaction(model, gear_options=None, status_cycle_time=60.0, include_thermochemistry=False, general_settings=None, add_default_chemoton_nt_settings=True, exact_settings_check=False, react_flasks=False, *args, **kwargs)

The base class for all network expansions that should implement a basic reaction step. Still abstract and not to be used directly.

Generate a new network expansion with the most important options. Any detailed options can still be specified on gear-level in GearOptions.

Parameters:

modeldb.Model

The model of the network expansion.

status_cycle_timefloat, optional

How often the status of the individual gears and subsequently the own status should be updated. Small expansions on small networks benefit from shorter times, while the querying on larger database may become expensive and short expansion can cause race condition problems with the gears, hence longer times are safer, by default 1.0 (very short).

include_thermochemistrybool, optional

If thermochemistry calculations (require Hessian calculations) should be added, by default False

general_settingsOptional[Dict[str, Any]], optional

Settings to be added to each separate job (beside graph job), because this only accepts special options and is at time of writing not created anymore, because the graph is generated within the bond orders job, which also accepts calculator specific settings. Due to being added to many jobs, we recommend only calculator settings, such as ‘max_scf_iterations’, by default None.

add_default_chemoton_nt_settingsbool, optional

Whether the default react job setting of Chemoton should be added to all react jobs, by default False.

class Options(*args, **kwargs)

Construct it with a given model

Parameters:

modeldb.Model

The model given to all subclasses.

unset_collections()

Duplicate name to HoldCollections method to be triggered in pickling process, so infinite _parent loops are avoided.

Return type:

None

current_gears()

The gears currently in the protocol. Allows ProtocolEntry agnostic access.

Return type:

List[Gear]

Returns:

List[Gear]

List of gears.

dry_setup_protocol(credentials, selection=None, n_already_executed_protocol_steps=0)

Sets up the protocol (individual gears) as currently specified in the options without running anything. This is useful to get some preemptive information about the gears to be run.

Return type:

None

Parameters:

credentialsdb.Credentials

The credentials of the database to connect to. Only used for retrieving collections, not manipulation.

selectionOptional[SelectionResult], optional

A selection to be given to the expansion, can manipulate the individual gears, by default None.

Notes

Protocol should be cleared afterward if the step is not immediately executed to avoid problems with multithreaded / multiprocessed code due to presence of potentially forked objects in the protocol.

get_result()

Return type:

Optional[NetworkExpansionResult]

hardcoded_gear_options: GearOptions

initialize_collections(manager)

Return type:

None

property name: str

options: ChemicalReaction.Options

static possible_attributes()

Return type:

List[str]

protocol: List[Union[ProtocolEntry, StopPreviousProtocolEntries]]

set_result(result)

Return type:

None

thermochemistry_gear

alias of BasicThermoDataCompletion

unset_collections()

Return type:

None

class scine_chemoton.steering_wheel.network_expansions.reactions.Dissociation(model, gear_options=None, status_cycle_time=60.0, include_thermochemistry=False, general_settings=None, add_default_chemoton_nt_settings=True, exact_settings_check=False, react_flasks=False, max_bond_dissociations=1, further_explore_dissociations_barrier=200.0, *args, **kwargs)

Represents an unimolecular dissociation into two or more separate compounds.

Generate a new network expansion with the most important options. Any detailed options can still be specified on gear-level in GearOptions.

Parameters:

modeldb.Model

The model of the network expansion.

status_cycle_timefloat, optional

How often the status of the individual gears and subsequently the own status should be updated. Small expansions on small networks benefit from shorter times, while the querying on larger database may become expensive and short expansion can cause race condition problems with the gears, hence longer times are safer, by default 1.0 (very short).

include_thermochemistrybool, optional

If thermochemistry calculations (require Hessian calculations) should be added, by default False

general_settingsOptional[Dict[str, Any]], optional

Settings to be added to each separate job (beside graph job), because this only accepts special options and is at time of writing not created anymore, because the graph is generated within the bond orders job, which also accepts calculator specific settings. Due to being added to many jobs, we recommend only calculator settings, such as ‘max_scf_iterations’, by default None.

add_default_chemoton_nt_settingsbool, optional

Whether the default react job setting of Chemoton should be added to all react jobs, by default False.

class Options(model, status_cycle_time, include_thermochemistry, gear_options, general_settings, max_bond_dissociations, further_explore_dissociations_barrier, *args, **kwargs)

Construct it with a given model

Parameters:

modeldb.Model

The model given to all subclasses.

unset_collections()

Duplicate name to HoldCollections method to be triggered in pickling process, so infinite _parent loops are avoided.

Return type:

None

current_gears()

The gears currently in the protocol. Allows ProtocolEntry agnostic access.

Return type:

List[Gear]

Returns:

List[Gear]

List of gears.

dry_setup_protocol(credentials, selection=None, n_already_executed_protocol_steps=0)

Sets up the protocol (individual gears) as currently specified in the options without running anything. This is useful to get some preemptive information about the gears to be run.

Return type:

None

Parameters:

credentialsdb.Credentials

The credentials of the database to connect to. Only used for retrieving collections, not manipulation.

selectionOptional[SelectionResult], optional

A selection to be given to the expansion, can manipulate the individual gears, by default None.

Notes

Protocol should be cleared afterward if the step is not immediately executed to avoid problems with multithreaded / multiprocessed code due to presence of potentially forked objects in the protocol.

get_result()

Return type:

Optional[NetworkExpansionResult]

hardcoded_gear_options: GearOptions

initialize_collections(manager)

Return type:

None

property name: str

options: Dissociation.Options

static possible_attributes()

Return type:

List[str]

protocol: List[Union[ProtocolEntry, StopPreviousProtocolEntries]]

set_result(result)

Return type:

None

thermochemistry_gear

alias of BasicThermoDataCompletion

unset_collections()

Return type:

None

class scine_chemoton.steering_wheel.network_expansions.reactions.Rearrangement(model, gear_options=None, status_cycle_time=60.0, include_thermochemistry=False, general_settings=None, add_default_chemoton_nt_settings=True, exact_settings_check=False, react_flasks=False, max_bond_associations=1, max_bond_dissociations=0, max_intra_associations=0, *args, **kwargs)

Represents the unimolecular rearrangement of a compound into another compound or multiple separate compounds.

Generate a new network expansion with the most important options. Any detailed options can still be specified on gear-level in GearOptions.

Parameters:

modeldb.Model

The model of the network expansion.

status_cycle_timefloat, optional

How often the status of the individual gears and subsequently the own status should be updated. Small expansions on small networks benefit from shorter times, while the querying on larger database may become expensive and short expansion can cause race condition problems with the gears, hence longer times are safer, by default 1.0 (very short).

include_thermochemistrybool, optional

If thermochemistry calculations (require Hessian calculations) should be added, by default False

general_settingsOptional[Dict[str, Any]], optional

Settings to be added to each separate job (beside graph job), because this only accepts special options and is at time of writing not created anymore, because the graph is generated within the bond orders job, which also accepts calculator specific settings. Due to being added to many jobs, we recommend only calculator settings, such as ‘max_scf_iterations’, by default None.

add_default_chemoton_nt_settingsbool, optional

Whether the default react job setting of Chemoton should be added to all react jobs, by default False.

class Options(model, status_cycle_time, include_thermochemistry, gear_options, general_settings, max_bond_dissociations, further_explore_dissociations_barrier, max_bond_associations, max_intra_associations, *args, **kwargs)

Construct it with a given model

Parameters:

modeldb.Model

The model given to all subclasses.

unset_collections()

Duplicate name to HoldCollections method to be triggered in pickling process, so infinite _parent loops are avoided.

Return type:

None

current_gears()

The gears currently in the protocol. Allows ProtocolEntry agnostic access.

Return type:

List[Gear]

Returns:

List[Gear]

List of gears.

dry_setup_protocol(credentials, selection=None, n_already_executed_protocol_steps=0)

Sets up the protocol (individual gears) as currently specified in the options without running anything. This is useful to get some preemptive information about the gears to be run.

Return type:

None

Parameters:

credentialsdb.Credentials

The credentials of the database to connect to. Only used for retrieving collections, not manipulation.

selectionOptional[SelectionResult], optional

A selection to be given to the expansion, can manipulate the individual gears, by default None.

Notes

Protocol should be cleared afterward if the step is not immediately executed to avoid problems with multithreaded / multiprocessed code due to presence of potentially forked objects in the protocol.

get_result()

Return type:

Optional[NetworkExpansionResult]

hardcoded_gear_options: GearOptions

initialize_collections(manager)

Return type:

None

property name: str

options: Rearrangement.Options

static possible_attributes()

Return type:

List[str]

protocol: List[Union[ProtocolEntry, StopPreviousProtocolEntries]]

set_result(result)

Return type:

None

thermochemistry_gear

alias of BasicThermoDataCompletion

unset_collections()

Return type:

None