BmnRoot 26.10.0-18-g4e3414f9
Software framework of the BM@N experiment
Loading...
Searching...
No Matches
create_rootgeom_GEMS_v2.C
Go to the documentation of this file.
1//---------------------------
2#include "TFile.h"
3#include "TGeoBBox.h"
4#include "TGeoManager.h"
5#include "TGeoShape.h"
6#include "TMath.h"
7#include "TString.h"
8
9using namespace TMath;
10
11// GeoManager
12TGeoManager* gGeoMan = NULL;
13
14// Set Parameters of GEMS
15const Int_t nStations = 12;
16
17// Stantion Parameters
18const Double_t XSizeOfStation[nStations] = {60, 60, 80, 132, 160, 160, 240, 240, 240, 240, 240, 240};
19const Double_t YSizeOfStation[nStations] = {60, 60, 80, 82, 80, 80, 80, 80, 80, 80, 80, 80};
20const Double_t ZStantionPosition[nStations] = {30, 50, 70, 90, 110, 140, 170, 200, 240, 280, 320, 360};
21
22// Beam Pipe Hole Parameters
23const Double_t BeamPipeMinRadius = 2.5; // radius of the hole in first GEM-station
24const Double_t BeamPipeMaxRadius = 5.0; // radius of the hole in last GEM-station
25Double_t BeamPipeRadius[nStations];
26
27// Module Parameters
28const Int_t nModulesInStation = 4;
29const Double_t dXOuterFrame = 5.0;
30const Double_t dXInnerFrame = 1.7;
31const Double_t dYOuterFrame = 3.75;
32const Double_t dYInnerFrame = 1.7;
33const Double_t dZSensitiveVolume = 1.0;
34const Double_t ZModuleSize = 2.5;
35
36Double_t XModuleSize[nStations];
37Double_t YModuleSize[nStations];
38
39const Double_t XSizeSpacer = 10.0;
40const Double_t YSizeSpacer = 10.0;
41const Double_t SpacerWidth = 0.2;
42const Double_t SpacerThickness = dZSensitiveVolume;
43
44// Position of GEM-Detector
45const Bool_t StationCenterPosition = kFALSE;
46const Double_t ZDisplacementOfDetector = (ZModuleSize * 2) / 2;
47
48// Add spacers or not?
49const Bool_t WithSpacers = kTRUE;
50
51void CalculateParameters()
52{
53 // Calculate the Beam Pipe Radius for each GEM-stations
54 Double_t BeamPipeAngle =
55 (ATan((BeamPipeMaxRadius - BeamPipeMinRadius) / (ZStantionPosition[nStations - 1] - ZStantionPosition[0])))
56 * 180 / Pi();
57 BeamPipeRadius[0] = BeamPipeMinRadius;
58 BeamPipeRadius[nStations - 1] = BeamPipeMaxRadius;
59 Double_t delta_const = BeamPipeMaxRadius - BeamPipeMinRadius;
60 for (UInt_t iStation = 1; iStation < nStations - 1; iStation++) {
61 BeamPipeRadius[iStation] =
62 delta_const + (ZStantionPosition[iStation] - ZStantionPosition[0]) * Tan((BeamPipeAngle * Pi() / 180));
63 }
64 cout << "Beam Pipe Angle = " << BeamPipeAngle << " deg" << "\n";
65 cout << "Beam Pipe Radiuses:" << "\n";
66 for (UInt_t iStation = 0; iStation < nStations; iStation++) {
67 cout << " Station[" << iStation << "] = " << BeamPipeRadius[iStation] << " cm" << "\n";
68 }
69 cout << "----------------------------" << "\n";
70
71 // Calculate sizes of Modules
72 cout << "Modules Size ( X : Y ):" << "\n";
73 for (UInt_t iStation = 0; iStation < nStations; iStation++) {
74 XModuleSize[iStation] = XSizeOfStation[iStation] / 2;
75 YModuleSize[iStation] = YSizeOfStation[iStation] / 2;
76 cout << " Modules[" << iStation << "] = " << XModuleSize[iStation] << " : " << YModuleSize[iStation]
77 << "\n";
78 }
79 cout << "----------------------------" << "\n";
80}
81
82void create_rootgeom_GEMS_v2()
83{
84
85 CalculateParameters();
86
87 // Load the necessary FairRoot libraries
88 gROOT->LoadMacro("$VMCWORKDIR/macro/run/bmnloadlibs.C");
89 bmnloadlibs(); // load libraries
90
91 // ------- Load media from media file -----------------------------------
92 FairGeoLoader* geoLoad = new FairGeoLoader("TGeo", "FairGeoLoader");
93 FairGeoInterface* geoFace = geoLoad->getGeoInterface();
94 TString geoPath = gSystem->Getenv("VMCWORKDIR");
95 TString medFile = geoPath + "/geometry/media.geo";
96 geoFace->setMediaFile(medFile);
97 geoFace->readMedia();
98 gGeoMan = gGeoManager;
99 // --------------------------------------------------------------------------
100
101 // ------- Geometry file name (output) ----------------------------------
102 const TString geoDetectorName = "GEMS";
103 const TString geoDetectorVersion = "v2";
104 const TString geoFileName = geoPath + "/geometry/" + geoDetectorName + "_" + geoDetectorVersion + ".root";
105 // --------------------------------------------------------------------------
106
107 // ----------------- Get and create the required media -----------------
108 FairGeoMedia* geoMedia = geoFace->getMedia();
109 FairGeoBuilder* geoBuild = geoLoad->getGeoBuilder();
110
111 FairGeoMedium* mAir = geoMedia->getMedium("air");
112 if (!mAir)
113 Fatal("Main", "FairMedium air not found");
114 geoBuild->createMedium(mAir);
115 TGeoMedium* pMedAir = gGeoMan->GetMedium("air");
116 if (!pMedAir)
117 Fatal("Main", "Medium air not found");
118
119 FairGeoMedium* mCarbon = geoMedia->getMedium("carbon");
120 if (!mCarbon)
121 Fatal("Main", "FairMedium carbon not found");
122 geoBuild->createMedium(mCarbon);
123 TGeoMedium* pMedCarbon = gGeoMan->GetMedium("carbon");
124 if (!pMedCarbon)
125 Fatal("Main", "Medium carbon not found");
126
127 FairGeoMedium* mFiberGlass = geoMedia->getMedium("fiberglass");
128 if (!mFiberGlass)
129 Fatal("Main", "FairMedium fiberglass not found");
130 geoBuild->createMedium(mFiberGlass);
131 TGeoMedium* pMedFiberGlass = gGeoMan->GetMedium("fiberglass");
132 if (!pMedFiberGlass)
133 Fatal("Main", "Medium fiberglass not found");
134
135 FairGeoMedium* mArCO27030 = geoMedia->getMedium("arco27030");
136 if (!mArCO27030)
137 Fatal("Main", "FairMedium arco27030 not found");
138 geoBuild->createMedium(mArCO27030);
139 TGeoMedium* pMedArCO27030 = gGeoMan->GetMedium("arco27030");
140 if (!pMedArCO27030)
141 Fatal("Main", "Medium arco27030 not found");
142
143 // --------------------------------------------------------------------------
144
145 // -------------- Create geometry and top volume -------------------------
146 gGeoMan = (TGeoManager*)gROOT->FindObject("FAIRGeom");
147 gGeoMan->SetName(geoDetectorName + "_geom");
148 TGeoVolume* top = new TGeoVolumeAssembly("TOP");
149 top->SetMedium(pMedAir);
150 gGeoMan->SetTopVolume(top);
151 // gGeoMan->SetTopVisible(1);
152 // --------------------------------------------------------------------------
153
154 // Define TOP Geometry
155 TGeoVolume* GEMSTop = new TGeoVolumeAssembly(geoDetectorName);
156 GEMSTop->SetMedium(pMedAir);
157
158 // Shapes and volume pointers
159 TGeoBBox* StationS[nStations];
160 TGeoVolume* StationV[nStations];
161
162 TGeoBBox* BeamPipeHoleS[nStations];
163 TGeoCompositeShape* StationWithHoleS[nStations];
164
165 TGeoBBox* ModuleS[nStations];
166 TGeoVolume* ModuleV[nStations][nModulesInStation];
167
168 TGeoBBox* VerticalOuterFrameS[nStations];
169 TGeoBBox* HorizontalOuterFrameS[nStations];
170 TGeoBBox* HorizontalInnerFrameS[nStations];
171 TGeoBBox* VerticalInnerFrameS[nStations];
172
173 TGeoVolume* VerticalOuterFrameV[nStations];
174 TGeoVolume* HorizontalOuterFrameV[nStations];
175 TGeoVolume* HorizontalInnerFrameV[nStations];
176 TGeoVolume* VerticalInnerFrameV[nStations];
177
178 TGeoBBox* SensitiveVolumeS[nStations];
179 TGeoVolume* SensitiveVolumeV[nStations][nModulesInStation];
180
181 TGeoBBox* HorizontalSpacerS[nStations];
182 TGeoBBox* VerticalSpacerPartS[nStations];
183 TGeoBBox* VerticalSpacerSmallPartS[nStations];
184
185 TGeoVolume* HorizontalSpacerV[nStations];
186 TGeoVolume* VerticalSpacerPartV[nStations];
187 TGeoVolume* VerticalSpacerSmallPartV[nStations];
188
189 TGeoVolumeAssembly* SpacerBoxV[nStations][nModulesInStation];
190
191 TGeoVolumeAssembly* FrameBoxV[nStations][nModulesInStation];
192
193 TGeoTranslation* VerticalOuterFrameVPosition[nStations][nModulesInStation];
194 TGeoTranslation* HorizontalOuterFrameVPosition[nStations][nModulesInStation];
195 TGeoTranslation* HorizontalInnerFrameVPosition[nStations][nModulesInStation];
196 TGeoTranslation* VerticalInnerFrameVPosition[nStations][nModulesInStation];
197
198 TGeoRotation* SpacerBoxVRot[nModulesInStation];
199
200 TGeoTranslation* SensitiveVolumePosition[nStations][nModulesInStation];
201
202 TGeoTranslation* ModulePosition[nStations][nModulesInStation];
203 //------------------------------------------------------------------------------
204
205 for (Int_t iStation = 0; iStation < nStations; iStation++) {
206
207 // Creating spacers
208 Int_t NHorizontalSpacers =
209 (Int_t)((YModuleSize[iStation] - (dYInnerFrame + dYOuterFrame)) / (YSizeSpacer + SpacerWidth));
210 Int_t NVerticalSpacers =
211 (Int_t)((XModuleSize[iStation] - (dXInnerFrame + dXOuterFrame)) / (XSizeSpacer + SpacerWidth));
212 Double_t YSizeSmallPart = (YModuleSize[iStation] - (dYInnerFrame + dYOuterFrame)) / (YSizeSpacer + SpacerWidth);
213 YSizeSmallPart -= (Int_t)YSizeSmallPart;
214 YSizeSmallPart *= YSizeSpacer + SpacerWidth;
215
216 HorizontalSpacerS[iStation] =
217 new TGeoBBox("HorizontalSpacerS", (XModuleSize[iStation] - (dXInnerFrame + dXOuterFrame)) / 2,
218 SpacerWidth / 2, SpacerThickness / 2);
219 HorizontalSpacerV[iStation] = new TGeoVolume("HorizontalSpacerV", HorizontalSpacerS[iStation]);
220 HorizontalSpacerV[iStation]->SetMedium(pMedCarbon);
221 HorizontalSpacerV[iStation]->SetLineColor(kYellow);
222 HorizontalSpacerV[iStation]->SetTransparency(10);
223
224 VerticalSpacerPartS[iStation] =
225 new TGeoBBox("VerticalSpacerPartS", SpacerWidth / 2, YSizeSpacer / 2, SpacerThickness / 2);
226 VerticalSpacerPartV[iStation] = new TGeoVolume("VerticalSpacerPartV", VerticalSpacerPartS[iStation]);
227 VerticalSpacerPartV[iStation]->SetMedium(pMedCarbon);
228 VerticalSpacerPartV[iStation]->SetLineColor(kYellow);
229 VerticalSpacerPartV[iStation]->SetTransparency(10);
230
231 VerticalSpacerSmallPartS[iStation] =
232 new TGeoBBox("VerticalSpacerSmallPartS", SpacerWidth / 2, YSizeSmallPart / 2, SpacerThickness / 2);
233 VerticalSpacerSmallPartV[iStation] =
234 new TGeoVolume("VerticalSpacerSmallPartV", VerticalSpacerSmallPartS[iStation]);
235 VerticalSpacerSmallPartV[iStation]->SetMedium(pMedCarbon);
236 VerticalSpacerSmallPartV[iStation]->SetLineColor(kYellow);
237 VerticalSpacerSmallPartV[iStation]->SetTransparency(10);
238
239 for (Int_t iModule = 0; iModule < nModulesInStation; iModule++) {
240 SpacerBoxV[iStation][iModule] = new TGeoVolumeAssembly("SpacerBoxV");
241 SpacerBoxV[iStation][iModule]->SetMedium(pMedArCO27030);
242
243 Int_t hpart_cnt = 0;
244 Int_t vpart_cnt = 0;
245 for (Int_t ihspacer = 0; ihspacer < NHorizontalSpacers; ihspacer++) {
246 Double_t ydisph = ((YModuleSize[iStation] - (dYInnerFrame + dYOuterFrame)) / 2 - SpacerWidth / 2)
247 - YSizeSpacer * (ihspacer + 1) - SpacerWidth * ihspacer;
248 SpacerBoxV[iStation][iModule]->AddNode(HorizontalSpacerV[iStation], hpart_cnt,
249 new TGeoTranslation(0, ydisph, 0));
250 hpart_cnt++;
251
252 for (Int_t ivspacer = 0; ivspacer < NVerticalSpacers; ivspacer++) {
253 Double_t xdispv = (-(XModuleSize[iStation] - (dXInnerFrame + dXOuterFrame)) / 2 + SpacerWidth / 2)
254 + XSizeSpacer * (ivspacer + 1) + SpacerWidth * ivspacer;
255 Double_t ydispv = (YModuleSize[iStation] - (dYInnerFrame + dYOuterFrame)) / 2 - YSizeSpacer / 2
256 - (YSizeSpacer + SpacerWidth) * ihspacer;
257 SpacerBoxV[iStation][iModule]->AddNode(VerticalSpacerPartV[iStation], vpart_cnt,
258 new TGeoTranslation(xdispv, ydispv, 0));
259 vpart_cnt++;
260
261 if (ihspacer == NHorizontalSpacers - 1) {
262 Double_t ydispvs = (YModuleSize[iStation] - (dYInnerFrame + dYOuterFrame)) / 2 - YSizeSpacer / 2
263 - (YSizeSpacer + SpacerWidth) * (ihspacer + 1)
264 + (YSizeSpacer - YSizeSmallPart) / 2;
265 SpacerBoxV[iStation][iModule]->AddNode(VerticalSpacerSmallPartV[iStation], ivspacer,
266 new TGeoTranslation(xdispv, ydispvs, 0));
267 }
268 }
269 }
270 }
271
272 // Creating sensitive shapes and volumes + Adding spacer boxes to sensitive volumes
273 SensitiveVolumeS[iStation] =
274 new TGeoBBox("SensitiveVolumeS", (XModuleSize[iStation] - (dXOuterFrame + dXInnerFrame)) / 2,
275 (YModuleSize[iStation] - (dYOuterFrame + dYInnerFrame)) / 2, dZSensitiveVolume / 2);
276 for (Int_t iModule = 0; iModule < nModulesInStation; iModule++) {
277 SensitiveVolumeV[iStation][iModule] = new TGeoVolume("SensitiveVolume_SensorV", SensitiveVolumeS[iStation]);
278 SensitiveVolumeV[iStation][iModule]->SetMedium(pMedArCO27030);
279 SensitiveVolumeV[iStation][iModule]->SetLineColor(kRed);
280 SensitiveVolumeV[iStation][iModule]->SetTransparency(50);
281 // SensitiveVolumeV->SetVisibility(kFALSE);
282
283 SpacerBoxVRot[iModule] = new TGeoRotation();
284
285 switch (iModule) {
286 case 0:
287 SpacerBoxVRot[iModule]->SetAngles(0, 0, 0);
288 break;
289
290 case 1:
291 SpacerBoxVRot[iModule]->SetAngles(0, 180, 180);
292 break;
293
294 case 2:
295 SpacerBoxVRot[iModule]->SetAngles(180, 0, 0);
296 break;
297
298 case 3:
299 SpacerBoxVRot[iModule]->SetAngles(0, 180, 0);
300 break;
301 }
302
303 if (WithSpacers)
304 SensitiveVolumeV[iStation][iModule]->AddNode(SpacerBoxV[iStation][iModule], iModule,
305 SpacerBoxVRot[iModule]);
306 }
307
308 // Creating border frames shapes and volumes
309 VerticalOuterFrameS[iStation] =
310 new TGeoBBox("VerticalOuterFrameS", dXOuterFrame / 2, YModuleSize[iStation] / 2, ZModuleSize / 2);
311 VerticalOuterFrameV[iStation] = new TGeoVolume("VerticalOuterFrameV", VerticalOuterFrameS[iStation]);
312 VerticalOuterFrameV[iStation]->SetMedium(pMedFiberGlass);
313 VerticalOuterFrameV[iStation]->SetLineColor(kBlue);
314 VerticalOuterFrameV[iStation]->SetTransparency(40);
315
316 HorizontalOuterFrameS[iStation] =
317 new TGeoBBox("HorizontalOuterFrameS", (XModuleSize[iStation] - dXOuterFrame) / 2, dYOuterFrame / 2,
318 (ZModuleSize[iStation] - dZSensitiveVolume) / 2);
319 HorizontalOuterFrameV[iStation] = new TGeoVolume("HorizontalOuterFrameV", HorizontalOuterFrameS[iStation]);
320 HorizontalOuterFrameV[iStation]->SetMedium(pMedFiberGlass);
321 HorizontalOuterFrameV[iStation]->SetLineColor(kBlue);
322 HorizontalOuterFrameV[iStation]->SetTransparency(40);
323
324 HorizontalInnerFrameS[iStation] =
325 new TGeoBBox("HorizontalInnerFrameS", (XModuleSize[iStation] - dXOuterFrame) / 2, dYInnerFrame / 2,
326 (ZModuleSize[iStation] - dZSensitiveVolume) / 2);
327 HorizontalInnerFrameV[iStation] = new TGeoVolume("HorizontalInnerFrameV", HorizontalInnerFrameS[iStation]);
328 HorizontalInnerFrameV[iStation]->SetMedium(pMedFiberGlass);
329 HorizontalInnerFrameV[iStation]->SetLineColor(kBlue);
330 HorizontalInnerFrameV[iStation]->SetTransparency(40);
331
332 VerticalInnerFrameS[iStation] = new TGeoBBox("VerticalInnerFrameS", dXInnerFrame / 2,
333 (YModuleSize[iStation] - dYInnerFrame - dYOuterFrame) / 2,
334 (ZModuleSize[iStation] - dZSensitiveVolume) / 2);
335 VerticalInnerFrameV[iStation] = new TGeoVolume("VerticalInnerFrameV", VerticalInnerFrameS[iStation]);
336 VerticalInnerFrameV[iStation]->SetMedium(pMedFiberGlass);
337 VerticalInnerFrameV[iStation]->SetLineColor(kBlue);
338 VerticalInnerFrameV[iStation]->SetTransparency(40);
339
340 // Creating box frames from parts
341 for (Int_t iModule = 0; iModule < nModulesInStation; iModule++) {
342 FrameBoxV[iStation][iModule] = new TGeoVolumeAssembly("FrameBoxV");
343 FrameBoxV[iStation][iModule]->SetMedium(pMedAir);
344
345 VerticalOuterFrameVPosition[iStation][iModule] = new TGeoTranslation();
346 HorizontalOuterFrameVPosition[iStation][iModule] = new TGeoTranslation();
347 HorizontalInnerFrameVPosition[iStation][iModule] = new TGeoTranslation();
348 VerticalInnerFrameVPosition[iStation][iModule] = new TGeoTranslation();
349
350 switch (iModule) {
351 case 0:
352 VerticalOuterFrameVPosition[iStation][iModule]->SetTranslation(
353 XModuleSize[iStation] / 2 - dXOuterFrame / 2, 0.0, 0.0);
354 HorizontalOuterFrameVPosition[iStation][iModule]->SetTranslation(
355 -dXOuterFrame / 2, -(YModuleSize[iStation] / 2 - dYOuterFrame / 2),
356 -(ZModuleSize[iStation] / 2 - (ZModuleSize[iStation] - dZSensitiveVolume) / 2));
357 HorizontalInnerFrameVPosition[iStation][iModule]->SetTranslation(
358 -dXOuterFrame / 2, YModuleSize[iStation] / 2 - dYInnerFrame / 2,
359 -(ZModuleSize[iStation] / 2 - (ZModuleSize[iStation] - dZSensitiveVolume) / 2));
360 VerticalInnerFrameVPosition[iStation][iModule]->SetTranslation(
361 -(XModuleSize[iStation] / 2 - dXInnerFrame / 2), dYOuterFrame / 2 - dYInnerFrame / 2,
362 -(ZModuleSize[iStation] / 2 - (ZModuleSize[iStation] - dZSensitiveVolume) / 2));
363 break;
364
365 case 1:
366 VerticalOuterFrameVPosition[iStation][iModule]->SetTranslation(
367 -(XModuleSize[iStation] / 2 - dXOuterFrame / 2), 0.0, 0.0);
368 HorizontalOuterFrameVPosition[iStation][iModule]->SetTranslation(
369 dXOuterFrame / 2, -(YModuleSize[iStation] / 2 - dYOuterFrame / 2),
370 ZModuleSize[iStation] / 2 - (ZModuleSize[iStation] - dZSensitiveVolume) / 2);
371 HorizontalInnerFrameVPosition[iStation][iModule]->SetTranslation(
372 dXOuterFrame / 2, YModuleSize[iStation] / 2 - dYInnerFrame / 2,
373 ZModuleSize[iStation] / 2 - (ZModuleSize[iStation] - dZSensitiveVolume) / 2);
374 VerticalInnerFrameVPosition[iStation][iModule]->SetTranslation(
375 XModuleSize[iStation] / 2 - dXInnerFrame / 2, dYOuterFrame / 2 - dYInnerFrame / 2,
376 ZModuleSize[iStation] / 2 - (ZModuleSize[iStation] - dZSensitiveVolume) / 2);
377 break;
378
379 case 2:
380 VerticalOuterFrameVPosition[iStation][iModule]->SetTranslation(
381 -(XModuleSize[iStation] / 2 - dXOuterFrame / 2), 0.0, 0.0);
382 HorizontalOuterFrameVPosition[iStation][iModule]->SetTranslation(
383 dXOuterFrame / 2, YModuleSize[iStation] / 2 - dYOuterFrame / 2,
384 -(ZModuleSize[iStation] / 2 - (ZModuleSize[iStation] - dZSensitiveVolume) / 2));
385 HorizontalInnerFrameVPosition[iStation][iModule]->SetTranslation(
386 dXOuterFrame / 2, -(YModuleSize[iStation] / 2 - dYInnerFrame / 2),
387 -(ZModuleSize[iStation] / 2 - (ZModuleSize[iStation] - dZSensitiveVolume) / 2));
388 VerticalInnerFrameVPosition[iStation][iModule]->SetTranslation(
389 XModuleSize[iStation] / 2 - dXInnerFrame / 2, -(dYOuterFrame / 2 - dYInnerFrame / 2),
390 -(ZModuleSize[iStation] / 2 - (ZModuleSize[iStation] - dZSensitiveVolume) / 2));
391 break;
392
393 case 3:
394 VerticalOuterFrameVPosition[iStation][iModule]->SetTranslation(
395 XModuleSize[iStation] / 2 - dXOuterFrame / 2, 0.0, 0.0);
396 HorizontalOuterFrameVPosition[iStation][iModule]->SetTranslation(
397 -dXOuterFrame / 2, YModuleSize[iStation] / 2 - dYOuterFrame / 2,
398 ZModuleSize[iStation] / 2 - (ZModuleSize[iStation] - dZSensitiveVolume) / 2);
399 HorizontalInnerFrameVPosition[iStation][iModule]->SetTranslation(
400 -dXOuterFrame / 2, -(YModuleSize[iStation] / 2 - dYInnerFrame / 2),
401 ZModuleSize[iStation] / 2 - (ZModuleSize[iStation] - dZSensitiveVolume) / 2);
402 VerticalInnerFrameVPosition[iStation][iModule]->SetTranslation(
403 -(XModuleSize[iStation] / 2 - dXInnerFrame / 2), -(dYOuterFrame / 2 - dYInnerFrame / 2),
404 ZModuleSize[iStation] / 2 - (ZModuleSize[iStation] - dZSensitiveVolume) / 2);
405 break;
406 }
407
408 FrameBoxV[iStation][iModule]->AddNode(VerticalOuterFrameV[iStation], iModule,
409 VerticalOuterFrameVPosition[iStation][iModule]);
410 FrameBoxV[iStation][iModule]->AddNode(HorizontalOuterFrameV[iStation], iModule,
411 HorizontalOuterFrameVPosition[iStation][iModule]);
412 FrameBoxV[iStation][iModule]->AddNode(HorizontalInnerFrameV[iStation], iModule,
413 HorizontalInnerFrameVPosition[iStation][iModule]);
414 FrameBoxV[iStation][iModule]->AddNode(VerticalInnerFrameV[iStation], iModule,
415 VerticalInnerFrameVPosition[iStation][iModule]);
416 }
417
418 // Creating modules from parts
419 ModuleS[iStation] =
420 new TGeoBBox("ModuleS", XModuleSize[iStation] / 2, YModuleSize[iStation] / 2, ZModuleSize / 2);
421
422 for (Int_t iModule = 0; iModule < nModulesInStation; iModule++) {
423 ModuleV[iStation][iModule] = new TGeoVolume("ModuleV", ModuleS[iStation]);
424 ModuleV[iStation][iModule]->SetMedium(pMedAir);
425 ModuleV[iStation][iModule]->SetLineColor(kYellow);
426 ModuleV[iStation][iModule]->SetTransparency(40);
427 // ModuleV[iModule]->SetVisibility(kFALSE);
428
429 SensitiveVolumePosition[iStation][iModule] = new TGeoTranslation();
430
431 switch (iModule) {
432 case 0:
433 SensitiveVolumePosition[iStation][iModule]->SetTranslation(
434 -((XModuleSize[iStation] - (XModuleSize[iStation] - (dXOuterFrame + dXInnerFrame))) / 2
435 - dXInnerFrame),
436 (YModuleSize[iStation] - (YModuleSize[iStation] - (dYOuterFrame + dYInnerFrame))) / 2
437 - dYInnerFrame,
438 (ZModuleSize - dZSensitiveVolume) / 2);
439 break;
440
441 case 1:
442 SensitiveVolumePosition[iStation][iModule]->SetTranslation(
443 (XModuleSize[iStation] - (XModuleSize[iStation] - (dXOuterFrame + dXInnerFrame))) / 2
444 - dXInnerFrame,
445 (YModuleSize[iStation] - (YModuleSize[iStation] - (dYOuterFrame + dYInnerFrame))) / 2
446 - dYInnerFrame,
447 -(ZModuleSize - dZSensitiveVolume) / 2);
448 break;
449
450 case 2:
451 SensitiveVolumePosition[iStation][iModule]->SetTranslation(
452 (XModuleSize[iStation] - (XModuleSize[iStation] - (dXOuterFrame + dXInnerFrame))) / 2
453 - dXInnerFrame,
454 (YModuleSize[iStation] - (YModuleSize[iStation] - (dYOuterFrame + dYInnerFrame))) / 2
455 - dYOuterFrame,
456 (ZModuleSize - dZSensitiveVolume) / 2);
457 break;
458
459 case 3:
460 SensitiveVolumePosition[iStation][iModule]->SetTranslation(
461 -((XModuleSize[iStation] - (XModuleSize[iStation] - (dXOuterFrame + dXInnerFrame))) / 2
462 - dXInnerFrame),
463 (YModuleSize[iStation] - (YModuleSize[iStation] - (dYOuterFrame + dYInnerFrame))) / 2
464 - dYOuterFrame,
465 -(ZModuleSize - dZSensitiveVolume) / 2);
466 break;
467 }
468
469 ModuleV[iStation][iModule]->AddNode(FrameBoxV[iStation][iModule], iModule);
470 ModuleV[iStation][iModule]->AddNode(SensitiveVolumeV[iStation][iModule], 0,
471 SensitiveVolumePosition[iStation][iModule]);
472 }
473
474 // Creating GEM-stations from parts
475 TString SolidName = "Station";
476 SolidName += iStation;
477 SolidName += "S";
478 StationS[iStation] =
479 new TGeoBBox(SolidName, (2 * XModuleSize[iStation]) / 2 + BeamPipeRadius[iStation],
480 (2 * YModuleSize[iStation]) / 2 + BeamPipeRadius[iStation], (ZModuleSize * 2) / 2);
481
482 SolidName = "BeamPipeHole";
483 SolidName += iStation;
484 SolidName += "S";
485 BeamPipeHoleS[iStation] =
486 new TGeoBBox(SolidName, BeamPipeRadius[iStation], BeamPipeRadius[iStation], (ZModuleSize * 2) / 2 + 0.1);
487
488 // Subtraction the beam pipe hole from the current GEM-station
489 TString BooleanExpression = StationS[iStation]->GetName();
490 BooleanExpression += "-";
491 BooleanExpression += BeamPipeHoleS[iStation]->GetName();
492 StationWithHoleS[iStation] = new TGeoCompositeShape("StationWithHoleS", BooleanExpression);
493 StationS[iStation] = StationWithHoleS[iStation];
494
495 TString VolumeName = "Station";
496 VolumeName += iStation;
497 VolumeName += "V";
498 StationV[iStation] = new TGeoVolume(VolumeName, StationS[iStation]);
499 StationV[iStation]->SetMedium(pMedAir);
500 StationV[iStation]->SetLineColor(kGreen);
501 StationV[iStation]->SetTransparency(90);
502 // StationV[iStation]->SetVisibility(kFALSE);
503
504 for (Int_t iModule = 0; iModule < nModulesInStation; iModule++) {
505 ModulePosition[iStation][iModule] = new TGeoTranslation();
506
507 switch (iModule) {
508 case 0:
509 ModulePosition[iStation][iModule]->SetTranslation(
510 XModuleSize[iStation] / 2 + BeamPipeRadius[iStation],
511 -(YModuleSize[iStation] / 2 + BeamPipeRadius[iStation])
512 + (2 * dYInnerFrame + 2 * BeamPipeRadius[iStation]),
513 -0.5 * ZModuleSize);
514 break;
515
516 case 1:
517 ModulePosition[iStation][iModule]->SetTranslation(
518 -(XModuleSize[iStation] / 2 + BeamPipeRadius[iStation])
519 + (2 * dXInnerFrame + 2 * BeamPipeRadius[iStation]),
520 -(YModuleSize[iStation] / 2 + BeamPipeRadius[iStation]), 0.5 * ZModuleSize);
521 break;
522
523 case 2:
524 ModulePosition[iStation][iModule]->SetTranslation(
525 -(XModuleSize[iStation] / 2 + BeamPipeRadius[iStation]),
526 (YModuleSize[iStation] / 2 + BeamPipeRadius[iStation])
527 - (2 * dYInnerFrame + 2 * BeamPipeRadius[iStation]),
528 -0.5 * ZModuleSize);
529 break;
530
531 case 3:
532 ModulePosition[iStation][iModule]->SetTranslation(
533 XModuleSize[iStation] / 2 + BeamPipeRadius[iStation]
534 - (2 * dXInnerFrame + 2 * BeamPipeRadius[iStation]),
535 (YModuleSize[iStation] / 2 + BeamPipeRadius[iStation]), 0.5 * ZModuleSize);
536 break;
537 }
538
539 StationV[iStation]->AddNode(ModuleV[iStation][iModule], iModule, ModulePosition[iStation][iModule]);
540 }
541
542 GEMSTop->AddNode(StationV[iStation], iStation, new TGeoTranslation(0.0, 0.0, ZStantionPosition[iStation]));
543 }
544
545 if (StationCenterPosition == kTRUE) {
546 top->AddNode(GEMSTop, 0);
547 } else {
548 top->AddNode(GEMSTop, 0, new TGeoTranslation(0, 0, ZDisplacementOfDetector));
549 }
550
551 top->SetVisContainers(kTRUE);
552
553 // --------------- Finish -----------------------------------------------
554 gGeoMan->CloseGeometry();
555 gGeoMan->CheckOverlaps(0.0001);
556 gGeoMan->PrintOverlaps();
557 gGeoMan->Test();
558
559 TFile* geoFile = new TFile(geoFileName, "RECREATE");
560 top->Write();
561 geoFile->Close();
562 top->Draw("ogl");
563}
Bool_t
bool Bool_t
Int_t
int Int_t
UInt_t
unsigned int UInt_t
kFALSE
constexpr Bool_t kFALSE
Double_t
double Double_t
kTRUE
constexpr Bool_t kTRUE
kRed
kRed
kGreen
kGreen
kBlue
kBlue
kYellow
kYellow
Fatal
void Fatal(const char *location, const char *msgfmt,...)
gGeoManager
R__EXTERN TGeoManager * gGeoManager
gROOT
#define gROOT
gSystem
R__EXTERN TSystem * gSystem
TFile::Close
void Close(Option_t *option="") override
TGeoRotation::SetAngles
void SetAngles(Double_t phi, Double_t theta, Double_t psi)
TGeoShape::GetName
const char * GetName() const override
TGeoTranslation::SetTranslation
void SetTranslation(const TGeoMatrix &other)
TGeoVolumeAssembly::AddNode
TGeoNode * AddNode(TGeoVolume *vol, Int_t copy_no, TGeoMatrix *mat=nullptr, Option_t *option="") override
TGeoVolume::SetVisContainers
void SetVisContainers(Bool_t flag=kTRUE) override
TGeoVolume::AddNode
virtual TGeoNode * AddNode(TGeoVolume *vol, Int_t copy_no, TGeoMatrix *mat=nullptr, Option_t *option="")
TGeoVolume::Draw
void Draw(Option_t *option="") override
TGeoVolume::SetTransparency
void SetTransparency(Char_t transparency=0)
TGeoVolume::SetMedium
virtual void SetMedium(TGeoMedium *medium)
TGeoVolume::SetLineColor
void SetLineColor(Color_t lcolor) override
TObject::Write
virtual Int_t Write(const char *name=nullptr, Int_t option=0, Int_t bufsize=0)
gGeoMan
TGeoManager * gGeoMan
Definition create_rootgeom_GEMS_v2.C:12
dXOuterFrame
const Double_t dXOuterFrame
Definition create_rootgeom_GEMS_v2.C:29
dZSensitiveVolume
const Double_t dZSensitiveVolume
Definition create_rootgeom_GEMS_v2.C:33
BeamPipeMaxRadius
const Double_t BeamPipeMaxRadius
Definition create_rootgeom_GEMS_v2.C:24
BeamPipeMinRadius
const Double_t BeamPipeMinRadius
Definition create_rootgeom_GEMS_v2.C:23
nStations
const Int_t nStations
Definition create_rootgeom_GEMS_v2.C:15
XSizeOfStation
const Double_t XSizeOfStation[nStations]
Definition create_rootgeom_GEMS_v2.C:18
YSizeOfStation
const Double_t YSizeOfStation[nStations]
Definition create_rootgeom_GEMS_v2.C:19
dXInnerFrame
const Double_t dXInnerFrame
Definition create_rootgeom_GEMS_v2.C:30
ZStantionPosition
const Double_t ZStantionPosition[nStations]
Definition create_rootgeom_GEMS_v2.C:20
StationCenterPosition
const Bool_t StationCenterPosition
Definition create_rootgeom_GEMS_v2.C:45
dYOuterFrame
const Double_t dYOuterFrame
Definition create_rootgeom_GEMS_v2.C:31
dYInnerFrame
const Double_t dYInnerFrame
Definition create_rootgeom_GEMS_v2.C:32
nModulesInStation
const Int_t nModulesInStation
Definition create_rootgeom_GEMS_v2.C:28
ZDisplacementOfDetector
const Double_t ZDisplacementOfDetector
Definition create_rootgeom_GEMS_v2.C:46
XSizeSpacer
const Double_t XSizeSpacer
Definition create_rootgeom_GEMS_v2.C:39
YSizeSpacer
const Double_t YSizeSpacer
Definition create_rootgeom_GEMS_v2.C:40
SpacerThickness
const Double_t SpacerThickness
Definition create_rootgeom_GEMS_v2.C:42
WithSpacers
const Bool_t WithSpacers
Definition create_rootgeom_GEMS_v2.C:49
SpacerWidth
const Double_t SpacerWidth
Definition create_rootgeom_GEMS_v2.C:41
CalculateParameters
void CalculateParameters()
Definition create_rootgeom_GEMS_v2.C:51
create_rootgeom_GEMS_v2
void create_rootgeom_GEMS_v2()
Definition create_rootgeom_GEMS_v2.C:82
TMath::ATan
Double_t ATan(Double_t)
TMath::Pi
constexpr Double_t Pi()
TMath::Tan
Double_t Tan(Double_t)