b2-run-sim 0.0.1__py3-none-any.whl

b2_run_sim/__init__.py

@@ -0,0 +1,4 @@
+from .util import Interval
+from .config import RunMetadata
+from .setup import RandomSampler, GridSampler, setup_run_dir
+from .submit import submit_jobs

b2_run_sim/config.py

@@ -0,0 +1,142 @@
+from pathlib import Path
+from dataclasses import dataclass, field
+
+from .util import Interval, load_dataclass_from_json_file, save_dataclass_to_json_file
+
+
+@dataclass
+class Filenames:
+    metadata: Path | str = "metadata.json"
+    decay: Path | str = "decay.dec"
+    log: Path | str = "log.log"
+
+    def recon(self, subtrial: int):
+        out = f"recon_{subtrial}.root"
+        return out
+
+    def sim(self, subtrial: int):
+        out = f"sim_{subtrial}.root"
+        return out
+
+
+@dataclass
+class FilePaths:
+    dir_: Path | str
+    metadata: Path = field(init=False)
+    decay: Path = field(init=False)
+    log: Path = field(init=False)
+
+    def __post_init__(self):
+        self.dir_ = Path(self.dir_)
+        filenames = Filenames()
+        self.metadata = self.dir_.joinpath(filenames.metadata)
+        self.decay = self.dir_.joinpath(filenames.decay)
+        self.log = self.dir_.joinpath(filenames.log)
+
+    def recon(self, subtrial: int):
+        filename = Filenames().recon(subtrial)
+        out = self.dir_.joinpath(filename)
+        return out
+
+    def sim(self, subtrial: int):
+        filename = Filenames().sim(subtrial)
+        out = self.dir_.joinpath(filename)
+        return out
+
+
+@dataclass
+class SubtrialMetadata:
+    subtrial_num: int
+    num_events: int
+    parameter_values: dict[str, float]
+
+
+@dataclass
+class TrialMetadata:
+    trial_num: int
+    num_events: int
+    num_subtrials: int
+    parameter_values: dict[str, float]
+
+    @property
+    def num_events_per_subtrial(self) -> int:
+        out = safer_convert_to_int(self.num_events / self.num_subtrials)
+        return out
+
+
+@dataclass
+class RunMetadata:
+    split: str
+    total_num_events: int
+    num_trials: int
+    num_subtrials_per_trial: int
+    parameter_bounds: dict[str, Interval]
+    sampling_type: str
+    parameter_grid_counts: None | dict[str, int] = None
+
+    def __post_init__(self):
+        if self.sampling_type not in ("grid", "random"):
+            raise ValueError
+        if self.sampling_type == "grid" and self.parameter_grid_counts is None:
+            raise ValueError
+        if self.sampling_type != "grid" and self.parameter_grid_counts is not None:
+            raise ValueError
+        if (
+            self.parameter_grid_counts is not None
+            and self.total_num_grid_points != self.num_trials
+        ):
+            raise ValueError
+
+    @property
+    def num_events_per_trial(self) -> int:
+        out = safer_convert_to_int(self.total_num_events / self.num_trials)
+        return out
+
+    @property
+    def num_events_per_subtrial(self) -> int:
+        out = safer_convert_to_int(
+            self.num_events_per_trial / self.num_subtrials_per_trial
+        )
+        return out
+
+    @property
+    def total_num_grid_points(self) -> None | int:
+        if self.parameter_grid_counts is None:
+            return None
+        out = prod(self.parameter_grid_counts.values())
+        return out
+
+
+def make_trial_metadata_list(
+    run_metadata: RunMetadata, parameter_values_list: list[dict[str, float]]
+) -> list[TrialMetadata]:
+    assert len(parameter_values_list) == run_metadata.num_trials
+    out = [
+        TrialMetadata(
+            trial_num,
+            run_metadata.num_events_per_trial,
+            run_metadata.num_subtrials_per_trial,
+            parameter_values,
+        )
+        for trial_num, parameter_values in enumerate(parameter_values_list)
+    ]
+    return out
+
+
+def save_metadata_to_dir(
+    metadata: TrialMetadata | RunMetadata, dir_path: Path | str
+) -> None:
+    dir_path = Path(dir_path)
+    filename = Filenames().metadata
+    path = dir_path.joinpath(filename)
+    save_dataclass_to_json_file(metadata, path)
+
+
+def load_metadata_from_dir(
+    metadata_cls, dir_path: Path | str
+) -> RunMetadata | TrialMetadata:
+    dir_path = Path(dir_path)
+    filename = Filenames().metadata
+    path = dir_path.joinpath(filename)
+    out = load_dataclass_from_json_file(metadata_cls, path)
+    return out

