scripts/view12/.DAWN_1.history

+1.34392e+07
+0
+180
+0
+0
+0
+0
+8
+1
+0.001
+0
+1
+1
+1
+0.5
+0.5
+0.5
+19
+71
+0.01
+0.01
+0.01
+3
+70
+0.01
+1
+1
+1
+evince
+0
+0

scripts/view12/generate_eps

@@ -18,7 +18,7 @@ tan ()
 
 
 function print_the_help {
-  echo "USAGE: $0 -i <PRIM_FILE>  "
+  echo "USAGE: $0 -i <PRIM_FILE> <slices ...> "
   echo "  OPTIONS: "
   echo "            -t,--tag           filename tag (default: view1)"
   exit 
@@ -48,12 +48,16 @@ do
       shift # past argument
       shift # past value
       ;;
-    *)    # unknown option
-      #POSITIONAL+=("$1") # save it in an array for later
+    -[a-zA-Z]*) # unknown option
+      POSITIONAL+=("$1") # save it in an array for later
       echo "unknown option $1"
       print_the_help
       shift # past argument
       ;;
+    *)     # positional options
+      POSITIONAL+=("$1") # save it in an array for later
+      shift # past argument
+      ;;
   esac
 done
 set -- "${POSITIONAL[@]}" # restore positional parameters
@@ -62,17 +66,6 @@ set -- "${POSITIONAL[@]}" # restore positional parameters
 
 echo "view12 produces a series of slightly rotated XY slices a different z locations. Along beamline"
 
-# slice at z = 2m
-# note the offset has to change with sign of the direction to cut in the opposite direction.
-dawncut 0  0  1  2005 ${INPUT_FILE} ${FILE_TAG}b_temp0.prim 
-dawncut 0  0 -1 -2000 ${FILE_TAG}b_temp0.prim  ${FILE_TAG}b.prim
-dawn -d ${FILE_TAG}b.prim 
-ps2pdf ${FILE_TAG}b.eps ${FILE_TAG}b_full.pdf
-gs -o ${FILE_TAG}b.pdf -sDEVICE=pdfwrite \
-  -c "[/CropBox [50 175 550 675] /PAGES pdfmark" \
-  -f ${FILE_TAG}b_full.pdf
-pdftoppm ${FILE_TAG}b.pdf ${FILE_TAG}b -png -singlefile -cropbox
-
 original_file_tag="${FILE_TAG}"
 
 make_slice(){
@@ -90,9 +83,10 @@ make_slice(){
   rm "${FILE_TAG}_temp0.prim"
   rm "${FILE_TAG}.prim"
 }
-for zzz in $(seq 50 50 2000) ;
+
+for zzz in $@ ;
 do
-  make_slice ${zzz} & 
+  make_slice ${zzz}
 done
 
 wait

scripts/view13/generate_eps

@@ -9,7 +9,7 @@ function print_the_help {
   exit 
 }
 
-FILE_TAG="view2"
+FILE_TAG="view13"
 INPUT_FILE="g4_0000.prim"
 
 

scripts/view14/.DAWN_1.history

+0.0
+72.5
+189.5
+0
+0
+0
+1500
+55
+3
+0.001
+0
+1
+1
+1
+0.5
+0.5
+0.5
+25.5
+71
+0.001
+0.001
+0.001
+1
+70
+0.001
+1
+0
+1
+evince
+0
+0

scripts/view14/generate_eps

 #!/bin/bash
 
 #trignometry
-sin ()
-{
-    echo "scale=5;s($1)" | bc -l
-}
-
-add ()
-{
-    echo "scale=5;$1 + $2" | bc -l
-}
-
-cos ()
-{
-    echo "scale=5;c($1)" | bc -l
-}
-
-tan ()
-{
-    echo "scale=5;s($1)/c($1)" | bc -l
-}
+#sin ()
+#{
+#    echo "scale=5;s($1)" | bc -l
+#}
+#
+#add ()
+#{
+#    echo "scale=5;$1 + $2" | bc -l
+#}
+#
+#cos ()
+#{
+#    echo "scale=5;c($1)" | bc -l
+#}
+#
+#tan ()
+#{
+#    echo "scale=5;s($1)/c($1)" | bc -l
+#}
 
 
 function print_the_help {
-  echo "USAGE: $0 -i <PRIM_FILE>  "
+  echo "USAGE: $0 -i <PRIM_FILE> <slices ...> "
   echo "  OPTIONS: "
   echo "            -t,--tag           filename tag (default: view1)"
   exit 
@@ -53,34 +53,22 @@ do
       shift # past argument
       shift # past value
       ;;
-    *)    # unknown option
-      #POSITIONAL+=("$1") # save it in an array for later
+    -[a-zA-Z]*) # unknown option
+      POSITIONAL+=("$1") # save it in an array for later
       echo "unknown option $1"
       print_the_help
       shift # past argument
       ;;
+    *)     # positional options
+      POSITIONAL+=("$1") # save it in an array for later
+      shift # past argument
+      ;;
   esac
 done
 set -- "${POSITIONAL[@]}" # restore positional parameters
 
 # units are mm
 
-echo "view14 produces a series of slightly rotated XY slices a different z locations. Along beamline"
-
-# slice at z = 2m
-# note the offset has to change with sign of the direction to cut in the opposite direction.
-dawncut 0  0  1  10005 ${INPUT_FILE} ${FILE_TAG}b_temp0.prim 
-dawncut 0  0 -1 -1000 ${FILE_TAG}b_temp0.prim  ${FILE_TAG}b.prim
-dawn -d ${FILE_TAG}b.prim 
-ps2pdf ${FILE_TAG}b.eps ${FILE_TAG}b_full.pdf
-gs -o ${FILE_TAG}b.pdf -sDEVICE=pdfwrite \
-  -c "[/CropBox [50 175 550 675] /PAGES pdfmark" \
-  -f ${FILE_TAG}b_full.pdf
-pdftoppm ${FILE_TAG}b.pdf ${FILE_TAG}b -png -singlefile -cropbox
-
-echo "done ..."
-
-
 original_file_tag="${FILE_TAG}"
 
 make_slice(){
@@ -102,7 +90,8 @@ make_slice(){
   rm "${FILE_TAG}_temp0.prim"
   rm "${FILE_TAG}.prim"
 }
-for zzz in $(seq 150 50 2000) ;
+
+for zzz in $@ ;
 do
   make_slice ${zzz} 
 done

scripts/view15/.DAWN_1.history

+0.0
+72.5
+189.5
+0
+0
+0
+1500
+50
+3
+0.001
+0
+1
+1
+1
+0.5
+0.5
+0.5
+25.5
+71
+0.001
+0.001
+0.001
+1
+70
+0.001
+1
+0
+1
+evince
+0
+0

scripts/view15/generate_eps

+#!/bin/bash
+
+#trignometry
+#sin ()
+#{
+#    echo "scale=5;s($1)" | bc -l
+#}
+#
+#add ()
+#{
+#    echo "scale=5;$1 + $2" | bc -l
+#}
+#
+#cos ()
+#{
+#    echo "scale=5;c($1)" | bc -l
+#}
+#
+#tan ()
+#{
+#    echo "scale=5;s($1)/c($1)" | bc -l
+#}
+
+
+function print_the_help {
+  echo "USAGE: $0 -i <PRIM_FILE> <slices ...> "
+  echo "  OPTIONS: "
+  echo "            -t,--tag           filename tag (default: view1)"
+  exit 
+}
+
+FILE_TAG="view15"
+INPUT_FILE="../../g4_0000.prim"
+
+
+POSITIONAL=()
+while [[ $# -gt 0 ]]
+do
+  key="$1"
+
+  case $key in
+    -h|--help)
+      shift # past argument
+      print_the_help
+      ;;
+    -t|--tag)
+      FILE_TAG="$2"
+      shift # past argument
+      shift # past value
+      ;;
+    -i|--input)
+      INPUT_FILE="$2"
+      shift # past argument
+      shift # past value
+      ;;
+    -[a-zA-Z]*) # unknown option
+      POSITIONAL+=("$1") # save it in an array for later
+      echo "unknown option $1"
+      print_the_help
+      shift # past argument
+      ;;
+    *)     # positional options
+      POSITIONAL+=("$1") # save it in an array for later
+      shift # past argument
+      ;;
+  esac
+done
+set -- "${POSITIONAL[@]}" # restore positional parameters
+
+# units are mm
+
+echo "view15 produces a series of slightly rotated XY slices a different z locations. Along beamline"
+
+# slice at z = 2m
+# note the offset has to change with sign of the direction to cut in the opposite direction.
+#dawncut 0  0  1  10005 ${INPUT_FILE} ${FILE_TAG}b_temp0.prim 
+#dawncut 0  0 -1 -1000 ${FILE_TAG}b_temp0.prim  ${FILE_TAG}b.prim
+#dawn  ${FILE_TAG}b.prim 
+#ps2pdf ${FILE_TAG}b.eps ${FILE_TAG}b_full.pdf
+#gs -o ${FILE_TAG}b.pdf -sDEVICE=pdfwrite \
+#  -c "[/CropBox [50 175 550 675] /PAGES pdfmark" \
+#  -f ${FILE_TAG}b_full.pdf
+#pdftoppm ${FILE_TAG}b.pdf ${FILE_TAG}b -png -singlefile -cropbox
+
+echo "done ..."
+
+
+original_file_tag="${FILE_TAG}"
+
+make_slice(){
+  local zpos="$1"
+  local tagnum=$(printf "%04d" ${zpos})
+  local FILE_TAG="${original_file_tag}a${tagnum}"
+  local z1=$(add ${zpos} 100)
+  local z2=$(add ${zpos} -100)
+  #dawncut 0 0 1 ${z1}1 ${INPUT_FILE} ${FILE_TAG}_temp0.prim 
+  #dawncut 0 0 -1 -${z2}0  ${FILE_TAG}_temp0.prim  ${FILE_TAG}.prim
+  ../../bin/dawn_tweak -z ${zpos}0 --draw 5
+  #cp ${INPUT_FILE} ${FILE_TAG}.prim
+  dawncut -1 0 0 0 ${INPUT_FILE} ${FILE_TAG}.prim 
+  dawn -d ${FILE_TAG}.prim 
+  ps2pdf ${FILE_TAG}.eps ${FILE_TAG}_full.pdf
+  gs -o ${FILE_TAG}.pdf -sDEVICE=pdfwrite \
+    -c "[/CropBox [50 175 550 675] /PAGES pdfmark" \
+    -f ${FILE_TAG}_full.pdf
+      pdftoppm ${FILE_TAG}.pdf ${FILE_TAG} -png -singlefile -cropbox
+  rm "${FILE_TAG}_temp0.prim"
+  rm "${FILE_TAG}.prim"
+}
+
+for zzz in $@ ;
+do
+  make_slice ${zzz} 
+done
+
+wait
+
+
+
+#dawncut 0  1 0 10 ${INPUT_FILE} ${FILE_TAG}c_temp0.prim 
+#dawncut 0 -1 0 0 ${FILE_TAG}c_temp0.prim  ${FILE_TAG}c.prim
+#dawn -d ${FILE_TAG}c.prim 
+#ps2pdf ${FILE_TAG}c.eps ${FILE_TAG}c_full.pdf
+#gs -o ${FILE_TAG}c.pdf -sDEVICE=pdfwrite \
+#  -c "[/CropBox [50 175 550 675] /PAGES pdfmark" \
+#  -f ${FILE_TAG}c_full.pdf
+#pdftoppm ${FILE_TAG}c.pdf ${FILE_TAG}c -png -singlefile -cropbox
+#
+## slice at z = -1m
+#dawncut 0 0 1 -1000 ${INPUT_FILE} ${FILE_TAG}d_temp0.prim 
+#dawncut 0 0 -1 1001 ${FILE_TAG}d_temp0.prim  ${FILE_TAG}d.prim
+#dawn -d ${FILE_TAG}d.prim 
+#ps2pdf ${FILE_TAG}d.eps ${FILE_TAG}d_full.pdf
+#gs -o ${FILE_TAG}d.pdf -sDEVICE=pdfwrite \
+#  -c "[/CropBox [50 175 550 675] /PAGES pdfmark" \
+#  -f ${FILE_TAG}d_full.pdf
+#pdftoppm ${FILE_TAG}d.pdf ${FILE_TAG}d -png -singlefile -cropbox
+#
+## slice at z = -2m
+#dawncut 0 0 1 -2000 ${INPUT_FILE} ${FILE_TAG}e_temp0.prim 
+#dawncut 0 0 -1 2001 ${FILE_TAG}e_temp0.prim  ${FILE_TAG}e.prim
+#dawn -d ${FILE_TAG}e.prim 
+#ps2pdf ${FILE_TAG}e.eps ${FILE_TAG}e_full.pdf
+#gs -o ${FILE_TAG}e.pdf -sDEVICE=pdfwrite \
+#  -c "[/CropBox [50 175 550 675] /PAGES pdfmark" \
+#  -f ${FILE_TAG}e_full.pdf
+#pdftoppm ${FILE_TAG}e.pdf ${FILE_TAG}e -png -singlefile -cropbox
+
+
+#https://geant4.kek.jp/~tanaka/DAWN/About_DAWNCUT.html
+# % dawncut a b c d input-file [output-file]
+#
+#       input-file : Source DAWN-format file describing a 3D scene.
+#
+#       output-file: Output DAWN-format file describing a plane-clipped 
+#                    3D scene.  The default output stream is stdout.
+#
+#       a, b, c, d : Parameters  a, b, c, and d  are double values to
+#                    define a clipping plane described with the following 
+#                    equation: 
+#
+#                       ax + by + cz + d = 0. 
+#
+#                    Vector (a,b,c) defines the normal vector of 
+#                    the clipping plane.  
+#                    3D scene data in the half space at the front side 
+#                    of the clipping plane are clipped out and erased. 
+#                    The normal vector (a,b,c) needs not be a unit vector. 
+#                    If it is a unit vector, parameter "d" gives distance 
+#                    between the clipping plane and origin (0,0,0).

