src/BarrelBarDetectorWithSideFrame_geo.cpp

@@ -16,6 +16,7 @@
 #include "DDRec/DetectorData.h"
 #include "DDRec/Surface.h"
 #include "XML/Layering.h"
+#include <array>
 
 using namespace std;
 using namespace dd4hep;

src/BarrelCalorimeterInterlayers_geo.cpp

@@ -21,7 +21,7 @@ using namespace dd4hep;
 using namespace dd4hep::detail;
 
 typedef ROOT::Math::XYPoint Point;
-// fiber placement helpers, defined in BarrelCalorimeterHybrid_geo
+// fiber placement helpers, defined below
 vector<vector<Point>> fiberPositions(double radius, double x_spacing, double z_spacing,
                                      double x, double z, double phi, double spacing_tol = 1e-2);
 std::pair<int, int> getNdivisions(double x, double z, double dx, double dz);
@@ -277,25 +277,22 @@ void buildSupport(Detector& desc, Volume &mod_vol, xml_comp_t x_support,
   double beam_width       = 2. * trd_x1_support / (n_beams + 1); // quick hack to make some gap between T beams
   double beam_gap         = getAttrOrDefault(x_support, _Unicode(beam_gap), 3.*cm);
 
-  // build H-shape beam
+  // build T-shape beam
   double beam_space_x    = beam_width + beam_gap;
   double beam_space_z    = support_thickness - beam_thickness;
-  double cross_thickness = support_thickness - 2.*beam_thickness;
-  double beam_pos_z      = -beam_thickness / 2.;
-  double beam_center_z   = support_thickness / 2. + beam_pos_z;
+  double cross_thickness = support_thickness - beam_thickness;
+  double beam_pos_z      = beam_thickness / 2.;
+  double beam_center_z   = support_thickness / 2. - beam_pos_z;
 
-  // Box        beam_vert_s(beam_thickness / 2., trd_y, cross_thickness / 2.);
-  Box        beam_vert_s(beam_thickness / 2., trd_y, beam_space_z / 2.);
+  Box        beam_vert_s(beam_thickness / 2., trd_y, cross_thickness / 2.);
   Box        beam_hori_s(beam_width / 2., trd_y, beam_thickness / 2.);
-  // UnionSolid T_beam_s(beam_hori_s, beam_vert_s, Position(0., 0., beam_space_z / 2.));
-  // UnionSolid H_beam_s(T_beam_s, beam_hori_s, Position(0., 0., support_thickness - beam_thickness));
   UnionSolid T_beam_s(beam_hori_s, beam_vert_s, Position(0., 0., support_thickness / 2.));
   Volume H_beam_vol("H_beam", T_beam_s, desc.material(x_support.materialStr()));
   H_beam_vol.setVisAttributes(desc, x_support.visStr());
   // place H beams first
   double beam_start_x = - (n_beams - 1) * (beam_width + beam_gap) / 2.;
   for (int i = 0; i < n_beams; ++i) {
-    Position beam_pos(beam_start_x + i * (beam_width + beam_gap), 0., - support_thickness / 2. - beam_pos_z);
+    Position beam_pos(beam_start_x + i * (beam_width + beam_gap), 0., - support_thickness / 2. + beam_pos_z);
     env_vol.placeVolume(H_beam_vol, beam_pos);
   }
 
@@ -305,10 +302,10 @@ void buildSupport(Detector& desc, Volume &mod_vol, xml_comp_t x_support,
   Volume cross_vol("cross_center_beam", cross_s, desc.material(x_support.materialStr()));
   cross_vol.setVisAttributes(desc, x_support.visStr());
   for (int i = 0; i < n_beams - 1; ++i) {
-    env_vol.placeVolume(cross_vol, Position(beam_start_x + beam_space_x * (i + 0.5), 0., 0.));
+    env_vol.placeVolume(cross_vol, Position(beam_start_x + beam_space_x * (i + 0.5), 0., beam_pos_z));
     for (int j = 1; j < n_cross_supports; j++) {
-      env_vol.placeVolume(cross_vol, Position(beam_start_x + beam_space_x * (i + 0.5), -j * grid_size, 0.));
-      env_vol.placeVolume(cross_vol, Position(beam_start_x + beam_space_x * (i + 0.5), j * grid_size, 0.));
+      env_vol.placeVolume(cross_vol, Position(beam_start_x + beam_space_x * (i + 0.5), -j * grid_size, beam_pos_z));
+      env_vol.placeVolume(cross_vol, Position(beam_start_x + beam_space_x * (i + 0.5), j * grid_size, beam_pos_z));
     }
   }
 
@@ -317,24 +314,135 @@ void buildSupport(Detector& desc, Volume &mod_vol, xml_comp_t x_support,
   double    cross_edge_x = trd_x1_support + beam_start_x - beam_thickness / 2.;
   double    cross_trd_x1 = cross_edge_x + std::tan(hphi) * beam_thickness;
   double    cross_trd_x2 = cross_trd_x1 + 2.* std::tan(hphi) * cross_thickness;
-  double    edge_pos_x   = beam_start_x - beam_thickness / 2. - cross_trd_x1 / 2.;
+  double    edge_pos_x   = beam_start_x - cross_trd_x1 / 2. - beam_thickness / 2;
   Trapezoid cross_s2_trd (cross_trd_x1 / 2., cross_trd_x2 / 2.,
                           beam_thickness / 2., beam_thickness / 2., cross_thickness / 2.);
-  Box       cross_s2_box ((cross_trd_x2 - cross_trd_x1)/2., beam_thickness / 2., cross_thickness / 2.);
-  SubtractionSolid cross_s2(cross_s2_trd, cross_s2_box, Position((cross_trd_x1 + cross_trd_x2) / 4., 0., 0.));
+  Box       cross_s2_box ((cross_trd_x2 - cross_trd_x1)/4., beam_thickness / 2., cross_thickness / 2.);
+  SubtractionSolid cross_s2(cross_s2_trd, cross_s2_box, Position((cross_trd_x2 + cross_trd_x1)/4., 0., 0.));
   Volume cross_vol2("cross_edge_beam", cross_s2, desc.material(x_support.materialStr()));
   cross_vol2.setVisAttributes(desc, x_support.visStr());
-  env_vol.placeVolume(cross_vol2, Position(edge_pos_x, 0., 0.));
-  env_vol.placeVolume(cross_vol2, Transform3D(Translation3D(-edge_pos_x, 0., 0.) * RotationZ(M_PI)));
+  env_vol.placeVolume(cross_vol2, Position(edge_pos_x, 0., beam_pos_z));
+  env_vol.placeVolume(cross_vol2, Transform3D(Translation3D(-edge_pos_x, 0., beam_pos_z) * RotationZ(M_PI)));
   for (int j = 1; j < n_cross_supports; j++) {
-    env_vol.placeVolume(cross_vol2, Position(edge_pos_x, -j * grid_size, 0.));
-    env_vol.placeVolume(cross_vol2, Position(edge_pos_x, j * grid_size, 0.));
-    env_vol.placeVolume(cross_vol2, Transform3D(Translation3D(-edge_pos_x, -j * grid_size, 0.) * RotationZ(M_PI)));
-    env_vol.placeVolume(cross_vol2, Transform3D(Translation3D(-edge_pos_x, j * grid_size, 0.) * RotationZ(M_PI)));
+    env_vol.placeVolume(cross_vol2, Position(edge_pos_x, -j * grid_size, beam_pos_z));
+    env_vol.placeVolume(cross_vol2, Position(edge_pos_x, j * grid_size, beam_pos_z));
+    env_vol.placeVolume(cross_vol2, Transform3D(Translation3D(-edge_pos_x, -j * grid_size, beam_pos_z) * RotationZ(M_PI)));
+    env_vol.placeVolume(cross_vol2, Transform3D(Translation3D(-edge_pos_x, j * grid_size, beam_pos_z) * RotationZ(M_PI)));
   }
 
   mod_vol.placeVolume(env_vol, Position(0.0, 0.0, l_pos_z + support_thickness/2.));
 }
 
+// Fill fiber lattice into trapezoid starting from position (0,0) in x-z coordinate system
+vector<vector<Point>> fiberPositions(double radius, double x_spacing, double z_spacing, double x, double z, double phi,
+                                     double spacing_tol)
+{
+  // z_spacing - distance between fiber layers in z
+  // x_spacing - distance between fiber centers in x
+  // x - half-length of the shorter (bottom) base of the trapezoid
+  // z - height of the trapezoid
+  // phi - angle between z and trapezoid arm
+
+  vector<vector<Point>> positions;
+  int z_layers = floor((z / 2 - radius - spacing_tol) / z_spacing); // number of layers that fit in z/2
+
+  double z_pos = 0.;
+  double x_pos = 0.;
+
+  for (int l = -z_layers; l < z_layers + 1; l++) {
+    vector<Point> xline;
+    z_pos                = l * z_spacing;
+    double x_max         = x + (z / 2. + z_pos) * tan(phi) - spacing_tol; // calculate max x at particular z_pos
+    (l % 2 == 0) ? x_pos = 0. : x_pos = x_spacing / 2;                    // account for spacing/2 shift
+
+    while (x_pos < (x_max - radius)) {
+      xline.push_back(Point(x_pos, z_pos));
+      if (x_pos != 0.)
+        xline.push_back(Point(-x_pos, z_pos)); // using symmetry around x=0
+      x_pos += x_spacing;
+    }
+    // Sort fiber IDs for a better organization
+    sort(xline.begin(), xline.end(), [](const Point& p1, const Point& p2) { return p1.x() < p2.x(); });
+    positions.emplace_back(std::move(xline));
+  }
+  return positions;
+}
+
+// Calculate number of divisions for the readout grid for the fiber layers
+std::pair<int, int> getNdivisions(double x, double z, double dx, double dz)
+{
+  // x and z defined as in vector<Point> fiberPositions
+  // dx, dz - size of the grid in x and z we want to get close to with the polygons
+  // See also descripltion when the function is called
+
+  double SiPMsize = 13.0 * mm;
+  double grid_min = SiPMsize + 3.0 * mm;
+
+  if (dz < grid_min) {
+    dz = grid_min;
+  }
+
+  if (dx < grid_min) {
+    dx = grid_min;
+  }
+
+  int nfit_cells_z = floor(z / dz);
+  int n_cells_z    = nfit_cells_z;
+
+  if (nfit_cells_z == 0)
+    n_cells_z++;
+
+  int nfit_cells_x = floor((2 * x) / dx);
+  int n_cells_x    = nfit_cells_x;
+
+  if (nfit_cells_x == 0)
+    n_cells_x++;
+
+  return std::make_pair(n_cells_x, n_cells_z);
+}
+
+// Calculate dimensions of the polygonal grid in the cartesian coordinate system x-z
+vector<tuple<int, Point, Point, Point, Point>> gridPoints(int div_x, int div_z, double x, double z, double phi)
+{
+  // x, z and phi defined as in vector<Point> fiberPositions
+  // div_x, div_z - number of divisions in x and z
+  double dz = z / div_z;
+
+  std::vector<std::tuple<int, Point, Point, Point, Point>> points;
+
+  for (int iz = 0; iz < div_z + 1; iz++) {
+    for (int ix = 0; ix < div_x + 1; ix++) {
+      double A_z = -z / 2 + iz * dz;
+      double B_z = -z / 2 + (iz + 1) * dz;
+
+      double len_x_for_z        = 2 * (x + iz * dz * tan(phi));
+      double len_x_for_z_plus_1 = 2 * (x + (iz + 1) * dz * tan(phi));
+
+      double dx_for_z        = len_x_for_z / div_x;
+      double dx_for_z_plus_1 = len_x_for_z_plus_1 / div_x;
+
+      double A_x = -len_x_for_z / 2. + ix * dx_for_z;
+      double B_x = -len_x_for_z_plus_1 / 2. + ix * dx_for_z_plus_1;
+
+      double C_z = B_z;
+      double D_z = A_z;
+      double C_x = B_x + dx_for_z_plus_1;
+      double D_x = A_x + dx_for_z;
+
+      int id = ix + div_x * iz;
+
+      auto A = Point(A_x, A_z);
+      auto B = Point(B_x, B_z);
+      auto C = Point(C_x, C_z);
+      auto D = Point(D_x, D_z);
+
+      // vertex points filled in the clock-wise direction
+      points.push_back(make_tuple(id, A, B, C, D));
+    }
+  }
+
+  return points;
+}
+
 DECLARE_DETELEMENT(athena_EcalBarrelInterlayers, create_detector)
 

src/BarrelTrackerWithFrame_geo.cpp

@@ -13,10 +13,15 @@
 #include "DDRec/DetectorData.h"
 #include "XML/Layering.h"
 #include "XML/Utilities.h"
+#include <array>
 
+#if defined(USE_ACTSDD4HEP)
+#include "ActsDD4hep/ActsExtension.hpp"
+#include "ActsDD4hep/ConvertMaterial.hpp"
+#else
 #include "Acts/Plugins/DD4hep/ActsExtension.hpp"
 #include "Acts/Plugins/DD4hep/ConvertDD4hepMaterial.hpp"
-
+#endif
 
 using namespace std;
 using namespace dd4hep;
@@ -166,24 +171,26 @@ static Ref_t create_BarrelTrackerWithFrame(Detector& description, xml_h e, Sensi
     double thickness_so_far = 0.0;
     double thickness_sum = -total_thickness/2.0;
     for (xml_coll_t ci(x_mod, _U(module_component)); ci; ++ci, ++ncomponents) {
-      xml_comp_t x_comp = ci;
-      xml_comp_t x_pos  = x_comp.position(false);
-      xml_comp_t x_rot  = x_comp.rotation(false);
-      string     c_nam  = _toString(ncomponents, "component%d");
-      Box        c_box(x_comp.width() / 2, x_comp.length() / 2, x_comp.thickness() / 2);
-      Volume     c_vol(c_nam, c_box, description.material(x_comp.materialStr()));
-
+      xml_comp_t   x_comp = ci;
+      xml_comp_t   x_pos  = x_comp.position(false);
+      xml_comp_t   x_rot  = x_comp.rotation(false);
+      const string c_nam  = _toString(ncomponents, "component%d");
+      Box          c_box(x_comp.width() / 2, x_comp.length() / 2, x_comp.thickness() / 2);
+      Volume       c_vol(c_nam, c_box, description.material(x_comp.materialStr()));
+
+      // Utility variable for the relative z-offset based off the previous components
+      const double zoff = thickness_sum+x_comp.thickness() / 2.0;
       if (x_pos && x_rot) {
-        Position c_pos(x_pos.x(0), x_pos.y(0), x_pos.z(0));
+        Position c_pos(x_pos.x(0), x_pos.y(0), x_pos.z(0) + zoff);
         RotationZYX c_rot(x_rot.z(0), x_rot.y(0), x_rot.x(0));
         pv = m_vol.placeVolume(c_vol, Transform3D(c_rot, c_pos));
       } else if (x_rot) {
-        Position c_pos(0, 0, thickness_sum + x_comp.thickness() / 2.0);
-        pv = m_vol.placeVolume(c_vol, Transform3D(RotationZYX(x_rot.z(0), x_rot.y(0), x_rot.x(0)),c_pos));
+        Position c_pos(0, 0, zoff);
+        pv = m_vol.placeVolume(c_vol, Transform3D(RotationZYX(x_rot.z(0), x_rot.y(0), x_rot.x(0)), c_pos));
       } else if (x_pos) {
-        pv = m_vol.placeVolume(c_vol, Position(x_pos.x(0), x_pos.y(0), x_pos.z(0)));
+        pv = m_vol.placeVolume(c_vol, Position(x_pos.x(0), x_pos.y(0), x_pos.z(0) + zoff));
       } else {
-        pv = m_vol.placeVolume(c_vol, Position(0,0,thickness_sum+x_comp.thickness()/2.0));
+        pv = m_vol.placeVolume(c_vol, Position(0, 0, zoff));
       }
       c_vol.setRegion(description, x_comp.regionStr());
       c_vol.setLimitSet(description, x_comp.limitsStr());
@@ -217,6 +224,11 @@ static Ref_t create_BarrelTrackerWithFrame(Detector& description, xml_h e, Sensi
       }
       thickness_sum += x_comp.thickness();
       thickness_so_far += x_comp.thickness();
+      // apply relative offsets in z-position used to stack components side-by-side
+      if (x_pos) {
+        thickness_sum += x_pos.z(0);
+        thickness_so_far += x_pos.z(0);
+      }
     }
   }
 
@@ -341,3 +353,4 @@ static Ref_t create_BarrelTrackerWithFrame(Detector& description, xml_h e, Sensi
 DECLARE_DETELEMENT(BarrelTrackerWithFrame, create_BarrelTrackerWithFrame)
 DECLARE_DETELEMENT(athena_TrackerBarrel,   create_BarrelTrackerWithFrame)
 DECLARE_DETELEMENT(athena_VertexBarrel,    create_BarrelTrackerWithFrame)
+DECLARE_DETELEMENT(athena_TOFBarrel,       create_BarrelTrackerWithFrame)

src/CompositeTracker_geo.cpp

@@ -11,7 +11,11 @@
 #include "DD4hep/Printout.h"
 #include "XML/Utilities.h"
 
+#if defined(USE_ACTSDD4HEP)
+#include "ActsDD4hep/ActsExtension.hpp"
+#else
 #include "Acts/Plugins/DD4hep/ActsExtension.hpp"
+#endif
 
 using namespace dd4hep;
 using namespace dd4hep::detail;

src/CylinderTrackerBarrel_geo.cpp

@@ -2,11 +2,17 @@
 // Specialized generic detector constructor
 //==========================================================================
 
-#include "Acts/Plugins/DD4hep/ActsExtension.hpp"
-#include "Acts/Plugins/DD4hep/ConvertDD4hepMaterial.hpp"
 #include "DD4hep/DetFactoryHelper.h"
 #include "DD4hep/Printout.h"
 
+#if defined(USE_ACTSDD4HEP)
+#include "ActsDD4hep/ActsExtension.hpp"
+#include "ActsDD4hep/ConvertMaterial.hpp"
+#else
+#include "Acts/Plugins/DD4hep/ActsExtension.hpp"
+#include "Acts/Plugins/DD4hep/ConvertDD4hepMaterial.hpp"
+#endif
+
 using namespace std;
 using namespace dd4hep;
 using namespace dd4hep::detail;

src/DIRC_geo.cpp

@@ -162,7 +162,7 @@ static Ref_t createDetector(Detector& desc, xml_h e, SensitiveDetector sens)
   Volume lGlue("lGlue", gGlue, desc.material(xml_glue.materialStr()));
   lGlue.setVisAttributes(desc.visAttributes(xml_glue.visStr()));
 
-  sens.setType("photoncounter");
+  sens.setType("tracker");
   lBar.setSensitiveDetector(sens);
 
   int bars_repeat_z = 4;    // TODO parametrize!
@@ -320,7 +320,7 @@ static Ref_t createDetector(Detector& desc, xml_h e, SensitiveDetector sens)
   // Box    bar_geo(bar_thicknes / 2., bar_width / 2., bar_length / 2.);
   // Volume bar_volume("cb_DIRC_bars_Logix", bar_geo, bar_material);
   // bar_volume.setVisAttributes(desc.visAttributes(xml_det.visStr()));
-  // sens.setType("photoncounter");
+  // sens.setType("tracker");
   // bar_volume.setSensitiveDetector(sens);
 
   // for (int ia = 0; ia < bar_count; ia++) {

src/DRich_geo.cpp → src/DRICH_geo.cpp

@@ -217,7 +217,7 @@ static Ref_t createDetector(Detector& desc, xml::Handle_t handle, SensitiveDetec
 
 
   // sensitive detector type
-  sens.setType("photoncounter");
+  sens.setType("tracker");
 
 
   // BUILD RADIATOR ====================================================================

src/FieldMapBrBz.cpp

 #include <DD4hep/DetFactoryHelper.h>
 #include <DD4hep/FieldTypes.h>
+#include <DD4hep/Printout.h>
 #include <XML/Utilities.h>
 
 #include <cstdlib>
@@ -12,6 +13,8 @@
 #include <tuple>
 namespace fs = std::filesystem;
 
+#include "FileLoaderHelper.h"
+
 using namespace dd4hep;
 
 
@@ -19,7 +22,7 @@ using namespace dd4hep;
 class FieldMapBrBz : public dd4hep::CartesianField::Object
 {
 public:
-    FieldMapBrBz(const std::string &field_type);
+    FieldMapBrBz(const std::string &field_type = "magnetic");
     void Configure(double rmin, double rmax, double rstep, double zmin, double zmax, double zstep);
     void LoadMap(const std::string &map_file, double scale);
     void GetIndices(double r, double z, int &ir, int &iz, double &dr, double &dz);
@@ -35,7 +38,7 @@ private:
 };
 
 // constructor
-FieldMapBrBz::FieldMapBrBz(const std::string &field_type = "magnetic")
+FieldMapBrBz::FieldMapBrBz(const std::string &field_type)
 {
     std::string ftype = field_type;
     for (auto &c : ftype) { c = tolower(c); }
@@ -185,20 +188,16 @@ static Ref_t create_field_map_brbz(Detector & /*lcdd*/, xml::Handle_t handle)
     std::string field_map_file = x_par.attr<std::string>(_Unicode(field_map));
     std::string field_map_url = x_par.attr<std::string>(_Unicode(url));
 
+    EnsureFileFromURLExists(field_map_url,field_map_file);
+
     double field_map_scale = x_par.attr<double>(_Unicode(scale));
 
     if( !fs::exists(fs::path(field_map_file))  ) {
-      auto ret = std::system(("mkdir -p fieldmaps && "
-                             "curl --retry 5 -f " +
-                             field_map_url + " -o " + field_map_file).c_str());
-
-      if (!fs::exists(fs::path(field_map_file))) {
-        std::cerr << "ERROR: file, " << field_map_file << ", does not exist\n";
-        std::quick_exit(1);
-      }
+        printout(ERROR, "FieldMapBrBz", "file " + field_map_file + " does not exist");
+        printout(ERROR, "FieldMapBrBz", "use a FileLoader plugin before the field element");
+        std::_Exit(EXIT_FAILURE);
     }
 
-
     auto map = new FieldMapBrBz(field_type);
     map->Configure(r_dim.rmin(), r_dim.rmax(), r_dim.step(), z_dim.zmin(), z_dim.zmax(), z_dim.step());
 

src/FileLoader.cpp

 #include <DD4hep/DetFactoryHelper.h>
+#include <DD4hep/Primitives.h>
 #include <DD4hep/Factories.h>
 #include <DD4hep/Printout.h>
 #include <XML/Utilities.h>
 
+#include <fmt/core.h>
+
 #include <filesystem>
 #include <iostream>
+#include <cstdlib>
 #include <string>
 
-namespace fs = std::filesystem;
+#include "FileLoaderHelper.h"
 
 using namespace dd4hep;
 
-void usage(int argc, char** argv)    {
+void usage(int argc, char** argv) {
   std::cout <<
     "Usage: -plugin <name> -arg [-arg]                                                  \n"
     "     name:   factory name     FileLoader                                           \n"
+    "     cache:<string>           cache location (may be read-only)                    \n"
     "     file:<string>            file location                                        \n"
     "     url:<string>             url location                                         \n"
+    "     cmd:<string>             download command with {0} for url, {1} for output    \n"
     "\tArguments given: " << arguments(argc,argv) << std::endl;
   std::exit(EINVAL);
 }
@@ -27,24 +33,33 @@ long load_file(
     int argc,
     char** argv
 ) {
-  std::string file, url;
+  // argument parsing
+  std::string cache, file, url;
+  std::string cmd("curl --retry 5 -f {0} -o {1}");
   for (int i = 0; i < argc && argv[i]; ++i) {
-    if      (0 == std::strncmp("file:",argv[i], 5)) file = (argv[i] + 5);
-    else if (0 == std::strncmp("url:", argv[i], 4)) url  = (argv[i] + 4);
+    if      (0 == std::strncmp("cache:", argv[i], 6)) cache = (argv[i] + 6);
+    else if (0 == std::strncmp("file:", argv[i], 5)) file = (argv[i] + 5);
+    else if (0 == std::strncmp("url:", argv[i], 4)) url = (argv[i] + 4);
+    else if (0 == std::strncmp("cmd:", argv[i], 4)) cmd = (argv[i] + 4);
     else usage(argc, argv);
   }
-  std::cout << "Loading " << file << " from " << url << std::endl;
-
-  if (!fs::exists(fs::path(file))) {
-    std::string parent_path = fs::path(file).parent_path();
-    auto ret = std::system(("mkdir -p " + parent_path + " && "
-                            "curl --retry 5 -f " + url + " -o " + file).c_str());
-    if (!fs::exists(fs::path(file))) {
-      std::cerr << "ERROR: file, " << file << ", does not exist\n";
-      std::quick_exit(1);
-    }
+  printout(DEBUG, "FileLoader", "arg cache: " + cache);
+  printout(DEBUG, "FileLoader", "arg file: " + file);
+  printout(DEBUG, "FileLoader", "arg url: " + url);
+  printout(DEBUG, "FileLoader", "arg cmd: " + cmd);
+
+  // if file or url is empty, do nothing
+  if (file.empty()) {
+    printout(WARNING, "FileLoader", "no file specified");
+    return 0;
+  }
+  if (url.empty()) {
+    printout(WARNING, "FileLoader", "no url specified");
+    return 0;
   }
 
+  EnsureFileFromURLExists(url, file, cache, cmd);
+
   return 0;
 }
 

src/FileLoaderHelper.h

+#pragma once
+
+#include <DD4hep/DetFactoryHelper.h>
+#include <DD4hep/Primitives.h>
+#include <DD4hep/Factories.h>
+#include <DD4hep/Printout.h>
+
+#include <fmt/core.h>
+
+#include <filesystem>
+#include <iostream>
+#include <cstdlib>
+#include <string>
+
+namespace fs = std::filesystem;
+
+using namespace dd4hep;
+
+// Function to download files
+inline void
+EnsureFileFromURLExists(
+  std::string url,
+  std::string file,
+  std::string cache = "",
+  std::string cmd = "curl --retry 5 -f {0} -o {1}"
+) {
+  // parse cache for environment variables
+  auto pos = std::string::npos;
+  while ((pos = cache.find('$')) != std::string::npos) {
+    auto after = cache.find_first_not_of(
+      "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
+      "abcdefghijklmnopqrstuvwxyz"
+      "0123456789"
+      "_",
+      pos + 1);
+    if (after == std::string::npos) after = cache.size(); // cache ends on env var
+    const std::string env_name(cache.substr(pos + 1, after - pos - 1));
+    auto env_ptr = std::getenv(env_name.c_str());
+    const std::string env_value(env_ptr != nullptr ? env_ptr : "");
+    cache.erase(pos, after - pos);
+    cache.insert(pos, env_value);
+    printout(INFO, "FileLoader", "$" + env_name + " -> " + env_value);
+  }
+
+  // create file path
+  fs::path file_path(file);
+
+  // create hash from url, hex of unsigned long long
+  std::string hash = fmt::format("{:016x}", dd4hep::detail::hash64(url)); // TODO: Use c++20 std::fmt
+
+  // create file parent path, if not exists
+  fs::path parent_path = file_path.parent_path();
+  if (!fs::exists(parent_path)) {
+    if (fs::create_directories(parent_path) == false) {
+      printout(ERROR, "FileLoader", "parent path " + parent_path.string() + " cannot be created");
+      printout(ERROR, "FileLoader", "check permissions and retry");
+      std::_Exit(EXIT_FAILURE);
+    }
+  }
+
+  // if file exists and is symlink to correct hash
+  fs::path hash_path(parent_path / hash);
+  if (fs::exists(file_path)
+   && fs::equivalent(file_path, hash_path)) {
+    printout(INFO, "FileLoader", "Link " + file + " -> hash " + hash + " already exists");
+    return;
+  }
+
+  // if hash does not exist, we try to retrieve file from cache
+  if (!fs::exists(hash_path)) {
+    // recursive loop into cache directory
+    fs::path cache_path(cache);
+    printout(INFO, "FileLoader", "Cache " + cache_path.string());
+    if (fs::exists(cache_path)) {
+      for (auto const& dir_entry: fs::recursive_directory_iterator(cache_path)) {
+        if (!dir_entry.is_directory()) continue;
+        fs::path cache_dir_path = cache_path / dir_entry;
+        printout(INFO, "FileLoader", "Checking " + cache_dir_path.string());
+        fs::path cache_hash_path = cache_dir_path / hash;
+        if (fs::exists(cache_hash_path)) {
+          // symlink hash to cache/.../hash
+          printout(INFO, "FileLoader", "File " + file + " with hash " + hash + " found in " + cache_hash_path.string());
+          try {
+            fs::create_symlink(cache_hash_path, hash_path);
+          } catch (const fs::filesystem_error&) {
+            printout(ERROR, "FileLoader", "unable to link from " + hash_path.string() + " to " + cache_hash_path.string());
+            printout(ERROR, "FileLoader", "check permissions and retry");
+            std::_Exit(EXIT_FAILURE);
+          }
+          break;
+        }
+      }
+    }
+  }
+
+  // if hash does not exist, we try to retrieve file from url
+  if (!fs::exists(hash_path)) {
+    cmd = fmt::format(cmd, url, hash_path.c_str()); // TODO: Use c++20 std::fmt
+    printout(INFO, "FileLoader", "Downloading " + file + " as hash " + hash + " with " + cmd);
+    // run cmd
+    auto ret = std::system(cmd.c_str());
+    if (!fs::exists(hash_path)) {
+      printout(ERROR, "FileLoader", "unable to run cmd " + cmd);
+      printout(ERROR, "FileLoader", "check command and retry");
+      printout(ERROR, "FileLoader", "hint: allow insecure connections with -k");
+      std::_Exit(EXIT_FAILURE);
+    }
+  }
+
+  // check if file already exists
+  if (fs::exists(file_path)) {
+    // file already exists
+    if (fs::is_symlink(file_path)) {
+      // file is symlink
+      if (fs::equivalent(hash_path, fs::read_symlink(file_path))) {
+        // link points to correct path
+        return;
+      } else {
+        // link points to incorrect path 
+        if (fs::remove(file_path) == false) {
+          printout(ERROR, "FileLoader", "unable to remove symlink " + file_path.string());
+          printout(ERROR, "FileLoader", "check permissions or remove manually");
+          std::_Exit(EXIT_FAILURE);
+        }
+      }
+    } else {
+      // file exists but not symlink
+      printout(ERROR, "FileLoader", "will not remove actual file " + file_path.string());
+      printout(ERROR, "FileLoader", "check content, remove manually, and retry");
+      std::_Exit(EXIT_FAILURE);
+    }
+  }
+  // file_path now does not exist
+
+  // symlink file_path to hash_path
+  try {
+    // use new path from hash so file link is local
+    fs::create_symlink(fs::path(hash), file_path);
+  } catch (const fs::filesystem_error&) {
+    printout(ERROR, "FileLoader", "unable to link from " + file_path.string() + " to " + hash_path.string());
+    printout(ERROR, "FileLoader", "check permissions and retry");
+    std::_Exit(EXIT_FAILURE);
+  }
+}

src/GaseousRICH_geo.cpp

@@ -75,7 +75,7 @@ static Ref_t createDetector(Detector& desc, xml::Handle_t handle, SensitiveDetec
     envVol.setVisAttributes(desc.visAttributes(detElem.visStr()));
 
     // sensitive detector type
-    sens.setType("photoncounter");
+    sens.setType("tracker");
 
     // @TODO: place a radiator
     // build_radiator(desc, envVol, detElement.child(_Unicode(radiator)), snout_front);

src/MRich_geo.cpp

@@ -29,7 +29,7 @@ static Ref_t createDetector(Detector& description, xml::Handle_t e, SensitiveDet
   string         det_name = x_det.nameStr();
   DetElement     sdet(det_name, x_det.id());
   Assembly       assembly(det_name);
-  sens.setType("photoncounter");
+  sens.setType("tracker");
   OpticalSurfaceManager surfMgr = description.surfaceManager();
 
   bool projective = getAttrOrDefault(x_det, _Unicode(projective), false);
@@ -437,7 +437,7 @@ static Ref_t createDetector(Detector& description, xml::Handle_t e, SensitiveDet
 //    modVol.placeVolume(mVol, Position(0., 0., -0.1*mm));
 //
 //    modVol.setVisAttributes(description.visAttributes(mods.visStr()));
-//    sens.setType("photoncounter");
+//    sens.setType("tracker");
 //    modVol.setSensitiveDetector(sens);
 //
 //    // place modules in the sectors (disk)

src/ERich_geo.cpp → src/PFRICH_geo.cpp

 //----------------------------------
-//  eRICH: Electron endcap RICH
+//  pfRICH: Proximity Focusing RICH
 //  Author: C. Dilks
 //----------------------------------
 
@@ -79,7 +79,7 @@ static Ref_t createDetector(Detector& desc, xml::Handle_t handle, SensitiveDetec
   // if debugging optics, override some settings
   bool debug_optics = debug_optics_mode > 0;
   if (debug_optics) {
-    printout(WARNING, "ERich_geo", "DEBUGGING ERICH OPTICS");
+    printout(WARNING, "PFRICH_geo", "DEBUGGING PFRICH OPTICS");
     switch (debug_optics_mode) {
     case 1:
       vesselMat = aerogelMat = filterMat = sensorMat = gasvolMat = desc.material("VacuumOptical");
@@ -88,7 +88,7 @@ static Ref_t createDetector(Detector& desc, xml::Handle_t handle, SensitiveDetec
       vesselMat = aerogelMat = filterMat = sensorMat = desc.material("VacuumOptical");
       break;
     default:
-      printout(FATAL, "ERich_geo", "UNKNOWN debug_optics_mode");
+      printout(FATAL, "PFRICH_geo", "UNKNOWN debug_optics_mode");
       return det;
     };
     aerogelVis = sensorVis;
@@ -96,7 +96,7 @@ static Ref_t createDetector(Detector& desc, xml::Handle_t handle, SensitiveDetec
   };
 
   // BUILD VESSEL //////////////////////////////////////
-  /* - `vessel`: aluminum enclosure, the mother volume of the eRICh
+  /* - `vessel`: aluminum enclosure, the mother volume of the pfRICH
    * - `gasvol`: gas volume, which fills `vessel`; all other volumes defined below
    *   are children of `gasvol`
    */
@@ -145,7 +145,7 @@ static Ref_t createDetector(Detector& desc, xml::Handle_t handle, SensitiveDetec
   auto originBack  = Position(0., 0., -vesselLength / 2.0);
 
   // sensitive detector type
-  sens.setType("photoncounter");
+  sens.setType("tracker");
 
 
   // BUILD RADIATOR //////////////////////////////////////
@@ -313,4 +313,4 @@ static Ref_t createDetector(Detector& desc, xml::Handle_t handle, SensitiveDetec
 };
 
 // clang-format off
-DECLARE_DETELEMENT(athena_ERICH, createDetector)
+DECLARE_DETELEMENT(athena_PFRICH, createDetector)

src/PolyhedraEndcapCalorimeter2_geo.cpp

@@ -11,7 +11,7 @@
 //
 //==========================================================================
 //
-// Modified for TOPSiDE detector
+// Modified for ATHENA detector
 //
 //==========================================================================
 #include "DD4hep/DetFactoryHelper.h"
@@ -129,3 +129,4 @@ static Ref_t create_detector(Detector& description, xml_h e, SensitiveDetector s
 
 // clang-format off
 DECLARE_DETELEMENT(athena_PolyhedraEndcapCalorimeter2, create_detector)
+DECLARE_DETELEMENT(athena_PolyhedraEndcapCalorimeter, create_detector)