def run(model_specification, results_directory, verbose, with_debugger):
"""Run a simulation from the command line.
The simulation itself is defined by the given MODEL_SPECIFICATION yaml file.
Within the results directory, which defaults to ~/vivarium_results if none
is provided, a subdirectory will be created with the same name as the
MODEL_SPECIFICATION if one does not exist. Results will be written to a
further subdirectory named after the start time of the simulation run."""
configure_logging_to_terminal(verbose)
start = time()
results_root = get_output_root(results_directory, model_specification)
results_root.mkdir(parents=True, exist_ok=False)
configure_logging_to_file(results_root)
shutil.copy(model_specification, results_root / 'model_specification.yaml')
main = handle_exceptions(run_simulation, logger, with_debugger)
override_configuration = {'output_data': {'results_directory': str(results_root)}}
finished_sim = main(model_specification, configuration=override_configuration)
idx = pd.Index([finished_sim.configuration.randomness.random_seed], name='random_seed')
metrics = pd.DataFrame(finished_sim.report(), index=idx)
metrics['simulation_run_time'] = time() - start
metrics.to_hdf(results_root / 'output.hdf', key='data')
def make_artifacts(location: str, output_dir: str, append: bool, verbose: int,
with_debugger: bool) -> None:
configure_logging_to_terminal(verbose)
main = handle_exceptions(build_artifacts,
logger,
with_debugger=with_debugger)
main(location, output_dir, append, verbose)
def test_handle_exceptions(test_input):
def raise_me(ex):
raise ex
with pytest.raises(test_input):
func = handle_exceptions(raise_me(test_input), None, False)
func()
def make_joint_pafs(location: str, draws: str, verbose: int,
with_debugger: bool, queue: str) -> None:
configure_logging_to_terminal(verbose)
main = handle_exceptions(build_joint_pafs,
logger,
with_debugger=with_debugger)
main(location, draws, verbose, queue)
def restart(results_root, **options):
"""Restart a parallel simulation from a previous run at RESULTS_ROOT.
Restarting will not erase existing results, but will start workers to
perform the remaining simulations. RESULTS_ROOT is expected to be an
output directory from a previous ``psimulate run`` invocation.
"""
logs.configure_main_process_logging_to_terminal(options["verbose"])
main = handle_exceptions(runner.main, logger, options["with_debugger"])
main(
command=COMMANDS.restart,
input_paths=paths.InputPaths.from_entry_point_args(
result_directory=results_root, ),
native_specification=cluster.NativeSpecification(
job_name=results_root.parent.name,
project=options["project"],
queue=options["queue"],
peak_memory=options["peak_memory"],
max_runtime=options["max_runtime"],
),
redis_processes=options["redis"],
no_batch=options["no_batch"],
extra_args={},
)
def expand(results_root, **options):
"""Expand a previous run at RESULTS_ROOT by adding input draws and/or
random seeds.
Expanding will not erase existing results, but will start workers to perform
the additional simulations determined by the added draws/seeds.
RESULTS_ROOT is expected to be an output directory from a previous
``psimulate run`` invocation.
"""
logs.configure_main_process_logging_to_terminal(options["verbose"])
main = handle_exceptions(runner.main, logger, options["with_debugger"])
main(
command=COMMANDS.expand,
input_paths=paths.InputPaths.from_entry_point_args(
result_directory=results_root, ),
native_specification=cluster.NativeSpecification(
job_name=results_root.parent.name,
project=options["project"],
queue=options["queue"],
peak_memory=options["peak_memory"],
max_runtime=options["max_runtime"],
),
redis_processes=options["redis"],
no_batch=options["no_batch"],
extra_args={
"num_draws": options["add_draws"],
"num_seeds": options["add_seeds"],
},
)
def make_specs(template: str, location: str, output_dir: str, verbose: int,
with_debugger: bool) -> None:
"""
Make model specifications
click application that takes a template model specification file
and locations for which to create model specs and uses jinja2 to
render model specs with the correct location parameters plugged in.
It will look for the model spec template in "model_spec.in" in the directory
``src/vivarium_csu_zenon/model_specifications``.
Add location strings to the ``src/globals.py`` file. By default, specifications
for all locations will be built. You can choose to make a model specification
for a single location by specifying that location. However, the location
string must exist in the list in ``src/globals.py``.
The application will look for the model spec based on the python environment
that is active and these files don't need to be specified if the
default names and location are used.
"""
configure_logging_to_terminal(verbose)
main = handle_exceptions(build_model_specifications,
logger,
with_debugger=with_debugger)
main(template, location, output_dir)
def make_sample_histories(location: str, scenarios: str, verbose: int,
with_debugger: bool, queue: str) -> None:
configure_logging_to_terminal(verbose)
main = handle_exceptions(build_sample_histories,
logger,
with_debugger=with_debugger)
main(location, scenarios, verbose, queue)
def run(model_specification, branch_configuration, result_directory, **options):
"""Run a parallel simulation.
The simulation itself is defined by a MODEL_SPECIFICATION yaml file
and the parameter changes across runs are defined by a BRANCH_CONFIGURATION
yaml file.
If a results directory is provided, a subdirectory will be created with the
same name as the MODEL_SPECIFICATION if one does not exist. Results will be
written to a further subdirectory named after the start time of the
simulation run.
If a results directory is not provided the base results_directory is taken
to be /share/costeffectiveness/results.
"""
utilities.configure_master_process_logging_to_terminal(options['verbose'])
main = handle_exceptions(runner.main, logger, options['with_debugger'])
main(model_specification, branch_configuration, result_directory,
{'project': options['project'],
'queue': options['queue'],
'peak_memory': options['peak_memory'],
'max_runtime': options['max_runtime']},
redis_processes=options['redis'], no_batch=options['no_batch'])
def make_ldl_exposure_thresholds(location: str, draws: str, concat_only: bool,
verbose: int, with_debugger: bool) -> None:
configure_logging_to_terminal(verbose)
main = handle_exceptions(build_ldl_thresholds,
logger,
with_debugger=with_debugger)
main(location, draws, concat_only, verbose)
def test():
"""Run a test simulation using the ``disease_model.yaml`` model specification
provided in the examples directory.
"""
configure_logging_to_terminal(verbose=True)
model_specification = disease_model.get_model_specification_path()
main = handle_exceptions(run_simulation, logger, with_debugger=False)
main(model_specification)
click.echo()
click.secho("Installation test successful!", fg='green')
def make_specs(template: str, location: str, output_dir: str, verbose: int,
with_debugger: bool) -> None:
"""Generate model specifications based on a template.
The default template lives here:
``src/vivarium_conic_vitamin_a_supp/model_specification/model_spec.in``
"""
configure_logging_to_terminal(verbose)
main = handle_exceptions(build_model_specifications,
logger,
with_debugger=with_debugger)
main(template, location, output_dir)
def run(
model_specification: Path,
branch_configuration: Path,
artifact_path: Optional[Path],
result_directory: Optional[Path],
**options,
) -> None:
"""Run a parallel simulation.
The simulation itself is defined by a MODEL_SPECIFICATION yaml file
and the parameter changes across runs are defined by a BRANCH_CONFIGURATION
yaml file.
The path to the data artifact can be provided as an argument here, in the
branch configuration, or in the model specification file. Values provided as
a command line argument or in the branch specification file will override a
value specified in the model specifications file. If an artifact path is
provided both as a command line argument and to the branch configuration file
a ConfigurationError will be thrown.
Within the provided or default results directory, a subdirectory will be
created with the same name as the MODEL_SPECIFICATION if one does not exist.
Results will be written to a further subdirectory named after the start time
of the simulation run.
"""
logs.configure_main_process_logging_to_terminal(options["verbose"])
main = handle_exceptions(runner.main, logger, options["with_debugger"])
main(
command=COMMANDS.run,
input_paths=paths.InputPaths.from_entry_point_args(
input_model_specification_path=model_specification,
input_branch_configuration_path=branch_configuration,
input_artifact_path=artifact_path,
result_directory=result_directory,
),
native_specification=cluster.NativeSpecification(
job_name=model_specification.stem,
project=options["project"],
queue=options["queue"],
peak_memory=options["peak_memory"],
max_runtime=options["max_runtime"],
),
redis_processes=options["redis"],
no_batch=options["no_batch"],
extra_args={},
)
def restart(results_root, **options):
"""Restart a parallel simulation from a previous run at RESULTS_ROOT.
Restarting will not erase existing results, but will start workers to
perform the remaining simulations. RESULTS_ROOT is expected to be an
output directory from a previous ``psimulate run`` invocation.
"""
utilities.configure_master_process_logging_to_terminal(options['verbose'])
main = handle_exceptions(runner.main, logger, options['with_debugger'])
main(None, None, results_root,
{'project': options['project'],
'queue': options['queue'],
'peak_memory': options['peak_memory'],
'max_runtime': options['max_runtime']},
redis_processes=options['redis'], restart=True, no_batch=options['no_batch'])
def test(test_type, num_workers, result_directory, **options):
logs.configure_main_process_logging_to_terminal(options["verbose"])
main = handle_exceptions(runner.main, logger, options["with_debugger"])
main(
command=COMMANDS.load_test,
input_paths=paths.InputPaths.from_entry_point_args(
result_directory=result_directory, ),
native_specification=cluster.NativeSpecification(
job_name=f"load_test_{test_type}",
project=options["project"],
queue=options["queue"],
peak_memory=options["peak_memory"],
max_runtime=options["max_runtime"],
),
redis_processes=options["redis"],
no_batch=options["no_batch"],
extra_args={
"test_type": test_type,
"num_workers": num_workers,
},
)
def make_specs(template: str, location: str, output_dir: str, verbose: int,
with_debugger: bool) -> None:
"""Generate model specifications based on a template.
The default template lives here:
``vivarium_gates_shigella_vaccine/src/vivarium_gates_shigella_vaccine/model_specification/model_spec.in``
Supply the locations for which you want a model spec generated by filling
in the empty 'locations.txt' file. A template for this file can be found at
``vivarium_gates_shigella_vaccine/src/vivarium_gates_shigella_vaccine/model_specification/locations.txt``
with instructions for it's use.
"""
configure_logging_to_terminal(verbose)
main = handle_exceptions(build_model_specifications,
logger,
with_debugger=with_debugger)
main(template, location, output_dir)
def expand(results_root, **options):
"""Expand a previous run at RESULTS_ROOT by adding input draws and/or
random seeds.
Expanding will not erase existing results, but will start workers to perform
the additional simulations determined by the added draws/seeds.
RESULTS_ROOT is expected to be an output directory from a previous
``psimulate run`` invocation.
"""
utilities.configure_master_process_logging_to_terminal(options['verbose'])
main = handle_exceptions(runner.main, logger, options['with_debugger'])
main(None, None, results_root,
{'project': options['project'],
'queue': options['queue'],
'peak_memory': options['peak_memory'],
'max_runtime': options['max_runtime']},
redis_processes=options['redis'],
restart=True,
expand={'num_draws': options['add_draws'],
'num_seeds': options['add_seeds']},
no_batch=options['no_batch'])
def make_results(output_file: str, verbose: int, with_debugger: bool, single_run: bool) -> None:
configure_logging_to_terminal(verbose)
main = handle_exceptions(build_results, logger, with_debugger=with_debugger)
main(output_file, single_run)
def parse_logs(worker_log_directory, output_file, verbose, with_debugger):
configure_logging_to_terminal(verbose)
main = handle_exceptions(build_results_from_logs,
logger,
with_debugger=with_debugger)
main(worker_log_directory, output_file)
def build_htn_artifact(location):
from vivarium_csu_hypertension_sdc.components import builder
output_root = Path(f'/share/costeffectiveness/artifacts/{PROJECT_NAME}/')
main = handle_exceptions(builder.build_artifact, logger, with_debugger=True)
main(output_root, location)