scripts/view2/.DAWN_1.history

@@ -6,7 +6,7 @@
 0
 0
 8
-3
+1
 0.001
 0
 1

scripts/view20/.DAWN_1.history

+1.34392e+07
+90
+180
+0
+0
+0
+0
+1
+1
+0.001
+0
+1
+1
+1
+0.5
+0.5
+0.5
+19
+71
+0.001
+0.001
+0.001
+3
+71
+0.001
+0
+0
+1
+evince
+0
+0

scripts/view20/generate_eps

+#!/bin/bash
+
+#export DAWN_PS_PREVIEWER="derp"
+
+function print_the_help {
+  echo "USAGE: $0 <PRIM_FILE>  "
+  echo "  OPTIONS: "
+  echo "            -t,--tag           filename tag (default: view1)"
+  exit 
+}
+
+FILE_TAG="view20"
+INPUT_FILE="../../g4_0000.prim"
+
+
+POSITIONAL=()
+while [[ $# -gt 0 ]]
+do
+  key="$1"
+
+  case $key in
+    -h|--help)
+      shift # past argument
+      print_the_help
+      ;;
+    -t|--tag)
+      FILE_TAG="$2"
+      shift # past argument
+      shift # past value
+      ;;
+    -i|--input)
+      INPUT_FILE="$2"
+      shift # past argument
+      shift # past value
+      ;;
+    *)    # 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
+
+
+# Top view with a thin slice down the middle
+dawncut 0 1 0 1 ${INPUT_FILE} ${FILE_TAG}_top_temp0.prim   
+dawncut 0 -1 0 1 ${FILE_TAG}_top_temp0.prim  ${FILE_TAG}_top.prim
+../../bin/dawn_tweak --mag 2 --draw 1 --theta 90 --phi 90
+dawn -d ${FILE_TAG}_top.prim 
+ps2pdf ${FILE_TAG}_top.eps ${FILE_TAG}_top_full.pdf
+gs -o ${FILE_TAG}_top.pdf -sDEVICE=pdfwrite \
+  -c "[/CropBox [51 250 550 590] /PAGES pdfmark" \
+  -f ${FILE_TAG}_top_full.pdf
+pdftoppm ${FILE_TAG}_top.pdf ${FILE_TAG}_top -png -singlefile -cropbox -thinlinemode solid -aaVector yes
+
+# Side view (lines)
+dawncut 1 0 0 1 ${INPUT_FILE} ${FILE_TAG}_temp0.prim 
+dawncut -1 0 0 1 ${FILE_TAG}_temp0.prim  ${FILE_TAG}.prim
+../../bin/dawn_tweak --mag 1 --draw 1 --theta 180 --phi 90 
+dawn -d ${FILE_TAG}.prim
+ps2pdf ${FILE_TAG}.eps ${FILE_TAG}_full.pdf
+gs -o ${FILE_TAG}.pdf -sDEVICE=pdfwrite \
+  -c "[/CropBox [51 250 550 590] /PAGES pdfmark" \
+  -f ${FILE_TAG}_full.pdf
+pdftoppm ${FILE_TAG}.pdf ${FILE_TAG} -png -singlefile -cropbox -thinlinemode solid -aaVector yes
+
+#npdet_info print EcalEndcapN_z0 --value-only ../../athena.xml
+#180.5 cm
+zcut=$(npdet_info print EcalEndcapN_z0 --value-only ${DETECTOR_PATH}/athena.xml )
+NMOD1=$(npdet_info print EcalEndcapN_NModules_Sector1 --value-only ${DETECTOR_PATH}/calorimeters.xml )
+NMOD2=$(npdet_info print EcalEndcapN_NModules_Sector2 --value-only ${DETECTOR_PATH}/calorimeters.xml )
+
+echo "NMOD1 = ${NMOD1}"
+echo "NMOD2 = ${NMOD2}"
+echo "zcut  = ${zcut}"
+
+# Top view with a thin slice down the middle
+dawncut 0 0  1 -1800 ${INPUT_FILE} ${FILE_TAG}_endcapN_temp0.prim   
+dawncut 0 0 -1 2200 ${FILE_TAG}_endcapN_temp0.prim  ${FILE_TAG}_endcapN.prim
+../../bin/dawn_tweak --mag 5 --draw 3 --theta 180 --phi 0
+dawn -d ${FILE_TAG}_endcapN.prim 
+ps2pdf ${FILE_TAG}_endcapN.eps ${FILE_TAG}_endcapN_full.pdf
+gs -o ${FILE_TAG}_endcapN.pdf -sDEVICE=pdfwrite \
+  -c "[/CropBox [50 170 550 670] /PAGES pdfmark" \
+  -f ${FILE_TAG}_endcapN_full.pdf
+pdftoppm ${FILE_TAG}_endcapN.pdf ${FILE_TAG}_endcapN -png -singlefile -cropbox -thinlinemode solid \
+         -aaVector yes -r 1200
+convert -pointsize 180 -fill black -draw "text 200,200 \"$NMOD1 Crystals\"" \
+        ${FILE_TAG}_endcapN.png ${FILE_TAG}_endcapN.png
+convert -pointsize 180 -fill black -draw "text 200,400 \"$NMOD2 Glasses\"" \
+        ${FILE_TAG}_endcapN.png ${FILE_TAG}_endcapN.png
+

scripts/view5/.DAWN_1.history

+1.34392e+07
+0
+0
+1
+0
+0
+491.1
+1.2
+5
+0.001
+0
+1
+1
+1
+0.5
+0.5
+0.5
+19
+71
+0.01
+0.01
+0.01
+3
+70
+0.01
+1
+1
+1
+evince
+0
+0

scripts/view6/.DAWN_1.history

+1.34392e+07
+0
+180
+0
+0
+0
+0
+8.6
+1
+0.001
+0
+1
+1
+1
+0.5
+0.5
+0.5
+19
+71
+0.01
+0.01
+0.01
+3
+70
+0.01
+1
+1
+1
+evince
+0
+0

scripts/view6/generate_eps

@@ -59,6 +59,7 @@ INPUT_FILE=${FILE_TAG}_input.prim
 # units are mm
 dawncut 0 0 -1 1 ${INPUT_FILE} ${FILE_TAG}a_temp0.prim 
 dawncut 0 0 1 1  ${FILE_TAG}a_temp0.prim  ${FILE_TAG}a.prim
+../../bin/dawn_tweak --mag 14 
 dawn -d ${FILE_TAG}a.prim 
 ps2pdf ${FILE_TAG}a.eps ${FILE_TAG}a_full.pdf
 gs -o ${FILE_TAG}a.pdf -sDEVICE=pdfwrite \
@@ -69,6 +70,7 @@ pdftoppm ${FILE_TAG}a.pdf ${FILE_TAG}a -png -singlefile -cropbox
 #SiTracker Endcap layer 5 zstart = 860mm ( 90 mm thick )
 dawncut 0 0 1   945   ${INPUT_FILE} ${FILE_TAG}b_temp0.prim 
 dawncut 0 0 -1 -865 ${FILE_TAG}b_temp0.prim  ${FILE_TAG}b.prim
+../../bin/dawn_tweak --mag 14 
 dawn -d ${FILE_TAG}b.prim 
 ps2pdf ${FILE_TAG}b.eps ${FILE_TAG}b_full.pdf
 gs -o ${FILE_TAG}b.pdf -sDEVICE=pdfwrite \
@@ -79,6 +81,7 @@ pdftoppm ${FILE_TAG}b.pdf ${FILE_TAG}b -png -singlefile -cropbox
 #SiTracker Endcap layer 4 zstart = 695mm ( 90 mm thick )
 dawncut 0 0 1 780   ${INPUT_FILE} ${FILE_TAG}c_temp0.prim 
 dawncut 0 0 -1 -700 ${FILE_TAG}c_temp0.prim  ${FILE_TAG}c.prim
+../../bin/dawn_tweak --mag 14 
 dawn -d ${FILE_TAG}c.prim 
 ps2pdf ${FILE_TAG}c.eps ${FILE_TAG}c_full.pdf
 gs -o ${FILE_TAG}c.pdf -sDEVICE=pdfwrite \
@@ -101,6 +104,7 @@ pdftoppm ${FILE_TAG}d.pdf ${FILE_TAG}d -png -singlefile -cropbox
 # slice at z = -2m
 dawncut 0 0 1 430 ${INPUT_FILE} ${FILE_TAG}e_temp0.prim 
 dawncut 0 0 -1 -370 ${FILE_TAG}e_temp0.prim  ${FILE_TAG}e.prim
+../../bin/dawn_tweak --mag 14 
 dawn -d ${FILE_TAG}e.prim 
 ps2pdf ${FILE_TAG}e.eps ${FILE_TAG}e_full.pdf
 gs -o ${FILE_TAG}e.pdf -sDEVICE=pdfwrite \
@@ -111,6 +115,7 @@ pdftoppm ${FILE_TAG}e.pdf ${FILE_TAG}e -png -singlefile -cropbox
 #SiTracker Endcap layer 1 zstart = 200mm ( 30 mm thick )
 dawncut 0 0 1 225 ${INPUT_FILE} ${FILE_TAG}f_temp0.prim 
 dawncut 0 0 -1 205 ${FILE_TAG}f_temp0.prim  ${FILE_TAG}f.prim
+../../bin/dawn_tweak --mag 14 
 dawn -d ${FILE_TAG}f.prim 
 ps2pdf ${FILE_TAG}f.eps ${FILE_TAG}f_full.pdf
 gs -o ${FILE_TAG}f.pdf -sDEVICE=pdfwrite \

src/BarrelBarDetectorWithSideFrame_geo.cpp

