optmapper 0.1.0__py3-none-any.whl

optmapper/macro.py

@@ -0,0 +1,136 @@
+"""Composition of the remage macro from a template and the production configuration."""
+
+from __future__ import annotations
+
+import importlib
+import inspect
+import string
+import tempfile
+from collections.abc import Callable, Iterator
+from contextlib import contextmanager
+from importlib import resources
+from pathlib import Path
+
+import pint
+
+from .config import Config, ConfigError, EmissionConfig, OptmapConfig
+
+ureg = pint.get_application_registry()
+
+
+def _quantity(value: str | float, default_unit: str, what: str) -> pint.Quantity:
+    try:
+        q = ureg.Quantity(value)
+    except (pint.PintError, ValueError) as e:
+        msg = f"cannot interpret {what} = {value!r} as a quantity: {e}"
+        raise ConfigError(msg) from e
+    return ureg.Quantity(q.m, default_unit) if q.dimensionless else q
+
+
+def confinement_commands(optmap: OptmapConfig) -> list[str]:
+    """Primary vertex confinement to the optical map volume(s) and bounds."""
+    volumes = [optmap.volume] if isinstance(optmap.volume, str) else optmap.volume
+    cmds = [
+        "/RMG/Generator/Confine Volume",
+        "/RMG/Generator/Confinement/ForceContainmentCheck",
+    ]
+
+    if optmap.shape != "none":
+        cmds += ["/RMG/Generator/Confinement/SamplingMode IntersectPhysicalWithGeometrical"]
+    cmds += [f"/RMG/Generator/Confinement/Physical/AddVolume {v}" for v in volumes]
+    if optmap.shape == "none":
+        return cmds
+
+    geo = "/RMG/Generator/Confinement/Geometrical"
+    center = [(lo + hi) / 2 for lo, hi in optmap.range_in_m]
+    size = [hi - lo for lo, hi in optmap.range_in_m]
+    cmds += [f"{geo}/AddSolid {optmap.shape.capitalize()}"]
+    cmds += [f"{geo}/CenterPosition{ax} {c:g} m" for ax, c in zip("XYZ", center, strict=True)]
+
+    if optmap.shape == "cylinder":
+        cmds += [
+            f"{geo}/Cylinder/InnerRadius {optmap.inner_radius_in_m:g} m",
+            f"{geo}/Cylinder/OuterRadius {size[0] / 2:g} m",
+            f"{geo}/Cylinder/Height {size[2]:g} m",
+        ]
+    else:
+        cmds += [f"{geo}/Box/{ax}Length {s:g} m" for ax, s in zip("XYZ", size, strict=True)]
+    return cmds
+
+
+def load_spectrum_function(spec: str) -> Callable[[str, bool], None]:
+    """Import a spectrum function from its dotted path, e.g. ``pygeomoptics.lar.g4gps_...``."""
+    module_name, _, func_name = spec.rpartition(".")
+    try:
+        func = getattr(importlib.import_module(module_name), func_name)
+    except (ImportError, AttributeError, ValueError) as e:
+        msg = f"cannot import emission spectrum function '{spec}': {e}"
+        raise ConfigError(msg) from e
+    if not callable(func) or len(inspect.signature(func).parameters) != 2:
+        msg = f"'{spec}' must be a function f(filename, output_macro), like pygeomoptics' g4gps_*"
+        raise ConfigError(msg)
+    return func
+
+
+@contextmanager
+def _optics_plugin(plugin: str | None) -> Iterator[None]:
+    """Apply a pygeom-optics plugin, restoring the original material properties afterwards."""
+    if plugin is None:
+        yield
+        return
+    from pygeomoptics import store  # noqa: PLC0415
+
+    store.load_user_material_code(plugin)
+    try:
+        yield
+    finally:
+        store.reset_all_to_original()
+
+
+def energy_commands(emission: EmissionConfig, optics_plugin: str | None = None) -> list[str]:
+    """GPS energy distribution of the optical photons.
+
+    The pygeom-optics `optics_plugin`, if any, is applied while generating the spectrum, so
+    that it sees the same material properties as the geometry.
+    """
+    if emission.gaussian is not None:
+        try:
+            with ureg.context("sp"):
+                mean = _quantity(emission.gaussian["mean"], "eV", "gaussian mean").to("eV")
+            sigma = _quantity(emission.gaussian["sigma"], "eV", "gaussian sigma").to("eV")
+        except pint.DimensionalityError as e:
+            msg = f"emission.gaussian: {e}"
+            raise ConfigError(msg) from e
+        return [
+            "/gps/ene/type     Gauss",
+            f"/gps/ene/mono     {mean.m:.6g} eV",
+            f"/gps/ene/sigma    {sigma.m:.6g} eV",
+        ]
+
+    assert emission.spectrum is not None
+    func = load_spectrum_function(emission.spectrum)
+    with _optics_plugin(optics_plugin), tempfile.TemporaryDirectory() as tmpdir:
+        fn = Path(tmpdir) / "spectrum.mac"
+        func(str(fn), True)
+        return fn.read_text().strip().splitlines()
+
+
+def render_macro(cfg: Config, n_events: int) -> str:
+    """Return the full remage macro for this production."""
+    if cfg.advanced.template is not None:
+        template = Path(cfg.advanced.template).read_text()
+    else:
+        template = (resources.files("optmapper") / "templates" / "optmap.mac").read_text()
+
+    try:
+        return string.Template(template).substitute(
+            name=cfg.name,
+            pre_init_commands="\n".join(cfg.advanced.pre_init_commands),
+            confinement_commands="\n".join(confinement_commands(cfg.optmap)),
+            energy_commands="\n".join(energy_commands(cfg.emission, cfg.geometry.optics_plugin)),
+            commands="\n".join(cfg.advanced.commands),
+            n_events=n_events,
+        )
+    except (KeyError, ValueError) as e:
+        msg = f"invalid placeholder in macro template: {e}"
+        raise ConfigError(msg) from e

