/* Copyright (C) 2021 Facitity for antiproton and ion Research in Europe, Darmstadt SPDX-License-Identifier: GPL-3.0-only: Authors: Pascal Raisig, Eoin Clerkin [committer] */ /// /// \file Create_TRD_Geometry_v23c.C /// \brief Generates TRD geometry in Root format. /// // 2023-05-25 - OS - v23c - Add support structure from CAD file (using GDML) // 2021-12-15 - EC - v20c - same as v20b but positioning relative to the center of the magnet // 2020-10-20 - PR - v20b - put TRD layers at z-startposition according to 17n/18a, only sis100_hadron at 410 instead of 260 (260 should not be possible due to rail construction) // 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 "TGeoArb8.h" #include "TGeoCompositeShape.h" #include "TGeoCone.h" #include "TGeoManager.h" #include "TGeoMaterial.h" #include "TGeoMatrix.h" #include "TGeoMedium.h" #include "TGeoPgon.h" #include "TGeoTube.h" #include "TGeoVolume.h" #include "TGeoXtru.h" #include "TList.h" #include "TRandom3.h" #include "TString.h" #include "TSystem.h" #include // Name of output file with geometry const TString tagVersion = "v23c"; //const TString subVersion = "_1h"; //const TString subVersion = "_1e"; //const TString subVersion = "_1m"; //const TString subVersion = "_3e"; //const TString subVersion = "_3m"; const Int_t setupid = 0; // 1e is the default //const Double_t zfront[5] = { 260., 410., 360., 410., 550. }; // original const Double_t zfront[5] = {370., // SIS100 hadron 370., // SIS100 electron 450., // SIS100 muon 370., 510.}; // 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"; //Support Structure const Bool_t IncludeMainFrame = true; const Bool_t IncludeSecondaryFrame = true; const Bool_t IncludeTragwerkBlock = true; const Bool_t IncludeCenterSupport = true; // 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_v20b(const Int_t setupid = 1) { void Create_TRD_Geometry_v23c() { // 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, "s"); 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(); // Convert to VecGeom tessellated solid auto converter = TVirtualGeoConverter::Instance(gGeoManager); if (!converter) { printf("Raytracing a tessellated shape without VecGeom support will just draw a box\n"); } else { converter->ConvertGeometry(); } top->Draw("ogl"); top->RandomPoints(10000000,""); // 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() { TGeoMaterial* material; TGeoMedium* aluminiumVolMed = gGeoMan->GetMedium(AluminiumVolumeMedium); // define Volume Medium // main frame supoort //------------------------------------------------------------------------- if (IncludeMainFrame) { TGeoVolume* trd_main_support = new TGeoVolumeAssembly("mainframe"); TFile* _file = new TFile("mainframe.root"); TGeoVolume* mainframe_vol = (TGeoVolume*) _file->Get("mainframe"); TObjArray* nodesArr_mainframe = mainframe_vol->GetNodes(); for (int iNode = 0; iNode < nodesArr_mainframe->GetEntriesFast(); iNode++) { TGeoNode* fNode = (TGeoNode*) nodesArr_mainframe->At(iNode); TGeoVolume* fVol = (TGeoVolume*) fNode->GetVolume(); fVol->SetMedium(aluminiumVolMed); fVol->SetLineColor(kRed); material = fVol->GetMaterial(); // material->Print(); trd_main_support->AddNode(fVol, iNode, 0); } //trd_support->AddNode(trd_main_support, 0, new TGeoTranslation(0, -312.48, 255.15)); gGeoMan->GetVolume(geoVersion)->AddNode(trd_main_support, 0, new TGeoTranslation(0, -312.48, 255.15)); } // secondary frame support TGeoVolume* trd_secondary_support = new TGeoVolumeAssembly("secondary_frame"); TFile* _file = new TFile("secondary_frame.root"); TGeoVolume* secondaryframe_vol = (TGeoVolume*) _file->Get("secondary_frame"); TObjArray* nodesArr_secondaryframe = secondaryframe_vol->GetNodes(); for (int iNode = 0; iNode < nodesArr_secondaryframe->GetEntriesFast(); iNode++) { TGeoNode* fNode = (TGeoNode*) nodesArr_secondaryframe->At(iNode); TGeoVolume* fVol = (TGeoVolume*) fNode->GetVolume(); fVol->SetMedium(aluminiumVolMed); fVol->SetLineColor(kBlue); material = fVol->GetMaterial(); // material->Print(); trd_secondary_support->AddNode(fVol, iNode, 0); } TGeoRotation* r1 = new TGeoRotation("r1"); r1->RotateY(180.); Double_t startZ = 42.15; for (int iLayer = 0; iLayer < 4; iLayer++){ TString layername = Form("layer%02d", iLayer + 1); TGeoTranslation* trans = new TGeoTranslation(-1.927, -11.507, startZ + iLayer*LayerThickness); TGeoHMatrix* incline_mod = new TGeoHMatrix(""); (*incline_mod) = (*trans) * (*r1); gGeoMan->GetVolume(layername)->AddNode(trd_secondary_support, iLayer, incline_mod); } // tragwerk block //---------------------------------------------------------------------- if (IncludeTragwerkBlock) { TGeoVolume* tragwek_side_right = new TGeoVolumeAssembly("tragwerk_block_right"); TGeoVolume* tragwek_side_left = new TGeoVolumeAssembly("tragwerk_block_left"); TFile* _file = new TFile("tragwerk_block.root"); TGeoVolume* tragwerk_vol = (TGeoVolume*) _file->Get("tragwerk_block"); TObjArray* nodesArr_tragwerk = tragwerk_vol->GetNodes(); for (int iNode = 0; iNode < nodesArr_tragwerk->GetEntriesFast(); iNode++) { TGeoNode* fNode = (TGeoNode*) nodesArr_tragwerk->At(iNode); TGeoVolume* fVol = (TGeoVolume*) fNode->GetVolume(); fVol->SetMedium(aluminiumVolMed); fVol->SetLineColor(kMagenta); material = fVol->GetMaterial(); // material->Print(); tragwek_side_left->AddNode(fVol, iNode, 0); tragwek_side_right->AddNode(fVol, iNode + nodesArr_tragwerk->GetEntriesFast(), 0); } TGeoRotation* rot_tragwerk = new TGeoRotation("tragwerk"); rot_tragwerk->RotateX(-90); Double_t startZ_tragwerk = 41.429; for (int iLayer = 0; iLayer < 4; iLayer++){ TString layername = Form("layer%02d", iLayer + 1); // right side placement TGeoTranslation* trans_right = new TGeoTranslation(213.75, 0, startZ_tragwerk + iLayer*LayerThickness); TGeoHMatrix* incline_mod_right = new TGeoHMatrix(""); (*incline_mod_right) = (*trans_right) * (*rot_tragwerk); // left side placement TGeoTranslation* trans_left = new TGeoTranslation(-213.75, 0, startZ_tragwerk + iLayer*LayerThickness); TGeoHMatrix* incline_mod_left = new TGeoHMatrix(""); (*incline_mod_left) = (*trans_left) * (*rot_tragwerk); gGeoMan->GetVolume(layername)->AddNode(tragwek_side_right, iLayer, incline_mod_right); gGeoMan->GetVolume(layername)->AddNode(tragwek_side_left, iLayer, incline_mod_left); } } // Center support //-------------------------------------------------------------------------- if (IncludeCenterSupport) { TGeoVolume* trd_center_support = new TGeoVolumeAssembly("support_center"); TFile* _file = new TFile("support_center.root"); TGeoVolume* centersupport_vol = (TGeoVolume*) _file->Get("support_center"); TObjArray* nodesArr_center = centersupport_vol->GetNodes(); for (int iNode = 0; iNode < nodesArr_center->GetEntriesFast(); iNode++) { TGeoNode* fNode = (TGeoNode*) nodesArr_center->At(iNode); TGeoVolume* fVol = (TGeoVolume*) fNode->GetVolume(); fVol->SetMedium(aluminiumVolMed); fVol->SetLineColor(kMagenta); material = fVol->GetMaterial(); // material->Print(); trd_center_support->AddNode(fVol, iNode, 0); } TGeoRotation* rot_centersupport = new TGeoRotation("rot_centersupport"); rot_centersupport->RotateX(180); Double_t startZ_centersupport = 65.66; for (int iLayer = 0; iLayer < 4; iLayer++){ TString layername = Form("layer%02d", iLayer + 1); TGeoTranslation* trans = new TGeoTranslation(0., 262.6, startZ_centersupport + iLayer*LayerThickness); TGeoHMatrix* incline_mod = new TGeoHMatrix(""); (*incline_mod) = (*trans) * (*rot_centersupport); gGeoMan->GetVolume(layername)->AddNode(trd_center_support, iLayer, incline_mod); } } }