+/** \addtogroup PID
+ * \brief Type: **Barrel bar detector (think DIRC) with longitudinal frame**.
+ * \author S. Joosten
+ *
+ * \ingroup PID
+ *
+ *
+ * \code
+ * \endcode
+ *
+ * @{
+ */
+#include "DD4hep/DetFactoryHelper.h"
+#include "DD4hep/Printout.h"
+#include "DD4hep/Shapes.h"
+#include "DDRec/DetectorData.h"
+#include "DDRec/Surface.h"
+#include "XML/Layering.h"
+#include <array>
+
+using namespace std;
+using namespace dd4hep;
+
+/** Barrel Bar detector with optional framek
+ *
+ * - Optional "frame" tag within the module element (frame eats part of the module width
+ *   and is longitudinal at both sides)
+ * - Detector is setup as a "tracker" so we can use the hits to perform fast MC
+ *   for e.g. the DIRC
+ *
+ */
+static Ref_t create_BarrelBarDetectorWithSideFrame(Detector& description, xml_h e, SensitiveDetector sens)
+{
+  typedef vector<PlacedVolume>            Placements;
+  xml_det_t                               x_det    = e;
+  Material                                air      = description.air();
+  int                                     det_id   = x_det.id();
+  string                                  det_name = x_det.nameStr();
+  DetElement                              sdet(det_name, det_id);
+  map<string, Volume>                     volumes;
+  map<string, Placements>                 sensitives;
+  map<string, std::vector<rec::VolPlane>> volplane_surfaces;
+  PlacedVolume                            pv;
+  dd4hep::xml::Dimension                  dimensions(x_det.dimensions());
+  xml_dim_t                               dirc_pos = x_det.position();
+
+  map<string, std::array<double, 2>> module_thicknesses;
+
+  Tube   topVolumeShape(dimensions.rmin(), dimensions.rmax(), dimensions.length() * 0.5);
+  Volume assembly(det_name, topVolumeShape, air);
+
+  sens.setType("tracker");
+
+  // loop over the modules
+  for (xml_coll_t mi(x_det, _U(module)); mi; ++mi) {
+    xml_comp_t x_mod = mi;
+    string     m_nam = x_mod.nameStr();
+
+    if (volumes.find(m_nam) != volumes.end()) {
+      printout(ERROR, "BarrelBarDetectorWithSideFrame",
+               string((string("Module with named ") + m_nam + string(" already exists."))).c_str());
+      throw runtime_error("Logics error in building modules.");
+    }
+
+    int    ncomponents     = 0;
+    int    sensor_number   = 1;
+    double total_thickness = 0;
+
+    // Compute module total thickness from components
+    xml_coll_t ci(x_mod, _U(module_component));
+    for (ci.reset(), total_thickness = 0.0; ci; ++ci) {
+      total_thickness += xml_comp_t(ci).thickness();
+    }
+    // the module assembly volume
+    Assembly m_vol(m_nam);
+    volumes[m_nam] = m_vol;
+    m_vol.setVisAttributes(description, x_mod.visStr());
+
+    // Optional module frame.
+    // frame is 2 longitudinal bars at the side of the module
+    //
+    // |___| <-- example module cross section (x-y plane), frame is flush with the
+    //           bottom of the module and protrudes on the top if needed
+    //
+
+    // Get frame width, as it impacts the main module for being built. We
+    // construct the actual frame structure later (once we know the module width)
+    double frame_width = 0;
+    if (x_mod.hasChild("frame")) {
+      xml_comp_t m_frame = x_mod.child(_U(frame));
+      frame_width        = m_frame.width();
+    }
+
+    double thickness_so_far    = 0.0;
+    double thickness_sum       = -total_thickness / 2.0;
+    double max_component_width = 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);
+      string     c_nam  = _toString(ncomponents, "component%d");
+
+      double box_width    = x_comp.width() - 2 * frame_width;
+      max_component_width = fmax(max_component_width, box_width);
+
+      Box    c_box{box_width / 2, x_comp.length() / 2, x_comp.thickness() / 2};
+      Volume c_vol{c_nam, c_box, description.material(x_comp.materialStr())};
+
+      pv = m_vol.placeVolume(c_vol, Position(0, 0, thickness_sum + x_comp.thickness() / 2.0));
+
+      c_vol.setRegion(description, x_comp.regionStr());
+      c_vol.setLimitSet(description, x_comp.limitsStr());
+      c_vol.setVisAttributes(description, x_comp.visStr());
+      if (x_comp.isSensitive()) {
+        c_vol.setSensitiveDetector(sens);
+        sensitives[m_nam].push_back(pv);
+        module_thicknesses[m_nam] = {thickness_so_far + x_comp.thickness() / 2.0,
+                                     total_thickness - thickness_so_far - x_comp.thickness() / 2.0};
+        // -------- create a measurement plane for the tracking surface attched to the sensitive volume -----
+        rec::Vector3D u(0., 1., 0.);
+        rec::Vector3D v(0., 0., 1.);
+        rec::Vector3D n(1., 0., 0.);
+
+        // compute the inner and outer thicknesses that need to be assigned to the tracking surface
+        // depending on wether the support is above or below the sensor
+        double inner_thickness = module_thicknesses[m_nam][0];
+        double outer_thickness = module_thicknesses[m_nam][1];
+
+        rec::SurfaceType type(rec::SurfaceType::Sensitive);
+
+        rec::VolPlane surf(c_vol, type, inner_thickness, outer_thickness, u, v, n); //,o ) ;
+        volplane_surfaces[m_nam].push_back(surf);
+      }
+      thickness_sum += x_comp.thickness();
+      thickness_so_far += x_comp.thickness();
+    }
+    // Now add-on the frame
+    if (x_mod.hasChild("frame")) {
+      xml_comp_t m_frame         = x_mod.child(_U(frame));
+      double     frame_thickness = getAttrOrDefault<double>(m_frame, _U(thickness), total_thickness);
+
+      Box lframe_box{m_frame.width() / 2., m_frame.length() / 2., frame_thickness / 2.};
+      Box rframe_box{m_frame.width() / 2., m_frame.length() / 2., frame_thickness / 2.};
+
+      // Keep track of frame with so we can adjust the module bars appropriately
+
+      Volume lframe_vol{"left_frame", lframe_box, description.material(m_frame.materialStr())};
+      Volume rframe_vol{"right_frame", rframe_box, description.material(m_frame.materialStr())};
+      lframe_vol.setVisAttributes(description, m_frame.visStr());
+      rframe_vol.setVisAttributes(description, m_frame.visStr());
+
+      m_vol.placeVolume(lframe_vol, Position(frame_width / 2. + max_component_width / 2, 0.,
+                                             frame_thickness / 2. - total_thickness / 2.0));
+      m_vol.placeVolume(rframe_vol, Position(-frame_width / 2. - max_component_width / 2, 0.,
+                                             frame_thickness / 2. - total_thickness / 2.0));
+    }
+  }
+
+  // now build the layers
+  for (xml_coll_t li(x_det, _U(layer)); li; ++li) {
+    xml_comp_t x_layer  = li;
+    xml_comp_t x_barrel = x_layer.child(_U(barrel_envelope));
+    xml_comp_t x_layout = x_layer.child(_U(rphi_layout));
+    xml_comp_t z_layout = x_layer.child(_U(z_layout)); // Get the <z_layout> element.
+    int        lay_id   = x_layer.id();
+    string     m_nam    = x_layer.moduleStr();
+    string     lay_nam  = _toString(x_layer.id(), "layer%d");
+    Tube       lay_tub(x_barrel.inner_r(), x_barrel.outer_r(), x_barrel.z_length() / 2.0);
+    Volume     lay_vol(lay_nam, lay_tub, air); // Create the layer envelope volume.
+    lay_vol.setVisAttributes(description, x_layer.visStr());
+
+    double phi0     = x_layout.phi0();     // Starting phi of first module.
+    double phi_tilt = x_layout.phi_tilt(); // Phi tilt of a module.
+    double rc       = x_layout.rc();       // Radius of the module center.
+    int    nphi     = x_layout.nphi();     // Number of modules in phi.
+    double rphi_dr  = x_layout.dr();       // The delta radius of every other module.
+    double phi_incr = (M_PI * 2) / nphi;   // Phi increment for one module.
+    double phic     = phi0;                // Phi of the module center.
+    double z0       = z_layout.z0();       // Z position of first module in phi.
+    double nz       = z_layout.nz();       // Number of modules to place in z.
+    double z_dr     = z_layout.dr();       // Radial displacement parameter, of every other module.
+
+    Volume      module_env = volumes[m_nam];
+    DetElement  lay_elt(sdet, _toString(x_layer.id(), "layer%d"), lay_id);
+    Placements& sensVols = sensitives[m_nam];
+
+    // Z increment for module placement along Z axis.
+    // Adjust for z0 at center of module rather than
+    // the end of cylindrical envelope.
+    double z_incr = nz > 1 ? (2.0 * z0) / (nz - 1) : 0.0;
+    // Starting z for module placement along Z axis.
+    double module_z = -z0;
+    int    module   = 1;
+
+    // Loop over the number of modules in phi.
+    for (int ii = 0; ii < nphi; ii++) {
+      double dx = z_dr * std::cos(phic + phi_tilt); // Delta x of module position.
+      double dy = z_dr * std::sin(phic + phi_tilt); // Delta y of module position.
+      double x  = rc * std::cos(phic);              // Basic x module position.
+      double y  = rc * std::sin(phic);              // Basic y module position.
+
+      // Loop over the number of modules in z.
+      for (int j = 0; j < nz; j++) {
+        string     module_name = _toString(module, "module%d");
+        DetElement mod_elt(lay_elt, module_name, module);
+
+        Transform3D tr(RotationZYX(0, ((M_PI / 2) - phic - phi_tilt), -M_PI / 2), Position(x, y, module_z));
+
+        pv = lay_vol.placeVolume(module_env, tr);
+        pv.addPhysVolID("module", module);
+        pv.addPhysVolID("section", j);
+        mod_elt.setPlacement(pv);
+        for (size_t ic = 0; ic < sensVols.size(); ++ic) {
+          PlacedVolume sens_pv = sensVols[ic];
+          DetElement   comp_de(mod_elt, std::string("de_") + sens_pv.volume().name(), module);
+          comp_de.setPlacement(sens_pv);
+          rec::volSurfaceList(comp_de)->push_back(volplane_surfaces[m_nam][ic]);
+        }
+
+        /// Increase counters etc.
+        module++;
+        // Adjust the x and y coordinates of the module.
+        x += dx;
+        y += dy;
+        // Flip sign of x and y adjustments.
+        dx *= -1;
+        dy *= -1;
+        // Add z increment to get next z placement pos.
+        module_z += z_incr;
+      }
+      phic += phi_incr; // Increment the phi placement of module.
+      rc += rphi_dr;    // Increment the center radius according to dr parameter.
+      rphi_dr *= -1;    // Flip sign of dr parameter.
+      module_z = -z0;   // Reset the Z placement parameter for module.
+    }
+    // Create the PhysicalVolume for the layer.
+    pv = assembly.placeVolume(lay_vol); // Place layer in mother
+    pv.addPhysVolID("layer", lay_id);   // Set the layer ID.
+    lay_elt.setAttributes(description, lay_vol, x_layer.regionStr(), x_layer.limitsStr(), x_layer.visStr());
+    lay_elt.setPlacement(pv);
+  }
+  sdet.setAttributes(description, assembly, x_det.regionStr(), x_det.limitsStr(), x_det.visStr());
+  assembly.setVisAttributes(description.invisible());
+  pv = description.pickMotherVolume(sdet).placeVolume(assembly, Position(0, 0, dirc_pos.z()));
+  pv.addPhysVolID("system", det_id); // Set the subdetector system ID.
+  sdet.setPlacement(pv);
+  return sdet;
+}
+
+//@}
+// clang-format off
+DECLARE_DETELEMENT(BarrelBarDetectorWithSideFrame, create_BarrelBarDetectorWithSideFrame)
+DECLARE_DETELEMENT(athena_FakeDIRC, create_BarrelBarDetectorWithSideFrame)

src/BarrelCalorimeterInterlayers_geo.cpp