optmapper/schedulers.py

@@ -0,0 +1,108 @@
+"""Job submission backends."""
+
+from __future__ import annotations
+
+import logging
+import shlex
+import subprocess
+from abc import ABC, abstractmethod
+from collections.abc import Mapping, Sequence
+from dataclasses import dataclass, field
+from pathlib import Path
+
+log = logging.getLogger(__name__)
+
+
+@dataclass
+class Job:
+    name: str
+    command: list[str]
+    log_file: Path
+    """Log file of the job, ``%j`` is replaced by the job ID."""
+    options: Mapping = field(default_factory=dict)
+    """Backend specific options, e.g. ``sbatch`` options for Slurm."""
+    dependencies: Sequence[str] = ()
+    """IDs of jobs that must have terminated (successfully or not) before this one starts."""
+
+
+class Scheduler(ABC):
+    def __init__(self, dry_run: bool = False):
+        self.dry_run = dry_run
+
+    @abstractmethod
+    def submit(self, job: Job) -> str:
+        """Submit `job` and return its ID."""
+
+
+class SlurmScheduler(Scheduler):
+    """Submit jobs with ``sbatch --wrap``, no job script files are written."""
+
+    @staticmethod
+    def sbatch_command(job: Job) -> list[str]:
+        cmd = [
+            "sbatch",
+            "--parsable",
+            f"--job-name={job.name}",
+            f"--output={job.log_file}",
+            f"--error={job.log_file}",
+        ]
+        for k, v in job.options.items():
+            if v is True:
+                cmd.append(f"--{k}")
+            elif v is not None and v is not False:
+                cmd.append(f"--{k}={v}")
+        if job.dependencies:
+            cmd.append(f"--dependency=afterany:{':'.join(job.dependencies)}")
+        cmd += ["--wrap", shlex.join(job.command)]
+        return cmd
+
+    def submit(self, job: Job) -> str:
+        cmd = self.sbatch_command(job)
+        if self.dry_run:
+            log.info("would run: %s", shlex.join(cmd))
+            return f"<{job.name}>"
+
+        log.debug("running: %s", shlex.join(cmd))
+        try:
+            res = subprocess.run(cmd, check=True, capture_output=True, text=True)
+        except FileNotFoundError as e:
+            msg = "sbatch not found, is this a Slurm cluster?"
+            raise RuntimeError(msg) from e
+        except subprocess.CalledProcessError as e:
+            msg = f"sbatch failed for job {job.name}: {e.stderr.strip()}"
+            raise RuntimeError(msg) from e
+        # --parsable prints "jobid[;cluster]"
+        return res.stdout.strip().split(";")[0]
+
+
+class LocalScheduler(Scheduler):
+    """Run jobs one after the other in the foreground, on the current machine.
+
+    Jobs are executed at submission time, so dependencies are always satisfied.
+    Like for ``afterany`` in Slurm, a job runs even if its dependencies failed.
+    """
+
+    def __init__(self, dry_run: bool = False):
+        super().__init__(dry_run)
+        self.failed: list[str] = []
+        self._count = 0
+
+    def submit(self, job: Job) -> str:
+        self._count += 1
+        job_id = str(self._count)
+        log_file = Path(str(job.log_file).replace("%j", job_id))
+        if self.dry_run:
+            log.info("would run: %s > %s", shlex.join(job.command), log_file)
+            return job_id
+
+        log.info("running job %s, log in %s", job.name, log_file)
+        with log_file.open("w") as f:
+            ret = subprocess.run(job.command, stdout=f, stderr=subprocess.STDOUT, check=False)
+        if ret.returncode != 0:
+            log.error("job %s failed with exit code %d", job.name, ret.returncode)
+            self.failed.append(job.name)
+        return job_id
+
+
+def get_scheduler(name: str, dry_run: bool = False) -> Scheduler:
+    return {"slurm": SlurmScheduler, "local": LocalScheduler}[name](dry_run=dry_run)

