Command line tools

Dockerfile

-FROM rootproject/root:6.24.06-ubuntu20.04
+FROM rootproject/root:6.26.02-ubuntu22.04
 
 RUN  apt-get -qq update && \
-     apt-get -qq install python3-pip libbz2-dev git
+     apt-get -qq install python3.10 python3.10-distutils python3-pip libbz2-dev git 
 
 RUN  cd /opt && \
      wget -O RootTuple-1.0.0.tar.gz https://roottuple.hepforge.org/downloads?f=RootTuple-1.0.0.tar.gz && \
@@ -31,6 +31,7 @@ RUN cd /km3buu && \
     pip3 install --upgrade pip && \
     pip3 install setuptools-scm && \
     pip3 install pytest-runner && \
+    pip3 install conan && \
     pip3 install -e . && \
     pip3 install -e ".[dev]" && \
     pip3 install -e ".[extras]"

km3buu/cmd.py

+#!/usr/bin/env python
+# coding=utf-8
+# Filename: cmd.py
+# Author: Johannes Schumann <jschumann@km3net.de>
+
+import numpy as np
+import argparse
+from pathlib import Path
+from tempfile import TemporaryDirectory
+from os.path import join
+
+from km3buu.jobcard import generate_neutrino_jobcard
+from km3buu.ctrl import run_jobcard
+from km3buu.geometry import CanVolume, SphericalVolume
+from km3buu.output import GiBUUOutput, write_detector_file
+
+ARGPARSE_DESC = {
+    "prog": "km3buu",
+    "description": "Runscript for GIBUU/KM3BUU",
+    "epilog": "https://git.km3net.de/simulation/km3buu"
+}
+
+ARGPARSE_GENERAL_PARAMS = [{
+    "option_strings": ["--events", "-n"],
+    "dest": "events",
+    "type": int,
+    "help": "Number of events which are simulated",
+    "required": True
+}, {
+    "option_strings": ["--flavor", "-f"],
+    "dest": "flavor",
+    "choices": ["electron", "muon", "tau"],
+    "help": "Simulated neutrino flavor",
+    "required": True
+}, {
+    "option_strings": ["--interaction", "-i"],
+    "dest": "interaction",
+    "choices": ["nc", "cc"],
+    "help": "The current type of the weak interaction",
+    "required": True
+}, {
+    "option_strings": ["--target", "-t"],
+    "dest": "target",
+    "nargs": 2,
+    "type": int,
+    "help": "The number of nucleons/protons in the target nucleus",
+    "metavar": ("A", "Z"),
+    "required": True
+}, {
+    "option_strings": ["--geometry", "-g"],
+    "dest":
+    "geometry",
+    "choices": ["no", "can", "sphere"],
+    "default":
+    "no",
+    "help":
+    "Type of detector enviroment geometry should be used"
+}, {
+    "option_strings": ["--center", "-c"],
+    "dest":
+    "center",
+    "type":
+    float,
+    "nargs":
+    3,
+    "metavar": ("x", "y", "z"),
+    "default": [0, 0, 0],
+    "help":
+    "Center (offset) if a geometry is used (otherwise ignored)"
+}, {
+    "option_strings": ["--dimensions", "-d"],
+    "dest":
+    "dimensions",
+    "type":
+    float,
+    "nargs":
+    "*",
+    "help":
+    "Dimensions of the geometry; sphere -> -d <radius> / can -> -d <radius> <zmin> <zmax>"
+}, {
+    "option_strings": ["--output-dir", "-o"],
+    "dest": "output",
+    "type": Path,
+    "default": Path("."),
+    "help": "Output directory"
+}, {
+    "option_strings": ["--run", "-r"],
+    "dest": "runnumber",
+    "type": int,
+    "default": 1,
+    "help": "Run number to use"
+}, {
+    "option_strings": ["--gibuuparams", "-p"],
+    "dest":
+    "gibuuparams",
+    "type":
+    Path,
+    "help":
+    "JSON file for modified GiBUU namelist params"
+}, {
+    "option_strings": ["--taupropagation"],
+    "dest": "tauprop",
+    "action": argparse.BooleanOptionalAction,
+    "help": "Do tau propagation",
+    "default": False
+}]
+
+
+def main():
+    #
+    # ARG PARSE
+    #
+    parser = argparse.ArgumentParser(**ARGPARSE_DESC)
+    for kwargs in ARGPARSE_GENERAL_PARAMS:
+        args = kwargs.pop("option_strings")
+        parser.add_argument(*args, **kwargs)
+    subparsers = parser.add_subparsers(title="modes", help="Modes")
+    # Single Energy
+    single_energy_parser = subparsers.add_parser(
+        "single", help="Run in single energy mode")
+    single_energy_parser.add_argument("-e",
+                                      "--energy",
+                                      dest="energy",
+                                      type=float,
+                                      help="Neutrino energy [GeV]",
+                                      required=True)
+    # Energy Range
+    energy_range_parser = subparsers.add_parser(
+        "range", help="Run in energy range mode")
+    energy_range_parser.add_argument("-e",
+                                     "--energy",
+                                     dest="energy",
+                                     type=float,
+                                     nargs=2,
+                                     help="Neutrino energy range [GeV]",
+                                     metavar=("Emin", "Emax"),
+                                     required=True)
+    energy_range_parser.add_argument(
+        "-y",
+        "--gamma",
+        dest="flux",
+        type=float,
+        help="The power law index of the simulated neutrino flux",
+        default=0.0)
+    args = parser.parse_args()
+
+    if type(args.energy) is float:
+        descriptor = "{0}_{1}_{2}GeV_A{3}Z{4}".format(
+            args.flavor, args.interaction, args.energy,
+            args.target[0].args.target[1])
+    else:
+        descriptor = "{0}_{1}_{2}-{3}GeV_A{4}Z{5}_power_law_{6:.1f}".format(
+            args.flavor, args.interaction, args.energy[0], args.energy[1],
+            args.target[0], args.target[1], args.flux)
+
+    gibuu_dir = Path(join(args.output, descriptor))
+    gibuu_dir.mkdir(exist_ok=True)
+    #
+    # FLUX
+    #
+    fluxfile = None
+
+    if not np.isclose(args.flux, 0.):
+        energies = np.linspace(args.energy[0], args.energy[1], 1000)
+        flux = 1e3 * energies**args.flux
+        fluxfile = join(args.output, "flux.dat")
+        np.savetxt(fluxfile, np.c_[energies, flux])
+
+    jc = generate_neutrino_jobcard(args.events,
+                                   args.interaction,
+                                   args.flavor,
+                                   tuple(args.energy),
+                                   args.target,
+                                   fluxfile=fluxfile,
+                                   do_decay=True)
+
+    jc["neutrinoanalysis"]["outputEvents"] = True
+    jc["neutrinoanalysis"]["inclusiveAnalysis"] = False
+
+    if args.gibuuparams:
+        with open(args.gibuuparams) as f:
+            additional_args = json.load(f)
+
+        for k1, param_dct in additional_args.items():
+            for k2, v in param_dct.items():
+                jc[k1][k2] = v
+
+    run_jobcard(jc, gibuu_dir)
+
+    fobj = GiBUUOutput(gibuu_dir)
+
+    if args.geometry == 'no':
+        volume = NoGeometry()
+    elif args.geometry == 'sphere':
+        volume = SphericalVolume(args.dimensions[0], tuple(args.center))
+    elif args.geometry == 'can':
+        kwargs = {"detector_center": tuple(args.center)}
+        if args.dimensions:
+            kwargs["radius"] = arg.dimensions[0]
+            kwargs["zmin"] = arg.dimensions[1]
+            kwargs["zmax"] = arg.dimensions[2]
+        volume = CanVolume(**kwargs)
+    run_descriptor = ""
+    if args.runnumber:
+        run_descriptor = "run_{0}".format(args.runnumber)
+
+    outfilename = join(args.output,
+                       "km3buu_" + run_descriptor + descriptor + ".root")
+
+    write_detector_file(fobj,
+                        geometry=volume,
+                        ofile=outfilename,
+                        no_files=args.target[0],
+                        propagate_tau=args.tauprop)
+
+
+if __name__ == '__main__':
+    main()