+// Detector plugin to support a hybrid central barrel calorimeter
+// The detector consists of interlayers of Pb/ScFi (segmentation in global r, phi) and W/Si (segmentation in local x, y)
+// Assembly is used as the envelope so two different detectors can be interlayered with each other
+//
+//
+// 06/19/2021: Implementation of the Sci Fiber geometry. M. Żurek
+// 07/09/2021: Support interlayers between multiple detectors. C. Peng
+// 07/23/2021: Add assemblies as mother volumes of fibers to reduce the number of daughter volumes. C. Peng, M. Żurek
+//     Reference: TGeo performance issue with large number of daughter volumes
+//     https://indico.cern.ch/event/967418/contributions/4075358/attachments/2128099/3583278/201009_shKo_dd4hep.pdf
+// 07/24/2021: Changed support implementation to avoid too many uses of boolean geometries. DAWN view seems to have
+//     issue dealing with it. C. Peng
+
+#include "DD4hep/DetFactoryHelper.h"
+#include "XML/Layering.h"
+#include "Math/Point2D.h"
+#include "TGeoPolygon.h"
+
+using namespace std;
+using namespace dd4hep;
+using namespace dd4hep::detail;
+
+typedef ROOT::Math::XYPoint Point;
+// 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);
+vector<tuple<int, Point, Point, Point, Point>> gridPoints(int div_x, int div_z, double x, double z, double phi);
+
+// geometry helpers
+void buildFibers(Detector& desc, SensitiveDetector &sens, Volume &mother, xml_comp_t x_fiber,
+                 const std::tuple<double, double, double, double> &dimensions);
+void buildSupport(Detector& desc, Volume &mother, xml_comp_t x_support,
+                  const std::tuple<double, double, double, double> &dimensions);
+
+
+// barrel ecal layers contained in an assembly
+static Ref_t create_detector(Detector& desc, xml_h e, SensitiveDetector sens)  {
+  Layering      layering (e);
+  xml_det_t     x_det     = e;
+  Material      air       = desc.air();
+  int           det_id    = x_det.id();
+  string        det_name  = x_det.nameStr();
+  double        offset    = x_det.attr<double>(_Unicode(offset));
+  xml_comp_t    x_dim     = x_det.dimensions();
+  int           nsides    = x_dim.numsides();
+  double        inner_r   = x_dim.rmin();
+  double        dphi      = (2*M_PI/nsides);
+  double        hphi      = dphi/2;
+
+  DetElement    sdet      (det_name, det_id);
+  Volume        motherVol = desc.pickMotherVolume(sdet);
+
+  Assembly      envelope  (det_name);
+  Transform3D   tr        = Translation3D(0, 0, offset) * RotationZ(hphi);
+  PlacedVolume  env_phv   = motherVol.placeVolume(envelope, tr);
+  sens.setType("calorimeter");
+
+  env_phv.addPhysVolID("system",det_id);
+  sdet.setPlacement(env_phv);
+
+  // build a single stave
+  DetElement    stave_det("stave0", det_id);
+  Assembly      mod_vol("stave");
+
+  // keep tracking of the total thickness
+  double l_pos_z = inner_r;
+  { // =====  buildBarrelStave(desc, sens, module_volume) =====
+    // Parameters for computing the layer X dimension:
+    double tan_hphi = std::tan(hphi);
+    double l_dim_y  = x_dim.z()/2.;
+
+    // Loop over the sets of layer elements in the detector.
+    int l_num = 1;
+    for(xml_coll_t li(x_det, _U(layer)); li; ++li)  {
+      xml_comp_t x_layer = li;
+      int repeat = x_layer.repeat();
+      double l_space_between = dd4hep::getAttrOrDefault(x_layer, _Unicode(space_between), 0.);
+      double l_space_before = dd4hep::getAttrOrDefault(x_layer, _Unicode(space_before), 0.);
+      l_pos_z += l_space_before;
+      // Loop over number of repeats for this layer.
+      for (int j = 0; j < repeat; j++)    {
+        string l_name = Form("layer%d", l_num);
+        double l_thickness = layering.layer(l_num - 1)->thickness();  // Layer's thickness.
+        double l_dim_x = tan_hphi* l_pos_z;
+        l_pos_z += l_thickness;
+
+        Position   l_pos(0, 0, l_pos_z - l_thickness/2.);      // Position of the layer.
+	    double l_trd_x1 = l_dim_x;
+	    double l_trd_x2 = l_dim_x + l_thickness*tan_hphi;
+	    double l_trd_y1 = l_dim_y;
+	    double l_trd_y2 = l_trd_y1;
+	    double l_trd_z  = l_thickness/2;
+        Trapezoid  l_shape(l_trd_x1, l_trd_x2, l_trd_y1, l_trd_y2, l_trd_z);
+        Volume     l_vol(l_name, l_shape, air);
+        DetElement layer(stave_det, l_name, det_id);
+
+        // Loop over the sublayers or slices for this layer.
+        int s_num = 1;
+        double s_pos_z = -(l_thickness / 2.);
+        for(xml_coll_t si(x_layer,_U(slice)); si; ++si)  {
+          xml_comp_t x_slice = si;
+          string     s_name  = Form("slice%d", s_num);
+          double     s_thick = x_slice.thickness();
+	      double s_trd_x1 = l_dim_x + (s_pos_z + l_thickness/2)*tan_hphi;
+	      double s_trd_x2 = l_dim_x + (s_pos_z + l_thickness/2 + s_thick)*tan_hphi;
+	      double s_trd_y1 = l_trd_y1;
+	      double s_trd_y2 = s_trd_y1;
+	      double s_trd_z  = s_thick/2.;
+          Trapezoid  s_shape(s_trd_x1, s_trd_x2, s_trd_y1, s_trd_y2, s_trd_z);
+          Volume     s_vol(s_name, s_shape, desc.material(x_slice.materialStr()));
+          DetElement slice(layer, s_name, det_id);
+
+          // build fibers
+          if (x_slice.hasChild(_Unicode(fiber))) {
+              buildFibers(desc, sens, s_vol, x_slice.child(_Unicode(fiber)), {s_trd_x1, s_thick, l_dim_y, hphi});
+          }
+
+          if ( x_slice.isSensitive() ) {
+            s_vol.setSensitiveDetector(sens);
+          }
+          s_vol.setAttributes(desc, x_slice.regionStr(), x_slice.limitsStr(), x_slice.visStr());
+
+          // Slice placement.
+          PlacedVolume slice_phv = l_vol.placeVolume(s_vol, Position(0, 0, s_pos_z + s_thick/2));
+          slice_phv.addPhysVolID("slice", s_num);
+          slice.setPlacement(slice_phv);
+          // Increment Z position of slice.
+          s_pos_z += s_thick;
+          ++s_num;
+        }
+
+        // Set region, limitset, and vis of layer.
+        l_vol.setAttributes(desc, x_layer.regionStr(), x_layer.limitsStr(), x_layer.visStr());
+
+        PlacedVolume layer_phv = mod_vol.placeVolume(l_vol, l_pos);
+        layer_phv.addPhysVolID("layer", l_num);
+        layer.setPlacement(layer_phv);
+        // Increment to next layer Z position. Do not add space_between for the last layer
+        if (j < repeat - 1) {
+          l_pos_z += l_space_between;
+        }
+        ++l_num;
+      }
+    }
+  }
+  // Phi start for a stave.
+  double phi = M_PI / nsides;
+  // Create nsides staves.
+  for (int i = 0; i < nsides; i++, phi -= dphi)      { // i is module number
+    // Compute the stave position
+    Transform3D tr(RotationZYX(0, phi, M_PI*0.5), Translation3D(0, 0, 0));
+    PlacedVolume pv = envelope.placeVolume(mod_vol, tr);
+    pv.addPhysVolID("module", i + 1);
+    DetElement sd = (i == 0) ? stave_det : stave_det.clone(Form("stave%d", i));
+    sd.setPlacement(pv);
+    sdet.add(sd);
+  }
+
+  // optional stave support
+  if (x_det.hasChild(_U(staves))) {
+    xml_comp_t x_staves = x_det.staves();
+    mod_vol.setVisAttributes(desc.visAttributes(x_staves.visStr()));
+    if (x_staves.hasChild(_U(support))) {
+      buildSupport(desc, mod_vol, x_staves.child(_U(support)), {inner_r, l_pos_z, x_dim.z(), hphi});
+    }
+  }
+
+  // Set envelope volume attributes.
+  envelope.setAttributes(desc, x_det.regionStr(), x_det.limitsStr(), x_det.visStr());
+  return sdet;
+}
+
+void buildFibers(Detector& desc, SensitiveDetector &sens, Volume &s_vol, xml_comp_t x_fiber,
+                 const std::tuple<double, double, double, double> &dimensions)
+{
+  auto [s_trd_x1, s_thick, s_length, hphi] = dimensions;
+  double f_radius = getAttrOrDefault(x_fiber, _U(radius), 0.1 * cm);
+  double f_spacing_x = getAttrOrDefault(x_fiber, _Unicode(spacing_x), 0.122 * cm);
+  double f_spacing_z = getAttrOrDefault(x_fiber, _Unicode(spacing_z), 0.134 * cm);
+  std::string f_id_grid = getAttrOrDefault(x_fiber, _Unicode(identifier_grid), "grid");
+  std::string f_id_fiber = getAttrOrDefault(x_fiber, _Unicode(identifier_fiber), "fiber");
+
+  // Set up the readout grid for the fiber layers
+  // Trapezoid is divided into segments with equal dz and equal number of divisions in x
+  // Every segment is a polygon that can be attached later to the lightguide
+  // The grid size is assumed to be ~2x2 cm (starting values). This is to be larger than
+  // SiPM chip (for GlueX 13mmx13mm: 4x4 grid 3mmx3mm with 3600 50×50 μm pixels each)
+  // See, e.g., https://arxiv.org/abs/1801.03088 Fig. 2d
+
+  // Calculate number of divisions
+  auto grid_div = getNdivisions(s_trd_x1, s_thick, 2.0*cm, 2.0*cm);
+  // Calculate polygonal grid coordinates (vertices)
+  auto grid_vtx = gridPoints(grid_div.first, grid_div.second, s_trd_x1, s_thick, hphi);
+  Tube f_tube(0, f_radius, s_length);
+  Volume f_vol("fiber_vol", f_tube, desc.material(x_fiber.materialStr()));
+
+  vector<int> f_id_count(grid_div.first*grid_div.second, 0);
+  auto f_pos = fiberPositions(f_radius, f_spacing_x, f_spacing_z, s_trd_x1, s_thick, hphi);
+  // std::cout << f_pos.size() << " lines, ~" << f_pos.front().size() << " fibers each line" << std::endl;
+  for (size_t il = 0; il < f_pos.size(); ++il) {
+    auto &line = f_pos[il];
+    if (line.empty()) {
+      continue;
+    }
+    double l_pos_y = line.front().y();
+    // use assembly as intermediate volume container to reduce number of daughter volumes
+    Assembly lfibers(Form("fiber_array_line_%lu", il));
+    for (auto &p : line) {
+      int f_grid_id = -1;
+      int f_id = -1;
+      // Check to which grid fiber belongs to
+      for (auto &poly_vtx : grid_vtx) {
+        if (p.y() != l_pos_y) {
+          std::cerr << Form("Expected the same y position from a same line: %.2f, but got %.2f", l_pos_y, p.y())
+                    << std::endl;
+          continue;
+        }
+        auto [grid_id, vtx_a, vtx_b, vtx_c, vtx_d] = poly_vtx;
+        double poly_x[4] = {vtx_a.x(), vtx_b.x(), vtx_c.x(), vtx_d.x()};
+        double poly_y[4] = {vtx_a.y(), vtx_b.y(), vtx_c.y(), vtx_d.y()};
+        double f_xy[2] = {p.x(), p.y()};
+
+        TGeoPolygon poly(4);
+        poly.SetXY(poly_x, poly_y);
+        poly.FinishPolygon();
+
+        if(poly.Contains(f_xy)) {
+          f_grid_id = grid_id;
+          f_id = f_id_count[grid_id];
+          f_id_count[grid_id]++;
+        }
+      }
+
+      if ( x_fiber.isSensitive() ) {
+        f_vol.setSensitiveDetector(sens);
+      }
+      f_vol.setAttributes(desc, x_fiber.regionStr(), x_fiber.limitsStr(), x_fiber.visStr());
+
+      // Fiber placement
+      // Transform3D f_tr(RotationZYX(0,0,M_PI*0.5),Position(p.x(), 0, p.y()));
+      // PlacedVolume fiber_phv = s_vol.placeVolume(f_vol, Position(p.x(), 0., p.y()));
+      PlacedVolume fiber_phv = lfibers.placeVolume(f_vol, Position(p.x(), 0., 0.));
+      fiber_phv.addPhysVolID(f_id_grid, f_grid_id + 1).addPhysVolID(f_id_fiber, f_id + 1);
+    }
+    lfibers.ptr()->Voxelize("");
+    Transform3D l_tr(RotationZYX(0,0,M_PI*0.5),Position(0., 0, l_pos_y));
+    s_vol.placeVolume(lfibers, l_tr);
+  }
+}
+
+// DAWN view seems to have some issue with overlapping solids even if they were unions
+// The support is now built without overlapping
+void buildSupport(Detector& desc, Volume &mod_vol, xml_comp_t x_support,
+                  const std::tuple<double, double, double, double> &dimensions)
+{
+  auto [inner_r, l_pos_z, stave_length, hphi] = dimensions;
+
+  double support_thickness = getAttrOrDefault(x_support, _Unicode(thickness), 5. * cm);
+  double beam_thickness    = getAttrOrDefault(x_support, _Unicode(beam_thickness), support_thickness/4.);
+  // sanity check
+  if (beam_thickness > support_thickness/3.) {
+    std::cerr << Form("beam_thickness (%.2f) cannot be greater than support_thickness/3 (%.2f), shrink it to fit",
+                      beam_thickness, support_thickness/3.) << std::endl;
+    beam_thickness = support_thickness/3.;
+  }
+  double   trd_x1_support = std::tan(hphi) * l_pos_z;
+  double   trd_x2_support = std::tan(hphi) * (l_pos_z + support_thickness);
+  double   trd_y          = stave_length / 2.;
+  Assembly env_vol        ("support_envelope");
+
+  double grid_size        = getAttrOrDefault(x_support, _Unicode(grid_size), 25. * cm);
+  int    n_cross_supports = std::floor(trd_y - beam_thickness)/grid_size;
+  // number of "beams" running the length of the stave.
+  // @TODO make it configurable
+  int    n_beams          = getAttrOrDefault(x_support, _Unicode(n_beams), 3);;
+  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 T-shape beam
+  double beam_space_x    = beam_width + beam_gap;
+  double beam_space_z    = support_thickness - beam_thickness;
+  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_hori_s(beam_width / 2., trd_y, beam_thickness / 2.);
+  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);
+    env_vol.placeVolume(H_beam_vol, beam_pos);
+  }
+
+  // place central crossing beams that connects the H beams
+  double cross_x = beam_space_x - beam_thickness;
+  Box cross_s(cross_x / 2., beam_thickness / 2., cross_thickness / 2.);
+  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., 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, beam_pos_z));
+      env_vol.placeVolume(cross_vol, Position(beam_start_x + beam_space_x * (i + 0.5), j * grid_size, beam_pos_z));
+    }
+  }
+
+  // place edge crossing beams that connects the neighbour support
+  // @TODO: connection part is still using boolean volumes, maybe problematic to DAWN
+  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 - 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)/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., 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, 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/BarrelCalorimeter_geo.cpp