optmapper/sites/local.yaml

@@ -0,0 +1,3 @@
+# run all jobs one after the other on the current machine, in the foreground.
+# useful for testing and for small productions on a workstation.
+scheduler: local

optmapper/sites/nersc.yaml

@@ -0,0 +1,23 @@
+# NERSC Perlmutter CPU nodes, LEGEND allocation.
+scheduler: slurm
+scratch_dir: $PSCRATCH/optmapper
+slurm:
+  node:
+    account: m2676
+    qos: regular
+    constraint: cpu
+    licenses: cfs,scratch
+    nodes: 1
+    ntasks: 1
+    ntasks-per-node: 1
+    cpus-per-task: 256
+    time: "04:00:00"
+  # merging maps needs a few cores only: use the shared QOS instead of a full node
+  merge:
+    account: m2676
+    qos: shared
+    constraint: cpu
+    licenses: cfs,scratch
+    ntasks: 1
+    cpus-per-task: 16
+    time: "01:00:00"

optmapper/sites/slurm.yaml

@@ -0,0 +1,12 @@
+# generic Slurm cluster. Start from this preset when porting to a new facility,
+# options under slurm.node and slurm.merge are passed verbatim to sbatch.
+scheduler: slurm
+slurm:
+  node:
+    nodes: 1
+    ntasks: 1
+    exclusive: true
+  merge:
+    nodes: 1
+    ntasks: 1
+    cpus-per-task: 8

optmapper/templates/optmap.mac

@@ -0,0 +1,30 @@
+# remage macro for optical map production, generated by optmapper
+# production: ${name}
+
+/RMG/Processes/OpticalPhysics true
+/RMG/Processes/OpticalPhysicsMaxOneWLSPhoton true
+
+/RMG/Geometry/RegisterDetectorsFromGDML Optical
+
+/RMG/Manager/PrintProgressModulo 100000
+/RMG/Geometry/GDMLDisableOverlapCheck true
+
+${pre_init_commands}
+
+/run/initialize
+
+/RMG/Output/NtuplePerDetector false
+/RMG/Output/Vertex/StorePrimaryParticleInformation false
+/RMG/Output/Vertex/StoreSinglePrecisionEnergy
+/RMG/Output/Vertex/StoreSinglePrecisionPosition
+
+${confinement_commands}
+
+/RMG/Generator/Select GPS
+/gps/particle     opticalphoton
+${energy_commands}
+/gps/ang/type     iso
+
+${commands}
+
+/run/beamOn ${n_events}

