initial commit with compiling bench

Author: tomeichlersmith

.bash_aliases

@@ -0,0 +1,7 @@
+# framework-testbench specific bash aliases for within the denv
+
+# need the home install path added to various PATHs
+export PATH=${HOME}/.local/bin:${PATH}
+export LD_LIBRARY_PATH=${HOME}/.local/lib:${LD_LIBRARY_PATH}
+export PYTHONPATH=${HOME}/.local/python:${HOME}/.local/lib:${HOME}/.local/lib/python:${PYTHONPATH}
+

.denv/.gitignore

@@ -0,0 +1,5 @@
+# ignore everything in this directory
+*
+# except the config which folks might want to share
+# across many computers
+!config

.denv/config

@@ -0,0 +1,4 @@
+denv_name="framework-testbench"
+denv_image="ldmx/dev:latest"
+denv_shell="/bin/bash -i"
+denv_mounts=""

.gitignore

@@ -0,0 +1,9 @@
+# HOME-like stuff from having denv here
+.bash_logout
+.bash_history
+.bashrc
+.local
+.profile
+
+# build directory to ignore
+build

.gitmodules

@@ -0,0 +1,6 @@
+[submodule "Framework"]
+	path = Framework
+	url = [email protected]:LDMX-Software/Framework.git
+[submodule "cmake"]
+	path = cmake
+	url = [email protected]:LDMX-Software/cmake.git

Bench/CMakeLists.txt

@@ -0,0 +1,24 @@
+
+# Set the minimum version of CMake that's required
+cmake_minimum_required(VERSION 3.12)
+
+# Set the project name
+project(Bench DESCRIPTION "Benchmarking and Testing Framework" LANGUAGES CXX)
+
+option(BUILD_EVENT_ONLY "Build the event library." ON)
+if(BUILD_EVENT_ONLY)
+  # Search and configure ROOT
+  find_package(ROOT CONFIG REQUIRED)
+
+  register_event_object(module_path "Bench/Event" namespace "bench" 
+                        class "Hit" type "collection" )
+
+  setup_library(module Bench name Event
+                dependencies ROOT::Core
+                register_target)
+  
+  return()
+endif()
+
+setup_library(module Bench
+  dependencies Framework::Framework Bench::Event)

Bench/README.md

@@ -0,0 +1,59 @@
+# Bench
+
+Benchmark testing between ROOT-based fire and HDF5-based fire.
+
+The actual compiling and running of this module is done in the
+[benchmark GitHub action](../.github/workflows/bench.yml).
+
+In short, after compiling whichever version of the framework we are
+using against this module, we run the command
+
+```bash
+ldmx time fire config.py <num-events>
+```
+
+To time how long the processing takes, and then
+
+```bash
+stat output/output_<num-events>.<ext>
+```
+
+To obtain how large the output data file is.
+
+## Run Locally
+
+If you want to run this benchmarking test on your own machine, 
+you can use the script that the GitHub workflow uses.
+You will need to provide the number of trials per test point
+and the event number points to test.
+```
+source env.sh
+source Bench/run.sh
+bench 10 1 10 42
+```
+
+The plotting script assumes you have `matplotlib` and `pandas` available.
+You can install them quickly with `pip`.
+```
+python3 -m pip install matplotlib pandas
+```
+
+And then you can generate plots from the data the `bench` command generated.
+```
+python3 Bench/plot.py data.csv
+```
+
+## Results
+The latest results were generated with a GitHub action.
+This limits the number of events we can sample because of the 6 hour time limit.
+We still are able to compare up to 100k events being written and read.
+The results generated with a GitHub action using docker as the container runner.
+
+![Production Mode](results/production_data.png)
+![Reconstruction Mode](results/recon_data.png)
+
+Results generated manually up to 1M events being written/read were done on a computer
+at UMN using singularity.
+
+![Production Mode](results/umn_production_data.png)
+![Reconstruction Mode](results/umn_recon_data.png)

Bench/include/Bench/Event/Hit.h