+//==========================================================================
+//  AIDA Detector description implementation 
+//--------------------------------------------------------------------------
+// Copyright (C) Organisation europeenne pour la Recherche nucleaire (CERN)
+// All rights reserved.
+//
+// For the licensing terms see $DD4hepINSTALL/LICENSE.
+// For the list of contributors see $DD4hepINSTALL/doc/CREDITS.
+//
+// Author     : M.Frank
+//
+//==========================================================================
+//
+// Specialized generic detector constructor
+//
+//==========================================================================
+#include "DD4hep/DetFactoryHelper.h"
+#include "XML/Layering.h"
+
+using namespace std;
+using namespace dd4hep;
+using namespace dd4hep::detail;
+
+static Ref_t create_detector(Detector& description, xml_h e, SensitiveDetector sens)  {
+  static double tolerance = 0e0;
+  Layering      layering (e);
+  xml_det_t     x_det     = e;
+  Material      air       = description.air();
+  int           det_id    = x_det.id();
+  string        det_name  = x_det.nameStr();
+  xml_comp_t    x_staves  = x_det.staves();
+  xml_comp_t    x_dim     = x_det.dimensions();
+  int           nsides    = x_dim.numsides();
+  double        inner_r   = x_dim.rmin();
+  double        dphi      = (2*M_PI/nsides);
+  double        hphi      = dphi/2;
+  double        support_thickness = 0.0;
+  if(x_staves.hasChild("support")){
+    support_thickness = getAttrOrDefault(x_staves.child(_U(support)), _U(thickness), 5.0 * cm);
+  }
+  double        mod_z     = layering.totalThickness() + support_thickness;
+  double        outer_r   = inner_r + mod_z;
+  double        totThick  = mod_z;
+  double        offset    = x_det.attr<double>(_Unicode(offset));
+  DetElement    sdet      (det_name,det_id);
+  Volume        motherVol = description.pickMotherVolume(sdet);
+  PolyhedraRegular hedra  (nsides,inner_r,inner_r+totThick+tolerance*2e0,x_dim.z());
+  Volume        envelope  (det_name,hedra,air);
+  PlacedVolume  env_phv   = motherVol.placeVolume(envelope,Transform3D(Translation3D(0,0,offset)*RotationZ(M_PI/nsides)));
+
+  env_phv.addPhysVolID("system",det_id);
+  env_phv.addPhysVolID("barrel",0);
+  sdet.setPlacement(env_phv);
+
+  DetElement    stave_det("stave0",det_id);
+  double dx = 0.0; //mod_z / std::sin(dphi); // dx per layer
+
+  // Compute the top and bottom face measurements.
+  double trd_x2 = (2 * std::tan(hphi) * outer_r - dx)/2 - tolerance;
+  double trd_x1 = (2 * std::tan(hphi) * inner_r + dx)/2 - tolerance;
+  double trd_y1 = x_dim.z()/2 - tolerance;
+  double trd_y2 = trd_y1;
+  double trd_z  = mod_z/2 - tolerance;
+
+  // Create the trapezoid for the stave.
+  Trapezoid trd(trd_x1, // Outer side, i.e. the "short" X side.
+                trd_x2, // Inner side, i.e. the "long"  X side.
+                trd_y1, // Corresponds to subdetector (or module) Z.
+                trd_y2, //
+                trd_z); // Thickness, in Y for top stave, when rotated.
+
+  Volume mod_vol("stave",trd,air);
+  double l_pos_z = -(layering.totalThickness() / 2) - support_thickness/2.0;
+
+  //double trd_x2_support = trd_x1;
+  double trd_x1_support = (2 * std::tan(hphi) * outer_r - dx- support_thickness)/2 - tolerance;
+
+  Solid  support_frame_s;
+  // optional stave support
+  if(x_staves.hasChild("support")){
+    xml_comp_t x_support         = x_staves.child(_U(support));
+    // is the support on the inside surface?
+    bool       is_inside_support = getAttrOrDefault<bool>(x_support, _Unicode(inside), true);
+    // number of "beams" running the length of the stave.
+    int    n_beams        = getAttrOrDefault<int>(x_support, _Unicode(n_beams), 3);
+    double beam_thickness = support_thickness / 4.0; // maybe a parameter later...
+    trd_x1_support        = (2 * std::tan(hphi) * (outer_r - support_thickness + beam_thickness)) / 2 - tolerance;
+    double grid_size      = getAttrOrDefault(x_support, _Unicode(grid_size), 25.0 * cm);
+    double beam_width     = 2.0 * trd_x1_support / (n_beams + 1); // quick hack to make some gap between T beams
+
+    double cross_beam_thickness    = support_thickness/4.0;
+    //double trd_x1_support    = (2 * std::tan(hphi) * (inner_r + beam_thickness)) / 2 - tolerance;
+    double trd_x2_support = trd_x2;
+
+    int n_cross_supports = std::floor((trd_y1-cross_beam_thickness)/grid_size);
+
+    Box        beam_vert_s(beam_thickness / 2.0 - tolerance, trd_y1, support_thickness / 2.0 - tolerance);
+    Box        beam_hori_s(beam_width / 2.0 - tolerance, trd_y1, beam_thickness / 2.0 - tolerance);
+    UnionSolid T_beam_s(beam_vert_s, beam_hori_s, Position(0, 0, -support_thickness / 2.0 + beam_thickness / 2.0));
+
+    // cross supports
+    Trapezoid  trd_support(trd_x1_support,trd_x2_support,
+                           beam_thickness / 2.0 - tolerance, beam_thickness / 2.0 - tolerance,
+                          support_thickness / 2.0 - tolerance - cross_beam_thickness/2.0);
+    UnionSolid support_array_start_s(T_beam_s,trd_support,Position(0,0,cross_beam_thickness/2.0));
+    for (int isup = 0; isup < n_cross_supports; isup++) {
+      support_array_start_s = UnionSolid(support_array_start_s, trd_support, Position(0, -1.0 * isup * grid_size, cross_beam_thickness/2.0));
+      support_array_start_s = UnionSolid(support_array_start_s, trd_support, Position(0, 1.0 * isup * grid_size, cross_beam_thickness/2.0));
+    }
+    support_array_start_s =
+        UnionSolid(support_array_start_s, beam_hori_s,
+                   Position(-1.8 * 0.5*(trd_x1+trd_x2_support) / n_beams, 0, -support_thickness / 2.0 + beam_thickness / 2.0));
+    support_array_start_s =
+        UnionSolid(support_array_start_s, beam_hori_s,
+                   Position(1.8 * 0.5*(trd_x1+trd_x2_support) / n_beams, 0, -support_thickness / 2.0 + beam_thickness / 2.0));
+    support_array_start_s =
+        UnionSolid(support_array_start_s, beam_vert_s, Position(-1.8 * 0.5*(trd_x1+trd_x2_support) / n_beams, 0, 0));
+    support_array_start_s =
+        UnionSolid(support_array_start_s, beam_vert_s, Position(1.8 * 0.5*(trd_x1+trd_x2_support) / n_beams, 0, 0));
+
+    support_frame_s = support_array_start_s;
+
+    Material support_mat = description.material(x_support.materialStr());
+    Volume   support_vol("support_frame_v", support_frame_s, support_mat);
+    support_vol.setVisAttributes(description,x_support.visStr());
+
+    // figure out how to best place
+    //auto pv = mod_vol.placeVolume(support_vol, Position(0.0, 0.0, l_pos_z + support_thickness / 2.0));
+    auto pv = mod_vol.placeVolume(support_vol, Position(0.0, 0.0, -l_pos_z - support_thickness / 2.0));
+  }
+  //l_pos_z += support_thickness;
+
+  sens.setType("calorimeter");
+  { // =====  buildBarrelStave(description, sens, module_volume) =====
+    // Parameters for computing the layer X dimension:
+    double stave_z  = trd_y1;
+    double tan_hphi = std::tan(hphi);
+    double l_dim_x  = trd_x1; // Starting X dimension for the layer.
+
+    // Loop over the sets of layer elements in the detector.
+    int l_num = 1;
+    for(xml_coll_t li(x_det,_U(layer)); li; ++li)  {
+      xml_comp_t x_layer = li;
+      int repeat = x_layer.repeat();
+      // Loop over number of repeats for this layer.
+      for (int j=0; j<repeat; j++)    {
+        string l_name = _toString(l_num,"layer%d");
+        double l_thickness = layering.layer(l_num-1)->thickness();  // Layer's thickness.
+
+        Position   l_pos(0,0,l_pos_z+l_thickness/2);      // Position of the layer.
+        Box        l_box(l_dim_x-tolerance,stave_z-tolerance,l_thickness / 2-tolerance);
+        Volume     l_vol(l_name,l_box,air);
+        DetElement layer(stave_det, l_name, det_id);
+
+        // Loop over the sublayers or slices for this layer.
+        int s_num = 1;
+        double s_pos_z = -(l_thickness / 2);
+        for(xml_coll_t si(x_layer,_U(slice)); si; ++si)  {
+          xml_comp_t x_slice = si;
+          string     s_name  = _toString(s_num,"slice%d");
+          double     s_thick = x_slice.thickness();
+          Box        s_box(l_dim_x-tolerance,stave_z-tolerance,s_thick / 2-tolerance);
+          Volume     s_vol(s_name,s_box,description.material(x_slice.materialStr()));
+          DetElement slice(layer,s_name,det_id);
+
+          if ( x_slice.isSensitive() ) {
+            s_vol.setSensitiveDetector(sens);
+          }
+          slice.setAttributes(description,s_vol,x_slice.regionStr(),x_slice.limitsStr(),x_slice.visStr());
+
+          // Slice placement.
+          PlacedVolume slice_phv = l_vol.placeVolume(s_vol,Position(0,0,s_pos_z+s_thick/2));
+          slice_phv.addPhysVolID("slice", s_num);
+          slice.setPlacement(slice_phv);
+          // Increment Z position of slice.
+          s_pos_z += s_thick;
+
+          // Increment slice number.
+          ++s_num;
+        }
+
+        // Set region, limitset, and vis of layer.
+        layer.setAttributes(description,l_vol,x_layer.regionStr(),x_layer.limitsStr(),x_layer.visStr());
+
+        PlacedVolume layer_phv = mod_vol.placeVolume(l_vol,l_pos);
+        layer_phv.addPhysVolID("layer", l_num);
+        layer.setPlacement(layer_phv);
+        // Increment to next layer Z position.
+        double xcut = l_thickness * tan_hphi;
+        l_dim_x += xcut;
+        l_pos_z += l_thickness;
+        ++l_num;
+      }
+    }
+  }
+
+  // Set stave visualization.
+  if ( x_staves )   {
+    mod_vol.setVisAttributes(description.visAttributes(x_staves.visStr()));
+
+  }
+  // Phi start for a stave.
+  double phi = M_PI / nsides;
+  double mod_x_off = dx / 2;             // Stave X offset, derived from the dx.
+  double mod_y_off = inner_r + mod_z/2;  // Stave Y offset
+
+  // Create nsides staves.
+  for (int i = 0; i < nsides; i++, phi -= dphi)      { // i is module number
+    // Compute the stave position
+    double m_pos_x = mod_x_off * std::cos(phi) - mod_y_off * std::sin(phi);
+    double m_pos_y = mod_x_off * std::sin(phi) + mod_y_off * std::cos(phi);
+    Transform3D tr(RotationZYX(0,phi,M_PI*0.5),Translation3D(-m_pos_x,-m_pos_y,0));
+    PlacedVolume pv = envelope.placeVolume(mod_vol,tr);
+    pv.addPhysVolID("system",det_id);
+    pv.addPhysVolID("barrel",0);
+    pv.addPhysVolID("module",i+1);
+    DetElement sd = i==0 ? stave_det : stave_det.clone(_toString(i,"stave%d"));
+    sd.setPlacement(pv);
+    sdet.add(sd);
+  }
+
+  // Set envelope volume attributes.
+  envelope.setAttributes(description,x_det.regionStr(),x_det.limitsStr(),x_det.visStr());
+  return sdet;
+}
+
+DECLARE_DETELEMENT(athena_EcalBarrel,create_detector)
+DECLARE_DETELEMENT(athena_HcalBarrel,create_detector)

src/BarrelTrackerWithFrame_geo.cpp