optmapper/work.py

@@ -0,0 +1,240 @@
+"""Worker process, runs on the compute nodes."""
+
+from __future__ import annotations
+
+import argparse
+import logging
+import os
+import re
+import resource
+import shlex
+import shutil
+import subprocess
+import time
+from concurrent.futures import ThreadPoolExecutor
+from contextlib import contextmanager
+from pathlib import Path
+
+import dbetto
+
+from .config import Config
+from .log_utils import setup_log
+
+log = logging.getLogger(__name__)
+
+
+@contextmanager
+def _step(what: str):
+    log.info("%s...", what)
+    start = time.monotonic()
+    yield
+    log.info("%s: done in %.0f s", what, time.monotonic() - start)
+
+
+def _natural_key(path: Path) -> list:
+    return [int(t) if t.isdigit() else t for t in re.split(r"(\d+)", path.name)]
+
+
+def _available_cpus() -> int:
+    if "SLURM_CPUS_ON_NODE" in os.environ:
+        return int(os.environ["SLURM_CPUS_ON_NODE"])
+    return len(os.sched_getaffinity(0))
+
+
+def merge_maps(cfg: Config, inputs: list[Path], output: Path, workdir: Path) -> None:
+    """Merge optical maps into `output`, temporary files are written to `workdir`."""
+    from reboost.optmap.create import merge_optical_maps  # noqa: PLC0415
+
+    output.parent.mkdir(parents=True, exist_ok=True)
+    tmp = workdir / f".{output.name}.part"
+    tmp.unlink(missing_ok=True)
+    if len(inputs) == 1:
+        shutil.copyfile(inputs[0], tmp)
+    else:
+        merge_optical_maps(
+            [str(p) for p in inputs],
+            str(tmp),
+            cfg.optmap.reboost_settings(),
+            n_procs=cfg.processing.merge_procs,
+        )
+    shutil.move(tmp, output)
+
+
+def _reboost_create_args(cfg: Config, workdir: Path) -> list[str]:
+    """Options of ``reboost-optmap create``, its input files are written to `workdir`."""
+    settings = workdir / "optmap-settings.json"
+    dbetto.utils.write_dict(cfg.optmap.reboost_settings(), str(settings))
+    args = [
+        *("--bufsize", str(cfg.processing.bufsize), "create"),
+        *("--settings", str(settings), "--geom", str(cfg.gdml_file)),
+        *("--n-procs", str(cfg.processing.procs_per_map)),
+    ]
+    if cfg.optmap.detectors is not None:
+        detectors = workdir / "optmap-detectors.json"
+        dbetto.utils.write_dict(cfg.optmap.detectors, str(detectors))
+        args += ["--detectors", str(detectors)]
+    return args
+
+
+def _create_map(create_args: list[str], inputs: list[Path], output: Path) -> None:
+    """Create a map with ``reboost-optmap``, in a separate process as it spawns its own pool."""
+    cmd = ["reboost-optmap", *create_args, "--", *map(str, inputs), str(output)]
+    res = subprocess.run(cmd, capture_output=True, text=True, check=False)
+    if res.returncode != 0:
+        msg = f"map creation failed for {output.name}:\n{res.stdout}{res.stderr}"
+        raise RuntimeError(msg)
+    log.info("created %s from %d stp files", output.name, len(inputs))
+
+
+def run_node(cfg: Config, index: int) -> None:
+    """Simulate photons on this node and build the node optical map."""
+    from .macro import render_macro  # noqa: PLC0415
+
+    job_id = os.environ.get("SLURM_JOB_ID", str(os.getpid()))
+    scratch_base = os.path.expandvars(
+        cfg.execution.scratch_dir or str(Path(cfg.output_dir) / "scratch")
+    )
+    scratch = Path(scratch_base) / cfg.name / f"node{index:04d}-{job_id}"
+    # a requeued Slurm job keeps its ID, do not pick up files from the previous attempt
+    shutil.rmtree(scratch, ignore_errors=True)
+    scratch.mkdir(parents=True)
+    os.environ.setdefault("NUMBA_CACHE_DIR", str(scratch / ".numba-cache"))
+
+    nprocs = cfg.statistics.processes_per_node or _available_cpus()
+    n_primaries = cfg.statistics.primaries_per_process
+    log.info(
+        "node %d (job %s): %d run(s) x %d remage processes x %.3g primaries, scratch in %s",
+        index,
+        job_id,
+        cfg.statistics.runs_per_node,
+        nprocs,
+        n_primaries,
+        scratch,
+    )
+
+    macro = scratch / f"{cfg.name}.mac"
+    macro.write_text(render_macro(cfg, n_primaries))
+    if index == 0:
+        shutil.copyfile(macro, Path(cfg.output_dir) / macro.name)
+
+    proc = cfg.processing
+    map_dir = scratch / "maps"
+    map_dir.mkdir()
+    create_args = _reboost_create_args(cfg, scratch)
+
+    for run in range(cfg.statistics.runs_per_node):
+        stp_dir = scratch / "stp" / f"run{run:03d}"
+        stp_dir.mkdir(parents=True)
+
+        cmd = [
+            "remage",
+            *cfg.advanced.remage_args,
+            "--gdml-files",
+            str(cfg.gdml_file),
+            "--output-file",
+            str(stp_dir / f"{cfg.name}-node{index:04d}-run{run:03d}-tier_stp.lh5"),
+            "--procs",
+            str(nprocs),
+            "--flat-output",
+            "--",
+            str(macro),
+        ]
+        with _step(f"run {run}: remage simulation"):
+            log.debug("running: %s", shlex.join(cmd))
+            subprocess.run(cmd, check=True)
+
+        stp_files = sorted(stp_dir.glob("*.lh5"), key=_natural_key)
+        if not stp_files:
+            msg = f"remage did not produce any output file in {stp_dir}"
+            raise RuntimeError(msg)
+
+        chunks = [
+            stp_files[i : i + proc.stp_files_per_map]
+            for i in range(0, len(stp_files), proc.stp_files_per_map)
+        ]
+        with (
+            _step(f"run {run}: creating {len(chunks)} map(s) from {len(stp_files)} stp files"),
+            ThreadPoolExecutor(proc.parallel_maps) as pool,
+        ):
+            futures = [
+                pool.submit(_create_map, create_args, chunk, map_dir / f"run{run:03d}-{k:04d}.lh5")
+                for k, chunk in enumerate(chunks)
+            ]
+            for f in futures:
+                f.result()
+
+        if proc.keep_stp:
+            dest = Path(cfg.output_dir) / "stp" / f"node{index:04d}"
+            with _step(f"run {run}: copying stp files to {dest}"):
+                dest.mkdir(parents=True, exist_ok=True)
+                for stp_file in stp_files:
+                    shutil.copy2(stp_file, dest)
+        shutil.rmtree(stp_dir)
+
+    output = cfg.node_map(index)
+    with _step(f"merging intermediate maps into {output}"):
+        merge_maps(cfg, sorted(map_dir.glob("*.lh5"), key=_natural_key), output, scratch)
+
+    shutil.rmtree(scratch)
+    log.info(
+        "node %d done, max RSS of child processes: %.1f GiB",
+        index,
+        resource.getrusage(resource.RUSAGE_CHILDREN).ru_maxrss / 1024**2,
+    )
+
+
+def run_merge(cfg: Config) -> None:
+    """Merge the node maps into the final map, tolerating failed nodes."""
+    nodes = [cfg.node_map(i) for i in range(cfg.statistics.nodes)]
+    found = [p for p in nodes if p.is_file()]
+    missing = [p for p in nodes if not p.is_file()]
+    if not found:
+        msg = f"all node jobs failed, no node map to merge: see the node job logs in {cfg.log_dir}"
+        raise RuntimeError(msg)
+    if missing:
+        log.warning(
+            "%d of %d node maps are missing (failed jobs?), see the logs in %s: %s",
+            len(missing),
+            len(nodes),
+            cfg.log_dir,
+            ", ".join(p.name for p in missing),
+        )
+
+    with _step(f"merging {len(found)} node maps into {cfg.final_map}"):
+        merge_maps(cfg, found, cfg.final_map, cfg.final_map.parent)
+
+
+def work_cli(argv: list[str] | None = None) -> None:
+    parser = argparse.ArgumentParser(
+        prog="optmapper-work",
+        description="%(prog)s: optical map production worker, usually started by optmapper",
+    )
+    parser.add_argument("--verbose", "-v", action="count", default=0, help="increase verbosity")
+    subparsers = parser.add_subparsers(dest="command", required=True)
+
+    def _add_config(p):
+        p.add_argument(
+            "--config", required=True, help="resolved production configuration file (JSON)"
+        )
+
+    node_parser = subparsers.add_parser("node", help="run the full production on one node")
+    _add_config(node_parser)
+    node_parser.add_argument("--index", type=int, required=True, help="node index")
+
+    merge_parser = subparsers.add_parser("merge", help="merge the node maps into the final map")
+    _add_config(merge_parser)
+
+    args = parser.parse_args(argv)
+    setup_log((None, logging.INFO, logging.DEBUG)[min(args.verbose, 2)])
+
+    cfg = Config.load(args.config)
+    os.environ.update(cfg.execution.env)
+
+    if args.command == "node":
+        run_node(cfg, args.index)
+    elif args.command == "merge":
+        run_merge(cfg)
+
+
+if __name__ == "__main__":
+    work_cli()

