examol.specify

Tool for defining then deploying an ExaMol application

class examol.specify.ExaMolSpecification(database: ~pathlib._local.Path | str | ~examol.store.db.base.MoleculeStore, recipes: ~typing.Sequence[~examol.store.recipes.PropertyRecipe], search_space: list[~pathlib._local.Path | str], simulator: ~examol.simulate.base.BaseSimulator, solution: ~examol.solution.SolutionSpecification, thinker: type[~examol.steer.base.MoleculeThinker] = Ellipsis, thinker_options: dict[str, object] = <factory>, thinker_workers: int = 4, reporters: list[~examol.reporting.base.BaseReporter] = <factory>, compute_config: ~parsl.config.Config = Ellipsis, proxystore: ~proxystore.store.base.Store | dict[str, ~proxystore.store.base.Store] | None = None, proxystore_threshold: float | int = 10000, colmena_queue: type[~colmena.queue.base.ColmenaQueues] = <class 'colmena.queue.python.PipeQueues'>, run_dir: ~pathlib._local.Path | str = Ellipsis)

Bases: object

Specification for a molecular design application that can set up then start it.

Creating a Compute Configuration

The compute_config option accepts a subset of Parsl’s configuration options:

• Single Executor: Specify a single executor and have ExaMol use that executor for all tasks

• Split Executor: Specify two executors and label one “learning” and the other “simulation” to have the AI tasks be placed on one resource and simulation on the other.

assemble() → tuple[BaseTaskServer, MoleculeThinker, MoleculeStore]

Assemble the Colmena application

Returns:

• Task server used to perform computations

• Thinker used to steer computations

• Store used to collect results

colmena_queue

Class used to send messages between Thinker and Task Server.

alias of PipeQueues

compute_config: Config = Ellipsis

Description of the available resources via Parsl. See Config.

database: Path | str | MoleculeStore

Path to the data as a line-delimited JSON file or an already-activated store

load_database() → MoleculeStore

Load the starting database

Returns:

Pointer to the database object

proxystore: Store | dict[str, Store] | None = None

Proxy store(s) used to communicate large objects between Thinker and workers. Can be either a single store used for all task types, or a mapping between a task topic (inference, simulation, train) and the store used for that task type.

All messages larger than proxystore_threshold will be proxied using the store.

proxystore_threshold: float | int = 10000

bytes

Type:

Messages larger than this size will be sent via Proxystore rather than through the workflow engine. Units

recipes: Sequence[PropertyRecipe]

Definition for how to compute the target properties

reporters: list[BaseReporter]

List of classes which provide users with real-time information

run_dir: Path | str = Ellipsis

Path in which to write output files

search_space: list[Path | str]

Path to the molecules over which to search. Should be a list of “.smi” files

simulator: BaseSimulator

Tool used to perform quantum chemistry computations

solution: SolutionSpecification

Define how to solve the design challenge

thinker: type[MoleculeThinker] = Ellipsis

Policy used to schedule computations

thinker_options: dict[str, object]

Options passed forward to initializing the thinker

thinker_workers: int = 4

Number of workers to use in the steering process