Full/reference/best-effort reconstruction

.gitlab-ci.yml

@@ -53,6 +53,7 @@ common:detector:
     - ln -s "${LOCAL_DATA_PATH}/sim_output" sim_output
     - ln -s "${LOCAL_DATA_PATH}/datasets/data" data
     - ls -lrtha
+  interruptible: true
 
 include: 
   - local: 'benchmarks/ecal/config.yml'
@@ -61,11 +62,12 @@ include:
   - local: 'benchmarks/rich/config.yml'
   - local: 'benchmarks/imaging_ecal/config.yml'
   - local: 'benchmarks/imaging_shower_ML/config.yml'
+  - local: 'benchmarks/full/config.yml'
 
 
 final_report:
   stage: finish
-  needs: ["ecal_collect", "tracking_central_electrons","clustering:results"]
+  needs: ["ecal_collect", "tracking_central_electrons", "clustering:results", "full:results"]
   script:
     # disabled while we address ACTS issues
     #- mkdir -p results/views && cd results/views && bash ../../bin/download_views

benchmarks/full/config.yml

+full:reco:
+  extends: .rec_benchmark
+  stage: run
+  timeout: 24 hours
+  script:
+    - bash benchmarks/full/full_reconstruction.sh -t full_${REGIONS}_${PARTICLES} -n 100 -p "${PARTICLES}" --pmin 1 --pmax 20 --region "${REGIONS}"
+  parallel:
+    matrix:
+      - REGIONS: ["forward", "barrel", "backward"]
+        PARTICLES: ["electron", "pion+", "pion-", "kaon+", "kaon-", "proton", "neutron", "positron", "photon"]
+        #PARTICLES: ["electron", "pion0", "pion+", "pion-", "kaon0S", "kaon0L", "kaon+", "kaon-", "proton", "neutron", "positron", "photon"]
+
+full:results:
+  extends: .rec_benchmark
+  stage: collect
+  needs: ["full:reco"]
+  script:
+    - ls -lrth
+      #- python dvcs/scripts/merge_results.py
+

benchmarks/full/full_reconstruction.sh