b2_run_sim/setup.py

@@ -0,0 +1,117 @@
+from pathlib import Path
+from random import seed, uniform
+from dataclasses import dataclass
+
+from .util import product_combine, Interval, linspace
+from .config import (
+    TrialMetadata,
+    RunMetadata,
+    save_metadata_to_dir,
+    make_trial_metadata_list,
+)
+
+
+def set_random_seed(seed_: int | None = None):
+    seed(seed_)
+
+
+@dataclass
+class RandomSampler:
+    parameter_bounds: dict[str, Interval]
+
+    def sample(
+        self,
+        n: int,
+    ) -> list[dict[str, float]]:
+        out = [self._sample_once() for _ in range(n)]
+        return out
+
+    def _sample_once(
+        self,
+    ) -> dict[str, float]:
+        out = {name: uniform(*bounds) for name, bounds in self.parameter_bounds.items()}
+        return out
+
+
+@dataclass
+class GridSampler:
+    parameter_bounds: dict[str, Interval]
+
+    def sample(self, parameter_counts: dict[str, int]) -> list[dict[str, float]]:
+        samples_per_wc = self._samples_per_wc(parameter_counts)
+        out = product_combine(samples_per_wc)
+        return out
+
+    def _samples_per_wc(
+        self,
+        parameter_counts: dict[str, int],
+    ) -> dict[str, list[float]]:
+        assert parameter_counts.keys() == self.parameter_bounds.keys()
+        out = {
+            name: linspace(*self.parameter_bounds[name], count)
+            for name, count in parameter_counts.items()
+        }
+        return out
+
+
+def sample(run_metadata: RunMetadata):
+    sampler_cls = GridSampler if run_metadata.sampling_type == "grid" else RandomSampler
+    sampler = sampler_cls(run_metadata.parameter_bounds)
+    out = (
+        sampler.sample(run_metadata.parameter_grid_counts)
+        if run_metadata.sampling_type == "grid"
+        else sampler.sample(run_metadata.num_trials)
+    )
+    return out
+
+
+def run_dir_name(split: str) -> str:
+    out = f"{split}"
+    return out
+
+
+def trial_dir_name(trial_num: int) -> str:
+    out = f"{trial_num}"
+    return out
+
+
+def run_dir_path(split: str, parent_dir_path: Path | str) -> Path:
+    parent_dir_path = Path(parent_dir_path)
+    name = run_dir_name(split)
+    out = parent_dir_path.joinpath(name)
+    return out
+
+
+def trial_dir_path(trial_num: int, parent_dir_path: Path | str) -> Path:
+    parent_dir_path = Path(parent_dir_path)
+    name = trial_dir_name(trial_num)
+    out = parent_dir_path.joinpath(name)
+    return out
+
+
+def setup_trial_dir(trial_metadata: TrialMetadata, parent_dir_path: Path | str) -> None:
+    trial_num = trial_metadata.trial_num
+    dir_ = trial_dir_path(trial_num, parent_dir_path)
+    dir_.mkdir()
+    save_metadata_to_dir(
+        trial_metadata,
+        dir_,
+    )
+
+
+def setup_run_dir(
+    run_metadata: RunMetadata,
+    parent_dir: Path | str,
+) -> None:
+    split = run_metadata.split
+    dir_ = run_dir_path(split, parent_dir)
+    dir_.mkdir(parents=True)
+    save_metadata_to_dir(
+        run_metadata,
+        dir_,
+    )
+    parameter_values = sample(run_metadata)
+    trial_metadatas = make_trial_metadata_list(run_metadata, parameter_values)
+    for trial_metadata in trial_metadatas:
+        setup_trial_dir(trial_metadata, dir_)
+    return dir_

b2_run_sim/submit.py

