From 0e10fe6e3036e6f188c4aa4ff88cb54490c3c86e Mon Sep 17 00:00:00 2001
From: David Emschermann <d.emschermann@gsi.de>
Date: Tue, 30 Apr 2024 15:44:04 +0200
Subject: [PATCH] [squashed] mTOF geometry v24d
- Introduce TOF geometry macro provided by Ingo Deppner
- Add TOF v24d geometry binaries, provided by Ingo Deppner
- In TOF v24d, fix Z position of odd and even RPCs in module type 0 (17-18/06/2024)
- Made reproducible
---
.../tof/mcbm/Create_TOF_Geometry_v24d_mcbm.C | 1326 +++++++++++++++++
tof/tof_v24d_mcbm.geo.info | 15 +
tof/tof_v24d_mcbm.geo.root | Bin 0 -> 12943 bytes
3 files changed, 1341 insertions(+)
create mode 100644 macro/tof/mcbm/Create_TOF_Geometry_v24d_mcbm.C
create mode 100644 tof/tof_v24d_mcbm.geo.info
create mode 100644 tof/tof_v24d_mcbm.geo.root
diff --git a/macro/tof/mcbm/Create_TOF_Geometry_v24d_mcbm.C b/macro/tof/mcbm/Create_TOF_Geometry_v24d_mcbm.C
new file mode 100644
index 0000000..0fb5386
--- /dev/null
+++ b/macro/tof/mcbm/Create_TOF_Geometry_v24d_mcbm.C
@@ -0,0 +1,1326 @@
+/* Copyright (C) 2024 GSI Helmholtzzentrum fuer Schwerionenforschung, Darmstadt
+ SPDX-License-Identifier: GPL-3.0-only
+ Authors: Florian Uhlig, Ingo Deppner [committer], A. Bercuci */
+
+///
+/// \file Create_TOF_Geometry_v24d_mcbm.C
+/// \brief Generates TOF geometry in Root format.
+///
+
+// Changelog
+// 2024-06-17 - v24d - AB - Fix Z position of odd and even RPCs in module type 0
+// 2024-04-30 - v24d - ID - Add 2nd downstream wall of TOF modules
+// 2024-03-26 - v24b - DE - Shifted in z to position measured in the cave
+// 2024-03-26 - v24a - DE - March 2024 setup by NH, script patched by DE in lines 1000 and 1004 to show only 2 STAR modules
+// 2021-11-17 - v24a - QZ - Modified v20d to fit the logic of digibdf.par
+// 2020-04-14 - v20b - NH - swapped double stack layer 2 with STAR2 moodule, buc kept as dummy
+// 2020-04-01 - v20a - NH - move mTOF +20 cm in x direction for the Mar 2020 run
+// 2019-11-28 - v19b - DE - move mTOF +12 cm in x direction for the Nov 2019 run
+// 2019-07-31 - v19a - DE - this TOF March 2019 geometry is also known as v18m
+// 2017-11-03 - v18i - DE - shift mTOF to z=298 cm for acceptance matching with mSTS
+// 2017-10-06 - v18h - DE - put v18f into vertical position to fit into the mCBM cave
+// 2017-07-15 - v18g - DE - swap the z-position of TOF modules: 2 in the front, 3 in the back
+// 2017-07-14 - v18f - DE - reduce vertical gap between TOF modules to fix the gap between modules 1-2 and 4-5
+// 2017-05-17 - v18e - DE - rotate electronics away from beam, shift 16 cm away from beam along x-axis
+// 2017-05-17 - v18d - DE - change geometry name to v18d
+
+// in root all sizes are given in cm
+
+#include "TFile.h"
+#include "TGeoCompositeShape.h"
+#include "TGeoManager.h"
+#include "TGeoMaterial.h"
+#include "TGeoMatrix.h"
+#include "TGeoMedium.h"
+#include "TGeoPgon.h"
+#include "TGeoVolume.h"
+#include "TList.h"
+#include "TMath.h"
+#include "TROOT.h"
+#include "TString.h"
+#include "TSystem.h"
+
+#include <iostream>
+
+// Name of geometry version and output file
+const TString geoVersion = "tof_v24d_mcbm"; // do not change
+const TString geoVersionStand = geoVersion + "Stand";
+//
+const TString fileTag = "tof_v24d";
+const TString FileNameSim = fileTag + "_mcbm.geo.root?reproducible";
+const TString FileNameGeo = fileTag + "_mcbm_geo.root?reproducible";
+const TString FileNameInfo = fileTag + "_mcbm.geo.info";
+
+// TOF_Z_Front corresponds to front cover of outer super module towers
+const Float_t TOF_Z_Front_Stand = 233.2; // = z=298 mCBM@SIS18
+const Float_t TOF_Y_Front_Stand = 0.;
+const Float_t TOF_X_Front_Stand = 0.;
+const Float_t TOF_Z_Front = 0;
+//const Float_t TOF_Z_Front = 130; // = z=225 mCBM@SIS18
+//const Float_t TOF_Z_Front = 250; // SIS 100 hadron
+//const Float_t TOF_Z_Front = 450; // SIS 100 hadron
+//const Float_t TOF_Z_Front = 600; // SIS 100 electron
+//const Float_t TOF_Z_Front = 650; // SIS 100 muon
+//const Float_t TOF_Z_Front = 880; // SIS 300 electron
+//const Float_t TOF_Z_Front = 1020; // SIS 300 muon
+//
+//const Float_t TOF_Z_Front = 951.5; // Wall_Z_Position = 1050 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 BoxVolumeMedium = "aluminium";
+const TString NoActivGasMedium = "RPCgas_noact";
+const TString ActivGasMedium = "RPCgas";
+const TString GlasMedium = "RPCglass";
+const TString ElectronicsMedium = "carbon";
+
+// Counters:
+// 0 MRPC3a
+// 1 MRPC3b
+// 2 USTC
+// 3
+// 4 Diamond
+//
+// 6 Buc 2019
+// 7 CERN 20gap
+// 8 Ceramic Pad
+const Int_t NumberOfDifferentCounterTypes = 9;
+const Float_t Glass_X[NumberOfDifferentCounterTypes] = {32., 32., 32., 32., 0.2, 32., 28.8, 20., 2.4};
+const Float_t Glass_Y[NumberOfDifferentCounterTypes] = {27.0, 53., 26.8, 10., 0.2, 10., 6., 20., 2.4};
+const Float_t Glass_Z[NumberOfDifferentCounterTypes] = {0.1, 0.1, 0.1, 0.1, 0.01, 0.1, 0.1, 0.1, 0.1};
+
+const Float_t GasGap_X[NumberOfDifferentCounterTypes] = {32., 32., 32., 32., 0.2, 32., 28.8, 20., 2.4};
+const Float_t GasGap_Y[NumberOfDifferentCounterTypes] = {27.0, 53., 26.8, 10., 0.2, 10., 6., 20., 2.4};
+const Float_t GasGap_Z[NumberOfDifferentCounterTypes] = {0.025, 0.025, 0.025, 0.025, 0.01, 0.02, 0.02, 0.02, 0.025};
+
+const Int_t NumberOfGaps[NumberOfDifferentCounterTypes] = {8, 8, 8, 8, 1, 8, 10, 20, 4};
+//const Int_t NumberOfGaps[NumberOfDifferentCounterTypes] = {1,1,1,1}; //deb
+const Int_t NumberOfReadoutStrips[NumberOfDifferentCounterTypes] = {32, 32, 32, 32, 16, 32, 32, 20, 1};
+//const Int_t NumberOfReadoutStrips[NumberOfDifferentCounterTypes] = {1,1,1,1}; //deb
+
+const Float_t SingleStackStartPosition_Z[NumberOfDifferentCounterTypes] = {-0.6, -0.6, -0.6, -0.6, -0.1,
+ -0.6, -0.6, -0.6, -1.};
+
+const Float_t Electronics_X[NumberOfDifferentCounterTypes] = {32.0, 32.0, 32.0, 32., 0.3, 0.1, 28.8, 20., 0.1};
+const Float_t Electronics_Y[NumberOfDifferentCounterTypes] = {5.0, 5.0, 1.0, 1., 0.1, 0.1, 1.0, 1.0, 0.1};
+const Float_t Electronics_Z[NumberOfDifferentCounterTypes] = {0.3, 0.3, 0.3, 0.3, 0.1, 0.1, 0.1, 0.1, 0.1};
+
+const Int_t NofModuleTypes = 10;
+// 0 M4 (TSHU)
+// 1 M4 (USTC)
+// 2 M6 (USTC)
+// 5 Diamond
+// 6 Buc
+// 7 Testbox MRPC4
+// 8 Ceramic
+// 9 Star2
+// Aluminum box for all module types
+const Float_t Module_Size_X[NofModuleTypes] = {180., 180., 180., 180., 180., 5., 40., 100., 10., 100.};
+const Float_t Module_Size_Y[NofModuleTypes] = {49., 49., 74., 28., 18., 5., 15., 49., 10., 49.};
+const Float_t Module_Over_Y[NofModuleTypes] = {11.5, 11.5, 11., 4.5, 4.5, 0., 0., 0., 0., 0.};
+const Float_t Module_Size_Z[NofModuleTypes] = {11., 11., 13., 11., 11., 1., 14.5, 11., 1., 11.2};
+const Float_t Module_Thick_Alu_X_left = 0.1;
+const Float_t Module_Thick_Alu_X_right = 1.0;
+const Float_t Module_Thick_Alu_Y = 0.1;
+const Float_t Module_Thick_Alu_Z = 0.1;
+
+// Distance to the center of the TOF wall [cm];
+const Float_t Wall_Z_Position = 400.;
+const Float_t MeanTheta = 0.;
+
+//Type of Counter for module
+const Int_t CounterTypeInModule[NofModuleTypes] = {0, 0, 1, 2, 3, 4, 6, 7, 8, 0};
+const Int_t NCounterInModule[NofModuleTypes] = {5, 5, 5, 5, 5, 1, 2, 1, 8, 2};
+
+// Placement of the counter inside the module
+const Float_t CounterXStartPosition[NofModuleTypes] = {-60.0, -66.0, -61.1, -60.0, -60.0, 0.0, 0., 0., 0., 0.};
+const Float_t CounterXDistance[NofModuleTypes] = { 30.0, 32.0, 30.45, 30.0, 30.0, 0.0, 0., 0., 0., 0.};
+const Float_t CounterYStartPosition[NofModuleTypes] = { 0.0, 0.0, 0.0, 0.0, 0.0, 0., 0., 0., 0., 0.};
+const Float_t CounterYDistance[NofModuleTypes] = { 0.0, 0.0, 0.0, 0.0, 0.0, 0., 0., 0., 0., 0.};
+const Float_t CounterZDistance[NofModuleTypes] = { -2.25, 0.0, 0.0, 2.5, 2.5, 0., 3.8, 4., 0.1, 4.3};
+const Float_t CounterZStartPosition[NofModuleTypes] = { 3.3, 0.0, 0.0, 0.0, 0.0, 0., -1.9, -2., 0.0,-2.2};
+const Float_t CounterRotationAngle[NofModuleTypes] = { 0., 8.7, -10.0, 0., 0., 0., 0., 0., 0., 0.};
+const Float_t CounterRotationAngleZ[NofModuleTypes] = { 0., 0., 0.0, 0., 0., 0., 0., 90., 0., 0.};
+// clang-format on
+
+// Pole (support structure)
+const Int_t MaxNumberOfPoles = 20;
+Float_t Pole_ZPos[MaxNumberOfPoles];
+Float_t Pole_Col[MaxNumberOfPoles];
+Int_t NumberOfPoles = 0;
+
+const Float_t Pole_Size_X = 20.;
+const Float_t Pole_Size_Y = 300.;
+const Float_t Pole_Size_Z = 10.;
+const Float_t Pole_Thick_X = 5.;
+const Float_t Pole_Thick_Y = 5.;
+const Float_t Pole_Thick_Z = 5.;
+
+// Bars (support structure)
+const Float_t Bar_Size_X = 20.;
+const Float_t Bar_Size_Y = 20.;
+Float_t Bar_Size_Z = 100.;
+
+const Int_t MaxNumberOfBars = 20;
+Float_t Bar_ZPos[MaxNumberOfBars];
+Float_t Bar_XPos[MaxNumberOfBars];
+Int_t NumberOfBars = 0;
+
+const Float_t ChamberOverlap = 40;
+const Float_t DxColl = 158.0; //Module_Size_X-ChamberOverlap;
+//const Float_t Pole_Offset=Module_Size_X/2.+Pole_Size_X/2.;
+const Float_t Pole_Offset = 90.0 + Pole_Size_X / 2.;
+
+// Position for module placement
+const Float_t Inner_Module_First_Y_Position = 16.;
+const Float_t Inner_Module_Last_Y_Position = 480.;
+const Float_t Inner_Module_X_Offset = 0.; // centered position in x/y
+//const Float_t Inner_Module_X_Offset=18; // shift by 16 cm in x
+const Int_t Inner_Module_NTypes = 3;
+const Float_t Inner_Module_Types[Inner_Module_NTypes] = {4., 3., 0.};
+//const Float_t Inner_Module_Number[Inner_Module_NTypes] = {2.,2.,6.}; //V13_3a
+const Float_t Inner_Module_Number[Inner_Module_NTypes] = {2., 2., 1.}; //V13_3a
+//const Float_t Inner_Module_Number[Inner_Module_NTypes] = {0.,0.,0.}; //debugging
+
+const Float_t InnerSide_Module_X_Offset = 51.;
+const Float_t InnerSide_Module_NTypes = 1;
+const Float_t InnerSide_Module_Types[Inner_Module_NTypes] = {5.};
+const Float_t InnerSide_Module_Number[Inner_Module_NTypes] = {2.}; //v13_3a
+//const Float_t InnerSide_Module_Number[Inner_Module_NTypes] = {0.}; //debug
+
+const Float_t Outer_Module_First_Y_Position = 0.;
+const Float_t Outer_Module_Last_Y_Position = 480.;
+const Float_t Outer_Module_X_Offset = 3.;
+const Int_t Outer_Module_Col = 4;
+const Int_t Outer_Module_NTypes = 2;
+const Float_t Outer_Module_Types[Outer_Module_NTypes][Outer_Module_Col] = {1., 1., 1., 1., 2., 2., 2., 2.};
+const Float_t Outer_Module_Number[Outer_Module_NTypes][Outer_Module_Col] = {9., 9., 2., 0., 0., 0., 3., 4.}; //V13_3a
+//const Float_t Outer_Module_Number[Outer_Module_NTypes][Outer_Module_Col] = {1.,1.,0.,0., 0.,0.,0.,0.};//debug
+
+const Float_t Star2_First_Z_Position = TOF_Z_Front + 36.;
+const Float_t Star2_Delta_Z_Position = 16.;
+const Float_t Star2_First_Y_Position = -1.3; //
+const Float_t Star2_Delta_Y_Position = 0.; //
+const Int_t Star2_NTypes = 2;
+const Float_t Star2_rotate_Z[Star2_NTypes] = {90.,90};
+const Float_t Star2_Types[Star2_NTypes] = {9.,9};
+const Float_t Star2_Number[Star2_NTypes] = {1.,1.}; //debugging, V16b
+const Float_t Star2_X_Offset[Star2_NTypes] = {-15.,-15.0}; //{62.};
+
+const Float_t Buc_First_Z_Position = TOF_Z_Front + 34.75;
+const Float_t Buc_Delta_Z_Position = 0.;
+const Float_t Buc_First_Y_Position = 33.5; //
+const Float_t Buc_Delta_Y_Position = 0.; //
+const Float_t Buc_rotate_Z = 180.;
+const Float_t Buc_rotate_Y = 0.;
+const Int_t Buc_NTypes = 1;
+const Float_t Buc_Types[Buc_NTypes] = {6.};
+const Float_t Buc_Number[Buc_NTypes] = {1.}; //debugging, V16b
+const Float_t Buc_X_Offset[Buc_NTypes] = {32.};
+
+const Int_t Cer_NTypes = 3;
+const Float_t Cer_Z_Position[Cer_NTypes] = {(float) (TOF_Z_Front + 13.2), (float) (TOF_Z_Front + 45.),
+ (float) (TOF_Z_Front + 45.)};
+const Float_t Cer_X_Position[Cer_NTypes] = {0., 49.8, 49.8};
+const Float_t Cer_Y_Position[Cer_NTypes] = {-1., 5., 5.};
+const Float_t Cer_rotate_Z[Cer_NTypes] = {0., 0., 0.};
+const Float_t Cer_Types[Cer_NTypes] = {5., 8., 8.};
+const Float_t Cer_Number[Cer_NTypes] = {1., 1., 1.}; //V16b
+
+
+const Float_t Testbox_MRPC4_Z_Position = TOF_Z_Front + 15.9; //
+const Float_t Testbox_MRPC4_First_Y_Position = 32.70;
+const Float_t Testbox_MRPC4_X_Offset = 50.17; //65.5;
+const Float_t Testbox_MRPC4_rotate_Z = -90.;
+const Int_t Testbox_MRPC4_NTypes = 1;
+const Float_t Testbox_MRPC4_Types[Testbox_MRPC4_NTypes] = {7.}; // this is the SmType!
+const Float_t Testbox_MRPC4_Number[Testbox_MRPC4_NTypes] = {1.}; // evtl. double for split signals
+
+// some global variables
+TGeoManager* gGeoMan = NULL; // Pointer to TGeoManager instance
+TGeoVolume* gModules[NofModuleTypes]; // Global storage for module types
+TGeoVolume* gCounter[NumberOfDifferentCounterTypes];
+TGeoVolume* gPole;
+TGeoVolume* gBar[MaxNumberOfBars];
+
+const Float_t Dia_Z_Position = -0.5 - TOF_Z_Front_Stand;
+const Float_t Dia_First_Y_Position = 0.;
+const Float_t Dia_X_Offset = 0.;
+const Float_t Dia_rotate_Z = 0.;
+const Int_t Dia_NTypes = 1;
+const Float_t Dia_Types[Dia_NTypes] = {5.};
+const Float_t Dia_Number[Dia_NTypes] = {1.};
+
+Float_t Last_Size_Y = 0.;
+Float_t Last_Over_Y = 0.;
+
+// Forward declarations
+void create_materials_from_media_file();
+TGeoVolume* create_counter(Int_t);
+TGeoVolume* create_new_counter(Int_t);
+TGeoVolume* create_tof_module(Int_t);
+TGeoVolume* create_new_tof_module(Int_t);
+TGeoVolume* create_tof_pole();
+TGeoVolume* create_tof_bar();
+void position_tof_poles(Int_t);
+void position_tof_bars(Int_t);
+void position_inner_tof_modules(Int_t);
+void position_side_tof_modules(Int_t);
+void position_outer_tof_modules(Int_t);
+void position_Dia(Int_t);
+void position_Star2(Int_t);
+void position_Buc(Int_t);
+void position_cer_modules(Int_t);
+void position_Testbox_MRPC4(Int_t);
+void dump_info_file();
+
+
+void Create_TOF_Geometry_v24d_mcbm()
+{
+
+ // Load needed material definition from media.geo file
+ create_materials_from_media_file();
+
+ // Get the GeoManager for later usage
+ gGeoMan = (TGeoManager*) gROOT->FindObject("FAIRGeom");
+ gGeoMan->SetVisLevel(5); // 2 = super modules
+ gGeoMan->SetVisOption(0);
+
+ // Create the top volume
+ /*
+ TGeoBBox* topbox= new TGeoBBox("", 1000., 1000., 1000.);
+ TGeoVolume* top = new TGeoVolume("top", topbox, gGeoMan->GetMedium("air"));
+ gGeoMan->SetTopVolume(top);
+ */
+
+ TGeoVolume* top = new TGeoVolumeAssembly("TOP");
+ gGeoMan->SetTopVolume(top);
+
+ TGeoRotation* tof_rotation = new TGeoRotation();
+ tof_rotation->RotateY(0.); // angle with respect to beam axis
+ //tof_rotation->RotateZ( 0 ); // electronics on 9 o'clock position = +x
+ // tof_rotation->RotateZ( 0 ); // electronics on 9 o'clock position = +x
+ // tof_rotation->RotateZ( 90 ); // electronics on 12 o'clock position (top)
+ // tof_rotation->RotateZ( 180 ); // electronics on 3 o'clock position = -x
+ // tof_rotation->RotateZ( 270 ); // electronics on 6 o'clock position (bottom)
+
+ TGeoVolume* tof = new TGeoVolumeAssembly(geoVersion);
+ // top->AddNode(tof, 1, tof_rotation);
+ top->AddNode(tof, 1);
+
+ TGeoVolume* tofstand = new TGeoVolumeAssembly(geoVersionStand);
+ // Mar 2020 run
+ TGeoTranslation* stand_trans_local = new TGeoTranslation("", TOF_X_Front_Stand, TOF_Y_Front_Stand, 0.);
+ TGeoTranslation* stand_trans = new TGeoTranslation("", 0., 0., TOF_Z_Front_Stand);
+ TGeoCombiTrans* stand_combi_trans = new TGeoCombiTrans(*stand_trans, *tof_rotation);
+
+ TGeoRotation* stand_rot = new TGeoRotation();
+ stand_rot->RotateY(0.);
+ //stand_rot->RotateY(0.97);
+ TGeoCombiTrans* stand_combi_trans_local = new TGeoCombiTrans(*stand_trans_local, *stand_rot);
+
+ //tof->AddNode(tofstand, 1, stand_combi_trans);
+ tof->AddNode(tofstand, 1, stand_combi_trans_local);
+ //tof->AddNode(tofstand, 1);
+
+ for (Int_t counterType = 0; counterType < NumberOfDifferentCounterTypes; counterType++) {
+ gCounter[counterType] = create_new_counter(counterType);
+ }
+
+ for (Int_t moduleType = 0; moduleType < NofModuleTypes; moduleType++) {
+ gModules[moduleType] = create_new_tof_module(moduleType);
+ gModules[moduleType]->SetVisContainers(1);
+ }
+
+ // no pole
+ // gPole = create_tof_pole();
+
+ // position_side_tof_modules(1); // keep order !!
+ // position_inner_tof_modules(2);
+ position_inner_tof_modules(1);
+ position_Dia(1);
+ position_Star2(2);
+ // position_cer_modules(3);
+ // position_CERN(1);
+ position_Buc(1);
+
+ cout << "Outer Types " << Outer_Module_Types[0][0] << ", " << Outer_Module_Types[1][0]
+ << ", col=1: " << Outer_Module_Types[0][1] << ", " << Outer_Module_Types[1][1] << endl;
+ cout << "Outer Number " << Outer_Module_Number[0][0] << ", " << Outer_Module_Number[1][0]
+ << ", col=1: " << Outer_Module_Number[0][1] << ", " << Outer_Module_Number[1][1] << endl;
+ // position_outer_tof_modules(4);
+ // position_tof_poles(0);
+ // position_tof_bars(0);
+
+ gGeoMan->CloseGeometry();
+ gGeoMan->CheckOverlaps(0.001);
+ gGeoMan->PrintOverlaps();
+ gGeoMan->CheckOverlaps(0.001, "s");
+ gGeoMan->PrintOverlaps();
+ gGeoMan->Test();
+
+ tof->Export(FileNameSim);
+ TFile* geoFile = new TFile(FileNameSim, "UPDATE");
+ stand_combi_trans->Write();
+ geoFile->Close();
+
+ /*
+ TFile* outfile1 = new TFile(FileNameSim,"RECREATE");
+ top->Write();
+ //gGeoMan->Write();
+ outfile1->Close();
+*/
+ TFile* outfile2 = new TFile(FileNameGeo, "RECREATE");
+ gGeoMan->Write();
+ outfile2->Close();
+
+ dump_info_file();
+
+ top->SetVisContainers(1);
+ gGeoMan->SetVisLevel(5);
+ top->Draw("ogl");
+ //top->Draw();
+ //gModules[0]->Draw("ogl");
+ // gModules[0]->Draw("");
+ gModules[0]->SetVisContainers(1);
+ // gModules[1]->Draw("");
+ gModules[1]->SetVisContainers(1);
+ //gModules[5]->Draw("");
+ // top->Raytrace();
+}
+
+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 geoFile = geoPath + "/geometry/media.geo";
+ geoFace->setMediaFile(geoFile);
+ geoFace->readMedia();
+
+ // Read the required media and create them in the GeoManager
+ FairGeoMedia* geoMedia = geoFace->getMedia();
+ FairGeoBuilder* geoBuild = geoLoad->getGeoBuilder();
+
+ FairGeoMedium* air = geoMedia->getMedium("air");
+ FairGeoMedium* aluminium = geoMedia->getMedium("aluminium");
+ FairGeoMedium* RPCgas = geoMedia->getMedium("RPCgas");
+ FairGeoMedium* RPCgas_noact = geoMedia->getMedium("RPCgas_noact");
+ FairGeoMedium* RPCglass = geoMedia->getMedium("RPCglass");
+ FairGeoMedium* carbon = geoMedia->getMedium("carbon");
+
+ // include check if all media are found
+
+ geoBuild->createMedium(air);
+ geoBuild->createMedium(aluminium);
+ geoBuild->createMedium(RPCgas);
+ geoBuild->createMedium(RPCgas_noact);
+ geoBuild->createMedium(RPCglass);
+ geoBuild->createMedium(carbon);
+}
+
+TGeoVolume* create_counter(Int_t modType)
+{
+
+ //glass
+ Float_t gdx = Glass_X[modType];
+ Float_t gdy = Glass_Y[modType];
+ Float_t gdz = Glass_Z[modType];
+
+ //gas gap
+ Int_t nstrips = NumberOfReadoutStrips[modType];
+ Int_t ngaps = NumberOfGaps[modType];
+
+
+ Float_t ggdx = GasGap_X[modType];
+ Float_t ggdy = GasGap_Y[modType];
+ Float_t ggdz = GasGap_Z[modType];
+ Float_t gsdx = ggdx / float(nstrips);
+
+ //single stack
+ Float_t dzpos = gdz + ggdz;
+ Float_t startzpos = SingleStackStartPosition_Z[modType];
+
+ // electronics
+ //pcb dimensions
+ Float_t dxe = Electronics_X[modType];
+ Float_t dye = Electronics_Y[modType];
+ Float_t dze = Electronics_Z[modType];
+ Float_t yele = (gdy + 0.1) / 2. + dye / 2.;
+
+ // needed materials
+ TGeoMedium* glassPlateVolMed = gGeoMan->GetMedium(GlasMedium);
+ TGeoMedium* noActiveGasVolMed = gGeoMan->GetMedium(NoActivGasMedium);
+ TGeoMedium* activeGasVolMed = gGeoMan->GetMedium(ActivGasMedium);
+ TGeoMedium* electronicsVolMed = gGeoMan->GetMedium(ElectronicsMedium);
+
+ // Single glass plate
+ TGeoBBox* glass_plate = new TGeoBBox("", gdx / 2., gdy / 2., gdz / 2.);
+ TGeoVolume* glass_plate_vol = new TGeoVolume("tof_glass", glass_plate, glassPlateVolMed);
+ glass_plate_vol->SetLineColor(kMagenta); // set line color for the glass plate
+ glass_plate_vol->SetTransparency(20); // set transparency for the TOF
+ TGeoTranslation* glass_plate_trans = new TGeoTranslation("", 0., 0., 0.);
+
+ // Single gas gap
+ TGeoBBox* gas_gap = new TGeoBBox("", ggdx / 2., ggdy / 2., ggdz / 2.);
+ //TGeoVolume* gas_gap_vol =
+ //new TGeoVolume("tof_gas_gap", gas_gap, noActiveGasVolMed);
+ TGeoVolume* gas_gap_vol = new TGeoVolume("tof_gas_active", gas_gap, activeGasVolMed);
+ gas_gap_vol->Divide("Strip", 1, nstrips, -ggdx / 2., 0);
+
+ gas_gap_vol->SetLineColor(kRed); // set line color for the gas gap
+ gas_gap_vol->SetTransparency(70); // set transparency for the TOF
+ TGeoTranslation* gas_gap_trans = new TGeoTranslation("", 0., 0., (gdz + ggdz) / 2.);
+
+
+ // Single subdivided active gas gap
+ /*
+ TGeoBBox* gas_active = new TGeoBBox("", gsdx/2., ggdy/2., ggdz/2.);
+ TGeoVolume* gas_active_vol =
+ new TGeoVolume("tof_gas_active", gas_active, activeGasVolMed);
+ gas_active_vol->SetLineColor(kBlack); // set line color for the gas gap
+ gas_active_vol->SetTransparency(70); // set transparency for the TOF
+ */
+
+ // Add glass plate, inactive gas gap and active gas gaps to a single stack
+ TGeoVolume* single_stack = new TGeoVolumeAssembly("single_stack");
+ single_stack->AddNode(glass_plate_vol, 0, glass_plate_trans);
+ single_stack->AddNode(gas_gap_vol, 0, gas_gap_trans);
+
+ /*
+ for (Int_t l=0; l<nstrips; l++){
+ TGeoTranslation* gas_active_trans
+ = new TGeoTranslation("", -ggdx/2+(l+0.5)*gsdx, 0., 0.);
+ gas_gap_vol->AddNode(gas_active_vol, l, gas_active_trans);
+ // single_stack->AddNode(gas_active_vol, l, gas_active_trans);
+ }
+ */
+
+ // Add 8 single stacks + one glass plate at the e09.750nd to a multi stack
+ TGeoVolume* multi_stack = new TGeoVolumeAssembly("multi_stack");
+ Int_t l;
+ for (l = 0; l < ngaps; l++) {
+ TGeoTranslation* single_stack_trans = new TGeoTranslation("", 0., 0., startzpos + l * dzpos);
+ multi_stack->AddNode(single_stack, l, single_stack_trans);
+ }
+ TGeoTranslation* single_glass_back_trans = new TGeoTranslation("", 0., 0., startzpos + ngaps * dzpos);
+ multi_stack->AddNode(glass_plate_vol, l, single_glass_back_trans);
+
+ // Add electronics above and below the glass stack to build a complete counter
+ TGeoVolume* counter = new TGeoVolumeAssembly("counter");
+ TGeoTranslation* multi_stack_trans = new TGeoTranslation("", 0., 0., 0.);
+ counter->AddNode(multi_stack, l, multi_stack_trans);
+
+ TGeoBBox* pcb = new TGeoBBox("", dxe / 2., dye / 2., dze / 2.);
+ TGeoVolume* pcb_vol = new TGeoVolume("pcb", pcb, electronicsVolMed);
+ pcb_vol->SetLineColor(kCyan); // set line color for the gas gap
+ pcb_vol->SetTransparency(10); // set transparency for the TOF
+ for (Int_t l = 0; l < 2; l++) {
+ yele *= -1.;
+ TGeoTranslation* pcb_trans = new TGeoTranslation("", 0., yele, 0.);
+ counter->AddNode(pcb_vol, l, pcb_trans);
+ }
+
+ return counter;
+}
+
+TGeoVolume* create_new_counter(Int_t modType)
+{
+
+ //glass
+ Float_t gdx = Glass_X[modType];
+ Float_t gdy = Glass_Y[modType];
+ Float_t gdz = Glass_Z[modType];
+
+ //gas gap
+ Int_t nstrips = NumberOfReadoutStrips[modType];
+ Int_t ngaps = NumberOfGaps[modType];
+
+
+ Float_t ggdx = GasGap_X[modType];
+ Float_t ggdy = GasGap_Y[modType];
+ Float_t ggdz = GasGap_Z[modType];
+ Float_t gsdx = ggdx / (Float_t)(nstrips);
+
+ // electronics
+ //pcb dimensions
+ Float_t dxe = Electronics_X[modType];
+ Float_t dye = Electronics_Y[modType];
+ Float_t dze = Electronics_Z[modType];
+ Float_t yele = gdy / 2. + dye / 2.;
+
+ // counter size (calculate from glas, gap and electronics sizes)
+ Float_t cdx = TMath::Max(gdx, ggdx);
+ cdx = TMath::Max(cdx, dxe) + 0.2;
+ Float_t cdy = TMath::Max(gdy, ggdy) + 2 * dye + 0.2;
+ Float_t cdz = ngaps * ggdz + (ngaps + 1) * gdz + 0.2; // ngaps * (gdz+ggdz) + gdz + 0.2; // ok
+
+ //calculate thickness and first position in counter of single stack
+ Float_t dzpos = gdz + ggdz;
+ Float_t startzposglas = -ngaps * (gdz + ggdz) / 2.; // -cdz/2.+0.1+gdz/2.; // ok // (-cdz+gdz)/2.; // not ok
+ Float_t startzposgas = startzposglas + gdz / 2. + ggdz / 2.; // -cdz/2.+0.1+gdz +ggdz/2.; // ok
+
+
+ // needed materials
+ TGeoMedium* glassPlateVolMed = gGeoMan->GetMedium(GlasMedium);
+ TGeoMedium* noActiveGasVolMed = gGeoMan->GetMedium(NoActivGasMedium);
+ TGeoMedium* activeGasVolMed = gGeoMan->GetMedium(ActivGasMedium);
+ TGeoMedium* electronicsVolMed = gGeoMan->GetMedium(ElectronicsMedium);
+
+
+ // define counter volume
+ TGeoBBox* counter_box = new TGeoBBox("", cdx / 2., cdy / 2., cdz / 2.);
+ TGeoVolume* counter = new TGeoVolume("counter", counter_box, noActiveGasVolMed);
+ counter->SetLineColor(kRed); // set line color for the counter
+ counter->SetTransparency(70); // set transparency for the TOF
+
+ // define single glass plate volume
+ TGeoBBox* glass_plate = new TGeoBBox("", gdx / 2., gdy / 2., gdz / 2.);
+ TGeoVolume* glass_plate_vol = new TGeoVolume("tof_glass", glass_plate, glassPlateVolMed);
+ glass_plate_vol->SetLineColor(kMagenta); // set line color for the glass plate
+ glass_plate_vol->SetTransparency(20); // set transparency for the TOF
+ // define single gas gap volume
+ TGeoBBox* gas_gap = new TGeoBBox("", ggdx / 2., ggdy / 2., ggdz / 2.);
+ TGeoVolume* gas_gap_vol = new TGeoVolume("Gap", gas_gap, activeGasVolMed);
+ gas_gap_vol->Divide("Cell", 1, nstrips, -ggdx / 2., 0);
+ gas_gap_vol->SetLineColor(kRed); // set line color for the gas gap
+ gas_gap_vol->SetTransparency(99); // set transparency for the TOF
+
+ // place 8 gas gaps and 9 glas plates in the counter
+ for (Int_t igap = 0; igap <= ngaps; igap++) {
+ // place (ngaps+1) glass plates
+ Float_t zpos_glas = startzposglas + igap * dzpos;
+ TGeoTranslation* glass_plate_trans = new TGeoTranslation("", 0., 0., zpos_glas);
+ counter->AddNode(glass_plate_vol, igap, glass_plate_trans);
+ // place ngaps gas gaps
+ if (igap < ngaps) {
+ Float_t zpos_gas = startzposgas + igap * dzpos;
+ TGeoTranslation* gas_gap_trans = new TGeoTranslation("", 0., 0., zpos_gas);
+ counter->AddNode(gas_gap_vol, igap, gas_gap_trans);
+ }
+ // cout <<"Zpos(Glas): "<< zpos_glas << endl;
+ // cout <<"Zpos(Gas): "<< zpos_gas << endl;
+ }
+
+ // create and place the electronics above and below the glas stack
+ TGeoBBox* pcb = new TGeoBBox("", dxe / 2., dye / 2., dze / 2.);
+ TGeoVolume* pcb_vol = new TGeoVolume("pcb", pcb, electronicsVolMed);
+ pcb_vol->SetLineColor(kYellow); // kCyan); // set line color for electronics
+ pcb_vol->SetTransparency(10); // set transparency for the TOF
+ for (Int_t l = 0; l < 2; l++) {
+ yele *= -1.;
+ TGeoTranslation* pcb_trans = new TGeoTranslation("", 0., yele, 0.);
+ counter->AddNode(pcb_vol, l, pcb_trans);
+ }
+
+
+ return counter;
+}
+
+TGeoVolume* create_tof_module(Int_t modType)
+{
+ Int_t cType = CounterTypeInModule[modType];
+ Float_t dx = Module_Size_X[modType];
+ Float_t dy = Module_Size_Y[modType];
+ Float_t dz = Module_Size_Z[modType];
+ Float_t width_aluxl = Module_Thick_Alu_X_left;
+ Float_t width_aluxr = Module_Thick_Alu_X_right;
+ Float_t width_aluy = Module_Thick_Alu_Y;
+ Float_t width_aluz = Module_Thick_Alu_Z;
+
+ Float_t shift_gas_box = (Module_Thick_Alu_X_right - Module_Thick_Alu_X_left) / 2;
+
+ Float_t dxpos = CounterXDistance[modType];
+ Float_t startxpos = CounterXStartPosition[modType];
+ Float_t dzoff = CounterZDistance[modType];
+ Float_t rotangle = CounterRotationAngle[modType];
+
+ TGeoMedium* boxVolMed = gGeoMan->GetMedium(BoxVolumeMedium);
+ TGeoMedium* noActiveGasVolMed = gGeoMan->GetMedium(NoActivGasMedium);
+
+ TString moduleName = Form("module_%d", modType);
+ TGeoVolume* module = new TGeoVolumeAssembly(moduleName);
+
+ TGeoBBox* alu_box = new TGeoBBox("", dx / 2., dy / 2., dz / 2.);
+ TGeoVolume* alu_box_vol = new TGeoVolume("alu_box", alu_box, boxVolMed);
+ alu_box_vol->SetLineColor(kGreen); // set line color for the alu box
+ alu_box_vol->SetTransparency(20); // set transparency for the TOF
+ TGeoTranslation* alu_box_trans = new TGeoTranslation("", 0., 0., 0.);
+ module->AddNode(alu_box_vol, 0, alu_box_trans);
+
+ TGeoBBox* gas_box =
+ new TGeoBBox("", (dx - (width_aluxl + width_aluxr)) / 2., (dy - 2 * width_aluy) / 2., (dz - 2 * width_aluz) / 2.);
+ TGeoVolume* gas_box_vol = new TGeoVolume("gas_box", gas_box, noActiveGasVolMed);
+ gas_box_vol->SetLineColor(kYellow); // set line color for the gas box
+ gas_box_vol->SetTransparency(70); // set transparency for the TOF
+ TGeoTranslation* gas_box_trans = new TGeoTranslation("", shift_gas_box, 0., 0.);
+ alu_box_vol->AddNode(gas_box_vol, 0, gas_box_trans);
+
+ for (Int_t j = 0; j < 5; j++) { //loop over counters (modules)
+ Float_t zpos;
+ if (0 == modType) { zpos = dzoff *= -1; }
+ else {
+ zpos = 0.;
+ }
+ //cout << "counter z position " << zpos << endl;
+ TGeoTranslation* counter_trans = new TGeoTranslation("", startxpos + j * dxpos, 0.0, zpos);
+
+ TGeoRotation* counter_rot = new TGeoRotation();
+ counter_rot->RotateY(rotangle);
+ TGeoCombiTrans* counter_combi_trans = new TGeoCombiTrans(*counter_trans, *counter_rot);
+ gas_box_vol->AddNode(gCounter[cType], j, counter_combi_trans);
+ }
+
+ return module;
+}
+
+TGeoVolume* create_new_tof_module(Int_t modType)
+{
+ Int_t cType = CounterTypeInModule[modType];
+ Float_t dx = Module_Size_X[modType];
+ Float_t dy = Module_Size_Y[modType];
+ Float_t dz = Module_Size_Z[modType];
+ Float_t width_aluxl = Module_Thick_Alu_X_left;
+ Float_t width_aluxr = Module_Thick_Alu_X_right;
+ Float_t width_aluy = Module_Thick_Alu_Y;
+ Float_t width_aluz = Module_Thick_Alu_Z;
+
+ Float_t shift_gas_box = (Module_Thick_Alu_X_right - Module_Thick_Alu_X_left) / 2;
+
+ Float_t dxpos = CounterXDistance[modType];
+ Float_t startxpos = CounterXStartPosition[modType];
+ Float_t dypos = CounterYDistance[modType];
+ Float_t startypos = CounterYStartPosition[modType];
+ Float_t dzoff = CounterZDistance[modType];
+ Float_t rotangle = CounterRotationAngle[modType];
+
+ TGeoMedium* boxVolMed = gGeoMan->GetMedium(BoxVolumeMedium);
+ TGeoMedium* noActiveGasVolMed = gGeoMan->GetMedium(NoActivGasMedium);
+
+ TString moduleName = Form("module_%d", modType);
+
+ TGeoBBox* module_box = new TGeoBBox("", dx / 2., dy / 2., dz / 2.);
+ TGeoVolume* module = new TGeoVolume(moduleName, module_box, boxVolMed);
+ module->SetLineColor(kGreen); // set line color for the alu box
+ module->SetTransparency(20); // set transparency for the TOF
+
+ TGeoBBox* gas_box =
+ new TGeoBBox("", (dx - (width_aluxl + width_aluxr)) / 2., (dy - 2 * width_aluy) / 2., (dz - 2 * width_aluz) / 2.);
+ TGeoVolume* gas_box_vol = new TGeoVolume("gas_box", gas_box, noActiveGasVolMed);
+ gas_box_vol->SetLineColor(kBlue); // set line color for the alu box
+ gas_box_vol->SetTransparency(50); // set transparency for the TOF
+ TGeoTranslation* gas_box_trans = new TGeoTranslation("", shift_gas_box, 0., 0.);
+ module->AddNode(gas_box_vol, 0, gas_box_trans);
+
+ for (Int_t j = 0; j < NCounterInModule[modType]; j++) { //loop over counters (modules)
+ //for (Int_t j=0; j< 1; j++){ //loop over counters (modules)
+ Float_t xpos, ypos, zpos;
+ if (0 == modType || 3 == modType || 4 == modType || 5 == modType) { zpos = dzoff *= -1; }
+ else {
+ zpos = CounterZStartPosition[modType] + j * dzoff;
+ }
+ //cout << "counter z position " << zpos << endl;
+ xpos = startxpos + j * dxpos;
+ ypos = startypos + j * dypos;
+
+ TGeoTranslation* counter_trans = new TGeoTranslation("", xpos, ypos, zpos);
+
+ TGeoRotation* counter_rot = new TGeoRotation();
+ counter_rot->RotateY(rotangle);
+ if ( CounterRotationAngleZ[modType] != 0. ) counter_rot->RotateZ(CounterRotationAngleZ[modType]);
+ TGeoCombiTrans* counter_combi_trans = new TGeoCombiTrans(*counter_trans, *counter_rot);
+ gas_box_vol->AddNode(gCounter[cType], j, counter_combi_trans);
+ }
+
+ return module;
+}
+
+
+TGeoVolume* create_tof_pole()
+{
+ // needed materials
+ TGeoMedium* boxVolMed = gGeoMan->GetMedium(BoxVolumeMedium);
+ TGeoMedium* airVolMed = gGeoMan->GetMedium(KeepingVolumeMedium);
+
+ Float_t dx = Pole_Size_X;
+ Float_t dy = Pole_Size_Y;
+ Float_t dz = Pole_Size_Z;
+ Float_t width_alux = Pole_Thick_X;
+ Float_t width_aluy = Pole_Thick_Y;
+ Float_t width_aluz = Pole_Thick_Z;
+
+ TGeoVolume* pole = new TGeoVolumeAssembly("Pole");
+ TGeoBBox* pole_alu_box = new TGeoBBox("", dx / 2., dy / 2., dz / 2.);
+ TGeoVolume* pole_alu_vol = new TGeoVolume("pole_alu", pole_alu_box, boxVolMed);
+ pole_alu_vol->SetLineColor(kGreen); // set line color for the alu box
+ pole_alu_vol->SetTransparency(20); // set transparency for the TOF
+ TGeoTranslation* pole_alu_trans = new TGeoTranslation("", 0., 0., 0.);
+ pole->AddNode(pole_alu_vol, 0, pole_alu_trans);
+
+ Float_t air_dx = dx / 2. - width_alux;
+ Float_t air_dy = dy / 2. - width_aluy;
+ Float_t air_dz = dz / 2. - width_aluz;
+
+ // cout << "My pole." << endl;
+ if (air_dx <= 0.) cout << "ERROR - No air volume in pole X, size: " << air_dx << endl;
+ if (air_dy <= 0.) cout << "ERROR - No air volume in pole Y, size: " << air_dy << endl;
+ if (air_dz <= 0.) cout << "ERROR - No air volume in pole Z, size: " << air_dz << endl;
+
+ if ((air_dx > 0.) && (air_dy > 0.) && (air_dz > 0.)) // crate air volume only, if larger than zero
+ {
+ TGeoBBox* pole_air_box = new TGeoBBox("", air_dx, air_dy, air_dz);
+ // TGeoBBox* pole_air_box = new TGeoBBox("", dx/2.-width_alux, dy/2.-width_aluy, dz/2.-width_aluz);
+ TGeoVolume* pole_air_vol = new TGeoVolume("pole_air", pole_air_box, airVolMed);
+ pole_air_vol->SetLineColor(kYellow); // set line color for the alu box
+ pole_air_vol->SetTransparency(70); // set transparency for the TOF
+ TGeoTranslation* pole_air_trans = new TGeoTranslation("", 0., 0., 0.);
+ pole_alu_vol->AddNode(pole_air_vol, 0, pole_air_trans);
+ }
+ else
+ cout << "Skipping pole_air_vol, no thickness: " << air_dx << " " << air_dy << " " << air_dz << endl;
+
+ return pole;
+}
+
+TGeoVolume* create_tof_bar(Float_t dx, Float_t dy, Float_t dz)
+{
+ // needed materials
+ TGeoMedium* boxVolMed = gGeoMan->GetMedium(BoxVolumeMedium);
+ TGeoMedium* airVolMed = gGeoMan->GetMedium(KeepingVolumeMedium);
+
+ Float_t width_alux = Pole_Thick_X;
+ Float_t width_aluy = Pole_Thick_Y;
+ Float_t width_aluz = Pole_Thick_Z;
+
+ TGeoVolume* bar = new TGeoVolumeAssembly("Bar");
+ TGeoBBox* bar_alu_box = new TGeoBBox("", dx / 2., dy / 2., dz / 2.);
+ TGeoVolume* bar_alu_vol = new TGeoVolume("bar_alu", bar_alu_box, boxVolMed);
+ bar_alu_vol->SetLineColor(kGreen); // set line color for the alu box
+ bar_alu_vol->SetTransparency(20); // set transparency for the TOF
+ TGeoTranslation* bar_alu_trans = new TGeoTranslation("", 0., 0., 0.);
+ bar->AddNode(bar_alu_vol, 0, bar_alu_trans);
+
+ TGeoBBox* bar_air_box = new TGeoBBox("", dx / 2. - width_alux, dy / 2. - width_aluy, dz / 2. - width_aluz);
+ TGeoVolume* bar_air_vol = new TGeoVolume("bar_air", bar_air_box, airVolMed);
+ bar_air_vol->SetLineColor(kYellow); // set line color for the alu box
+ bar_air_vol->SetTransparency(70); // set transparency for the TOF
+ TGeoTranslation* bar_air_trans = new TGeoTranslation("", 0., 0., 0.);
+ bar_alu_vol->AddNode(bar_air_vol, 0, bar_air_trans);
+
+ return bar;
+}
+
+void position_tof_poles(Int_t modType)
+{
+
+ TGeoTranslation* pole_trans = NULL;
+
+ Int_t numPoles = 0;
+ for (Int_t i = 0; i < NumberOfPoles; i++) {
+ if (i < 2) {
+ pole_trans = new TGeoTranslation("", -Pole_Offset + 2.0, 0., Pole_ZPos[i]);
+ gGeoMan->GetVolume(geoVersionStand)->AddNode(gPole, numPoles, pole_trans);
+ numPoles++;
+ }
+ else {
+ Float_t xPos = Pole_Offset + Pole_Size_X / 2. + Pole_Col[i] * DxColl;
+ Float_t zPos = Pole_ZPos[i];
+ pole_trans = new TGeoTranslation("", xPos, 0., zPos);
+ gGeoMan->GetVolume(geoVersionStand)->AddNode(gPole, numPoles, pole_trans);
+ numPoles++;
+
+ pole_trans = new TGeoTranslation("", -xPos, 0., zPos);
+ gGeoMan->GetVolume(geoVersionStand)->AddNode(gPole, numPoles, pole_trans);
+ numPoles++;
+ }
+ cout << " Position Pole " << numPoles << " at z=" << Pole_ZPos[i] << endl;
+ }
+}
+
+void position_tof_bars(Int_t modType)
+{
+
+ TGeoTranslation* bar_trans = NULL;
+
+ Int_t numBars = 0;
+ Int_t i;
+ Float_t xPos;
+ Float_t yPos;
+ Float_t zPos;
+
+ for (i = 0; i < NumberOfBars; i++) {
+
+ xPos = Bar_XPos[i];
+ zPos = Bar_ZPos[i];
+ yPos = Pole_Size_Y / 2. + Bar_Size_Y / 2.;
+
+ bar_trans = new TGeoTranslation("", xPos, yPos, zPos);
+ gGeoMan->GetVolume(geoVersionStand)->AddNode(gBar[i], numBars, bar_trans);
+ numBars++;
+
+ bar_trans = new TGeoTranslation("", xPos, -yPos, zPos);
+ gGeoMan->GetVolume(geoVersionStand)->AddNode(gBar[i], numBars, bar_trans);
+ numBars++;
+
+ bar_trans = new TGeoTranslation("", -xPos, yPos, zPos);
+ gGeoMan->GetVolume(geoVersionStand)->AddNode(gBar[i], numBars, bar_trans);
+ numBars++;
+
+ bar_trans = new TGeoTranslation("", -xPos, -yPos, zPos);
+ gGeoMan->GetVolume(geoVersionStand)->AddNode(gBar[i], numBars, bar_trans);
+ numBars++;
+ }
+ cout << " Position Bar " << numBars << " at z=" << Bar_ZPos[i] << endl;
+
+ // horizontal frame bars
+ i = NumberOfBars;
+ NumberOfBars++;
+ // no bar
+ // gBar[i]=create_tof_bar(2.*xPos+Pole_Size_X,Bar_Size_Y,Bar_Size_Y);
+
+ zPos = Pole_ZPos[0] + Pole_Size_Z / 2.;
+ bar_trans = new TGeoTranslation("", 0., yPos, zPos);
+ gGeoMan->GetVolume(geoVersionStand)->AddNode(gBar[i], numBars, bar_trans);
+ numBars++;
+
+ bar_trans = new TGeoTranslation("", 0., -yPos, zPos);
+ gGeoMan->GetVolume(geoVersionStand)->AddNode(gBar[i], numBars, bar_trans);
+ numBars++;
+}
+
+void position_inner_tof_modules(Int_t modNType)
+{
+ TGeoTranslation* module_trans = NULL;
+
+ // Int_t numModules=(Int_t)( (Inner_Module_Last_Y_Position-Inner_Module_First_Y_Position)/Module_Size_Y[modType])+1;
+ Float_t yPos = Inner_Module_First_Y_Position;
+ Int_t ii = 0;
+ Float_t xPos = Inner_Module_X_Offset;
+ Float_t zPos = Wall_Z_Position;
+
+ Pole_ZPos[NumberOfPoles] = zPos;
+ Pole_Col[NumberOfPoles] = 0;
+ NumberOfPoles++;
+
+ Float_t DzPos = 0.;
+ for (Int_t j = 0; j < modNType; j++) {
+ if (Module_Size_Z[j] > DzPos) { DzPos = Module_Size_Z[j]; }
+ }
+ Pole_ZPos[NumberOfPoles] = zPos + DzPos;
+ Pole_Col[NumberOfPoles] = 0;
+ NumberOfPoles++;
+
+ // Mar2019 setup
+ Int_t modNum[4] = {4 * 0};
+ const Int_t NModules = 8;
+ xPos = 0.;
+ yPos = 0.;
+ zPos = TOF_Z_Front;
+ const Int_t ModType[NModules] = {0, 0, 0, 0, 0, 0, 2, 2};
+ const Double_t ModDx[NModules] = {0., 0., 0., 0., 0., 0., 0., 0.};
+ //const Double_t ModDx[NModules]= { 1.5, 0., -1.5, 49.8, 55.8};
+ const Double_t ModDy[NModules] = {50., 0., -50.0, 27., -27.0, 0., 37.5, -37.5};
+ const Double_t ModDz[NModules] = {0., 0, 0, 20., 20., 92., 72., 72};
+ const Double_t ModAng[NModules] = {0., 0., 0., 0., 0., 0., 0., 0.};
+ TGeoRotation* module_rot = NULL;
+ TGeoCombiTrans* module_combi_trans = NULL;
+
+ /*
+ for (Int_t iMod = 0; iMod < NModules; iMod++) {
+ module_trans = new TGeoTranslation("", xPos + ModDx[iMod], yPos + ModDy[iMod], zPos + ModDz[iMod]);
+ module_rot = new TGeoRotation();
+ module_rot->RotateZ(ModAng[iMod]);
+ module_combi_trans = new TGeoCombiTrans(*module_trans, *module_rot);
+ if (iMod < 5) { gGeoMan->GetVolume(geoVersionStand)->AddNode(gModules[0], modNum, module_combi_trans); }
+ else {
+ gGeoMan->GetVolume(geoVersionStand)->AddNode(gModules[2], modNum, module_combi_trans);
+ }
+ modNum++;
+ }
+*/
+
+ for (Int_t iMod = 0; iMod < NModules; iMod++) {
+ module_trans = new TGeoTranslation("", xPos + ModDx[iMod], yPos + ModDy[iMod], zPos + ModDz[iMod]);
+ module_rot = new TGeoRotation();
+ module_rot->RotateZ(ModAng[iMod]);
+ module_combi_trans = new TGeoCombiTrans(*module_trans, *module_rot);
+ gGeoMan->GetVolume(geoVersionStand)->AddNode(gModules[ModType[iMod]], modNum[ModType[iMod]], module_combi_trans);
+ cout << "Placed Module " << modNum[ModType[iMod]] << ", Type " << ModType[iMod] << endl;
+ modNum[ModType[iMod]]++;
+ }
+
+ /*
+ module_trans = new TGeoTranslation("", xPos, 0, zPos+16.5);
+ gGeoMan->GetVolume(geoVersionStand)->AddNode(gModules[modType], modNum, module_trans);
+ modNum++;
+
+ // module_trans = new TGeoTranslation("", xPos, 49+3, zPos);
+ module_trans = new TGeoTranslation("", xPos, 0, zPos+16.5+17.5);
+ gGeoMan->GetVolume(geoVersionStand)->AddNode(gModules[modType], modNum, module_trans);
+ modNum++;
+
+ // module_trans = new TGeoTranslation("", xPos,-26, zPos+Module_Size_Z[modType]);
+ module_trans = new TGeoTranslation("", xPos, -49.8, zPos);
+ gGeoMan->GetVolume(geoVersionStand)->AddNode(gModules[modType], modNum, module_trans);
+ modNum++;
+
+ // module_trans = new TGeoTranslation("", xPos, 26, zPos+Module_Size_Z[modType]);
+ module_trans = new TGeoTranslation("", xPos, -49.8, zPos+16.5);
+ gGeoMan->GetVolume(geoVersionStand)->AddNode(gModules[modType], modNum, module_trans);
+ modNum++;
+ */
+}
+
+
+void position_Dia(Int_t modNType)
+{
+ TGeoTranslation* module_trans = NULL;
+ TGeoRotation* module_rot = new TGeoRotation();
+ module_rot->RotateZ(Dia_rotate_Z);
+ TGeoCombiTrans* module_combi_trans = NULL;
+
+ // Int_t numModules=(Int_t)( (Inner_Module_Last_Y_Position-Inner_Module_First_Y_Position)/Module_Size_Y[modType])+1;
+ Float_t yPos = Dia_First_Y_Position;
+ Int_t ii = 0;
+ Float_t xPos = Dia_X_Offset;
+ Float_t zPos = Dia_Z_Position;
+
+ Int_t modNum = 0;
+ for (Int_t j = 0; j < modNType; j++) {
+ Int_t modType = Dia_Types[j];
+ for (Int_t i = 0; i < Dia_Number[j]; i++) {
+ ii++;
+ module_trans = new TGeoTranslation("", xPos, yPos, zPos);
+ module_combi_trans = new TGeoCombiTrans(*module_trans, *module_rot);
+ gGeoMan->GetVolume(geoVersionStand)->AddNode(gModules[modType], modNum, module_combi_trans);
+ modNum++;
+ }
+ }
+}
+
+void position_Star2(Int_t modNType)
+{
+ TGeoTranslation* module_trans = NULL;
+ TGeoCombiTrans* module_combi_trans = NULL;
+ TGeoRotation* module_rot = NULL;
+ Float_t yPos = Star2_First_Y_Position;
+ Float_t zPos = Star2_First_Z_Position;
+ Int_t ii = 0;
+
+ Int_t modNum = 0;
+ for (Int_t j = 0; j < modNType; j++) {
+ Int_t modType = Star2_Types[j];
+ Float_t xPos = Star2_X_Offset[j];
+ module_rot = new TGeoRotation();
+ module_rot->RotateZ(Star2_rotate_Z[j]);
+ for (Int_t i = 0; i < Star2_Number[j]; i++) {
+ ii++;
+ module_trans = new TGeoTranslation("", xPos, yPos, zPos);
+ module_combi_trans = new TGeoCombiTrans(*module_trans, *module_rot);
+ gGeoMan->GetVolume(geoVersionStand)->AddNode(gModules[modType], modNum, module_combi_trans);
+ modNum++;
+ yPos += Star2_Delta_Y_Position;
+ zPos += Star2_Delta_Z_Position;
+ }
+ }
+}
+
+void position_Buc(Int_t modNType)
+{
+ TGeoTranslation* module_trans = NULL;
+ TGeoRotation* module_rot = new TGeoRotation();
+ module_rot->RotateZ(Buc_rotate_Z);
+ module_rot->RotateY(Buc_rotate_Y);
+ TGeoCombiTrans* module_combi_trans = NULL;
+
+ Float_t yPos = Buc_First_Y_Position;
+ Float_t zPos = Buc_First_Z_Position;
+ Int_t ii = 0;
+
+ Int_t modNum = 0;
+ for (Int_t j = 0; j < modNType; j++) {
+ Int_t modType = Buc_Types[j];
+ Float_t xPos = Buc_X_Offset[j];
+ for (Int_t i = 0; i < Buc_Number[j]; i++) {
+ ii++;
+ module_trans = new TGeoTranslation("", xPos, yPos, zPos);
+ module_combi_trans = new TGeoCombiTrans(*module_trans, *module_rot);
+ gGeoMan->GetVolume(geoVersionStand)->AddNode(gModules[modType], modNum, module_combi_trans);
+ modNum++;
+ yPos += Buc_Delta_Y_Position;
+ zPos += Buc_Delta_Z_Position;
+ }
+ }
+}
+
+void position_cer_modules(Int_t modNType)
+{
+ Int_t ii = 0;
+ Int_t modNum = 0;
+ for (Int_t j = 1; j < modNType; j++) {
+ Int_t modType = Cer_Types[j];
+ Float_t xPos = Cer_X_Position[j];
+ Float_t yPos = Cer_Y_Position[j];
+ Float_t zPos = Cer_Z_Position[j];
+ TGeoTranslation* module_trans = NULL;
+ TGeoRotation* module_rot = new TGeoRotation(Form("Cer%d", j), Cer_rotate_Z[j], -MeanTheta, 0.);
+ // module_rot->RotateZ(Cer_rotate_Z[j]);
+ TGeoCombiTrans* module_combi_trans = NULL;
+
+ for (Int_t i = 0; i < Cer_Number[j]; i++) {
+ ii++;
+ cout << "Position Ceramic Module " << i << " of " << Cer_Number[j] << " Type " << modType << " at X = " << xPos
+ << ", Y = " << yPos << ", Z = " << zPos << endl;
+ // Front staggered module (Top if pair), top
+ module_trans = new TGeoTranslation("", xPos, yPos, zPos);
+ module_combi_trans = new TGeoCombiTrans(*module_trans, *module_rot);
+ gGeoMan->GetVolume(geoVersionStand)->AddNode(gModules[modType], modNum, module_combi_trans);
+ // modNum++;
+ }
+ }
+}
+
+void position_Testbox_MRPC4(Int_t modNType)
+{
+ TGeoTranslation* module_trans = NULL;
+ TGeoRotation* module_rot = new TGeoRotation();
+ module_rot->RotateZ(Testbox_MRPC4_rotate_Z);
+ TGeoCombiTrans* module_combi_trans = NULL;
+
+ // Int_t numModules=(Int_t)( (Inner_Module_Last_Y_Position-Inner_Module_First_Y_Position)/Module_Size_Y[modType])+1;
+ Float_t yPos = Testbox_MRPC4_First_Y_Position;
+ Int_t ii = 0;
+ Float_t xPos = Testbox_MRPC4_X_Offset;
+ Float_t zPos = Testbox_MRPC4_Z_Position;
+
+ for (Int_t j = 0; j < modNType; j++) {
+ Int_t modType = Testbox_MRPC4_Types[j];
+ Int_t modNum = 0;
+ for (Int_t i = 0; i < Testbox_MRPC4_Number[j]; i++) {
+ ii++;
+ module_trans = new TGeoTranslation("", xPos, yPos, zPos);
+ module_combi_trans = new TGeoCombiTrans(*module_trans, *module_rot);
+ gGeoMan->GetVolume(geoVersionStand)->AddNode(gModules[modType], modNum, module_combi_trans);
+ modNum++;
+ }
+ }
+}
+
+void position_side_tof_modules(Int_t modNType)
+{
+ TGeoTranslation* module_trans = NULL;
+ TGeoRotation* module_rot = new TGeoRotation();
+ module_rot->RotateZ(180.);
+ TGeoCombiTrans* module_combi_trans = NULL;
+
+ // Int_t numModules=(Int_t)( (Inner_Module_Last_Y_Position-Inner_Module_First_Y_Position)/Module_Size_Y[modType])+1;
+ Float_t yPos = 0.; //Inner_Module_First_Y_Position;
+ Int_t ii = 0;
+ for (Int_t j = 0; j < modNType; j++) {
+ Int_t modType = InnerSide_Module_Types[j];
+ Int_t modNum = 0;
+ for (Int_t i = 0; i < InnerSide_Module_Number[j]; i++) {
+ ii++;
+ cout << "InnerSide ii " << ii << " Last " << Last_Size_Y << "," << Last_Over_Y << endl;
+ Float_t DeltaY = Module_Size_Y[modType] + Last_Size_Y - 2. * (Module_Over_Y[modType] + Last_Over_Y);
+ if (ii > 1) { yPos += DeltaY; }
+ Last_Size_Y = Module_Size_Y[modType];
+ Last_Over_Y = Module_Over_Y[modType];
+ Float_t xPos = InnerSide_Module_X_Offset;
+ Float_t zPos = Wall_Z_Position;
+ cout << "Position InnerSide Module " << i << " of " << InnerSide_Module_Number[j] << " Type " << modType
+ << " at Y = " << yPos << " Ysize = " << Module_Size_Y[modType] << " DeltaY = " << DeltaY << endl;
+
+ module_trans = new TGeoTranslation("", xPos, yPos, zPos);
+ gGeoMan->GetVolume(geoVersionStand)->AddNode(gModules[modType], modNum, module_trans);
+ modNum++;
+
+ module_trans = new TGeoTranslation("", -xPos, yPos, zPos);
+ module_combi_trans = new TGeoCombiTrans(*module_trans, *module_rot);
+ gGeoMan->GetVolume(geoVersionStand)->AddNode(gModules[modType], modNum, module_combi_trans);
+ modNum++;
+
+ if (ii > 1) {
+ module_trans = new TGeoTranslation("", xPos, -yPos, zPos);
+ gGeoMan->GetVolume(geoVersionStand)->AddNode(gModules[modType], modNum, module_trans);
+ modNum++;
+
+ module_trans = new TGeoTranslation("", -xPos, -yPos, zPos);
+ module_combi_trans = new TGeoCombiTrans(*module_trans, *module_rot);
+ gGeoMan->GetVolume(geoVersionStand)->AddNode(gModules[modType], modNum, module_combi_trans);
+ modNum++;
+
+ module_trans = new TGeoTranslation("", xPos, yPos - DeltaY / 2, zPos + Module_Size_Z[modType]);
+ gGeoMan->GetVolume(geoVersionStand)->AddNode(gModules[modType], modNum, module_trans);
+ modNum++;
+
+ module_trans = new TGeoTranslation("", -xPos, yPos - DeltaY / 2, zPos + Module_Size_Z[modType]);
+ module_combi_trans = new TGeoCombiTrans(*module_trans, *module_rot);
+ gGeoMan->GetVolume(geoVersionStand)->AddNode(gModules[modType], modNum, module_combi_trans);
+ modNum++;
+
+ module_trans = new TGeoTranslation("", xPos, -(yPos - DeltaY / 2), zPos + Module_Size_Z[modType]);
+ gGeoMan->GetVolume(geoVersionStand)->AddNode(gModules[modType], modNum, module_trans);
+ modNum++;
+
+ module_trans = new TGeoTranslation("", -xPos, -(yPos - DeltaY / 2), zPos + Module_Size_Z[modType]);
+ module_combi_trans = new TGeoCombiTrans(*module_trans, *module_rot);
+ gGeoMan->GetVolume(geoVersionStand)->AddNode(gModules[modType], modNum, module_combi_trans);
+ modNum++;
+ }
+ }
+ }
+}
+
+void position_outer_tof_modules(Int_t nCol) //modType, Int_t col1, Int_t col2)
+{
+ TGeoTranslation* module_trans = NULL;
+ TGeoRotation* module_rot = new TGeoRotation();
+ module_rot->RotateZ(180.);
+ TGeoCombiTrans* module_combi_trans = NULL;
+
+ // Int_t numModules=(Int_t)( (Outer_Module_Last_Y_Position-Outer_Module_First_Y_Position)/Module_Size_Y[modType])+1;
+
+ Int_t modNum[NofModuleTypes];
+ for (Int_t k = 0; k < NofModuleTypes; k++) {
+ modNum[k] = 0;
+ }
+
+ Float_t zPos = Wall_Z_Position;
+ for (Int_t j = 0; j < nCol; j++) {
+ Float_t xPos = Outer_Module_X_Offset + ((j + 1) * DxColl);
+ Last_Size_Y = 0.;
+ Last_Over_Y = 0.;
+ Float_t yPos = 0.;
+ Int_t ii = 0;
+ Float_t DzPos = 0.;
+ for (Int_t k = 0; k < Outer_Module_NTypes; k++) {
+ Int_t modType = Outer_Module_Types[k][j];
+ if (Module_Size_Z[modType] > DzPos) {
+ if (Outer_Module_Number[k][j] > 0) { DzPos = Module_Size_Z[modType]; }
+ }
+ }
+
+ zPos -= 2. * DzPos; //((j+1)*2*Module_Size_Z[modType]);
+
+ Pole_ZPos[NumberOfPoles] = zPos;
+ Pole_Col[NumberOfPoles] = j + 1;
+ NumberOfPoles++;
+ Pole_ZPos[NumberOfPoles] = zPos + DzPos;
+ Pole_Col[NumberOfPoles] = j + 1;
+ NumberOfPoles++;
+ //if (j+1==nCol) {
+ if (1) {
+ Pole_ZPos[NumberOfPoles] = Pole_ZPos[0];
+ Pole_Col[NumberOfPoles] = j + 1;
+ NumberOfPoles++;
+
+ Bar_Size_Z = Pole_ZPos[0] - zPos;
+ gBar[NumberOfBars] = create_tof_bar(Bar_Size_X, Bar_Size_Y, Bar_Size_Z);
+ Bar_ZPos[NumberOfBars] = zPos + Bar_Size_Z / 2. - Pole_Size_Z / 2.;
+ Bar_XPos[NumberOfBars] = xPos + Pole_Offset;
+ NumberOfBars++;
+ }
+
+ for (Int_t k = 0; k < Outer_Module_NTypes; k++) {
+ Int_t modType = Outer_Module_Types[k][j];
+ Int_t numModules = Outer_Module_Number[k][j];
+
+ cout << " Outer: position " << numModules << " of type " << modType << " in col " << j << " at z = " << zPos
+ << ", DzPos = " << DzPos << endl;
+ for (Int_t i = 0; i < numModules; i++) {
+ ii++;
+ cout << "Outer ii " << ii << " Last " << Last_Size_Y << "," << Last_Over_Y << endl;
+ Float_t DeltaY = Module_Size_Y[modType] + Last_Size_Y - 2. * (Module_Over_Y[modType] + Last_Over_Y);
+ if (ii > 1) { yPos += DeltaY; }
+ Last_Size_Y = Module_Size_Y[modType];
+ Last_Over_Y = Module_Over_Y[modType];
+ cout << "Position Outer Module " << i << " of " << Outer_Module_Number[k][j] << " Type " << modType << "(#"
+ << modNum[modType] << ") "
+ << " at Y = " << yPos << " Ysize = " << Module_Size_Y[modType] << " DeltaY = " << DeltaY << endl;
+
+ module_trans = new TGeoTranslation("", xPos, yPos, zPos);
+ gGeoMan->GetVolume(geoVersionStand)->AddNode(gModules[modType], modNum[modType], module_trans);
+ modNum[modType]++;
+
+ module_trans = new TGeoTranslation("", -xPos, yPos, zPos);
+ module_combi_trans = new TGeoCombiTrans(*module_trans, *module_rot);
+ gGeoMan->GetVolume(geoVersionStand)->AddNode(gModules[modType], modNum[modType], module_combi_trans);
+ modNum[modType]++;
+
+ if (ii > 1) {
+ module_trans = new TGeoTranslation("", xPos, -yPos, zPos);
+ gGeoMan->GetVolume(geoVersionStand)->AddNode(gModules[modType], modNum[modType], module_trans);
+ modNum[modType]++;
+ module_trans = new TGeoTranslation("", -xPos, -yPos, zPos);
+ module_combi_trans = new TGeoCombiTrans(*module_trans, *module_rot);
+ gGeoMan->GetVolume(geoVersionStand)->AddNode(gModules[modType], modNum[modType], module_combi_trans);
+ modNum[modType]++;
+
+ // second layer
+ module_trans = new TGeoTranslation("", xPos, yPos - DeltaY / 2., zPos + DzPos);
+ gGeoMan->GetVolume(geoVersionStand)->AddNode(gModules[modType], modNum[modType], module_trans);
+ modNum[modType]++;
+ module_trans = new TGeoTranslation("", -xPos, yPos - DeltaY / 2., zPos + DzPos);
+ module_combi_trans = new TGeoCombiTrans(*module_trans, *module_rot);
+ gGeoMan->GetVolume(geoVersionStand)->AddNode(gModules[modType], modNum[modType], module_combi_trans);
+ modNum[modType]++;
+
+ module_trans = new TGeoTranslation("", xPos, -(yPos - DeltaY / 2.), zPos + DzPos);
+ gGeoMan->GetVolume(geoVersionStand)->AddNode(gModules[modType], modNum[modType], module_trans);
+ modNum[modType]++;
+ module_trans = new TGeoTranslation("", -xPos, -(yPos - DeltaY / 2.), zPos + DzPos);
+ module_combi_trans = new TGeoCombiTrans(*module_trans, *module_rot);
+ gGeoMan->GetVolume(geoVersionStand)->AddNode(gModules[modType], modNum[modType], module_combi_trans);
+ modNum[modType]++;
+ }
+ }
+ }
+ }
+}
+
+
+void dump_info_file()
+{
+ TDatime datetime; // used to get timestamp
+
+ printf("writing info 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());
+
+ fprintf(ifile, "# TOF setup\n");
+ if (TOF_Z_Front == 450) fprintf(ifile, "SIS 100 hadron setup\n");
+ if (TOF_Z_Front == 600) fprintf(ifile, "SIS 100 electron\n");
+ if (TOF_Z_Front == 650) fprintf(ifile, "SIS 100 muon\n");
+ if (TOF_Z_Front == 880) fprintf(ifile, "SIS 300 electron\n");
+ if (TOF_Z_Front == 1020) fprintf(ifile, "SIS 300 muon\n");
+ fprintf(ifile, "\n");
+
+ const Float_t TOF_Z_Back = Wall_Z_Position + 1.5 * Module_Size_Z[0]; // back of TOF wall
+
+ fprintf(ifile, "# envelope\n");
+ // Show extension of TRD
+ fprintf(ifile, "%7.2f cm start of TOF (z)\n", TOF_Z_Front);
+ fprintf(ifile, "%7.2f cm end of TOF (z)\n", TOF_Z_Back);
+ fprintf(ifile, "\n");
+
+ // Layer thickness
+ fprintf(ifile, "# central tower position\n");
+ fprintf(ifile, "%7.2f cm center of staggered, front RPC cell at x=0\n", Wall_Z_Position);
+ fprintf(ifile, "\n");
+
+ fclose(ifile);
+}
diff --git a/tof/tof_v24d_mcbm.geo.info b/tof/tof_v24d_mcbm.geo.info
new file mode 100644
index 0000000..bac4e71
--- /dev/null
+++ b/tof/tof_v24d_mcbm.geo.info
@@ -0,0 +1,15 @@
+#
+## tof_v24d_mcbm information file
+#
+
+# created 20240617
+
+# TOF setup
+
+# envelope
+ 0.00 cm start of TOF (z)
+ 416.50 cm end of TOF (z)
+
+# central tower position
+ 400.00 cm center of staggered, front RPC cell at x=0
+
diff --git a/tof/tof_v24d_mcbm.geo.root b/tof/tof_v24d_mcbm.geo.root
new file mode 100644
index 0000000000000000000000000000000000000000..19f45d24999b16886a747e96460866c6cb74dac7
GIT binary patch
literal 12943
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
literal 0
HcmV?d00001
--
GitLab