+/** \addtogroup Trackers Trackers
+ * \brief Type: **BarrelTrackerWithFrame**.
+ * \author W. Armstrong
+ *
+ * \ingroup trackers
+ *
+ * @{
+ */
+#include "DD4hep/DetFactoryHelper.h"
+#include "DD4hep/Printout.h"
+#include "DD4hep/Shapes.h"
+#include "DDRec/Surface.h"
+#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;
+using namespace dd4hep::rec;
+using namespace dd4hep::detail;
+
+
+/** Barrel Tracker with space frame.
+ *
+ * - Optional "support" tag within the detector element.
+ * 
+ * The shapes are created using createShape which can be one of many basic geomtries. 
+ * See the examples Check_shape_*.xml in 
+ * [dd4hep's examples/ClientTests/compact](https://github.com/AIDASoft/DD4hep/tree/master/examples/ClientTests/compact)
+ * directory.
+ *
+ *
+ * - Optional "frame" tag within the module element.
+ *
+ * \ingroup trackers
+ *
+ * \code
+ * \endcode
+ * 
+ *
+ * @author Whitney Armstrong
+ */
+static Ref_t create_BarrelTrackerWithFrame(Detector& description, xml_h e, SensitiveDetector sens) {
+  typedef vector<PlacedVolume> Placements;
+  xml_det_t                    x_det    = e;
+  Material                     air      = description.air();
+  int                          det_id   = x_det.id();
+  string                       det_name = x_det.nameStr();
+  DetElement                   sdet(det_name, det_id);
+
+  map<string, Volume>                volumes;
+  map<string, Placements>            sensitives;
+  map<string, std::vector<VolPlane>> volplane_surfaces;
+  map<string, std::array<double, 2>> module_thicknesses;
+
+  PlacedVolume           pv;
+  dd4hep::xml::Dimension dimensions(x_det.dimensions());
+
+  // ACTS extension
+  {
+    Acts::ActsExtension* detWorldExt = new Acts::ActsExtension();
+    detWorldExt->addType("barrel", "detector");
+    // Add the volume boundary material if configured
+    for (xml_coll_t bmat(x_det, _Unicode(boundary_material)); bmat; ++bmat) {
+      xml_comp_t x_boundary_material = bmat;
+      Acts::xmlToProtoSurfaceMaterial(x_boundary_material, *detWorldExt, "boundary_material");
+    }
+    sdet.addExtension<Acts::ActsExtension>(detWorldExt);
+  }
+
+  Tube topVolumeShape(dimensions.rmin(), dimensions.rmax(), dimensions.length() * 0.5);
+  Volume assembly(det_name,topVolumeShape,air);
+
+  sens.setType("tracker");
+
+  // Loop over the suports
+  for (xml_coll_t su(x_det, _U(support)); su; ++su) {
+    xml_comp_t x_support = su;
+    double      support_thickness = getAttrOrDefault(x_support, _U(thickness), 2.0 * mm);
+    double      support_length    = getAttrOrDefault(x_support, _U(length), 2.0 * mm);
+    double      support_rmin      = getAttrOrDefault(x_support, _U(rmin), 2.0 * mm);
+    double      support_zstart    = getAttrOrDefault(x_support, _U(zstart), 2.0 * mm);
+    std::string support_name      = getAttrOrDefault<std::string>(x_support, _Unicode(name), "support_tube");
+    std::string support_vis       = getAttrOrDefault<std::string>(x_support, _Unicode(vis), "AnlRed");
+    xml_dim_t  pos        (x_support.child(_U(position), false));
+    xml_dim_t  rot        (x_support.child(_U(rotation), false));
+    Solid support_solid;
+    if(x_support.hasChild("shape")){
+      xml_comp_t shape(x_support.child(_U(shape)));
+      string     shape_type = shape.typeStr();
+      support_solid  = xml::createShape(description, shape_type, shape);
+    } else {
+      support_solid = Tube(support_rmin, support_rmin + support_thickness, support_length / 2);
+    }
+    Transform3D tr = Transform3D(Rotation3D(),Position(0,0,(support_zstart + support_length / 2)));
+    if ( pos.ptr() && rot.ptr() )  {
+      Rotation3D  rot3D(RotationZYX(rot.z(0),rot.y(0),rot.x(0)));
+      Position    pos3D(pos.x(0),pos.y(0),pos.z(0));
+      tr = Transform3D(rot3D, pos3D);
+    }
+    else if ( pos.ptr() )  {
+      tr = Transform3D(Rotation3D(),Position(pos.x(0),pos.y(0),pos.z(0)));
+    }
+    else if ( rot.ptr() )  {
+      Rotation3D rot3D(RotationZYX(rot.z(0),rot.y(0),rot.x(0)));
+      tr = Transform3D(rot3D,Position());
+    }
+    Material    support_mat       = description.material(x_support.materialStr());
+    Volume      support_vol(support_name, support_solid, support_mat);
+    support_vol.setVisAttributes(description.visAttributes(support_vis));
+    pv = assembly.placeVolume(support_vol, tr);
+    // pv = assembly.placeVolume(support_vol, Position(0, 0, support_zstart + support_length / 2));
+  }
+
+  // loop over the modules
+  for (xml_coll_t mi(x_det, _U(module)); mi; ++mi) {
+    xml_comp_t x_mod = mi;
+    string     m_nam = x_mod.nameStr();
+
+    if (volumes.find(m_nam) != volumes.end()) {
+      printout(ERROR, "BarrelTrackerWithFrame", string((string("Module with named ") + m_nam + string(" already exists."))).c_str() );
+      throw runtime_error("Logics error in building modules.");
+    }
+
+    int ncomponents   = 0;
+    int sensor_number = 1;
+    double total_thickness = 0;
+
+    // Compute module total thickness from components
+    xml_coll_t ci(x_mod, _U(module_component));
+    for (ci.reset(), total_thickness = 0.0; ci; ++ci) {
+      total_thickness += xml_comp_t(ci).thickness();
+    }
+    // the module assembly volume
+    Assembly m_vol( m_nam );
+    volumes[m_nam] = m_vol;
+    m_vol.setVisAttributes(description.visAttributes(x_mod.visStr()));
+
+    // Optional module frame.
+    if(x_mod.hasChild("frame")){
+      xml_comp_t m_frame = x_mod.child(_U(frame));
+      //xmleles[m_nam]  = x_mod;
+      double frame_thickness = m_frame.thickness();
+      double frame_width     = m_frame.width();
+      double frame_height    = getAttrOrDefault<double>(m_frame, _U(height), 5.0 * mm);
+      double tanth           = frame_height/(frame_width/2.0);
+      double frame_height2   = frame_height-frame_thickness-frame_thickness/tanth;
+      double frame_width2    = 2.0*frame_height2/tanth;
+
+      Trd1 moduleframe_part1(frame_width / 2, 0.001 * mm, m_frame.length() / 2,
+                             frame_height / 2);
+      Trd1 moduleframe_part2(frame_width2/2, 0.001 * mm,
+                             m_frame.length() / 2 + 0.01 * mm, frame_height2/2);
+
+      SubtractionSolid moduleframe(moduleframe_part1, moduleframe_part2,Position(0.0,frame_thickness,0.0));
+      Volume v_moduleframe(m_nam+"_vol", moduleframe, description.material(m_frame.materialStr()));
+      v_moduleframe.setVisAttributes(description, m_frame.visStr());
+      m_vol.placeVolume(v_moduleframe, Position(0.0, 0.0, frame_height / 2 + total_thickness / 2.0));
+    }
+
+
+    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);
+      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) + 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, 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) + zoff));
+      } else {
+        pv = m_vol.placeVolume(c_vol, Position(0, 0, zoff));
+      }
+      c_vol.setRegion(description, x_comp.regionStr());
+      c_vol.setLimitSet(description, x_comp.limitsStr());
+      c_vol.setVisAttributes(description, x_comp.visStr());
+      if (x_comp.isSensitive()) {
+        pv.addPhysVolID("sensor", sensor_number++);
+        c_vol.setSensitiveDetector(sens);
+        sensitives[m_nam].push_back(pv);
+        module_thicknesses[m_nam] = {thickness_so_far + x_comp.thickness()/2.0, total_thickness-thickness_so_far - x_comp.thickness()/2.0};
+
+        // -------- create a measurement plane for the tracking surface attched to the sensitive volume -----
+        Vector3D u(-1., 0., 0.);
+        Vector3D v(0., -1., 0.);
+        Vector3D n(0., 0., 1.);
+        //    Vector3D o( 0. , 0. , 0. ) ;
+
+        // compute the inner and outer thicknesses that need to be assigned to the tracking surface
+        // depending on wether the support is above or below the sensor
+        double inner_thickness = module_thicknesses[m_nam][0];
+        double outer_thickness = module_thicknesses[m_nam][1];
+
+        SurfaceType type(SurfaceType::Sensitive);
+
+        // if( isStripDetector )
+        //  type.setProperty( SurfaceType::Measurement1D , true ) ;
+
+        VolPlane surf(c_vol, type, inner_thickness, outer_thickness, u, v, n); //,o ) ;
+        volplane_surfaces[m_nam].push_back(surf);
+
+        //--------------------------------------------
+      }
+      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);
+      }
+    }
+  }
+
+  // now build the layers
+  for (xml_coll_t li(x_det, _U(layer)); li; ++li) {
+    xml_comp_t x_layer  = li;
+    xml_comp_t x_barrel = x_layer.child(_U(barrel_envelope));
+    xml_comp_t x_layout = x_layer.child(_U(rphi_layout));
+    xml_comp_t z_layout = x_layer.child(_U(z_layout)); // Get the <z_layout> element.
+    int        lay_id   = x_layer.id();
+    string     m_nam    = x_layer.moduleStr();
+    string     lay_nam  = _toString(x_layer.id(), "layer%d");
+    Tube       lay_tub(x_barrel.inner_r(), x_barrel.outer_r(), x_barrel.z_length() / 2.0);
+    Volume     lay_vol(lay_nam, lay_tub, air); // Create the layer envelope volume.
+    lay_vol.setVisAttributes(description.visAttributes(x_layer.visStr()));
+
+    double      phi0       = x_layout.phi0();     // Starting phi of first module.
+    double      phi_tilt   = x_layout.phi_tilt(); // Phi tilt of a module.
+    double      rc         = x_layout.rc();       // Radius of the module center.
+    int         nphi       = x_layout.nphi();     // Number of modules in phi.
+    double      rphi_dr    = x_layout.dr();       // The delta radius of every other module.
+    double      phi_incr   = (M_PI * 2) / nphi;   // Phi increment for one module.
+    double      phic       = phi0;                // Phi of the module center.
+    double      z0         = z_layout.z0();       // Z position of first module in phi.
+    double      nz         = z_layout.nz();       // Number of modules to place in z.
+    double      z_dr       = z_layout.dr();       // Radial displacement parameter, of every other module.
+
+    Volume      module_env = volumes[m_nam];
+    DetElement  lay_elt(sdet, lay_nam, lay_id);
+    Placements& sensVols = sensitives[m_nam];
+
+    // the local coordinate systems of modules in dd4hep and acts differ
+    // see http://acts.web.cern.ch/ACTS/latest/doc/group__DD4hepPlugins.html
+    {
+      Acts::ActsExtension* layerExtension = new Acts::ActsExtension();
+      // layer is simple tube so no need to set envelope
+      layerExtension->addType("sensitive cylinder", "layer");
+      // Add the proto layer material
+      for(xml_coll_t lmat(x_layer, _Unicode(layer_material)); lmat; ++lmat) {
+        xml_comp_t x_layer_material = lmat;
+        xmlToProtoSurfaceMaterial(x_layer_material, *layerExtension, "layer_material");
+      }
+      lay_elt.addExtension<Acts::ActsExtension>(layerExtension);
+    }
+
+    // Z increment for module placement along Z axis.
+    // Adjust for z0 at center of module rather than
+    // the end of cylindrical envelope.
+    double z_incr = nz > 1 ? (2.0 * z0) / (nz - 1) : 0.0;
+    // Starting z for module placement along Z axis.
+    double module_z = -z0;
+    int module = 1;
+
+    // Loop over the number of modules in phi.
+    for (int ii = 0; ii < nphi; ii++) {
+      double dx = z_dr * std::cos(phic + phi_tilt);  // Delta x of module position.
+      double dy = z_dr * std::sin(phic + phi_tilt);  // Delta y of module position.
+      double x = rc * std::cos(phic);                // Basic x module position.
+      double y = rc * std::sin(phic);                // Basic y module position.
+
+      // Loop over the number of modules in z.
+      for (int j = 0; j < nz; j++) {
+        string module_name = _toString(module, "module%d");
+        DetElement mod_elt(lay_elt, module_name, module);
+
+        Transform3D tr(RotationZYX(0, ((M_PI / 2) - phic - phi_tilt), -M_PI / 2),
+                       Position(x, y, module_z));
+
+        pv = lay_vol.placeVolume(module_env, tr);
+        pv.addPhysVolID("module", module);
+        mod_elt.setPlacement(pv);
+        for (size_t ic = 0; ic < sensVols.size(); ++ic) {
+          PlacedVolume sens_pv = sensVols[ic];
+          DetElement comp_de(mod_elt, std::string("de_") + sens_pv.volume().name(), module);
+          comp_de.setPlacement(sens_pv);
+          // ACTS extension
+          {
+            Acts::ActsExtension* sensorExtension = new Acts::ActsExtension();
+            //sensorExtension->addType("sensor", "detector");
+            comp_de.addExtension<Acts::ActsExtension>(sensorExtension);
+          }
+          //comp_de.setAttributes(description, sens_pv.volume(), x_layer.regionStr(), x_layer.limitsStr(),
+          //                      xml_det_t(xmleles[m_nam]).visStr());
+          //
+
+          volSurfaceList(comp_de)->push_back(volplane_surfaces[m_nam][ic]);
+        }
+
+        /// Increase counters etc.
+        module++;
+        // Adjust the x and y coordinates of the module.
+        x += dx;
+        y += dy;
+        // Flip sign of x and y adjustments.
+        dx *= -1;
+        dy *= -1;
+        // Add z increment to get next z placement pos.
+        module_z += z_incr;
+      }
+      phic += phi_incr;  // Increment the phi placement of module.
+      rc += rphi_dr;     // Increment the center radius according to dr parameter.
+      rphi_dr *= -1;     // Flip sign of dr parameter.
+      module_z = -z0;    // Reset the Z placement parameter for module.
+    }
+    // Create the PhysicalVolume for the layer.
+    pv = assembly.placeVolume(lay_vol);  // Place layer in mother
+    pv.addPhysVolID("layer", lay_id);    // Set the layer ID.
+    lay_elt.setAttributes(description, lay_vol, x_layer.regionStr(), x_layer.limitsStr(),
+                          x_layer.visStr());
+    lay_elt.setPlacement(pv);
+  }
+  sdet.setAttributes(description, assembly, x_det.regionStr(), x_det.limitsStr(), x_det.visStr());
+  assembly.setVisAttributes(description.invisible());
+  pv = description.pickMotherVolume(sdet).placeVolume(assembly);
+  pv.addPhysVolID("system", det_id);  // Set the subdetector system ID.
+  sdet.setPlacement(pv);
+  return sdet;
+}
+
+//@}
+// clang-format off
+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

+//==========================================================================
+//  Based off DD4hep_SubDetectorAssembly
+//
+//  This is a simple plugin to allow compositing different detectors
+//  into a single barrel or endcap for ACTS
+//  Note: positive/negative position strings differentiate between
+//        positive/negative endcaps
+//--------------------------------------------------------------------------
+
+#include "DD4hep/DetFactoryHelper.h"
+#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;
+
+static Ref_t create_element(Detector& description, xml_h e, Ref_t)
+{
+  xml_det_t         x_det(e);
+  const std::string det_name = x_det.nameStr();
+  DetElement        sdet(det_name, x_det.id());
+  Volume            vol;
+  Position          pos;
+
+  const bool usePos = x_det.hasChild(_U(position));
+
+  sdet.setType("compound");
+  xml::setDetectorTypeFlag(e, sdet);
+
+  const std::string actsType = getAttrOrDefault(x_det, _Unicode(actsType), "endcap");
+  printout(DEBUG, det_name, "+++ Creating composite tracking detector (type: " + actsType + ")");
+  assert(actsType == "barrel" || actsType == "endcap");
+
+  // ACTS extension
+  {
+    Acts::ActsExtension* detWorldExt = new Acts::ActsExtension();
+    detWorldExt->addType(actsType, "detector");
+    sdet.addExtension<Acts::ActsExtension>(detWorldExt);
+  }
+
+  if (usePos) {
+    pos = Position(x_det.position().x(), x_det.position().y(), x_det.position().z());
+  }
+  vol = Assembly(det_name);
+  vol.setAttributes(description, x_det.regionStr(), x_det.limitsStr(), x_det.visStr());
+
+  Volume       mother = description.pickMotherVolume(sdet);
+  PlacedVolume pv;
+  if (usePos) {
+    pv = mother.placeVolume(vol, pos);
+  } else {
+    pv = mother.placeVolume(vol);
+  }
+  sdet.setPlacement(pv);
+  for (xml_coll_t c(x_det, _U(composite)); c; ++c) {
+    xml_dim_t         component = c;
+    const std::string nam       = component.nameStr();
+    description.declareParent(nam, sdet);
+  }
+  return sdet;
+}
+
+DECLARE_DETELEMENT(athena_CompositeTracker, create_element)

src/CylinderTrackerBarrel_geo.cpp