km3buu/jobcard.py

@@ -121,7 +121,7 @@ def generate_neutrino_jobcard(events,
     energy: float, tuple
         Initial energy or energy range (emin, emax) of the primary neutrino in GeV
     target: (int, int)
-        (Z, A) describing the target nucleon
+        (A, Z) describing the target nucleon
     write_pert: boolean (default: True)
         Write perturbative particles
     write_real: boolean (default: False)
@@ -144,8 +144,8 @@ def generate_neutrino_jobcard(events,
     jc["neutrino_induced"]["process_ID"] = PROCESS_LOOKUP[process.lower()]
     jc["neutrino_induced"]["flavor_ID"] = FLAVOR_LOOKUP[flavour.lower()]
     # TARGET
-    jc["target"]["target_Z"] = target[0]
-    jc["target"]["target_A"] = target[1]
+    jc["target"]["target_Z"] = target[1]
+    jc["target"]["target_A"] = target[0]
     # EVENTS
     run_events = int(100000 / target[1])
     if events < run_events:

km3buu/tests/test_jobcard.py

@@ -69,7 +69,7 @@ class TestNeutrinoEnergyRangeJobcard(unittest.TestCase):
             1000,
             "CC",
             "electron", (self.test_energy_min, self.test_energy_max),
-            (self.test_Z, self.test_A),
+            (self.test_A, self.test_Z),
             do_decay=self.do_decay,
             photon_propagation=self.photon_propagation_flag,
             fluxfile=self.test_fluxfile.name,
@@ -119,7 +119,7 @@ class TestNeutrinoSingleEnergyJobcard(unittest.TestCase):
             1000,
             "CC",
             "electron",
-            self.test_energy, (self.test_Z, self.test_A),
+            self.test_energy, (self.test_A, self.test_Z),
             do_decay=self.do_decay,
             photon_propagation=self.photon_propagation_flag,
             fluxfile=self.test_fluxfile.name,

scripts/runner.py

-#!/usr/bin/env python
-# coding=utf-8
-# Filename: runner.py
-# Author: Johannes Schumann <jschumann@km3net.de>
-"""
-
-Usage:
-    runner.py fixed --energy=ENERGY --events=EVENTS (--CC|--NC) (--electron|--muon|--tau) --target-a=TARGETA --target-z=TARGETZ (--sphere=RADIUS | --can) [--outdir=OUTDIR] [--km3netfile=OUTFILE]
-    runner.py range --energy-min=ENERGYMIN --energy-max=ENERGYMAX --events=EVENTS (--CC|--NC) (--electron|--muon|--tau) --target-a=TARGETA --target-z=TARGETZ (--sphere=RADIUS | --can) [--flux=FLUXFILE] [--outdir=OUTDIR] [--km3netfile=OUTFILE]
-    runner.py (-h | --help)
-
-Options:
-    -h --help   Show this screen.
-    --energy=ENERGY                 Neutrino energy [type: float]                   
-    --energy-min=ENERGYMIN          Neutrino energy [type: float]                   
-    --energy-max=ENERGYMAX          Neutrino energy [type: float]                   
-    --events=EVENTS                 Number of simulated events [type: int]          
-    --target-a=TARGETA              Target nucleons [type: int]                     
-    --target-z=TARGETZ              Target protons [type: int]                      
-    --sphere=RADIUS                 Radius of the sphere volume in metres [type: float]
-    --can                           Use CAN with std. dimensions
-    --flux=FLUXFILE                 Flux definition [type: path]
-    --outdir=OUTDIR                 Output directory [type: path]
-    (--CC | --NC)                   Interaction type
-    (--electron | --muon | --tau)   Neutrino flavor
-"""
-from type_docopt import docopt
-from pathlib import Path
-from tempfile import TemporaryDirectory
-from os.path import join
-
-from km3buu.jobcard import generate_neutrino_jobcard
-from km3buu.ctrl import run_jobcard
-from km3buu.geometry import CanVolume, SphericalVolume
-from km3buu.output import GiBUUOutput, write_detector_file
-
-
-def main():
-    args = docopt(__doc__, types={'path': Path})
-
-    events = args["--events"]
-    energy = args["--energy"] if args["fixed"] else (args["--energy-min"],
-                                                     args["--energy-max"])
-    interaction = "CC" if args["--CC"] else "NC"
-    flavour = "electron" if args["--electron"] else (
-        "muon" if args["--muon"] else "tau")
-    target = (args["--target-z"], args["--target-a"])
-
-    jc = generate_neutrino_jobcard(events,
-                                   interaction,
-                                   flavour,
-                                   energy,
-                                   target,
-                                   fluxfile=args["--flux"])
-
-    outdir = args["--outdir"] if args["--outdir"] else TemporaryDirectory()
-    outdirname = outdir if args["--outdir"] else outdir.name
-
-    run_jobcard(jc, outdirname)
-
-    fobj = GiBUUOutput(outdir)
-
-    volume = SphericalVolume(
-        args["--sphere"]) if args["--sphere"] else CanVolume()
-
-    if args["fixed"]:
-        descriptor = "{0}_{1}_{2}GeV_A{3}Z{4}".format(flavour, interaction,
-                                                      energy, target[0],
-                                                      target[1])
-    else:
-        descriptor = "{0}_{1}_{2}-{3}GeV_A{4}Z{5}".format(
-            flavour, interaction, energy[0], energy[1], target[0], target[1])
-
-    if args["--km3netfile"]:
-        outfilename = args["--km3netfile"]
-    else:
-        outfilename = "km3buu_" + descriptor + ".root"
-        if args["--outdir"]:
-            outfilename = join(args["--outdir"], outfilename)
-
-    write_detector_file(fobj, geometry=volume, ofile=outfilename)
-
-
-if __name__ == '__main__':
-    main()

setup.cfg

@@ -45,8 +45,8 @@ install_requires =
     particle
     click
     f90nml
-    uproot>=4.0.0
-    awkward>=1.4.0
+    uproot>=4.0.0,<5.0.0
+    awkward>=1.4.0,<2.0.0
     pandas
     mendeleev
     proposal>=7.1.1