+#!/bin/bash
+
+print_env.sh
+
+function print_the_help {
+  echo "USAGE: ${0} -n <nevents> -t <nametag> -p <particle> "
+  echo "  OPTIONS: "
+  echo "    -n,--nevents     Number of events"
+  echo "    -t,--nametag     name tag"
+  echo "    -p,--particle    particle type"
+  echo "                     allowed types: pion0, pion+, pion-, kaon0, kaon+, kaon-, proton, neutron, electron, positron, photon"
+  echo "    --pmin           minimum particle momentum (GeV)"
+  echo "    --pmax           maximum particle momentum (GeV)"
+  echo "    --angmin         minimum particle angle (deg)"
+  echo "    --angmax         maximum particle angle (deg)"
+  echo "    --region         detector region"
+  echo "                     allowed regions: farbackward, backward, barrel, forward, farforward"
+  exit
+}
+
+POSITIONAL=()
+while [[ $# -gt 0 ]]
+do
+  key="$1"
+
+  case $key in
+    -h|--help)
+      shift # past argument
+      print_the_help
+      ;;
+    -t|--nametag)
+      nametag="$2"
+      shift # past argument
+      shift # past value
+      ;;
+    -p|--particle)
+      particle="$2"
+      shift # past argument
+      shift # past value
+      ;;
+    -n|--nevents)
+      export JUGGLER_N_EVENTS="$2"
+      shift # past argument
+      shift # past value
+      ;;
+    --pmin)
+      export PMIN="$2"
+      shift
+      shift
+      ;;
+    --pmax)
+      export PMAX="$2"
+      shift
+      shift
+      ;;
+    --angmin)
+      export ANGMIN="$2"
+      shift
+      shift
+      ;;
+    --angmax)
+      export ANGMAX="$2"
+      shift
+      shift
+      ;;
+    --region)
+      export REGION="$2"
+      shift
+      shift
+      ;;
+    *)    # unknown option
+      #POSITIONAL+=("$1") # save it in an array for later
+      echo "unknown option $1"
+      print_the_help
+      shift # past argument
+      ;;
+  esac
+done
+set -- "${POSITIONAL[@]}" # restore positional parameters
+
+if [[ ! -n  "${JUGGLER_N_EVENTS}" ]] ; then
+  export JUGGLER_N_EVENTS=1000
+fi
+
+if [[ ! -n  "${PMIN}" ]] ; then
+  export PMIN=1.0
+fi
+
+if [[ ! -n  "${PMAX}" ]] ; then
+  export PMAX=10.0
+fi
+
+if [[ ! -n  "${ANGMIN}" ]] ; then
+  export ANGMIN=3
+fi
+
+if [[ ! -n  "${ANGMAX}" ]] ; then
+  export ANGMAX=177
+fi
+
+if [[ ! -n  "${REGION}" ]] ; then
+  export REGION="ignore"
+fi
+
+if [[ ! -n "${JUGGLER_DETECTOR}" ]] ; then
+  export JUGGLER_DETECTOR="athena"
+fi
+
+if [[ ! -n "${JUGGLER_DETECTOR_PATH}" ]] ; then
+  export JUGGLER_DETECTOR_PATH="/opt/detector/share/athena"
+fi
+
+if [[ ! -n "${JUGGLER_INSTALL_PREFIX}" ]] ; then
+  export JUGGLER_INSTALL_PREFIX="/usr/local"
+fi
+
+compact_path=${JUGGLER_DETECTOR_PATH}/${JUGGLER_DETECTOR}.xml
+export JUGGLER_FILE_NAME_TAG="${nametag}"
+export JUGGLER_GEN_FILE="gen_${JUGGLER_FILE_NAME_TAG}.hepmc"
+
+export JUGGLER_SIM_FILE="sim_${JUGGLER_FILE_NAME_TAG}.root"
+export JUGGLER_REC_FILE="rec_${JUGGLER_FILE_NAME_TAG}.root"
+
+echo "JUGGLER_N_EVENTS = ${JUGGLER_N_EVENTS}"
+echo "JUGGLER_DETECTOR_PATH = ${JUGGLER_DETECTOR_PATH}"
+echo "JUGGLER_DETECTOR = ${JUGGLER_DETECTOR}"
+
+# Generate the input events
+if [ ! -f ${JUGGLER_GEN_FILE} ] ; then
+  python benchmarks/full/scripts/gen_particles.py ${JUGGLER_GEN_FILE} -n ${JUGGLER_N_EVENTS}\
+    --angmin ${ANGMIN} --angmax ${ANGMAX} --phmin 0 --phmax 360 --pmin ${PMIN} --pmax ${PMAX}\
+    --regions="${REGION}" --particles="${particle}"
+fi
+
+if [[ "$?" -ne "0" ]] ; then
+  echo "ERROR running script: generating input events"
+  exit 1
+fi
+
+ls -lh ${JUGGLER_GEN_FILE}
+
+# Run geant4 simulations
+if [ ! -f ${JUGGLER_SIM_FILE} ] ; then
+  npsim --runType batch \
+        -v WARNING \
+        --part.minimalKineticEnergy "1*TeV" \
+        --numberOfEvents ${JUGGLER_N_EVENTS} \
+        --compactFile ${compact_path} \
+        --inputFiles ${JUGGLER_GEN_FILE} \
+        --outputFile ${JUGGLER_SIM_FILE}
+fi
+
+if [[ "$?" -ne "0" ]] ; then
+  echo "ERROR running npdet"
+  exit 1
+fi
+
+rootls -t "${JUGGLER_SIM_FILE}"
+
+# Directory for results
+mkdir -p results
+
+OPTION_DIR=benchmarks/full/options
+SCRIPT_DIR=benchmarks/full/scripts
+
+# Run Juggler
+xenv -x ${JUGGLER_INSTALL_PREFIX}/Juggler.xenv \
+    gaudirun.py ${OPTION_DIR}/full_reconstruction.py
+if [[ "$?" -ne "0" ]] ; then
+  echo "ERROR running reconstruction (juggler)"
+  exit 1
+fi
+
+# Run analysis scripts
+#python ${SCRIPT_DIR}/full_reconstruction.py ${JUGGLER_SIM_FILE} ${JUGGLER_REC_FILE} -o results
+
+root_filesize=$(stat --format=%s "${JUGGLER_REC_FILE}")
+if [[ "${JUGGLER_N_EVENTS}" -lt "500" ]] ; then
+  # file must be less than 10 MB to upload
+  if [[ "${root_filesize}" -lt "10000000" ]] ; then
+    cp ${JUGGLER_REC_FILE} results/.
+  fi
+fi
+

benchmarks/full/scripts/gen_particles.py