@@ -0,0 +1,215 @@
+#ifndef BENCH_EVENT_HIT_H_
+#define BENCH_EVENT_HIT_H_
+
+// STL
+#include <iostream>
+
+// ROOT
+#include "TObject.h"  //For ClassDef
+
+namespace bench {
+
+/**
+ * @class Hit
+ * @brief Represents a simulated tracker hit in the simulation
+ */
+class Hit {
+ public:
+  /**
+   * Class constructor.
+   */
+  Hit();
+
+  /**
+   * Class destructor.
+   */
+  virtual ~Hit();
+
+  /**
+   * Print a description of this object.
+   */
+  void Print() const;
+
+  /**
+   * Reset the Hit object.
+   */
+  void Clear();
+
+  /**
+   * Get the geometric layer ID of the hit.
+   * @return The layer ID of the hit.
+   */
+  int getLayerID() const { return layerID_; };
+
+  /**
+   * Get the module ID associated with a hit.  This is used to
+   * uniquely identify a sensor within a layer.
+   * @return The module ID associated with a hit.
+   */
+  int getModuleID() const { return moduleID_; };
+
+  /**
+   * Get the XYZ position of the hit [mm].
+   * @return The position of the hit.
+   */
+  std::vector<float> getPosition() const { return {x_, y_, z_}; };
+
+  /**
+   * Get the energy
+   * @return The energy of the hit.
+   */
+  float getEnergy() const { return energy_; };
+
+  /**
+   * Get the global time of the hit [ns].
+   * @return The global time of the hit.
+   */
+  float getTime() const { return time_; };
+
+  /**
+   * Get the XYZ momentum of the particle at the position at which
+   * the hit took place [MeV].
+   * @return The momentum of the particle.
+   */
+  std::vector<double> getMomentum() const { return {px_, py_, pz_}; };
+
+  /**
+   * Get the Sim particle track ID of the hit.
+   * @return The Sim particle track ID of the hit.
+   */
+  int getTrackID() const { return trackID_; };
+
+  /**
+   * Get the Sim particle track ID of the hit.
+   * @return The Sim particle track ID of the hit.
+   */
+  int getPdgID() const { return pdgID_; };
+
+  /**
+   * Set the geometric layer ID of the hit.
+   * @param layerID The layer ID of the hit.
+   */
+  void setLayerID(const int layerID) { this->layerID_ = layerID; };
+
+  /**
+   * Set the module ID associated with a hit.  This is used to
+   * uniquely identify a sensor within a layer.
+   * @return moduleID The module ID associated with a hit.
+   */
+  void setModuleID(const int moduleID) { this->moduleID_ = moduleID; };
+
+  /**
+   * Set the position of the hit [mm].
+   * @param x The X position.
+   * @param y The Y position.
+   * @param z The Z position.
+   */
+  void setPosition(const float x, const float y, const float z);
+
+  /**
+   * Set the energy of the hit.
+   * @param e The energy of the hit.
+   */
+  void setEnergy(const float energy) { energy_ = energy; };
+
+  /**
+   * Set the global time of the hit [ns].
+   * @param time The global time of the hit.
+   */
+  void setTime(const float time) { this->time_ = time; };
+
+  /**
+   * Set the momentum of the particle at the position at which
+   * the hit took place [GeV].
+   * @param px The X momentum.
+   * @param py The Y momentum.
+   * @param pz The Z momentum.
+   */
+  void setMomentum(const float px, const float py, const float pz);
+
+  /**
+   * Set the Sim particle track ID of the hit.
+   * @return The Sim particle track ID of the hit.
+   */
+  void setTrackID(const int simTrackID) { this->trackID_ = simTrackID; };
+
+  /**
+   * Set the Sim particle track ID of the hit.
+   * @return The Sim particle track ID of the hit.
+   */
+  void setPdgID(const int simPdgID) { this->pdgID_ = simPdgID; };
+
+  /**
+   * Sort by time of hit
+   */
+  bool operator<(const bench::Hit &rhs) const {
+    return this->getTime() < rhs.getTime();
+  }
+
+  /**
+   * The layer ID.
+   */
+  int layerID_{0};
+
+  /** The module ID. */
+  int moduleID_{0};
+
+  /**
+   * The global time of the hit.
+   */
+  float time_{0};
+
+  /**
+   * The X momentum.
+   */
+  float px_{0};
+
+  /**
+   * The Y momentum.
+   */
+  float py_{0};
+
+  /**
+   * The Z momentum.
+   */
+  float pz_{0};
+
+  /**
+   * The total energy.
+   */
+  float energy_{0};
+
+  /**
+   * The X position.
+   */
+  float x_{0};
+
+  /**
+   * The Y position.
+   */
+  float y_{0};
+
+  /**
+   * The Z position.
+   */
+  float z_{0};
+
+  /**
+   * The Sim Track ID.
+   */
+  int trackID_{0};
+
+  /**
+   * The Sim PDG ID.
+   */
+  int pdgID_{0};
+
+  /**
+   * The ROOT class definition.
+   */
+  ClassDef(Hit, 1);
+
+};  // Hit
+}  // namespace bench
+
+#endif