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); +}