+//==========================================================================
+// Specialized generic detector constructor
+//==========================================================================
+
+#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;
+
+/** A barrel tracker with a module that is curved (not flat).
+ *
+ * \ingroup tracking
+ */
+static Ref_t CylinderTrackerBarrel_create_detector(Detector& description, xml_h e, SensitiveDetector sens)
+{
+  typedef vector<PlacedVolume> Placements;
+  xml_det_t                    x_det = e;
+  Material                     air   = description.air();
+
+  int        det_id   = x_det.id();
+  string     det_name = x_det.nameStr();
+  DetElement sdet(det_name, det_id);
+
+  //Acts::ActsExtension* barrelExtension = new Acts::ActsExtension();
+  //barrelExtension->addType("barrel", "detector");
+  //sdet.addExtension<Acts::ActsExtension>(barrelExtension);
+
+  Assembly                assembly(det_name);
+  map<string, Volume>     mod_volumes;
+  map<string, Placements> sensitives;
+  PlacedVolume            pv;
+
+  sens.setType("tracker");
+  int n_modules = 0;
+  for (xml_coll_t mi(x_det, _U(module)); mi; ++mi) {
+    n_modules++;
+    xml_comp_t x_mod = mi;
+    xml_comp_t m_env = x_mod.child(_U(module_envelope));
+    string     m_nam = x_mod.nameStr();
+
+    Assembly module_assembly(_toString(n_modules, "mod_assembly_%d"));
+    auto     module_rmin      = m_env.rmin();
+    auto     module_thickness = m_env.thickness();
+    auto     module_length    = m_env.length();
+    auto     module_phi       = getAttrOrDefault(m_env, _Unicode(phi), 90.0);
+
+    Volume m_vol(
+        m_nam,
+        Tube(module_rmin, module_rmin + module_thickness, module_length / 2, -module_phi / 2.0, module_phi / 2.0), air);
+    int    ncomponents = 0, sensor_number = 1;
+    module_assembly.placeVolume(m_vol, Position(-module_rmin, 0, 0));
+    mod_volumes[m_nam] = module_assembly;
+    m_vol.setVisAttributes(description.visAttributes(x_mod.visStr()));
+
+    auto comp_rmin = module_rmin;
+    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");
+
+      auto comp_thickness = x_comp.thickness();
+      comp_rmin           = getAttrOrDefault(x_comp, _Unicode(rmin), comp_rmin);
+      auto comp_phi       = getAttrOrDefault(x_comp, _Unicode(phi), module_phi);
+      auto comp_phi0      = getAttrOrDefault(x_comp, _Unicode(phi0), 0.0);
+      auto comp_length    = getAttrOrDefault(x_comp, _Unicode(length), module_length);
+
+      Tube         c_tube(comp_rmin, comp_rmin + comp_thickness, comp_length / 2, -comp_phi / 2.0 + comp_phi0,
+                  comp_phi / 2.0 + comp_phi0);
+      Volume       c_vol(c_nam, c_tube, description.material(x_comp.materialStr()));
+      PlacedVolume c_pv;
+
+      if (x_pos && x_rot) {
+        Position    c_pos(x_pos.x(0), x_pos.y(0), x_pos.z(0));
+        RotationZYX c_rot(x_rot.z(0), x_rot.y(0), x_rot.x(0));
+        c_pv = m_vol.placeVolume(c_vol, Transform3D(c_rot, c_pos));
+      } else if (x_rot) {
+        c_pv = m_vol.placeVolume(c_vol, RotationZYX(x_rot.z(0), x_rot.y(0), x_rot.x(0)));
+      } else if (x_pos) {
+        c_pv = m_vol.placeVolume(c_vol, Position(x_pos.x(0), x_pos.y(0), x_pos.z(0)));
+      } else {
+        c_pv = m_vol.placeVolume(c_vol);
+      }
+      c_vol.setRegion(description, x_comp.regionStr());
+      c_vol.setLimitSet(description, x_comp.limitsStr());
+      c_vol.setVisAttributes(description, x_comp.visStr());
+      if (x_comp.isSensitive()) {
+        c_pv.addPhysVolID(_U(sensor), sensor_number++);
+        c_vol.setSensitiveDetector(sens);
+        sensitives[m_nam].push_back(c_pv);
+      }
+      comp_rmin = comp_rmin + comp_thickness;
+    }
+  }
+  for (xml_coll_t li(x_det, _U(layer)); li; ++li) {
+    xml_comp_t x_layer  = li;
+    xml_comp_t x_barrel = x_layer.child(_U(barrel_envelope));
+    xml_comp_t x_layout = x_layer.child(_U(rphi_layout));
+    xml_comp_t z_layout = x_layer.child(_U(z_layout)); // Get the <z_layout> element.
+    int        lay_id   = x_layer.id();
+    string     m_nam    = x_layer.moduleStr();
+    string     lay_nam  = _toString(x_layer.id(), "layer%d");
+    Tube       lay_tub(x_barrel.inner_r(), x_barrel.outer_r(), x_barrel.z_length() / 2);
+    Volume     lay_vol(lay_nam, lay_tub, air); // Create the layer envelope volume.
+    lay_vol.setVisAttributes(description.visAttributes(x_layer.visStr()));
+    double     phi0     = x_layout.phi0();     // Starting phi of first module.
+    double     phi_tilt = x_layout.phi_tilt(); // Phi tilt of a module.
+    double     rc       = x_layout.rc();       // Radius of the module center.
+    int        nphi     = x_layout.nphi();     // Number of modules in phi.
+    double     rphi_dr  = x_layout.dr();       // The delta radius of every other module.
+    double     phi_incr = (M_PI * 2) / nphi;   // Phi increment for one module.
+    double     phic     = phi0;                // Phi of the module center.
+    double     z0       = z_layout.z0();       // Z position of first module in phi.
+    double     nz       = z_layout.nz();       // Number of modules to place in z.
+    double     z_dr     = z_layout.dr();       // Radial displacement parameter, of every other module.
+    Volume     m_env    = mod_volumes[m_nam];
+    DetElement lay_elt(sdet, _toString(x_layer.id(), "layer%d"), lay_id);
+
+    ///Acts::ActsExtension* layerExtension = new Acts::ActsExtension();
+    ///layerExtension->addType("sensitive cylinder", "layer");
+    /////// layerExtension->addValue(10. * Acts::UnitConstants::mm, "r", "envelope");
+    ///lay_elt.addExtension<Acts::ActsExtension>(layerExtension);
+
+    Placements& sensVols = sensitives[m_nam];
+
+    // Z increment for module placement along Z axis.
+    // Adjust for z0 at center of module rather than
+    // the end of cylindrical envelope.
+    double z_incr = nz > 1 ? (2.0 * z0) / (nz - 1) : 0.0;
+    // Starting z for module placement along Z axis.
+    double module_z = -z0;
+    int    module   = 1;
+
+    // Loop over the number of modules in phi.
+    for (int ii = 0; ii < nphi; ii++) {
+      double dx = z_dr * std::cos(phic + phi_tilt); // Delta x of module position.
+      double dy = z_dr * std::sin(phic + phi_tilt); // Delta y of module position.
+      double x  = rc * std::cos(phic);              // Basic x module position.
+      double y  = rc * std::sin(phic);              // Basic y module position.
+
+      // Loop over the number of modules in z.
+      for (int j = 0; j < nz; j++) {
+        string     module_name = _toString(module, "module%d");
+        DetElement mod_elt(lay_elt, module_name, module);
+        // Module PhysicalVolume.
+        //         Transform3D
+        //         tr(RotationZYX(0,-((M_PI/2)-phic-phi_tilt),M_PI/2),Position(x,y,module_z));
+        // NOTE (Nikiforos, 26/08 Rotations needed to be fixed so that component1 (silicon) is on the
+        // outside
+        Transform3D tr(RotationZYX(phic - phi_tilt, 0, 0), Position(x, y, module_z));
+
+        pv = lay_vol.placeVolume(m_env, tr);
+        pv.addPhysVolID("module", module);
+        mod_elt.setPlacement(pv);
+        for (size_t ic = 0; ic < sensVols.size(); ++ic) {
+          PlacedVolume sens_pv = sensVols[ic];
+          DetElement   comp_elt(mod_elt, sens_pv.volume().name(), module);
+          comp_elt.setPlacement(sens_pv);
+          //Acts::ActsExtension* moduleExtension = new Acts::ActsExtension();
+          //comp_elt.addExtension<Acts::ActsExtension>(moduleExtension);
+        }
+
+        /// Increase counters etc.
+        module++;
+        // Adjust the x and y coordinates of the module.
+        x += dx;
+        y += dy;
+        // Flip sign of x and y adjustments.
+        dx *= -1;
+        dy *= -1;
+        // Add z increment to get next z placement pos.
+        module_z += z_incr;
+      }
+      phic += phi_incr; // Increment the phi placement of module.
+      rc += rphi_dr;    // Increment the center radius according to dr parameter.
+      rphi_dr *= -1;    // Flip sign of dr parameter.
+      module_z = -z0;   // Reset the Z placement parameter for module.
+    }
+    // Create the PhysicalVolume for the layer.
+    pv = assembly.placeVolume(lay_vol); // Place layer in mother
+    pv.addPhysVolID("layer", lay_id);   // Set the layer ID.
+    lay_elt.setAttributes(description, lay_vol, x_layer.regionStr(), x_layer.limitsStr(), x_layer.visStr());
+    lay_elt.setPlacement(pv);
+  }
+  sdet.setAttributes(description, assembly, x_det.regionStr(), x_det.limitsStr(), x_det.visStr());
+  // assembly.setVisAttributes(description.invisible());
+  pv = description.pickMotherVolume(sdet).placeVolume(assembly);
+  pv.addPhysVolID("system", det_id); // Set the subdetector system ID.
+  pv.addPhysVolID("barrel", 1);      // Flag this as a barrel subdetector.
+  sdet.setPlacement(pv);
+  return sdet;
+}
+
+// clang-format off
+DECLARE_DETELEMENT(athena_CylinderTrackerBarrel, CylinderTrackerBarrel_create_detector)
+DECLARE_DETELEMENT(athena_MMTrackerBarrel,       CylinderTrackerBarrel_create_detector)
+DECLARE_DETELEMENT(athena_RWellTrackerBarrel,    CylinderTrackerBarrel_create_detector)
+DECLARE_DETELEMENT(athena_CylinderVertexBarrel,  CylinderTrackerBarrel_create_detector)
+

src/DIRC_geo.cpp