optmapper-0.1.0.dist-info/METADATA

@@ -0,0 +1,58 @@
+Metadata-Version: 2.4
+Name: optmapper
+Version: 0.1.0
+Summary: Production of LEGEND optical maps on batch systems
+Author-email: Luigi Pertoldi <gipert@pm.me>
+Maintainer: The LEGEND Collaboration
+License-Expression: GPL-3.0
+Project-URL: Homepage, https://github.com/legend-exp/optmapper
+Project-URL: Bug Tracker, https://github.com/legend-exp/optmapper/issues
+Classifier: Intended Audience :: Science/Research
+Classifier: Operating System :: POSIX
+Classifier: Operating System :: Unix
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Topic :: Scientific/Engineering
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: colorlog
+Requires-Dist: dbetto
+Requires-Dist: legend-pygeom-optics>=0.15.0
+Requires-Dist: pint
+Requires-Dist: reboost>=1.4
+Provides-Extra: all
+Requires-Dist: optmapper[docs,test]; extra == "all"
+Provides-Extra: docs
+Requires-Dist: furo; extra == "docs"
+Requires-Dist: myst-parser; extra == "docs"
+Requires-Dist: sphinx; extra == "docs"
+Requires-Dist: sphinx-copybutton; extra == "docs"
+Provides-Extra: test
+Requires-Dist: pre-commit; extra == "test"
+Requires-Dist: pytest>=6.0; extra == "test"
+Requires-Dist: pytest-cov; extra == "test"
+Dynamic: license-file
+
+# optmapper
+
+![GitHub tag (latest by date)](https://img.shields.io/github/v/tag/legend-exp/optmapper?logo=git)
+[![GitHub Workflow Status](https://img.shields.io/github/checks-status/legend-exp/optmapper/main?label=main%20branch&logo=github)](https://github.com/legend-exp/optmapper/actions)
+[![pre-commit](https://img.shields.io/badge/pre--commit-enabled-brightgreen?logo=pre-commit&logoColor=white)](https://github.com/pre-commit/pre-commit)
+[![Codecov](https://img.shields.io/codecov/c/github/legend-exp/optmapper?logo=codecov)](https://app.codecov.io/gh/legend-exp/optmapper)
+![GitHub issues](https://img.shields.io/github/issues/legend-exp/optmapper?logo=github)
+![GitHub pull requests](https://img.shields.io/github/issues-pr/legend-exp/optmapper?logo=github)
+![License](https://img.shields.io/github/license/legend-exp/optmapper)
+[![Read the Docs](https://img.shields.io/readthedocs/optmapper?logo=readthedocs)](https://optmapper.readthedocs.io)
+
+_optmapper_ produces LEGEND optical maps on batch systems. An optical map gives,
+for each position in a volume (e.g. the liquid argon), the probability that an
+optical photon emitted there is detected by each optical detector. Building one
+requires simulating billions of photons with
+[remage](https://remage.readthedocs.io/en/stable/) and histogramming the result
+with [reboost](https://reboost.readthedocs.io/en/stable/). _optmapper_ takes a
+single configuration file and runs the whole chain on one or many compute nodes.
+
+For more information see our dedicated
+[documentation](https://optmapper.readthedocs.io/en/stable/)!

optmapper-0.1.0.dist-info/RECORD

@@ -0,0 +1,19 @@
+optmapper/__init__.py,sha256=a14TEcUQN9VjmFAsSR9oU6SgZbolz34DNqxA96m1924,167
+optmapper/_version.py,sha256=n_5vdJsPNu7wZ57LGuRL585uvll-hiuvZUBWzdG0RQU,520
+optmapper/cli.py,sha256=jWpd74k-BhIU1PWRQBCo4-gZzQgCrg3mA0qLFXIp_ow,5147
+optmapper/config.py,sha256=xCbslmxxZLqO_6rJmqGwym-IRDIPVA8O-rdwQSOjJ44,13208
+optmapper/geometry.py,sha256=7Izc1WedlnR6q2VfkZ1fJJF6gY4MWhgD24w5nPMXOTk,1833
+optmapper/log_utils.py,sha256=Cd5vFu3STrBzvQmkgpICLpnjteGO00BD--2UDITqQzE,768
+optmapper/macro.py,sha256=ROLRiVLk3dKDlKyB8kSyi9tE8dQlwyNzf3IhMe210g0,5257
+optmapper/schedulers.py,sha256=2iDD54A_gYYQj-YFwIX7KEVDBtC7YeTPHIViZgqQemk,3643
+optmapper/work.py,sha256=PMGI6mXobjNmV__EGveA_FE7AiuZdW9sNEJHLsJtKMY,8417
+optmapper/sites/local.yaml,sha256=-E6i1vzSOJYwOWlrZNvMyqALvJ56RlVS1xQLPg459r4,160
+optmapper/sites/nersc.yaml,sha256=-HBeTnACwZJcc-LLnktVEnzqIuj9ih0vFV9bk69j0UU,520
+optmapper/sites/slurm.yaml,sha256=6G2SR52GhvP3ZwhFvtAU1SSi1ZrYQtEok5QOV1_jHzI,290
+optmapper/templates/optmap.mac,sha256=hFYKvjtnZgUpqgk-6hsFsWdhYZL3c7k3Lo2QUEdLYjU,697
+optmapper-0.1.0.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
+optmapper-0.1.0.dist-info/METADATA,sha256=j1Uab-Bnv5fy185ynKUranJ5NSEo2RJhX9vK_qM1vow,2915
+optmapper-0.1.0.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+optmapper-0.1.0.dist-info/entry_points.txt,sha256=DEM7sd9pnWOrNAhDHSFxeoBC9OfKhZtHnscRvcy4oeg,99
+optmapper-0.1.0.dist-info/top_level.txt,sha256=paE_szQAS0XPUNrxr6QJCcIb7JKN96ve-dX-Uls3Ers,10
+optmapper-0.1.0.dist-info/RECORD,,

optmapper-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (84.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

optmapper-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+optmapper = optmapper.cli:optmapper_cli
+optmapper-work = optmapper.work:work_cli