diff --git a/macro/trd/geometry/trd.v20/Create_TRD_Geometry_v20a.C b/macro/trd/geometry/trd.v20/Create_TRD_Geometry_v20a.C
new file mode 100644
index 0000000000000000000000000000000000000000..8e9815e6c08503c527993bfedd8a6d98c404ed60
--- /dev/null
+++ b/macro/trd/geometry/trd.v20/Create_TRD_Geometry_v20a.C
@@ -0,0 +1,4741 @@
+///
+/// \file Create_TRD_Geometry_v20a.C
+/// \brief Generates TRD geometry in Root format.
+///
+
+// 2020-10-12 - DE - v20a    - put TRD layers at z-positions according to proposed CAD frame design
+// 2017-06-02 - DE - v17n    - increase pad granularity wrt v17l: type 6 = 24 rows, type 8 = 8 rows
+// 2017-05-31 - DE - v17l    - increase large module size to 96/99 cm
+// 2017-05-25 - DE - v17k    - use only 4 module types: 1, 3, 6, 8
+// 2017-05-25 - DE - v17j    - re-arrange inner zone to allow for a 2x1 hole
+// 2017-04-28 - DE - v17     - implement power bus bars as defined in the TDR
+// 2017-04-26 - DE - v17     - add aluminium ledge around backpanel
+// 2017-04-25 - DE - v17c_3e - reduce the number of FEBs on the small modules from 10, 6, 4 to 8, 4 and 2
+// 2017-02-14 - DE - v17b_3e - build TRD from ROB-3 only, optimise layout
+// 2017-01-10 - DE - v17a_3e - replace 6 ultimate density by 9 super density FEBs for TRD type 1 modules
+// 2016-07-05 - FU - v16a_3e - identical to v15a, change the way the trd volume is exported to resolve a bug with TGeoShape destructor
+// 2015-01-08 - DE - v15a_3e - reduce frame thickness in large modules to 15 mm instead of 20 mm
+// 2014-06-25 - DE - v14a_3e - consists of only 3 small and 3 large modules types (was 4+4 before)
+// 2014-06-25 - DE - v14a_3e - inner part of all 3 stations is now identical
+// 2014-05-02 - DE - v14a_3e - redesign inner part of station 3, now with 5x5-1 small modules, like in station 1 and station 2
+// 2014-05-02 - DE - v14a_3e - include optional GBTX readout boards on each module
+// 2014-05-02 - DE - v14a_3e - introduce 3x5=15 Spadic FEBs for ultimate density on module type 1
+//
+// 2013-11-14 - DE - v13q_3e - generate information about pad plane layout (CbmTrdPads_v14a.h) for all module types in this macro
+//
+// 2013-11-04 - DE - v13p4 - adapt the number of front-end boards to the pad layout of the 540 mm modules
+// 2013-11-04 - DE - v13p4 - use 8 module types (4x S + 4x L) to better match the occupancy
+// 2013-10-31 - DE - v13p4 - modify the support structure of station 1 to match with the MUCH/RICH platform
+// 2013-10-29 - DE - v13p4 - build lattice grid as TGeoBBox instead of VolumeAssembly - in run_sim.C save  9% of time compared to v13p7
+// 2013-10-29 - DE - v13p4 - build lattice grid as TGeoBBox instead of CompositeShape - in run_sim.C save 18% of time compared to v13p6
+//
+// 2013-10-28 - DE - introduce new geometry naming scheme: v13p1 - SIS 100 hadron
+// 2013-10-28 - DE - introduce new geometry naming scheme: v13p2 - SIS 100 electron
+// 2013-10-28 - DE - introduce new geometry naming scheme: v13p3 - SIS 100 muon
+// 2013-10-28 - DE - introduce new geometry naming scheme: v13p4 - SIS 300 electron
+// 2013-10-28 - DE - introduce new geometry naming scheme: v13p5 - SIS 300 muon
+// 2013-10-28 - DE - add option to draw the magnetic field vector in the magnet
+// 2013-09-27 - DE - do not use TGeoXtru to build the supports, use TGeoBBox instead
+//
+// 2013-06-25 - DE - v13g trd300_rich             (10 layers, z = 4100 ) - TRD right behind SIS300 RICH
+// 2013-06-25 - DE - v13h trd100_sts              ( 4 layers, z = 2600 ) - TRD completely on RICH/MUCH platform to allow TOF to move upstream
+// 2013-06-25 - DE - v13i trd100_rich             ( 2 layers, z = 4100 ) - TRD right behind RICH
+// 2013-06-25 - DE - v13j trd100_rich             ( 3 layers, z = 4100 ) - TRD right behind RICH
+// 2013-06-25 - DE - v13k trd100_rich             ( 4 layers, z = 4100 ) - TRD right behind RICH
+// 2013-06-25 - DE - ---  trd100_much_2_absorbers ( 4 layers, z = 4300 ) - same as version at z = 4600
+// 2013-06-25 - DE - v13l trd100_much_3_absorbers ( 4 layers, z = 4600 ) - TRD right behind SIS100 MUCH
+// 2013-06-25 - DE - v13m trd300_much_6_absorbers (10 layers, z = 5500 ) - TRD right behind SIS300 MUCH
+// 2013-06-25 - DE - v13n trd300_rich_stretched   (10 layers, z = 4600 ) - TRD stretched behind SIS300 RICH
+//
+// 2013-06-19 - DE - add TRD (I, II, III) labels on support structure
+// 2013-05-29 - DE - allow for flexible TRD z-positions defined by position of layer01
+// 2013-05-23 - DE - remove "trd_" prefix from node names (except top node)
+// 2013-05-22 - DE - radiators G30 (z=240 mm)
+// 2013-05-22 - DE - radiators H (z=275 mm - 125 * 2.2mm), (H++ z=335 mm)
+// 2013-05-22 - DE - radiators B++ (z=254 mm - 350 * 0.724 mm), K++ (z=254 mm - 350 * 0.724 mm)
+// 2013-04-17 - DE - introduce volume assembly for layers, e.g. trd_layer03
+// 2013-03-26 - DE - use Air as ASIC material
+// 2013-03-26 - DE - put support structure into its own assembly
+// 2013-03-26 - DE - move TRD upstream to z=400m
+// 2013-03-26 - DE - RICH will probably end at z=380 cm, TRD can move to 400 cm
+// 2013-03-25 - DE - shrink active area from 570 to 540 mm and 960 to 910 mm
+// 2013-03-06 - DE - add ASICs on FEBs
+// 2013-03-05 - DE - introduce supports for SIS100 and SIS300
+// 2013-03-05 - DE - replace all Float_t by Double_t
+// 2013-01-21 - DE - introduce TRD media, use TRDG10 as material for pad plane and FEBs
+// 2013-01-21 - DE - put backpanel into the geometry
+// 2013-01-11 - DE - allow for misalignment of TRD modules
+// 2012-11-04 - DE - add kapton foil, add FR4 padplane
+// 2012-11-03 - DE - add lattice grid on entrance window as CompositeShape
+
+// TODO:
+// - use Silicon as ASIC material
+
+// in root all sizes are given in cm
+
+#include "TDatime.h"
+#include "TFile.h"
+#include "TGeoCompositeShape.h"
+#include "TGeoManager.h"
+#include "TGeoMaterial.h"
+#include "TGeoMatrix.h"
+#include "TGeoMedium.h"
+#include "TGeoPgon.h"
+#include "TGeoVolume.h"
+#include "TGeoXtru.h"
+#include "TList.h"
+#include "TRandom3.h"
+#include "TString.h"
+#include "TSystem.h"
+
+#include "TGeoArb8.h"
+#include "TGeoCone.h"
+#include "TGeoTube.h"
+
+#include <iostream>
+
+// Name of output file with geometry
+const TString tagVersion = "v20a";
+//const TString subVersion   = "_1h";
+//const TString subVersion   = "_1e";
+//const TString subVersion   = "_1m";
+//const TString subVersion   = "_3e";
+//const TString subVersion   = "_3m";
+
+const Int_t setupid = 1;  // 1e is the default
+//const Double_t zfront[5]  = { 260., 410., 360., 410., 550. };  // original
+const Double_t zfront[5]  = {435.,  // SIS100 hadron
+                            435.,  // SIS100 electron
+                            472.,  // SIS100 muon
+                            410.,
+                            550.};  // muon_jpsi and muon_lmvm
+const TString setupVer[5] = {"_1h", "_1e", "_1m", "_3e", "_3m"};
+const TString subVersion  = setupVer[setupid];
+
+const TString geoVersion   = "trd_" + tagVersion + subVersion;
+const TString FileNameSim  = geoVersion + ".geo.root";
+const TString FileNameGeo  = geoVersion + "_geo.root";
+const TString FileNameInfo = geoVersion + ".geo.info";
+const TString FileNamePads = "CbmTrdPads_" + tagVersion + ".h";
+
+// display switches
+const Bool_t IncludeRadiator =
+  true;  // false;  // true, if radiator is included in geometry
+const Bool_t IncludeLattice =
+  true;  // false;  // true, if lattice grid is included in geometry
+
+const Bool_t IncludeKaptonFoil =
+  true;  // false;  // true, if entrance window is included in geometry
+const Bool_t IncludeGasFrame =
+  true;  // false;  // true, if frame around gas volume is included in geometry
+const Bool_t IncludePadplane =
+  true;  // false;  // true, if padplane is included in geometry
+const Bool_t IncludeBackpanel =
+  true;  // false;  // true, if backpanel is included in geometry
+const Bool_t IncludeAluLedge =
+  true;  // false;  // true, if Al-ledge around the backpanel is included in geometry
+const Bool_t IncludePowerbars =
+  true;  // false;  // true, if LV copper bus bars to be drawn
+
+const Bool_t IncludeFebs =
+  true;  // false;  // true, if FEBs are included in geometry
+const Bool_t IncludeRobs =
+  true;  // false;  // true, if ROBs are included in geometry
+const Bool_t IncludeAsics =
+  true;  // false;  // true, if ASICs are included in geometry
+const Bool_t IncludeSupports =
+  true;  // false;  // true, if support structure is included in geometry
+const Bool_t IncludeLabels =
+  true;  // false;  // true, if TRD (I, II, III) labels are plotted in (VisLevel 5)
+const Bool_t IncludeFieldVector =
+  false;  // true, if magnetic field vector to be shown (in the magnet)
+
+// positioning switches
+const Bool_t DisplaceRandom =
+  false;  // true; // false;  // add random displacement of modules for alignment study
+const Bool_t RotateRandom =
+  false;  // true; // false;  // add random rotation of modules for alignment study
+const Bool_t DoExplode =
+  false;  // true, // false;  // add random displacement of modules for alignment study
+
+// positioning parameters
+const Double_t maxdx = 0.2;  // max +- 0.1 cm shift in x
+const Double_t maxdy = 0.2;  // max +- 0.1 cm shift in y
+const Double_t maxdz = 1.0;  // max +- 1.0 cm shift in z
+
+const Double_t maxdrotx = 2.0;  // 20.0; // max rotation around x
+const Double_t maxdroty = 2.0;  // 20.0; // max rotation around y
+const Double_t maxdrotz = 2.0;  // 20.0; // max rotation around z
+
+const Double_t ExplodeFactor =
+  1.02;  // 1.02; // Factor by which modules are exploded in the x/y plane
+
+// initialise random numbers
+TRandom3 r3(0);
+
+// Parameters defining the layout of the complete detector build out of different detector layers.
+const Int_t MaxLayers = 10;  // max layers
+
+// select layers to display
+//
+//const Int_t    ShowLayer[MaxLayers] = { 1, 0, 0, 0, 0, 0, 0, 0, 0, 0 };  //  1st layer only
+//const Int_t    ShowLayer[MaxLayers] = { 0, 1, 0, 0, 0, 0, 0, 0, 0, 0 };  //  2nd layer only
+//const Int_t    ShowLayer[MaxLayers] = { 0, 0, 0, 0, 1, 0, 0, 0, 0, 0 };  //  5th layer only
+//const Int_t    ShowLayer[MaxLayers] = { 0, 0, 0, 0, 0, 1, 0, 0, 0, 0 };  //  6th layer only
+//const Int_t    ShowLayer[MaxLayers] = { 0, 0, 0, 0, 0, 0, 0, 0, 1, 0 };  //  9th layer only
+//const Int_t    ShowLayer[MaxLayers] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 1 };  // 10th layer only
+//
+//const Int_t    ShowLayer[MaxLayers] = { 1, 1, 0, 0, 0, 0, 0, 0, 0, 0 };  // Station 1, layer 1, 2
+//const Int_t    ShowLayer[MaxLayers] = { 0, 0, 0, 0, 1, 1, 0, 0, 0, 0 };  // Station 2, layer 5, 6
+//const Int_t    ShowLayer[MaxLayers] = { 0, 0, 0, 0, 0, 0, 0, 0, 1, 1 };  // Station 3, layer 9,10
+//const Int_t    ShowLayer[MaxLayers] = { 1, 1, 0, 0, 1, 1, 0, 0, 0, 0 };  // Station 1 and 2
+//const Int_t    ShowLayer[MaxLayers] = { 1, 1, 0, 0, 1, 1, 1, 0, 1, 1 };  // Station 1, 2 and 3
+//
+//const Int_t    ShowLayer[MaxLayers] = { 1, 1, 0, 0, 0, 0, 0, 0, 0, 0 };  // SIS100-2l  // 1: plot, 0: hide
+//const Int_t    ShowLayer[MaxLayers] = { 1, 1, 1, 0, 0, 0, 0, 0, 0, 0 };  // SIS100-3l  // 1: plot, 0: hide
+//
+//const Int_t    ShowLayer[MaxLayers] = { 1, 1, 1, 1, 0, 0, 0, 0, 0, 0 };  // SIS100-4l  // 1: plot, 0: hide
+//const Int_t    ShowLayer[MaxLayers] = { 0, 0, 0, 0, 1, 1, 1, 1, 1, 1 };  // SIS300-mu  // 1: plot, 0: hide
+//const Int_t    ShowLayer[MaxLayers] = { 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 };  // SIS300-e   // 1: plot, 0: hide
+Int_t ShowLayer[MaxLayers] =
+  {1, 1, 1, 1, 0, 0, 0, 0, 0, 0};  // SIS100-4l is default
+
+Int_t BusBarOrientation[MaxLayers] =
+  {1, 1, 1, 1, 0, 0, 0, 0, 0, 0};  // 1 = vertical
+
+Int_t PlaneId[MaxLayers];  // automatically filled with layer ID
+
+const Int_t LayerType[MaxLayers] = {
+  10,
+  11,
+  10,
+  11,
+  20,
+  21,
+  20,
+  21,
+  30,
+  31};  // ab: a [1-3] - layer type, b [0,1] - vertical/horizontal pads
+// ### Layer Type 11 is Layer Type 1 with detector modules rotated by 90°
+// ### Layer Type 21 is Layer Type 2 with detector modules rotated by 90°
+// ### Layer Type 31 is Layer Type 3 with detector modules rotated by 90°
+// In the subroutine creating the layers this is recognized automatically
+
+const Int_t LayerNrInStation[MaxLayers] = {1, 2, 3, 4, 1, 2, 3, 4, 1, 2};
+
+Double_t LayerPosition[MaxLayers] = {
+  0.};  // start position = 0 - 2016-07-12 - DE
+
+// 5x z-positions from 260 till 550 cm
+//Double_t LayerPosition[MaxLayers] = { 260. }; // start position - 2013-10-28 - DE - v14_1h - SIS 100 hadron         ( 4 layers, z = 2600 )
+//Double_t LayerPosition[MaxLayers] = { 410. }; // start position - 2013-10-28 - DE - v14_1e - SIS 100 electron       ( 4 layers, z = 4100 )
+//Double_t LayerPosition[MaxLayers] = { 360. }; // start position - 2014-06-16 - DE - v14_1m - SIS 100 muon           ( 4 layers, z = 3600 ) was 460.
+//Double_t LayerPosition[MaxLayers] = { 410. }; // start position - 2013-10-28 - DE - v14_3e - SIS 300 electron       (10 layers, z = 4100 )
+//Double_t LayerPosition[MaxLayers] = { 550. }; // start position - 2013-10-28 - DE - v14_3m - SIS 300 muon     6_abs (10 layers, z = 5500 )
+//
+// obsolete variants
+//Double_t LayerPosition[MaxLayers] = { 460. }; // start position - 2013-10-28 - DE - v13x3 - SIS 100 muon         ( 4 layers, z = 4600 )
+//Double_t LayerPosition[MaxLayers] = { 410. }; // start position - 2013-06-25 - DE - v13i trd100_rich             ( 2 layers, z = 4100 )
+//Double_t LayerPosition[MaxLayers] = { 410. }; // start position - 2013-06-25 - DE - v13j trd100_rich             ( 3 layers, z = 4100 )
+//Double_t LayerPosition[MaxLayers] = { 430. }; // start position - 2013-06-25 - DE - ---  trd100_much_2_absorbers ( 4 layers, z = 4300 )
+//Double_t LayerPosition[MaxLayers] = { 460. }; // start position - 2013-06-25 - DE - v13n trd300_rich_stretched   (10 layers, z = 4600 )
+
+
+const Double_t LayerThickness =
+  71.0;  // 45.0;  // Thickness of one TRD layer in cm
+
+const Double_t LayerOffset[MaxLayers] = {
+  0.,
+  0.,
+  0.,
+  0.,
+  5.,
+  0.,
+  0.,
+  0.,
+  5.,
+  0.};  // v13x[4,5] - z offset in addition to LayerThickness
+//const Double_t LayerOffset[MaxLayers] = {   0.,   0.,   0.,   0.,   0.,   0.,   0.,   0.,   0.,   0. };  // SIS100 - z offset in addition to LayerThickness
+//const Double_t LayerOffset[MaxLayers] = {   0.,   0.,   0.,   0.,  95.,   0.,   0.,   0.,   5.,   0. };  // v13n       - z offset in addition to LayerThickness
+
+const Int_t LayerArraySize[3][4] = {{9, 4, 9, 11},  // for layer[1-3][i,o] below
+                                    {5, 5, 9, 11},
+                                    {5, 5, 9, 11}};
+
+
+// ### Layer Type 1
+// v14x - module types in the inner sector of layer type 1 - looking upstream
+const Int_t layer1i[9][4] = {
+  {323,
+   323,
+   321,
+   321},  // abc: a module type - b orientation (x90 deg) in odd - c even layers
+  {323, 323, 321, 321},
+  {323, 323, 321, 321},
+  {123, 123, 121, 121},
+  {103, 0, 0, 101},
+  {103, 103, 101, 101},
+  {303, 303, 301, 301},
+  {303, 303, 301, 301},
+  {303, 303, 301, 301}};
+// number of modules: 24
+
+// v14x - module types in the outer sector of layer type 1 - looking upstream
+const Int_t layer1o[9][11] = {{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
+                              {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
+                              {0, 0, 723, 723, 0, 0, 0, 721, 721, 0, 0},
+                              {0, 0, 723, 523, 0, 0, 0, 521, 721, 0, 0},
+                              {0, 0, 503, 503, 0, 0, 0, 501, 501, 0, 0},
+                              {0, 0, 703, 503, 0, 0, 0, 501, 701, 0, 0},
+                              {0, 0, 703, 703, 0, 0, 0, 701, 701, 0, 0},
+                              {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
+                              {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}};
+// number of modules: 26
+// Layer1 =  24 + 26;   // v14a
+
+
+// ### Layer Type 2
+// v14x - module types in the inner sector of layer type 2 - looking upstream
+const Int_t layer2i[5][5] = {
+  {323,
+   323,
+   321,
+   321,
+   321},  // abc: a module type - b orientation (x90 deg) in odd - c even layers
+  {223, 123, 121, 121, 221},
+  {203, 103, 0, 101, 201},
+  {203, 103, 101, 101, 201},
+  {303, 303, 301, 301, 301}};
+// number of modules: 24
+
+// v14x - module types in the outer sector of layer type 2 - looking upstream
+const Int_t layer2o[9][11] = {
+  {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
+  {0, 823, 823, 823, 823, 821, 821, 821, 821, 821, 0},
+  {0, 823, 823, 823, 723, 721, 721, 821, 821, 821, 0},
+  {0, 823, 723, 623, 0, 0, 0, 621, 721, 821, 0},
+  {0, 803, 703, 603, 0, 0, 0, 601, 701, 801, 0},
+  {0, 803, 703, 603, 0, 0, 0, 601, 701, 801, 0},
+  {0, 803, 803, 803, 703, 701, 701, 801, 801, 801, 0},
+  {0, 803, 803, 803, 803, 801, 801, 801, 801, 801, 0},
+  {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}};
+// number of modules: 54
+// Layer2 =  24 + 54;   // v14a
+
+
+// ### Layer Type 3
+// v14x - module types in the inner sector of layer type 3 - looking upstream
+const Int_t layer3i[5][5] = {
+  {323,
+   323,
+   321,
+   321,
+   321},  // abc: a module type - b orientation (x90 deg) in odd - c even layers
+  {223, 123, 121, 121, 221},
+  {203, 103, 0, 101, 201},
+  {203, 103, 101, 101, 201},
+  {303, 303, 301, 301, 301}};
+// number of modules: 24
+
+// v14x - module types in the outer sector of layer type 3 - looking upstream
+const Int_t layer3o[9][11] = {
+  {823, 823, 823, 823, 823, 821, 821, 821, 821, 821, 821},
+  {823, 823, 823, 823, 823, 821, 821, 821, 821, 821, 821},
+  {823, 823, 823, 723, 623, 621, 621, 721, 821, 821, 821},
+  {823, 823, 723, 623, 0, 0, 0, 621, 721, 821, 821},
+  {803, 803, 703, 603, 0, 0, 0, 601, 701, 801, 801},
+  {803, 803, 703, 603, 0, 0, 0, 601, 701, 801, 801},
+  {803, 803, 803, 703, 603, 601, 601, 701, 801, 801, 801},
+  {803, 803, 803, 803, 803, 801, 801, 801, 801, 801, 801},
+  {803, 803, 803, 803, 803, 801, 801, 801, 801, 801, 801}};
+// number of modules: 90
+// Layer2 =  24 + 90;   // v14a
+
+
+// Parameters defining the layout of the different detector modules
+const Int_t NofModuleTypes = 8;
+const Int_t ModuleType[NofModuleTypes] =
+  {0, 0, 0, 0, 1, 1, 1, 1};  // 0 = small module, 1 = large module
+
+// FEB inclination angle
+const Double_t feb_rotation_angle[NofModuleTypes] = {
+  60,
+  90,
+  90,
+  80,
+  60,
+  60,
+  90,
+  90};  // rotation around x-axis, 0 = vertical, 90 = horizontal
+//const Double_t feb_rotation_angle[NofModuleTypes] = { 60,  90,  90,  80,  80,  90,  90,  90 }; // rotation around x-axis, 0 = vertical, 90 = horizontal
+//const Double_t feb_rotation_angle[NofModuleTypes] = { 45,  45,  45,  45,  45,  45,  45,  45 }; // rotation around x-axis, 0 = vertical, 90 = horizontal
+
+// GBTx ROB definitions
+//// v17d
+//const Int_t RobsPerModule[NofModuleTypes] = {  4,  2,  2,  1,  2,  3,  2,  1 }; // number of GBTx ROBs on module
+//const Int_t GbtxPerRob[NofModuleTypes]    = {103,103,103,103,107,103,103,103 }; // number of GBTx ASICs on ROB
+//
+//const Int_t GbtxPerModule[NofModuleTypes] = {   12,  6,  6,  0,  0,  9,  6,  3 }; // for .geo.info - TODO: merge with above GbtxPerRob
+//const Int_t RobTypeOnModule[NofModuleTypes]={ 3333, 33, 33,  0,  0,333, 33,  3 }; // for .geo.info - TODO: merge with above GbtxPerRob
+//
+// v17l - 96 cm
+const Int_t RobsPerModule[NofModuleTypes] =
+  {4, 2, 1, 1, 6, 6, 2, 2};  // number of GBTx ROBs on module
+const Int_t GbtxPerRob[NofModuleTypes] =
+  {103, 103, 103, 103, 103, 103, 103, 103};  // number of GBTx ASICs on ROB
+
+const Int_t GbtxPerModule[NofModuleTypes] = {
+  12,
+  6,
+  3,
+  0,
+  18,
+  18,
+  6,
+  6};  // for .geo.info - TODO: merge with above GbtxPerRob
+const Int_t RobTypeOnModule[NofModuleTypes] = {
+  3333,
+  33,
+  3,
+  0,
+  333333,
+  333333,
+  33,
+  33};  // for .geo.info - TODO: merge with above GbtxPerRob
+
+//// v17c
+//const Int_t RobsPerModule[NofModuleTypes] = {  4,  2,  1,  1,  2,  3,  2,  1 }; // number of GBTx ROBs on module
+//const Int_t GbtxPerRob[NofModuleTypes]    = {103,103,103,103,107,103,103,103 }; // number of GBTx ASICs on ROB
+//
+//const Int_t GbtxPerModule[NofModuleTypes] = {   12,  6,  3,  0,  0,  9,  6,  3 }; // for .geo.info - TODO: merge with above GbtxPerRob
+//const Int_t RobTypeOnModule[NofModuleTypes]={ 3333, 33,  3,  0,  0,333, 33,  3 }; // for .geo.info - TODO: merge with above GbtxPerRob
+
+//// v17b
+//const Int_t RobsPerModule[NofModuleTypes] = {  5,  3,  2,  1,  2,  3,  2,  1 }; // number of GBTx ROBs on module
+//const Int_t GbtxPerRob[NofModuleTypes]    = {103,103,103,103,107,103,103,103 }; // number of GBTx ASICs on ROB
+//
+//const Int_t GbtxPerModule[NofModuleTypes] = {   15,  9,  6,  0,  0,  9,  6,  3 }; // for .geo.info - TODO: merge with above GbtxPerRob
+//const Int_t RobTypeOnModule[NofModuleTypes]={33333,333, 33,  0,  0,333, 33,  3 }; // for .geo.info - TODO: merge with above GbtxPerRob
+
+//v17a // GBTx ROB definitions
+//v17a const Int_t RobsPerModule[NofModuleTypes] = {  3,  2,  1,  1,  2,  2,  1,  1 }; // number of GBTx ROBs on module
+//v17a const Int_t GbtxPerRob[NofModuleTypes]    = {105,105,105,103,107,105,105,103 }; // number of GBTx ASICs on ROB
+//v17a
+//v17a const Int_t GbtxPerModule[NofModuleTypes] = { 15, 10,  5,  0,  0, 10,  5,  3 }; // for .geo.info - TODO: merge with above GbtxPerRob
+//v17a const Int_t RobTypeOnModule[NofModuleTypes]={555, 55,  5,  0,  0, 55,  5,  3 }; // for .geo.info - TODO: merge with above GbtxPerRob
+
+//const Int_t RobsPerModule[NofModuleTypes] = {  2,  2,  1,  1,  2,  2,  1,  1 }; // number of GBTx ROBs on module
+//const Int_t GbtxPerRob[NofModuleTypes]    = {107,105,105,103,107,105,105,103 }; // number of GBTx ASICs on ROB
+//const Int_t GbtxPerModule[NofModuleTypes] = { 14,  8,  5,  0,  0, 10,  5,  3 }; // for .geo.info - TODO: merge with above GbtxPerRob
+//const Int_t RobTypeOnModule[NofModuleTypes] = { 77, 53,  5,  0,  0, 55,  5,  3 }; // for .geo.info - TODO: merge with above GbtxPerRob
+
+// super density for type 1 modules - 2017 - 540 mm
+//// v17d
+//const Int_t FebsPerModule[NofModuleTypes] = {  8,  4,  4,  4, 12,  9,  6,  3 }; // number of FEBs on backside
+//const Int_t AsicsPerFeb[NofModuleTypes]   = {210,210,210,105,108,107,107,107 }; // %100 gives number of ASICs on FEB, /100 gives grouping
+
+// v17l - 96 cm
+//const Int_t FebsPerModule[NofModuleTypes] = {  8,  4,  2,  4, 12,  8,  6,  4 }; // number of FEBs on backside
+//const Int_t FebsPerModule[NofModuleTypes] = {  8,  4,  2,  4, 12,  8,  6,  2 }; // number of FEBs on backside
+const Int_t FebsPerModule[NofModuleTypes] =
+  {8, 4, 2, 4, 12, 12, 4, 4};  // number of FEBs on backside
+const Int_t AsicsPerFeb[NofModuleTypes] = {
+  210,
+  210,
+  210,
+  105,
+  109,
+  109,
+  109,
+  109};  // %100 gives number of ASICs on FEB, /100 gives grouping
+
+//// v17c
+//const Int_t FebsPerModule[NofModuleTypes] = {  8,  4,  2,  4, 12,  9,  6,  3 }; // number of FEBs on backside
+//const Int_t AsicsPerFeb[NofModuleTypes]   = {210,210,210,105,108,107,107,107 }; // %100 gives number of ASICs on FEB, /100 gives grouping
+
+//// v17b
+//const Int_t FebsPerModule[NofModuleTypes] = {  10,  6,  4,  4, 12,  9,  6,  3 }; // number of FEBs on backside
+//const Int_t AsicsPerFeb[NofModuleTypes]   = {210,210,210,105,108,107,107,107 }; // %100 gives number of ASICs on FEB, /100 gives grouping
+// v17a // super density for type 1 modules - 2017 - 540 mm
+// v17a //const Int_t FebsPerModule[NofModuleTypes] = {  9,  5,  6,  4, 12,  8,  4,  3 }; // number of FEBs on backside
+// v17a const Int_t FebsPerModule[NofModuleTypes] = {  9,  6,  3,  4, 12,  8,  4,  3 }; // number of FEBs on backside
+// v17a const Int_t AsicsPerFeb[NofModuleTypes]   = {210,210,210,105,108,108,108,108 }; // %100 gives number of ASICs on FEB, /100 gives grouping
+//// ultimate density - 540 mm
+//const Int_t FebsPerModule[NofModuleTypes] = {  6,  5,  6,  4, 12,  8,  4,  3 }; // number of FEBs on backside - reduced FEBs (64 ch ASICs)
+//const Int_t AsicsPerFeb[NofModuleTypes]   = {315,210,105,105,108,108,108,108 }; //  %100 gives number of ASICs on FEB, /100 gives grouping
+////const Int_t FebsPerModule[NofModuleTypes] = {  6,  5,  3,  2,  6,  3,  4,  3 }; // min number of FEBs // number of FEBs on backside - reduced FEBs (64 ch ASICs)
+////const Int_t AsicsPerFeb[NofModuleTypes]   = {315,210,210,210,216,216,108,108 }; //  %100 gives number of ASICs on FEB, /100 gives grouping
+////const Int_t AsicsPerFeb[NofModuleTypes]   = {216,210,210,210,216,216,108,108 }; //  %100 gives number of ASICs on FEB, /100 gives grouping
+//
+////// super density - 540 mm
+//const Int_t FebsPerModule[NofModuleTypes] = {  9,  5,  6,  4, 12,  6,  4,  3 }; // light // number of FEBs on backside - reduced FEBs (64 ch ASICs)
+//const Int_t AsicsPerFeb[NofModuleTypes]   = {210,210,105,105,108,108,108,108 }; // %100 gives number of ASICs on FEB, /100 gives grouping
+//
+//// normal density - 540 mm
+//const Int_t FebsPerModule[NofModuleTypes] = { 18, 10,  6,  4, 12,  6,  4,  3 }; // number of FEBs on backside (linked to pad layout) - mod4 = mod3, therefore same
+//const Int_t AsicsPerFeb[NofModuleTypes]   = {105,105,105,105,108,108,108,108 }; // %100 gives number of ASICs on FEB, /100 gives grouping
+
+// ultimate density - 570 mm
+//const Int_t FebsPerModule[NofModuleTypes] = {  6,  5,  3,  2,  5,  3,  2,  1 }; // min number of FEBs // number of FEBs on backside - reduced FEBs (64 ch ASICs)
+//const Int_t AsicsPerFeb[NofModuleTypes]   = {216,210,210,210,216,216,216,216 }; //  %100 gives number of ASICs on FEB, /100 gives grouping
+//
+//const Int_t FebsPerModule[NofModuleTypes] = {  6,  5,  3,  3, 10,  5,  3,  3 }; // min (6) module types // number of FEBs on backside - reduced FEBs (64 ch ASICs)
+//const Int_t AsicsPerFeb[NofModuleTypes]   = {216,210,210,210,108,108,108,108 }; //  %100 gives number of ASICs on FEB, /100 gives grouping
+//// super density - 570 mm
+//const Int_t FebsPerModule[NofModuleTypes] = { 10,  5,  5,  5, 12,  6,  4,  3 }; // light // number of FEBs on backside - reduced FEBs (64 ch ASICs)
+//const Int_t AsicsPerFeb[NofModuleTypes]   = {210,210,105,105,108,108,108,108 }; // %100 gives number of ASICs on FEB, /100 gives grouping
+//
+//// normal density - 570 mm
+//const Int_t FebsPerModule[NofModuleTypes] = { 19, 10,  5,  5, 12,  6,  4,  3 }; // number of FEBs on backside (linked to pad layout) - mod4 = mod3, therefore same
+//const Int_t AsicsPerFeb[NofModuleTypes]   = {105,105,105,105,108,108,108,108 }; // %100 gives number of ASICs on FEB, /100 gives grouping
+
+
+/* TODO: activate connector grouping info below
+// ultimate - grouping of pads to connectors
+const Int_t RowsPerConnector[NofModuleTypes]  = {  6,  4,  2,  2,  2,  2,  2,  2 };
+const Int_t ColsPerConnector[NofModuleTypes]  = { 16, 16, 16, 16, 16, 16, 16, 16 };
+// super    - grouping of pads to connectors
+const Int_t RowsPerConnector[NofModuleTypes]  = {  4,  4,  2,  2,  2,  2,  2,  2 };
+const Int_t ColsPerConnector[NofModuleTypes]  = { 16, 16, 16, 16, 16, 16, 16, 16 };
+// normal   - grouping of pads to connectors
+const Int_t RowsPerConnector[NofModuleTypes]  = {  2,  2,  2,  2,  2,  2,  2,  2 };
+const Int_t ColsPerConnector[NofModuleTypes]  = { 16, 16, 16, 16, 16, 16, 16, 16 };
+*/
+
+
+const Double_t feb_z_offset = 0.1;  // 1 mm - offset in z of FEBs to backpanel
+const Double_t asic_offset =
+  0.1;  // 1 mm - offset of ASICs to FEBs to avoid overlaps
+
+// ASIC parameters
+Double_t asic_distance;
+
+//const Double_t FrameWidth[2]    = { 1.5, 2.0 };   // Width of detector frames in cm
+const Double_t FrameWidth[2] = {1.5, 1.5};  // Width of detector frames in cm
+// mini - production
+const Double_t DetectorSizeX[2] = {
+  57.,
+  99.};  // => 54 x 54 cm2 & 96 x 96 cm2 active area
+const Double_t DetectorSizeY[2] = {57., 99.};  // quadratic modules
+// 108 cm const Double_t DetectorSizeX[2] = { 57., 111.};   // => 54 x 54 cm2 & 108 x 108 cm2 active area
+// 108 cm const Double_t DetectorSizeY[2] = { 57., 111.};   // quadratic modules
+//// default
+//const Double_t DetectorSizeX[2] = { 60., 100.};   // => 57 x 57 cm2 & 96 x 96 cm2 active area
+//const Double_t DetectorSizeY[2] = { 60., 100.};   // quadratic modules
+
+// Parameters tor the lattice grid reinforcing the entrance window
+//const Double_t lattice_o_width[2] = { 1.5, 2.0 };   // Width of outer lattice frame in cm
+const Double_t lattice_o_width[2] = {
+  1.5,
+  1.5};  // Width of outer lattice frame in cm
+const Double_t lattice_i_width[2] = {
+  0.2,
+  0.2};  // { 0.4, 0.4 };   // Width of inner lattice frame in cm
+// Thickness (in z) of lattice frames in cm - see below
+
+// statistics
+Int_t ModuleStats[MaxLayers][NofModuleTypes] = {0};
+
+// z - geometry of TRD modules
+//const Double_t radiator_thickness     =  35.0;    // 35 cm thickness of radiator
+const Double_t radiator_thickness =
+  30.0;  // 30 cm thickness of radiator + shift pad plane to integer multiple of 1 mm
+const Double_t radiator_position =
+  -LayerThickness / 2. + radiator_thickness / 2.;
+
+//const Double_t lattice_thickness      =   1.0;  // 1.0;  // 10 mm thick lattice frames
+const Double_t lattice_thickness =
+  1.0 - 0.0025;  // 0.9975;  // 1.0;  // 10 mm thick lattice frames
+const Double_t lattice_position =
+  radiator_position + radiator_thickness / 2. + lattice_thickness / 2.;
+
+const Double_t kapton_thickness = 0.0025;  //  25 micron thickness of kapton
+const Double_t kapton_position =
+  lattice_position + lattice_thickness / 2. + kapton_thickness / 2.;
+
+const Double_t gas_thickness = 1.2;  //  12 mm thickness of gas
+const Double_t gas_position =
+  kapton_position + kapton_thickness / 2. + gas_thickness / 2.;
+
+// frame thickness
+const Double_t frame_thickness =
+  gas_thickness;  // frame covers gas volume: from kapton foil to pad plane
+const Double_t frame_position = -LayerThickness / 2. + radiator_thickness
+                                + lattice_thickness + kapton_thickness
+                                + frame_thickness / 2.;
+
+// pad plane
+const Double_t padcopper_thickness =
+  0.0025;  //  25 micron thickness of copper pads
+const Double_t padcopper_position =
+  gas_position + gas_thickness / 2. + padcopper_thickness / 2.;
+
+const Double_t padplane_thickness = 0.0360;  // 360 micron thickness of padplane
+const Double_t padplane_position =
+  padcopper_position + padcopper_thickness / 2. + padplane_thickness / 2.;
+
+// backpanel components
+const Double_t carbon_thickness =
+  0.0190
+  * 2;  // use 2 layers!!   // 190 micron thickness for 1 layer of carbon fibers
+const Double_t honeycomb_thickness =
+  2.3 - kapton_thickness - padcopper_thickness - padplane_thickness
+  - carbon_thickness;  //  ~ 2.3 mm thickness of honeycomb
+const Double_t honeycomb_position =
+  padplane_position + padplane_thickness / 2. + honeycomb_thickness / 2.;
+const Double_t carbon_position =
+  honeycomb_position + honeycomb_thickness / 2. + carbon_thickness / 2.;
+
+// aluminium thickness
+const Double_t aluminium_thickness =
+  0.4;  // crossbar of 1 x 1 cm at every module edge
+const Double_t aluminium_width =
+  1.0;  // crossbar of 1 x 1 cm at every module edge
+const Double_t aluminium_position =
+  carbon_position + carbon_thickness / 2. + aluminium_thickness / 2.;
+
+// power bus bars
+const Double_t powerbar_thickness = 1.0;  // 1 cm in z direction
+const Double_t powerbar_width     = 2.0;  // 2 cm in x/y direction
+const Double_t powerbar_position =
+  aluminium_position + aluminium_thickness / 2. + powerbar_thickness / 2.;
+
+// readout boards
+//const  Double_t feb_width           =  10.0;    // width of FEBs in cm
+const Double_t feb_width     = 8.5;   // width of FEBs in cm
+const Double_t feb_thickness = 0.25;  // light //  2.5 mm thickness of FEBs
+const Double_t febvolume_position =
+  aluminium_position + aluminium_thickness / 2. + feb_width / 2.;
+
+// ASIC parameters
+const Double_t asic_thickness = 0.25;  // 2.5 mm asic_thickness
+const Double_t asic_width     = 3.0;   // 2.0;  1.0;   // 1 cm
+
+
+// Names of the different used materials which are used to build the modules
+// The materials are defined in the global media.geo file
+const TString KeepingVolumeMedium   = "air";
+const TString RadiatorVolumeMedium  = "TRDpefoam20";
+const TString LatticeVolumeMedium   = "TRDG10";
+const TString KaptonVolumeMedium    = "TRDkapton";
+const TString GasVolumeMedium       = "TRDgas";
+const TString PadCopperVolumeMedium = "TRDcopper";
+const TString PadPcbVolumeMedium =
+  "TRDG10";  // todo - put correct FEB material here
+const TString HoneycombVolumeMedium = "TRDaramide";
+const TString CarbonVolumeMedium    = "TRDcarbon";
+const TString FebVolumeMedium =
+  "TRDG10";  // todo - put correct FEB material here
+const TString AsicVolumeMedium =
+  "air";  // todo - put correct ASIC material here
+const TString TextVolumeMedium     = "air";  // leave as air
+const TString FrameVolumeMedium    = "TRDG10";
+const TString PowerBusVolumeMedium = "TRDcopper";  // power bus bars
+const TString AluLegdeVolumeMedium =
+  "aluminium";  // aluminium frame around backpanel
+const TString AluminiumVolumeMedium = "aluminium";
+//const TString MylarVolumeMedium       = "mylar";
+//const TString RadiatorVolumeMedium    = "polypropylene";
+//const TString ElectronicsVolumeMedium = "goldcoatedcopper";
+
+
+// some global variables
+TGeoManager* gGeoMan = NULL;           // Pointer to TGeoManager instance
+TGeoVolume* gModules[NofModuleTypes];  // Global storage for module types
+
+// Forward declarations
+void create_materials_from_media_file();
+TGeoVolume* create_trd_module_type(Int_t moduleType);
+void create_detector_layers(Int_t layer);
+void create_power_bars_vertical();
+void create_power_bars_horizontal();
+void create_xtru_supports();
+void create_box_supports();
+void add_trd_labels(TGeoVolume*, TGeoVolume*, TGeoVolume*);
+void create_mag_field_vector();
+void dump_info_file();
+void dump_digi_file();
+
+
+//void Create_TRD_Geometry_v20a(const Int_t setupid = 1) {
+void Create_TRD_Geometry_v20a() {
+
+  // declare TRD layer layout
+  if (setupid > 2)
+    for (Int_t i = 0; i < MaxLayers; i++)
+      ShowLayer[i] = 1;  // show all layers
+
+  // Load needed material definition from media.geo file
+  create_materials_from_media_file();
+
+  // Position the layers in z
+  for (Int_t iLayer = 1; iLayer < MaxLayers; iLayer++)
+    LayerPosition[iLayer] = LayerPosition[iLayer - 1] + LayerThickness
+                            + LayerOffset[iLayer];  // add offset for extra gaps
+
+  // Get the GeoManager for later usage
+  gGeoMan = (TGeoManager*) gROOT->FindObject("FAIRGeom");
+  gGeoMan->SetVisLevel(10);
+
+  // Create the top volume
+  TGeoBBox* topbox = new TGeoBBox("", 1000., 1000., 2000.);
+  TGeoVolume* top  = new TGeoVolume("top", topbox, gGeoMan->GetMedium("air"));
+  gGeoMan->SetTopVolume(top);
+
+  TGeoVolume* trd = new TGeoVolumeAssembly(geoVersion);
+  top->AddNode(trd, 1);
+
+  for (Int_t iModule = 0; iModule < NofModuleTypes; iModule++) {
+    Int_t moduleType  = iModule + 1;
+    gModules[iModule] = create_trd_module_type(moduleType);
+  }
+
+  Int_t nLayer = 0;  // active layer counter
+  for (Int_t iLayer = 0; iLayer < MaxLayers; iLayer++) {
+    //    if ((iLayer != 0) && (iLayer != 3))  continue;  // first layer only - comment later on
+    //    if (iLayer != 0) continue;  // first layer only - comment later on
+    if (ShowLayer[iLayer]) {
+      PlaneId[iLayer] = ++nLayer;
+      create_detector_layers(iLayer);
+      //      printf("calling layer %2d\n",iLayer);
+    }
+  }
+
+  // TODO: remove or comment out
+  // test PlaneId
+  printf("generated TRD layers: ");
+  for (Int_t iLayer = 0; iLayer < MaxLayers; iLayer++)
+    if (ShowLayer[iLayer]) printf(" %2d", PlaneId[iLayer]);
+  printf("\n");
+
+  if (IncludeSupports) { create_box_supports(); }
+
+  if (IncludePowerbars) {
+    create_power_bars_vertical();
+    create_power_bars_horizontal();
+  }
+
+  if (IncludeFieldVector) create_mag_field_vector();
+
+  gGeoMan->CloseGeometry();
+  //  gGeoMan->CheckOverlaps(0.001);
+  //  gGeoMan->PrintOverlaps();
+  gGeoMan->Test();
+
+  trd->Export(FileNameSim);  // an alternative way of writing the trd volume
+
+  TFile* outfile = new TFile(FileNameSim, "UPDATE");
+  //  TGeoTranslation* trd_placement = new TGeoTranslation("trd_trans", 0., 0., 0.);
+  TGeoTranslation* trd_placement =
+    new TGeoTranslation("trd_trans", 0., 0., zfront[setupid]);
+  trd_placement->Write();
+  outfile->Close();
+
+  outfile = new TFile(FileNameGeo, "RECREATE");
+  gGeoMan->Write();  // use this is you want GeoManager format in the output
+  outfile->Close();
+
+  dump_info_file();
+  dump_digi_file();
+
+  top->Draw("ogl");
+
+  //top->Raytrace();
+
+  //  cout << "Press Return to exit" << endl;
+  //  cin.get();
+  //  exit();
+}
+
+
+//==============================================================
+void dump_digi_file() {
+  TDatime datetime;  // used to get timestamp
+
+  const Double_t ActiveAreaX[2] = {DetectorSizeX[0] - 2 * FrameWidth[0],
+                                   DetectorSizeX[1] - 2 * FrameWidth[1]};
+  const Int_t NofSectors        = 3;
+  // v17b
+  //  const Int_t NofPadsInRow[2]  = { 80, 112 };  //  7 // number of pads in rows
+  //  const Int_t NofPadsInRow[2]  = { 80, 128 };  //  8 // number of pads in rows
+  const Int_t NofPadsInRow[2] = {80, 144};  //  9 // number of pads in rows
+  //  const Int_t NofPadsInRow[2]  = { 80, 160 };  // 10 // number of pads in rows
+  Int_t nrow = 0;  // number of rows in module
+
+  const Double_t PadHeightInSector[NofModuleTypes][NofSectors] =  // pad height
+    {//v17b {  1.25,  1.50,  1.25 },   // module type 1 -  1.01 cm2
+     //v17b {  2.25,  2.25,  2.25 },   // module type 2 -  1.52 cm2
+     //v17b {  3.25,  3.50,  3.25 },   // module type 3 -  2.36 cm2
+
+     {1.50, 1.75, 1.50},  // module type 1 -  1.18 cm2
+     {3.25, 3.50, 3.25},  // module type 2 -  2.36 cm2
+     {6.75, 6.75, 6.75},  // module type 3 -  4.56 cm2
+     {6.75, 6.75, 6.75},  // module type 4 -
+
+     // 108 cm          {  2.25,  2.25,  2.25 },   // module type 5 -
+     // 108 cm          {  4.50,  4.50,  4.50 },   // module type 6 -  4.52 cm2
+     // 108 cm          {  9.00,  9.00,  9.00 },   // module type 7 -  6.37 cm2
+     // 108 cm          { 18.00, 18.00, 18.00 } }; // module type 8 - 12.73 cm2
+
+     {4.00, 4.00, 4.00},      // module type 5 -  2.67 cm2
+     {6.00, 6.00, 6.00},      // module type 6 -  4.00 cm2
+     {12.00, 12.00, 12.00},   // module type 7 -  8.00 cm2
+     {24.00, 24.00, 24.00}};  // module type 8 - 16.00 cm2
+
+  //          {  3.75,  4.00,  3.75 },   // module type 5 -
+  //          {  5.00,  5.50,  5.00 },   // module type 6 -  4.52 cm2
+  //          {  7.50,  7.75,  7.50 },   // module type 7 -  6.37 cm2
+  //          { 15.25, 15.50, 15.25 } }; // module type 8 - 12.73 cm2
+
+  const Int_t NofRowsInSector[NofModuleTypes][NofSectors] =
+    // number of rows per sector
+    {//v17b {  12,  16,  12 },         // module type 1
+     //v17b {   8,   8,   8 },         // module type 2
+     //v17b {   4,   8,   4 },         // module type 3
+
+     {4, 24, 4},  // module type 1
+     {4, 8, 4},   // module type 2
+     {2, 4, 2},   // module type 3
+     {2, 4, 2},   // module type 4
+
+     {8, 8, 8},   // module type 5
+     {6, 4, 6},   // module type 6
+     {2, 4, 2},   // module type 7
+     {1, 2, 1}};  // module type 8
+
+  //          {   8,   8,   8 },         // module type 5
+  //          {   4,   8,   4 },         // module type 6
+  //          {   2,   8,   2 },         // module type 7
+  //          {   2,   2,   2 } };       // module type 8
+
+  // v17a   const Int_t NofPadsInRow[2]  = { 80, 128 };  // number of pads in rows
+  // v17a   Int_t nrow = 0;   // number of rows in module
+  // v17a
+  // v17a   const Double_t PadHeightInSector[NofModuleTypes][NofSectors] =  // pad height
+  // v17a         { {  1.50,  1.50,  1.50 },   // module type 1 -  1.01 cm2
+  // v17a           {  2.25,  2.25,  2.25 },   // module type 2 -  1.52 cm2
+  // v17a //          {  2.75,  2.50,  2.75 },   // module type 2 -  1.86 cm2
+  // v17a           {  4.50,  4.50,  4.50 },   // module type 3 -  3.04 cm2
+  // v17a           {  6.75,  6.75,  6.75 },   // module type 4 -  4.56 cm2
+  // v17a
+  // v17a           {  3.75,  4.00,  3.75 },   // module type 5 -  2.84 cm2
+  // v17a           {  5.75,  5.75,  5.75 },   // module type 6 -  4.13 cm2
+  // v17a           { 11.50, 11.50, 11.50 },   // module type 7 -  8.26 cm2
+  // v17a           { 15.25, 15.50, 15.25 } }; // module type 8 - 11.14 cm2
+  // v17a //          {  7.50,  7.75,  7.50 },   // module type 6 -  5.51 cm2
+  // v17a //          {  5.50,  5.75,  5.50 },   // module type 6 -  4.09 cm2
+  // v17a //          { 11.25, 11.50, 11.25 },   // module type 7 -  8.18 cm2
+  // v17a
+  // v17a   const Int_t NofRowsInSector[NofModuleTypes][NofSectors] =   // number of rows per sector
+  // v17a         { {  12,  12,  12 },         // module type 1
+  // v17a           {   8,   8,   8 },         // module type 2
+  // v17a //          {   8,   4,   8 },         // module type 2
+  // v17a           {   4,   4,   4 },         // module type 3
+  // v17a           {   2,   4,   2 },         // module type 4
+  // v17a
+  // v17a           {   8,   8,   8 },         // module type 5
+  // v17a           {   4,   8,   4 },         // module type 6
+  // v17a           {   2,   4,   2 },         // module type 7
+  // v17a           {   2,   2,   2 } };       // module type 8
+  // v17a //          {  10,   4,  10 },         // module type 5
+  // v17a //          {   4,   4,   4 },         // module type 6
+  // v17a //          {   2,  12,   2 },         // module type 6
+  // v17a //          {   2,   4,   2 },         // module type 7
+  // v17a //          {   2,   2,   2 } };       // module type 8
+  // v17a
+
+  Double_t HeightOfSector[NofModuleTypes][NofSectors];
+  Double_t PadWidth[NofModuleTypes];
+
+  // calculate pad width
+  for (Int_t im = 0; im < NofModuleTypes; im++)
+    PadWidth[im] = ActiveAreaX[ModuleType[im]] / NofPadsInRow[ModuleType[im]];
+
+  // calculate height of sectors
+  for (Int_t im = 0; im < NofModuleTypes; im++)
+    for (Int_t is = 0; is < NofSectors; is++)
+      HeightOfSector[im][is] =
+        NofRowsInSector[im][is] * PadHeightInSector[im][is];
+
+  // check, if the entire module size is covered by pads
+  for (Int_t im = 0; im < NofModuleTypes; im++)
+    if (ActiveAreaX[ModuleType[im]]
+          - (HeightOfSector[im][0] + HeightOfSector[im][1]
+             + HeightOfSector[im][2])
+        != 0) {
+      printf("WARNING: sector size does not add up to module size for module "
+             "type %d\n",
+             im + 1);
+      printf("%.2f = %.2f + %.2f + %.2f\n",
+             ActiveAreaX[ModuleType[im]],
+             HeightOfSector[im][0],
+             HeightOfSector[im][1],
+             HeightOfSector[im][2]);
+      exit(1);
+    }
+
+  //==============================================================
+
+  printf("writing trd pad information file: %s\n", FileNamePads.Data());
+
+  FILE* ifile;
+  ifile = fopen(FileNamePads.Data(), "w");
+
+  if (ifile == NULL) {
+    printf("error opening %s\n", FileNamePads.Data());
+    exit(1);
+  }
+
+  fprintf(ifile, "//\n");
+  fprintf(ifile, "//   TRD pad layout for geometry %s\n", tagVersion.Data());
+  fprintf(ifile, "//\n");
+  fprintf(ifile,
+          "// automatically generated by Create_TRD_Geometry_%s%s.C\n",
+          tagVersion.Data(),
+          subVersion.Data());
+  fprintf(ifile, "// created %d\n", datetime.GetDate());
+  fprintf(ifile, "//\n");
+
+  fprintf(ifile, "\n");
+  fprintf(ifile, "#ifndef CBMTRDPADS_H\n");
+  fprintf(ifile, "#define CBMTRDPADS_H\n");
+  fprintf(ifile, "\n");
+  fprintf(ifile, "Int_t fst1_sect_count = 3;\n");
+  fprintf(ifile, "// array of pad geometries in the TRD (trd1mod[1-8])\n");
+  fprintf(ifile, "// 8 modules  // 3 sectors  // 4 values \n");
+  fprintf(ifile, "Float_t fst1_pad_type[8][3][4] =        \n");
+  //fprintf(ifile,"Double_t fst1_pad_type[8][3][4] =       \n");
+  fprintf(ifile, "			 		 \n");
+
+  for (Int_t im = 0; im < NofModuleTypes; im++) {
+    if (im + 1 == 5) fprintf(ifile, "//---\n\n");
+    fprintf(ifile, "// module type %d\n", im + 1);
+
+    // number of pads
+    nrow = 0;  // reset number of pad rows to 0
+    for (Int_t is = 0; is < NofSectors; is++)
+      nrow += HeightOfSector[im][is]
+              / PadHeightInSector[im][is];  // add number of rows in this sector
+    fprintf(ifile,
+            "// number of pads: %3d x %2d = %4d\n",
+            NofPadsInRow[ModuleType[im]],
+            nrow,
+            NofPadsInRow[ModuleType[im]] * nrow);
+
+    // pad size
+    fprintf(ifile,
+            "// pad size sector 1: %5.2f cm x %5.2f cm = %5.2f cm2\n",
+            PadWidth[im],
+            PadHeightInSector[im][1],
+            PadWidth[im] * PadHeightInSector[im][1]);
+    fprintf(ifile,
+            "// pad size sector 0: %5.2f cm x %5.2f cm = %5.2f cm2\n",
+            PadWidth[im],
+            PadHeightInSector[im][0],
+            PadWidth[im] * PadHeightInSector[im][0]);
+
+    for (Int_t is = 0; is < NofSectors; is++) {
+      if ((im == 0) && (is == 0))
+        fprintf(ifile, "  { { ");
+      else if (is == 0)
+        fprintf(ifile, "    { ");
+      else
+        fprintf(ifile, "      ");
+
+      fprintf(ifile,
+              "{ %.1f, %5.2f, %.1f/%3d, %5.2f }",
+              ActiveAreaX[ModuleType[im]],
+              HeightOfSector[im][is],
+              ActiveAreaX[ModuleType[im]],
+              NofPadsInRow[ModuleType[im]],
+              PadHeightInSector[im][is]);
+
+      if ((im == NofModuleTypes - 1) && (is == 2))
+        fprintf(ifile, " } };");
+      else if (is == 2)
+        fprintf(ifile, " },");
+      else
+        fprintf(ifile, ",");
+
+      fprintf(ifile, "\n");
+    }
+
+    fprintf(ifile, "\n");
+  }
+
+  fprintf(ifile, "#endif\n");
+
+  //  Int_t im = 0;
+  //  fprintf(ifile,"// module type %d	 		   \n", im+1);
+  //  fprintf(ifile,"  { { { %.1f, %5.2f, %.1f/%3d, %5.2f },    \n", ActiveAreaX[ModuleType[im]], HeightOfSector[im][0], ActiveAreaX[ModuleType[im]], NofPadsInRow[ModuleType[im]], PadHeightInSector[im][0]);
+  //  fprintf(ifile,"      { %.1f, %5.2f, %.1f/%3d, %5.2f },    \n", ActiveAreaX[ModuleType[im]], HeightOfSector[im][1], ActiveAreaX[ModuleType[im]], NofPadsInRow[ModuleType[im]], PadHeightInSector[im][1]);
+  //  fprintf(ifile,"      { %.1f, %5.2f, %.1f/%3d, %5.2f } },  \n", ActiveAreaX[ModuleType[im]], HeightOfSector[im][2], ActiveAreaX[ModuleType[im]], NofPadsInRow[ModuleType[im]], PadHeightInSector[im][2]);
+  //  fprintf(ifile,"\n");
+  //
+  //  for (Int_t im = 1; im < NofModuleTypes-1; im++)
+  //  {
+  //    fprintf(ifile,"// module type %d	 		     \n", im+1);
+  //    fprintf(ifile,"    { { %.1f, %5.2f, %.1f/%3d, %5.2f },    \n", ActiveAreaX[ModuleType[im]], HeightOfSector[im][0], ActiveAreaX[ModuleType[im]], NofPadsInRow[ModuleType[im]], PadHeightInSector[im][0]);
+  //    fprintf(ifile,"      { %.1f, %5.2f, %.1f/%3d, %5.2f },    \n", ActiveAreaX[ModuleType[im]], HeightOfSector[im][1], ActiveAreaX[ModuleType[im]], NofPadsInRow[ModuleType[im]], PadHeightInSector[im][1]);
+  //    fprintf(ifile,"      { %.1f, %5.2f, %.1f/%3d, %5.2f } },  \n", ActiveAreaX[ModuleType[im]], HeightOfSector[im][2], ActiveAreaX[ModuleType[im]], NofPadsInRow[ModuleType[im]], PadHeightInSector[im][2]);
+  //    fprintf(ifile,"\n");
+  //  }
+  //
+  //  Int_t im = 7;
+  //  fprintf(ifile,"// module type %d	 		   \n", im+1);
+  //  fprintf(ifile,"    { { %.1f, %5.2f, %.1f/%3d, %5.2f },    \n", ActiveAreaX[ModuleType[im]], HeightOfSector[im][0], ActiveAreaX[ModuleType[im]], NofPadsInRow[ModuleType[im]], PadHeightInSector[im][0]);
+  //  fprintf(ifile,"      { %.1f, %5.2f, %.1f/%3d, %5.2f },    \n", ActiveAreaX[ModuleType[im]], HeightOfSector[im][1], ActiveAreaX[ModuleType[im]], NofPadsInRow[ModuleType[im]], PadHeightInSector[im][1]);
+  //  fprintf(ifile,"      { %.1f, %5.2f, %.1f/%3d, %5.2f } } };\n", ActiveAreaX[ModuleType[im]], HeightOfSector[im][2], ActiveAreaX[ModuleType[im]], NofPadsInRow[ModuleType[im]], PadHeightInSector[im][2]);
+  //  fprintf(ifile,"\n");
+
+  fclose(ifile);
+}
+
+
+void dump_info_file() {
+  TDatime datetime;  // used to get timestamp
+
+  Double_t z_first_layer = 2000;  // z position of first layer (front)
+  Double_t z_last_layer  = 0;     // z position of last  layer (front)
+
+  Double_t xangle;   // horizontal angle
+  Double_t yangle;   // vertical   angle for inner modules
+  Double_t yangleo;  // vertical   angle for outer modules
+
+  Double_t total_surface = 0;  // total surface
+  Double_t total_actarea = 0;  // total active area
+
+  Int_t channels_per_module[NofModuleTypes + 1] = {
+    0};  // number of channels per module
+  Int_t channels_per_feb[NofModuleTypes + 1] = {
+    0};  // number of channels per feb
+  Int_t asics_per_module[NofModuleTypes + 1] = {
+    0};  // number of asics per module
+
+  Int_t total_modules[NofModuleTypes + 1]  = {0};  // total number of modules
+  Int_t total_febs[NofModuleTypes + 1]     = {0};  // total number of febs
+  Int_t total_asics[NofModuleTypes + 1]    = {0};  // total number of asics
+  Int_t total_gbtx[NofModuleTypes + 1]     = {0};  // total number of gbtx
+  Int_t total_rob3[NofModuleTypes + 1]     = {0};  // total number of gbtx rob3
+  Int_t total_rob5[NofModuleTypes + 1]     = {0};  // total number of gbtx rob5
+  Int_t total_rob7[NofModuleTypes + 1]     = {0};  // total number of gbtx rob7
+  Int_t total_channels[NofModuleTypes + 1] = {0};  // total number of channels
+
+  Int_t total_channels_u = 0;  // total number of ultimate channels
+  Int_t total_channels_s = 0;  // total number of super    channels
+  Int_t total_channels_r = 0;  // total number of regular  channels
+
+  printf("writing summary information file: %s\n", FileNameInfo.Data());
+
+  FILE* ifile;
+  ifile = fopen(FileNameInfo.Data(), "w");
+
+  if (ifile == NULL) {
+    printf("error opening %s\n", FileNameInfo.Data());
+    exit(1);
+  }
+
+  fprintf(ifile, "#\n##   %s information file\n#\n\n", geoVersion.Data());
+
+  fprintf(ifile, "# created %d\n\n", datetime.GetDate());
+
+  // determine first and last TRD layer
+  for (Int_t iLayer = 0; iLayer < MaxLayers; iLayer++) {
+    if (ShowLayer[iLayer]) {
+      if (z_first_layer > LayerPosition[iLayer])
+        z_first_layer = LayerPosition[iLayer];
+      if (z_last_layer < LayerPosition[iLayer])
+        z_last_layer = LayerPosition[iLayer];
+    }
+  }
+
+  fprintf(ifile, "# position\n");
+  // Show position of TRD
+  fprintf(
+    ifile, "%4f cm z-front position of TRD in hadron   setup\n", zfront[0]);
+  fprintf(
+    ifile, "%4f cm z-front position of TRD in electron setup\n", zfront[1]);
+  fprintf(
+    ifile, "%4f cm z-front position of TRD in muon     setup\n", zfront[2]);
+  fprintf(ifile, "\n");
+
+  //  fprintf(ifile, "# envelope\n");
+  fprintf(ifile, "# detector thickness\n");
+  // Show extension of TRD
+  //  fprintf(ifile, "%4f cm   start of TRD (z)\n", z_first_layer);
+  fprintf(ifile, "%4f cm   end   of TRD (z)\n", z_last_layer + LayerThickness);
+  fprintf(ifile, "\n");
+
+  // Layer thickness
+  fprintf(ifile, "# layer thickness\n");
+  fprintf(ifile, "%4f cm   per single layer (z)\n", LayerThickness);
+  fprintf(ifile, "\n");
+
+  // Show extra gaps
+  fprintf(ifile, "# extra gaps\n ");
+  for (Int_t iLayer = 0; iLayer < MaxLayers; iLayer++)
+    if (ShowLayer[iLayer]) fprintf(ifile, "%3f ", LayerOffset[iLayer]);
+  fprintf(ifile, "   extra gaps in z (cm)\n");
+  fprintf(ifile, "\n");
+
+  // Show layer flags
+  fprintf(ifile, "# generated TRD layers\n ");
+  for (Int_t iLayer = 0; iLayer < MaxLayers; iLayer++)
+    if (ShowLayer[iLayer]) fprintf(ifile, "%2d ", PlaneId[iLayer]);
+  fprintf(ifile, "   planeID\n");
+  fprintf(ifile, "\n");
+
+  // Dimensions in x
+  fprintf(ifile, "# dimensions in x\n");
+  for (Int_t iLayer = 0; iLayer < MaxLayers; iLayer++)
+    if (ShowLayer[iLayer]) {
+      if (PlaneId[iLayer] < 5)
+        fprintf(ifile,
+                "%5f cm to %5f cm x-dimension of layer %2d\n",
+                -(2.0 * DetectorSizeX[0] + 2.0 * DetectorSizeX[1]),
+                2.0 * DetectorSizeX[0] + 2.0 * DetectorSizeX[1],
+                PlaneId[iLayer]);
+      else {
+        if (PlaneId[iLayer] < 9)
+          fprintf(ifile,
+                  "%5f cm to %5f cm x-dimension of layer %2d\n",
+                  -4.5 * DetectorSizeX[1],
+                  4.5 * DetectorSizeX[1],
+                  PlaneId[iLayer]);
+        else
+          fprintf(ifile,
+                  "%5f cm to %5f cm x-dimension of layer %2d\n",
+                  -5.5 * DetectorSizeX[1],
+                  5.5 * DetectorSizeX[1],
+                  PlaneId[iLayer]);
+      }
+    }
+  fprintf(ifile, "\n");
+
+  // Dimensions in y
+  fprintf(ifile, "# dimensions in y inner modules\n");
+  for (Int_t iLayer = 0; iLayer < MaxLayers; iLayer++)
+    if (ShowLayer[iLayer]) {
+      if (PlaneId[iLayer] < 5)
+        fprintf(ifile,
+                "%5f cm to %5f cm y-dimension of layer %2d\n",
+                -4.5 * DetectorSizeY[0],
+                4.5 * DetectorSizeY[0],
+                PlaneId[iLayer]);
+      else {
+        if (PlaneId[iLayer] < 9)
+          fprintf(ifile,
+                  "%5f cm to %5f cm y-dimension of layer %2d\n",
+                  -3.5 * DetectorSizeY[1],
+                  3.5 * DetectorSizeY[1],
+                  PlaneId[iLayer]);
+        else
+          fprintf(ifile,
+                  "%5f cm to %5f cm y-dimension of layer %2d\n",
+                  -4.5 * DetectorSizeY[1],
+                  4.5 * DetectorSizeY[1],
+                  PlaneId[iLayer]);
+      }
+    }
+  fprintf(ifile, "\n");
+
+  // Dimensions in y
+  fprintf(ifile, "# dimensions in y outer modules\n");
+  for (Int_t iLayer = 0; iLayer < MaxLayers; iLayer++)
+    if (ShowLayer[iLayer]) {
+      if (PlaneId[iLayer] < 5)
+        fprintf(ifile,
+                "%5f cm to %5f cm y-dimension of layer %2d\n",
+                -2.5 * DetectorSizeY[1],
+                2.5 * DetectorSizeY[1],
+                PlaneId[iLayer]);
+    }
+  fprintf(ifile, "\n");
+
+  // angles
+  fprintf(ifile, "# angles of acceptance for inner + outer modules\n");
+
+  for (Int_t iLayer = 0; iLayer < MaxLayers; iLayer++)
+    if (ShowLayer[iLayer]) {
+      if (iLayer < 4) {
+        //        fprintf(ifile,"y %10.4f cm   x %10.4f cm\n", 2.5 * DetectorSizeY[1], 3.5 * DetectorSizeX[1]);
+        yangle = atan(4.5 * DetectorSizeY[0]
+                      / (zfront[setupid] + LayerPosition[iLayer]
+                         + LayerThickness / 2. + padplane_position))
+                 * 180. / acos(-1.);
+        yangleo = atan(2.5 * DetectorSizeY[1]
+                       / (zfront[setupid] + LayerPosition[iLayer]
+                          + LayerThickness / 2. + padplane_position))
+                  * 180. / acos(-1.);
+        xangle = atan((2.0 * DetectorSizeX[0] + 2.0 * DetectorSizeX[1])
+                      / (zfront[setupid] + LayerPosition[iLayer]
+                         + LayerThickness / 2. + padplane_position))
+                 * 180. / acos(-1.);
+      }
+      if ((iLayer >= 4) && (iLayer < 8)) {
+        //        fprintf(ifile,"y %10.4f cm   x %10.4f cm\n", 3.5 * DetectorSizeY[1], 4.5 * DetectorSizeX[1]);
+        yangle = atan(3.5 * DetectorSizeY[1]
+                      / (LayerPosition[iLayer] + LayerThickness / 2.
+                         + padplane_position))
+                 * 180. / acos(-1.);
+        xangle = atan(4.5 * DetectorSizeX[1]
+                      / (LayerPosition[iLayer] + LayerThickness / 2.
+                         + padplane_position))
+                 * 180. / acos(-1.);
+      }
+      if ((iLayer >= 8) && (iLayer < 10)) {
+        //        fprintf(ifile,"y %10.4f cm   x %10.4f cm\n", 4.5 * DetectorSizeY[1], 5.5 * DetectorSizeX[1]);
+        yangle = atan(4.5 * DetectorSizeY[1]
+                      / (LayerPosition[iLayer] + LayerThickness / 2.
+                         + padplane_position))
+                 * 180. / acos(-1.);
+        xangle = atan(5.5 * DetectorSizeX[1]
+                      / (LayerPosition[iLayer] + LayerThickness / 2.
+                         + padplane_position))
+                 * 180. / acos(-1.);
+      }
+      fprintf(ifile,
+              "vi: %5.2f deg, vo: %5.2f deg, h: %5.2f deg - "
+              "vertical/horizontal - layer %2d\n",
+              yangle,
+              yangleo,
+              xangle,
+              PlaneId[iLayer]);
+    }
+  fprintf(ifile, "\n");
+
+  // aperture
+  fprintf(ifile, "# inner aperture\n");
+
+  for (Int_t iLayer = 0; iLayer < MaxLayers; iLayer++)
+    if (ShowLayer[iLayer]) {
+      if (iLayer < 4) {
+        //        fprintf(ifile,"y %10.4f cm   x %10.4f cm\n", 2.5 * DetectorSizeY[1], 3.5 * DetectorSizeX[1]);
+        yangle = atan(0.5 * DetectorSizeY[0]
+                      / (zfront[setupid] + LayerPosition[iLayer]
+                         + LayerThickness / 2. + padplane_position))
+                 * 180. / acos(-1.);
+        xangle = atan(1.0 * DetectorSizeX[0]
+                      / (zfront[setupid] + LayerPosition[iLayer]
+                         + LayerThickness / 2. + padplane_position))
+                 * 180. / acos(-1.);
+      }
+      if ((iLayer >= 4) && (iLayer < 8)) {
+        //        fprintf(ifile,"y %10.4f cm   x %10.4f cm\n", 3.5 * DetectorSizeY[1], 4.5 * DetectorSizeX[1]);
+        yangle = atan(0.5 * DetectorSizeY[0]
+                      / (zfront[setupid] + LayerPosition[iLayer]
+                         + LayerThickness / 2. + padplane_position))
+                 * 180. / acos(-1.);
+        xangle = atan(0.5 * DetectorSizeX[0]
+                      / (zfront[setupid] + LayerPosition[iLayer]
+                         + LayerThickness / 2. + padplane_position))
+                 * 180. / acos(-1.);
+      }
+      if ((iLayer >= 8) && (iLayer < 10)) {
+        //        fprintf(ifile,"y %10.4f cm   x %10.4f cm\n", 4.5 * DetectorSizeY[1], 5.5 * DetectorSizeX[1]);
+        yangle = atan(0.5 * DetectorSizeY[0]
+                      / (zfront[setupid] + LayerPosition[iLayer]
+                         + LayerThickness / 2. + padplane_position))
+                 * 180. / acos(-1.);
+        xangle = atan(0.5 * DetectorSizeX[0]
+                      / (zfront[setupid] + LayerPosition[iLayer]
+                         + LayerThickness / 2. + padplane_position))
+                 * 180. / acos(-1.);
+      }
+      fprintf(ifile,
+              "v: %5.2f deg, h: %5.2f deg - vertical/horizontal - layer %2d\n",
+              yangle,
+              xangle,
+              PlaneId[iLayer]);
+    }
+  fprintf(ifile, "\n");
+
+  // Show layer positions
+  fprintf(ifile, "# z-positions of layer front\n");
+  for (Int_t iLayer = 0; iLayer < MaxLayers; iLayer++) {
+    if (ShowLayer[iLayer])
+      fprintf(ifile,
+              "%7.2f cm   z-position of layer %2d\n",
+              LayerPosition[iLayer],
+              PlaneId[iLayer]);
+  }
+  fprintf(ifile, "\n");
+
+  // flags
+  fprintf(ifile, "# flags\n");
+
+  fprintf(ifile, "support structure is    : ");
+  if (!IncludeSupports) fprintf(ifile, "NOT ");
+  fprintf(ifile, "included\n");
+
+  fprintf(ifile, "radiator is             : ");
+  if (!IncludeRadiator) fprintf(ifile, "NOT ");
+  fprintf(ifile, "included\n");
+
+  fprintf(ifile, "lattice grid is         : ");
+  if (!IncludeLattice) fprintf(ifile, "NOT ");
+  fprintf(ifile, "included\n");
+
+  fprintf(ifile, "kapton window is        : ");
+  if (!IncludeKaptonFoil) fprintf(ifile, "NOT ");
+  fprintf(ifile, "included\n");
+
+  fprintf(ifile, "gas frame is            : ");
+  if (!IncludeGasFrame) fprintf(ifile, "NOT ");
+  fprintf(ifile, "included\n");
+
+  fprintf(ifile, "padplane is             : ");
+  if (!IncludePadplane) fprintf(ifile, "NOT ");
+  fprintf(ifile, "included\n");
+
+  fprintf(ifile, "backpanel is            : ");
+  if (!IncludeBackpanel) fprintf(ifile, "NOT ");
+  fprintf(ifile, "included\n");
+
+  fprintf(ifile, "Aluminium ledge is      : ");
+  if (!IncludeAluLedge) fprintf(ifile, "NOT ");
+  fprintf(ifile, "included\n");
+
+  fprintf(ifile, "Power bus bars are      : ");
+  if (!IncludePowerbars) fprintf(ifile, "NOT ");
+  fprintf(ifile, "included\n");
+
+  fprintf(ifile, "asics are               : ");
+  if (!IncludeAsics) fprintf(ifile, "NOT ");
+  fprintf(ifile, "included\n");
+
+  fprintf(ifile, "front-end boards are    : ");
+  if (!IncludeFebs) fprintf(ifile, "NOT ");
+  fprintf(ifile, "included\n");
+
+  fprintf(ifile, "GBTX readout boards are : ");
+  if (!IncludeRobs) fprintf(ifile, "NOT ");
+  fprintf(ifile, "included\n");
+
+  fprintf(ifile, "\n");
+
+
+  // module statistics
+  //  fprintf(ifile,"#\n##   modules\n#\n\n");
+  //  fprintf(ifile,"number of modules per type and layer:\n");
+  fprintf(ifile, "# modules\n");
+
+  for (Int_t iModule = 1; iModule <= NofModuleTypes; iModule++)
+    fprintf(ifile, "     mod%1d", iModule);
+  fprintf(ifile, "    total");
+
+  fprintf(ifile,
+          "\n------------------------------------------------------------------"
+          "---------------\n");
+  for (Int_t iLayer = 0; iLayer < MaxLayers; iLayer++)
+    if (ShowLayer[iLayer]) {
+      for (Int_t iModule = 0; iModule < NofModuleTypes; iModule++) {
+        fprintf(ifile, " %8d", ModuleStats[iLayer][iModule]);
+        total_modules[iModule] +=
+          ModuleStats[iLayer][iModule];  // sum up modules across layers
+      }
+      fprintf(ifile, "            layer %2d\n", PlaneId[iLayer]);
+    }
+  fprintf(ifile,
+          "\n------------------------------------------------------------------"
+          "---------------\n");
+
+  // total statistics
+  for (Int_t iModule = 0; iModule < NofModuleTypes; iModule++) {
+    fprintf(ifile, " %8d", total_modules[iModule]);
+    total_modules[NofModuleTypes] += total_modules[iModule];
+  }
+  fprintf(ifile, " %8d", total_modules[NofModuleTypes]);
+  fprintf(ifile, "   number of modules\n");
+
+  //------------------------------------------------------------------------------
+
+  // number of FEBs
+  //  fprintf(ifile,"\n#\n##   febs\n#\n\n");
+  fprintf(ifile, "# febs\n");
+
+  fprintf(ifile, " ");
+  for (Int_t iModule = 0; iModule < NofModuleTypes; iModule++) {
+    if ((AsicsPerFeb[iModule] / 100) == 3)
+      fprintf(ifile, "%8du", FebsPerModule[iModule]);
+    else if ((AsicsPerFeb[iModule] / 100) == 2)
+      fprintf(ifile, "%8ds", FebsPerModule[iModule]);
+    else
+      fprintf(ifile, "%8d ", FebsPerModule[iModule]);
+  }
+  fprintf(ifile, "           FEBs per module\n");
+
+  // FEB total per type
+  total_febs[NofModuleTypes] = 0;  // reset sum to 0
+  fprintf(ifile, " ");
+  for (Int_t iModule = 0; iModule < NofModuleTypes; iModule++) {
+    if ((AsicsPerFeb[iModule] / 100) == 3) {
+      total_febs[iModule] = total_modules[iModule] * FebsPerModule[iModule];
+      fprintf(ifile, "%8du", total_febs[iModule]);
+      total_febs[NofModuleTypes] += total_febs[iModule];
+    } else
+      fprintf(ifile, "         ");
+  }
+  fprintf(ifile, "%8d", total_febs[NofModuleTypes]);
+  fprintf(ifile, "   ultimate  FEBs\n");
+
+  // FEB total per type
+  total_febs[NofModuleTypes] = 0;  // reset sum to 0
+  fprintf(ifile, " ");
+  for (Int_t iModule = 0; iModule < NofModuleTypes; iModule++) {
+    if ((AsicsPerFeb[iModule] / 100) == 2) {
+      total_febs[iModule] = total_modules[iModule] * FebsPerModule[iModule];
+      fprintf(ifile, "%8ds", total_febs[iModule]);
+      total_febs[NofModuleTypes] += total_febs[iModule];
+    } else
+      fprintf(ifile, "         ");
+  }
+  fprintf(ifile, "%8d", total_febs[NofModuleTypes]);
+  fprintf(ifile, "   super     FEBs\n");
+
+  // FEB total per type
+  total_febs[NofModuleTypes] = 0;  // reset sum to 0
+  fprintf(ifile, " ");
+  for (Int_t iModule = 0; iModule < NofModuleTypes; iModule++) {
+    if ((AsicsPerFeb[iModule] / 100) == 1) {
+      total_febs[iModule] = total_modules[iModule] * FebsPerModule[iModule];
+      fprintf(ifile, "%8d ", total_febs[iModule]);
+      total_febs[NofModuleTypes] += total_febs[iModule];
+    } else
+      fprintf(ifile, "         ");
+  }
+  fprintf(ifile, "%8d", total_febs[NofModuleTypes]);
+  fprintf(ifile, "   regular   FEBs\n");
+
+  // FEB total over all types
+  total_febs[NofModuleTypes] = 0;  // reset sum to 0
+  for (Int_t iModule = 0; iModule < NofModuleTypes; iModule++) {
+    total_febs[iModule] = total_modules[iModule] * FebsPerModule[iModule];
+    fprintf(ifile, " %8d", total_febs[iModule]);
+    total_febs[NofModuleTypes] += total_febs[iModule];
+  }
+  fprintf(ifile, " %8d", total_febs[NofModuleTypes]);
+  fprintf(ifile, "   number of FEBs\n");
+
+  //------------------------------------------------------------------------------
+
+  // number of ASICs
+  //  fprintf(ifile,"\n#\n##   asics\n#\n\n");
+  fprintf(ifile, "# asics\n");
+
+  for (Int_t iModule = 0; iModule < NofModuleTypes; iModule++) {
+    fprintf(ifile, " %8d", AsicsPerFeb[iModule] % 100);
+  }
+  fprintf(ifile, "            ASICs per FEB\n");
+
+  // ASICs per module
+  for (Int_t iModule = 0; iModule < NofModuleTypes; iModule++) {
+    asics_per_module[iModule] =
+      FebsPerModule[iModule] * (AsicsPerFeb[iModule] % 100);
+    fprintf(ifile, " %8d", asics_per_module[iModule]);
+  }
+  fprintf(ifile, "            ASICs per module\n");
+
+  // ASICs per module type
+  for (Int_t iModule = 0; iModule < NofModuleTypes; iModule++) {
+    total_asics[iModule] = total_febs[iModule] * (AsicsPerFeb[iModule] % 100);
+    fprintf(ifile, " %8d", total_asics[iModule]);
+    total_asics[NofModuleTypes] += total_asics[iModule];
+  }
+  fprintf(ifile, " %8d", total_asics[NofModuleTypes]);
+  fprintf(ifile, "   number of ASICs\n");
+
+  //------------------------------------------------------------------------------
+
+  // number of GBTXs
+  //  fprintf(ifile,"\n#\n##   asics\n#\n\n");
+  fprintf(ifile, "# gbtx\n");
+
+  for (Int_t iModule = 0; iModule < NofModuleTypes; iModule++) {
+    fprintf(ifile, " %8d", GbtxPerModule[iModule]);
+  }
+  fprintf(ifile, "            GBTXs per module\n");
+
+  // GBTXs per module type
+  for (Int_t iModule = 0; iModule < NofModuleTypes; iModule++) {
+    total_gbtx[iModule] = total_modules[iModule] * GbtxPerModule[iModule];
+    fprintf(ifile, " %8d", total_gbtx[iModule]);
+    total_gbtx[NofModuleTypes] += total_gbtx[iModule];
+  }
+  fprintf(ifile, " %8d", total_gbtx[NofModuleTypes]);
+  fprintf(ifile, "   number of GBTXs\n");
+
+  // GBTX ROB types per module type
+  for (Int_t iModule = 0; iModule < NofModuleTypes; iModule++) {
+    fprintf(ifile, " %8d", RobTypeOnModule[iModule]);
+  }
+  fprintf(ifile, "            GBTX ROB types on module\n");
+
+  for (Int_t iModule = 0; iModule < NofModuleTypes; iModule++) {
+    if ((RobTypeOnModule[iModule] % 10) == 7) total_rob7[iModule]++;
+    if ((RobTypeOnModule[iModule] / 10 % 10) == 7) total_rob7[iModule]++;
+    if ((RobTypeOnModule[iModule] / 100) == 7) total_rob7[iModule]++;
+
+    if ((RobTypeOnModule[iModule] % 10) == 5) total_rob5[iModule]++;
+    if ((RobTypeOnModule[iModule] / 10 % 10) == 5) total_rob5[iModule]++;
+    if ((RobTypeOnModule[iModule] / 100) == 5) total_rob5[iModule]++;
+
+    if ((RobTypeOnModule[iModule] % 10) == 3) total_rob3[iModule]++;
+    if ((RobTypeOnModule[iModule] / 10 % 10) == 3) total_rob3[iModule]++;
+    if ((RobTypeOnModule[iModule] / 100 % 10) == 3) total_rob3[iModule]++;
+    if ((RobTypeOnModule[iModule] / 1000 % 10) == 3) total_rob3[iModule]++;
+    if ((RobTypeOnModule[iModule] / 10000 % 10) == 3) total_rob3[iModule]++;
+    if ((RobTypeOnModule[iModule] / 100000 % 10) == 3) total_rob3[iModule]++;
+  }
+
+  for (Int_t iModule = 0; iModule < NofModuleTypes; iModule++) {
+    total_rob7[iModule] *= total_modules[iModule];
+    fprintf(ifile, " %8d", total_rob7[iModule]);
+    total_rob7[NofModuleTypes] += total_rob7[iModule];
+  }
+  fprintf(ifile, " %8d", total_rob7[NofModuleTypes]);
+  fprintf(ifile, "   number of GBTX ROB7\n");
+
+  for (Int_t iModule = 0; iModule < NofModuleTypes; iModule++) {
+    total_rob5[iModule] *= total_modules[iModule];
+    fprintf(ifile, " %8d", total_rob5[iModule]);
+    total_rob5[NofModuleTypes] += total_rob5[iModule];
+  }
+  fprintf(ifile, " %8d", total_rob5[NofModuleTypes]);
+  fprintf(ifile, "   number of GBTX ROB5\n");
+
+  for (Int_t iModule = 0; iModule < NofModuleTypes; iModule++) {
+    total_rob3[iModule] *= total_modules[iModule];
+    fprintf(ifile, " %8d", total_rob3[iModule]);
+    total_rob3[NofModuleTypes] += total_rob3[iModule];
+  }
+  fprintf(ifile, " %8d", total_rob3[NofModuleTypes]);
+  fprintf(ifile, "   number of GBTX ROB3\n");
+
+  //------------------------------------------------------------------------------
+  fprintf(ifile, "# e-links\n");
+
+  // e-links used
+  for (Int_t iModule = 0; iModule < NofModuleTypes; iModule++)
+    fprintf(ifile, " %8d", asics_per_module[iModule] * 2);
+  fprintf(ifile, " %8d", total_asics[NofModuleTypes] * 2);
+  fprintf(ifile, "   e-links used\n");
+
+  // e-links available
+  for (Int_t iModule = 0; iModule < NofModuleTypes; iModule++)
+    fprintf(ifile, " %8d", GbtxPerModule[iModule] * 14);
+  fprintf(ifile, " %8d", total_gbtx[NofModuleTypes] * 14);
+  fprintf(ifile, "   e-links available\n");
+
+  // e-link efficiency
+  for (Int_t iModule = 0; iModule < NofModuleTypes; iModule++) {
+    if (total_gbtx[iModule] != 0)
+      fprintf(ifile,
+              " %7.1f%%",
+              (float) total_asics[iModule] * 2 / (total_gbtx[iModule] * 14)
+                * 100);
+    else
+      fprintf(ifile, "        -");
+  }
+  if (total_gbtx[NofModuleTypes] != 0)
+    fprintf(ifile,
+            " %7.1f%%",
+            (float) total_asics[NofModuleTypes] * 2
+              / (total_gbtx[NofModuleTypes] * 14) * 100);
+  fprintf(ifile, "   e-link efficiency\n\n");
+
+  //------------------------------------------------------------------------------
+
+  // number of channels
+  fprintf(ifile, "# channels\n");
+
+  // channels per module
+  for (Int_t iModule = 0; iModule < NofModuleTypes; iModule++) {
+    if ((AsicsPerFeb[iModule] % 100) == 16) {
+      channels_per_feb[iModule] = 80 * 6;  // rows  // 84, if 63 of 64 ch used
+      channels_per_module[iModule] =
+        channels_per_feb[iModule] * FebsPerModule[iModule];
+    }
+    if ((AsicsPerFeb[iModule] % 100) == 15) {
+      channels_per_feb[iModule] = 80 * 6;  // rows
+      channels_per_module[iModule] =
+        channels_per_feb[iModule] * FebsPerModule[iModule];
+    }
+    if ((AsicsPerFeb[iModule] % 100) == 10) {
+      channels_per_feb[iModule] = 80 * 4;  // rows
+      channels_per_module[iModule] =
+        channels_per_feb[iModule] * FebsPerModule[iModule];
+    }
+    if ((AsicsPerFeb[iModule] % 100) == 5) {
+      channels_per_feb[iModule] = 80 * 2;  // rows
+      channels_per_module[iModule] =
+        channels_per_feb[iModule] * FebsPerModule[iModule];
+    }
+
+    if ((AsicsPerFeb[iModule] % 100) == 9) {
+      channels_per_feb[iModule] = 144 * 2;  // rows
+      channels_per_module[iModule] =
+        channels_per_feb[iModule] * FebsPerModule[iModule];
+    }
+    if ((AsicsPerFeb[iModule] % 100) == 8) {
+      channels_per_feb[iModule] = 128 * 2;  // rows
+      channels_per_module[iModule] =
+        channels_per_feb[iModule] * FebsPerModule[iModule];
+    }
+    if ((AsicsPerFeb[iModule] % 100) == 7) {
+      channels_per_feb[iModule] = 112 * 2;  // rows
+      channels_per_module[iModule] =
+        channels_per_feb[iModule] * FebsPerModule[iModule];
+    }
+  }
+
+  for (Int_t iModule = 0; iModule < NofModuleTypes; iModule++)
+    fprintf(ifile, " %8d", channels_per_module[iModule]);
+  fprintf(ifile, "            channels per module\n");
+
+  for (Int_t iModule = 0; iModule < NofModuleTypes; iModule++)
+    fprintf(ifile, " %8d", channels_per_feb[iModule]);
+  fprintf(ifile, "            channels per feb\n");
+
+  // channels used
+  for (Int_t iModule = 0; iModule < NofModuleTypes; iModule++) {
+    total_channels[iModule] =
+      channels_per_module[iModule] * total_modules[iModule];
+    fprintf(ifile, " %8d", total_channels[iModule]);
+    total_channels[NofModuleTypes] += total_channels[iModule];
+  }
+  fprintf(ifile, " %8d", total_channels[NofModuleTypes]);
+  fprintf(ifile, "   channels used\n");
+
+  // channels available
+  fprintf(ifile, " ");
+  for (Int_t iModule = 0; iModule < NofModuleTypes; iModule++) {
+    if ((AsicsPerFeb[iModule] / 100) == 3) {
+      fprintf(ifile, "%8du", total_asics[iModule] * 32);
+      total_channels_u += total_asics[iModule] * 32;
+    } else if ((AsicsPerFeb[iModule] / 100) == 2) {
+      fprintf(ifile, "%8ds", total_asics[iModule] * 32);
+      total_channels_s += total_asics[iModule] * 32;
+    } else {
+      fprintf(ifile, "%8d ", total_asics[iModule] * 32);
+      total_channels_r += total_asics[iModule] * 32;
+    }
+  }
+  fprintf(ifile, "%8d", total_asics[NofModuleTypes] * 32);
+  fprintf(ifile, "   channels available\n");
+
+  // channel ratio for u,s,r density
+  fprintf(ifile, " ");
+  fprintf(ifile,
+          "%7.1f%%u",
+          (float) total_channels_u / (total_asics[NofModuleTypes] * 32) * 100);
+  fprintf(ifile,
+          "%7.1f%%s",
+          (float) total_channels_s / (total_asics[NofModuleTypes] * 32) * 100);
+  fprintf(ifile,
+          "%7.1f%%r",
+          (float) total_channels_r / (total_asics[NofModuleTypes] * 32) * 100);
+  fprintf(
+    ifile,
+    "                                                        channel ratio\n");
+
+  fprintf(ifile, "\n");
+  fprintf(ifile,
+          "%8.1f%%   channel efficiency\n",
+          1. * total_channels[NofModuleTypes]
+            / (total_asics[NofModuleTypes] * 32) * 100);
+
+  //------------------------------------------------------------------------------
+
+  // total surface of TRD
+  for (Int_t iModule = 0; iModule < NofModuleTypes; iModule++)
+    if (iModule <= 3) {
+      total_surface += total_modules[iModule] * DetectorSizeX[0] / 100
+                       * DetectorSizeY[0] / 100;
+      total_actarea += total_modules[iModule]
+                       * (DetectorSizeX[0] - 2 * FrameWidth[0]) / 100
+                       * (DetectorSizeY[0] - 2 * FrameWidth[0]) / 100;
+    } else {
+      total_surface += total_modules[iModule] * DetectorSizeX[1] / 100
+                       * DetectorSizeY[1] / 100;
+      total_actarea += total_modules[iModule]
+                       * (DetectorSizeX[1] - 2 * FrameWidth[1]) / 100
+                       * (DetectorSizeY[1] - 2 * FrameWidth[1]) / 100;
+    }
+  fprintf(ifile, "\n");
+
+  // summary
+  fprintf(ifile, "%7.2f m2      total surface    \n", total_surface);
+  fprintf(ifile, "%7.2f m2      total active area\n", total_actarea);
+  fprintf(ifile,
+          "%7.2f m3      total gas volume \n",
+          total_actarea * gas_thickness
+            / 100);  // convert cm to m for thickness
+
+  fprintf(ifile,
+          "%7.2f cm2/ch  average channel size\n",
+          100. * 100 * total_actarea / total_channels[NofModuleTypes]);
+  fprintf(ifile,
+          "%7.2f ch/m2   channels per m2 active area\n",
+          1. * total_channels[NofModuleTypes] / total_actarea);
+  fprintf(ifile, "\n");
+
+  // gas volume position
+  fprintf(ifile, "# gas volume position\n");
+  for (Int_t iLayer = 0; iLayer < MaxLayers; iLayer++)
+    if (ShowLayer[iLayer])
+      fprintf(ifile,
+              "%10.4f cm   position of gas volume - layer %2d\n",
+              LayerPosition[iLayer] + LayerThickness / 2. + gas_position,
+              PlaneId[iLayer]);
+  fprintf(ifile, "\n");
+
+  fclose(ifile);
+}
+
+
+void create_materials_from_media_file() {
+  // Use the FairRoot geometry interface to load the media which are already defined
+  FairGeoLoader* geoLoad    = new FairGeoLoader("TGeo", "FairGeoLoader");
+  FairGeoInterface* geoFace = geoLoad->getGeoInterface();
+  TString geoPath           = gSystem->Getenv("VMCWORKDIR");
+  TString medFile           = geoPath + "/geometry/media.geo";
+  geoFace->setMediaFile(medFile);
+  geoFace->readMedia();
+
+  // Read the required media and create them in the GeoManager
+  FairGeoMedia* geoMedia   = geoFace->getMedia();
+  FairGeoBuilder* geoBuild = geoLoad->getGeoBuilder();
+
+  FairGeoMedium* air       = geoMedia->getMedium(KeepingVolumeMedium);
+  FairGeoMedium* pefoam20  = geoMedia->getMedium(RadiatorVolumeMedium);
+  FairGeoMedium* G10       = geoMedia->getMedium(LatticeVolumeMedium);
+  FairGeoMedium* kapton    = geoMedia->getMedium(KaptonVolumeMedium);
+  FairGeoMedium* trdGas    = geoMedia->getMedium(GasVolumeMedium);
+  FairGeoMedium* copper    = geoMedia->getMedium(PadCopperVolumeMedium);
+  FairGeoMedium* carbon    = geoMedia->getMedium(CarbonVolumeMedium);
+  FairGeoMedium* honeycomb = geoMedia->getMedium(HoneycombVolumeMedium);
+  FairGeoMedium* aluminium = geoMedia->getMedium(AluminiumVolumeMedium);
+
+  //  FairGeoMedium* goldCoatedCopper = geoMedia->getMedium("goldcoatedcopper");
+  //  FairGeoMedium* polypropylene    = geoMedia->getMedium("polypropylene");
+  //  FairGeoMedium* mylar            = geoMedia->getMedium("mylar");
+
+  geoBuild->createMedium(air);
+  geoBuild->createMedium(pefoam20);
+  geoBuild->createMedium(trdGas);
+  geoBuild->createMedium(honeycomb);
+  geoBuild->createMedium(carbon);
+  geoBuild->createMedium(G10);
+  geoBuild->createMedium(copper);
+  geoBuild->createMedium(kapton);
+  geoBuild->createMedium(aluminium);
+
+  //  geoBuild->createMedium(goldCoatedCopper);
+  //  geoBuild->createMedium(polypropylene);
+  //  geoBuild->createMedium(mylar);
+}
+
+TGeoVolume* create_trd_module_type(Int_t moduleType) {
+  Int_t type           = ModuleType[moduleType - 1];
+  Double_t sizeX       = DetectorSizeX[type];
+  Double_t sizeY       = DetectorSizeY[type];
+  Double_t frameWidth  = FrameWidth[type];
+  Double_t activeAreaX = sizeX - 2 * frameWidth;
+  Double_t activeAreaY = sizeY - 2 * frameWidth;
+
+  TGeoMedium* keepVolMed      = gGeoMan->GetMedium(KeepingVolumeMedium);
+  TGeoMedium* radVolMed       = gGeoMan->GetMedium(RadiatorVolumeMedium);
+  TGeoMedium* latticeVolMed   = gGeoMan->GetMedium(LatticeVolumeMedium);
+  TGeoMedium* kaptonVolMed    = gGeoMan->GetMedium(KaptonVolumeMedium);
+  TGeoMedium* gasVolMed       = gGeoMan->GetMedium(GasVolumeMedium);
+  TGeoMedium* padcopperVolMed = gGeoMan->GetMedium(PadCopperVolumeMedium);
+  TGeoMedium* padpcbVolMed    = gGeoMan->GetMedium(PadPcbVolumeMedium);
+  TGeoMedium* honeycombVolMed = gGeoMan->GetMedium(HoneycombVolumeMedium);
+  TGeoMedium* carbonVolMed    = gGeoMan->GetMedium(CarbonVolumeMedium);
+  //  TGeoMedium* mylarVolMed       = gGeoMan->GetMedium(MylarVolumeMedium);
+  //  TGeoMedium* electronicsVolMed = gGeoMan->GetMedium(ElectronicsVolumeMedium);
+  TGeoMedium* frameVolMed    = gGeoMan->GetMedium(FrameVolumeMedium);
+  TGeoMedium* aluledgeVolMed = gGeoMan->GetMedium(AluLegdeVolumeMedium);
+  TGeoMedium* febVolMed      = gGeoMan->GetMedium(FebVolumeMedium);
+  TGeoMedium* asicVolMed     = gGeoMan->GetMedium(AsicVolumeMedium);
+  //  TGeoMedium* aluminiumVolMed   = gGeoMan->GetMedium(AluminiumVolumeMedium);
+
+  TString name       = Form("module%d", moduleType);
+  TGeoVolume* module = new TGeoVolumeAssembly(name);
+
+
+  if (IncludeRadiator) {
+    // Radiator
+    //   TGeoBBox* trd_radiator = new TGeoBBox("", activeAreaX /2., activeAreaY /2., radiator_thickness /2.);
+    TGeoBBox* trd_radiator = new TGeoBBox(
+      "trd_radiator", sizeX / 2., sizeY / 2., radiator_thickness / 2.);
+    TGeoVolume* trdmod1_radvol =
+      new TGeoVolume("radiator", trd_radiator, radVolMed);
+    //     TGeoVolume* trdmod1_radvol = new TGeoVolume(Form("module%d_radiator", moduleType), trd_radiator, radVolMed);
+    //     TGeoVolume* trdmod1_radvol = new TGeoVolume(Form("trd1mod%dradiator", moduleType), trd_radiator, radVolMed);
+    trdmod1_radvol->SetLineColor(kBlue);
+    trdmod1_radvol->SetTransparency(
+      70);  // (60);  // (70);  // set transparency for the TRD radiator
+    TGeoTranslation* trd_radiator_trans =
+      new TGeoTranslation("", 0., 0., radiator_position);
+    module->AddNode(trdmod1_radvol, 1, trd_radiator_trans);
+  }
+
+  // Lattice grid
+  if (IncludeLattice) {
+
+    if (type == 0)  // inner modules
+    {
+      //     printf("lattice type %d\n", type);
+      // drift window - lattice grid - sprossenfenster
+      TGeoBBox* trd_lattice_mod0_ho =
+        new TGeoBBox("trd_lattice_mod0_ho",
+                     sizeX / 2.,
+                     lattice_o_width[type] / 2.,
+                     lattice_thickness / 2.);  // horizontal outer
+      TGeoBBox* trd_lattice_mod0_hi =
+        new TGeoBBox("trd_lattice_mod0_hi",
+                     sizeX / 2. - lattice_o_width[type],
+                     lattice_i_width[type] / 2.,
+                     lattice_thickness / 2.);  // horizontal inner
+      TGeoBBox* trd_lattice_mod0_vo =
+        new TGeoBBox("trd_lattice_mod0_vo",
+                     lattice_o_width[type] / 2.,
+                     sizeX / 2. - lattice_o_width[type],
+                     lattice_thickness / 2.);  // vertical outer
+      TGeoBBox* trd_lattice_mod0_vi =
+        new TGeoBBox("trd_lattice_mod0_vi",
+                     lattice_i_width[type] / 2.,
+                     0.20 * activeAreaY / 2. - lattice_i_width[type] / 2.,
+                     lattice_thickness / 2.);  // vertical inner
+      TGeoBBox* trd_lattice_mod0_vb =
+        new TGeoBBox("trd_lattice_mod0_vb",
+                     lattice_i_width[type] / 2.,
+                     0.20 * activeAreaY / 2. - lattice_i_width[type] / 4.,
+                     lattice_thickness / 2.);  // vertical border
+
+      TGeoVolume* trd_lattice_mod0_vol_ho =
+        new TGeoVolume("lattice0ho", trd_lattice_mod0_ho, latticeVolMed);
+      TGeoVolume* trd_lattice_mod0_vol_hi =
+        new TGeoVolume("lattice0hi", trd_lattice_mod0_hi, latticeVolMed);
+      TGeoVolume* trd_lattice_mod0_vol_vo =
+        new TGeoVolume("lattice0vo", trd_lattice_mod0_vo, latticeVolMed);
+      TGeoVolume* trd_lattice_mod0_vol_vi =
+        new TGeoVolume("lattice0vi", trd_lattice_mod0_vi, latticeVolMed);
+      TGeoVolume* trd_lattice_mod0_vol_vb =
+        new TGeoVolume("lattice0vb", trd_lattice_mod0_vb, latticeVolMed);
+
+      trd_lattice_mod0_vol_ho->SetLineColor(kYellow);  // kBlue);
+      trd_lattice_mod0_vol_vo->SetLineColor(kYellow);  // kOrange);
+      trd_lattice_mod0_vol_hi->SetLineColor(kYellow);  // kRed);
+      trd_lattice_mod0_vol_vi->SetLineColor(kYellow);  // kWhite);
+      trd_lattice_mod0_vol_vb->SetLineColor(kYellow);
+
+      TGeoTranslation* tv010 = new TGeoTranslation(
+        "tv010", 0., (1.00 * activeAreaY / 2. + lattice_o_width[type] / 2.), 0);
+      TGeoTranslation* tv015 = new TGeoTranslation(
+        "tv015",
+        0.,
+        -(1.00 * activeAreaY / 2. + lattice_o_width[type] / 2.),
+        0);
+
+      TGeoTranslation* th020 = new TGeoTranslation(
+        "th020", (1.00 * activeAreaX / 2. + lattice_o_width[type] / 2.), 0., 0);
+      TGeoTranslation* th025 = new TGeoTranslation(
+        "th025",
+        -(1.00 * activeAreaX / 2. + lattice_o_width[type] / 2.),
+        0.,
+        0);
+
+      Double_t hypos0[4] = {(0.60 * activeAreaY / 2.),
+                            (0.20 * activeAreaY / 2.),
+                            -(0.20 * activeAreaY / 2.),
+                            -(0.60 * activeAreaY / 2.)};
+
+      Double_t vxpos0[4] = {(0.60 * activeAreaX / 2.),
+                            (0.20 * activeAreaX / 2.),
+                            -(0.20 * activeAreaX / 2.),
+                            -(0.60 * activeAreaX / 2.)};
+
+      Double_t vypos0[5] = {
+        (0.80 * activeAreaY / 2. + lattice_i_width[type] / 4.),
+        (0.40 * activeAreaY / 2.),
+        (0.00 * activeAreaY / 2.),
+        -(0.40 * activeAreaY / 2.),
+        -(0.80 * activeAreaY / 2. + lattice_i_width[type] / 4.)};
+
+      //       TGeoVolumeAssembly* trdmod0_lattice = new TGeoVolumeAssembly("mod0lattice"); // volume for lattice grid
+
+      TGeoBBox* trd_lattice_mod0 = new TGeoBBox(
+        "trd_lattice_mod0", sizeX / 2., sizeY / 2., lattice_thickness / 2.);
+      TGeoVolume* trdmod0_lattice =
+        new TGeoVolume("lat_grid_mod0", trd_lattice_mod0, keepVolMed);
+
+      //       trdmod0_lattice->SetLineColor(kGreen);  // set color for keeping volume
+
+      // outer frame
+      trdmod0_lattice->AddNode(trd_lattice_mod0_vol_ho, 1, tv010);
+      trdmod0_lattice->AddNode(trd_lattice_mod0_vol_ho, 2, tv015);
+
+      trdmod0_lattice->AddNode(trd_lattice_mod0_vol_vo, 3, th020);
+      trdmod0_lattice->AddNode(trd_lattice_mod0_vol_vo, 4, th025);
+
+      // lattice piece number
+      Int_t lat0_no = 5;
+
+      // horizontal bars
+      for (Int_t y = 0; y < 4; y++) {
+        TGeoTranslation* t0xy = new TGeoTranslation("", 0, hypos0[y], 0);
+        trdmod0_lattice->AddNode(trd_lattice_mod0_vol_hi, lat0_no, t0xy);
+        lat0_no++;
+      }
+
+      // vertical bars
+      for (Int_t x = 0; x < 4; x++)
+        for (Int_t y = 0; y < 5; y++) {
+          TGeoTranslation* t0xy =
+            new TGeoTranslation("", vxpos0[x], vypos0[y], 0);
+          if ((y == 0) || (y == 4))
+            trdmod0_lattice->AddNode(
+              trd_lattice_mod0_vol_vb, lat0_no, t0xy);  // border piece
+          else
+            trdmod0_lattice->AddNode(
+              trd_lattice_mod0_vol_vi, lat0_no, t0xy);  // middle piece
+          lat0_no++;
+        }
+
+      // add lattice to module
+      TGeoTranslation* trd_lattice_trans =
+        new TGeoTranslation("", 0., 0., lattice_position);
+      module->AddNode(trdmod0_lattice, 1, trd_lattice_trans);
+    }
+
+    else if (type == 1)  // outer modules
+    {
+      //     printf("lattice type %d\n", type);
+      // drift window - lattice grid - sprossenfenster
+      TGeoBBox* trd_lattice_mod1_ho =
+        new TGeoBBox("trd_lattice_mod1_ho",
+                     sizeX / 2.,
+                     lattice_o_width[type] / 2.,
+                     lattice_thickness / 2.);  // horizontal outer
+      TGeoBBox* trd_lattice_mod1_hi =
+        new TGeoBBox("trd_lattice_mod1_hi",
+                     sizeX / 2. - lattice_o_width[type],
+                     lattice_i_width[type] / 2.,
+                     lattice_thickness / 2.);  // horizontal inner
+      TGeoBBox* trd_lattice_mod1_vo =
+        new TGeoBBox("trd_lattice_mod1_vo",
+                     lattice_o_width[type] / 2.,
+                     sizeX / 2. - lattice_o_width[type],
+                     lattice_thickness / 2.);  // vertical outer
+      TGeoBBox* trd_lattice_mod1_vi =
+        new TGeoBBox("trd_lattice_mod1_vi",
+                     lattice_i_width[type] / 2.,
+                     0.125 * activeAreaY / 2. - lattice_i_width[type] / 2.,
+                     lattice_thickness / 2.);  // vertical inner
+      TGeoBBox* trd_lattice_mod1_vb =
+        new TGeoBBox("trd_lattice_mod1_vb",
+                     lattice_i_width[type] / 2.,
+                     0.125 * activeAreaY / 2. - lattice_i_width[type] / 4.,
+                     lattice_thickness / 2.);  // vertical border
+
+      TGeoVolume* trd_lattice_mod1_vol_ho =
+        new TGeoVolume("lattice1ho", trd_lattice_mod1_ho, latticeVolMed);
+      TGeoVolume* trd_lattice_mod1_vol_hi =
+        new TGeoVolume("lattice1hi", trd_lattice_mod1_hi, latticeVolMed);
+      TGeoVolume* trd_lattice_mod1_vol_vo =
+        new TGeoVolume("lattice1vo", trd_lattice_mod1_vo, latticeVolMed);
+      TGeoVolume* trd_lattice_mod1_vol_vi =
+        new TGeoVolume("lattice1vi", trd_lattice_mod1_vi, latticeVolMed);
+      TGeoVolume* trd_lattice_mod1_vol_vb =
+        new TGeoVolume("lattice1vb", trd_lattice_mod1_vb, latticeVolMed);
+
+      trd_lattice_mod1_vol_ho->SetLineColor(kYellow);  // kBlue);
+      trd_lattice_mod1_vol_vo->SetLineColor(kYellow);  // kOrange);
+      trd_lattice_mod1_vol_hi->SetLineColor(kYellow);  // kRed);
+      trd_lattice_mod1_vol_vi->SetLineColor(kYellow);  // kWhite);
+      trd_lattice_mod1_vol_vb->SetLineColor(kYellow);
+
+      TGeoTranslation* tv110 = new TGeoTranslation(
+        "tv110", 0., (1.00 * activeAreaY / 2. + lattice_o_width[type] / 2.), 0);
+      TGeoTranslation* tv118 = new TGeoTranslation(
+        "tv118",
+        0.,
+        -(1.00 * activeAreaY / 2. + lattice_o_width[type] / 2.),
+        0);
+
+      TGeoTranslation* th120 = new TGeoTranslation(
+        "th120", (1.00 * activeAreaX / 2. + lattice_o_width[type] / 2.), 0., 0);
+      TGeoTranslation* th128 = new TGeoTranslation(
+        "th128",
+        -(1.00 * activeAreaX / 2. + lattice_o_width[type] / 2.),
+        0.,
+        0);
+
+      Double_t hypos1[7] = {(0.75 * activeAreaY / 2.),
+                            (0.50 * activeAreaY / 2.),
+                            (0.25 * activeAreaY / 2.),
+                            (0.00 * activeAreaY / 2.),
+                            -(0.25 * activeAreaY / 2.),
+                            -(0.50 * activeAreaY / 2.),
+                            -(0.75 * activeAreaY / 2.)};
+
+      Double_t vxpos1[7] = {(0.75 * activeAreaX / 2.),
+                            (0.50 * activeAreaX / 2.),
+                            (0.25 * activeAreaX / 2.),
+                            (0.00 * activeAreaX / 2.),
+                            -(0.25 * activeAreaX / 2.),
+                            -(0.50 * activeAreaX / 2.),
+                            -(0.75 * activeAreaX / 2.)};
+
+      Double_t vypos1[8] = {
+        (0.875 * activeAreaY / 2. + lattice_i_width[type] / 4.),
+        (0.625 * activeAreaY / 2.),
+        (0.375 * activeAreaY / 2.),
+        (0.125 * activeAreaY / 2.),
+        -(0.125 * activeAreaY / 2.),
+        -(0.375 * activeAreaY / 2.),
+        -(0.625 * activeAreaY / 2.),
+        -(0.875 * activeAreaY / 2. + lattice_i_width[type] / 4.)};
+
+      //       TGeoVolumeAssembly* trdmod1_lattice = new TGeoVolumeAssembly("mod1lattice"); // volume for lattice grid
+
+      TGeoBBox* trd_lattice_mod1 = new TGeoBBox(
+        "trd_lattice_mod1", sizeX / 2., sizeY / 2., lattice_thickness / 2.);
+      TGeoVolume* trdmod1_lattice =
+        new TGeoVolume("lat_grid_mod1", trd_lattice_mod1, keepVolMed);
+
+      //       trdmod1_lattice->SetLineColor(kGreen);  // set color for keeping volume
+
+      // outer frame
+      trdmod1_lattice->AddNode(trd_lattice_mod1_vol_ho, 1, tv110);
+      trdmod1_lattice->AddNode(trd_lattice_mod1_vol_ho, 2, tv118);
+
+      trdmod1_lattice->AddNode(trd_lattice_mod1_vol_vo, 3, th120);
+      trdmod1_lattice->AddNode(trd_lattice_mod1_vol_vo, 4, th128);
+
+      // lattice piece number
+      Int_t lat1_no = 5;
+
+      // horizontal bars
+      for (Int_t y = 0; y < 7; y++) {
+        TGeoTranslation* t1xy = new TGeoTranslation("", 0, hypos1[y], 0);
+        trdmod1_lattice->AddNode(trd_lattice_mod1_vol_hi, lat1_no, t1xy);
+        lat1_no++;
+      }
+
+      // vertical bars
+      for (Int_t x = 0; x < 7; x++)
+        for (Int_t y = 0; y < 8; y++) {
+          TGeoTranslation* t1xy =
+            new TGeoTranslation("", vxpos1[x], vypos1[y], 0);
+          if ((y == 0) || (y == 7))
+            trdmod1_lattice->AddNode(
+              trd_lattice_mod1_vol_vb, lat1_no, t1xy);  // border piece
+          else
+            trdmod1_lattice->AddNode(
+              trd_lattice_mod1_vol_vi, lat1_no, t1xy);  // middle piece
+          lat1_no++;
+        }
+
+      // add lattice to module
+      TGeoTranslation* trd_lattice_trans =
+        new TGeoTranslation("", 0., 0., lattice_position);
+      module->AddNode(trdmod1_lattice, 1, trd_lattice_trans);
+    }
+
+  }  // with lattice grid
+
+  if (IncludeKaptonFoil) {
+    // Kapton Foil
+    TGeoBBox* trd_kapton =
+      new TGeoBBox("trd_kapton", sizeX / 2., sizeY / 2., kapton_thickness / 2.);
+    TGeoVolume* trdmod1_kaptonvol =
+      new TGeoVolume("kaptonfoil", trd_kapton, kaptonVolMed);
+    //   TGeoVolume* trdmod1_kaptonvol = new TGeoVolume(Form("module%d_kaptonfoil", moduleType), trd_kapton, kaptonVolMed);
+    //   TGeoVolume* trdmod1_kaptonvol = new TGeoVolume(Form("trd1mod%dkapton", moduleType), trd_kapton, kaptonVolMed);
+    trdmod1_kaptonvol->SetLineColor(kGreen);
+    TGeoTranslation* trd_kapton_trans =
+      new TGeoTranslation("", 0., 0., kapton_position);
+    module->AddNode(trdmod1_kaptonvol, 1, trd_kapton_trans);
+  }
+
+  // start of Frame in z
+  // Gas
+  TGeoBBox* trd_gas = new TGeoBBox(
+    "trd_gas", activeAreaX / 2., activeAreaY / 2., gas_thickness / 2.);
+  TGeoVolume* trdmod1_gasvol = new TGeoVolume("gas", trd_gas, gasVolMed);
+  //   TGeoVolume* trdmod1_gasvol = new TGeoVolume(Form("module%d_gas", moduleType), trd_gas, gasVolMed);
+  //   TGeoVolume* trdmod1_gasvol = new TGeoVolume(Form("trd1mod%dgas", moduleType), trd_gas, gasVolMed);
+  //   trdmod1_gasvol->SetLineColor(kBlue);
+  trdmod1_gasvol->SetLineColor(
+    kGreen);  // to avoid blue overlaps in the screenshots
+  trdmod1_gasvol->SetTransparency(40);  // set transparency for the TRD gas
+  TGeoTranslation* trd_gas_trans =
+    new TGeoTranslation("", 0., 0., gas_position);
+  module->AddNode(trdmod1_gasvol, 1, trd_gas_trans);
+  // end of Frame in z
+
+  if (IncludeGasFrame) {
+    // frame1
+    TGeoBBox* trd_frame1 = new TGeoBBox(
+      "trd_frame1", sizeX / 2., frameWidth / 2., frame_thickness / 2.);
+    TGeoVolume* trdmod1_frame1vol =
+      new TGeoVolume("frame1", trd_frame1, frameVolMed);
+    trdmod1_frame1vol->SetLineColor(kRed);
+
+    // translations
+    TGeoTranslation* trd_frame1_trans = new TGeoTranslation(
+      "", 0., activeAreaY / 2. + frameWidth / 2., frame_position);
+    module->AddNode(trdmod1_frame1vol, 1, trd_frame1_trans);
+    trd_frame1_trans = new TGeoTranslation(
+      "", 0., -(activeAreaY / 2. + frameWidth / 2.), frame_position);
+    module->AddNode(trdmod1_frame1vol, 2, trd_frame1_trans);
+
+
+    // frame2
+    TGeoBBox* trd_frame2 = new TGeoBBox(
+      "trd_frame2", frameWidth / 2., activeAreaY / 2., frame_thickness / 2.);
+    TGeoVolume* trdmod1_frame2vol =
+      new TGeoVolume("frame2", trd_frame2, frameVolMed);
+    trdmod1_frame2vol->SetLineColor(kRed);
+
+    // translations
+    TGeoTranslation* trd_frame2_trans = new TGeoTranslation(
+      "", activeAreaX / 2. + frameWidth / 2., 0., frame_position);
+    module->AddNode(trdmod1_frame2vol, 1, trd_frame2_trans);
+    trd_frame2_trans = new TGeoTranslation(
+      "", -(activeAreaX / 2. + frameWidth / 2.), 0., frame_position);
+    module->AddNode(trdmod1_frame2vol, 2, trd_frame2_trans);
+  }
+
+  if (IncludePadplane) {
+    // Pad Copper
+    TGeoBBox* trd_padcopper = new TGeoBBox(
+      "trd_padcopper", sizeX / 2., sizeY / 2., padcopper_thickness / 2.);
+    TGeoVolume* trdmod1_padcoppervol =
+      new TGeoVolume("padcopper", trd_padcopper, padcopperVolMed);
+    //   TGeoVolume* trdmod1_padcoppervol = new TGeoVolume(Form("module%d_padcopper", moduleType), trd_padcopper, padcopperVolMed);
+    //   TGeoVolume* trdmod1_padcoppervol = new TGeoVolume(Form("trd1mod%dpadcopper", moduleType), trd_padcopper, padcopperVolMed);
+    trdmod1_padcoppervol->SetLineColor(kOrange);
+    TGeoTranslation* trd_padcopper_trans =
+      new TGeoTranslation("", 0., 0., padcopper_position);
+    module->AddNode(trdmod1_padcoppervol, 1, trd_padcopper_trans);
+
+    // Pad Plane
+    TGeoBBox* trd_padpcb = new TGeoBBox(
+      "trd_padpcb", sizeX / 2., sizeY / 2., padplane_thickness / 2.);
+    TGeoVolume* trdmod1_padpcbvol =
+      new TGeoVolume("padplane", trd_padpcb, padpcbVolMed);
+    //   TGeoVolume* trdmod1_padpcbvol = new TGeoVolume(Form("module%d_padplane", moduleType), trd_padpcb, padpcbVolMed);
+    //   TGeoVolume* trdmod1_padpcbvol = new TGeoVolume(Form("trd1mod%dpadplane", moduleType), trd_padpcb, padpcbVolMed);
+    trdmod1_padpcbvol->SetLineColor(kBlue);
+    TGeoTranslation* trd_padpcb_trans =
+      new TGeoTranslation("", 0., 0., padplane_position);
+    module->AddNode(trdmod1_padpcbvol, 1, trd_padpcb_trans);
+  }
+
+  if (IncludeBackpanel) {
+    // Honeycomb
+    TGeoBBox* trd_honeycomb = new TGeoBBox(
+      "trd_honeycomb", sizeX / 2., sizeY / 2., honeycomb_thickness / 2.);
+    TGeoVolume* trdmod1_honeycombvol =
+      new TGeoVolume("honeycomb", trd_honeycomb, honeycombVolMed);
+    //   TGeoVolume* trdmod1_honeycombvol = new TGeoVolume(Form("module%d_honeycomb", moduleType), trd_honeycomb, honeycombVolMed);
+    //   TGeoVolume* trdmod1_honeycombvol = new TGeoVolume(Form("trd1mod%dhoneycomb", moduleType), trd_honeycomb, honeycombVolMed);
+    trdmod1_honeycombvol->SetLineColor(kOrange);
+    TGeoTranslation* trd_honeycomb_trans =
+      new TGeoTranslation("", 0., 0., honeycomb_position);
+    module->AddNode(trdmod1_honeycombvol, 1, trd_honeycomb_trans);
+
+    // Carbon fiber layers
+    TGeoBBox* trd_carbon =
+      new TGeoBBox("trd_carbon", sizeX / 2., sizeY / 2., carbon_thickness / 2.);
+    TGeoVolume* trdmod1_carbonvol =
+      new TGeoVolume("carbonsheet", trd_carbon, carbonVolMed);
+    //   TGeoVolume* trdmod1_carbonvol = new TGeoVolume(Form("module%d_carbonsheet", moduleType), trd_carbon, carbonVolMed);
+    //   TGeoVolume* trdmod1_carbonvol = new TGeoVolume(Form("trd1mod%dcarbon", moduleType), trd_carbon, carbonVolMed);
+    trdmod1_carbonvol->SetLineColor(kGreen);
+    TGeoTranslation* trd_carbon_trans =
+      new TGeoTranslation("", 0., 0., carbon_position);
+    module->AddNode(trdmod1_carbonvol, 1, trd_carbon_trans);
+  }
+
+  if (IncludeAluLedge) {
+    // Al-ledge
+    TGeoBBox* trd_aluledge1 = new TGeoBBox("trd_aluledge1",
+                                           sizeY / 2.,
+                                           aluminium_width / 2.,
+                                           aluminium_thickness / 2.);
+    TGeoVolume* trdmod1_aluledge1vol =
+      new TGeoVolume("aluledge1", trd_aluledge1, aluledgeVolMed);
+    trdmod1_aluledge1vol->SetLineColor(kRed);
+
+    // translations
+    TGeoTranslation* trd_aluledge1_trans = new TGeoTranslation(
+      "", 0., sizeY / 2. - aluminium_width / 2., aluminium_position);
+    module->AddNode(trdmod1_aluledge1vol, 1, trd_aluledge1_trans);
+    trd_aluledge1_trans = new TGeoTranslation(
+      "", 0., -(sizeY / 2. - aluminium_width / 2.), aluminium_position);
+    module->AddNode(trdmod1_aluledge1vol, 2, trd_aluledge1_trans);
+
+
+    // Al-ledge
+    TGeoBBox* trd_aluledge2 = new TGeoBBox("trd_aluledge2",
+                                           aluminium_width / 2.,
+                                           sizeY / 2. - aluminium_width,
+                                           aluminium_thickness / 2.);
+    TGeoVolume* trdmod1_aluledge2vol =
+      new TGeoVolume("aluledge2", trd_aluledge2, aluledgeVolMed);
+    trdmod1_aluledge2vol->SetLineColor(kRed);
+
+    // translations
+    TGeoTranslation* trd_aluledge2_trans = new TGeoTranslation(
+      "", sizeX / 2. - aluminium_width / 2., 0., aluminium_position);
+    module->AddNode(trdmod1_aluledge2vol, 1, trd_aluledge2_trans);
+    trd_aluledge2_trans = new TGeoTranslation(
+      "", -(sizeX / 2. - aluminium_width / 2.), 0., aluminium_position);
+    module->AddNode(trdmod1_aluledge2vol, 2, trd_aluledge2_trans);
+  }
+
+  // FEBs
+  if (IncludeFebs) {
+    // assemblies
+    TGeoVolumeAssembly* trd_feb_vol =
+      new TGeoVolumeAssembly("febvol");  // the mother volume of all FEBs
+    TGeoVolumeAssembly* trd_feb_box = new TGeoVolumeAssembly(
+      "febbox");  // volume for inclined FEBs, then shifted along y
+    //TGeoVolumeAssembly* trd_feb_vol = new TGeoVolumeAssembly(Form("module%d_febvol", moduleType));  // the mother volume of all FEBs
+    //TGeoVolumeAssembly* trd_feb_box = new TGeoVolumeAssembly(Form("module%d_febbox", moduleType));  // volume for inclined FEBs, then shifted along y
+    //TGeoVolumeAssembly* trd_feb_vol = new TGeoVolumeAssembly(Form("trd1mod%dfebvol", moduleType));  // the mother volume of all FEBs
+    //TGeoVolumeAssembly* trd_feb_box = new TGeoVolumeAssembly(Form("trd1mod%dfebbox", moduleType));  // volume for inclined FEBs, then shifted along y
+
+    // translations + rotations
+    TGeoTranslation* trd_feb_trans1;      // center to corner
+    TGeoTranslation* trd_feb_trans2;      // corner back
+    TGeoRotation* trd_feb_rotation;       // rotation around x axis
+    TGeoTranslation* trd_feb_y_position;  // shift to y position on TRD
+    //      TGeoTranslation *trd_feb_null;       // no displacement
+
+    // replaced by matrix operation (see below)
+    //  //      Double_t yback, zback;
+    //  //      TGeoCombiTrans  *trd_feb_placement;
+    //  //      // fix Z back offset 0.3 at some point
+    //  //      yback = -    sin(feb_rotation_angle/180*3.141)  * feb_width /2.;
+    //  //      zback = - (1-cos(feb_rotation_angle/180*3.141)) * feb_width /2. + 0.3;
+    //  //      trd_feb_placement = new TGeoCombiTrans(0, feb_pos_y + yback, zback, trd_feb_rotation);
+    //  //      trd_feb_box->AddNode(trdmod1_feb, iFeb+1, trd_feb_placement);
+
+    //      trd_feb_null       = new TGeoTranslation("", 0., 0., 0.);  // empty operation
+    trd_feb_trans1 = new TGeoTranslation(
+      "",
+      0.,
+      -feb_thickness / 2.,
+      -feb_width / 2.);  // move bottom right corner to center
+    trd_feb_trans2 =
+      new TGeoTranslation("",
+                          0.,
+                          feb_thickness / 2.,
+                          feb_width / 2.);  // move bottom right corner back
+    trd_feb_rotation = new TGeoRotation();
+    trd_feb_rotation->RotateX(feb_rotation_angle[moduleType - 1]);
+
+    TGeoHMatrix* incline_feb = new TGeoHMatrix("");
+
+    //        (*incline_feb) = (*trd_feb_null);        // OK
+    //        (*incline_feb) = (*trd_feb_y_position);  // OK
+    //        (*incline_feb) = (*trd_feb_trans1);      // OK
+    //        (*incline_feb) = (*trd_feb_trans1) * (*trd_feb_y_position);  // OK
+    //        (*incline_feb) = (*trd_feb_trans1) * (*trd_feb_trans2);      // OK
+    //        (*incline_feb) = (*trd_feb_trans1) * (*trd_feb_rotation);    // OK
+    //        (*incline_feb) =  (*trd_feb_trans1) * (*trd_feb_rotation) * (*trd_feb_trans2) * (*trd_feb_y_position);  // not OK
+    // trd_feb_y_position is displaced in rotated coordinate system
+
+    // matrix operation to rotate FEB PCB around its corner on the backanel
+    (*incline_feb) =
+      (*trd_feb_trans1) * (*trd_feb_rotation) * (*trd_feb_trans2);  // OK
+
+    // Create all FEBs and place them in an assembly which will be added to the TRD module
+    TGeoBBox* trd_feb =
+      new TGeoBBox("trd_feb",
+                   activeAreaX / 2.,
+                   feb_thickness / 2.,
+                   feb_width / 2.);  // the FEB itself - as a cuboid
+    TGeoVolume* trdmod1_feb = new TGeoVolume(
+      "feb", trd_feb, febVolMed);  // the FEB made of a certain medium
+    //      TGeoVolume* trdmod1_feb = new TGeoVolume(Form("module%d_feb", moduleType), trd_feb, febVolMed);  // the FEB made of a certain medium
+    //      TGeoVolume* trdmod1_feb = new TGeoVolume(Form("trd1mod%dfeb", moduleType), trd_feb, febVolMed);  // the FEB made of a certain medium
+    trdmod1_feb->SetLineColor(kYellow);  // set yellow color
+    trd_feb_box->AddNode(trdmod1_feb, 1, incline_feb);
+    // now we have an inclined FEB
+
+    // ASICs
+    if (IncludeAsics) {
+      Double_t asic_pos;
+      Double_t asic_pos_x;
+      TGeoTranslation* trd_asic_trans0;  // ASIC on FEB x position
+      TGeoTranslation* trd_asic_trans1;  // center to corner
+      TGeoTranslation* trd_asic_trans2;  // corner back
+      TGeoRotation* trd_asic_rotation;   // rotation around x axis
+
+      trd_asic_trans1 = new TGeoTranslation(
+        "",
+        0.,
+        -(feb_thickness + asic_offset + asic_thickness / 2.),
+        -feb_width / 2.);  // move ASIC center to FEB corner
+      trd_asic_trans2 = new TGeoTranslation(
+        "",
+        0.,
+        feb_thickness + asic_offset + asic_thickness / 2.,
+        feb_width / 2.);  // move FEB corner back to asic center
+      trd_asic_rotation = new TGeoRotation();
+      trd_asic_rotation->RotateX(feb_rotation_angle[moduleType - 1]);
+
+      TGeoHMatrix* incline_asic;
+
+      // put many ASICs on each inclined FEB
+      TGeoBBox* trd_asic = new TGeoBBox("trd_asic",
+                                        asic_width / 2.,
+                                        asic_thickness / 2.,
+                                        asic_width / 2.);  // ASIC dimensions
+      // TODO: use Silicon as ASICs material
+      TGeoVolume* trdmod1_asic = new TGeoVolume(
+        "asic", trd_asic, asicVolMed);  // the ASIC made of a certain medium
+      //        TGeoVolume* trdmod1_asic = new TGeoVolume(Form("module%d_asic", moduleType), trd_asic, asicVolMed);   // the ASIC made of a certain medium
+      //        TGeoVolume* trdmod1_asic = new TGeoVolume(Form("trd1mod%dasic", moduleType), trd_asic, asicVolMed);   // the ASIC made of a certain medium
+      trdmod1_asic->SetLineColor(kBlue);  // set blue color for ASICs
+
+      Int_t nofAsics = AsicsPerFeb[moduleType - 1] % 100;
+      Int_t groupAsics =
+        AsicsPerFeb[moduleType - 1] / 100;  // either 1 or 2 or 3 (new ultimate)
+
+      if ((nofAsics == 16) && (activeAreaX < 60))
+        asic_distance = 0.0;  // for 57 cm  // 0.1;  // for 60 cm
+      else
+        asic_distance = 0.4;
+
+      for (Int_t iAsic = 0; iAsic < (nofAsics / groupAsics); iAsic++) {
+        if (groupAsics == 1)  // single ASICs
+        {
+          asic_pos =
+            (iAsic + 0.5) / nofAsics
+            - 0.5;  // equal spacing of ASICs on the FEB, e.g. for no=3 : -1/3, 0, +1/3
+
+          // ASIC 1
+          asic_pos_x      = asic_pos * activeAreaX;
+          trd_asic_trans0 = new TGeoTranslation(
+            "",
+            asic_pos_x,
+            feb_thickness / 2. + asic_thickness / 2. + asic_offset,
+            0.);  // move asic on top of FEB
+          incline_asic    = new TGeoHMatrix("");
+          (*incline_asic) = (*trd_asic_trans0) * (*trd_asic_trans1)
+                            * (*trd_asic_rotation) * (*trd_asic_trans2);  // OK
+          trd_feb_box->AddNode(
+            trdmod1_asic,
+            iAsic + 1,
+            incline_asic);  // now we have ASICs on the inclined FEB
+        }
+
+        if (groupAsics == 2)  // pairs of ASICs
+        {
+          asic_pos =
+            (iAsic + 0.5) / (nofAsics / groupAsics)
+            - 0.5;  // equal spacing of ASICs on the FEB, e.g. for no=3 : -1/3, 0, +1/3
+
+          // ASIC 1
+          asic_pos_x =
+            asic_pos * activeAreaX + (0.5 + asic_distance / 2.) * asic_width;
+          trd_asic_trans0 = new TGeoTranslation(
+            "",
+            asic_pos_x,
+            feb_thickness / 2. + asic_thickness / 2. + asic_offset,
+            0.);  // move asic on top of FEB);
+          incline_asic    = new TGeoHMatrix("");
+          (*incline_asic) = (*trd_asic_trans0) * (*trd_asic_trans1)
+                            * (*trd_asic_rotation) * (*trd_asic_trans2);  // OK
+          trd_feb_box->AddNode(
+            trdmod1_asic,
+            2 * iAsic + 1,
+            incline_asic);  // now we have ASICs on the inclined FEB
+
+          // ASIC 2
+          asic_pos_x =
+            asic_pos * activeAreaX - (0.5 + asic_distance / 2.) * asic_width;
+          trd_asic_trans0 = new TGeoTranslation(
+            "",
+            asic_pos_x,
+            feb_thickness / 2. + asic_thickness / 2. + asic_offset,
+            0.);  // move asic on top of FEB
+          incline_asic    = new TGeoHMatrix("");
+          (*incline_asic) = (*trd_asic_trans0) * (*trd_asic_trans1)
+                            * (*trd_asic_rotation) * (*trd_asic_trans2);  // OK
+          trd_feb_box->AddNode(
+            trdmod1_asic,
+            2 * iAsic + 2,
+            incline_asic);  // now we have ASICs on the inclined FEB
+        }
+
+        if (groupAsics == 3)  // triplets of ASICs
+        {
+          asic_pos =
+            (iAsic + 0.5) / (nofAsics / groupAsics)
+            - 0.5;  // equal spacing of ASICs on the FEB, e.g. for no=3 : -1/3, 0, +1/3
+
+          // ASIC 1
+          asic_pos_x =
+            asic_pos * activeAreaX
+            + 1.1 * asic_width;  // (0.5 + asic_distance/2.) * asic_width;
+          trd_asic_trans0 = new TGeoTranslation(
+            "",
+            asic_pos_x,
+            feb_thickness / 2. + asic_thickness / 2. + asic_offset,
+            0.);  // move asic on top of FEB);
+          incline_asic    = new TGeoHMatrix("");
+          (*incline_asic) = (*trd_asic_trans0) * (*trd_asic_trans1)
+                            * (*trd_asic_rotation) * (*trd_asic_trans2);  // OK
+          trd_feb_box->AddNode(
+            trdmod1_asic,
+            3 * iAsic + 1,
+            incline_asic);  // now we have ASICs on the inclined FEB
+
+          // ASIC 2
+          asic_pos_x      = asic_pos * activeAreaX;
+          trd_asic_trans0 = new TGeoTranslation(
+            "",
+            asic_pos_x,
+            feb_thickness / 2. + asic_thickness / 2. + asic_offset,
+            0.);  // move asic on top of FEB
+          incline_asic    = new TGeoHMatrix("");
+          (*incline_asic) = (*trd_asic_trans0) * (*trd_asic_trans1)
+                            * (*trd_asic_rotation) * (*trd_asic_trans2);  // OK
+          trd_feb_box->AddNode(
+            trdmod1_asic,
+            3 * iAsic + 2,
+            incline_asic);  // now we have ASICs on the inclined FEB
+
+          // ASIC 3
+          asic_pos_x =
+            asic_pos * activeAreaX
+            - 1.1 * asic_width;  // (0.5 + asic_distance/2.) * asic_width;
+          trd_asic_trans0 = new TGeoTranslation(
+            "",
+            asic_pos_x,
+            feb_thickness / 2. + asic_thickness / 2. + asic_offset,
+            0.);  // move asic on top of FEB
+          incline_asic    = new TGeoHMatrix("");
+          (*incline_asic) = (*trd_asic_trans0) * (*trd_asic_trans1)
+                            * (*trd_asic_rotation) * (*trd_asic_trans2);  // OK
+          trd_feb_box->AddNode(
+            trdmod1_asic,
+            3 * iAsic + 3,
+            incline_asic);  // now we have ASICs on the inclined FEB
+        }
+      }
+      // now we have an inclined FEB with ASICs
+    }
+
+
+    // now go on with FEB placement
+    Double_t feb_pos;
+    Double_t feb_pos_y;
+
+    Int_t nofFebs = FebsPerModule[moduleType - 1];
+    for (Int_t iFeb = 0; iFeb < nofFebs; iFeb++) {
+      feb_pos =
+        (iFeb + 0.5) / nofFebs - 0.5;  // equal spacing of FEBs on the backpanel
+      // cout << "feb_pos " << iFeb << ": " << feb_pos << endl;
+      feb_pos_y = feb_pos * activeAreaY;
+      feb_pos_y += feb_width / 2.
+                   * sin(feb_rotation_angle[moduleType - 1] * acos(-1.) / 180.);
+
+      // shift inclined FEB in y to its final position
+      trd_feb_y_position = new TGeoTranslation(
+        "",
+        0.,
+        feb_pos_y,
+        feb_z_offset);  // with additional fixed offset in z direction
+      //        trd_feb_y_position = new TGeoTranslation("", 0., feb_pos_y, 0.0);  // touching the backpanel with the corner
+      trd_feb_vol->AddNode(
+        trd_feb_box, iFeb + 1, trd_feb_y_position);  // position FEB in y
+    }
+
+    if (IncludeRobs) {
+      // GBTx ROBs
+      Double_t rob_size_x    = 20.0;  // 13.0; // 130 mm
+      Double_t rob_size_y    = 9.0;   //  4.5; //  45 mm
+      Double_t rob_offset    = 1.2;
+      Double_t rob_thickness = feb_thickness;
+
+      TGeoVolumeAssembly* trd_rob_box = new TGeoVolumeAssembly(
+        "robbox");  // volume for inclined FEBs, then shifted along y
+      TGeoBBox* trd_rob       = new TGeoBBox("trd_rob",
+                                       rob_size_x / 2.,
+                                       rob_size_y / 2.,
+                                       rob_thickness / 2.);  // the ROB itself
+      TGeoVolume* trdmod1_rob = new TGeoVolume(
+        "rob", trd_rob, febVolMed);     // the ROB made of a certain medium
+      trdmod1_rob->SetLineColor(kRed);  // set color
+
+      //      TGeoHMatrix *incline_rob = new TGeoHMatrix("");
+      trd_rob_box->AddNode(trdmod1_rob, 1);
+
+      // GBTXs
+      Double_t gbtx_pos;
+      Double_t gbtx_pos_x;
+      Double_t gbtx_pos_y;
+      TGeoTranslation* trd_gbtx_trans1;  // center to corner
+
+      // GBTX parameters
+      const Double_t gbtx_thickness = 0.25;  // 2.5 mm
+      const Double_t gbtx_width     = 3.0;   // 2.0;  1.0;   // 1 cm
+
+      // put many GBTXs on each inclined FEB
+      TGeoBBox* trd_gbtx =
+        new TGeoBBox("trd_gbtx",
+                     gbtx_width / 2.,
+                     gbtx_width / 2.,
+                     gbtx_thickness / 2.);  // GBTX dimensions
+      TGeoVolume* trdmod1_gbtx = new TGeoVolume(
+        "gbtx", trd_gbtx, asicVolMed);     // the GBTX made of a certain medium
+      trdmod1_gbtx->SetLineColor(kGreen);  // set color for GBTXs
+
+      Int_t nofGbtxs   = GbtxPerRob[moduleType - 1] % 100;
+      Int_t groupGbtxs = GbtxPerRob[moduleType - 1] / 100;  // usually 1
+
+      //      nofGbtxs   = 7;
+      //      groupGbtxs = 1;
+
+      Int_t nofGbtxX = (nofGbtxs - 1) / 2. + 1;  // +1 is for GBTx master
+      Int_t nofGbtxY = 2;
+
+      Double_t gbtx_distance = 0.4;
+      Int_t iGbtx            = 1;
+
+      for (Int_t iGbtxX = 0; iGbtxX < nofGbtxX; iGbtxX++) {
+        gbtx_pos =
+          (iGbtxX + 0.5) / nofGbtxX
+          - 0.5;  // equal spacing of GBTXs on the FEB, e.g. for no=3 : -1/3, 0, +1/3
+        gbtx_pos_x = -gbtx_pos * rob_size_x;
+
+        if (iGbtxX > 0)
+          for (Int_t iGbtxY = 0; iGbtxY < nofGbtxY; iGbtxY++) {
+            gbtx_pos =
+              (iGbtxY + 0.5) / nofGbtxY
+              - 0.5;  // equal spacing of GBTXs on the FEB, e.g. for no=3 : -1/3, 0, +1/3
+            gbtx_pos_y = gbtx_pos * rob_size_y;
+
+            trd_gbtx_trans1 = new TGeoTranslation(
+              "",
+              gbtx_pos_x,
+              gbtx_pos_y,
+              rob_thickness / 2.
+                + gbtx_thickness / 2.);  // move gbtx on top of ROB
+            trd_rob_box->AddNode(
+              trdmod1_gbtx,
+              iGbtx++,
+              trd_gbtx_trans1);  // now we have GBTXs on the ROB
+          }
+        else {
+          gbtx_pos_y = 0;
+
+          trd_gbtx_trans1 = new TGeoTranslation(
+            "",
+            gbtx_pos_x,
+            gbtx_pos_y,
+            rob_thickness / 2.
+              + gbtx_thickness / 2.);  // move gbtx on top of ROB
+          trd_rob_box->AddNode(
+            trdmod1_gbtx,
+            iGbtx++,
+            trd_gbtx_trans1);  // now we have GBTXs on the ROB
+        }
+      }
+
+      // now go on with ROB placement
+      Double_t rob_pos;
+      Double_t rob_pos_y;
+      TGeoTranslation* trd_rob_y_position;  // shift to y position on TRD
+
+      Int_t nofRobs = RobsPerModule[moduleType - 1];
+      for (Int_t iRob = 0; iRob < nofRobs; iRob++) {
+        rob_pos = (iRob + 0.5) / nofRobs
+                  - 0.5;  // equal spacing of ROBs on the backpanel
+        rob_pos_y = rob_pos * activeAreaY;
+
+        // shift inclined ROB in y to its final position
+        if (feb_rotation_angle[moduleType - 1]
+            == 90)  // if FEB parallel to backpanel
+          trd_rob_y_position = new TGeoTranslation(
+            "",
+            0.,
+            rob_pos_y,
+            -feb_width / 2. + rob_offset);  // place ROBs close to FEBs
+        else {
+          //	    Int_t rob_z_pos = 0.;  // test where ROB is placed by default
+          Int_t rob_z_pos =
+            -feb_width / 2.
+            + feb_width
+                * cos(feb_rotation_angle[moduleType - 1] * acos(-1.) / 180.)
+            + rob_offset;
+          if (rob_z_pos > feb_width / 2.)  // if the rob is too far out
+          {
+            rob_z_pos = feb_width / 2.
+                        - rob_thickness;  // place ROBs at end of feb volume
+            std::cout << "GBTx ROB was outside of the FEB volume, check "
+                         "overlap with FEB"
+                      << std::endl;
+          }
+          trd_rob_y_position =
+            new TGeoTranslation("", 0., rob_pos_y, rob_z_pos);
+        }
+        trd_feb_vol->AddNode(
+          trd_rob_box, iRob + 1, trd_rob_y_position);  // position FEB in y
+      }
+
+    }  // IncludeGbtx
+
+    // put FEB box on module
+    TGeoTranslation* trd_febvolume_trans =
+      new TGeoTranslation("", 0., 0., febvolume_position);
+    gGeoMan->GetVolume(name)->AddNode(
+      trd_feb_vol,
+      1,
+      trd_febvolume_trans);  // put febvolume at correct z position wrt to the module
+  }
+
+  return module;
+}
+
+Int_t copy_nr(Int_t stationNr,
+              Int_t copyNr,
+              Int_t isRotated,
+              Int_t planeNr,
+              Int_t modinplaneNr) {
+  if (modinplaneNr > 128)
+    printf("Warning: too many modules in this layer %02d (max 128 according to "
+           "CbmTrdAddress)\n",
+           planeNr);
+
+  return (stationNr * 100000000  // 1 digit
+          + copyNr * 1000000     // 2 digit
+          + isRotated * 100000   // 1 digit
+          + planeNr * 1000       // 2 digit
+          + modinplaneNr * 1);   // 3 digit
+}
+
+void create_detector_layers(Int_t layerId) {
+  Int_t module_id = 0;
+  Int_t layerType = LayerType[layerId] / 10;  // this is also a station number
+  Int_t isRotated = LayerType[layerId] % 10;  // is 1 for layers 2,4, ...
+  TGeoRotation* module_rotation = new TGeoRotation();
+
+  Int_t stationNr = layerType;
+
+  // rotation is now done in the for loop for each module individually
+  //  if ( isRotated == 1 ) {
+  //    module_rotation = new TGeoRotation();
+  //    module_rotation->RotateZ(90.);
+  //  } else {
+  //    module_rotation = new TGeoRotation();
+  //    module_rotation->RotateZ( 0.);
+  //  }
+
+  Int_t innerarray_size1 = LayerArraySize[layerType - 1][0];
+  Int_t innerarray_size2 = LayerArraySize[layerType - 1][1];
+  const Int_t* innerLayer;
+
+  Int_t outerarray_size1 = LayerArraySize[layerType - 1][2];
+  Int_t outerarray_size2 = LayerArraySize[layerType - 1][3];
+  const Int_t* outerLayer;
+
+  if (1 == layerType) {
+    innerLayer = (Int_t*) layer1i;
+    outerLayer = (Int_t*) layer1o;
+  } else if (2 == layerType) {
+    innerLayer = (Int_t*) layer2i;
+    outerLayer = (Int_t*) layer2o;
+  } else if (3 == layerType) {
+    innerLayer = (Int_t*) layer3i;
+    outerLayer = (Int_t*) layer3o;
+  } else {
+    std::cout << "Type of layer not known" << std::endl;
+  }
+
+  // add layer keeping volume
+  TString layername = Form("layer%02d", PlaneId[layerId]);
+  TGeoVolume* layer = new TGeoVolumeAssembly(layername);
+
+  // compute layer copy number
+  Int_t i = LayerType[layerId] / 10 * 10000    // 1 digit  // fStation
+            + LayerType[layerId] % 10 * 1000   // 1 digit  // isRotated
+            + LayerNrInStation[layerId] * 100  // 1 digit  // fLayer
+            + PlaneId[layerId];
+  // 2 digits // fPlane   // layer type as leading digit in copy number of layer
+  gGeoMan->GetVolume(geoVersion)->AddNode(layer, i);
+
+  //  Int_t i = 100 + PlaneId[layerId];
+  //  gGeoMan->GetVolume(geoVersion)->AddNode(layer, 1);
+  //  cout << layername << endl;
+
+  Double_t ExplodeScale = 1.00;
+  if (DoExplode)  // if explosion, set scale
+    ExplodeScale = ExplodeFactor;
+
+  Int_t modId = 0;  // module id, only within this layer
+
+  Int_t copyNrIn[4] = {0, 0, 0, 0};  // copy number for each module type
+  for (Int_t type = 1; type <= 4; type++) {
+    for (Int_t j = (innerarray_size1 - 1); j >= 0;
+         j--) {  // start from the bottom
+      for (Int_t i = 0; i < innerarray_size2; i++) {
+        module_id = *(innerLayer + (j * innerarray_size2 + i));
+        if (module_id / 100 == type) {
+          Float_t y = -(j - 4);
+          Float_t x = i - 1.5;
+
+          // displacement
+          Double_t dx = 0;
+          Double_t dy = 0;
+          Double_t dz = 0;
+
+          if (DisplaceRandom) {
+            dx = (r3.Rndm() - .5) * 2 * maxdx;  // max +- 0.1 cm shift
+            dy = (r3.Rndm() - .5) * 2 * maxdy;  // max +- 0.1 cm shift
+            dz = (r3.Rndm() - .5) * 2 * maxdz;  // max +- 1.0 cm shift
+          }
+
+          Double_t xPos = DetectorSizeX[0] * x * ExplodeScale + dx;
+          Double_t yPos = DetectorSizeY[0] * y * ExplodeScale + dy;
+          copyNrIn[type - 1]++;
+          modId++;
+
+          // statistics per layer and module type
+          ModuleStats[layerId][type - 1]++;
+
+          //          Int_t copy = copy_nr_modid(stationNr, layerNrInStation, copyNrIn[type - 1], PlaneId[layerId], modId);  // with modID
+          //          Int_t copy = copy_nr(stationNr, copyNrIn[type - 1], isRotated, PlaneId[layerId], modId);
+
+          // take care of FEB orientation - away from beam
+          Int_t copy = 0;
+          module_rotation =
+            new TGeoRotation();  // need to renew rotation to start from 0 degree angle
+          if (isRotated == 0)  // layer 1,3 ...
+          {
+            copy = copy_nr(stationNr,
+                           copyNrIn[type - 1],
+                           module_id / 10 % 10,
+                           PlaneId[layerId],
+                           modId);
+            module_rotation->RotateZ(
+              (module_id / 10 % 10)
+              * 90.);  // rotate module by   0 or 180 degrees, see layer[1-3][i,o] - vertical pads
+          } else  // layer 2,4 ...
+          {
+            copy = copy_nr(stationNr,
+                           copyNrIn[type - 1],
+                           module_id % 10,
+                           PlaneId[layerId],
+                           modId);
+            module_rotation->RotateZ(
+              (module_id % 10)
+              * 90.);  // rotate module by  90 or 270 degrees, see layer[1-3][i,o] - horizontal pads
+          }
+
+          // rotation
+          Double_t drotx = 0;
+          Double_t droty = 0;
+          Double_t drotz = 0;
+
+          if (RotateRandom) {
+            drotx = (r3.Rndm() - .5) * 2 * maxdrotx;
+            droty = (r3.Rndm() - .5) * 2 * maxdroty;
+            drotz = (r3.Rndm() - .5) * 2 * maxdrotz;
+
+            module_rotation->RotateZ(drotz);
+            module_rotation->RotateY(droty);
+            module_rotation->RotateX(drotx);
+          }
+
+          TGeoCombiTrans* module_placement = new TGeoCombiTrans(
+            xPos,
+            yPos,
+            LayerPosition[layerId] + LayerThickness / 2 + dz,
+            module_rotation);  // shift by half layer thickness
+          //          gGeoMan->GetVolume(geoVersion)->AddNode(gModules[type - 1], copy, module_placement);
+          // add module to layer
+          gGeoMan->GetVolume(layername)->AddNode(
+            gModules[type - 1], copy, module_placement);
+          //
+        }
+      }
+    }
+  }
+
+  Int_t copyNrOut[4] = {0, 0, 0, 0};  // copy number for each module type
+  for (Int_t type = 5; type <= 8; type++) {
+    for (Int_t j = (outerarray_size1 - 1); j >= 0;
+         j--) {  // start from the bottom
+      for (Int_t i = 0; i < outerarray_size2; i++) {
+        module_id = *(outerLayer + (j * outerarray_size2 + i));
+        if (module_id / 100 == type) {
+          Float_t y = -(j - 4);
+          Float_t x = i - 5;
+
+          // displacement
+          Double_t dx = 0;
+          Double_t dy = 0;
+          Double_t dz = 0;
+
+          if (DisplaceRandom) {
+            dx = (r3.Rndm() - .5) * 2 * maxdx;  // max +- 0.1 cm shift
+            dy = (r3.Rndm() - .5) * 2 * maxdy;  // max +- 0.1 cm shift
+            dz = (r3.Rndm() - .5) * 2 * maxdz;  // max +- 1.0 cm shift
+          }
+
+          //          Double_t xPos = DetectorSizeX[1] * x * ExplodeScale + dx;
+          Double_t xPos = 0;
+
+          cout << "x before: " << x;
+          if (x > 0) {
+            x += -2 + 0.5;
+            xPos =
+              2 * DetectorSizeX[0] + DetectorSizeX[1] * x * ExplodeScale + dx;
+          } else {
+            x += +2 - 0.5;
+            xPos =
+              -2 * DetectorSizeX[0] + DetectorSizeX[1] * x * ExplodeScale + dx;
+          }
+          cout << " x after: " << x << endl;
+          Double_t yPos = DetectorSizeY[1] * y * ExplodeScale + dy;
+          copyNrOut[type - 5]++;
+          modId++;
+
+          // statistics per layer and module type
+          ModuleStats[layerId][type - 1]++;
+
+          //          Int_t copy = copy_nr_modid(stationNr, layerNrInStation, copyNrOut[type - 5],  PlaneId[layerId], modId);  // with modID
+          //          Int_t copy = copy_nr(stationNr, copyNrOut[type - 5], isRotated, PlaneId[layerId], modId);
+
+          // take care of FEB orientation - away from beam
+          Int_t copy = 0;
+          module_rotation =
+            new TGeoRotation();  // need to renew rotation to start from 0 degree angle
+          if (isRotated == 0)  // layer 1,3 ...
+          {
+            copy = copy_nr(stationNr,
+                           copyNrOut[type - 5],
+                           module_id / 10 % 10,
+                           PlaneId[layerId],
+                           modId);
+            module_rotation->RotateZ(
+              (module_id / 10 % 10)
+              * 90.);  // rotate module by   0 or 180 degrees, see layer[1-3][i,o] - vertical pads
+          } else  // layer 2,4 ...
+          {
+            copy = copy_nr(stationNr,
+                           copyNrOut[type - 5],
+                           module_id % 10,
+                           PlaneId[layerId],
+                           modId);
+            module_rotation->RotateZ(
+              (module_id % 10)
+              * 90.);  // rotate module by  90 or 270 degrees, see layer[1-3][i,o] - horizontal pads
+          }
+
+          // rotation
+          Double_t drotx = 0;
+          Double_t droty = 0;
+          Double_t drotz = 0;
+
+          if (RotateRandom) {
+            drotx = (r3.Rndm() - .5) * 2 * maxdrotx;
+            droty = (r3.Rndm() - .5) * 2 * maxdroty;
+            drotz = (r3.Rndm() - .5) * 2 * maxdrotz;
+
+            module_rotation->RotateZ(drotz);
+            module_rotation->RotateY(droty);
+            module_rotation->RotateX(drotx);
+          }
+
+          TGeoCombiTrans* module_placement = new TGeoCombiTrans(
+            xPos,
+            yPos,
+            LayerPosition[layerId] + LayerThickness / 2 + dz,
+            module_rotation);  // shift by half layer thickness
+          //          gGeoMan->GetVolume(geoVersion)->AddNode(gModules[type - 1], copy, module_placement);
+          // add module to layer
+          gGeoMan->GetVolume(layername)->AddNode(
+            gModules[type - 1], copy, module_placement);
+          //
+        }
+      }
+    }
+  }
+}
+
+
+void create_mag_field_vector() {
+  const TString cbmfield_01 = "cbm_field";
+  TGeoVolume* cbmfield_1    = new TGeoVolumeAssembly(cbmfield_01);
+
+  TGeoMedium* copperVolMed =
+    gGeoMan->GetMedium(PadCopperVolumeMedium);  // define Volume Medium
+
+  TGeoRotation* rotx090 = new TGeoRotation("rotx090");
+  rotx090->RotateX(90.);  // rotate  90 deg around x-axis
+  TGeoRotation* rotx270 = new TGeoRotation("rotx270");
+  rotx270->RotateX(270.);  // rotate 270 deg around x-axis
+
+  Int_t tube_length = 500;
+  Int_t cone_length = 120;
+  Int_t cone_width  = 280;
+
+  // field tube
+  TGeoTube* trd_field = new TGeoTube("", 0., 100 / 2., tube_length / 2.);
+  TGeoVolume* trdmod1_fieldvol =
+    new TGeoVolume("tube", trd_field, copperVolMed);
+  trdmod1_fieldvol->SetLineColor(kRed);
+  trdmod1_fieldvol->SetTransparency(30);  // transparency for the TRD
+  TGeoTranslation* trd_field_trans =
+    new TGeoTranslation("", 0., 0., 0.);  // tube position
+  cbmfield_1->AddNode(trdmod1_fieldvol, 1, trd_field_trans);
+
+  // field cone
+  TGeoCone* trd_cone =
+    new TGeoCone("", cone_length / 2., 0., cone_width / 2., 0., 0.);
+  TGeoVolume* trdmod1_conevol = new TGeoVolume("cone", trd_cone, copperVolMed);
+  trdmod1_conevol->SetLineColor(kRed);
+  trdmod1_conevol->SetTransparency(30);  // transparency for the TRD
+  TGeoTranslation* trd_cone_trans = new TGeoTranslation(
+    "", 0., 0., (tube_length + cone_length) / 2.);  // cone position
+  cbmfield_1->AddNode(trdmod1_conevol, 1, trd_cone_trans);
+
+  TGeoCombiTrans* field_combi01 =
+    new TGeoCombiTrans(0., 0., 40., rotx270);  // point in +y direction
+  gGeoMan->GetVolume(geoVersion)->AddNode(cbmfield_1, 1, field_combi01);
+
+  //   TGeoCombiTrans* field_combi02 = new TGeoCombiTrans( 200., 0., 0., rotx090);   // point in -y direction
+  //   gGeoMan->GetVolume(geoVersion)->AddNode(cbmfield_1, 2, field_combi02);
+}
+
+
+void create_power_bars_vertical() {
+  const TString power_01 = "power_bars_trd1";
+  TGeoVolume* power_1    = new TGeoVolumeAssembly(power_01);
+
+  TGeoBBox* power1;
+  TGeoBBox* power2;
+
+  TGeoVolume* power1_vol;
+  TGeoVolume* power2_vol;
+
+  TGeoTranslation* power1_trans;
+  TGeoTranslation* power2_trans;
+
+  const Int_t kColor = kBlue;  // bus bar color
+
+  TGeoMedium* powerBusVolMed = gGeoMan->GetMedium(PowerBusVolumeMedium);
+
+  //  // powerbus - horizontal short
+  //  power1     = new TGeoBBox("power1", (DetectorSizeX[1] - DetectorSizeX[0] - powerbar_width)/2., powerbar_width /2., powerbar_thickness /2.);
+  //  power1_vol = new TGeoVolume("powerbus1", power1, powerBusVolMed);
+  //  power1_vol->SetLineColor(kColor);
+  //
+  //  // translations
+  //  power1_trans = new TGeoTranslation("",  1 * (DetectorSizeX[1] - DetectorSizeY[0]/2.),  1.5 * DetectorSizeY[1], 0.);
+  //  power_1->AddNode(power1_vol, 1, power1_trans);
+  //
+  //  power1_trans = new TGeoTranslation("", -1 * (DetectorSizeX[1] - DetectorSizeY[0]/2.), -1.5 * DetectorSizeY[1], 0.);
+  //  power_1->AddNode(power1_vol, 2, power1_trans);
+  //
+  //  // powerbus - horizontal long
+  //  power1     = new TGeoBBox("power1", (DetectorSizeX[0] - powerbar_width)/2., powerbar_width /2., powerbar_thickness /2.);
+  //  power1_vol = new TGeoVolume("powerbus1", power1, powerBusVolMed);
+  //  power1_vol->SetLineColor(kColor);
+  //
+  //  // translations
+  //  power1_trans = new TGeoTranslation("", -1 * DetectorSizeX[0],  1.5 * DetectorSizeY[1], 0.);
+  //  power_1->AddNode(power1_vol, 3, power1_trans);
+  //
+  //  power1_trans = new TGeoTranslation("",  1 * DetectorSizeX[0], -1.5 * DetectorSizeY[1], 0.);
+  //  power_1->AddNode(power1_vol, 4, power1_trans);
+
+
+  // powerbus - vertical long
+  power2     = new TGeoBBox("power2",
+                        powerbar_width / 2.,
+                        (9 * DetectorSizeY[0] + powerbar_width) / 2.,
+                        powerbar_thickness / 2.);
+  power2_vol = new TGeoVolume("powerbus2", power2, powerBusVolMed);
+  power2_vol->SetLineColor(kColor);
+
+  // translations
+  power2_trans = new TGeoTranslation(
+    "", -(2.0 * DetectorSizeX[0] + 1.0 * DetectorSizeX[1]), 0., 0.);
+  power_1->AddNode(power2_vol, 1, power2_trans);
+  power2_trans = new TGeoTranslation(
+    "", 2.0 * DetectorSizeX[0] + 1.0 * DetectorSizeX[1], 0., 0.);
+  power_1->AddNode(power2_vol, 2, power2_trans);
+
+  power2_trans = new TGeoTranslation("", -1.0 * DetectorSizeX[0], 0., 0.);
+  power_1->AddNode(power2_vol, 3, power2_trans);
+  power2_trans = new TGeoTranslation("", 1.0 * DetectorSizeX[0], 0., 0.);
+  power_1->AddNode(power2_vol, 4, power2_trans);
+
+  //  // powerbus - vertical middle
+  //  power2     = new TGeoBBox("power2", powerbar_width /2., (3 * DetectorSizeY[1] + powerbar_width) /2., powerbar_thickness /2.);
+  //  power2_vol = new TGeoVolume("powerbus2", power2, powerBusVolMed);
+  //  power2_vol->SetLineColor(kColor);
+  //
+  //  // translations
+  //  power2_trans = new TGeoTranslation("", -1.5 * DetectorSizeX[0],  0., 0.);
+  //  power_1->AddNode(power2_vol, 7, power2_trans);
+  //  power2_trans = new TGeoTranslation("",  1.5 * DetectorSizeX[0],  0., 0.);
+  //  power_1->AddNode(power2_vol, 8, power2_trans);
+  //
+  //  // powerbus - vertical short 1
+  //  power2     = new TGeoBBox("power2", powerbar_width /2., 1 * DetectorSizeY[1] /2., powerbar_thickness /2.);
+  //  power2_vol = new TGeoVolume("powerbus2", power2, powerBusVolMed);
+  //  power2_vol->SetLineColor(kColor);
+  //  //  power2_vol->SetLineColor(kRed);
+  //
+  //  // translations
+  //  power2_trans = new TGeoTranslation("", -0.5 * DetectorSizeX[1],  (2.0 * DetectorSizeY[1] + powerbar_width/2.), 0.);
+  //  power_1->AddNode(power2_vol, 9, power2_trans);
+  //  power2_trans = new TGeoTranslation("",  0.5 * DetectorSizeX[1], -(2.0 * DetectorSizeY[1] + powerbar_width/2.), 0.);
+  //  power_1->AddNode(power2_vol,10, power2_trans);
+  //
+  //  // powerbus - vertical short 2
+  //  power2     = new TGeoBBox("power2", powerbar_width /2., (1 * DetectorSizeY[1] + powerbar_width) /2., powerbar_thickness /2.);
+  //  power2_vol = new TGeoVolume("powerbus2", power2, powerBusVolMed);
+  //  power2_vol->SetLineColor(kColor);
+  //
+  //  // translations
+  //  power2_trans = new TGeoTranslation("", -0.5 * DetectorSizeX[1], -2.0 * DetectorSizeY[1], 0.);
+  //  power_1->AddNode(power2_vol,11, power2_trans);
+  //  power2_trans = new TGeoTranslation("",  0.5 * DetectorSizeX[1],  2.0 * DetectorSizeY[1], 0.);
+  //  power_1->AddNode(power2_vol,12, power2_trans);
+  //
+  //  // powerbus - vertical short 3
+  //  power2     = new TGeoBBox("power2", powerbar_width /2., (2 * DetectorSizeY[0] + powerbar_width/2.) /2., powerbar_thickness /2.);
+  //  power2_vol = new TGeoVolume("powerbus2", power2, powerBusVolMed);
+  //  power2_vol->SetLineColor(kColor);
+  //
+  //  // translations
+  //  power2_trans = new TGeoTranslation("", -0.5 * DetectorSizeX[0],  (1.5 * DetectorSizeY[0] + powerbar_width/4.), 0.);
+  //  power_1->AddNode(power2_vol,11, power2_trans);
+  //  power2_trans = new TGeoTranslation("",  0.5 * DetectorSizeX[0], -(1.5 * DetectorSizeY[0] + powerbar_width/4.), 0.);
+  //  power_1->AddNode(power2_vol,12, power2_trans);
+
+  Int_t l;
+  for (l = 0; l < 4; l++)
+    if ((ShowLayer[l])
+        && (BusBarOrientation[l] == 1))  // if geometry contains layer l
+    {
+      TString layername                = Form("layer%02d", l + 1);
+      TGeoTranslation* power_placement = new TGeoTranslation(
+        0, 0, LayerPosition[l] + LayerThickness / 2. + powerbar_position);
+      gGeoMan->GetVolume(layername)->AddNode(power_1, l, power_placement);
+    }
+}
+
+
+void create_power_bars_horizontal() {
+  const TString power_01 = "power_bars_trd1";
+  TGeoVolume* power_1    = new TGeoVolumeAssembly(power_01);
+
+  TGeoBBox* power1;
+  TGeoBBox* power2;
+
+  TGeoVolume* power1_vol;
+  TGeoVolume* power2_vol;
+
+  TGeoTranslation* power1_trans;
+  TGeoTranslation* power2_trans;
+
+  const Int_t kColor = kBlue;  // bus bar color
+
+  TGeoMedium* powerBusVolMed = gGeoMan->GetMedium(PowerBusVolumeMedium);
+
+  // powerbus - vertical short
+  power1 =
+    new TGeoBBox("power1",
+                 powerbar_width / 2.,
+                 (DetectorSizeY[1] - DetectorSizeY[0] - powerbar_width) / 2.,
+                 powerbar_thickness / 2.);
+  power1_vol = new TGeoVolume("powerbus1", power1, powerBusVolMed);
+  power1_vol->SetLineColor(kColor);
+
+  // translations
+  power1_trans =
+    new TGeoTranslation("",
+                        1.5 * DetectorSizeX[1],
+                        -1 * (DetectorSizeY[1] - DetectorSizeY[0] / 2.),
+                        0.);
+  power_1->AddNode(power1_vol, 1, power1_trans);
+
+  power1_trans =
+    new TGeoTranslation("",
+                        -1.5 * DetectorSizeX[1],
+                        1 * (DetectorSizeY[1] - DetectorSizeY[0] / 2.),
+                        0.);
+  power_1->AddNode(power1_vol, 2, power1_trans);
+
+  // powerbus - vertical long
+  power1     = new TGeoBBox("power1",
+                        powerbar_width / 2.,
+                        (DetectorSizeY[0] - powerbar_width) / 2.,
+                        powerbar_thickness / 2.);
+  power1_vol = new TGeoVolume("powerbus1", power1, powerBusVolMed);
+  power1_vol->SetLineColor(kColor);
+
+  // translations
+  power1_trans =
+    new TGeoTranslation("", 1.5 * DetectorSizeX[1], 1 * DetectorSizeY[0], 0.);
+  power_1->AddNode(power1_vol, 3, power1_trans);
+
+  power1_trans =
+    new TGeoTranslation("", -1.5 * DetectorSizeX[1], -1 * DetectorSizeY[0], 0.);
+  power_1->AddNode(power1_vol, 4, power1_trans);
+
+
+  // powerbus - horizontal long
+  power2     = new TGeoBBox("power2",
+                        (7 * DetectorSizeX[1] + powerbar_width) / 2.,
+                        powerbar_width / 2.,
+                        powerbar_thickness / 2.);
+  power2_vol = new TGeoVolume("powerbus2", power2, powerBusVolMed);
+  power2_vol->SetLineColor(kColor);
+
+  // translations
+  power2_trans = new TGeoTranslation("", 0., -2.5 * DetectorSizeY[1], 0.);
+  power_1->AddNode(power2_vol, 1, power2_trans);
+  power2_trans = new TGeoTranslation("", 0., 2.5 * DetectorSizeY[1], 0.);
+  power_1->AddNode(power2_vol, 2, power2_trans);
+
+  power2_trans = new TGeoTranslation("", 0., -1.5 * DetectorSizeY[1], 0.);
+  power_1->AddNode(power2_vol, 3, power2_trans);
+  power2_trans = new TGeoTranslation("", 0., 1.5 * DetectorSizeY[1], 0.);
+  power_1->AddNode(power2_vol, 4, power2_trans);
+
+  // powerbus - horizontal middle
+  power2     = new TGeoBBox("power2",
+                        (3 * DetectorSizeX[1] + powerbar_width) / 2.,
+                        powerbar_width / 2.,
+                        powerbar_thickness / 2.);
+  power2_vol = new TGeoVolume("powerbus2", power2, powerBusVolMed);
+  power2_vol->SetLineColor(kColor);
+
+  // translations
+  power2_trans = new TGeoTranslation("", 0., -1.5 * DetectorSizeY[0], 0.);
+  power_1->AddNode(power2_vol, 7, power2_trans);
+  power2_trans = new TGeoTranslation("", 0., 1.5 * DetectorSizeY[0], 0.);
+  power_1->AddNode(power2_vol, 8, power2_trans);
+
+  // powerbus - horizontal short 1
+  power2     = new TGeoBBox("power2",
+                        2 * DetectorSizeX[1] / 2.,
+                        powerbar_width / 2.,
+                        powerbar_thickness / 2.);
+  power2_vol = new TGeoVolume("powerbus2", power2, powerBusVolMed);
+  power2_vol->SetLineColor(kColor);
+  //  power2_vol->SetLineColor(kRed);
+
+  // translations
+  power2_trans =
+    new TGeoTranslation("",
+                        (2.5 * DetectorSizeX[1] + powerbar_width / 2.),
+                        0.5 * DetectorSizeY[1],
+                        0.);
+  power_1->AddNode(power2_vol, 9, power2_trans);
+  power2_trans =
+    new TGeoTranslation("",
+                        -(2.5 * DetectorSizeX[1] + powerbar_width / 2.),
+                        -0.5 * DetectorSizeY[1],
+                        0.);
+  power_1->AddNode(power2_vol, 10, power2_trans);
+
+  // powerbus - horizontal short 2
+  power2     = new TGeoBBox("power2",
+                        (2 * DetectorSizeX[1] + powerbar_width) / 2.,
+                        powerbar_width / 2.,
+                        powerbar_thickness / 2.);
+  power2_vol = new TGeoVolume("powerbus2", power2, powerBusVolMed);
+  power2_vol->SetLineColor(kColor);
+
+  // translations
+  power2_trans = new TGeoTranslation(
+    "", -2.5 * DetectorSizeX[1], 0.5 * DetectorSizeY[1], 0.);
+  power_1->AddNode(power2_vol, 11, power2_trans);
+  power2_trans = new TGeoTranslation(
+    "", 2.5 * DetectorSizeX[1], -0.5 * DetectorSizeY[1], 0.);
+  power_1->AddNode(power2_vol, 12, power2_trans);
+
+  // powerbus - horizontal short 3
+  power2     = new TGeoBBox("power2",
+                        (2 * DetectorSizeX[0] + powerbar_width / 2.) / 2.,
+                        powerbar_width / 2.,
+                        powerbar_thickness / 2.);
+  power2_vol = new TGeoVolume("powerbus2", power2, powerBusVolMed);
+  power2_vol->SetLineColor(kColor);
+
+  // translations
+  power2_trans =
+    new TGeoTranslation("",
+                        (1.5 * DetectorSizeX[0] + powerbar_width / 4.),
+                        0.5 * DetectorSizeY[0],
+                        0.);
+  power_1->AddNode(power2_vol, 11, power2_trans);
+  power2_trans =
+    new TGeoTranslation("",
+                        -(1.5 * DetectorSizeX[0] + powerbar_width / 4.),
+                        -0.5 * DetectorSizeY[0],
+                        0.);
+  power_1->AddNode(power2_vol, 12, power2_trans);
+
+  Int_t l;
+  for (l = 0; l < 4; l++)
+    if ((ShowLayer[l])
+        && (BusBarOrientation[l] == 0))  // if geometry contains layer l
+    {
+      TString layername                = Form("layer%02d", l + 1);
+      TGeoTranslation* power_placement = new TGeoTranslation(
+        0, 0, LayerPosition[l] + LayerThickness / 2. + powerbar_position);
+      gGeoMan->GetVolume(layername)->AddNode(power_1, l, power_placement);
+    }
+}
+
+
+void create_xtru_supports() {
+  const TString trd_01 = "support_trd1";
+  TGeoVolume* trd_1    = new TGeoVolumeAssembly(trd_01);
+
+  const TString trd_02 = "support_trd2";
+  TGeoVolume* trd_2    = new TGeoVolumeAssembly(trd_02);
+
+  const TString trd_03 = "support_trd3";
+  TGeoVolume* trd_3    = new TGeoVolumeAssembly(trd_03);
+
+  //  const TString trdSupport = "supportframe";
+  //  TGeoVolume* trdsupport = new TGeoVolumeAssembly(trdSupport);
+  //
+  //  trdsupport->AddNode(trd_1, 1);
+  //  trdsupport->AddNode(trd_2, 2);
+  //  trdsupport->AddNode(trd_3, 3);
+
+  TGeoMedium* aluminiumVolMed =
+    gGeoMan->GetMedium(AluminiumVolumeMedium);  // define Volume Medium
+
+  const Double_t x[12] = {
+    -15, -15, -1, -1, -15, -15, 15, 15, 1, 1, 15, 15};  // IPB 400
+  const Double_t y[12] = {-20,
+                          -18,
+                          -18,
+                          18,
+                          18,
+                          20,
+                          20,
+                          18,
+                          18,
+                          -18,
+                          -18,
+                          -20};      // 30 x 40 cm in size, 2 cm wall thickness
+  const Double_t Hwid  = -2 * x[0];  // 30
+  const Double_t Hhei  = -2 * y[0];  // 40
+
+  Double_t AperX[3] = {
+    450.,
+    550.,
+    600.};  // inner aperture in X of support structure for stations 1,2,3
+  Double_t AperY[3] = {
+    350.,
+    450.,
+    500.};  // inner aperture in Y of support structure for stations 1,2,3
+  Double_t PilPosX;
+  Double_t BarPosY;
+
+  const Double_t BeamHeight = 570;  // beamline is at 5.7m above floor
+
+  Double_t PilPosZ[6];  // PilPosZ
+                        //  PilPosZ[0] = LayerPosition[0] + LayerThickness/2.;
+                        //  PilPosZ[1] = LayerPosition[3] + LayerThickness/2.;
+                        //  PilPosZ[2] = LayerPosition[4] + LayerThickness/2.;
+                        //  PilPosZ[3] = LayerPosition[7] + LayerThickness/2.;
+                        //  PilPosZ[4] = LayerPosition[8] + LayerThickness/2.;
+                        //  PilPosZ[5] = LayerPosition[9] + LayerThickness/2.;
+
+  PilPosZ[0] = LayerPosition[0] + 15;
+  PilPosZ[1] = LayerPosition[3] - 15 + LayerThickness;
+  PilPosZ[2] = LayerPosition[4] + 15;
+  PilPosZ[3] = LayerPosition[7] - 15 + LayerThickness;
+  PilPosZ[4] = LayerPosition[8] + 15;
+  PilPosZ[5] = LayerPosition[9] - 15 + LayerThickness;
+
+  //  cout << "PilPosZ[0]: " << PilPosZ[0] << endl;
+  //  cout << "PilPosZ[1]: " << PilPosZ[1] << endl;
+
+  TGeoRotation* rotx090 = new TGeoRotation("rotx090");
+  rotx090->RotateX(90.);  // rotate  90 deg around x-axis
+  TGeoRotation* roty090 = new TGeoRotation("roty090");
+  roty090->RotateY(90.);  // rotate  90 deg around y-axis
+  TGeoRotation* rotz090 = new TGeoRotation("rotz090");
+  rotz090->RotateZ(90.);  // rotate  90 deg around y-axis
+  TGeoRotation* roty270 = new TGeoRotation("roty270");
+  roty270->RotateY(270.);  // rotate 270 deg around y-axis
+
+  TGeoRotation* rotzx01 = new TGeoRotation("rotzx01");
+  rotzx01->RotateZ(90.);  // rotate  90 deg around z-axis
+  rotzx01->RotateX(90.);  // rotate  90 deg around x-axis
+
+  //  TGeoRotation  *rotxz01 = new TGeoRotation("rotxz01");
+  //  rotxz01->RotateX(  90.); // rotate  90 deg around x-axis
+  //  rotxz01->RotateZ(  90.); // rotate  90 deg around z-axis
+
+  Double_t ang1 = atan(3. / 4.) * 180. / acos(-1.);
+  //  cout << "DEDE " << ang1 << endl;
+  //  Double_t sin1 = acos(-1.);
+  //  cout << "DEDE " << sin1 << endl;
+  TGeoRotation* rotx080 = new TGeoRotation("rotx080");
+  rotx080->RotateX(90. - ang1);  // rotate  80 deg around x-axis
+  TGeoRotation* rotx100 = new TGeoRotation("rotx100");
+  rotx100->RotateX(90. + ang1);  // rotate 100 deg around x-axis
+
+  TGeoRotation* rotxy01 = new TGeoRotation("rotxy01");
+  rotxy01->RotateX(90.);    // rotate  90 deg around x-axis
+  rotxy01->RotateZ(-ang1);  // rotate  ang1   around rotated y-axis
+
+  TGeoRotation* rotxy02 = new TGeoRotation("rotxy02");
+  rotxy02->RotateX(90.);   // rotate  90 deg around x-axis
+  rotxy02->RotateZ(ang1);  // rotate  ang1   around rotated y-axis
+
+
+  //-------------------
+  // vertical pillars (Y)
+  //-------------------
+
+  // station 1
+  if (ShowLayer[0])  // if geometry contains layer 1 (1st layer of station 1)
+  {
+    TGeoXtru* trd_H_vert1 = new TGeoXtru(2);  // define Xtrusion of 2 planes
+    trd_H_vert1->DefinePolygon(12, x, y);
+    trd_H_vert1->DefineSection(0, -(AperY[0] + Hhei), 0, 0, 1.0);
+    trd_H_vert1->DefineSection(1, BeamHeight, 0, 0, 1.0);
+    TGeoVolume* trd_H_vert_vol1 =
+      new TGeoVolume("trd_H_y_01", trd_H_vert1, aluminiumVolMed);
+    trd_H_vert_vol1->SetLineColor(kYellow);
+    PilPosX = AperX[0];
+
+    TGeoCombiTrans* trd_H_vert_combi01 =
+      new TGeoCombiTrans((PilPosX + Hhei / 2.), 0., PilPosZ[0], rotzx01);
+    trd_1->AddNode(trd_H_vert_vol1, 11, trd_H_vert_combi01);
+    TGeoCombiTrans* trd_H_vert_combi02 =
+      new TGeoCombiTrans(-(PilPosX + Hhei / 2.), 0., PilPosZ[0], rotzx01);
+    trd_1->AddNode(trd_H_vert_vol1, 12, trd_H_vert_combi02);
+    TGeoCombiTrans* trd_H_vert_combi03 =
+      new TGeoCombiTrans((PilPosX + Hhei / 2.), 0., PilPosZ[1], rotzx01);
+    trd_1->AddNode(trd_H_vert_vol1, 13, trd_H_vert_combi03);
+    TGeoCombiTrans* trd_H_vert_combi04 =
+      new TGeoCombiTrans(-(PilPosX + Hhei / 2.), 0., PilPosZ[1], rotzx01);
+    trd_1->AddNode(trd_H_vert_vol1, 14, trd_H_vert_combi04);
+  }
+
+  // station 2
+  if (ShowLayer[4])  // if geometry contains layer 5 (1st layer of station 2)
+  {
+    TGeoXtru* trd_H_vert1 = new TGeoXtru(2);  // define Xtrusion of 2 planes
+    trd_H_vert1->DefinePolygon(12, x, y);
+    trd_H_vert1->DefineSection(0, -(AperY[1] + Hhei), 0, 0, 1.0);
+    trd_H_vert1->DefineSection(1, BeamHeight, 0, 0, 1.0);
+    TGeoVolume* trd_H_vert_vol1 =
+      new TGeoVolume("trd_H_y_02", trd_H_vert1, aluminiumVolMed);
+    trd_H_vert_vol1->SetLineColor(kYellow);
+    PilPosX = AperX[1];
+
+    TGeoCombiTrans* trd_H_vert_combi01 =
+      new TGeoCombiTrans((PilPosX + Hhei / 2.), 0., PilPosZ[2], rotzx01);
+    trd_2->AddNode(trd_H_vert_vol1, 21, trd_H_vert_combi01);
+    TGeoCombiTrans* trd_H_vert_combi02 =
+      new TGeoCombiTrans(-(PilPosX + Hhei / 2.), 0., PilPosZ[2], rotzx01);
+    trd_2->AddNode(trd_H_vert_vol1, 22, trd_H_vert_combi02);
+    TGeoCombiTrans* trd_H_vert_combi03 =
+      new TGeoCombiTrans((PilPosX + Hhei / 2.), 0., PilPosZ[3], rotzx01);
+    trd_2->AddNode(trd_H_vert_vol1, 23, trd_H_vert_combi03);
+    TGeoCombiTrans* trd_H_vert_combi04 =
+      new TGeoCombiTrans(-(PilPosX + Hhei / 2.), 0., PilPosZ[3], rotzx01);
+    trd_2->AddNode(trd_H_vert_vol1, 24, trd_H_vert_combi04);
+  }
+
+  // station 3
+  if (ShowLayer[8])  // if geometry contains layer 9 (1st layer of station 3)
+  {
+    TGeoXtru* trd_H_vert1 = new TGeoXtru(2);  // define Xtrusion of 2 planes
+    trd_H_vert1->DefinePolygon(12, x, y);
+    trd_H_vert1->DefineSection(0, -(AperY[2] + Hhei), 0, 0, 1.0);
+    trd_H_vert1->DefineSection(1, BeamHeight, 0, 0, 1.0);
+    TGeoVolume* trd_H_vert_vol1 =
+      new TGeoVolume("trd_H_y_03", trd_H_vert1, aluminiumVolMed);
+    trd_H_vert_vol1->SetLineColor(kYellow);
+    PilPosX = AperX[2];
+
+    TGeoCombiTrans* trd_H_vert_combi01 =
+      new TGeoCombiTrans((PilPosX + Hhei / 2.), 0., PilPosZ[4], rotzx01);
+    trd_3->AddNode(trd_H_vert_vol1, 31, trd_H_vert_combi01);
+    TGeoCombiTrans* trd_H_vert_combi02 =
+      new TGeoCombiTrans(-(PilPosX + Hhei / 2.), 0., PilPosZ[4], rotzx01);
+    trd_3->AddNode(trd_H_vert_vol1, 32, trd_H_vert_combi02);
+    TGeoCombiTrans* trd_H_vert_combi03 =
+      new TGeoCombiTrans((PilPosX + Hhei / 2.), 0., PilPosZ[5], rotzx01);
+    trd_3->AddNode(trd_H_vert_vol1, 33, trd_H_vert_combi03);
+    TGeoCombiTrans* trd_H_vert_combi04 =
+      new TGeoCombiTrans(-(PilPosX + Hhei / 2.), 0., PilPosZ[5], rotzx01);
+    trd_3->AddNode(trd_H_vert_vol1, 34, trd_H_vert_combi04);
+  }
+
+
+  //-------------------
+  // horizontal supports (X)
+  //-------------------
+
+  // station 1
+  if (ShowLayer[0])  // if geometry contains layer 1 (1st layer of station 1)
+  {
+    TGeoXtru* trd_H_hori1 = new TGeoXtru(2);  // define Xtrusion of 2 planes
+    trd_H_hori1->DefinePolygon(12, x, y);
+    trd_H_hori1->DefineSection(0, -AperX[0], 0, 0, 1.0);
+    trd_H_hori1->DefineSection(1, AperX[0], 0, 0, 1.0);
+    TGeoVolume* trd_H_hori_vol1 =
+      new TGeoVolume("trd_H_x_01", trd_H_hori1, aluminiumVolMed);
+    trd_H_hori_vol1->SetLineColor(kRed);
+    BarPosY = AperY[0];
+
+    TGeoCombiTrans* trd_H_hori_combi01 =
+      new TGeoCombiTrans(0., (BarPosY + Hhei / 2.), PilPosZ[0], roty090);
+    trd_1->AddNode(trd_H_hori_vol1, 11, trd_H_hori_combi01);
+    TGeoCombiTrans* trd_H_hori_combi02 =
+      new TGeoCombiTrans(0., -(BarPosY + Hhei / 2.), PilPosZ[0], roty090);
+    trd_1->AddNode(trd_H_hori_vol1, 12, trd_H_hori_combi02);
+    TGeoCombiTrans* trd_H_hori_combi03 =
+      new TGeoCombiTrans(0., (BarPosY + Hhei / 2.), PilPosZ[1], roty090);
+    trd_1->AddNode(trd_H_hori_vol1, 13, trd_H_hori_combi03);
+    TGeoCombiTrans* trd_H_hori_combi04 =
+      new TGeoCombiTrans(0., -(BarPosY + Hhei / 2.), PilPosZ[1], roty090);
+    trd_1->AddNode(trd_H_hori_vol1, 14, trd_H_hori_combi04);
+  }
+
+  // station 2
+  if (ShowLayer[4])  // if geometry contains layer 5 (1st layer of station 2)
+  {
+    TGeoXtru* trd_H_hori1 = new TGeoXtru(2);  // define Xtrusion of 2 planes
+    trd_H_hori1->DefinePolygon(12, x, y);
+    trd_H_hori1->DefineSection(0, -AperX[1], 0, 0, 1.0);
+    trd_H_hori1->DefineSection(1, AperX[1], 0, 0, 1.0);
+    TGeoVolume* trd_H_hori_vol1 =
+      new TGeoVolume("trd_H_x_02", trd_H_hori1, aluminiumVolMed);
+    trd_H_hori_vol1->SetLineColor(kRed);
+    BarPosY = AperY[1];
+
+    TGeoCombiTrans* trd_H_hori_combi01 =
+      new TGeoCombiTrans(0., (BarPosY + Hhei / 2.), PilPosZ[2], roty090);
+    trd_2->AddNode(trd_H_hori_vol1, 21, trd_H_hori_combi01);
+    TGeoCombiTrans* trd_H_hori_combi02 =
+      new TGeoCombiTrans(0., -(BarPosY + Hhei / 2.), PilPosZ[2], roty090);
+    trd_2->AddNode(trd_H_hori_vol1, 22, trd_H_hori_combi02);
+    TGeoCombiTrans* trd_H_hori_combi03 =
+      new TGeoCombiTrans(0., (BarPosY + Hhei / 2.), PilPosZ[3], roty090);
+    trd_2->AddNode(trd_H_hori_vol1, 23, trd_H_hori_combi03);
+    TGeoCombiTrans* trd_H_hori_combi04 =
+      new TGeoCombiTrans(0., -(BarPosY + Hhei / 2.), PilPosZ[3], roty090);
+    trd_2->AddNode(trd_H_hori_vol1, 24, trd_H_hori_combi04);
+  }
+
+  // station 3
+  if (ShowLayer[8])  // if geometry contains layer 9 (1st layer of station 3)
+  {
+    TGeoXtru* trd_H_hori1 = new TGeoXtru(2);  // define Xtrusion of 2 planes
+    trd_H_hori1->DefinePolygon(12, x, y);
+    trd_H_hori1->DefineSection(0, -AperX[2], 0, 0, 1.0);
+    trd_H_hori1->DefineSection(1, AperX[2], 0, 0, 1.0);
+    TGeoVolume* trd_H_hori_vol1 =
+      new TGeoVolume("trd_H_x_03", trd_H_hori1, aluminiumVolMed);
+    trd_H_hori_vol1->SetLineColor(kRed);
+    BarPosY = AperY[2];
+
+    TGeoCombiTrans* trd_H_hori_combi01 =
+      new TGeoCombiTrans(0., (BarPosY + Hhei / 2.), PilPosZ[4], roty090);
+    trd_3->AddNode(trd_H_hori_vol1, 31, trd_H_hori_combi01);
+    TGeoCombiTrans* trd_H_hori_combi02 =
+      new TGeoCombiTrans(0., -(BarPosY + Hhei / 2.), PilPosZ[4], roty090);
+    trd_3->AddNode(trd_H_hori_vol1, 32, trd_H_hori_combi02);
+    TGeoCombiTrans* trd_H_hori_combi03 =
+      new TGeoCombiTrans(0., (BarPosY + Hhei / 2.), PilPosZ[5], roty090);
+    trd_3->AddNode(trd_H_hori_vol1, 33, trd_H_hori_combi03);
+    TGeoCombiTrans* trd_H_hori_combi04 =
+      new TGeoCombiTrans(0., -(BarPosY + Hhei / 2.), PilPosZ[5], roty090);
+    trd_3->AddNode(trd_H_hori_vol1, 34, trd_H_hori_combi04);
+  }
+
+
+  //-------------------
+  // horizontal supports (Z)
+  //-------------------
+
+  // station 1
+  if (ShowLayer[0])  // if geometry contains layer 1 (1st layer of station 1)
+  {
+    TGeoXtru* trd_H_slope1 = new TGeoXtru(2);  // define Xtrusion of 2 planes
+    trd_H_slope1->DefinePolygon(12, x, y);
+    trd_H_slope1->DefineSection(
+      0, -(PilPosZ[1] - PilPosZ[0] - Hwid) / 2., 0, 0, 1.0);
+    trd_H_slope1->DefineSection(
+      1, +(PilPosZ[1] - PilPosZ[0] - Hwid) / 2., 0, 0, 1.0);
+    TGeoVolume* trd_H_slope_vol1 =
+      new TGeoVolume("trd_H_z_01", trd_H_slope1, aluminiumVolMed);
+    trd_H_slope_vol1->SetLineColor(kGreen);
+    PilPosX = AperX[0];
+    BarPosY = AperY[0];
+
+    TGeoCombiTrans* trd_H_slope_combi01 =
+      new TGeoCombiTrans((PilPosX + Hhei / 2.),
+                         (BarPosY + Hhei - Hwid / 2.),
+                         (PilPosZ[0] + PilPosZ[1]) / 2.,
+                         rotz090);
+    trd_1->AddNode(trd_H_slope_vol1, 11, trd_H_slope_combi01);
+    TGeoCombiTrans* trd_H_slope_combi02 =
+      new TGeoCombiTrans(-(PilPosX + Hhei / 2.),
+                         (BarPosY + Hhei - Hwid / 2.),
+                         (PilPosZ[0] + PilPosZ[1]) / 2.,
+                         rotz090);
+    trd_1->AddNode(trd_H_slope_vol1, 12, trd_H_slope_combi02);
+    TGeoCombiTrans* trd_H_slope_combi03 =
+      new TGeoCombiTrans((PilPosX + Hhei / 2.),
+                         -(BarPosY + Hhei - Hwid / 2.),
+                         (PilPosZ[0] + PilPosZ[1]) / 2.,
+                         rotz090);
+    trd_1->AddNode(trd_H_slope_vol1, 13, trd_H_slope_combi03);
+    TGeoCombiTrans* trd_H_slope_combi04 =
+      new TGeoCombiTrans(-(PilPosX + Hhei / 2.),
+                         -(BarPosY + Hhei - Hwid / 2.),
+                         (PilPosZ[0] + PilPosZ[1]) / 2.,
+                         rotz090);
+    trd_1->AddNode(trd_H_slope_vol1, 14, trd_H_slope_combi04);
+  }
+
+  // station 2
+  if (ShowLayer[4])  // if geometry contains layer 5 (1st layer of station 2)
+  {
+    TGeoXtru* trd_H_slope1 = new TGeoXtru(2);  // define Xtrusion of 2 planes
+    trd_H_slope1->DefinePolygon(12, x, y);
+    trd_H_slope1->DefineSection(
+      0, -(PilPosZ[3] - PilPosZ[2] - Hwid) / 2., 0, 0, 1.0);
+    trd_H_slope1->DefineSection(
+      1, +(PilPosZ[3] - PilPosZ[2] - Hwid) / 2., 0, 0, 1.0);
+    TGeoVolume* trd_H_slope_vol1 =
+      new TGeoVolume("trd_H_z_02", trd_H_slope1, aluminiumVolMed);
+    trd_H_slope_vol1->SetLineColor(kGreen);
+    PilPosX = AperX[1];
+    BarPosY = AperY[1];
+
+    TGeoCombiTrans* trd_H_slope_combi01 =
+      new TGeoCombiTrans((PilPosX + Hhei / 2.),
+                         (BarPosY + Hhei - Hwid / 2.),
+                         (PilPosZ[2] + PilPosZ[3]) / 2.,
+                         rotz090);
+    trd_2->AddNode(trd_H_slope_vol1, 21, trd_H_slope_combi01);
+    TGeoCombiTrans* trd_H_slope_combi02 =
+      new TGeoCombiTrans(-(PilPosX + Hhei / 2.),
+                         (BarPosY + Hhei - Hwid / 2.),
+                         (PilPosZ[2] + PilPosZ[3]) / 2.,
+                         rotz090);
+    trd_2->AddNode(trd_H_slope_vol1, 22, trd_H_slope_combi02);
+    TGeoCombiTrans* trd_H_slope_combi03 =
+      new TGeoCombiTrans((PilPosX + Hhei / 2.),
+                         -(BarPosY + Hhei - Hwid / 2.),
+                         (PilPosZ[2] + PilPosZ[3]) / 2.,
+                         rotz090);
+    trd_2->AddNode(trd_H_slope_vol1, 23, trd_H_slope_combi03);
+    TGeoCombiTrans* trd_H_slope_combi04 =
+      new TGeoCombiTrans(-(PilPosX + Hhei / 2.),
+                         -(BarPosY + Hhei - Hwid / 2.),
+                         (PilPosZ[2] + PilPosZ[3]) / 2.,
+                         rotz090);
+    trd_2->AddNode(trd_H_slope_vol1, 24, trd_H_slope_combi04);
+  }
+
+  // station 3
+  if (ShowLayer[8])  // if geometry contains layer 9 (1st layer of station 3)
+  {
+    TGeoXtru* trd_H_slope1 = new TGeoXtru(2);  // define Xtrusion of 2 planes
+    trd_H_slope1->DefinePolygon(12, x, y);
+    trd_H_slope1->DefineSection(
+      0, -(PilPosZ[5] - PilPosZ[4] - Hwid) / 2., 0, 0, 1.0);
+    trd_H_slope1->DefineSection(
+      1, +(PilPosZ[5] - PilPosZ[4] - Hwid) / 2., 0, 0, 1.0);
+    TGeoVolume* trd_H_slope_vol1 =
+      new TGeoVolume("trd_H_z_03", trd_H_slope1, aluminiumVolMed);
+    trd_H_slope_vol1->SetLineColor(kGreen);
+    PilPosX = AperX[2];
+    BarPosY = AperY[2];
+
+    TGeoCombiTrans* trd_H_slope_combi01 =
+      new TGeoCombiTrans((PilPosX + Hhei / 2.),
+                         (BarPosY + Hhei - Hwid / 2.),
+                         (PilPosZ[4] + PilPosZ[5]) / 2.,
+                         rotz090);
+    trd_3->AddNode(trd_H_slope_vol1, 31, trd_H_slope_combi01);
+    TGeoCombiTrans* trd_H_slope_combi02 =
+      new TGeoCombiTrans(-(PilPosX + Hhei / 2.),
+                         (BarPosY + Hhei - Hwid / 2.),
+                         (PilPosZ[4] + PilPosZ[5]) / 2.,
+                         rotz090);
+    trd_3->AddNode(trd_H_slope_vol1, 32, trd_H_slope_combi02);
+    TGeoCombiTrans* trd_H_slope_combi03 =
+      new TGeoCombiTrans((PilPosX + Hhei / 2.),
+                         -(BarPosY + Hhei - Hwid / 2.),
+                         (PilPosZ[4] + PilPosZ[5]) / 2.,
+                         rotz090);
+    trd_3->AddNode(trd_H_slope_vol1, 33, trd_H_slope_combi03);
+    TGeoCombiTrans* trd_H_slope_combi04 =
+      new TGeoCombiTrans(-(PilPosX + Hhei / 2.),
+                         -(BarPosY + Hhei - Hwid / 2.),
+                         (PilPosZ[4] + PilPosZ[5]) / 2.,
+                         rotz090);
+    trd_3->AddNode(trd_H_slope_vol1, 34, trd_H_slope_combi04);
+  }
+
+  if (IncludeLabels) {
+
+    Int_t text_height    = 40;
+    Int_t text_thickness = 8;
+
+    TGeoTranslation* tr200 =
+      new TGeoTranslation(0.,
+                          (AperY[0] + Hhei + text_height / 2.),
+                          PilPosZ[0] - 15 + text_thickness / 2.);
+    TGeoTranslation* tr201 =
+      new TGeoTranslation(0.,
+                          (AperY[1] + Hhei + text_height / 2.),
+                          PilPosZ[2] - 15 + text_thickness / 2.);
+    TGeoTranslation* tr202 =
+      new TGeoTranslation(0.,
+                          (AperY[2] + Hhei + text_height / 2.),
+                          PilPosZ[4] - 15 + text_thickness / 2.);
+
+    TGeoCombiTrans* tr203 =
+      new TGeoCombiTrans(-(AperX[0] + Hhei + text_thickness / 2.),
+                         (AperY[0] + Hhei - Hwid - text_height / 2.),
+                         (PilPosZ[0] + PilPosZ[1]) / 2.,
+                         roty090);
+    TGeoCombiTrans* tr204 =
+      new TGeoCombiTrans(-(AperX[1] + Hhei + text_thickness / 2.),
+                         (AperY[1] + Hhei - Hwid - text_height / 2.),
+                         (PilPosZ[2] + PilPosZ[3]) / 2.,
+                         roty090);
+    TGeoCombiTrans* tr205 =
+      new TGeoCombiTrans(-(AperX[2] + Hhei + text_thickness / 2.),
+                         (AperY[2] + Hhei - Hwid - text_height / 2.),
+                         (PilPosZ[4] + PilPosZ[5]) / 2.,
+                         roty090);
+
+    TGeoCombiTrans* tr206 =
+      new TGeoCombiTrans((AperX[0] + Hhei + text_thickness / 2.),
+                         (AperY[0] + Hhei - Hwid - text_height / 2.),
+                         (PilPosZ[0] + PilPosZ[1]) / 2.,
+                         roty270);
+    TGeoCombiTrans* tr207 =
+      new TGeoCombiTrans((AperX[1] + Hhei + text_thickness / 2.),
+                         (AperY[1] + Hhei - Hwid - text_height / 2.),
+                         (PilPosZ[2] + PilPosZ[3]) / 2.,
+                         roty270);
+    TGeoCombiTrans* tr208 =
+      new TGeoCombiTrans((AperX[2] + Hhei + text_thickness / 2.),
+                         (AperY[2] + Hhei - Hwid - text_height / 2.),
+                         (PilPosZ[4] + PilPosZ[5]) / 2.,
+                         roty270);
+
+    TGeoVolume* trdbox1 =
+      new TGeoVolumeAssembly("trdbox1");  // volume for TRD text (108, 40, 8)
+    TGeoVolume* trdbox2 =
+      new TGeoVolumeAssembly("trdbox2");  // volume for TRD text (108, 40, 8)
+    TGeoVolume* trdbox3 =
+      new TGeoVolumeAssembly("trdbox3");  // volume for TRD text (108, 40, 8)
+    add_trd_labels(trdbox1, trdbox2, trdbox3);
+
+    // final placement
+    if (ShowLayer[0])  // if geometry contains layer 1 (1st layer of station 1)
+    {
+      //    trd_1->AddNode(trdbox1, 1, tr200);
+      trd_1->AddNode(trdbox1, 4, tr203);
+      trd_1->AddNode(trdbox1, 7, tr206);
+    }
+    if (ShowLayer[4])  // if geometry contains layer 5 (1st layer of station 2)
+    {
+      //    trd_2->AddNode(trdbox2, 2, tr201);
+      trd_2->AddNode(trdbox2, 5, tr204);
+      trd_2->AddNode(trdbox2, 8, tr207);
+    }
+    if (ShowLayer[8])  // if geometry contains layer 9 (1st layer of station 3)
+    {
+      //    trd_3->AddNode(trdbox3, 3, tr202);
+      trd_3->AddNode(trdbox3, 6, tr205);
+      trd_3->AddNode(trdbox3, 9, tr208);
+    }
+  }
+
+  //  gGeoMan->GetVolume(geoVersion)->AddNode(trdsupport,1);
+
+  if (ShowLayer[0])  // if geometry contains layer 1 (1st layer of station 1)
+    gGeoMan->GetVolume(geoVersion)->AddNode(trd_1, 1);
+  if (ShowLayer[4])  // if geometry contains layer 5 (1st layer of station 2)
+    gGeoMan->GetVolume(geoVersion)->AddNode(trd_2, 2);
+  if (ShowLayer[8])  // if geometry contains layer 9 (1st layer of station 3)
+    gGeoMan->GetVolume(geoVersion)->AddNode(trd_3, 3);
+}
+
+
+void add_trd_labels(TGeoVolume* trdbox1,
+                    TGeoVolume* trdbox2,
+                    TGeoVolume* trdbox3) {
+  // write TRD (the 3 characters) in a simple geometry
+  TGeoMedium* textVolMed = gGeoMan->GetMedium(TextVolumeMedium);
+
+  Int_t Tcolor = kBlue;  // kRed;
+  Int_t Rcolor = kBlue;  // kRed;  // kRed;
+  Int_t Dcolor = kBlue;  // kRed;  // kYellow;
+  Int_t Icolor = kBlue;  // kRed;
+
+  // define transformations for letter pieces
+  // T
+  TGeoTranslation* tr01 = new TGeoTranslation(0., -4., 0.);
+  TGeoTranslation* tr02 = new TGeoTranslation(0., 16., 0.);
+
+  // R
+  TGeoTranslation* tr11 = new TGeoTranslation(10, 0., 0.);
+  TGeoTranslation* tr12 = new TGeoTranslation(2, 0., 0.);
+  TGeoTranslation* tr13 = new TGeoTranslation(2, 16., 0.);
+  TGeoTranslation* tr14 = new TGeoTranslation(-2, 8., 0.);
+  TGeoTranslation* tr15 = new TGeoTranslation(-6, 0., 0.);
+
+  // D
+  TGeoTranslation* tr21 = new TGeoTranslation(12., 0., 0.);
+  TGeoTranslation* tr22 = new TGeoTranslation(6., 16., 0.);
+  TGeoTranslation* tr23 = new TGeoTranslation(6., -16., 0.);
+  TGeoTranslation* tr24 = new TGeoTranslation(4., 0., 0.);
+
+  // I
+  TGeoTranslation* tr31 = new TGeoTranslation(0., 0., 0.);
+  TGeoTranslation* tr32 = new TGeoTranslation(0., 16., 0.);
+  TGeoTranslation* tr33 = new TGeoTranslation(0., -16., 0.);
+
+  // make letter T
+  //   TGeoVolume *T = geom->MakeBox("T", Vacuum, 25., 25., 5.);
+  //   T->SetVisibility(kFALSE);
+  TGeoVolume* T = new TGeoVolumeAssembly("Tbox");  // volume for T
+
+  TGeoBBox* Tbar1b  = new TGeoBBox("trd_Tbar1b", 4., 16., 4.);  // | vertical
+  TGeoVolume* Tbar1 = new TGeoVolume("Tbar1", Tbar1b, textVolMed);
+  Tbar1->SetLineColor(Tcolor);
+  T->AddNode(Tbar1, 1, tr01);
+  TGeoBBox* Tbar2b  = new TGeoBBox("trd_Tbar2b", 16, 4., 4.);  // - top
+  TGeoVolume* Tbar2 = new TGeoVolume("Tbar2", Tbar2b, textVolMed);
+  Tbar2->SetLineColor(Tcolor);
+  T->AddNode(Tbar2, 1, tr02);
+
+  // make letter R
+  //   TGeoVolume *R = geom->MakeBox("R", Vacuum, 25., 25., 5.);
+  //   R->SetVisibility(kFALSE);
+  TGeoVolume* R = new TGeoVolumeAssembly("Rbox");  // volume for R
+
+  TGeoBBox* Rbar1b  = new TGeoBBox("trd_Rbar1b", 4., 20, 4.);
+  TGeoVolume* Rbar1 = new TGeoVolume("Rbar1", Rbar1b, textVolMed);
+  Rbar1->SetLineColor(Rcolor);
+  R->AddNode(Rbar1, 1, tr11);
+  TGeoBBox* Rbar2b  = new TGeoBBox("trd_Rbar2b", 4., 4., 4.);
+  TGeoVolume* Rbar2 = new TGeoVolume("Rbar2", Rbar2b, textVolMed);
+  Rbar2->SetLineColor(Rcolor);
+  R->AddNode(Rbar2, 1, tr12);
+  R->AddNode(Rbar2, 2, tr13);
+  TGeoTubeSeg* Rtub1b = new TGeoTubeSeg("trd_Rtub1b", 4., 12, 4., 90., 270.);
+  TGeoVolume* Rtub1 = new TGeoVolume("Rtub1", (TGeoShape*) Rtub1b, textVolMed);
+  Rtub1->SetLineColor(Rcolor);
+  R->AddNode(Rtub1, 1, tr14);
+  TGeoArb8* Rbar3b  = new TGeoArb8("trd_Rbar3b", 4.);
+  TGeoVolume* Rbar3 = new TGeoVolume("Rbar3", Rbar3b, textVolMed);
+  Rbar3->SetLineColor(Rcolor);
+  TGeoArb8* arb = (TGeoArb8*) Rbar3->GetShape();
+  arb->SetVertex(0, 12., -4.);
+  arb->SetVertex(1, 0., -20.);
+  arb->SetVertex(2, -8., -20.);
+  arb->SetVertex(3, 4., -4.);
+  arb->SetVertex(4, 12., -4.);
+  arb->SetVertex(5, 0., -20.);
+  arb->SetVertex(6, -8., -20.);
+  arb->SetVertex(7, 4., -4.);
+  R->AddNode(Rbar3, 1, tr15);
+
+  // make letter D
+  //   TGeoVolume *D = geom->MakeBox("D", Vacuum, 25., 25., 5.);
+  //   D->SetVisibility(kFALSE);
+  TGeoVolume* D = new TGeoVolumeAssembly("Dbox");  // volume for D
+
+  TGeoBBox* Dbar1b  = new TGeoBBox("trd_Dbar1b", 4., 20, 4.);
+  TGeoVolume* Dbar1 = new TGeoVolume("Dbar1", Dbar1b, textVolMed);
+  Dbar1->SetLineColor(Dcolor);
+  D->AddNode(Dbar1, 1, tr21);
+  TGeoBBox* Dbar2b  = new TGeoBBox("trd_Dbar2b", 2., 4., 4.);
+  TGeoVolume* Dbar2 = new TGeoVolume("Dbar2", Dbar2b, textVolMed);
+  Dbar2->SetLineColor(Dcolor);
+  D->AddNode(Dbar2, 1, tr22);
+  D->AddNode(Dbar2, 2, tr23);
+  TGeoTubeSeg* Dtub1b = new TGeoTubeSeg("trd_Dtub1b", 12, 20, 4., 90., 270.);
+  TGeoVolume* Dtub1 = new TGeoVolume("Dtub1", (TGeoShape*) Dtub1b, textVolMed);
+  Dtub1->SetLineColor(Dcolor);
+  D->AddNode(Dtub1, 1, tr24);
+
+  // make letter I
+  TGeoVolume* I = new TGeoVolumeAssembly("Ibox");  // volume for I
+
+  TGeoBBox* Ibar1b  = new TGeoBBox("trd_Ibar1b", 4., 12., 4.);  // | vertical
+  TGeoVolume* Ibar1 = new TGeoVolume("Ibar1", Ibar1b, textVolMed);
+  Ibar1->SetLineColor(Icolor);
+  I->AddNode(Ibar1, 1, tr31);
+  TGeoBBox* Ibar2b  = new TGeoBBox("trd_Ibar2b", 10., 4., 4.);  // - top
+  TGeoVolume* Ibar2 = new TGeoVolume("Ibar2", Ibar2b, textVolMed);
+  Ibar2->SetLineColor(Icolor);
+  I->AddNode(Ibar2, 1, tr32);
+  I->AddNode(Ibar2, 2, tr33);
+
+
+  // build text block "TRD"  <32> + 8 + <28> + 8 + <32> = 108
+
+  //  TGeoBBox *trdboxb = new TGeoBBox("", 108./2, 40./2, 8./2);
+  //  TGeoVolume *trdbox = new TGeoVolume("trdboxb", trdboxb, textVolMed);
+  //  trdbox->SetVisibility(kFALSE);
+
+  //  TGeoVolume* trdbox[0] = new TGeoVolumeAssembly("trdbox1"); // volume for TRD text (108, 40, 8)
+  //  TGeoVolume* trdbox[1] = new TGeoVolumeAssembly("trdbox2"); // volume for TRD text (108, 40, 8)
+  //  TGeoVolume* trdbox[2] = new TGeoVolumeAssembly("trdbox3"); // volume for TRD text (108, 40, 8)
+
+  TGeoTranslation* tr100 = new TGeoTranslation(38., 0., 0.);
+  TGeoTranslation* tr101 = new TGeoTranslation(0., 0., 0.);
+  TGeoTranslation* tr102 = new TGeoTranslation(-38., 0., 0.);
+
+  //  TGeoTranslation *tr103 = new TGeoTranslation( -70., 0., 0.);  // on the same line
+  //  TGeoTranslation *tr104 = new TGeoTranslation( -86., 0., 0.);  // on the same line
+  //  TGeoTranslation *tr105 = new TGeoTranslation(-102., 0., 0.);  // on the same line
+
+  TGeoTranslation* tr110 = new TGeoTranslation(0., -50., 0.);
+  TGeoTranslation* tr111 = new TGeoTranslation(8., -50., 0.);
+  TGeoTranslation* tr112 = new TGeoTranslation(-8., -50., 0.);
+  TGeoTranslation* tr113 = new TGeoTranslation(16., -50., 0.);
+  TGeoTranslation* tr114 = new TGeoTranslation(-16., -50., 0.);
+
+  TGeoTranslation* tr200 = new TGeoTranslation(0., 0., 0.);
+  TGeoTranslation* tr201 = new TGeoTranslation(0., -50., 0.);
+  TGeoTranslation* tr202 = new TGeoTranslation(0., -100., 0.);
+
+  TGeoTranslation* tr210 = new TGeoTranslation(0., -150., 0.);
+  TGeoTranslation* tr213 = new TGeoTranslation(16., -150., 0.);
+  TGeoTranslation* tr214 = new TGeoTranslation(-16., -150., 0.);
+
+  // station 1
+  trdbox1->AddNode(T, 1, tr100);
+  trdbox1->AddNode(R, 1, tr101);
+  trdbox1->AddNode(D, 1, tr102);
+
+  trdbox1->AddNode(I, 1, tr110);
+
+  // station 2
+  trdbox2->AddNode(T, 1, tr100);
+  trdbox2->AddNode(R, 1, tr101);
+  trdbox2->AddNode(D, 1, tr102);
+
+  trdbox2->AddNode(I, 1, tr111);
+  trdbox2->AddNode(I, 2, tr112);
+
+  //// station 3
+  //  trdbox3->AddNode(T, 1, tr100);
+  //  trdbox3->AddNode(R, 1, tr101);
+  //  trdbox3->AddNode(D, 1, tr102);
+  //
+  //  trdbox3->AddNode(I, 1, tr110);
+  //  trdbox3->AddNode(I, 2, tr113);
+  //  trdbox3->AddNode(I, 3, tr114);
+
+  // station 3
+  trdbox3->AddNode(T, 1, tr200);
+  trdbox3->AddNode(R, 1, tr201);
+  trdbox3->AddNode(D, 1, tr202);
+
+  trdbox3->AddNode(I, 1, tr210);
+  trdbox3->AddNode(I, 2, tr213);
+  trdbox3->AddNode(I, 3, tr214);
+
+  //  TGeoScale *sc100 = new TGeoScale( 36./50., 36./50., 1.);  // text is vertical 50 cm, H-bar opening is 36 cm
+  //
+  //  // scale text
+  //  TGeoHMatrix *mat100 = new TGeoHMatrix("");
+  //  TGeoHMatrix *mat101 = new TGeoHMatrix("");
+  //  TGeoHMatrix *mat102 = new TGeoHMatrix("");
+  //  (*mat100) = (*tr100) * (*sc100);
+  //  (*mat101) = (*tr101) * (*sc100);
+  //  (*mat102) = (*tr102) * (*sc100);
+  //
+  //  trdbox->AddNode(T, 1, mat100);
+  //  trdbox->AddNode(R, 1, mat101);
+  //  trdbox->AddNode(D, 1, mat102);
+
+  //   // final placement
+  //   //   TGeoTranslation *tr103 = new TGeoTranslation(0., 400., 500.);
+  //   gGeoMan->GetVolume(geoVersion)->AddNode(trdbox, 1, new TGeoTranslation(0., 400., 500.));
+  //   gGeoMan->GetVolume(geoVersion)->AddNode(trdbox, 2, new TGeoTranslation(0., 500., 600.));
+  //   gGeoMan->GetVolume(geoVersion)->AddNode(trdbox, 3, new TGeoTranslation(0., 600., 700.));
+
+  //  return trdbox;
+}
+
+
+void create_box_supports() {
+  const TString trd_01 = "support_trd1";
+  TGeoVolume* trd_1    = new TGeoVolumeAssembly(trd_01);
+
+  const TString trd_02 = "support_trd2";
+  TGeoVolume* trd_2    = new TGeoVolumeAssembly(trd_02);
+
+  const TString trd_03 = "support_trd3";
+  TGeoVolume* trd_3    = new TGeoVolumeAssembly(trd_03);
+
+  //  const TString trdSupport = "supportframe";
+  //  TGeoVolume* trdsupport = new TGeoVolumeAssembly(trdSupport);
+  //
+  //  trdsupport->AddNode(trd_1, 1);
+  //  trdsupport->AddNode(trd_2, 2);
+  //  trdsupport->AddNode(trd_3, 3);
+
+  TGeoMedium* keepVolMed = gGeoMan->GetMedium(KeepingVolumeMedium);
+  TGeoMedium* aluminiumVolMed =
+    gGeoMan->GetMedium(AluminiumVolumeMedium);  // define Volume Medium
+
+  const Int_t I_height = 40;  // cm // I profile properties
+  const Int_t I_width  = 30;  // cm // I profile properties
+  const Int_t I_thick  = 2;   // cm // I profile properties
+
+  const Double_t BeamHeight     = 570;  // beamline is at 5.7m above the floor
+  const Double_t PlatformHeight = 234;  // platform is   2.34m above the floor
+  const Double_t PlatformOffset = 1;    // distance to platform
+
+  //  Double_t AperX[3] = { 450., 550., 600.};  // 100 cm modules  // inner aperture in X of support structure for stations 1,2,3
+  //  Double_t AperY[3] = { 350., 450., 500.};  // 100 cm modules  // inner aperture in Y of support structure for stations 1,2,3
+
+  const Double_t AperX[3] = {
+    4.5 * DetectorSizeX[1], 5.5 * DetectorSizeX[1], 6 * DetectorSizeX[1]};
+  // inner aperture in X of support structure for stations 1,2,3
+  const Double_t AperY[3] = {
+    3.5 * DetectorSizeY[1], 4.5 * DetectorSizeY[1], 5 * DetectorSizeY[1]};
+  // inner aperture in Y of support structure for stations 1,2,3
+  // platform
+  const Double_t AperYbot[3] = {
+    BeamHeight - (PlatformHeight + PlatformOffset + I_height),
+    4.5 * DetectorSizeY[1],
+    5 * DetectorSizeY[1]};  // inner aperture for station1
+
+  const Double_t xBarPosYtop[3] = {AperY[0] + I_height / 2.,
+                                   AperY[1] + I_height / 2.,
+                                   AperY[2] + I_height / 2.};
+  const Double_t xBarPosYbot[3] = {
+    AperYbot[0] + I_height / 2., xBarPosYtop[1], xBarPosYtop[2]};
+
+  const Double_t zBarPosYtop[3] = {AperY[0] + I_height - I_width / 2.,
+                                   AperY[1] + I_height - I_width / 2.,
+                                   AperY[2] + I_height - I_width / 2.};
+  const Double_t zBarPosYbot[3] = {
+    AperYbot[0] + I_height - I_width / 2., zBarPosYtop[1], zBarPosYtop[2]};
+
+  Double_t PilPosX;
+  Double_t PilPosZ[6];  // PilPosZ
+
+  PilPosZ[0] = LayerPosition[0] + I_width / 2.;
+  PilPosZ[1] = LayerPosition[3] - I_width / 2. + LayerThickness;
+  PilPosZ[2] = LayerPosition[4] + I_width / 2.;
+  PilPosZ[3] = LayerPosition[7] - I_width / 2. + LayerThickness;
+  PilPosZ[4] = LayerPosition[8] + I_width / 2.;
+  PilPosZ[5] = LayerPosition[9] - I_width / 2. + LayerThickness;
+
+  //  cout << "PilPosZ[0]: " << PilPosZ[0] << endl;
+  //  cout << "PilPosZ[1]: " << PilPosZ[1] << endl;
+
+  TGeoRotation* rotx090 = new TGeoRotation("rotx090");
+  rotx090->RotateX(90.);  // rotate  90 deg around x-axis
+  TGeoRotation* roty090 = new TGeoRotation("roty090");
+  roty090->RotateY(90.);  // rotate  90 deg around y-axis
+  TGeoRotation* rotz090 = new TGeoRotation("rotz090");
+  rotz090->RotateZ(90.);  // rotate  90 deg around y-axis
+  TGeoRotation* roty270 = new TGeoRotation("roty270");
+  roty270->RotateY(270.);  // rotate 270 deg around y-axis
+
+  TGeoRotation* rotzx01 = new TGeoRotation("rotzx01");
+  rotzx01->RotateZ(90.);  // rotate  90 deg around z-axis
+  rotzx01->RotateX(90.);  // rotate  90 deg around x-axis
+
+  TGeoRotation* rotzx02 = new TGeoRotation("rotzx02");
+  rotzx02->RotateZ(270.);  // rotate 270 deg around z-axis
+  rotzx02->RotateX(90.);   // rotate  90 deg around x-axis
+
+  Double_t ang1 = atan(3. / 4.) * 180. / acos(-1.);
+  //  cout << "DEDE " << ang1 << endl;
+  //  Double_t sin1 = acos(-1.);
+  //  cout << "DEDE " << sin1 << endl;
+  TGeoRotation* rotx080 = new TGeoRotation("rotx080");
+  rotx080->RotateX(90. - ang1);  // rotate  80 deg around x-axis
+  TGeoRotation* rotx100 = new TGeoRotation("rotx100");
+  rotx100->RotateX(90. + ang1);  // rotate 100 deg around x-axis
+
+  TGeoRotation* rotxy01 = new TGeoRotation("rotxy01");
+  rotxy01->RotateX(90.);    // rotate  90 deg around x-axis
+  rotxy01->RotateZ(-ang1);  // rotate  ang1   around rotated y-axis
+
+  TGeoRotation* rotxy02 = new TGeoRotation("rotxy02");
+  rotxy02->RotateX(90.);   // rotate  90 deg around x-axis
+  rotxy02->RotateZ(ang1);  // rotate  ang1   around rotated y-axis
+
+
+  //-------------------
+  // vertical pillars (Y)
+  //-------------------
+
+  // station 1
+  if (ShowLayer[0])  // if geometry contains layer 1 (1st layer of station 1)
+  {
+    //      TGeoBBox* trd_I_vert1_keep  = new TGeoBBox("", I_thick /2., I_height /2. - I_thick, (BeamHeight + (AperY[0]+I_height) ) /2.);
+    TGeoBBox* trd_I_vert1_keep =
+      new TGeoBBox("trd_I_vert1_keep",
+                   I_thick / 2.,
+                   I_height / 2. - I_thick,
+                   ((AperYbot[0] + I_height) + (AperY[0] + I_height)) / 2.);
+    TGeoVolume* trd_I_vert1 =
+      new TGeoVolume("trd_I_y11", trd_I_vert1_keep, aluminiumVolMed);
+    //      TGeoBBox* trd_I_vert2_keep  = new TGeoBBox("", I_width /2.,            I_thick /2., (BeamHeight + (AperY[0]+I_height) ) /2.);
+    TGeoBBox* trd_I_vert2_keep =
+      new TGeoBBox("trd_I_vert2_keep",
+                   I_width / 2.,
+                   I_thick / 2.,
+                   ((AperYbot[0] + I_height) + (AperY[0] + I_height)) / 2.);
+    TGeoVolume* trd_I_vert2 =
+      new TGeoVolume("trd_I_y12", trd_I_vert2_keep, aluminiumVolMed);
+
+    trd_I_vert1->SetLineColor(kGreen);  // kBlue);  // Yellow);  // kOrange);
+    trd_I_vert2->SetLineColor(kGreen);  // kBlue);  // Yellow);  // kOrange);
+
+    TGeoTranslation* ty01 = new TGeoTranslation("ty01", 0., 0., 0.);
+    TGeoTranslation* ty02 =
+      new TGeoTranslation("ty02", 0., (I_height - I_thick) / 2., 0.);
+    TGeoTranslation* ty03 =
+      new TGeoTranslation("ty03", 0., -(I_height - I_thick) / 2., 0.);
+
+    //      TGeoBBox* trd_I_vert_vol1_keep = new TGeoBBox("", I_width /2., I_height /2., (BeamHeight + (AperY[0]+I_height) ) /2.);
+    TGeoBBox* trd_I_vert_vol1_keep =
+      new TGeoBBox("trd_I_vert_vol1_keep",
+                   I_width / 2.,
+                   I_height / 2.,
+                   ((AperYbot[0] + I_height) + (AperY[0] + I_height)) / 2.);
+    TGeoVolume* trd_I_vert_vol1 =
+      new TGeoVolume("trd_I_y10", trd_I_vert_vol1_keep, keepVolMed);
+
+    // set green color for keeping volume of I profile, seen with gGeoManager->SetVisLevel(2)
+    trd_I_vert_vol1->SetLineColor(kGreen);
+
+    // build I-bar trd_I_vert_vol1
+    trd_I_vert_vol1->AddNode(trd_I_vert1, 1, ty01);
+    trd_I_vert_vol1->AddNode(trd_I_vert2, 2, ty02);
+    trd_I_vert_vol1->AddNode(trd_I_vert2, 3, ty03);
+
+    // close gap to horizontal z-bars
+    TGeoBBox* trd_I_vert3_keep = new TGeoBBox("trd_I_vert3_keep",
+                                              (I_width - I_thick) / 2. / 2.,
+                                              I_height / 2. - I_thick,
+                                              I_thick / 2.);
+    TGeoVolume* trd_I_vert3 =
+      new TGeoVolume("trd_I_y13", trd_I_vert3_keep, aluminiumVolMed);
+    trd_I_vert3->SetLineColor(kGreen);
+    //      TGeoTranslation *ty04 = new TGeoTranslation("ty04",  (I_thick/2. + (I_width-I_thick)/2./2.), 0., -( (AperYbot[0]+I_height) + (AperY[0]+I_height) - I_width) /2.);  // top
+    //      TGeoTranslation *ty05 = new TGeoTranslation("ty05",  (I_thick/2. + (I_width-I_thick)/2./2.), 0.,  ( (AperYbot[0]+I_height) + (AperY[0]+I_height) - I_width) /2.);  // bottom
+    TGeoTranslation* ty04 =
+      new TGeoTranslation("ty04",
+                          (I_thick / 2. + (I_width - I_thick) / 2. / 2.),
+                          0.,
+                          -(zBarPosYbot[0] + zBarPosYtop[0]) / 2.);  // top
+    TGeoTranslation* ty05 =
+      new TGeoTranslation("ty05",
+                          (I_thick / 2. + (I_width - I_thick) / 2. / 2.),
+                          0.,
+                          (zBarPosYbot[0] + zBarPosYtop[0]) / 2.);  // bottom
+    trd_I_vert_vol1->AddNode(trd_I_vert3, 4, ty04);
+    trd_I_vert_vol1->AddNode(trd_I_vert3, 5, ty05);
+
+    PilPosX = AperX[0];
+
+    TGeoCombiTrans* trd_I_vert_combi01 = new TGeoCombiTrans(
+      (PilPosX + I_height / 2.),
+      -((AperYbot[0] + I_height) - (AperY[0] + I_height)) / 2.,
+      PilPosZ[0],
+      rotzx01);
+    trd_1->AddNode(trd_I_vert_vol1, 11, trd_I_vert_combi01);
+    TGeoCombiTrans* trd_I_vert_combi02 = new TGeoCombiTrans(
+      -(PilPosX + I_height / 2.),
+      -((AperYbot[0] + I_height) - (AperY[0] + I_height)) / 2.,
+      PilPosZ[0],
+      rotzx01);
+    trd_1->AddNode(trd_I_vert_vol1, 12, trd_I_vert_combi02);
+    TGeoCombiTrans* trd_I_vert_combi03 = new TGeoCombiTrans(
+      (PilPosX + I_height / 2.),
+      -((AperYbot[0] + I_height) - (AperY[0] + I_height)) / 2.,
+      PilPosZ[1],
+      rotzx02);
+    trd_1->AddNode(trd_I_vert_vol1, 13, trd_I_vert_combi03);
+    TGeoCombiTrans* trd_I_vert_combi04 = new TGeoCombiTrans(
+      -(PilPosX + I_height / 2.),
+      -((AperYbot[0] + I_height) - (AperY[0] + I_height)) / 2.,
+      PilPosZ[1],
+      rotzx02);
+    trd_1->AddNode(trd_I_vert_vol1, 14, trd_I_vert_combi04);
+  }
+
+  // station 2
+  if (ShowLayer[4])  // if geometry contains layer 5 (1st layer of station 2)
+  {
+    TGeoBBox* trd_I_vert1_keep =
+      new TGeoBBox("trd_I_vert1_keep",
+                   I_thick / 2.,
+                   I_height / 2. - I_thick,
+                   (BeamHeight + (AperY[1] + I_height)) / 2.);
+    TGeoVolume* trd_I_vert1 =
+      new TGeoVolume("trd_I_y21", trd_I_vert1_keep, aluminiumVolMed);
+    TGeoBBox* trd_I_vert2_keep =
+      new TGeoBBox("trd_I_vert2_keep",
+                   I_width / 2.,
+                   I_thick / 2.,
+                   (BeamHeight + (AperY[1] + I_height)) / 2.);
+    TGeoVolume* trd_I_vert2 =
+      new TGeoVolume("trd_I_y22", trd_I_vert2_keep, aluminiumVolMed);
+
+    trd_I_vert1->SetLineColor(kGreen);
+    trd_I_vert2->SetLineColor(kGreen);
+
+    TGeoTranslation* ty01 = new TGeoTranslation("ty01", 0., 0., 0.);
+    TGeoTranslation* ty02 =
+      new TGeoTranslation("ty02", 0., (I_height - I_thick) / 2., 0.);
+    TGeoTranslation* ty03 =
+      new TGeoTranslation("ty03", 0., -(I_height - I_thick) / 2., 0.);
+
+    TGeoBBox* trd_I_vert_vol1_keep =
+      new TGeoBBox("trd_I_vert_vol1_keep",
+                   I_width / 2.,
+                   I_height / 2.,
+                   (BeamHeight + (AperY[1] + I_height)) / 2.);
+    TGeoVolume* trd_I_vert_vol1 =
+      new TGeoVolume("trd_I_y20", trd_I_vert_vol1_keep, keepVolMed);
+
+    // set green color for keeping volume of I profile, seen with gGeoManager->SetVisLevel(2)
+    trd_I_vert_vol1->SetLineColor(kGreen);
+
+    // build I-bar trd_I_vert_vol1
+    trd_I_vert_vol1->AddNode(trd_I_vert1, 1, ty01);
+    trd_I_vert_vol1->AddNode(trd_I_vert2, 2, ty02);
+    trd_I_vert_vol1->AddNode(trd_I_vert2, 3, ty03);
+
+    // close gap to horizontal z-bars
+    TGeoBBox* trd_I_vert3_keep = new TGeoBBox("trd_I_vert3_keep",
+                                              (I_width - I_thick) / 2. / 2.,
+                                              I_height / 2. - I_thick,
+                                              I_thick / 2.);
+    TGeoVolume* trd_I_vert3 =
+      new TGeoVolume("trd_I_y23", trd_I_vert3_keep, aluminiumVolMed);
+    trd_I_vert3->SetLineColor(kGreen);
+    TGeoTranslation* ty04 = new TGeoTranslation(
+      "ty04",
+      (I_thick / 2. + (I_width - I_thick) / 2. / 2.),
+      0.,
+      -(BeamHeight + (AperY[1] + I_height) - I_width) / 2.);  // top
+    TGeoTranslation* ty05 = new TGeoTranslation(
+      "ty05",
+      (I_thick / 2. + (I_width - I_thick) / 2. / 2.),
+      0.,
+      -(BeamHeight - (AperY[1] + I_height)) / 2. + zBarPosYbot[1]);  // bottom
+    trd_I_vert_vol1->AddNode(trd_I_vert3, 4, ty04);
+    trd_I_vert_vol1->AddNode(trd_I_vert3, 5, ty05);
+
+    PilPosX = AperX[1];
+
+    TGeoCombiTrans* trd_I_vert_combi01 =
+      new TGeoCombiTrans((PilPosX + I_height / 2.),
+                         -(BeamHeight - (AperY[1] + I_height)) / 2.,
+                         PilPosZ[2],
+                         rotzx01);
+    trd_2->AddNode(trd_I_vert_vol1, 21, trd_I_vert_combi01);
+    TGeoCombiTrans* trd_I_vert_combi02 =
+      new TGeoCombiTrans(-(PilPosX + I_height / 2.),
+                         -(BeamHeight - (AperY[1] + I_height)) / 2.,
+                         PilPosZ[2],
+                         rotzx01);
+    trd_2->AddNode(trd_I_vert_vol1, 22, trd_I_vert_combi02);
+    TGeoCombiTrans* trd_I_vert_combi03 =
+      new TGeoCombiTrans((PilPosX + I_height / 2.),
+                         -(BeamHeight - (AperY[1] + I_height)) / 2.,
+                         PilPosZ[3],
+                         rotzx02);
+    trd_2->AddNode(trd_I_vert_vol1, 23, trd_I_vert_combi03);
+    TGeoCombiTrans* trd_I_vert_combi04 =
+      new TGeoCombiTrans(-(PilPosX + I_height / 2.),
+                         -(BeamHeight - (AperY[1] + I_height)) / 2.,
+                         PilPosZ[3],
+                         rotzx02);
+    trd_2->AddNode(trd_I_vert_vol1, 24, trd_I_vert_combi04);
+  }
+
+  // station 3
+  if (ShowLayer[8])  // if geometry contains layer 9 (1st layer of station 3)
+  {
+    TGeoBBox* trd_I_vert1_keep =
+      new TGeoBBox("trd_I_vert1_keep",
+                   I_thick / 2.,
+                   I_height / 2. - I_thick,
+                   (BeamHeight + (AperY[2] + I_height)) / 2.);
+    TGeoVolume* trd_I_vert1 =
+      new TGeoVolume("trd_I_y31", trd_I_vert1_keep, aluminiumVolMed);
+    TGeoBBox* trd_I_vert2_keep =
+      new TGeoBBox("trd_I_vert2_keep",
+                   I_width / 2.,
+                   I_thick / 2.,
+                   (BeamHeight + (AperY[2] + I_height)) / 2.);
+    TGeoVolume* trd_I_vert2 =
+      new TGeoVolume("trd_I_y32", trd_I_vert2_keep, aluminiumVolMed);
+
+    trd_I_vert1->SetLineColor(kGreen);
+    trd_I_vert2->SetLineColor(kGreen);
+
+    TGeoTranslation* ty01 = new TGeoTranslation("ty01", 0., 0., 0.);
+    TGeoTranslation* ty02 =
+      new TGeoTranslation("ty02", 0., (I_height - I_thick) / 2., 0.);
+    TGeoTranslation* ty03 =
+      new TGeoTranslation("ty03", 0., -(I_height - I_thick) / 2., 0.);
+
+    TGeoBBox* trd_I_vert_vol1_keep =
+      new TGeoBBox("trd_I_vert_vol1_keep",
+                   I_width / 2.,
+                   I_height / 2.,
+                   (BeamHeight + (AperY[2] + I_height)) / 2.);
+    TGeoVolume* trd_I_vert_vol1 =
+      new TGeoVolume("trd_I_y30", trd_I_vert_vol1_keep, keepVolMed);
+
+    // set green color for keeping volume of I profile, seen with gGeoManager->SetVisLevel(2)
+    trd_I_vert_vol1->SetLineColor(kGreen);
+
+    // build I-bar trd_I_vert_vol1
+    trd_I_vert_vol1->AddNode(trd_I_vert1, 1, ty01);
+    trd_I_vert_vol1->AddNode(trd_I_vert2, 2, ty02);
+    trd_I_vert_vol1->AddNode(trd_I_vert2, 3, ty03);
+
+    // close gap to horizontal z-bars
+    TGeoBBox* trd_I_vert3_keep = new TGeoBBox("trd_I_vert3_keep",
+                                              (I_width - I_thick) / 2. / 2.,
+                                              I_height / 2. - I_thick,
+                                              I_thick / 2.);
+    TGeoVolume* trd_I_vert3 =
+      new TGeoVolume("trd_I_y33", trd_I_vert3_keep, aluminiumVolMed);
+    trd_I_vert3->SetLineColor(kGreen);
+    TGeoTranslation* ty04 = new TGeoTranslation(
+      "ty04",
+      (I_thick / 2. + (I_width - I_thick) / 2. / 2.),
+      0.,
+      -(BeamHeight + (AperY[2] + I_height) - I_width) / 2.);  // top
+    TGeoTranslation* ty05 = new TGeoTranslation(
+      "ty05",
+      (I_thick / 2. + (I_width - I_thick) / 2. / 2.),
+      0.,
+      -(BeamHeight - (AperY[2] + I_height)) / 2. + zBarPosYbot[2]);  // bottom
+    trd_I_vert_vol1->AddNode(trd_I_vert3, 4, ty04);
+    trd_I_vert_vol1->AddNode(trd_I_vert3, 5, ty05);
+
+    PilPosX = AperX[2];
+
+    TGeoCombiTrans* trd_I_vert_combi01 =
+      new TGeoCombiTrans((PilPosX + I_height / 2.),
+                         -(BeamHeight - (AperY[2] + I_height)) / 2.,
+                         PilPosZ[4],
+                         rotzx01);
+    trd_3->AddNode(trd_I_vert_vol1, 31, trd_I_vert_combi01);
+    TGeoCombiTrans* trd_I_vert_combi02 =
+      new TGeoCombiTrans(-(PilPosX + I_height / 2.),
+                         -(BeamHeight - (AperY[2] + I_height)) / 2.,
+                         PilPosZ[4],
+                         rotzx01);
+    trd_3->AddNode(trd_I_vert_vol1, 32, trd_I_vert_combi02);
+    TGeoCombiTrans* trd_I_vert_combi03 =
+      new TGeoCombiTrans((PilPosX + I_height / 2.),
+                         -(BeamHeight - (AperY[2] + I_height)) / 2.,
+                         PilPosZ[5],
+                         rotzx02);
+    trd_3->AddNode(trd_I_vert_vol1, 33, trd_I_vert_combi03);
+    TGeoCombiTrans* trd_I_vert_combi04 =
+      new TGeoCombiTrans(-(PilPosX + I_height / 2.),
+                         -(BeamHeight - (AperY[2] + I_height)) / 2.,
+                         PilPosZ[5],
+                         rotzx02);
+    trd_3->AddNode(trd_I_vert_vol1, 34, trd_I_vert_combi04);
+  }
+
+
+  //-------------------
+  // horizontal supports (X)
+  //-------------------
+
+  // station 1
+  if (ShowLayer[0])  // if geometry contains layer 1 (1st layer of station 1)
+  {
+    TGeoBBox* trd_I_hori1_keep = new TGeoBBox(
+      "trd_I_hori1_keep", I_thick / 2., I_height / 2. - I_thick, AperX[0]);
+    TGeoVolume* trd_I_hori1 =
+      new TGeoVolume("trd_I_x11", trd_I_hori1_keep, aluminiumVolMed);
+    TGeoBBox* trd_I_hori2_keep =
+      new TGeoBBox("trd_I_hori2_keep", I_width / 2., I_thick / 2., AperX[0]);
+    TGeoVolume* trd_I_hori2 =
+      new TGeoVolume("trd_I_x12", trd_I_hori2_keep, aluminiumVolMed);
+
+    trd_I_hori1->SetLineColor(kRed);  // Yellow);
+    trd_I_hori2->SetLineColor(kRed);  // Yellow);
+
+    TGeoTranslation* tx01 = new TGeoTranslation("tx01", 0., 0., 0.);
+    TGeoTranslation* tx02 =
+      new TGeoTranslation("tx02", 0., (I_height - I_thick) / 2., 0.);
+    TGeoTranslation* tx03 =
+      new TGeoTranslation("tx03", 0., -(I_height - I_thick) / 2., 0.);
+
+    TGeoBBox* trd_I_hori_vol1_keep = new TGeoBBox(
+      "trd_I_hori_vol1_keep", I_width / 2., I_height / 2., AperX[0]);
+    TGeoVolume* trd_I_hori_vol1 =
+      new TGeoVolume("trd_I_x10", trd_I_hori_vol1_keep, keepVolMed);
+
+    // set red color for keeping volume of I profile, seen with gGeoManager->SetVisLevel(2)
+    trd_I_hori_vol1->SetLineColor(kRed);
+
+    // build I-bar trd_I_hori_vol1
+    trd_I_hori_vol1->AddNode(trd_I_hori1, 1, tx01);
+    trd_I_hori_vol1->AddNode(trd_I_hori2, 2, tx02);
+    trd_I_hori_vol1->AddNode(trd_I_hori2, 3, tx03);
+
+    TGeoCombiTrans* trd_I_hori_combi01 =
+      new TGeoCombiTrans(0., xBarPosYtop[0], PilPosZ[0], roty090);
+    trd_1->AddNode(trd_I_hori_vol1, 11, trd_I_hori_combi01);
+    TGeoCombiTrans* trd_I_hori_combi02 =
+      new TGeoCombiTrans(0., -xBarPosYbot[0], PilPosZ[0], roty090);
+    trd_1->AddNode(trd_I_hori_vol1, 12, trd_I_hori_combi02);
+    TGeoCombiTrans* trd_I_hori_combi03 =
+      new TGeoCombiTrans(0., xBarPosYtop[0], PilPosZ[1], roty090);
+    trd_1->AddNode(trd_I_hori_vol1, 13, trd_I_hori_combi03);
+    TGeoCombiTrans* trd_I_hori_combi04 =
+      new TGeoCombiTrans(0., -xBarPosYbot[0], PilPosZ[1], roty090);
+    trd_1->AddNode(trd_I_hori_vol1, 14, trd_I_hori_combi04);
+  }
+
+  // station 2
+  if (ShowLayer[4])  // if geometry contains layer 5 (1st layer of station 2)
+  {
+    TGeoBBox* trd_I_hori1_keep = new TGeoBBox(
+      "trd_I_hori1_keep", I_thick / 2., I_height / 2. - I_thick, AperX[1]);
+    TGeoVolume* trd_I_hori1 =
+      new TGeoVolume("trd_I_x21", trd_I_hori1_keep, aluminiumVolMed);
+    TGeoBBox* trd_I_hori2_keep =
+      new TGeoBBox("trd_I_hori2_keep", I_width / 2., I_thick / 2., AperX[1]);
+    TGeoVolume* trd_I_hori2 =
+      new TGeoVolume("trd_I_x22", trd_I_hori2_keep, aluminiumVolMed);
+
+    trd_I_hori1->SetLineColor(kRed);
+    trd_I_hori2->SetLineColor(kRed);
+
+    TGeoTranslation* tx01 = new TGeoTranslation("tx01", 0., 0., 0.);
+    TGeoTranslation* tx02 =
+      new TGeoTranslation("tx02", 0., (I_height - I_thick) / 2., 0.);
+    TGeoTranslation* tx03 =
+      new TGeoTranslation("tx03", 0., -(I_height - I_thick) / 2., 0.);
+
+    TGeoBBox* trd_I_hori_vol1_keep = new TGeoBBox(
+      "trd_I_hori_vol1_keep", I_width / 2., I_height / 2., AperX[1]);
+    TGeoVolume* trd_I_hori_vol1 =
+      new TGeoVolume("trd_I_x20", trd_I_hori_vol1_keep, keepVolMed);
+
+    // set red color for keeping volume of I profile, seen with gGeoManager->SetVisLevel(2)
+    trd_I_hori_vol1->SetLineColor(kRed);
+
+    // build I-bar trd_I_hori_vol1
+    trd_I_hori_vol1->AddNode(trd_I_hori1, 1, tx01);
+    trd_I_hori_vol1->AddNode(trd_I_hori2, 2, tx02);
+    trd_I_hori_vol1->AddNode(trd_I_hori2, 3, tx03);
+
+    TGeoCombiTrans* trd_I_hori_combi01 =
+      new TGeoCombiTrans(0., xBarPosYtop[1], PilPosZ[2], roty090);
+    trd_2->AddNode(trd_I_hori_vol1, 21, trd_I_hori_combi01);
+    TGeoCombiTrans* trd_I_hori_combi02 =
+      new TGeoCombiTrans(0., -xBarPosYbot[1], PilPosZ[2], roty090);
+    trd_2->AddNode(trd_I_hori_vol1, 22, trd_I_hori_combi02);
+    TGeoCombiTrans* trd_I_hori_combi03 =
+      new TGeoCombiTrans(0., xBarPosYtop[1], PilPosZ[3], roty090);
+    trd_2->AddNode(trd_I_hori_vol1, 23, trd_I_hori_combi03);
+    TGeoCombiTrans* trd_I_hori_combi04 =
+      new TGeoCombiTrans(0., -xBarPosYbot[1], PilPosZ[3], roty090);
+    trd_2->AddNode(trd_I_hori_vol1, 24, trd_I_hori_combi04);
+  }
+
+  // station 3
+  if (ShowLayer[8])  // if geometry contains layer 9 (1st layer of station 3)
+  {
+    TGeoBBox* trd_I_hori1_keep = new TGeoBBox(
+      "trd_I_hori1_keep", I_thick / 2., I_height / 2. - I_thick, AperX[2]);
+    TGeoVolume* trd_I_hori1 =
+      new TGeoVolume("trd_I_x31", trd_I_hori1_keep, aluminiumVolMed);
+    TGeoBBox* trd_I_hori2_keep =
+      new TGeoBBox("trd_I_hori2_keep", I_width / 2., I_thick / 2., AperX[2]);
+    TGeoVolume* trd_I_hori2 =
+      new TGeoVolume("trd_I_x32", trd_I_hori2_keep, aluminiumVolMed);
+
+    trd_I_hori1->SetLineColor(kRed);
+    trd_I_hori2->SetLineColor(kRed);
+
+    TGeoTranslation* tx01 = new TGeoTranslation("tx01", 0., 0., 0.);
+    TGeoTranslation* tx02 =
+      new TGeoTranslation("tx02", 0., (I_height - I_thick) / 2., 0.);
+    TGeoTranslation* tx03 =
+      new TGeoTranslation("tx03", 0., -(I_height - I_thick) / 2., 0.);
+
+    TGeoBBox* trd_I_hori_vol1_keep = new TGeoBBox(
+      "trd_I_hori_vol1_keep", I_width / 2., I_height / 2., AperX[2]);
+    TGeoVolume* trd_I_hori_vol1 =
+      new TGeoVolume("trd_I_x30", trd_I_hori_vol1_keep, keepVolMed);
+
+    // set red color for keeping volume of I profile, seen with gGeoManager->SetVisLevel(2)
+    trd_I_hori_vol1->SetLineColor(kRed);
+
+    // build I-bar trd_I_hori_vol1
+    trd_I_hori_vol1->AddNode(trd_I_hori1, 1, tx01);
+    trd_I_hori_vol1->AddNode(trd_I_hori2, 2, tx02);
+    trd_I_hori_vol1->AddNode(trd_I_hori2, 3, tx03);
+
+    TGeoCombiTrans* trd_I_hori_combi01 =
+      new TGeoCombiTrans(0., xBarPosYtop[2], PilPosZ[4], roty090);
+    trd_3->AddNode(trd_I_hori_vol1, 31, trd_I_hori_combi01);
+    TGeoCombiTrans* trd_I_hori_combi02 =
+      new TGeoCombiTrans(0., -xBarPosYbot[2], PilPosZ[4], roty090);
+    trd_3->AddNode(trd_I_hori_vol1, 32, trd_I_hori_combi02);
+    TGeoCombiTrans* trd_I_hori_combi03 =
+      new TGeoCombiTrans(0., xBarPosYtop[2], PilPosZ[5], roty090);
+    trd_3->AddNode(trd_I_hori_vol1, 33, trd_I_hori_combi03);
+    TGeoCombiTrans* trd_I_hori_combi04 =
+      new TGeoCombiTrans(0., -xBarPosYbot[2], PilPosZ[5], roty090);
+    trd_3->AddNode(trd_I_hori_vol1, 34, trd_I_hori_combi04);
+  }
+
+
+  //-------------------
+  // horizontal supports (Z)
+  //-------------------
+
+  // station 1
+  if (ShowLayer[0])  // if geometry contains layer 1 (1st layer of station 1)
+  {
+    TGeoBBox* trd_I_slope1_keep =
+      new TGeoBBox("trd_I_slope1_keep",
+                   I_thick / 2.,
+                   I_height / 2. - I_thick,
+                   (PilPosZ[1] - PilPosZ[0] - I_width) / 2.);
+    TGeoVolume* trd_I_slope1 =
+      new TGeoVolume("trd_I_z11", trd_I_slope1_keep, aluminiumVolMed);
+    TGeoBBox* trd_I_slope2_keep =
+      new TGeoBBox("trd_I_slope2_keep",
+                   I_width / 2.,
+                   I_thick / 2.,
+                   (PilPosZ[1] - PilPosZ[0] - I_width) / 2.);
+    TGeoVolume* trd_I_slope2 =
+      new TGeoVolume("trd_I_z12", trd_I_slope2_keep, aluminiumVolMed);
+
+    trd_I_slope1->SetLineColor(kYellow);
+    trd_I_slope2->SetLineColor(kYellow);
+
+    TGeoTranslation* tz01 = new TGeoTranslation("tz01", 0., 0., 0.);
+    TGeoTranslation* tz02 =
+      new TGeoTranslation("tz02", 0., (I_height - I_thick) / 2., 0.);
+    TGeoTranslation* tz03 =
+      new TGeoTranslation("tz03", 0., -(I_height - I_thick) / 2., 0.);
+
+    TGeoBBox* trd_I_slope_vol1_keep =
+      new TGeoBBox("trd_I_slope_vol1_keep",
+                   I_width / 2.,
+                   I_height / 2.,
+                   (PilPosZ[1] - PilPosZ[0] - I_width) / 2.);
+    TGeoVolume* trd_I_slope_vol1 =
+      new TGeoVolume("trd_I_z10", trd_I_slope_vol1_keep, keepVolMed);
+
+    // set yellow color for keeping volume of I profile, seen with gGeoManager->SetVisLevel(2)
+    trd_I_slope_vol1->SetLineColor(kYellow);
+
+    // build I-bar trd_I_slope_vol1
+    trd_I_slope_vol1->AddNode(trd_I_slope1, 1, tz01);
+    trd_I_slope_vol1->AddNode(trd_I_slope2, 2, tz02);
+    trd_I_slope_vol1->AddNode(trd_I_slope2, 3, tz03);
+
+    PilPosX = AperX[0];
+
+    TGeoCombiTrans* trd_I_slope_combi01 =
+      new TGeoCombiTrans((PilPosX + I_height / 2.),
+                         zBarPosYtop[0],
+                         (PilPosZ[0] + PilPosZ[1]) / 2.,
+                         rotz090);
+    trd_1->AddNode(trd_I_slope_vol1, 11, trd_I_slope_combi01);
+    TGeoCombiTrans* trd_I_slope_combi02 =
+      new TGeoCombiTrans(-(PilPosX + I_height / 2.),
+                         zBarPosYtop[0],
+                         (PilPosZ[0] + PilPosZ[1]) / 2.,
+                         rotz090);
+    trd_1->AddNode(trd_I_slope_vol1, 12, trd_I_slope_combi02);
+    TGeoCombiTrans* trd_I_slope_combi03 =
+      new TGeoCombiTrans((PilPosX + I_height / 2.),
+                         -zBarPosYbot[0],
+                         (PilPosZ[0] + PilPosZ[1]) / 2.,
+                         rotz090);
+    trd_1->AddNode(trd_I_slope_vol1, 13, trd_I_slope_combi03);
+    TGeoCombiTrans* trd_I_slope_combi04 =
+      new TGeoCombiTrans(-(PilPosX + I_height / 2.),
+                         -zBarPosYbot[0],
+                         (PilPosZ[0] + PilPosZ[1]) / 2.,
+                         rotz090);
+    trd_1->AddNode(trd_I_slope_vol1, 14, trd_I_slope_combi04);
+  }
+
+  // station 2
+  if (ShowLayer[4])  // if geometry contains layer 5 (1st layer of station 2)
+  {
+    TGeoBBox* trd_I_slope1_keep =
+      new TGeoBBox("trd_I_slope1_keep",
+                   I_thick / 2.,
+                   I_height / 2. - I_thick,
+                   (PilPosZ[3] - PilPosZ[2] - I_width) / 2.);
+    TGeoVolume* trd_I_slope1 =
+      new TGeoVolume("trd_I_z21", trd_I_slope1_keep, aluminiumVolMed);
+    TGeoBBox* trd_I_slope2_keep =
+      new TGeoBBox("trd_I_slope2_keep",
+                   I_width / 2.,
+                   I_thick / 2.,
+                   (PilPosZ[3] - PilPosZ[2] - I_width) / 2.);
+    TGeoVolume* trd_I_slope2 =
+      new TGeoVolume("trd_I_z22", trd_I_slope2_keep, aluminiumVolMed);
+
+    trd_I_slope1->SetLineColor(kYellow);
+    trd_I_slope2->SetLineColor(kYellow);
+
+    TGeoTranslation* tz01 = new TGeoTranslation("tz01", 0., 0., 0.);
+    TGeoTranslation* tz02 =
+      new TGeoTranslation("tz02", 0., (I_height - I_thick) / 2., 0.);
+    TGeoTranslation* tz03 =
+      new TGeoTranslation("tz03", 0., -(I_height - I_thick) / 2., 0.);
+
+    TGeoBBox* trd_I_slope_vol1_keep =
+      new TGeoBBox("trd_I_slope_vol1_keep",
+                   I_width / 2.,
+                   I_height / 2.,
+                   (PilPosZ[3] - PilPosZ[2] - I_width) / 2.);
+    TGeoVolume* trd_I_slope_vol1 =
+      new TGeoVolume("trd_I_z20", trd_I_slope_vol1_keep, keepVolMed);
+
+    // set yellow color for keeping volume of I profile, seen with gGeoManager->SetVisLevel(2)
+    trd_I_slope_vol1->SetLineColor(kYellow);
+
+    // build I-bar trd_I_slope_vol1
+    trd_I_slope_vol1->AddNode(trd_I_slope1, 1, tz01);
+    trd_I_slope_vol1->AddNode(trd_I_slope2, 2, tz02);
+    trd_I_slope_vol1->AddNode(trd_I_slope2, 3, tz03);
+
+    PilPosX = AperX[1];
+
+    TGeoCombiTrans* trd_I_slope_combi01 =
+      new TGeoCombiTrans((PilPosX + I_height / 2.),
+                         zBarPosYtop[1],
+                         (PilPosZ[2] + PilPosZ[3]) / 2.,
+                         rotz090);
+    trd_2->AddNode(trd_I_slope_vol1, 21, trd_I_slope_combi01);
+    TGeoCombiTrans* trd_I_slope_combi02 =
+      new TGeoCombiTrans(-(PilPosX + I_height / 2.),
+                         zBarPosYtop[1],
+                         (PilPosZ[2] + PilPosZ[3]) / 2.,
+                         rotz090);
+    trd_2->AddNode(trd_I_slope_vol1, 22, trd_I_slope_combi02);
+    TGeoCombiTrans* trd_I_slope_combi03 =
+      new TGeoCombiTrans((PilPosX + I_height / 2.),
+                         -zBarPosYbot[1],
+                         (PilPosZ[2] + PilPosZ[3]) / 2.,
+                         rotz090);
+    trd_2->AddNode(trd_I_slope_vol1, 23, trd_I_slope_combi03);
+    TGeoCombiTrans* trd_I_slope_combi04 =
+      new TGeoCombiTrans(-(PilPosX + I_height / 2.),
+                         -zBarPosYbot[1],
+                         (PilPosZ[2] + PilPosZ[3]) / 2.,
+                         rotz090);
+    trd_2->AddNode(trd_I_slope_vol1, 24, trd_I_slope_combi04);
+  }
+
+  // station 3
+  if (ShowLayer[8])  // if geometry contains layer 9 (1st layer of station 3)
+  {
+    TGeoBBox* trd_I_slope1_keep =
+      new TGeoBBox("trd_I_slope1_keep",
+                   I_thick / 2.,
+                   I_height / 2. - I_thick,
+                   (PilPosZ[5] - PilPosZ[4] - I_width) / 2.);
+    TGeoVolume* trd_I_slope1 =
+      new TGeoVolume("trd_I_z31", trd_I_slope1_keep, aluminiumVolMed);
+    TGeoBBox* trd_I_slope2_keep =
+      new TGeoBBox("trd_I_slope2_keep",
+                   I_width / 2.,
+                   I_thick / 2.,
+                   (PilPosZ[5] - PilPosZ[4] - I_width) / 2.);
+    TGeoVolume* trd_I_slope2 =
+      new TGeoVolume("trd_I_z32", trd_I_slope2_keep, aluminiumVolMed);
+
+    trd_I_slope1->SetLineColor(kYellow);
+    trd_I_slope2->SetLineColor(kYellow);
+
+    TGeoTranslation* tz01 = new TGeoTranslation("tz01", 0., 0., 0.);
+    TGeoTranslation* tz02 =
+      new TGeoTranslation("tz02", 0., (I_height - I_thick) / 2., 0.);
+    TGeoTranslation* tz03 =
+      new TGeoTranslation("tz03", 0., -(I_height - I_thick) / 2., 0.);
+
+    TGeoBBox* trd_I_slope_vol1_keep =
+      new TGeoBBox("trd_I_slope_vol1_keep",
+                   I_width / 2.,
+                   I_height / 2.,
+                   (PilPosZ[5] - PilPosZ[4] - I_width) / 2.);
+    TGeoVolume* trd_I_slope_vol1 =
+      new TGeoVolume("trd_I_z30", trd_I_slope_vol1_keep, keepVolMed);
+
+    // set yellow color for keeping volume of I profile, seen with gGeoManager->SetVisLevel(2)
+    trd_I_slope_vol1->SetLineColor(kYellow);
+
+    // build I-bar trd_I_slope_vol1
+    trd_I_slope_vol1->AddNode(trd_I_slope1, 1, tz01);
+    trd_I_slope_vol1->AddNode(trd_I_slope2, 2, tz02);
+    trd_I_slope_vol1->AddNode(trd_I_slope2, 3, tz03);
+
+    PilPosX = AperX[2];
+
+    TGeoCombiTrans* trd_I_slope_combi01 =
+      new TGeoCombiTrans((PilPosX + I_height / 2.),
+                         zBarPosYtop[2],
+                         (PilPosZ[4] + PilPosZ[5]) / 2.,
+                         rotz090);
+    trd_3->AddNode(trd_I_slope_vol1, 31, trd_I_slope_combi01);
+    TGeoCombiTrans* trd_I_slope_combi02 =
+      new TGeoCombiTrans(-(PilPosX + I_height / 2.),
+                         zBarPosYtop[2],
+                         (PilPosZ[4] + PilPosZ[5]) / 2.,
+                         rotz090);
+    trd_3->AddNode(trd_I_slope_vol1, 32, trd_I_slope_combi02);
+    TGeoCombiTrans* trd_I_slope_combi03 =
+      new TGeoCombiTrans((PilPosX + I_height / 2.),
+                         -zBarPosYbot[2],
+                         (PilPosZ[4] + PilPosZ[5]) / 2.,
+                         rotz090);
+    trd_3->AddNode(trd_I_slope_vol1, 33, trd_I_slope_combi03);
+    TGeoCombiTrans* trd_I_slope_combi04 =
+      new TGeoCombiTrans(-(PilPosX + I_height / 2.),
+                         -zBarPosYbot[2],
+                         (PilPosZ[4] + PilPosZ[5]) / 2.,
+                         rotz090);
+    trd_3->AddNode(trd_I_slope_vol1, 34, trd_I_slope_combi04);
+  }
+
+  if (IncludeLabels) {
+
+    Int_t text_height    = 40;
+    Int_t text_thickness = 8;
+
+    TGeoTranslation* tr200 =
+      new TGeoTranslation(0.,
+                          (AperY[0] + I_height + text_height / 2.),
+                          PilPosZ[0] - I_width / 2. + text_thickness / 2.);
+    TGeoTranslation* tr201 =
+      new TGeoTranslation(0.,
+                          (AperY[1] + I_height + text_height / 2.),
+                          PilPosZ[2] - I_width / 2. + text_thickness / 2.);
+    TGeoTranslation* tr202 =
+      new TGeoTranslation(0.,
+                          (AperY[2] + I_height + text_height / 2.),
+                          PilPosZ[4] - I_width / 2. + text_thickness / 2.);
+
+    TGeoCombiTrans* tr203 =
+      new TGeoCombiTrans(-(AperX[0] + I_height + text_thickness / 2.),
+                         (AperY[0] + I_height - I_width - text_height / 2.),
+                         (PilPosZ[0] + PilPosZ[1]) / 2.,
+                         roty090);
+    TGeoCombiTrans* tr204 =
+      new TGeoCombiTrans(-(AperX[1] + I_height + text_thickness / 2.),
+                         (AperY[1] + I_height - I_width - text_height / 2.),
+                         (PilPosZ[2] + PilPosZ[3]) / 2.,
+                         roty090);
+    TGeoCombiTrans* tr205 =
+      new TGeoCombiTrans(-(AperX[2] + I_height + text_thickness / 2.),
+                         (AperY[2] + I_height - I_width - text_height / 2.),
+                         (PilPosZ[4] + PilPosZ[5]) / 2.,
+                         roty090);
+
+    TGeoCombiTrans* tr206 =
+      new TGeoCombiTrans((AperX[0] + I_height + text_thickness / 2.),
+                         (AperY[0] + I_height - I_width - text_height / 2.),
+                         (PilPosZ[0] + PilPosZ[1]) / 2.,
+                         roty270);
+    TGeoCombiTrans* tr207 =
+      new TGeoCombiTrans((AperX[1] + I_height + text_thickness / 2.),
+                         (AperY[1] + I_height - I_width - text_height / 2.),
+                         (PilPosZ[2] + PilPosZ[3]) / 2.,
+                         roty270);
+    TGeoCombiTrans* tr208 =
+      new TGeoCombiTrans((AperX[2] + I_height + text_thickness / 2.),
+                         (AperY[2] + I_height - I_width - text_height / 2.),
+                         (PilPosZ[4] + PilPosZ[5]) / 2.,
+                         roty270);
+
+    TGeoVolume* trdbox1 =
+      new TGeoVolumeAssembly("trdbox1");  // volume for TRD text (108, 40, 8)
+    TGeoVolume* trdbox2 =
+      new TGeoVolumeAssembly("trdbox2");  // volume for TRD text (108, 40, 8)
+    TGeoVolume* trdbox3 =
+      new TGeoVolumeAssembly("trdbox3");  // volume for TRD text (108, 40, 8)
+    add_trd_labels(trdbox1, trdbox2, trdbox3);
+
+    // final placement
+    if (ShowLayer[0])  // if geometry contains layer 1 (1st layer of station 1)
+    {
+      //    trd_1->AddNode(trdbox1, 1, tr200);
+      trd_1->AddNode(trdbox1, 4, tr203);
+      trd_1->AddNode(trdbox1, 7, tr206);
+    }
+    if (ShowLayer[4])  // if geometry contains layer 5 (1st layer of station 2)
+    {
+      //    trd_2->AddNode(trdbox2, 2, tr201);
+      trd_2->AddNode(trdbox2, 5, tr204);
+      trd_2->AddNode(trdbox2, 8, tr207);
+    }
+    if (ShowLayer[8])  // if geometry contains layer 9 (1st layer of station 3)
+    {
+      //    trd_3->AddNode(trdbox3, 3, tr202);
+      trd_3->AddNode(trdbox3, 6, tr205);
+      trd_3->AddNode(trdbox3, 9, tr208);
+    }
+  }
+
+  if (ShowLayer[0])  // if geometry contains layer 1 (1st layer of station 1)
+    gGeoMan->GetVolume(geoVersion)->AddNode(trd_1, 1);
+  if (ShowLayer[4])  // if geometry contains layer 5 (1st layer of station 2)
+    gGeoMan->GetVolume(geoVersion)->AddNode(trd_2, 2);
+  if (ShowLayer[8])  // if geometry contains layer 9 (1st layer of station 3)
+    gGeoMan->GetVolume(geoVersion)->AddNode(trd_3, 3);
+}