@@ -0,0 +1,202 @@
+from pathlib import Path
+from subprocess import run
+from time import sleep
+
+from .config import TrialMetadata, load_metadata_from_dir, FilePaths
+
+
+def read_dec_file(path: Path | str) -> str:
+    with open(path, "r", encoding="utf-8") as dec_file:
+        out = dec_file.read()
+    return out
+
+
+def format_template_dec_file_string(
+    str_: str, parameter_values: dict[str, float]
+) -> str:
+    for parameter_name in parameter_values.keys():
+        if "{" f"{parameter_name}" "}" not in str_:
+            raise ValueError(
+                f"Parameter name not found in decay file string: {parameter_name}"
+            )
+    try:
+        out = str_.format(**parameter_values)
+        return out
+    except KeyError:
+        raise ValueError("Not all decay file parameters were specified?")
+
+
+def format_template_dec_file(path: Path | str, parameter_values: dict[str, float]):
+    text = read_dec_file(path)
+    out = format_template_dec_file_string(text, parameter_values)
+    return out
+
+
+def write_formatted_dec_file(
+    formatted_dec_file_path: Path | str,
+    template_dec_file_path: Path | str,
+    parameter_values: dict[str, float],
+):
+    formatted_dec_file_string = format_template_dec_file(
+        template_dec_file_path, parameter_values
+    )
+    with open(formatted_dec_file_path, "w") as formatted_dec_file:
+        formatted_dec_file.write(formatted_dec_file_string)
+
+
+def make_sim_command_string(
+    num_events: int,
+    steer_file_path: Path | str,
+    decay_file_path: Path | str,
+    out_file_path: Path | str,
+    log_file_path: Path | str,
+):
+    out = f"basf2 {steer_file_path} {decay_file_path} {out_file_path} {num_events} &>> {log_file_path}"
+    return out
+
+
+def make_recon_command_string(
+    steer_file_path: Path | str,
+    sim_file_path: Path | str,
+    out_file_path: Path | str,
+    log_file_path: Path | str,
+):
+    out = f"basf2 {steer_file_path} {sim_file_path} {out_file_path} &>> {log_file_path}"
+    return out
+
+
+def make_remove_sim_file_command_string(sim_file_path: Path | str):
+    out = f"rm {sim_file_path}"
+    return out
+
+
+def make_bsub_command(
+    num_events: int,
+    sim_steer_file_path: Path | str,
+    recon_steer_file_path: Path | str,
+    decay_file_path: Path | str,
+    sim_file_path: Path | str,
+    recon_file_path: Path | str,
+    log_file_path: Path | str,
+    queue: str,
+):
+    sim_command = make_sim_command_string(
+        num_events=num_events,
+        steer_file_path=sim_steer_file_path,
+        decay_file_path=decay_file_path,
+        out_file_path=sim_file_path,
+        log_file_path=log_file_path,
+    )
+    recon_command = make_recon_command_string(
+        steer_file_path=recon_steer_file_path,
+        sim_file_path=sim_file_path,
+        out_file_path=recon_file_path,
+        log_file_path=log_file_path,
+    )
+    remove_sim_file_command = make_remove_sim_file_command_string(
+        sim_file_path=sim_file_path
+    )
+
+    out = f'bsub -q {queue} "{sim_command} && {recon_command} && {remove_sim_file_command}"'
+    return out
+
+
+def submit_job(
+    num_events: int,
+    sim_steer_file_path: Path | str,
+    recon_steer_file_path: Path | str,
+    decay_file_path: Path | str,
+    sim_file_path: Path | str,
+    recon_file_path: Path | str,
+    log_file_path: Path | str,
+    queue: str,
+    debug: bool = False,
+) -> None:
+    command = make_bsub_command(
+        num_events=num_events,
+        sim_steer_file_path=sim_steer_file_path,
+        recon_steer_file_path=recon_steer_file_path,
+        decay_file_path=decay_file_path,
+        sim_file_path=sim_file_path,
+        recon_file_path=recon_file_path,
+        log_file_path=log_file_path,
+        queue=queue,
+    )
+    if debug:
+        print(command, "\n")
+        return
+    run(command, shell=True)
+
+
+def trial_dir_is_incomplete(dir_path: Path | str) -> bool:
+    try:
+        trial_metadata = load_metadata_from_dir(TrialMetadata, dir_path)
+    except FileNotFoundError:
+        raise RuntimeError(f"Trial directory does not contain metadata:\n{dir_path}")
+    num_subtrials = trial_metadata.num_subtrials
+    for subtrial in range(num_subtrials):
+        recon_file_path = FilePaths(dir_path).recon(subtrial)
+        if not recon_file_path.is_file():
+            return True
+    return False
+
+
+def find_incomplete_trial_dirs(dir_path: Path | str) -> list[Path]:
+    dir_path = Path(dir_path)
+    out = [
+        child
+        for child in dir_path.iterdir()
+        if child.is_dir() and trial_dir_is_incomplete(child)
+    ]
+    return out
+
+
+def submit_jobs(
+    run_dir: Path | str,
+    sim_steer_file_path: Path | str,
+    recon_steer_file_path: Path | str,
+    template_dec_file_path: Path | str,
+    queue: str = "l",
+    batch_size: int = 200,
+    batch_wait_sec: int = 30,
+    job_wait_sec: int | float = 0.1,
+    verbose: bool = True,
+    debug: bool = False,
+) -> None:
+    """
+    Submit jobs.
+
+    Rerunning will skip trials deemed complete.
+    """
+
+    submitted_job_count = 0
+
+    incomplete_trial_dirs = find_incomplete_trial_dirs(run_dir)
+
+    for trial_dir in incomplete_trial_dirs:
+        if verbose:
+            print(f"Submitting jobs for {trial_dir}.")
+        trial_metadata = load_metadata_from_dir(TrialMetadata, trial_dir)
+        trial_file_paths = FilePaths(trial_dir)
+        write_formatted_dec_file(
+            trial_file_paths.decay,
+            template_dec_file_path,
+            trial_metadata.parameter_values,
+        )
+        for subtrial in range(trial_metadata.num_subtrials):
+            submit_job(
+                num_events=trial_metadata.num_events_per_subtrial,
+                sim_steer_file_path=sim_steer_file_path,
+                recon_steer_file_path=recon_steer_file_path,
+                decay_file_path=trial_file_paths.decay,
+                sim_file_path=trial_file_paths.sim(subtrial),
+                recon_file_path=trial_file_paths.recon(subtrial),
+                log_file_path=trial_file_paths.log,
+                queue=queue,
+                debug=debug,
+            )
+            submitted_job_count += 1
+            sleep(job_wait_sec)
+
+            if submitted_job_count % batch_size == 0:
+                sleep(batch_wait_sec)