+#include "DD4hep/DetFactoryHelper.h"
+#include "DD4hep/OpticalSurfaces.h"
+#include "DD4hep/Printout.h"
+#include "DDRec/DetectorData.h"
+#include "DDRec/Surface.h"
+#include <XML/Helper.h>
+
+//////////////////////////////////
+// Central Barrel DIRC
+//////////////////////////////////
+
+using namespace std;
+using namespace dd4hep;
+
+// Fixed Trap constructor. This function is a workaround of this bug:
+// https://github.com/AIDASoft/DD4hep/issues/850
+// Should be used instead of dd4hep::Trap(pName, pZ, pY, pX, pLTX) constructor
+dd4hep::Trap MakeTrap( const std::string& pName, double pZ, double pY, double pX, double pLTX );
+
+static Ref_t createDetector(Detector& desc, xml_h e, SensitiveDetector sens)
+{
+  xml_det_t xml_det   = e;
+  string    det_name = xml_det.nameStr();
+  int       det_id   = xml_det.id();
+
+  // Main detector xml element
+  xml_dim_t dirc_dim   = xml_det.dimensions();
+  xml_dim_t dirc_pos   = xml_det.position();
+  xml_dim_t dirc_rot   = xml_det.rotation();
+  double    det_rin   = dirc_dim.rmin();
+  double    det_rout  = dirc_dim.rmax();
+  double    SizeZ = dirc_dim.length();
+
+  // DEBUG
+  // double mirror_r1 = x_det.attr<double>(_Unicode(r1));
+
+  // DIRC box:
+  xml_comp_t xml_box_module = xml_det.child(_U(module));
+
+  Material Vacuum = desc.material("Vacuum");
+  Material air = desc.material("AirOptical");
+  Material quartz = desc.material("Quartz");
+  Material epotek = desc.material("Epotek");
+  Material nlak33a = desc.material("Nlak33a");
+  auto& bar_material = quartz;
+  auto mirror_material = desc.material("Aluminum");  // mirror material
+
+  Tube     det_geo(det_rin, det_rout, SizeZ / 2., 0., 360.0 * deg);
+  //Volume   det_volume("DIRC", det_geo, Vacuum);
+  Assembly   det_volume("DIRC");
+  det_volume.setVisAttributes(desc.visAttributes(xml_det.visStr()));
+
+  DetElement   det(det_name, det_id);
+  Volume       mother_vol = desc.pickMotherVolume(det);
+
+  Transform3D  tr(RotationZYX(0, dirc_rot.theta(), 0.0), Position(0.0, 0.0, dirc_pos.z()));
+  PlacedVolume det_plvol = mother_vol.placeVolume(det_volume, tr);
+
+  det_plvol.addPhysVolID("system", det_id);
+  det.setPlacement(det_plvol);
+
+  // Parts Dimentions
+
+  int fLensId = 6; // focusing system
+                   // 0    no lens
+                   // 1    spherical lens
+                   // 3    3-layer spherical lens
+                   // 6    3-layer cylindrical lens
+                   // 10   ideal lens (thickness = 0, ideal focusing)
+  
+  int fGeomType = 0;  // Full DIRC - 0, 1 only one plate
+  int fRunType = 0;   // 0, 10 - simulation, 1, 5 - lookup table, 2,3,4 - reconstruction
+
+
+  double fPrizm[4];
+  fPrizm[0] = 360 * mm;
+  fPrizm[1] = 300 * mm;
+  fPrizm[3] = 50 * mm;
+  fPrizm[2] = fPrizm[3] + 300 * tan(32 * deg) * mm;
+  double fBarsGap = 0.15 * mm;
+
+  std::cout << "DIRC: fPrizm[2] " << fPrizm[2] << std::endl;
+
+  double fdTilt = 80 * deg;
+  double fPrizmT[6];
+  fPrizmT[0] = 390 * mm;
+  fPrizmT[1] = (400 - 290 * cos(fdTilt)) * mm; //
+  fPrizmT[2] = 290 * sin(fdTilt) * mm;       // hight
+  fPrizmT[3] = 50 * mm;                      // face
+  fPrizmT[4] = 290 * mm;
+  fPrizmT[5] = 290 * cos(fdTilt)* mm;
+
+  double fMirror[3];
+  fMirror[0] = 20 * mm;
+  fMirror[1] = fPrizm[0];
+  fMirror[2] = 1 * mm;
+  //  fPrizm[0] = 170; fPrizm[1] = 300; fPrizm[2] = 50+300*tan(45*deg); fPrizm[3] = 50;
+
+//  double fBar[3];
+//  fBar[0] = 17 * mm;
+//  fBar[1] = (fPrizm[0] - (fNBar - 1) * fBarsGap) / fNBar;
+//  fBar[2] = 1050 * mm; // 4200; //4200
+
+  double fMcpTotal[3];
+  double fMcpActive[3];
+  fMcpTotal[0] = fMcpTotal[1] = 53 + 4;
+  fMcpTotal[2] = 1*mm;
+  fMcpActive[0] = fMcpActive[1] = 53;
+  fMcpActive[2] = 1*mm;
+
+  double fLens[4];
+  fLens[0] = fLens[1] = 40 * mm;
+  fLens[2] = 10 * mm;
+  double fRadius = (det_rin + det_rout)/2;
+
+  double fBoxWidth = fPrizm[0];
+
+  double fFd[3];
+  fFd[0] = fBoxWidth;
+  fFd[1] = fPrizm[2];
+  fFd[2] = 1 * mm;
+
+  fLens[0] = fPrizm[3];
+  fLens[1] = fPrizm[0];
+  fLens[2] = 12 * mm;
+
+  // Getting box XML
+  const int fNBoxes = xml_box_module.repeat();
+  const double box_width = xml_box_module.width();
+  const double box_height = xml_box_module.height();
+  const double box_length = xml_box_module.length() + 550*mm;
+
+
+  // The DIRC
+  Assembly dirc_module("DIRCModule");
+
+  //Volume lDirc("lDirc", gDirc, air);
+  dirc_module.setVisAttributes(desc.visAttributes(xml_box_module.visStr()));
+
+
+  // FD... whatever F and D is
+  xml_comp_t xml_fd = xml_box_module.child(_Unicode(fd));
+  Box gFd("gFd", xml_fd.height()/2, xml_fd.width()/2, xml_fd.thickness()/2);
+  Volume lFd ("lFd", gFd, desc.material(xml_fd.materialStr()));
+  lFd.setVisAttributes(desc.visAttributes(xml_fd.visStr()));
+  //lFd.setSensitiveDetector(sens);
+
+
+  // The Bar
+  xml_comp_t xml_bar = xml_box_module.child(_Unicode(bar));
+  double bar_height = xml_bar.height();
+  double bar_width = xml_bar.width();
+  double bar_length = xml_bar.length();
+  Box gBar("gBar", bar_height/2, bar_width/2, bar_length/2);
+  Volume lBar("lBar", gBar, desc.material(xml_bar.materialStr()));
+  lBar.setVisAttributes(desc.visAttributes(xml_bar.visStr()));
+
+  // Glue
+  xml_comp_t xml_glue = xml_box_module.child(_Unicode(glue));
+  double glue_thickness = xml_glue.thickness();  // 0.05 * mm;
+  Box gGlue("gGlue", bar_height/2, bar_width/2, glue_thickness/2);
+  Volume lGlue("lGlue", gGlue, desc.material(xml_glue.materialStr()));
+  lGlue.setVisAttributes(desc.visAttributes(xml_glue.visStr()));
+
+  sens.setType("tracker");
+  lBar.setSensitiveDetector(sens);
+
+  int bars_repeat_z = 4;    // TODO parametrize!
+  double bar_assm_length = (bar_length + glue_thickness) * bars_repeat_z;
+  int fNBar = xml_bar.repeat();
+  double bar_gap = xml_bar.gap();
+  for (int y_index = 0; y_index < fNBar; y_index++) {
+    double shift_y = y_index * (bar_width + bar_gap) - 0.5 * box_width + 0.5 * bar_width;
+    for (int z_index = 0; z_index < bars_repeat_z; z_index++) {
+      double z = -0.5 * bar_assm_length + 0.5 * bar_length + (bar_length + glue_thickness) * z_index;
+      auto placed_bar = dirc_module.placeVolume(lBar, Position(0, shift_y, z));
+      dirc_module.placeVolume(lGlue, Position(0, shift_y, z + 0.5 * (bar_length + glue_thickness)));
+      placed_bar.addPhysVolID("section", z_index);
+      placed_bar.addPhysVolID("bar", y_index);
+    }
+  }
+
+
+  // The Mirror
+  xml_comp_t xml_mirror = xml_box_module.child(_Unicode(mirror));
+  Box gMirror("gMirror", xml_mirror.height()/2, xml_mirror.width()/2, xml_mirror.thickness()/2);
+  Volume lMirror("lMirror", gMirror, desc.material(xml_mirror.materialStr()));
+  dirc_module.placeVolume(lMirror, Position(0, 0, -0.5 * (bar_assm_length - xml_mirror.thickness())));
+  lMirror.setVisAttributes(desc.visAttributes(xml_mirror.visStr()));
+
+  // The mirror optical surface
+  OpticalSurfaceManager surfMgr = desc.surfaceManager();
+  auto surf = surfMgr.opticalSurface("MirrorOpticalSurface");
+  SkinSurface skin(desc, det, Form("dirc_mirror_optical_surface"), surf, lMirror);
+  skin.isValid();
+
+  // LENS
+  // Lens volumes
+  Volume lLens1;
+  Volume lLens2;
+  Volume lLens3;
+
+  double lensMinThikness = 2.0 * mm;
+  double layer12 = lensMinThikness * 2;
+
+  // r1 = (r1==0)? 27.45: r1;
+  // r2 = (r2==0)? 20.02: r2;
+
+  double r1 = 33 * mm;
+  double r2 = 24 * mm;
+  double shight = 25 * mm;
+
+  Position zTrans1(0, 0, -r1 - fLens[2] / 2. + r1 - sqrt(r1 * r1 - shight / 2. * shight / 2.) + lensMinThikness);
+  Position zTrans2(0, 0, -r2 - fLens[2] / 2. + r2 - sqrt(r2 * r2 - shight / 2. * shight / 2.) + layer12);
+
+  Box gfbox("fbox", 0.5 * fLens[0], 0.5 * fLens[1], 0.5 * fLens[2]);
+  Box gcbox("cbox", 0.5 * fLens[0], 0.5 * fLens[1] + 1*mm, 0.5 * fLens[2]);
+
+//  Volume gfbox_volume("gfbox_volume", gfbox, bar_material);
+//  lDirc.placeVolume(gfbox_volume, Position(0, 0, 0));
+//
+//  Volume gcbox_volume("gcbox_volume", gcbox, bar_material);
+//  lDirc.placeVolume(gcbox_volume, Position(0, 0, 50));
+
+
+  Position tTrans1(0.5 * (fLens[0] + shight), 0, -fLens[2] + layer12);
+  Position tTrans0(-0.5 * (fLens[0] + shight), 0, -fLens[2] + layer12);
+  SubtractionSolid tubox("tubox", gfbox, gcbox, tTrans1);
+  SubtractionSolid gubox("gubox", tubox, gcbox, tTrans0);
+
+//  Volume tubox_volume("tubox_volume", tubox, bar_material);
+//  lDirc.placeVolume(tubox_volume, Position(0, 0, 100));
+//
+//  Volume gubox_volume("gubox_volume", gubox, bar_material);
+//  lDirc.placeVolume(gubox_volume, Position(0, 0, 150));
+
+  Tube gcylinder1("Cylinder1", 0, r1, 0.5 * fLens[1], 0 * deg, 360 * deg);
+  Tube gcylinder2("Cylinder2", 0, r2, 0.5 * fLens[1] - 0.5*mm, 0 * deg, 360 * deg);
+  Tube gcylinder1c("Cylinder1c", 0, r1, 0.5 * fLens[1] + 0.5*mm, 0 * deg, 360 * deg);
+  Tube gcylinder2c("Cylinder2c", 0, r2, 0.5 * fLens[1] + 0.5*mm, 0 * deg, 360 * deg);
+  RotationX xRot(-M_PI / 2.);
+
+  IntersectionSolid gLens1("Lens1", gubox, gcylinder1, Transform3D(xRot, zTrans1));
+  SubtractionSolid gLenst("temp", gubox, gcylinder1c, Transform3D(xRot, zTrans1));
+
+//  Volume gLens1_volume("gLens1_volume", gLens1, bar_material);
+//  lDirc.placeVolume(gLens1_volume, Position(0, 0, 200));
+//
+//  Volume gLenst_volume("gLenst_volume", gLenst, bar_material);
+//  lDirc.placeVolume(gLenst_volume, Position(0, 0, 250));
+
+  IntersectionSolid gLens2("Lens2", gLenst, gcylinder2, Transform3D(xRot, zTrans2));
+  SubtractionSolid gLens3("Lens3", gLenst, gcylinder2c, Transform3D(xRot, zTrans2));
+
+  lLens1 = Volume("lLens1", gLens1, bar_material);
+  lLens2 = Volume("lLens2", gLens2, nlak33a);
+  lLens3 = Volume("lLens3", gLens3, bar_material);
+
+  lLens1.setVisAttributes(desc.visAttributes("DIRCLens1"));
+  lLens2.setVisAttributes(desc.visAttributes("DIRCLens2"));
+  lLens3.setVisAttributes(desc.visAttributes("DIRCLens3"));
+
+
+  double shifth = 0.5 * (bar_assm_length + fLens[2]);
+  // fmt::print("LENS HERE shifth={}\n", shifth);
+
+  lLens1.setVisAttributes(desc.visAttributes("AnlTeal"));
+  dirc_module.placeVolume(lLens1, Position(0, 0, shifth));
+  dirc_module.placeVolume(lLens2, Position(0, 0, shifth));
+  dirc_module.placeVolume(lLens3, Position(0, 0, shifth));
+  
+  // The Prizm
+  Trap gPrizm = MakeTrap("gPrizm", fPrizm[0], fPrizm[1], fPrizm[2], fPrizm[3]);
+  Volume lPrizm("lPrizm", gPrizm, bar_material);
+  lPrizm.setVisAttributes(desc.visAttributes("DIRCPrism"));
+
+  //G4RotationMatrix *fdRot = new G4RotationMatrix();
+  //G4RotationMatrix *fdrot = new G4RotationMatrix();
+  double evshiftz = 0.5 * bar_assm_length + fPrizm[1] + fMcpActive[2] / 2. + fLens[2];
+  double evshiftx = -3*mm;
+
+  double prism_shift_x = (fPrizm[2] + fPrizm[3]) / 4. - 0.5 * fPrizm[3] + 1.5*mm;
+  double prism_shift_z = 0.5 * (bar_assm_length + fPrizm[1]) + fLens[2];
+
+  Position  fPrismShift(prism_shift_x, 0, prism_shift_z);
+  dirc_module.placeVolume(lPrizm, Transform3D(xRot, fPrismShift));
+  dirc_module.placeVolume(lFd, Position(0.5 * fFd[1] - 0.5 * fPrizm[3] - evshiftx, 0, evshiftz));
+
+  double dphi = 2 * M_PI / (double)fNBoxes;
+  for (int i = 0; i < fNBoxes; i++) {
+    double phi = dphi * i;
+    double dx = -fRadius * cos(phi);
+    double dy = -fRadius * sin(phi);
+
+    //G4RotationMatrix *tRot = new G4RotationMatrix();
+
+    Transform3D  tr(RotationZ(phi+M_PI), Position(dx, dy, 0));
+    PlacedVolume box_placement = det_volume.placeVolume(dirc_module, tr);
+    box_placement.addPhysVolID("module", i);
+
+
+    // fmt::print("placing dircbox # {} -tphi={:.0f} dx={:.0f}, dy={:.0f}\n", i, phi/deg, dx/cm, dy/cm);
+
+    //new G4PVPlacement(tRot, G4ThreeVector(dx, dy, 0), lDirc, "wDirc", lExpHall, false, i);
+  }
+
+    
+  //////////////////
+  // DIRC Bars
+  //////////////////
+
+  // double bar_radius   = 83.65 * cm;
+  // double bar_length   = SizeZ;
+  // double bar_width    = 42. * cm;
+  // double bar_thicknes = 1.7 * cm;
+  // int    bar_count    = 2 * M_PI * bar_radius / bar_width;
+  // double bar_dphi     = 2 * 3.1415926 / bar_count;
+  // Material bar_material = desc.material("Quartz");
+
+  // 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("tracker");
+  // bar_volume.setSensitiveDetector(sens);
+
+  // for (int ia = 0; ia < bar_count; ia++) {
+  //   double phi = (ia * (bar_dphi));
+  //   double x   = -bar_radius * cos(phi);
+  //   double y   = -bar_radius * sin(phi);
+
+  //   Transform3D  tr(RotationZ(bar_dphi * ia), Position(x, y, 0));
+  //   PlacedVolume barPV = det_volume.placeVolume(bar_volume, tr);
+  //   barPV.addPhysVolID("module", ia);
+  // }
+  return det;
+}
+
+DECLARE_DETELEMENT(cb_DIRC, createDetector)
+
+dd4hep::Trap MakeTrap( const std::string& pName, double pZ, double pY, double pX, double pLTX )
+{
+    // Fixed Trap constructor. This function is a workaround of this bug:
+    // https://github.com/AIDASoft/DD4hep/issues/850
+    // Should be used instead of dd4hep::Trap(pName, pZ, pY, pX, pLTX) constructor
+
+    double fDz  = 0.5*pZ;
+    double fTthetaCphi = 0;
+    double fTthetaSphi = 0;
+    double fDy1 = 0.5*pY;
+    double fDx1 = 0.5*pX;
+    double fDx2 = 0.5*pLTX;
+    double fTalpha1 = 0.5*(pLTX - pX)/pY;
+    double fDy2 = fDy1;
+    double fDx3 = fDx1;
+    double fDx4 = fDx2;
+    double fTalpha2 = fTalpha1;
+
+    return Trap(pName, fDz,  fTthetaCphi,  fTthetaSphi,
+                fDy1,  fDx1,  fDx2,  fTalpha1,
+                fDy2,  fDx3,  fDx4,  fTalpha2);
+}
+