b2-run-sim 0.0.1__tar.gz

b2_run_sim-0.0.1/.flake8

@@ -0,0 +1,8 @@
+[flake8]
+max-line-length = 80
+extend-select = B950
+extend-ignore = E203,E501,E701
+exclude = 
+    .env,
+    __pycache__,
+    __init__.py,

b2_run_sim-0.0.1/.gitignore

@@ -0,0 +1,5 @@
+
+__pycache__
+.env
+.DS_Store
+example/data/*

b2_run_sim-0.0.1/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.

b2_run_sim-0.0.1/PKG-INFO

@@ -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/README.md

@@ -0,0 +1,19 @@
+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/example/dec.dec

@@ -0,0 +1,26 @@
+Alias MyB0 B0
+Alias MyAntiB0 anti-B0
+ChargeConj MyB0 MyAntiB0
+
+Alias MyK*0 K*0
+Alias MyAnti-K*0 anti-K*0
+ChargeConj MyK*0 MyAnti-K*0
+
+Decay Upsilon(4S)
+0.500  MyB0 anti-B0    VSS;
+0.500  B0 MyAntiB0    VSS;
+Enddecay
+
+Decay MyB0
+1.000 MyK*0 mu+ mu- BTOSLLNPR 0 0 {dC_7} 0 1 {dC_9} 0 2 {dC_10} 0;
+Enddecay
+
+CDecay MyAntiB0
+
+Decay MyK*0
+1.000 K+ pi-   VSS;
+Enddecay
+
+CDecay MyAnti-K*0
+
+End

b2_run_sim-0.0.1/example/setup.bash

@@ -0,0 +1,11 @@
+function my_script_main()
+{
+    local original_dir="$PWD"
+    cd /home/belle/sibid/belle2
+    source tools/b2setup
+    cd release
+    b2setup
+    cd $original_dir
+}
+
+my_script_main

b2_run_sim-0.0.1/example/steer_recon.py

@@ -0,0 +1,126 @@
+import sys
+
+import basf2 as b2
+import modularAnalysis as ma
+from variables import collections as vc
+from variables import utils as vu
+from variables import variables as vm
+
+# command line options
+
+input_file_paths = sys.argv[1]  # overwritten on the Grid
+output_file_path = sys.argv[2]  # choose something like recon.root
+
+print("\n-- Reconstruction Configuration --")
+print(f"Input file (overwritten on grid): {input_file_paths}")
+print(f"Output file (modified on grid): {output_file_path}")
+print("-----------------------------------\n")
+
+
+# begin processing
+
+main = b2.Path()
+
+
+def append_global_tag():
+    gt = ma.getAnalysisGlobaltag()
+    b2.conditions.append_globaltag(gt)
+
+
+def define_aliases():
+    vm.addAlias("mcMother_mcPDG", "mcMother(mcPDG)")
+    vm.addAlias("mcSister_0_mcPDG", "mcMother(mcDaughter(0, mcPDG))")
+    vm.addAlias("mcSister_1_mcPDG", "mcMother(mcDaughter(1, mcPDG))")
+    vm.addAlias("mcSister_2_mcPDG", "mcMother(mcDaughter(2, mcPDG))")
+    vm.addAlias("mcSister_3_mcPDG", "mcMother(mcDaughter(3, mcPDG))")
+    vm.addAlias("mcSister_4_mcPDG", "mcMother(mcDaughter(4, mcPDG))")
+    vm.addAlias("mcSister_5_mcPDG", "mcMother(mcDaughter(5, mcPDG))")
+    vm.addAlias("mcSister_6_mcPDG", "mcMother(mcDaughter(6, mcPDG))")
+    vm.addAlias("mcSister_7_mcPDG", "mcMother(mcDaughter(7, mcPDG))")
+    vm.addAlias("mcSister_8_mcPDG", "mcMother(mcDaughter(8, mcPDG))")
+    vm.addAlias("mcSister_9_mcPDG", "mcMother(mcDaughter(9, mcPDG))")
+
+
+def input_to_the_path():
+    ma.inputMdstList(
+        filelist=input_file_paths,
+        path=main,
+        environmentType="default",
+    )
+
+
+def reconstruct_generator_level():
+    ma.fillParticleListFromMC(decayString="K+:gen", cut="", path=main)
+    ma.fillParticleListFromMC(decayString="pi-:gen", cut="", path=main)
+    ma.fillParticleListFromMC(decayString="mu+:gen", cut="", path=main)
+
+    ma.reconstructMCDecay("K*0:gen =direct=> K+:gen pi-:gen", cut="", path=main)
+    ma.reconstructMCDecay("B0:gen =direct=> K*0:gen mu+:gen mu-:gen", cut="", path=main)
+
+
+def create_variable_lists():
+    std_vars = (
+        vc.deltae_mbc
+        + vc.inv_mass
+        + vc.mc_truth
+        + ["mcMother_mcPDG"]
+        + ["PDG"]
+        + [
+            "mcSister_0_mcPDG",
+            "mcSister_1_mcPDG",
+            "mcSister_2_mcPDG",
+            "mcSister_3_mcPDG",
+            "mcSister_4_mcPDG",
+            "mcSister_5_mcPDG",
+            "mcSister_6_mcPDG",
+            "mcSister_7_mcPDG",
+            "mcSister_8_mcPDG",
+            "mcSister_9_mcPDG",
+        ]
+        + vc.pid
+        + vc.kinematics
+        + vc.mc_kinematics
+        + ["dr", "dz"]
+        + ["theta", "thetaErr", "mcTheta"]
+        + ["isSignalAcceptBremsPhotons"]
+    )
+
+    Kstar0_vars = vu.create_aliases_for_selected(
+        list_of_variables=std_vars,
+        decay_string="B0 -> [^K*0 -> K+ pi-] mu+ mu-",
+    )
+
+    K_pi_vars = vu.create_aliases_for_selected(
+        list_of_variables=std_vars,
+        decay_string="B0 -> [K*0 -> ^K+ ^pi-] mu+ mu-",
+        prefix=["K_p", "pi_m"],
+    )
+
+    lepton_vars = vu.create_aliases_for_selected(
+        list_of_variables=std_vars,
+        decay_string="B0 -> [K*0 -> K+ pi-] ^mu+ ^mu-",
+        prefix=["mu_p", "mu_m"],
+    )
+
+    out = std_vars + Kstar0_vars + K_pi_vars + lepton_vars
+    return out
+
+
+def save_output(B0_vars, sim_level, file_path):
+    ma.variablesToNtuple(
+        decayString=f"B0:{sim_level}",
+        variables=B0_vars,
+        filename=file_path,
+        treename=sim_level,
+        path=main,
+    )
+
+
+append_global_tag()
+define_aliases()
+input_to_the_path()
+reconstruct_generator_level()
+B0_vars = create_variable_lists()
+save_output(B0_vars, "gen", output_file_path)
+b2.process(main)
+print(b2.statistics)

b2_run_sim-0.0.1/example/steer_sim.py

@@ -0,0 +1,53 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+
+# based off of Alexei's steering file
+
+
+import sys
+
+import basf2 as b2
+import mdst as mdst
+import glob as glob
+
+dec_file_path = sys.argv[1]
+out_file_path = sys.argv[2]
+num_events = int(sys.argv[3])
+
+print("\n-- Simulation Configuration --")
+print(f"Decay file: {dec_file_path}")
+print(f"Output file: {out_file_path}")
+print(f"Number of events: {num_events}")
+print("-----------------------\n")
+
+# background (collision) files
+bg = glob.glob(
+    "/group/belle2/dataprod/BGOverlay/early_phase3/release-06-00-05/overlay/BGx1/set0/*.root"
+)
+# background if running locally
+bg_local = glob.glob(
+    "/group/belle2/dataprod/BGOverlay/early_phase3/release-06-00-05/overlay/BGx1/set0/*.root"
+)
+
+# set database conditions (in addition to default)
+b2.conditions.prepend_globaltag("mc_production_MC15ri_a")
+
+print("Create path")
+main = b2.Path()
+
+# default to early phase 3 (exp=1003), run 0
+print("Add EventInfoSetter")
+main.add_module("EventInfoSetter", expList=1003, runList=0, evtNumList=num_events)
+
+# generate events from decfile
+print("Add EvtGenInput")
+main.add_module("EvtGenInput", userDECFile=b2.find_file(dec_file_path))
+
+# Finally add mdst output (file name overwritten on the grid)
+print("Add mdst output")
+mdst.add_mdst_output(path=main, filename=str(out_file_path))
+
+# process events and print call statistics
+print("Process")
+b2.process(path=main)
+print(b2.statistics)

b2_run_sim-0.0.1/example.py

@@ -0,0 +1,72 @@
+from helpers import (
+    Interval,
+    RunMetadata,
+    setup_run_dir,
+    submit_jobs,
+)
+
+# Setup
+
+data_dir = "example/data/"
+
+sim_steer_file_path = "example/steer_sim.py"
+recon_steer_file_path = "example/steer_recon.py"
+template_dec_file_path = "example/dec.dec"
+
+parameter_bounds = {
+    "dC_7": Interval(0, 0),
+    "dC_9": Interval(-2, 1),
+    "dC_10": Interval(0, 0),
+}
+
+
+# Create a training dataset by sampling from a grid of parameters
+
+training_run_metadata = RunMetadata(
+    split="train",
+    total_num_events=10_000,
+    num_trials=10,  # each trial represents a different parameter configuration
+    num_subtrials_per_trial=1,
+    parameter_bounds=parameter_bounds,
+    sampling_type="grid",
+    parameter_grid_counts={  # number of grid points along each axis
+        "dC_7": 1,
+        "dC_9": 10,
+        "dC_10": 1,
+    },
+)
+
+training_run_dir = setup_run_dir(
+    run_metadata=training_run_metadata,
+    parent_dir=data_dir,
+)
+
+submit_jobs(
+    run_dir=training_run_dir,
+    sim_steer_file_path=sim_steer_file_path,
+    recon_steer_file_path=recon_steer_file_path,
+    template_dec_file_path=template_dec_file_path,
+)
+
+
+# Create a validation dataset by randomly sampling parameters
+
+validation_run_metadata = RunMetadata(
+    split="val",
+    total_num_events=5_000,
+    num_trials=5,
+    num_subtrials_per_trial=2,  # number of files per parameter value set
+    parameter_bounds=parameter_bounds,
+    sampling_type="random",
+)
+
+validation_run_dir = setup_run_dir(
+    run_metadata=validation_run_metadata, parent_dir=data_dir
+)
+
+submit_jobs(
+    run_dir=validation_run_dir,
+    sim_steer_file_path=sim_steer_file_path,
+    recon_steer_file_path=recon_steer_file_path,
+    template_dec_file_path=template_dec_file_path,
+)

b2_run_sim-0.0.1/pyproject.toml

@@ -0,0 +1,23 @@
+[build-system]
+requires = ["hatchling >= 1.26"]
+build-backend = "hatchling.build"
+
+[project]
+name = "b2_run_sim"
+version = "0.0.1"
+authors = [
+  { name="Ethan Lee", email="elee20@hawaii.edu" },
+]
+description = "Simulation helper for basf2."
+readme = "README.md"
+requires-python = ">=3.14"
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "Operating System :: OS Independent",
+]
+license = "MIT"
+license-files = ["LICEN[CS]E*"]
+
+[project.urls]
+Homepage = "https://github.com/ethanlee20/b2_sim"
+Issues = "https://github.com/ethanlee20/b2_sim/issues"

b2_run_sim-0.0.1/src/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-0.0.1/src/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-0.0.1/src/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-0.0.1/src/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-0.0.1/src/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