b2_run_sim/util.py

@@ -0,0 +1,121 @@
+from typing import Any
+from itertools import product
+from math import prod
+from dataclasses import dataclass, asdict, field, fields, is_dataclass
+from copy import deepcopy
+from pathlib import Path
+from json import load, dump
+
+
+def product_combine(d: dict[Any, list | tuple]):
+    prod = product(*d.values())
+    out = [dict(zip(d.keys(), i)) for i in prod]
+    return out
+
+
+def safer_convert_to_int(
+    x: float,
+) -> int:
+    assert x.is_integer()
+    return int(x)
+
+
+def load_json(
+    path: Path | str,
+) -> dict:
+
+    path = Path(path)
+    if not path.is_file():
+        raise FileNotFoundError
+    with open(path, "r") as f:
+        out = load(f)
+    return out
+
+
+def dump_json(
+    obj: dict,
+    path: Path | str,
+) -> None:
+    path = Path(path)
+    with open(path, "x") as f:
+        return dump(
+            obj,
+            f,
+            indent=4,
+        )
+
+
+def read_from_nested_dict(dict_, keys: list):
+    for key in keys:
+        dict_ = dict_[key]
+    return dict_
+
+
+def write_to_nested_dict(dict_, keys: list, value):
+    dict_ = read_from_nested_dict(dict_, keys[:-1])
+    dict_[keys[-1]] = value
+
+
+def _rebuild_dataclass(cls, dict_: dict, keys: list | None = None):
+    if not is_dataclass(cls):
+        return
+    if keys is None:
+        keys = []
+    for field_ in fields(cls):
+        _rebuild_dataclass(field_.type, dict_, keys=keys + [field_.name])
+    if keys == []:
+        out = cls(**dict_)
+        return out
+    write_to_nested_dict(dict_, keys, cls(**read_from_nested_dict(dict_, keys)))
+
+
+def rebuild_dataclass(cls, dict_: dict):
+    """
+    dict_ must not contain dataclasses.
+    """
+    dict_ = deepcopy(dict_)
+    out = _rebuild_dataclass(cls, dict_)
+    return out
+
+
+def load_dataclass_from_json_file(cls: Any, path: Path | str):
+    dict_ = load_json(path)
+    out = rebuild_dataclass(cls, dict_)
+    return out
+
+
+def save_dataclass_to_json_file(obj, path):
+    dict_ = asdict(obj)
+    dump_json(dict_, path)
+
+
+def linspace(start: float, stop: float, num_points: int) -> list[float, ...]:
+    if num_points < 1:
+        raise ValueError("Need at least two points." f" Got: {num_points} points")
+    if num_points == 1:
+        if start != stop:
+            raise ValueError("If creating only one point, start must equal stop.")
+        out = [
+            start,
+        ]
+        return out
+    num_spaces = num_points - 1
+    spacing = (stop - start) / num_spaces
+    out = [start + i * spacing for i in range(num_points)]
+    assert len(out) == num_points
+    assert out[-1] == stop
+    return out
+
+
+@dataclass
+class Interval:
+    left: float
+    right: float
+
+    def as_tuple(self):
+        return (self.left, self.right)
+
+    def __iter__(self):
+        tuple_ = self.as_tuple()
+        out = tuple_.__iter__()
+        return out

