Source code for pylbo.automation.api

from __future__ import annotations

import os
from typing import Union

from pylbo.automation.generator import ParfileGenerator
from pylbo.automation.runner import LegolasRunner

[docs] def generate_parfiles( parfile_dict: dict, basename: str = None, output_dir: Union[str, os.PathLike] = None, subdir: bool = True, prefix_numbers: bool = True, nb_prefix_digits: int = 4, ) -> list[str]: """ Generates parfiles based on a given configuration dictionary. The separate namelists do not have to be taken into account, and a normal dictionary should be supplied where the keys correspond to the namelist items that are required. Typechecking is done automatically during parfile generation. Parameters ---------- parfile_dict : dict Dictionary containing the keys to be placed in the parfile. basename : str The basename for the parfile, the `.par` suffix is added automatically and is not needed. If multiple parfiles are generated, these will be prepended by a 4-digit number (e.g. 0003myparfile.par). If not provided, the basename will default to `parfile`. output_dir : str, ~os.PathLike Output directory where the parfiles are saved, defaults to the current working directory if not specified. A subdirectory called `parfiles` will be created in which the parfiles will be saved. subdir : boolean If `True` (default), creates a subdirectory `parfiles` in the output folder. prefix_numbers : boolean If `True` prepends the `basename` by a n-digit number (e.g. xxxxmyparfile.par). The number of digits is specified by `nb_prefix_digits`. nb_prefix_digits : int Number of digits to prepend to the `basename` if `prefix_numbers` is `True`. Defaults to 4. Notes ----- This routine is quite flexible and specifically designed for parametric studies. You can specify both single values and list-like items as dictionary items. This routine will automatically generate multiple parfiles if lists/numpy arrays are present. Returns ------- parfiles : list A list with the paths to the parfiles that were generated. This list can be passed immediately to :func:`pylbo.run_legolas`. Examples -------- This will generate a single parfile in a subdirectory `parfile` of the current working directory. >>> import pylbo >>> config = { >>> "geometry": "Cartesian", >>> "x_start": 0, >>> "x_end": 1, >>> "equilibrium_type": "resistive_homo", >>> "gridpoints": 100, >>> "write_eigenfunctions": True, >>> "basename_datfile": "my_run", >>> "output_folder": "output", >>> } >>> parfile = pylbo.generate_parfiles(config) This will generate 10 parfiles in the directory `my_parfiles` relative to the current working directory. The first parfile will have `x_end = 1.0` and 100 gridpoints, the second one will have `x_end = 2.0` and 150 gridpoints, etc. >>> import pylbo >>> import numpy as np >>> config = { >>> "geometry": "Cartesian", >>> "x_start": 0, >>> "x_end": np.arange(1, 11) >>> "number_of_runs": 10 >>> "equilibrium_type": "resistive_homo", >>> "gridpoints": np.arange(100, 600, 50), >>> "write_eigenfunctions": True, >>> "basename_datfile": "my_run", >>> "output_folder": "output", >>> } >>> parfile_list = pylbo.generate_parfiles(config, output_dir="my_parfiles") """ pfgen = ParfileGenerator( parfile_dict=parfile_dict, basename=basename, output_dir=output_dir, subdir=subdir, prefix_numbers=prefix_numbers, nb_prefix_digits=nb_prefix_digits, ) pfgen.create_namelist_from_dict() return pfgen.generate_parfiles()
[docs] def run_legolas( parfiles: Union[str, list, os.PathLike], remove_parfiles: bool = False, nb_cpus: int = 1, executable: Union[str, os.PathLike] = None, ) -> None: """ Runs the legolas executable for a given list of parfiles. If more than one parfile is passed, the runs can be performed in parallel using the multiprocessing module. Parallelisation can be enabled by setting the `nb_cpus` kwarg to a number greater than one, and is disabled by default. Every CPU will have a single legolas executable subprocess associated with it. Parameters ---------- parfiles : str, list, numpy.ndarray A string, list or array containing the paths to the parfile(s). Accepts the output of :func:`pylbo.generate_parfiles`. remove_parfiles : bool If `True`, removes the parfiles after running Legolas. This will also remove the containing folder if it turns out to be empty after the parfiles are removed. If there are other files still in the folder it remains untouched. nb_cpus : int The number of CPUs to use when running Legolas. If equal to 1 then parallelisation is disabled. Defaults to the maximum number of CPUs available if a number larger than the available number is specified. executable : str, ~os.PathLike The path to the legolas executable. If not specified, defaults to the standard one in the legolas home directory. Notes ----- If multiprocessing is enabled, it is usually a good idea to have the number of runs requested divisible by the number of CPUs that are available. For example, if 24 runs are requested it is good practice to use either 2, 4, 6 or 8 CPUs, and avoid numbers like 3, 5 and 7. Examples -------- The example below will run a list of parfiles using using a local legolas executable from the current directory, on 4 CPU's. >>> import pylbo >>> from pathlib import Path >>> files = sorted(Path("parfiles").glob("*.dat")) >>> pylbo.run_legolas(files, nb_cpus=4, executable="legolas") """ runner = LegolasRunner(parfiles, remove_parfiles, nb_cpus, executable) runner.execute()