+import os
+from pyHepMC3 import HepMC3 as hm
+import numpy as np
+import argparse
+
+
+PARTICLES = {
+    "pion0": (111, 0.1349766),       # pi0
+    "pion+": (211, 0.13957018),      # pi+
+    "pion-": (-211, 0.13957018),     # pi-
+    "kaon0L": (130, 0.497648),       # K0L
+    "kaon0S": (310, 0.497648),       # K0S
+    "kaon0": (311, 0.497648),        # K0
+    "kaon+": (321, 0.493677),        # K+
+    "kaon-": (-321, 0.493677),       # K-
+    "proton": (2212, 0.938272),      # proton
+    "neutron": (2112, 0.939565),     # neutron
+    "electron": (11, 0.51099895e-3), # electron
+    "positron": (-11, 0.51099895e-3),# positron
+    "photon": (22, 0),               # photon
+}
+
+REGIONS = {
+    "farforward":  (1, 4),
+    "forward":     (3, 50),
+    "barrel":      (45, 135),
+    "backward":    (130, 177),
+    "farbackward": (176, 179),
+}
+
+def gen_event(p, theta, phi, pid, mass):
+    evt = hm.GenEvent(momentum_unit=hm.Units.MomentumUnit.GEV, length_unit=hm.Units.LengthUnit.MM)
+    # final state
+    state = 1
+    e0 = np.sqrt(p*p + mass*mass)
+    px = np.cos(phi)*np.sin(theta)
+    py = np.sin(phi)*np.sin(theta)
+    pz = np.cos(theta)
+
+    # beam
+    pbeam = hm.GenParticle(hm.FourVector(0, 0, 0, 0.938272), 2212, 4)
+    ebeam = hm.GenParticle(hm.FourVector(0, 0, e0, np.sqrt(e0*e0 + 0.511e-3*0.511e-3)), 11, 4)
+
+    # out particle
+    hout = hm.GenParticle(hm.FourVector(px*p, py*p, pz*p, e0), pid, state)
+
+    # vertex
+    vert = hm.GenVertex()
+    vert.add_particle_in(ebeam)
+    vert.add_particle_in(pbeam)
+    vert.add_particle_out(hout)
+    evt.add_vertex(vert)
+    return evt
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser()
+
+    parser.add_argument('output', help='path to the output file')
+    parser.add_argument('-n', type=int, default=1000, dest='nev', help='number of events to generate')
+    parser.add_argument('-s', type=int, default=-1, dest='seed', help='seed for random generator')
+    parser.add_argument('--parray', type=str, default="", dest='parray',
+                        help='an array of momenta in GeV, separated by \",\"')
+    parser.add_argument('--pmin', type=float, default=8.0, dest='pmin', help='minimum momentum in GeV')
+    parser.add_argument('--pmax', type=float, default=100.0, dest='pmax', help='maximum momentum in GeV')
+    parser.add_argument('--angmin', type=float, default=0.0, dest='angmin', help='minimum angle in degree')
+    parser.add_argument('--angmax', type=float, default=20.0, dest='angmax', help='maximum angle in degree')
+    parser.add_argument('--phmin', type=float, default=0.0, dest='phmin', help='minimum angle in degree')
+    parser.add_argument('--phmax', type=float, default=360.0, dest='phmax', help='maximum angle in degree')
+    parser.add_argument('--particles', type=str, default='electron', dest='particles',
+                        help='particle names, support {}'.format(list(PARTICLES.keys())))
+    parser.add_argument('--regions', type=str, default='ignored', dest='regions',
+                        help='detector regions, support {}'.format(list(REGIONS.keys())))
+
+    args = parser.parse_args()
+
+    # random seed (< 0 will get it from enviroment variable 'SEED', or a system random number)
+    if args.seed < 0:
+        args.seed = os.environ.get('SEED', int.from_bytes(os.urandom(4), byteorder='big', signed=False))
+    print("Random seed is {}".format(args.seed))
+    np.random.seed(args.seed)
+
+    output = hm.WriterAscii(args.output);
+    if output.failed():
+        print("Cannot open file \"{}\"".format(args.output))
+        sys.exit(2)
+
+    # build particle info
+    parts = []
+    for pid in args.particles.split(','):
+        pid = pid.strip()
+        if pid not in PARTICLES.keys():
+            print('pid {:d} not found in dictionary, ignored.'.format(pid))
+            continue
+        parts.append(PARTICLES[pid])
+
+    # interpret region
+    (angmin, angmax) = (args.angmin, args.angmax)
+    for region in args.regions.split(','):
+        region = region.strip()
+        if region not in REGIONS.keys():
+            print('region {:d} not found in dictionary, ignored.'.format(pid))
+            continue
+        (angmin, angmax) = REGIONS[region]
+
+    # p values
+    pvals = np.random.uniform(args.pmin, args.pmax, args.nev) if not args.parray else \
+            np.random.choice([float(p.strip()) for p in args.parray.split(',')], args.nev)
+    thvals = np.random.uniform(angmin, angmax, args.nev)/180.*np.pi
+    phivals = np.random.uniform(args.phmin, args.phmax, args.nev)/180.*np.pi
+    partvals = [parts[i] for i in np.random.choice(len(parts), args.nev)]
+
+    count = 0
+    for p, theta, phi, (pid, mass) in zip(pvals, thvals, phivals, partvals):
+        if (count % 1000 == 0):
+            print("Generated {} events".format(count), end='\r')
+        evt = gen_event(p, theta, phi, pid, mass)
+        output.write_event(evt)
+        evt.clear()
+        count += 1
+
+    print("Generated {} events".format(args.nev))
+    output.close()
+

benchmarks/tracking/config.yml

@@ -4,5 +4,4 @@ tracking_central_electrons:
   timeout: 24 hours
   script:
     - bash benchmarks/tracking/central_electrons.sh
-      #allow_failure: true
-
+      #allow_failure: true
\ No newline at end of file