b2_run_sim-0.0.1.dist-info/METADATA

@@ -0,0 +1,33 @@
+Metadata-Version: 2.4
+Name: b2_run_sim
+Version: 0.0.1
+Summary: Simulation helper for basf2.
+Project-URL: Homepage, https://github.com/ethanlee20/b2_sim
+Project-URL: Issues, https://github.com/ethanlee20/b2_sim/issues
+Author-email: Ethan Lee <elee20@hawaii.edu>
+License-Expression: MIT
+License-File: LICENSE
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Requires-Python: >=3.14
+Description-Content-Type: text/markdown
+
+After setting up your environment, run using
+
+```
+python3.14 <script> 
+```
+
+Steering files need to take the following command line arguments
+
+```
+simulation_steering_file.py <decay file path> <output file path> <number of events>
+```
+
+```
+reconstruction_steering_file.py <simulated events file path> <output file path>
+```
+
+Decay file should be specified as a template. i.e. put `{parameter_name}` in place of parameter values.
+
+See `example.py` script and `example` directory for more details.

b2_run_sim-0.0.1.dist-info/RECORD

@@ -0,0 +1,9 @@
+b2_run_sim/__init__.py,sha256=YSRdYapDNVneKGF_FV_6hhLH5qjA5RutVf91Tz9wLaI,156
+b2_run_sim/config.py,sha256=iDCzCSGDxt7MdSuvLJ8evZwYAuplDnbR6OkVcZEZFVs,4090
+b2_run_sim/setup.py,sha256=YI93StyqeutyRHgOcYReqhptUeJqKeWyhM-pjm2IHaI,3198
+b2_run_sim/submit.py,sha256=Md8uBvMzC5MASnnB5lLf4rgzQNqdOisztybWVNargSg,6342
+b2_run_sim/util.py,sha256=CH6uH2jCEXWG6wFoVQOAC-LGkYz9xKM5Ca6Zwc6ft2w,2899
+b2_run_sim-0.0.1.dist-info/METADATA,sha256=xrfmlVth_D_QiISRB_uRAAgPbYZyPSRdajmpTIyclEs,961
+b2_run_sim-0.0.1.dist-info/WHEEL,sha256=lCkmxWfQsSc9CfIClYeavTdQeEX2toPqufh9gI35EQA,87
+b2_run_sim-0.0.1.dist-info/licenses/LICENSE,sha256=rJ9-QKDD4ywOqu_JPCqozP6MHWLzR69JMCdICMitJno,1065
+b2_run_sim-0.0.1.dist-info/RECORD,,

b2_run_sim-0.0.1.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.31.0
+Root-Is-Purelib: true
+Tag: py3-none-any

b2_run_sim-0.0.1.dist-info/licenses/LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) Ethan Lee
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.