Belle II Software development
GeoCryostatCreator.cc
1/**************************************************************************
2 * basf2 (Belle II Analysis Software Framework) *
3 * Author: The Belle II Collaboration *
4 * *
5 * See git log for contributors and copyright holders. *
6 * This file is licensed under LGPL-3.0, see LICENSE.md. *
7 **************************************************************************/
8
9#include <ir/geometry/GeoCryostatCreator.h>
10#include <ir/simulation/SensitiveDetector.h>
11
12#include <geometry/Materials.h>
13#include <geometry/CreatorFactory.h>
14#include <geometry/utilities.h>
15#include <framework/gearbox/Unit.h>
16
17#include <cmath>
18#include <boost/algorithm/string.hpp>
19
20#include <G4LogicalVolume.hh>
21#include <G4PVPlacement.hh>
22
23#include <simulation/background/BkgSensitiveDetector.h>
24
25//Shapes
26#include <G4Box.hh>
27#include <G4Trd.hh>
28#include <G4Tubs.hh>
29#include <G4Cons.hh>
30#include <G4Polycone.hh>
31#include <G4EllipticalTube.hh>
32#include <G4UnionSolid.hh>
33#include <G4IntersectionSolid.hh>
34#include <G4SubtractionSolid.hh>
35#include <G4ExtrudedSolid.hh>
36#include <G4UserLimits.hh>
37
38using namespace std;
39
40namespace Belle2 {
45
46
47 using namespace geometry;
48
49 namespace ir {
50
51 //-----------------------------------------------------------------
52 // Register the Creator
53 //-----------------------------------------------------------------
54
55 geometry::CreatorFactory<GeoCryostatCreator> GeoCryostatFactory("CryostatCreator");
56
57 //-----------------------------------------------------------------
58 // Implementation
59 //-----------------------------------------------------------------
60
65
70
71 void GeoCryostatCreator::createGeometry(G4LogicalVolume& topVolume, GeometryTypes)
72 {
73
74 //###### R side index ######
75 //
76 // +- A1spc1+A1spc2
77 // +- A2wal1
78 // +- A3wal1
79 // +- A3wal2
80 // +- A4mag1
81 // +- A4mag2
82 // +- A4mag3
83 // +- A4mag4
84 //
85 // +- B1spc1+B1spc2
86 // +- B2wal1
87 // +- B3wal1
88 // +- B3wal2
89 // +- B4mag1
90 // +- B4mag2
91 // +- B4mag3
92 // +- B4mag4
93 //
94 // +- C1wal1
95 // +- C2spc1
96 // +- C3wal1
97 // +- C4spc1
98 // +- C5wal1
99 // +- C6spc1
100 // +- C7lyr1
101 // +- C7lyr2
102 // +- C7lyr3
103 // +- C7lyr4
104 // +- C7lyr5
105 // +- C2spc2
106 // +- C3wal2
107 // +- C4spc2
108 // +- C5wal2
109 // +- C6spc2
110 // +- C7wal1
111 // +- C5wal3
112 // +- C5wal4
113 // +- C3wal3
114 // +- C2spc3
115 // +- C1wal2
116 //
117 //###### L side index ######
118 //
119 // +- D1spc1
120 // +- D2wal1
121 // +- D3wal1
122 // +- D3wal2
123 // +- D4mag1
124 // +- D4mag2
125 // +- D4mag3
126 //
127 // +- E1spc1
128 // +- E2wal1
129 // +- E3wal1
130 // +- E4mag1
131 // +- E4mag2
132 // +- E4mag3
133 //
134 // +- F1wal1
135 // +- F2spc1
136 // +- F3wal1
137 // +- F4spc1
138 // +- F5wal1
139 // +- F6spc1
140 // +- F7lyr1
141 // +- F7lyr2
142 // +- F7lyr3
143 // +- F7lyr4
144 // +- F7lyr5
145 // +- F3wal2
146 // +- F3wal3
147 // +- F3wal4
148 // +- F1wal2
149
150 double stepMax = 5.0 * Unit::mm;
151 int flag_limitStep = int(m_config.getParameter("LimitStepLength"));
152
153 const double unitFactor = Unit::cm / Unit::mm;
154
155 double crossingAngleHER = m_config.getParameter("CrossingAngle.HER", 0.0415);
156 double crossingAngleLER = m_config.getParameter("CrossingAngle.LER", -0.0415);
157
158 G4Transform3D transform_HER = G4Translate3D(0., 0., 0.);
159 transform_HER = transform_HER * G4RotateY3D(crossingAngleHER);
160
161 G4Transform3D transform_LER = G4Translate3D(0., 0., 0.);
162 transform_LER = transform_LER * G4RotateY3D(crossingAngleLER);
163
164 map<string, CryostatElement> elements;
165
166 // debug
167 //cout << endl << "!!! Creating a Cryostat copy..." << endl << endl;
168
169 //--------------
170 //- Bounding shapes
171
172 // right bounding shape 1
173 CryostatElement tubeR;
174 std::string prep = "TubeR.";
175
176 const int TubeR_N = int(m_config.getParameter(prep + "N"));
177
178 std::vector<double> TubeR_Z(TubeR_N);
179 std::vector<double> TubeR_R(TubeR_N);
180 std::vector<double> TubeR_r(TubeR_N);
181
182 for (int i = 0; i < TubeR_N; ++i) {
183 ostringstream ossZID;
184 ossZID << "Z" << i;
185
186 ostringstream ossRID;
187 ossRID << "R" << i;
188
189 ostringstream ossrID;
190 ossrID << "r" << i;
191
192 TubeR_Z[i] = m_config.getParameter(prep + ossZID.str()) * unitFactor;
193 TubeR_R[i] = m_config.getParameter(prep + ossRID.str()) * unitFactor;
194 TubeR_r[i] = m_config.getParameter(prep + ossrID.str(), 0.0) * unitFactor;
195 }
196
197 tubeR.transform = G4Translate3D(0., 0., 0.);
198 tubeR.geo = new G4Polycone("geo_TubeR_name", 0, 2 * M_PI, TubeR_N, &(TubeR_Z[0]), &(TubeR_r[0]), &(TubeR_R[0]));
199 tubeR.logi = NULL;
200 elements["TubeR"] = tubeR;
201
202 // right bounding shape 2
203 CryostatElement tubeR2;
204 prep = "TubeR2.";
205 const int TubeR2_N = int(m_config.getParameter(prep + "N"));
206
207 std::vector<double> TubeR2_Z(TubeR2_N);
208 std::vector<double> TubeR2_R(TubeR2_N);
209 std::vector<double> TubeR2_r(TubeR2_N);
210
211 for (int i = 0; i < TubeR2_N; ++i) {
212 ostringstream ossZID;
213 ossZID << "Z" << i;
214
215 ostringstream ossRID;
216 ossRID << "R" << i;
217
218 ostringstream ossrID;
219 ossrID << "r" << i;
220
221 TubeR2_Z[i] = m_config.getParameter(prep + ossZID.str()) * unitFactor;
222 TubeR2_R[i] = m_config.getParameter(prep + ossRID.str()) * unitFactor;
223 TubeR2_r[i] = m_config.getParameter(prep + ossrID.str(), 0.0) * unitFactor;
224 }
225
226 tubeR2.transform = G4Translate3D(0., 0., 0.);
227 tubeR2.geo = new G4Polycone("geo_TubeR2_name", 0, 2 * M_PI, TubeR2_N, &(TubeR2_Z[0]), &(TubeR2_r[0]), &(TubeR2_R[0]));
228 tubeR2.logi = NULL;
229 elements["TubeR2"] = tubeR2;
230
231 // left bounding shape
232 CryostatElement tubeL;
233 prep = "TubeL.";
234 const int TubeL_N = int(m_config.getParameter(prep + "N"));
235
236 std::vector<double> TubeL_Z(TubeL_N);
237 std::vector<double> TubeL_R(TubeL_N);
238 std::vector<double> TubeL_r(TubeL_N);
239
240 for (int i = 0; i < TubeL_N; ++i) {
241 ostringstream ossZID;
242 ossZID << "Z" << i;
243
244 ostringstream ossRID;
245 ossRID << "R" << i;
246
247 ostringstream ossrID;
248 ossrID << "r" << i;
249
250 TubeL_Z[i] = m_config.getParameter(prep + ossZID.str()) * unitFactor;
251 TubeL_R[i] = m_config.getParameter(prep + ossRID.str()) * unitFactor;
252 TubeL_r[i] = m_config.getParameter(prep + ossrID.str()) * unitFactor;
253 }
254
255 tubeL.transform = G4Translate3D(0., 0., 0.);
256 tubeL.geo = new G4Polycone("geo_TubeL_name", 0, 2 * M_PI, TubeL_N, &(TubeL_Z[0]), &(TubeL_r[0]), &(TubeL_R[0]));
257 tubeL.logi = NULL;
258 elements["TubeL"] = tubeL;
259
260 //--------------
261 // Special cases with complex geometry
262
263 //--------------
264 //- A1spc1 and B1spc1
265
266 // space containing all structures around right HER beam pipe, part 1
267 CryostatElement A1spc1;
268 prep = "A1spc1.";
269 const int A1spc1_N = int(m_config.getParameter(prep + "N"));
270
271 std::vector<double> A1spc1_Z(A1spc1_N);
272 std::vector<double> A1spc1_r(A1spc1_N);
273 std::vector<double> A1spc1_R(A1spc1_N);
274
275 for (int i = 0; i < A1spc1_N; ++i) {
276 ostringstream ossZID;
277 ossZID << "Z" << i;
278
279 ostringstream ossRID;
280 ossRID << "R" << i;
281
282 ostringstream ossrID;
283 ossrID << "r" << i;
284
285 A1spc1_Z[i] = m_config.getParameter(prep + ossZID.str()) * unitFactor;
286 A1spc1_R[i] = m_config.getParameter(prep + ossRID.str()) * unitFactor;
287 A1spc1_r[i] = m_config.getParameter(prep + ossrID.str(), 0.0) * unitFactor;
288 }
289
290 A1spc1.transform = transform_HER;
291 G4Polycone* geo_A1spc1xx = new G4Polycone("geo_A1spc1xx_name", 0, 2 * M_PI, A1spc1_N, &(A1spc1_Z[0]), &(A1spc1_r[0]),
292 &(A1spc1_R[0]));
293
294 // space containing all structures around right HER beam pipe, part 2
295 CryostatElement A1spc2;
296 prep = "A1spc2.";
297 const int A1spc2_N = int(m_config.getParameter(prep + "N"));
298
299 std::vector<double> A1spc2_Z(A1spc2_N);
300 std::vector<double> A1spc2_R(A1spc2_N);
301 std::vector<double> A1spc2_r(A1spc2_N);
302
303 for (int i = 0; i < A1spc2_N; ++i) {
304 ostringstream ossZID;
305 ossZID << "Z" << i;
306
307 ostringstream ossRID;
308 ossRID << "R" << i;
309
310 ostringstream ossrID;
311 ossrID << "r" << i;
312
313 A1spc2_Z[i] = m_config.getParameter(prep + ossZID.str()) * unitFactor;
314 A1spc2_R[i] = m_config.getParameter(prep + ossRID.str()) * unitFactor;
315 A1spc2_r[i] = m_config.getParameter(prep + ossrID.str(), 0.0) * unitFactor;
316 }
317
318 A1spc2.transform = transform_HER;
319 G4Polycone* geo_A1spc2xx = new G4Polycone("geo_A1spc2xx_name", 0, 2 * M_PI, A1spc2_N, &(A1spc2_Z[0]), &(A1spc2_r[0]),
320 &(A1spc2_R[0]));
321
322 // space containing all structures around right LER beam pipe, part 1
323 CryostatElement B1spc1;
324 prep = "B1spc1.";
325 const int B1spc1_N = int(m_config.getParameter(prep + "N"));
326
327 std::vector<double> B1spc1_Z(B1spc1_N);
328 std::vector<double> B1spc1_R(B1spc1_N);
329 std::vector<double> B1spc1_r(B1spc1_N);
330
331 for (int i = 0; i < B1spc1_N; ++i) {
332 ostringstream ossZID;
333 ossZID << "Z" << i;
334
335 ostringstream ossRID;
336 ossRID << "R" << i;
337
338 ostringstream ossrID;
339 ossrID << "r" << i;
340
341 B1spc1_Z[i] = m_config.getParameter(prep + ossZID.str()) * unitFactor;
342 B1spc1_R[i] = m_config.getParameter(prep + ossRID.str()) * unitFactor;
343 B1spc1_r[i] = m_config.getParameter(prep + ossrID.str(), 0.0) * unitFactor;
344 }
345
346 B1spc1.transform = transform_LER;
347 G4Polycone* geo_B1spc1xx = new G4Polycone("geo_B1spc1xx_name", 0, 2 * M_PI, B1spc1_N, &(B1spc1_Z[0]), &(B1spc1_r[0]),
348 &(B1spc1_R[0]));
349
350 // space containing all structures around right LER beam pipe, part 2
351 CryostatElement B1spc2;
352 prep = "B1spc2.";
353 const int B1spc2_N = int(m_config.getParameter(prep + "N"));
354
355 std::vector<double> B1spc2_Z(B1spc2_N);
356 std::vector<double> B1spc2_R(B1spc2_N);
357 std::vector<double> B1spc2_r(B1spc2_N);
358
359 for (int i = 0; i < B1spc2_N; ++i) {
360 ostringstream ossZID;
361 ossZID << "Z" << i;
362
363 ostringstream ossRID;
364 ossRID << "R" << i;
365
366 ostringstream ossrID;
367 ossrID << "r" << i;
368
369 B1spc2_Z[i] = m_config.getParameter(prep + ossZID.str()) * unitFactor;
370 B1spc2_R[i] = m_config.getParameter(prep + ossRID.str()) * unitFactor;
371 B1spc2_r[i] = m_config.getParameter(prep + ossrID.str(), 0.0) * unitFactor;
372 }
373
374 B1spc2.transform = transform_LER;
375 G4Polycone* geo_B1spc2xx = new G4Polycone("geo_B1spc2xx_name", 0, 2 * M_PI, B1spc2_N, &(B1spc2_Z[0]), &(B1spc2_r[0]),
376 &(B1spc2_R[0]));
377
378 // final cut
379 B1spc2.geo = new G4IntersectionSolid("geo_B1spc2_name", geo_B1spc2xx, elements["TubeR2"].geo, B1spc2.transform.inverse());
380 B1spc2.logi = NULL;
381
382 G4IntersectionSolid* geo_B1spc1x = new G4IntersectionSolid("geo_B1spc1x_name", geo_B1spc1xx, elements["TubeR"].geo,
383 B1spc1.transform.inverse());
384 B1spc1.geo = new G4UnionSolid("geo_B1spc1_name", geo_B1spc1x, B1spc2.geo);
385
386 A1spc2.geo = new G4IntersectionSolid("geo_A1spc2_name", geo_A1spc2xx, elements["TubeR2"].geo, A1spc2.transform.inverse());
387 A1spc2.logi = NULL;
388
389 G4IntersectionSolid* geo_A1spc1xy = new G4IntersectionSolid("geo_A1spc1xy_name", geo_A1spc1xx, elements["TubeR"].geo,
390 A1spc1.transform.inverse());
391 G4UnionSolid* geo_A1spc1x = new G4UnionSolid("geo_A1spc1x_name", geo_A1spc1xy, A1spc2.geo);
392 A1spc1.geo = new G4SubtractionSolid("geo_A1spc1_name", geo_A1spc1x, B1spc1.geo, A1spc1.transform.inverse()*B1spc1.transform);
393
394 string strMat_A1spc1 = m_config.getParameterStr("A1spc1.Material");
395 G4Material* mat_A1spc1 = Materials::get(strMat_A1spc1);
396 A1spc1.logi = new G4LogicalVolume(A1spc1.geo, mat_A1spc1, "logi_A1spc1_name");
397 if (flag_limitStep)
398 A1spc1.logi->SetUserLimits(new G4UserLimits(stepMax));
399
400 //put volume
401 setColor(*A1spc1.logi, "#CC0000");
402 //setVisibility(*A1spc1.logi, false);
403 new G4PVPlacement(A1spc1.transform, A1spc1.logi, "phys_A1spc1_name", &topVolume, false, 0);
404
405 string strMat_B1spc1 = m_config.getParameterStr("B1spc1.Material");
406 G4Material* mat_B1spc1 = Materials::get(strMat_B1spc1);
407 B1spc1.logi = new G4LogicalVolume(B1spc1.geo, mat_B1spc1, "logi_B1spc1_name");
408 if (flag_limitStep)
409 B1spc1.logi->SetUserLimits(new G4UserLimits(stepMax));
410
411 //put volume
412 setColor(*B1spc1.logi, "#CC0000");
413 //setVisibility(*B1spc1.logi, false);
414 new G4PVPlacement(B1spc1.transform, B1spc1.logi, "phys_B1spc1_name", &topVolume, false, 0);
415
416 elements["A1spc1"] = A1spc1;
417 elements["A1spc2"] = A1spc2;
418 elements["B1spc1"] = B1spc1;
419 elements["B1spc2"] = B1spc2;
420
421 //--------------
422 //- C1wal1
423
424 //get parameters from .xml file
425 CryostatElement C1wal1;
426 prep = "C1wal1.";
427 const int C1wal1_N = m_config.getParameter(prep + "N");
428
429 std::vector<double> C1wal1_Z(C1wal1_N);
430 std::vector<double> C1wal1_R(C1wal1_N);
431 std::vector<double> C1wal1_r(C1wal1_N);
432
433 for (int i = 0; i < C1wal1_N; ++i) {
434 ostringstream ossZID;
435 ossZID << "Z" << i;
436
437 ostringstream ossRID;
438 ossRID << "R" << i;
439
440 ostringstream ossrID;
441 ossrID << "r" << i;
442
443 C1wal1_Z[i] = m_config.getParameter(prep + ossZID.str()) * unitFactor;
444 C1wal1_R[i] = m_config.getParameter(prep + ossRID.str()) * unitFactor;
445 C1wal1_r[i] = m_config.getParameter(prep + ossrID.str(), 0.0) * unitFactor;
446 }
447
448 C1wal1.transform = G4Translate3D(0., 0., 0.);
449
450 //define geometry
451 G4Polycone* geo_C1wal1xxx = new G4Polycone("geo_C1wal1xxx_name", 0, 2 * M_PI, C1wal1_N, &(C1wal1_Z[0]), &(C1wal1_r[0]),
452 &(C1wal1_R[0]));
453 G4IntersectionSolid* geo_C1wal1xx = new G4IntersectionSolid("geo_C1wal1xx_name", geo_C1wal1xxx, elements["TubeR"].geo,
454 elements["TubeR"].transform);
455 G4SubtractionSolid* geo_C1wal1x = new G4SubtractionSolid("geo_C1wal1x_name", geo_C1wal1xx, elements["A1spc1"].geo,
456 elements["A1spc1"].transform);
457 C1wal1.geo = new G4SubtractionSolid("geo_C1wal1_name", geo_C1wal1x, elements["B1spc1"].geo, elements["B1spc1"].transform);
458
459 string strMat_C1wal1 = m_config.getParameterStr(prep + "Material");
460 G4Material* mat_C1wal1 = Materials::get(strMat_C1wal1);
461 C1wal1.logi = new G4LogicalVolume(C1wal1.geo, mat_C1wal1, "logi_C1wal1_name");
462
463 //put volume
464 setColor(*C1wal1.logi, "#CC0000");
465//--andrii setVisibility(*C1wal1.logi, false);
466 new G4PVPlacement(0, G4ThreeVector(0, 0, 0), C1wal1.logi, "phys_C1wal1_name", &topVolume, false, 0);
467
468 elements["C1wal1"] = C1wal1;
469
470 //--------------
471 //- D1spc1 and E1spc1
472
473 // space containing all structures around left HER beam pipe
474 CryostatElement D1spc1;
475 prep = "D1spc1.";
476 const int D1spc1_N = m_config.getParameter(prep + "N");
477
478 std::vector<double> D1spc1_Z(D1spc1_N);
479 std::vector<double> D1spc1_r(D1spc1_N);
480 std::vector<double> D1spc1_R(D1spc1_N);
481
482 for (int i = 0; i < D1spc1_N; ++i) {
483 ostringstream ossZID;
484 ossZID << "Z" << i;
485
486 ostringstream ossRID;
487 ossRID << "R" << i;
488
489 ostringstream ossrID;
490 ossrID << "r" << i;
491
492 D1spc1_Z[i] = m_config.getParameter(prep + ossZID.str()) * unitFactor;
493 D1spc1_R[i] = m_config.getParameter(prep + ossRID.str()) * unitFactor;
494 D1spc1_r[i] = m_config.getParameter(prep + ossrID.str(), 0.0) * unitFactor;
495 }
496
497 D1spc1.transform = transform_HER;
498 G4Polycone* geo_D1spc1xx = new G4Polycone("geo_D1spc1xx_name", 0, 2 * M_PI, D1spc1_N, &(D1spc1_Z[0]), &(D1spc1_r[0]),
499 &(D1spc1_R[0]));
500
501 // space containing all structures around left LER beam pipe
502 CryostatElement E1spc1;
503 prep = "E1spc1.";
504 const int E1spc1_N = int(m_config.getParameter(prep + "N"));
505
506 std::vector<double> E1spc1_Z(E1spc1_N);
507 std::vector<double> E1spc1_R(E1spc1_N);
508 std::vector<double> E1spc1_r(E1spc1_N);
509
510 for (int i = 0; i < E1spc1_N; ++i) {
511 ostringstream ossZID;
512 ossZID << "Z" << i;
513
514 ostringstream ossRID;
515 ossRID << "R" << i;
516
517 ostringstream ossrID;
518 ossrID << "r" << i;
519
520 E1spc1_Z[i] = m_config.getParameter(prep + ossZID.str()) * unitFactor;
521 E1spc1_R[i] = m_config.getParameter(prep + ossRID.str()) * unitFactor;
522 E1spc1_r[i] = m_config.getParameter(prep + ossrID.str(), 0.0) * unitFactor;
523 }
524
525 E1spc1.transform = transform_LER;
526 G4Polycone* geo_E1spc1xx = new G4Polycone("geo_E1spc1xx_name", 0, 2 * M_PI, E1spc1_N, &(E1spc1_Z[0]), &(E1spc1_r[0]),
527 &(E1spc1_R[0]));
528
529 // final cut
530 G4IntersectionSolid* geo_D1spc1x = new G4IntersectionSolid("geo_D1spc1x_name", geo_D1spc1xx, elements["TubeL"].geo,
531 D1spc1.transform.inverse());
532 E1spc1.geo = new G4IntersectionSolid("geo_E1spc1_name", geo_E1spc1xx, elements["TubeL"].geo, E1spc1.transform.inverse());
533 D1spc1.geo = new G4SubtractionSolid("geo_D1spc1_name", geo_D1spc1x, E1spc1.geo, D1spc1.transform.inverse()*E1spc1.transform);
534
535 string strMat_D1spc1 = m_config.getParameterStr("D1spc1.Material");
536 G4Material* mat_D1spc1 = Materials::get(strMat_D1spc1);
537 D1spc1.logi = new G4LogicalVolume(D1spc1.geo, mat_D1spc1, "logi_D1spc1_name");
538 if (flag_limitStep)
539 D1spc1.logi->SetUserLimits(new G4UserLimits(stepMax));
540
541 //put volume
542 setColor(*D1spc1.logi, "#CC0000");
543 //setVisibility(*D1spc1.logi, false);
544 new G4PVPlacement(D1spc1.transform, D1spc1.logi, "phys_D1spc1_name", &topVolume, false, 0);
545
546 string strMat_E1spc1 = m_config.getParameterStr(prep + "Material");
547 G4Material* mat_E1spc1 = Materials::get(strMat_E1spc1);
548 E1spc1.logi = new G4LogicalVolume(E1spc1.geo, mat_E1spc1, "logi_E1spc1_name");
549 if (flag_limitStep)
550 E1spc1.logi->SetUserLimits(new G4UserLimits(stepMax));
551
552 //put volume
553 setColor(*E1spc1.logi, "#CC0000");
554 //setVisibility(*E1spc1.logi, false);
555 new G4PVPlacement(E1spc1.transform, E1spc1.logi, "phys_E1spc1_name", &topVolume, false, 0);
556
557 elements["E1spc1"] = E1spc1;
558 elements["D1spc1"] = D1spc1;
559
560
561 //--------------
562 //- F1wal1
563
564 //get parameters from .xml file
565 CryostatElement F1wal1;
566 prep = "F1wal1.";
567 const int F1wal1_N = int(m_config.getParameter(prep + "N"));
568
569 std::vector<double> F1wal1_Z(F1wal1_N);
570 std::vector<double> F1wal1_R(F1wal1_N);
571 std::vector<double> F1wal1_r(F1wal1_N);
572
573 for (int i = 0; i < F1wal1_N; ++i) {
574 ostringstream ossZID;
575 ossZID << "Z" << i;
576
577 ostringstream ossRID;
578 ossRID << "R" << i;
579
580 ostringstream ossrID;
581 ossrID << "r" << i;
582
583 F1wal1_Z[i] = m_config.getParameter(prep + ossZID.str()) * unitFactor;
584 F1wal1_R[i] = m_config.getParameter(prep + ossRID.str()) * unitFactor;
585 F1wal1_r[i] = m_config.getParameter(prep + ossrID.str(), 0.0) * unitFactor;
586 }
587
588 F1wal1.transform = G4Translate3D(0., 0., 0.);
589
590 //define geometry
591 G4Polycone* geo_F1wal1xxx = new G4Polycone("geo_F1wal1xxx_name", 0, 2 * M_PI, F1wal1_N, &(F1wal1_Z[0]), &(F1wal1_r[0]),
592 &(F1wal1_R[0]));
593 G4IntersectionSolid* geo_F1wal1xx = new G4IntersectionSolid("geo_F1wal1xx_name", geo_F1wal1xxx, elements["TubeL"].geo,
594 elements["TubeL"].transform);
595 G4SubtractionSolid* geo_F1wal1x = new G4SubtractionSolid("geo_F1wal1x_name", geo_F1wal1xx, elements["D1spc1"].geo,
596 elements["D1spc1"].transform);
597 F1wal1.geo = new G4SubtractionSolid("geo_F1wal1_name", geo_F1wal1x, elements["E1spc1"].geo, elements["E1spc1"].transform);
598
599 string strMat_F1wal1 = m_config.getParameterStr(prep + "Material");
600 G4Material* mat_F1wal1 = Materials::get(strMat_F1wal1);
601 F1wal1.logi = new G4LogicalVolume(F1wal1.geo, mat_F1wal1, "logi_F1wal1_name");
602
603 //put volume
604 setColor(*F1wal1.logi, "#CC0000");
605//--andrii setVisibility(*F1wal1.logi, false);
606 new G4PVPlacement(F1wal1.transform, F1wal1.logi, "phys_F1wal1_name", &topVolume, false, 0);
607
608 elements["F1wal1"] = F1wal1;
609
610
611 //--------------
612 //- Cryostats' supports
613
614 std::vector<std::string> supports;
615 boost::split(supports, m_config.getParameterStr("Support"), boost::is_any_of(" "));
616 for (const auto& name : supports) {
617 // storable element
618 CryostatElement sup;
619 prep = name + ".";
620
621 double box_W = m_config.getParameter(prep + "W") * unitFactor;
622 double box_H = m_config.getParameter(prep + "H") * unitFactor;
623 double box_L = m_config.getParameter(prep + "L") * unitFactor;
624 double box_X0 = m_config.getParameter(prep + "X0") * unitFactor;
625 double box_Y0 = m_config.getParameter(prep + "Y0") * unitFactor;
626 double box_Z0 = m_config.getParameter(prep + "Z0") * unitFactor;
627
628 double trd_W1 = m_config.getParameter(prep + "trdW1") * unitFactor;
629 double trd_W2 = m_config.getParameter(prep + "trdW2") * unitFactor;
630 double trd_L = m_config.getParameter(prep + "trdL") * unitFactor;
631 double trd_H = m_config.getParameter(prep + "trdH") * unitFactor;
632 double trd_X0 = m_config.getParameter(prep + "trdX0") * unitFactor;
633 double trd_Y0 = m_config.getParameter(prep + "trdY0") * unitFactor;
634 double trd_Z0 = m_config.getParameter(prep + "trdZ0") * unitFactor;
635
636 double sup_PHI = m_config.getParameter(prep + "PHI");
637
638 int sup_cut_N = int(m_config.getParameter(prep + "N", 0));
639
640 // transformations
641 G4Transform3D transform_box = G4Translate3D(box_X0, box_Y0, box_Z0);
642 transform_box = transform_box * G4RotateY3D(sup_PHI / Unit::rad);
643
644 G4Transform3D transform_trd = G4Translate3D(trd_X0, trd_Y0, trd_Z0);
645 transform_trd = transform_trd * G4RotateY3D(sup_PHI / Unit::rad) * G4RotateX3D(M_PI / 2.0 / Unit::rad);
646
647 //define geometry
648 string geo_box_name = "geo_" + name + "_box_name";
649 string geo_trd_name = "geo_" + name + "_trd_name";
650
651 string geo_sup_name;
652 if (sup_cut_N == 0) {
653 geo_sup_name = "geo_" + name + "_name";
654 } else {
655 geo_sup_name = "geo_" + name + "_x_name";
656 }
657
658 G4Box* geo_box = new G4Box(geo_box_name, box_W / 2.0, box_H / 2.0, box_L / 2.0);
659 G4Trd* geo_trd = new G4Trd(geo_trd_name, trd_W1 / 2.0, trd_W2 / 2.0, trd_L / 2.0, trd_L / 2.0, trd_H / 2.0);
660
661 G4VSolid* geo_sup = new G4UnionSolid(geo_sup_name, geo_box, geo_trd, transform_box.inverse() * transform_trd);
662
663 // cuts
664 for (int i = 0; i < sup_cut_N; ++i) {
665 ostringstream oss_block_num;
666 oss_block_num << i;
667
668 double cut_type = m_config.getParameter(prep + "cutType" + oss_block_num.str());
669 if (i == sup_cut_N - 1) {
670 geo_sup_name = "geo_" + name + "_name";
671 } else {
672 geo_sup_name = "geo_" + name + "_x" + oss_block_num.str() + "_name";
673 }
674 string geo_cut_name = "geo_" + name + "_cut" + oss_block_num.str() + "_name";
675
676 G4VSolid* geo_cut;
677
678 if (cut_type == 0.0) {
679 double cut_L = m_config.getParameter(prep + "cutL" + oss_block_num.str()) * unitFactor;
680 double cut_W = m_config.getParameter(prep + "cutW" + oss_block_num.str()) * unitFactor;
681 double cut_H = m_config.getParameter(prep + "cutH" + oss_block_num.str()) * unitFactor;
682
683 geo_cut = new G4Box(geo_cut_name, cut_W / 2.0, cut_H / 2.0, cut_L / 2.0);
684 } else {
685 double cut_L = m_config.getParameter(prep + "cutL" + oss_block_num.str()) * unitFactor;
686 double cut_R = m_config.getParameter(prep + "cutR" + oss_block_num.str()) * unitFactor;
687
688 geo_cut = new G4Tubs(geo_cut_name, 0.0, cut_R, cut_L / 2.0, 0.0, 2.0 * M_PI);
689 }
690
691 double cut_X0 = m_config.getParameter(prep + "cutDX" + oss_block_num.str()) * unitFactor;
692 double cut_Y0 = m_config.getParameter(prep + "cutDY" + oss_block_num.str()) * unitFactor;
693 double cut_Z0 = m_config.getParameter(prep + "cutDZ" + oss_block_num.str()) * unitFactor;
694 double cut_PHI = m_config.getParameter(prep + "cutPHI" + oss_block_num.str(), 0.0);
695 double cut_TH = m_config.getParameter(prep + "cutTH" + oss_block_num.str(), 0.0);
696
697 G4Transform3D cut_transform = G4Translate3D(cut_X0, cut_Y0, cut_Z0);
698 cut_transform = cut_transform * G4RotateX3D(cut_PHI / Unit::rad);
699 cut_transform = cut_transform * G4RotateZ3D(cut_TH / Unit::rad);
700
701 geo_sup = new G4SubtractionSolid(geo_sup_name, geo_sup, geo_cut, cut_transform);
702 }
703
704 sup.geo = geo_sup;
705 sup.transform = transform_box;
706
707 string strMat_sup = m_config.getParameterStr(prep + "Material");
708 G4Material* mat_sup = Materials::get(strMat_sup);
709
710 string logi_sup_name = "logi_" + name + "_name";
711 G4LogicalVolume* logi_sup = new G4LogicalVolume(sup.geo, mat_sup, logi_sup_name);
712
713 sup.logi = logi_sup;
714
715 //put volume
716 setColor(*logi_sup, "#0000CC");
717 //setVisibility(*logi_sup, false);
718 string phys_sup_name = "phys_" + name + "_name";
719 new G4PVPlacement(sup.transform, sup.logi, phys_sup_name, &topVolume, false, 0);
720
721 elements[name] = sup;
722 }
723
724 //----------------------------------
725 //- Bellows shield geometry
726 prep = "BellowsShield.";
727 double BS_fwdZ0 = m_config.getParameter(prep + "fwdZ0") * unitFactor;
728 double BS_fwdZ1 = m_config.getParameter(prep + "fwdZ1") * unitFactor;
729 double BS_fwdZ2 = m_config.getParameter(prep + "fwdZ2") * unitFactor;
730 double BS_fwdZ3 = m_config.getParameter(prep + "fwdZ3") * unitFactor;
731 double BS_fwdZ4 = m_config.getParameter(prep + "fwdZ4") * unitFactor;
732 double BS_bwdZ0 = m_config.getParameter(prep + "bwdZ0") * unitFactor;
733 double BS_bwdZ1 = m_config.getParameter(prep + "bwdZ1") * unitFactor;
734 double BS_bwdZ2 = m_config.getParameter(prep + "bwdZ2") * unitFactor;
735 double BS_bwdZ3 = m_config.getParameter(prep + "bwdZ3") * unitFactor;
736 //double BS_bwdZ4 = m_config.getParameter(prep + "bwdZ4")*unitFactor;
737
738 string strMat_BS = m_config.getParameterStr(prep + "Material");
739 G4Material* mat_BS = Materials::get(strMat_BS);
740
741 // Parameters for Base10/11 (FWD)
742 double BS_fwdP0_R = m_config.getParameter(prep + "fwdP0_R") * unitFactor;
743 double BS_fwdP0_Yout = m_config.getParameter(prep + "fwdP0_Yout") * unitFactor;
744 double BS_fwdP0_Yin = m_config.getParameter(prep + "fwdP0_Yin") * unitFactor;
745 double BS_fwdP0_Xin = m_config.getParameter(prep + "fwdP0_Xin") * unitFactor;
746 double BS_fwdP0_Yedge = m_config.getParameter(prep + "fwdP0_Yedge") * unitFactor;
747 double BS_fwdP0_Xedge = m_config.getParameter(prep + "fwdP0_Xedge") * unitFactor;
748 double BS_fwdP0_Yside = m_config.getParameter(prep + "fwdP0_Yside") * unitFactor;
749 double BS_fwdP0_Xside = m_config.getParameter(prep + "fwdP0_Xside") * unitFactor;
750
751 double BS_fwdP0_DHalf = (BS_fwdZ2 - BS_fwdZ0) / 2;
752 G4VSolid* geo_BS_fwdP0_B0 = new G4Tubs("geo_BS_fwdP0_B0", 0, BS_fwdP0_R, BS_fwdP0_DHalf, 0, 2 * M_PI);
753 G4Transform3D tfm_BS_fwdP0_B0 = G4Translate3D(0, 0, BS_fwdP0_DHalf);
754
755 G4VSolid* geo_BS_fwdP0_V0T = new G4Tubs("geo_BS_fwdP0_V0T", 0, BS_fwdP0_Yin, BS_fwdP0_DHalf, 0.25 * M_PI, 0.5 * M_PI);
756 G4VSolid* geo_BS_fwdP0_V0B = new G4Tubs("geo_BS_fwdP0_V0B", 0, BS_fwdP0_Yin, BS_fwdP0_DHalf, 1.25 * M_PI, 0.5 * M_PI);
757 G4Transform3D tfm_BS_fwdP0_V0L = G4Translate3D(-BS_fwdP0_Xin, 0, BS_fwdP0_DHalf);
758 G4Transform3D tfm_BS_fwdP0_V0R = G4Translate3D(+BS_fwdP0_Xin, 0, BS_fwdP0_DHalf);
759
760 G4VSolid* geo_BS_fwdP0_V1 = new G4Box("geo_BS_fwdP0_V1", BS_fwdP0_Xside, BS_fwdP0_Yedge, BS_fwdP0_DHalf);
761 G4Transform3D tfm_BS_fwdP0_V1 = G4Translate3D(0, 0, BS_fwdP0_DHalf);
762
763 G4VSolid* geo_BS_fwdP0_V2 = new G4Box("geo_BS_fwdP0_V2", 100, 100, BS_fwdP0_DHalf);
764 G4Transform3D tfm_BS_fwdP0_V2TR = G4Translate3D(+(100 + BS_fwdP0_Xedge), +(100 + BS_fwdP0_Yside), BS_fwdP0_DHalf);
765 G4Transform3D tfm_BS_fwdP0_V2TL = G4Translate3D(-(100 + BS_fwdP0_Xedge), +(100 + BS_fwdP0_Yside), BS_fwdP0_DHalf);
766 G4Transform3D tfm_BS_fwdP0_V2BR = G4Translate3D(+(100 + BS_fwdP0_Xedge), -(100 + BS_fwdP0_Yside), BS_fwdP0_DHalf);
767 G4Transform3D tfm_BS_fwdP0_V2BL = G4Translate3D(-(100 + BS_fwdP0_Xedge), -(100 + BS_fwdP0_Yside), BS_fwdP0_DHalf);
768
769 G4VSolid* geo_BS_fwdP0_V3 = new G4Box("geo_BS_fwdP0_V3", BS_fwdP0_Xin, BS_fwdP0_Yin, BS_fwdP0_DHalf);
770 G4Transform3D tfm_BS_fwdP0_V3 = G4Translate3D(0, 0, BS_fwdP0_DHalf);
771
772 double BS_fwdP0_C0_DHalf = (BS_fwdZ1 - BS_fwdZ0) / 2;
773 G4VSolid* geo_BS_fwdP0_V4 = new G4Box("geo_BS_fwdP0_V4", 100, 100, BS_fwdP0_C0_DHalf);
774 G4Transform3D tfm_BS_fwdP0_V4T = G4Translate3D(0, +(100 + BS_fwdP0_Yout), BS_fwdP0_C0_DHalf);
775 G4Transform3D tfm_BS_fwdP0_V4B = G4Translate3D(0, -(100 + BS_fwdP0_Yout), BS_fwdP0_C0_DHalf);
776
777 G4VSolid* geo_BS_fwdP0_Base = new G4DisplacedSolid("geo_BS_fwdP0_Base_00", geo_BS_fwdP0_B0, tfm_BS_fwdP0_B0);
778 geo_BS_fwdP0_Base = new G4SubtractionSolid("geo_BS_fwdP0_Base_01", geo_BS_fwdP0_Base, geo_BS_fwdP0_V0T, tfm_BS_fwdP0_V0L);
779 geo_BS_fwdP0_Base = new G4SubtractionSolid("geo_BS_fwdP0_Base_02", geo_BS_fwdP0_Base, geo_BS_fwdP0_V0T, tfm_BS_fwdP0_V0R);
780 geo_BS_fwdP0_Base = new G4SubtractionSolid("geo_BS_fwdP0_Base_03", geo_BS_fwdP0_Base, geo_BS_fwdP0_V0B, tfm_BS_fwdP0_V0L);
781 geo_BS_fwdP0_Base = new G4SubtractionSolid("geo_BS_fwdP0_Base_04", geo_BS_fwdP0_Base, geo_BS_fwdP0_V0B, tfm_BS_fwdP0_V0R);
782 geo_BS_fwdP0_Base = new G4SubtractionSolid("geo_BS_fwdP0_Base_05", geo_BS_fwdP0_Base, geo_BS_fwdP0_V1, tfm_BS_fwdP0_V1);
783 geo_BS_fwdP0_Base = new G4SubtractionSolid("geo_BS_fwdP0_Base_06", geo_BS_fwdP0_Base, geo_BS_fwdP0_V2, tfm_BS_fwdP0_V2TR);
784 geo_BS_fwdP0_Base = new G4SubtractionSolid("geo_BS_fwdP0_Base_07", geo_BS_fwdP0_Base, geo_BS_fwdP0_V2, tfm_BS_fwdP0_V2TL);
785 geo_BS_fwdP0_Base = new G4SubtractionSolid("geo_BS_fwdP0_Base_08", geo_BS_fwdP0_Base, geo_BS_fwdP0_V2, tfm_BS_fwdP0_V2BR);
786 geo_BS_fwdP0_Base = new G4SubtractionSolid("geo_BS_fwdP0_Base_09", geo_BS_fwdP0_Base, geo_BS_fwdP0_V2, tfm_BS_fwdP0_V2BL);
787 geo_BS_fwdP0_Base = new G4SubtractionSolid("geo_BS_fwdP0_Base_10", geo_BS_fwdP0_Base, geo_BS_fwdP0_V3, tfm_BS_fwdP0_V3);
788 geo_BS_fwdP0_Base = new G4SubtractionSolid("geo_BS_fwdP0_Base_11", geo_BS_fwdP0_Base, geo_BS_fwdP0_V4, tfm_BS_fwdP0_V4T);
789 geo_BS_fwdP0_Base = new G4SubtractionSolid("geo_BS_fwdP0_Base_12", geo_BS_fwdP0_Base, geo_BS_fwdP0_V4, tfm_BS_fwdP0_V4B);
790
791 // Parameters for Base20/21 (BWD)
792 double BS_bwdP0_R0 = m_config.getParameter(prep + "bwdP0_R0") * unitFactor;
793 double BS_bwdP0_R1 = m_config.getParameter(prep + "bwdP0_R1") * unitFactor;
794 double BS_bwdP0_Yin = m_config.getParameter(prep + "bwdP0_Yin") * unitFactor;
795 double BS_bwdP0_Xin = m_config.getParameter(prep + "bwdP0_Xin") * unitFactor;
796
797 double BS_bwdP0a_DHalf = (BS_bwdZ0 - BS_bwdZ1) / 2;
798 G4VSolid* geo_BS_bwdP0_B0 = new G4Tubs("geo_BS_bwdP0_B0", 0, BS_bwdP0_R0, BS_bwdP0a_DHalf, 0, 2 * M_PI);
799 G4Transform3D tfm_BS_bwdP0_B0 = G4Translate3D(0, 0, -BS_bwdP0a_DHalf);
800
801 double BS_bwdP0b_DHalf = (BS_bwdZ1 - BS_bwdZ2) / 2;
802 G4VSolid* geo_BS_bwdP0_B1 = new G4Tubs("geo_BS_bwdP0_B1", 0, BS_bwdP0_R1, BS_bwdP0b_DHalf, 0.5 * M_PI, M_PI);
803 G4Transform3D tfm_BS_bwdP0_B1 = G4Translate3D(-BS_bwdP0_Xin, 0, -BS_bwdP0b_DHalf - 2 * BS_bwdP0a_DHalf);
804
805 G4VSolid* geo_BS_bwdP0_B2 = new G4Tubs("geo_BS_bwdP0_B2", 0, BS_bwdP0_R1, BS_bwdP0b_DHalf, 1.5 * M_PI, M_PI);
806 G4Transform3D tfm_BS_bwdP0_B2 = G4Translate3D(+BS_bwdP0_Xin, 0, -BS_bwdP0b_DHalf - 2 * BS_bwdP0a_DHalf);
807
808 G4VSolid* geo_BS_bwdP0_B3 = new G4Box("geo_BS_bwdP0_B3", BS_bwdP0_Xin, BS_bwdP0_R1, BS_bwdP0b_DHalf);
809 G4Transform3D tfm_BS_bwdP0_B3 = G4Translate3D(0, 0, -BS_bwdP0b_DHalf - 2 * BS_bwdP0a_DHalf);
810
811 double BS_bwdP0c_DHalf = (BS_bwdZ0 - BS_bwdZ2) / 2;
812 G4VSolid* geo_BS_bwdP0_V0 = new G4Tubs("geo_BS_bwdP0_V0", 0, BS_bwdP0_Yin, BS_bwdP0c_DHalf, 0.5 * M_PI, M_PI);
813 G4Transform3D tfm_BS_bwdP0_V0 = G4Translate3D(-BS_bwdP0_Xin, 0, -BS_bwdP0c_DHalf);
814
815 G4VSolid* geo_BS_bwdP0_V1 = new G4Tubs("geo_BS_bwdP0_V1", 0, BS_bwdP0_Yin, BS_bwdP0c_DHalf, 1.5 * M_PI, M_PI);
816 G4Transform3D tfm_BS_bwdP0_V1 = G4Translate3D(+BS_bwdP0_Xin, 0, -BS_bwdP0c_DHalf);
817
818 G4VSolid* geo_BS_bwdP0_V2 = new G4Box("geo_BS_bwdP0_V2", BS_bwdP0_Xin, BS_bwdP0_Yin, BS_bwdP0c_DHalf);
819 G4Transform3D tfm_BS_bwdP0_V2 = G4Translate3D(0, 0, -BS_bwdP0c_DHalf);
820
821 G4VSolid* geo_BS_bwdP0_Base = new G4DisplacedSolid("geo_BS_bwdP0_Base_00", geo_BS_bwdP0_B0, tfm_BS_bwdP0_B0);
822 geo_BS_bwdP0_Base = new G4UnionSolid("geo_BS_bwdP0_Base_01", geo_BS_bwdP0_Base, geo_BS_bwdP0_B1, tfm_BS_bwdP0_B1);
823 geo_BS_bwdP0_Base = new G4UnionSolid("geo_BS_bwdP0_Base_02", geo_BS_bwdP0_Base, geo_BS_bwdP0_B2, tfm_BS_bwdP0_B2);
824 geo_BS_bwdP0_Base = new G4UnionSolid("geo_BS_bwdP0_Base_03", geo_BS_bwdP0_Base, geo_BS_bwdP0_B3, tfm_BS_bwdP0_B3);
825 geo_BS_bwdP0_Base = new G4SubtractionSolid("geo_BS_bwdP0_Base_04", geo_BS_bwdP0_Base, geo_BS_bwdP0_V0, tfm_BS_bwdP0_V0);
826 geo_BS_bwdP0_Base = new G4SubtractionSolid("geo_BS_bwdP0_Base_05", geo_BS_bwdP0_Base, geo_BS_bwdP0_V1, tfm_BS_bwdP0_V1);
827 geo_BS_bwdP0_Base = new G4SubtractionSolid("geo_BS_bwdP0_Base_06", geo_BS_bwdP0_Base, geo_BS_bwdP0_V2, tfm_BS_bwdP0_V2);
828
829 // Parameters for Base5/6
830 double BS_P1_Yout = m_config.getParameter(prep + "P1_Yout") * unitFactor;
831 double BS_P1_Yin = m_config.getParameter(prep + "P1_Yin") * unitFactor;
832 double BS_P1_Rout = m_config.getParameter(prep + "P1_Rout") * unitFactor;
833 double BS_P1_Rin = m_config.getParameter(prep + "P1_Rin") * unitFactor;
834 double BS_P1_Aout = m_config.getParameter(prep + "P1_Aout");
835 double BS_P1_Ain = m_config.getParameter(prep + "P1_Ain");
836 double BS_P1_RX = m_config.getParameter(prep + "P1_RX") * unitFactor;
837 double BS_fwdZhole = m_config.getParameter(prep + "fwdZhole") * unitFactor;
838 double BS_bwdZhole = m_config.getParameter(prep + "bwdZhole") * unitFactor;
839 double BS_P1_Rhole = m_config.getParameter(prep + "P1_Rhole") * unitFactor;
840 double BS_P1_Rbump = m_config.getParameter(prep + "P1_Rbump") * unitFactor;
841 double BS_P1_Yhole = m_config.getParameter(prep + "P1_Yhole") * unitFactor;
842 double BS_P1_MillD1 = m_config.getParameter(prep + "P1_MillD1") * unitFactor;
843 double BS_P1_MillD2 = m_config.getParameter(prep + "P1_MillD2") * unitFactor;
844 double BS_P1_MillX = m_config.getParameter(prep + "P1_MillX") * unitFactor;
845 double BS_P1_MillW = m_config.getParameter(prep + "P1_MillW") * unitFactor;
846 double BS_fwdZcut = m_config.getParameter(prep + "fwdZcut") * unitFactor;
847 double BS_bwdZcut = m_config.getParameter(prep + "bwdZcut") * unitFactor;
848 double BS_P1_XcutTL = m_config.getParameter(prep + "P1_XcutTL") * unitFactor;
849 double BS_P1_XcutTR = m_config.getParameter(prep + "P1_XcutTR") * unitFactor;
850 double BS_P1_XcutBL = m_config.getParameter(prep + "P1_XcutBL") * unitFactor;
851 double BS_P1_XcutBR = m_config.getParameter(prep + "P1_XcutBR") * unitFactor;
852
853 double BS_P1_Xout = BS_P1_Rout * cos(BS_P1_Aout) + BS_P1_RX;
854 double BS_P1_Xin = BS_P1_Rin * cos(BS_P1_Ain) + BS_P1_RX;
855
856 double BS_P1fwd_DHalf = (BS_fwdZ3 - BS_fwdZ2) / 2;
857 G4VSolid* geo_BS_P1fwd_B0 = new G4Box("geo_BS_P1fwd_B0", BS_P1_Xout, BS_P1_Yout, BS_P1fwd_DHalf);
858 G4Transform3D tfm_BS_P1fwd_B0 = G4Translate3D(0, 0, BS_P1fwd_DHalf);
859
860 G4VSolid* geo_BS_P1fwd_B1 = new G4Tubs("geo_BS_P1fwd_B1", 0, BS_P1_Rout, BS_P1fwd_DHalf, M_PI - BS_P1_Aout, 2 * BS_P1_Aout);
861 G4Transform3D tfm_BS_P1fwd_B1 = G4Translate3D(-BS_P1_RX, 0, BS_P1fwd_DHalf);
862
863 G4VSolid* geo_BS_P1fwd_B2 = new G4Tubs("geo_BS_P1fwd_B2", 0, BS_P1_Rout, BS_P1fwd_DHalf, 2 * M_PI - BS_P1_Aout, 2 * BS_P1_Aout);
864 G4Transform3D tfm_BS_P1fwd_B2 = G4Translate3D(+BS_P1_RX, 0, BS_P1fwd_DHalf);
865
866 G4VSolid* geo_BS_P1fwd_B3 = new G4Tubs("geo_BS_P1fwd_B3", 0, BS_P1_Rbump, BS_P1fwd_DHalf, 0, 2 * M_PI);
867 G4Transform3D tfm_BS_P1fwd_B3T = G4Translate3D(0, +BS_P1_Yhole, BS_P1fwd_DHalf);
868 G4Transform3D tfm_BS_P1fwd_B3B = G4Translate3D(0, -BS_P1_Yhole, BS_P1fwd_DHalf);
869
870 G4VSolid* geo_BS_P1fwd_V0 = new G4Box("geo_BS_P1fwd_V0", BS_P1_Xin, BS_P1_Yin, BS_P1fwd_DHalf);
871 G4Transform3D tfm_BS_P1fwd_V0 = G4Translate3D(0, 0, BS_P1fwd_DHalf);
872
873 G4VSolid* geo_BS_P1fwd_V1 = new G4Tubs("geo_BS_P1fwd_V1", 0, BS_P1_Rin, BS_P1fwd_DHalf, M_PI - BS_P1_Ain, 2 * BS_P1_Ain);
874 G4Transform3D tfm_BS_P1fwd_V1 = G4Translate3D(-BS_P1_RX, 0, BS_P1fwd_DHalf);
875
876 G4VSolid* geo_BS_P1fwd_V2 = new G4Tubs("geo_BS_P1fwd_V2", 0, BS_P1_Rin, BS_P1fwd_DHalf, 2 * M_PI - BS_P1_Ain, 2 * BS_P1_Ain);
877 G4Transform3D tfm_BS_P1fwd_V2 = G4Translate3D(+BS_P1_RX, 0, BS_P1fwd_DHalf);
878
879 double BS_P1fwd_V3_DHalf = (BS_fwdZ3 - BS_fwdZhole) / 2;
880 G4VSolid* geo_BS_P1fwd_V3 = new G4Tubs("geo_BS_P1fwd_V3", 0, BS_P1_Rhole, BS_P1fwd_V3_DHalf, 0, 2 * M_PI);
881 G4Transform3D tfm_BS_P1fwd_V3T = G4Translate3D(0, +BS_P1_Yhole, -BS_P1fwd_V3_DHalf + 2 * BS_P1fwd_DHalf);
882 G4Transform3D tfm_BS_P1fwd_V3B = G4Translate3D(0, -BS_P1_Yhole, -BS_P1fwd_V3_DHalf + 2 * BS_P1fwd_DHalf);
883
884 G4VSolid* geo_BS_P1fwd_V4 = new G4Box("geo_BS_P1fwd_V4", BS_P1_MillW / 2, 100, BS_P1_MillD1 / 2);
885 G4Transform3D tfm_BS_P1fwd_V4a = G4Translate3D(-BS_P1_MillX, 0, BS_P1_MillD1 / 2) * G4RotateZ3D(0.25 * M_PI);
886 G4Transform3D tfm_BS_P1fwd_V4b = G4Translate3D(-BS_P1_MillX, 0, BS_P1_MillD1 / 2) * G4RotateZ3D(0.75 * M_PI);
887
888 G4VSolid* geo_BS_P1fwd_V5 = new G4Box("geo_BS_P1fwd_V5", BS_P1_MillW / 2, 100, BS_P1_MillD2 / 2);
889 G4Transform3D tfm_BS_P1fwd_V5a = G4Translate3D(+BS_P1_MillX, 0, BS_P1_MillD2 / 2) * G4RotateZ3D(0.25 * M_PI);
890 G4Transform3D tfm_BS_P1fwd_V5b = G4Translate3D(+BS_P1_MillX, 0, BS_P1_MillD2 / 2) * G4RotateZ3D(0.75 * M_PI);
891
892 double BS_P1fwd_V67_DHalf = (BS_fwdZ3 - BS_fwdZcut) / 2;
893 double BS_P1fwd_V67_Pos = (BS_fwdZcut - BS_fwdZ2);
894 G4VSolid* geo_BS_P1fwd_V6 = new G4Box("geo_BS_P1fwd_V6", (BS_P1_XcutTR - BS_P1_XcutTL) / 2, 100, BS_P1fwd_V67_DHalf);
895 G4Transform3D tfm_BS_P1fwd_V6 = G4Translate3D((BS_P1_XcutTR + BS_P1_XcutTL) / 2, +100, BS_P1fwd_V67_DHalf + BS_P1fwd_V67_Pos);
896
897 G4VSolid* geo_BS_P1fwd_V7 = new G4Box("geo_BS_P1fwd_V7", (BS_P1_XcutBR - BS_P1_XcutBL) / 2, 100, BS_P1fwd_V67_DHalf);
898 G4Transform3D tfm_BS_P1fwd_V7 = G4Translate3D((BS_P1_XcutBR + BS_P1_XcutBL) / 2, -100, BS_P1fwd_V67_DHalf + BS_P1fwd_V67_Pos);
899
900
901 G4VSolid* geo_BS_P1fwd_Base = new G4DisplacedSolid("geo_BS_P1fwd_Base", geo_BS_P1fwd_B0, tfm_BS_P1fwd_B0);
902 geo_BS_P1fwd_Base = new G4UnionSolid("geo_BS_P1fwd_Base", geo_BS_P1fwd_Base, geo_BS_P1fwd_B1, tfm_BS_P1fwd_B1);
903 geo_BS_P1fwd_Base = new G4UnionSolid("geo_BS_P1fwd_Base", geo_BS_P1fwd_Base, geo_BS_P1fwd_B2, tfm_BS_P1fwd_B2);
904 geo_BS_P1fwd_Base = new G4UnionSolid("geo_BS_P1fwd_Base", geo_BS_P1fwd_Base, geo_BS_P1fwd_B3, tfm_BS_P1fwd_B3T);
905 geo_BS_P1fwd_Base = new G4UnionSolid("geo_BS_P1fwd_Base", geo_BS_P1fwd_Base, geo_BS_P1fwd_B3, tfm_BS_P1fwd_B3B);
906 geo_BS_P1fwd_Base = new G4SubtractionSolid("geo_BS_P1fwd_Base", geo_BS_P1fwd_Base, geo_BS_P1fwd_V0, tfm_BS_P1fwd_V0);
907 geo_BS_P1fwd_Base = new G4SubtractionSolid("geo_BS_P1fwd_Base", geo_BS_P1fwd_Base, geo_BS_P1fwd_V1, tfm_BS_P1fwd_V1);
908 geo_BS_P1fwd_Base = new G4SubtractionSolid("geo_BS_P1fwd_Base", geo_BS_P1fwd_Base, geo_BS_P1fwd_V2, tfm_BS_P1fwd_V2);
909 geo_BS_P1fwd_Base = new G4SubtractionSolid("geo_BS_P1fwd_Base", geo_BS_P1fwd_Base, geo_BS_P1fwd_V3, tfm_BS_P1fwd_V3T);
910 geo_BS_P1fwd_Base = new G4SubtractionSolid("geo_BS_P1fwd_Base", geo_BS_P1fwd_Base, geo_BS_P1fwd_V3, tfm_BS_P1fwd_V3B);
911 geo_BS_P1fwd_Base = new G4SubtractionSolid("geo_BS_P1fwd_Base", geo_BS_P1fwd_Base, geo_BS_P1fwd_V4, tfm_BS_P1fwd_V4a);
912 geo_BS_P1fwd_Base = new G4SubtractionSolid("geo_BS_P1fwd_Base", geo_BS_P1fwd_Base, geo_BS_P1fwd_V4, tfm_BS_P1fwd_V4b);
913 geo_BS_P1fwd_Base = new G4SubtractionSolid("geo_BS_P1fwd_Base", geo_BS_P1fwd_Base, geo_BS_P1fwd_V5, tfm_BS_P1fwd_V5a);
914 geo_BS_P1fwd_Base = new G4SubtractionSolid("geo_BS_P1fwd_Base", geo_BS_P1fwd_Base, geo_BS_P1fwd_V5, tfm_BS_P1fwd_V5b);
915 geo_BS_P1fwd_Base = new G4SubtractionSolid("geo_BS_P1fwd_Base", geo_BS_P1fwd_Base, geo_BS_P1fwd_V6, tfm_BS_P1fwd_V6);
916 geo_BS_P1fwd_Base = new G4SubtractionSolid("geo_BS_P1fwd_Base", geo_BS_P1fwd_Base, geo_BS_P1fwd_V7, tfm_BS_P1fwd_V7);
917
918 double BS_P1bwd_DHalf = -(BS_bwdZ3 - BS_bwdZ2) / 2;
919 G4VSolid* geo_BS_P1bwd_B0 = new G4Box("geo_BS_P1bwd_B0", BS_P1_Xout, BS_P1_Yout, BS_P1bwd_DHalf);
920 G4Transform3D tfm_BS_P1bwd_B0 = G4Translate3D(0, 0, BS_P1bwd_DHalf);
921
922 G4VSolid* geo_BS_P1bwd_B1 = new G4Tubs("geo_BS_P1bwd_B1", 0, BS_P1_Rout, BS_P1bwd_DHalf, M_PI - BS_P1_Aout, 2 * BS_P1_Aout);
923 G4Transform3D tfm_BS_P1bwd_B1 = G4Translate3D(-BS_P1_RX, 0, BS_P1bwd_DHalf);
924
925 G4VSolid* geo_BS_P1bwd_B2 = new G4Tubs("geo_BS_P1bwd_B2", 0, BS_P1_Rout, BS_P1bwd_DHalf, 2 * M_PI - BS_P1_Aout, 2 * BS_P1_Aout);
926 G4Transform3D tfm_BS_P1bwd_B2 = G4Translate3D(+BS_P1_RX, 0, BS_P1bwd_DHalf);
927
928 G4VSolid* geo_BS_P1bwd_B3 = new G4Tubs("geo_BS_P1bwd_B3", 0, BS_P1_Rbump, BS_P1bwd_DHalf, 0, 2 * M_PI);
929 G4Transform3D tfm_BS_P1bwd_B3T = G4Translate3D(0, +BS_P1_Yhole, BS_P1bwd_DHalf);
930 G4Transform3D tfm_BS_P1bwd_B3B = G4Translate3D(0, -BS_P1_Yhole, BS_P1bwd_DHalf);
931
932 G4VSolid* geo_BS_P1bwd_V0 = new G4Box("geo_BS_P1bwd_V0", BS_P1_Xin, BS_P1_Yin, BS_P1bwd_DHalf);
933 G4Transform3D tfm_BS_P1bwd_V0 = G4Translate3D(0, 0, BS_P1bwd_DHalf);
934
935 G4VSolid* geo_BS_P1bwd_V1 = new G4Tubs("geo_BS_P1bwd_V1", 0, BS_P1_Rin, BS_P1bwd_DHalf, M_PI - BS_P1_Ain, 2 * BS_P1_Ain);
936 G4Transform3D tfm_BS_P1bwd_V1 = G4Translate3D(-BS_P1_RX, 0, BS_P1bwd_DHalf);
937
938 G4VSolid* geo_BS_P1bwd_V2 = new G4Tubs("geo_BS_P1bwd_V2", 0, BS_P1_Rin, BS_P1bwd_DHalf, 2 * M_PI - BS_P1_Ain, 2 * BS_P1_Ain);
939 G4Transform3D tfm_BS_P1bwd_V2 = G4Translate3D(+BS_P1_RX, 0, BS_P1bwd_DHalf);
940
941 double BS_P1bwd_V3_DHalf = -(BS_bwdZ3 - BS_bwdZhole) / 2;
942 G4VSolid* geo_BS_P1bwd_V3 = new G4Tubs("geo_BS_P1bwd_V3", 0, BS_P1_Rhole, BS_P1bwd_V3_DHalf, 0, 2 * M_PI);
943 G4Transform3D tfm_BS_P1bwd_V3T = G4Translate3D(0, +BS_P1_Yhole, -BS_P1bwd_V3_DHalf + 2 * BS_P1bwd_DHalf);
944 G4Transform3D tfm_BS_P1bwd_V3B = G4Translate3D(0, -BS_P1_Yhole, -BS_P1bwd_V3_DHalf + 2 * BS_P1bwd_DHalf);
945
946 G4VSolid* geo_BS_P1bwd_V4 = new G4Box("geo_BS_P1bwd_V4", BS_P1_MillW / 2, 100, BS_P1_MillD1 / 2);
947 G4Transform3D tfm_BS_P1bwd_V4a = G4Translate3D(-BS_P1_MillX, 0, BS_P1_MillD1 / 2) * G4RotateZ3D(0.25 * M_PI);
948 G4Transform3D tfm_BS_P1bwd_V4b = G4Translate3D(-BS_P1_MillX, 0, BS_P1_MillD1 / 2) * G4RotateZ3D(0.75 * M_PI);
949
950 G4VSolid* geo_BS_P1bwd_V5 = new G4Box("geo_BS_P1bwd_V5", BS_P1_MillW / 2, 100, BS_P1_MillD2 / 2);
951 G4Transform3D tfm_BS_P1bwd_V5a = G4Translate3D(+BS_P1_MillX, 0, BS_P1_MillD2 / 2) * G4RotateZ3D(0.25 * M_PI);
952 G4Transform3D tfm_BS_P1bwd_V5b = G4Translate3D(+BS_P1_MillX, 0, BS_P1_MillD2 / 2) * G4RotateZ3D(0.75 * M_PI);
953
954 double BS_P1bwd_V67_DHalf = -(BS_bwdZ3 - BS_bwdZcut) / 2;
955 double BS_P1bwd_V67_Pos = -(BS_bwdZcut - BS_bwdZ2);
956 G4VSolid* geo_BS_P1bwd_V6 = new G4Box("geo_BS_P1bwd_V6", (BS_P1_XcutTR - BS_P1_XcutTL) / 2, 100, BS_P1bwd_V67_DHalf);
957 G4Transform3D tfm_BS_P1bwd_V6 = G4Translate3D((BS_P1_XcutTR + BS_P1_XcutTL) / 2, +100, BS_P1bwd_V67_DHalf + BS_P1bwd_V67_Pos);
958
959 G4VSolid* geo_BS_P1bwd_V7 = new G4Box("geo_BS_P1bwd_V7", (BS_P1_XcutBR - BS_P1_XcutBL) / 2, 100, BS_P1bwd_V67_DHalf);
960 G4Transform3D tfm_BS_P1bwd_V7 = G4Translate3D((BS_P1_XcutBR + BS_P1_XcutBL) / 2, -100, BS_P1bwd_V67_DHalf + BS_P1bwd_V67_Pos);
961
962
963 G4VSolid* geo_BS_P1bwd_Base = new G4DisplacedSolid("geo_BS_P1bwd_Base", geo_BS_P1bwd_B0, tfm_BS_P1bwd_B0);
964 geo_BS_P1bwd_Base = new G4UnionSolid("geo_BS_P1bwd_Base", geo_BS_P1bwd_Base, geo_BS_P1bwd_B1, tfm_BS_P1bwd_B1);
965 geo_BS_P1bwd_Base = new G4UnionSolid("geo_BS_P1bwd_Base", geo_BS_P1bwd_Base, geo_BS_P1bwd_B2, tfm_BS_P1bwd_B2);
966 geo_BS_P1bwd_Base = new G4UnionSolid("geo_BS_P1bwd_Base", geo_BS_P1bwd_Base, geo_BS_P1bwd_B3, tfm_BS_P1bwd_B3T);
967 geo_BS_P1bwd_Base = new G4UnionSolid("geo_BS_P1bwd_Base", geo_BS_P1bwd_Base, geo_BS_P1bwd_B3, tfm_BS_P1bwd_B3B);
968 geo_BS_P1bwd_Base = new G4SubtractionSolid("geo_BS_P1bwd_Base", geo_BS_P1bwd_Base, geo_BS_P1bwd_V0, tfm_BS_P1bwd_V0);
969 geo_BS_P1bwd_Base = new G4SubtractionSolid("geo_BS_P1bwd_Base", geo_BS_P1bwd_Base, geo_BS_P1bwd_V1, tfm_BS_P1bwd_V1);
970 geo_BS_P1bwd_Base = new G4SubtractionSolid("geo_BS_P1bwd_Base", geo_BS_P1bwd_Base, geo_BS_P1bwd_V2, tfm_BS_P1bwd_V2);
971 geo_BS_P1bwd_Base = new G4SubtractionSolid("geo_BS_P1bwd_Base", geo_BS_P1bwd_Base, geo_BS_P1bwd_V3, tfm_BS_P1bwd_V3T);
972 geo_BS_P1bwd_Base = new G4SubtractionSolid("geo_BS_P1bwd_Base", geo_BS_P1bwd_Base, geo_BS_P1bwd_V3, tfm_BS_P1bwd_V3B);
973 geo_BS_P1bwd_Base = new G4SubtractionSolid("geo_BS_P1bwd_Base", geo_BS_P1bwd_Base, geo_BS_P1bwd_V4, tfm_BS_P1bwd_V4a);
974 geo_BS_P1bwd_Base = new G4SubtractionSolid("geo_BS_P1bwd_Base", geo_BS_P1bwd_Base, geo_BS_P1bwd_V4, tfm_BS_P1bwd_V4b);
975 geo_BS_P1bwd_Base = new G4SubtractionSolid("geo_BS_P1bwd_Base", geo_BS_P1bwd_Base, geo_BS_P1bwd_V5, tfm_BS_P1bwd_V5a);
976 geo_BS_P1bwd_Base = new G4SubtractionSolid("geo_BS_P1bwd_Base", geo_BS_P1bwd_Base, geo_BS_P1bwd_V5, tfm_BS_P1bwd_V5b);
977 geo_BS_P1bwd_Base = new G4SubtractionSolid("geo_BS_P1bwd_Base", geo_BS_P1bwd_Base, geo_BS_P1bwd_V6, tfm_BS_P1bwd_V6);
978 geo_BS_P1bwd_Base = new G4SubtractionSolid("geo_BS_P1bwd_Base", geo_BS_P1bwd_Base, geo_BS_P1bwd_V7, tfm_BS_P1bwd_V7);
979
980 // Parameters for Base7/8 (FWD) Base23/24 (BWD)
981 double BS_P2_Rout = m_config.getParameter(prep + "P2_Rout") * unitFactor;
982 double BS_P2_Rin = m_config.getParameter(prep + "P2_Rin") * unitFactor;
983 double BS_P2_Xin = m_config.getParameter(prep + "P2_Xin") * unitFactor;
984 double BS_P2_Rhole = m_config.getParameter(prep + "P2_Rhole") * unitFactor;
985 double BS_P2_Yhole = m_config.getParameter(prep + "P2_Yhole") * unitFactor;
986 double BS_P2_XcutTL = m_config.getParameter(prep + "P2_XcutTL") * unitFactor;
987 double BS_P2_XcutTR = m_config.getParameter(prep + "P2_XcutTR") * unitFactor;
988 double BS_P2_XcutBL = m_config.getParameter(prep + "P2_XcutBL") * unitFactor;
989 double BS_P2_XcutBR = m_config.getParameter(prep + "P2_XcutBR") * unitFactor;
990
991 double BS_P2fwd_DHalf = (BS_fwdZ4 - BS_fwdZ3) / 2;
992 G4VSolid* geo_BS_P2fwd_B0 = new G4Tubs("geo_BS_P2fwd_B0", 0, BS_P2_Rout, BS_P2fwd_DHalf, 0, 2 * M_PI);
993 G4Transform3D tfm_BS_P2fwd_B0 = G4Translate3D(0, 0, BS_P2fwd_DHalf);
994
995 G4VSolid* geo_BS_P2fwd_V0 = new G4Box("geo_BS_P2fwd_V0", BS_P2_Xin, BS_P2_Rin, BS_P2fwd_DHalf);
996 G4Transform3D tfm_BS_P2fwd_V0 = G4Translate3D(0, 0, BS_P2fwd_DHalf);
997
998 G4VSolid* geo_BS_P2fwd_V1 = new G4Tubs("geo_BS_P2fwd_V1", 0, BS_P2_Rin, BS_P2fwd_DHalf, 0, 2 * M_PI);
999 G4Transform3D tfm_BS_P2fwd_V1L = G4Translate3D(-BS_P2_Xin, 0, BS_P2fwd_DHalf);
1000 G4Transform3D tfm_BS_P2fwd_V1R = G4Translate3D(+BS_P2_Xin, 0, BS_P2fwd_DHalf);
1001
1002 G4VSolid* geo_BS_P2fwd_V2 = new G4Tubs("geo_BS_P2fwd_V2", 0, BS_P2_Rhole, BS_P2fwd_DHalf, 0, 2 * M_PI);
1003 G4Transform3D tfm_BS_P2fwd_V2T = G4Translate3D(0, +BS_P2_Yhole, BS_P2fwd_DHalf);
1004 G4Transform3D tfm_BS_P2fwd_V2B = G4Translate3D(0, -BS_P2_Yhole, BS_P2fwd_DHalf);
1005
1006 G4VSolid* geo_BS_P2fwd_V3 = new G4Box("geo_BS_P2fwd_V3", (BS_P2_XcutTR - BS_P2_XcutTL) / 2, 100, BS_P2fwd_DHalf);
1007 G4Transform3D tfm_BS_P2fwd_V3 = G4Translate3D((BS_P2_XcutTR + BS_P2_XcutTL) / 2, +100, BS_P2fwd_DHalf);
1008
1009 G4VSolid* geo_BS_P2fwd_V4 = new G4Box("geo_BS_P2fwd_V4", (BS_P2_XcutBR - BS_P2_XcutBL) / 2, 100, BS_P2fwd_DHalf);
1010 G4Transform3D tfm_BS_P2fwd_V4 = G4Translate3D((BS_P2_XcutBR + BS_P2_XcutBL) / 2, -100, BS_P2fwd_DHalf);
1011
1012 G4VSolid* geo_BS_P2fwd_Base = new G4DisplacedSolid("geo_BS_P2fwd_Base", geo_BS_P2fwd_B0, tfm_BS_P2fwd_B0);
1013 geo_BS_P2fwd_Base = new G4SubtractionSolid("geo_BS_P2fwd_Base", geo_BS_P2fwd_Base, geo_BS_P2fwd_V0, tfm_BS_P2fwd_V0);
1014 geo_BS_P2fwd_Base = new G4SubtractionSolid("geo_BS_P2fwd_Base", geo_BS_P2fwd_Base, geo_BS_P2fwd_V1, tfm_BS_P2fwd_V1L);
1015 geo_BS_P2fwd_Base = new G4SubtractionSolid("geo_BS_P2fwd_Base", geo_BS_P2fwd_Base, geo_BS_P2fwd_V1, tfm_BS_P2fwd_V1R);
1016 geo_BS_P2fwd_Base = new G4SubtractionSolid("geo_BS_P2fwd_Base", geo_BS_P2fwd_Base, geo_BS_P2fwd_V2, tfm_BS_P2fwd_V2T);
1017 geo_BS_P2fwd_Base = new G4SubtractionSolid("geo_BS_P2fwd_Base", geo_BS_P2fwd_Base, geo_BS_P2fwd_V2, tfm_BS_P2fwd_V2B);
1018 geo_BS_P2fwd_Base = new G4SubtractionSolid("geo_BS_P2fwd_Base", geo_BS_P2fwd_Base, geo_BS_P2fwd_V3, tfm_BS_P2fwd_V3);
1019 geo_BS_P2fwd_Base = new G4SubtractionSolid("geo_BS_P2fwd_Base", geo_BS_P2fwd_Base, geo_BS_P2fwd_V4, tfm_BS_P2fwd_V4);
1020
1021
1022 //++++ Assemble and place the FWD bellows shield ++++//
1023 G4Transform3D tfm_BS_fwdP1 = G4Translate3D(0, 0, BS_fwdZ2 - BS_fwdZ0);
1024 G4Transform3D tfm_BS_fwdP2 = G4Translate3D(0, 0, BS_fwdZ3 - BS_fwdZ0);
1025
1026 G4VSolid* geo_BS_fwd = geo_BS_fwdP0_Base;
1027 geo_BS_fwd = new G4UnionSolid("geo_BS_fwd", geo_BS_fwd, geo_BS_P1fwd_Base, tfm_BS_fwdP1);
1028 geo_BS_fwd = new G4UnionSolid("geo_BS_fwd", geo_BS_fwd, geo_BS_P2fwd_Base, tfm_BS_fwdP2);
1029
1030 G4LogicalVolume* logi_BS_fwd = new G4LogicalVolume(geo_BS_fwd, mat_BS, "logi_BS_fwd");
1031
1032 G4Transform3D tfm_BS_fwd = G4Translate3D(0, 0, BS_fwdZ0);
1033 new G4PVPlacement(tfm_BS_fwd, logi_BS_fwd, "phys_BS_fwd", &topVolume, false, 0);
1034 //++++ +++++++++++++++++++++++++++++++++++++++++++ ++++//
1035
1036 //++++ Assemble and place the BWD bellows shield ++++//
1037 G4Transform3D tfm_BS_bwdP1 = G4Translate3D(0, 0, BS_bwdZ2 - BS_bwdZ0) * G4RotateY3D(M_PI);
1038
1039 G4VSolid* geo_BS_bwd = geo_BS_bwdP0_Base;
1040 geo_BS_bwd = new G4UnionSolid("geo_BS_bwd", geo_BS_bwd, geo_BS_P1bwd_Base, tfm_BS_bwdP1);
1041
1042 G4LogicalVolume* logi_BS_bwd = new G4LogicalVolume(geo_BS_bwd, mat_BS, "logi_BS_bwd");
1043
1044 G4Transform3D tfm_BS_bwd = G4Translate3D(0, 0, BS_bwdZ0);
1045 new G4PVPlacement(tfm_BS_bwd, logi_BS_bwd, "phys_BS_bwd", &topVolume, false, 0);
1046 //++++ +++++++++++++++++++++++++++++++++++++++++++ ++++//
1047
1048
1049 //--------------
1050 //- Rest of elements with typical geometry
1051
1052 std::vector<std::string> straightSections;
1053 boost::split(straightSections, m_config.getParameterStr("Straight"), boost::is_any_of(" "));
1054 for (const auto& name : straightSections) {
1055 prep = name + ".";
1056
1057 CryostatElement polycone;
1058
1059 int N = int(m_config.getParameter(prep + "N"));
1060
1061 std::vector<double> Z(N);
1062 std::vector<double> R(N);
1063 std::vector<double> r(N);
1064
1065 for (int i = 0; i < N; ++i) {
1066 ostringstream ossZID;
1067 ossZID << "Z" << i;
1068
1069 ostringstream ossRID;
1070 ossRID << "R" << i;
1071
1072 ostringstream ossrID;
1073 ossrID << "r" << i;
1074
1075 Z[i] = m_config.getParameter(prep + ossZID.str()) * unitFactor;
1076 R[i] = m_config.getParameter(prep + ossRID.str()) * unitFactor;
1077 r[i] = m_config.getParameter(prep + ossrID.str(), 0.0) * unitFactor;
1078 }
1079
1080 polycone.transform = G4Translate3D(0.0, 0.0, 0.0);
1081
1082 //define geometry
1083 string motherVolume = m_config.getParameterStr(prep + "MotherVolume");
1084 string subtract = m_config.getParameterStr(prep + "Subtract", "");
1085 string intersect = m_config.getParameterStr(prep + "Intersect", "");
1086
1087 string geo_polyconexx_name = "geo_" + name + "xx_name";
1088 string geo_polyconex_name = "geo_" + name + "x_name";
1089 string geo_polycone_name = "geo_" + name + "_name";
1090
1091 G4VSolid* geo_polyconexx, *geo_polycone;
1092
1093 if (subtract != "" && intersect != "") {
1094 geo_polyconexx = new G4Polycone(geo_polyconexx_name, 0.0, 2 * M_PI, N, &(Z[0]), &(r[0]), &(R[0]));
1095 G4VSolid* geo_polyconex = new G4SubtractionSolid(geo_polyconex_name, geo_polyconexx, elements[subtract].geo,
1096 elements[motherVolume].transform.inverse()*polycone.transform.inverse()*elements[subtract].transform);
1097 geo_polycone = new G4IntersectionSolid(geo_polycone_name, geo_polyconex, elements[intersect].geo,
1098 elements[motherVolume].transform.inverse()*polycone.transform.inverse()*elements[intersect].transform);
1099 } else if (subtract != "") {
1100 geo_polyconexx = new G4Polycone(geo_polyconexx_name, 0.0, 2 * M_PI, N, &(Z[0]), &(r[0]), &(R[0]));
1101 geo_polycone = new G4SubtractionSolid(geo_polycone_name, geo_polyconexx, elements[subtract].geo,
1102 elements[motherVolume].transform.inverse()*polycone.transform.inverse()*elements[subtract].transform);
1103 } else if (intersect != "") {
1104 geo_polyconexx = new G4Polycone(geo_polyconexx_name, 0.0, 2 * M_PI, N, &(Z[0]), &(r[0]), &(R[0]));
1105 geo_polycone = new G4IntersectionSolid(geo_polycone_name, geo_polyconexx, elements[intersect].geo,
1106 elements[motherVolume].transform.inverse()*polycone.transform.inverse()*elements[intersect].transform);
1107 } else
1108 geo_polycone = new G4Polycone(geo_polycone_name, 0.0, 2 * M_PI, N, &(Z[0]), &(r[0]), &(R[0]));
1109
1110 polycone.geo = geo_polycone;
1111
1112 // define logical volume
1113 string strMat_polycone = m_config.getParameterStr(prep + "Material");
1114 G4Material* mat_polycone = Materials::get(strMat_polycone);
1115 string logi_polycone_name = "logi_" + name + "_name";
1116 polycone.logi = new G4LogicalVolume(polycone.geo, mat_polycone, logi_polycone_name);
1117 setColor(*polycone.logi, "#CC0000");
1118 setVisibility(*polycone.logi, false);
1119
1120 //put volume
1121 string phys_polycone_name = "phys_" + name + "_name";
1122 new G4PVPlacement(polycone.transform, polycone.logi, phys_polycone_name, elements[motherVolume].logi, false, 0);
1123
1124 //to use it later in "intersect" and "subtract"
1125 polycone.transform = polycone.transform * elements[motherVolume].transform;
1126
1127 elements[name] = polycone;
1128 }
1129
1130
1131 //--------------------------------------------------------------------------------------------
1132 //- Shields
1133
1134 std::vector<std::string> shields;
1135 boost::split(shields, m_config.getParameterStr("Shield"), boost::is_any_of(" "));
1136 for (const auto& name : shields) {
1137 prep = name + ".";
1138
1139 //- Shield made as box with optional subtracted box-shaped inner space (hole)
1140
1141 double shield_W = m_config.getParameter(prep + "W") * unitFactor;
1142 double shield_H = m_config.getParameter(prep + "H") * unitFactor;
1143 double shield_L = m_config.getParameter(prep + "L") * unitFactor;
1144 double shield_X0 = m_config.getParameter(prep + "X0") * unitFactor;
1145 double shield_Y0 = m_config.getParameter(prep + "Y0") * unitFactor;
1146 double shield_Z0 = m_config.getParameter(prep + "Z0") * unitFactor;
1147
1148 double shield_hole_W = m_config.getParameter(prep + "holeW", 0) * unitFactor;
1149 double shield_hole_H = m_config.getParameter(prep + "holeH", 0) * unitFactor;
1150 double shield_hole_L = m_config.getParameter(prep + "holeL", 0) * unitFactor;
1151 double shield_hole_dX = m_config.getParameter(prep + "holeDX", 0) * unitFactor;
1152 double shield_hole_dY = m_config.getParameter(prep + "holeDY", 0) * unitFactor;
1153 double shield_hole_dZ = m_config.getParameter(prep + "holeDZ", 0) * unitFactor;
1154
1155 double shield_PHI = m_config.getParameter(prep + "PHI");
1156
1157 // storable element
1158 CryostatElement shield;
1159
1160 shield.transform = G4Translate3D(shield_X0, shield_Y0, shield_Z0);
1161 shield.transform = shield.transform * G4RotateY3D(shield_PHI / Unit::rad);
1162
1163 G4Transform3D transform_shield_hole = G4Translate3D(shield_hole_dX, shield_hole_dY, shield_hole_dZ);
1164
1165 //define geometry
1166 string geo_shieldx_name = "geo_" + name + "x_name";
1167 string geo_shield_hole_name = "geo_" + name + "_hole_name";
1168 string geo_shield_name = "geo_" + name + "_name";
1169
1170 if (shield_hole_W == 0 || shield_hole_H == 0 || shield_hole_L == 0) {
1171 G4Box* geo_shield = new G4Box(geo_shield_name, shield_W / 2.0, shield_H / 2.0, shield_L / 2.0);
1172
1173 shield.geo = geo_shield;
1174 } else {
1175 G4Box* geo_shieldx = new G4Box(geo_shieldx_name, shield_W / 2.0, shield_H / 2.0, shield_L / 2.0);
1176 G4Box* geo_shield_hole = new G4Box(geo_shield_hole_name, shield_hole_W / 2.0, shield_hole_H / 2.0, shield_hole_L / 2.0);
1177 G4SubtractionSolid* geo_shield = new G4SubtractionSolid(geo_shield_name, geo_shieldx, geo_shield_hole,
1178 transform_shield_hole);
1179
1180 shield.geo = geo_shield;
1181 }
1182
1183 string strMat_shield = m_config.getParameterStr(prep + "Material");
1184 G4Material* mat_shield = Materials::get(strMat_shield);
1185
1186 string logi_shield_name = "logi_" + name + "_name";
1187 G4LogicalVolume* logi_shield = new G4LogicalVolume(shield.geo, mat_shield, logi_shield_name);
1188
1189 shield.logi = logi_shield;
1190
1191 //put volume
1192 setColor(*logi_shield, "#0000CC");
1193 //setVisibility(*logi_shield, false);
1194 string phys_shield_name = "phys_" + name + "_name";
1195 new G4PVPlacement(shield.transform, shield.logi, phys_shield_name, &topVolume, false, 0);
1196
1197 elements[name] = shield;
1198 }
1199
1200
1201 // RVC connection structure (simplified shape)
1202 G4Tubs* geo_rvcR = new G4Tubs("geo_rvcR", 60, 60 + 60, (620 - 560) / 2., 0, 2 * M_PI);
1203 G4LogicalVolume* logi_rvcR = new G4LogicalVolume(geo_rvcR, Materials::get("SUS316L"), "logi_rvcR_name");
1204 new G4PVPlacement(0, G4ThreeVector(0, 0, (620 + 560) / 2.), logi_rvcR, "phys_rvcR_name", &topVolume, false, 0);
1205
1206 G4Tubs* geo_rvcL = new G4Tubs("geo_rvcL", 60, 60 + 60, (-560 - (-620)) / 2., 0, 2 * M_PI);
1207 G4LogicalVolume* logi_rvcL = new G4LogicalVolume(geo_rvcL, Materials::get("SUS316L"), "logi_rvcL_name");
1208 new G4PVPlacement(0, G4ThreeVector(0, 0, (-620 - 560) / 2.), logi_rvcL, "phys_rvcL_name", &topVolume, false, 0);
1209
1210 // Added 10 Nov 2018
1211 // Elliptical inner surface around QC1LE
1212 G4EllipticalTube* geo_elp_QC1LEx = new G4EllipticalTube("geo_elp_QC1LEx", 10.5, 13.5, (-675 - (-1225)) / 2.); //in mm
1213 G4IntersectionSolid* geo_elp_QC1LE = new G4IntersectionSolid("geo_elp_QC1LE", elements["D2wal1"].geo, geo_elp_QC1LEx,
1214 G4Translate3D(0, 0, (-675 - 1225) / 2.));
1215 G4LogicalVolume* logi_elp_QC1LE = new G4LogicalVolume(geo_elp_QC1LE, Materials::get("Vacuum"), "logi_elp_QC1LE_name");
1216 new G4PVPlacement(0, G4ThreeVector(0, 0, 0), logi_elp_QC1LE, "phys_elp_QC1LE_name", elements["D2wal1"].logi, false, 0);
1217 // Elliptical inner surface around QC1LP
1218 G4EllipticalTube* geo_elp_QC1LPx = new G4EllipticalTube("geo_elp_QC1LPx", 10.5, 13.5, (-675 - (-1225)) / 2.); //in mm
1219 G4IntersectionSolid* geo_elp_QC1LP = new G4IntersectionSolid("geo_elp_QC1LP", elements["E2wal1"].geo, geo_elp_QC1LPx,
1220 G4Translate3D(0, 0, (-675 - 1225) / 2.));
1221 G4LogicalVolume* logi_elp_QC1LP = new G4LogicalVolume(geo_elp_QC1LP, Materials::get("Vacuum"), "logi_elp_QC1LP_name");
1222 new G4PVPlacement(0, G4ThreeVector(0, 0, 0), logi_elp_QC1LP, "phys_elp_QC1LP_name", elements["E2wal1"].logi, false, 0);
1223 // Elliptical inner surface around QC1RE
1224 G4EllipticalTube* geo_elp_QC1REx = new G4EllipticalTube("geo_elp_QC1REx", 10.5, 13.5, (1225 - 675) / 2.); //in mm
1225 G4IntersectionSolid* geo_elp_QC1RE = new G4IntersectionSolid("geo_elp_QC1RE", elements["A2wal1"].geo, geo_elp_QC1REx,
1226 G4Translate3D(0, 0, (1225 + 675) / 2.));
1227 G4LogicalVolume* logi_elp_QC1RE = new G4LogicalVolume(geo_elp_QC1RE, Materials::get("Vacuum"), "logi_elp_QC1RE_name");
1228 new G4PVPlacement(0, G4ThreeVector(0, 0, 0), logi_elp_QC1RE, "phys_elp_QC1RE_name", elements["A2wal1"].logi, false, 0);
1229 // Elliptical inner surface around QC1RP
1230 G4EllipticalTube* geo_elp_QC1RPx = new G4EllipticalTube("geo_elp_QC1RPx", 10.5, 13.5, (1225 - 675) / 2.); //in mm
1231 G4IntersectionSolid* geo_elp_QC1RP = new G4IntersectionSolid("geo_elp_QC1RP", elements["B2wal1"].geo, geo_elp_QC1RPx,
1232 G4Translate3D(0, 0, (1225 + 675) / 2.));
1233 G4LogicalVolume* logi_elp_QC1RP = new G4LogicalVolume(geo_elp_QC1RP, Materials::get("Vacuum"), "logi_elp_QC1RP_name");
1234 new G4PVPlacement(0, G4ThreeVector(0, 0, 0), logi_elp_QC1RP, "phys_elp_QC1RP_name", elements["B2wal1"].logi, false, 0);
1235
1236
1237
1238
1239 //--------------------------------------------------------------------------------------------
1240 //- 2023 QCS shielding
1241
1242 if (m_config.getParameter("polyBlock-R-L1.L", -1) > 0) {
1243 // Run1 = false; post LS1
1244
1245 std::vector<std::string> polyBlocks;
1246 boost::split(polyBlocks, m_config.getParameterStr("PolyBlock"), boost::is_any_of(" "));
1247 for (const auto& name : polyBlocks) {
1248 prep = name + ".";
1249 //string type = m_config.getParameterStr(prep + "type");
1250
1251 double block_L = m_config.getParameter(prep + "L") * unitFactor;
1252 double block_R = m_config.getParameter(prep + "R") * unitFactor;
1253 double block_r = m_config.getParameter(prep + "r") * unitFactor;
1254 double block_W = m_config.getParameter(prep + "W") * unitFactor;
1255 double block_w = m_config.getParameter(prep + "w") * unitFactor;
1256 double block_t = m_config.getParameter(prep + "t") * unitFactor;
1257 double block_Z0 = m_config.getParameter(prep + "Z0") * unitFactor;
1258 double block_dr = m_config.getParameter(prep + "dr", 0.0) * unitFactor;
1259 // Number of instances
1260 int block_N = int(m_config.getParameter(prep + "N"));
1261
1262 std::vector<double> block_PHIs(block_N);
1263 for (int i = 0; i < block_N; ++i) {
1264 ostringstream oss_block_num;
1265 oss_block_num << i;
1266 block_PHIs[i] = m_config.getParameter(prep + "PHI" + oss_block_num.str());
1267 }
1268
1269 // Box shaped cuts, if any
1270 double block_cut_L0 = m_config.getParameter(prep + "cutL0", 0.0) * unitFactor;
1271 double block_cut_L1 = m_config.getParameter(prep + "cutL1", 0.0) * unitFactor;
1272 int block_cut_N = 0;
1273 if (block_cut_L0 != 0.0 && block_cut_L1 != 0.0) {
1274 block_cut_N = 2;
1275 } else if (block_cut_L0 != 0.0 || block_cut_L1 != 0.0) {
1276 block_cut_N = 1;
1277 } else {
1278 block_cut_N = 0;
1279 }
1280
1281 //define geometry
1282 string geo_block_name;
1283 if (block_cut_N == 0) {
1284 geo_block_name = "geo_" + name + "_name";
1285 } else {
1286 geo_block_name = "geo_" + name + "_x_name";
1287 }
1288
1289 double block_T = sqrt((block_R - block_r) * (block_R - block_r) + (block_W - block_w) * (block_W - block_w) / 4.0);
1290
1291 int nSect = 5;
1292 std::vector<G4TwoVector> xy(nSect);
1293 xy[0].set(0.0, 0.0);
1294 xy[1].set(-block_T, (block_W - block_w) / 2.0);
1295 xy[2].set(-block_t, block_W / 2.0);
1296 xy[3].set(-block_T, (block_w + block_W) / 2.0);
1297 xy[4].set(0.0, block_W);
1298
1299 G4TwoVector offset1(block_dr, 0.0), offset2(0.0, 0.0);
1300 G4double scale1 = 1.0, scale2 = 1.0;
1301
1302 G4VSolid* geo_block = new G4ExtrudedSolid(geo_block_name, xy, block_L / 2.0, offset1, scale1, offset2, scale2);
1303
1304 for (int i = 0; i < block_cut_N; ++i) {
1305 ostringstream oss_block_num;
1306 oss_block_num << i;
1307
1308 if (i == block_cut_N - 1) {
1309 geo_block_name = "geo_" + name + "_name";
1310 } else {
1311 geo_block_name = "geo_" + name + "_x" + oss_block_num.str() + "_name";
1312 }
1313 string geo_cut_name = "geo_" + name + "_cut" + oss_block_num.str() + "_name";
1314
1315 double cut_L = m_config.getParameter(prep + "cutL" + oss_block_num.str()) * unitFactor;
1316 double cut_W = m_config.getParameter(prep + "cutW" + oss_block_num.str()) * unitFactor;
1317 double cut_H = m_config.getParameter(prep + "cutH" + oss_block_num.str()) * unitFactor;
1318
1319 G4VSolid* geo_cut = new G4Box(geo_cut_name, cut_W / 2.0, cut_H / 2.0, cut_L / 2.0);
1320
1321 double cut_X0 = m_config.getParameter(prep + "cutX0" + oss_block_num.str()) * unitFactor;
1322 double cut_Y0 = m_config.getParameter(prep + "cutY0" + oss_block_num.str()) * unitFactor;
1323 double cut_Z0 = m_config.getParameter(prep + "cutZ0" + oss_block_num.str()) * unitFactor;
1324 double cut_PHI = m_config.getParameter(prep + "cutPHI" + oss_block_num.str());
1325
1326 G4Transform3D cut_transform = G4Translate3D(cut_X0, cut_Y0, cut_Z0);
1327 cut_transform = cut_transform * G4RotateY3D(cut_PHI / Unit::rad);
1328
1329 geo_block = new G4SubtractionSolid(geo_block_name, geo_block, geo_cut, cut_transform);
1330 //geo_block = new G4UnionSolid(geo_block_name, geo_block, geo_cut, cut_transform);
1331 }
1332
1333 // logical volume
1334 string strMat_block = m_config.getParameterStr(prep + "Material");
1335 G4Material* mat_block = Materials::get(strMat_block);
1336
1337 string logi_block_name = "logi_" + name + "_name";
1338 G4LogicalVolume* logi_block = new G4LogicalVolume(geo_block, mat_block, logi_block_name);
1339
1340 //put volume
1341 setColor(*logi_block, "#00CC00");
1342 //setVisibility(*logi_block, false);
1343
1344 for (int i = 0; i < block_N; ++i) {
1345 // storable element
1346 CryostatElement block;
1347 block.geo = geo_block;
1348 block.logi = logi_block;
1349
1350 double block_PHI = block_PHIs[i];
1351 double block_X0 = block_R * cos(block_PHI);
1352 double block_Y0 = block_R * sin(block_PHI);
1353 double block_dPHI = asin(block_W / block_R / 2.0);
1354
1355 block.transform = G4Translate3D(block_X0, block_Y0, block_Z0);
1356 block.transform = block.transform * G4RotateZ3D((block_PHI + block_dPHI) / Unit::rad);
1357
1358 ostringstream oss_block_num;
1359 oss_block_num << i;
1360 string phys_block_name = "phys_" + name + "-" + oss_block_num.str() + "_name";
1361 new G4PVPlacement(block.transform, block.logi, phys_block_name, &topVolume, false, 0);
1362
1363 elements[name] = block;
1364 }
1365 }
1366
1367 std::vector<std::string> SWXLayers;
1368 boost::split(SWXLayers, m_config.getParameterStr("SWXLayer"), boost::is_any_of(" "));
1369 for (const auto& name : SWXLayers) {
1370 prep = name + ".";
1371 //string type = m_config.getParameterStr(prep + "type");
1372
1373 // storable element
1374 CryostatElement layer;
1375
1376 double layer_L = m_config.getParameter(prep + "L") * unitFactor;
1377 double layer_r1 = m_config.getParameter(prep + "r1") * unitFactor;
1378 double layer_r2 = m_config.getParameter(prep + "r2") * unitFactor;
1379 double layer_t = m_config.getParameter(prep + "t") * unitFactor;
1380 double layer_Z0 = m_config.getParameter(prep + "Z0") * unitFactor;
1381 int layer_cut_N = int(m_config.getParameter(prep + "N", 0));
1382
1383 layer.transform = G4Translate3D(0.0, 0.0, layer_Z0);
1384
1385 //define geometry
1386 string geo_layer_name;
1387 if (layer_cut_N == 0) {
1388 geo_layer_name = "geo_" + name + "_name";
1389 } else {
1390 geo_layer_name = "geo_" + name + "_x_name";
1391 }
1392
1393 G4VSolid* geo_layer = new G4Cons(geo_layer_name, layer_r1, layer_r1 + layer_t, layer_r2, layer_r2 + layer_t, layer_L / 2.0, 0.0,
1394 2.0 * M_PI);
1395
1396 for (int i = 0; i < layer_cut_N; ++i) {
1397 ostringstream oss_block_num;
1398 oss_block_num << i;
1399
1400 //string cut_type = m_config.getParameterStr(prep + "cutType" + oss_block_num.str());
1401 double cut_type = m_config.getParameter(prep + "cutType" + oss_block_num.str());
1402 if (i == layer_cut_N - 1) {
1403 geo_layer_name = "geo_" + name + "_name";
1404 } else {
1405 geo_layer_name = "geo_" + name + "_x" + oss_block_num.str() + "_name";
1406 }
1407 string geo_cut_name = "geo_" + name + "_cut" + oss_block_num.str() + "_name";
1408
1409 G4VSolid* geo_cut;
1410
1411 if (cut_type == 0.0) {
1412 double cut_L = m_config.getParameter(prep + "cutL" + oss_block_num.str()) * unitFactor;
1413 double cut_W = m_config.getParameter(prep + "cutW" + oss_block_num.str()) * unitFactor;
1414 double cut_H = m_config.getParameter(prep + "cutH" + oss_block_num.str()) * unitFactor;
1415
1416 geo_cut = new G4Box(geo_cut_name, cut_W / 2.0, cut_H / 2.0, cut_L / 2.0);
1417 } else {
1418 double cut_L = m_config.getParameter(prep + "cutL" + oss_block_num.str()) * unitFactor;
1419 double cut_R = m_config.getParameter(prep + "cutR" + oss_block_num.str()) * unitFactor;
1420
1421 geo_cut = new G4Tubs(geo_cut_name, 0.0, cut_R, cut_L / 2.0, 0.0, 2.0 * M_PI);
1422 }
1423
1424 double cut_X0 = m_config.getParameter(prep + "cutX0" + oss_block_num.str()) * unitFactor;
1425 double cut_Y0 = m_config.getParameter(prep + "cutY0" + oss_block_num.str()) * unitFactor;
1426 double cut_Z0 = m_config.getParameter(prep + "cutZ0" + oss_block_num.str()) * unitFactor;
1427 double cut_PHI = m_config.getParameter(prep + "cutPHI" + oss_block_num.str());
1428 double cut_TH = m_config.getParameter(prep + "cutTH" + oss_block_num.str());
1429
1430 G4Transform3D cut_transform = G4Translate3D(cut_X0, cut_Y0, cut_Z0);
1431 cut_transform = cut_transform * G4RotateY3D(cut_PHI / Unit::rad);
1432 cut_transform = cut_transform * G4RotateX3D(cut_TH / Unit::rad);
1433
1434 geo_layer = new G4SubtractionSolid(geo_layer_name, geo_layer, geo_cut, layer.transform.inverse()*cut_transform);
1435 //geo_layer = new G4UnionSolid(geo_layer_name, geo_layer, geo_cut, layer.transform.inverse()*cut_transform);
1436 }
1437
1438 layer.geo = geo_layer;
1439
1440 // logical volume
1441 string strMat_layer = m_config.getParameterStr(prep + "Material");
1442 G4Material* mat_layer = Materials::get(strMat_layer);
1443
1444 string logi_layer_name = "logi_" + name + "_name";
1445 G4LogicalVolume* logi_layer = new G4LogicalVolume(layer.geo, mat_layer, logi_layer_name);
1446 layer.logi = logi_layer;
1447
1448 //put volume
1449 setColor(*logi_layer, "#B100CC");
1450 //setVisibility(*logi_layer, false);
1451
1452 string phys_layer_name = "phys_" + name + "_name";
1453 new G4PVPlacement(layer.transform, layer.logi, phys_layer_name, &topVolume, false, 0);
1454
1455 // cppcheck-suppress unreadVariable
1456 elements[name] = layer;
1457 }
1458 }
1459
1460 //---------------------------
1461 // for dose simulation
1462 //---------------------------
1463
1464 /*
1465 logi_A1spc1 ->SetSensitiveDetector(new BkgSensitiveDetector("IR", 101));
1466 logi_A1spc2 ->SetSensitiveDetector(new BkgSensitiveDetector("IR", 102));
1467 logi_A2wal1 ->SetSensitiveDetector(new BkgSensitiveDetector("IR", 103));
1468 logi_A3wal1 ->SetSensitiveDetector(new BkgSensitiveDetector("IR", 104));
1469 logi_A3wal2 ->SetSensitiveDetector(new BkgSensitiveDetector("IR", 105));
1470 logi_A4mag1 ->SetSensitiveDetector(new BkgSensitiveDetector("IR", 106));
1471 logi_A4mag2p1 ->SetSensitiveDetector(new BkgSensitiveDetector("IR", 107));
1472 logi_A4mag2p2 ->SetSensitiveDetector(new BkgSensitiveDetector("IR", 108));
1473 logi_A4mag2p3 ->SetSensitiveDetector(new BkgSensitiveDetector("IR", 109));
1474 logi_A4mag2p4 ->SetSensitiveDetector(new BkgSensitiveDetector("IR", 110));
1475 logi_A4mag3p1 ->SetSensitiveDetector(new BkgSensitiveDetector("IR", 111));
1476 logi_A4mag3p2 ->SetSensitiveDetector(new BkgSensitiveDetector("IR", 112));
1477 logi_A4mag4p1 ->SetSensitiveDetector(new BkgSensitiveDetector("IR", 113));
1478 logi_A4mag4p2 ->SetSensitiveDetector(new BkgSensitiveDetector("IR", 114));
1479 logi_A4mag4p3 ->SetSensitiveDetector(new BkgSensitiveDetector("IR", 115));
1480 logi_A4mag4p4 ->SetSensitiveDetector(new BkgSensitiveDetector("IR", 116));
1481 logi_A4mag4p5 ->SetSensitiveDetector(new BkgSensitiveDetector("IR", 117));
1482 logi_A4mag4p6 ->SetSensitiveDetector(new BkgSensitiveDetector("IR", 118));
1483 logi_A4mag4p7 ->SetSensitiveDetector(new BkgSensitiveDetector("IR", 119));
1484 logi_A4mag4p8 ->SetSensitiveDetector(new BkgSensitiveDetector("IR", 120));
1485 logi_A4mag4p9 ->SetSensitiveDetector(new BkgSensitiveDetector("IR", 121));
1486 logi_B1spc1 ->SetSensitiveDetector(new BkgSensitiveDetector("IR", 122));
1487 logi_B1spc2 ->SetSensitiveDetector(new BkgSensitiveDetector("IR", 123));
1488 logi_B2wal1 ->SetSensitiveDetector(new BkgSensitiveDetector("IR", 124));
1489 logi_B3wal1 ->SetSensitiveDetector(new BkgSensitiveDetector("IR", 125));
1490 logi_B3wal2 ->SetSensitiveDetector(new BkgSensitiveDetector("IR", 126));
1491 logi_B4mag1p1 ->SetSensitiveDetector(new BkgSensitiveDetector("IR", 127));
1492 logi_B4mag1p2 ->SetSensitiveDetector(new BkgSensitiveDetector("IR", 128));
1493 logi_B4mag1p3 ->SetSensitiveDetector(new BkgSensitiveDetector("IR", 129));
1494 logi_B4mag2 ->SetSensitiveDetector(new BkgSensitiveDetector("IR", 130));
1495 logi_B4mag3p1 ->SetSensitiveDetector(new BkgSensitiveDetector("IR", 131));
1496 logi_B4mag3p2 ->SetSensitiveDetector(new BkgSensitiveDetector("IR", 132));
1497 logi_B4mag3p3 ->SetSensitiveDetector(new BkgSensitiveDetector("IR", 133));
1498 logi_B4mag3p4 ->SetSensitiveDetector(new BkgSensitiveDetector("IR", 134));
1499 logi_B4mag3p5 ->SetSensitiveDetector(new BkgSensitiveDetector("IR", 135));
1500 logi_B4mag3p6 ->SetSensitiveDetector(new BkgSensitiveDetector("IR", 136));
1501 logi_B4mag4p1 ->SetSensitiveDetector(new BkgSensitiveDetector("IR", 137));
1502 logi_B4mag4p7 ->SetSensitiveDetector(new BkgSensitiveDetector("IR", 138));
1503 logi_B4mag4p8 ->SetSensitiveDetector(new BkgSensitiveDetector("IR", 139));
1504 logi_B4mag4p9 ->SetSensitiveDetector(new BkgSensitiveDetector("IR", 140));
1505 logi_C1wal1 ->SetSensitiveDetector(new BkgSensitiveDetector("IR", 141));
1506 logi_C1wal2 ->SetSensitiveDetector(new BkgSensitiveDetector("IR", 142));
1507 logi_C2spc1 ->SetSensitiveDetector(new BkgSensitiveDetector("IR", 143));
1508 logi_C2spc2 ->SetSensitiveDetector(new BkgSensitiveDetector("IR", 144));
1509 logi_C2spc3 ->SetSensitiveDetector(new BkgSensitiveDetector("IR", 145));
1510 logi_C3wal1 ->SetSensitiveDetector(new BkgSensitiveDetector("IR", 146));
1511 logi_C3wal2 ->SetSensitiveDetector(new BkgSensitiveDetector("IR", 147));
1512 logi_C4spc1 ->SetSensitiveDetector(new BkgSensitiveDetector("IR", 148));
1513 logi_C4spc2 ->SetSensitiveDetector(new BkgSensitiveDetector("IR", 149));
1514 logi_C5wal1 ->SetSensitiveDetector(new BkgSensitiveDetector("IR", 150));
1515 logi_C5wal2 ->SetSensitiveDetector(new BkgSensitiveDetector("IR", 151));
1516 logi_C5wal3 ->SetSensitiveDetector(new BkgSensitiveDetector("IR", 152));
1517 logi_C6spc1 ->SetSensitiveDetector(new BkgSensitiveDetector("IR", 153));
1518 logi_C6spc2 ->SetSensitiveDetector(new BkgSensitiveDetector("IR", 154));
1519 logi_C7wal1 ->SetSensitiveDetector(new BkgSensitiveDetector("IR", 155));
1520 logi_C7lyr1 ->SetSensitiveDetector(new BkgSensitiveDetector("IR", 156));
1521 logi_C7lyr2 ->SetSensitiveDetector(new BkgSensitiveDetector("IR", 157));
1522 logi_C7lyr3 ->SetSensitiveDetector(new BkgSensitiveDetector("IR", 158));
1523 logi_C7lyr4 ->SetSensitiveDetector(new BkgSensitiveDetector("IR", 159));
1524 logi_C7lyr5 ->SetSensitiveDetector(new BkgSensitiveDetector("IR", 160));
1525 logi_D1spc1 ->SetSensitiveDetector(new BkgSensitiveDetector("IR", 161));
1526 logi_D2wal1 ->SetSensitiveDetector(new BkgSensitiveDetector("IR", 162));
1527 logi_D3wal1 ->SetSensitiveDetector(new BkgSensitiveDetector("IR", 163));
1528 logi_D3wal2 ->SetSensitiveDetector(new BkgSensitiveDetector("IR", 164));
1529 logi_D4mag1 ->SetSensitiveDetector(new BkgSensitiveDetector("IR", 165));
1530 logi_D4mag2p1 ->SetSensitiveDetector(new BkgSensitiveDetector("IR", 166));
1531 logi_D4mag2p2 ->SetSensitiveDetector(new BkgSensitiveDetector("IR", 167));
1532 logi_D4mag2p3 ->SetSensitiveDetector(new BkgSensitiveDetector("IR", 168));
1533 logi_D4mag2p4 ->SetSensitiveDetector(new BkgSensitiveDetector("IR", 169));
1534 logi_D4mag3p1 ->SetSensitiveDetector(new BkgSensitiveDetector("IR", 170));
1535 logi_D4mag3p2 ->SetSensitiveDetector(new BkgSensitiveDetector("IR", 171));
1536 logi_D4mag3p3 ->SetSensitiveDetector(new BkgSensitiveDetector("IR", 172));
1537 logi_D4mag3p4 ->SetSensitiveDetector(new BkgSensitiveDetector("IR", 173));
1538 logi_D4mag3p5 ->SetSensitiveDetector(new BkgSensitiveDetector("IR", 174));
1539 logi_D4mag3p6 ->SetSensitiveDetector(new BkgSensitiveDetector("IR", 175));
1540 logi_E1spc1 ->SetSensitiveDetector(new BkgSensitiveDetector("IR", 176));
1541 logi_E2wal1 ->SetSensitiveDetector(new BkgSensitiveDetector("IR", 177));
1542 logi_E3wal1 ->SetSensitiveDetector(new BkgSensitiveDetector("IR", 178));
1543 logi_E4mag1p1 ->SetSensitiveDetector(new BkgSensitiveDetector("IR", 179));
1544 logi_E4mag1p2 ->SetSensitiveDetector(new BkgSensitiveDetector("IR", 180));
1545 logi_E4mag1p3 ->SetSensitiveDetector(new BkgSensitiveDetector("IR", 181));
1546 logi_E4mag2 ->SetSensitiveDetector(new BkgSensitiveDetector("IR", 182));
1547 logi_E4mag3p1 ->SetSensitiveDetector(new BkgSensitiveDetector("IR", 183));
1548 logi_E4mag3p2 ->SetSensitiveDetector(new BkgSensitiveDetector("IR", 184));
1549 logi_E4mag3p3 ->SetSensitiveDetector(new BkgSensitiveDetector("IR", 185));
1550 logi_E4mag3p4 ->SetSensitiveDetector(new BkgSensitiveDetector("IR", 186));
1551 logi_E4mag3p5 ->SetSensitiveDetector(new BkgSensitiveDetector("IR", 187));
1552 logi_F1wal1 ->SetSensitiveDetector(new BkgSensitiveDetector("IR", 188));
1553 logi_F1wal2 ->SetSensitiveDetector(new BkgSensitiveDetector("IR", 189));
1554 logi_F2spc1 ->SetSensitiveDetector(new BkgSensitiveDetector("IR", 190));
1555 logi_F2spc2 ->SetSensitiveDetector(new BkgSensitiveDetector("IR", 191));
1556 logi_F2spc3 ->SetSensitiveDetector(new BkgSensitiveDetector("IR", 192));
1557 logi_F3wal1 ->SetSensitiveDetector(new BkgSensitiveDetector("IR", 193));
1558 logi_F3wal2 ->SetSensitiveDetector(new BkgSensitiveDetector("IR", 194));
1559 logi_F3wal3 ->SetSensitiveDetector(new BkgSensitiveDetector("IR", 195));
1560 logi_F4spc1 ->SetSensitiveDetector(new BkgSensitiveDetector("IR", 196));
1561 logi_F5wal1 ->SetSensitiveDetector(new BkgSensitiveDetector("IR", 197));
1562 logi_F6spc1 ->SetSensitiveDetector(new BkgSensitiveDetector("IR", 198));
1563 logi_F7lyr1 ->SetSensitiveDetector(new BkgSensitiveDetector("IR", 199));
1564 logi_F7lyr2 ->SetSensitiveDetector(new BkgSensitiveDetector("IR", 200));
1565 logi_F7lyr3 ->SetSensitiveDetector(new BkgSensitiveDetector("IR", 201));
1566 logi_F7lyr4 ->SetSensitiveDetector(new BkgSensitiveDetector("IR", 202));
1567 logi_F7lyr5 ->SetSensitiveDetector(new BkgSensitiveDetector("IR", 203));
1568 */
1569 }
1570 }
1572}
R
double R
typedef autogenerated by FFTW
Definition DiscreteCosineTransform_31points.cc:35
Belle2::Unit::mm
static const double mm
[millimeters]
Definition Unit.h:70
Belle2::Unit::rad
static const double rad
Standard of [angle].
Definition Unit.h:50
Belle2::Unit::cm
static const double cm
Standard units with the value = 1.
Definition Unit.h:47
Belle2::geometry::Materials::get
static G4Material * get(const std::string &name)
Find given material.
Definition Materials.h:63
Belle2::ir::GeoCryostatCreator::GeoCryostatCreator
GeoCryostatCreator()
Constructor of the GeoCryostatCreator class.
Definition GeoCryostatCreator.cc:61
Belle2::ir::GeoCryostatCreator::m_config
CryostatGeo m_config
geometry parameters object
Definition GeoCryostatCreator.h:118
Belle2::ir::GeoCryostatCreator::createGeometry
void createGeometry(G4LogicalVolume &topVolume, geometry::GeometryTypes type)
Create detector geometry.
Definition GeoCryostatCreator.cc:71
Belle2::ir::GeoCryostatCreator::~GeoCryostatCreator
virtual ~GeoCryostatCreator() override
The destructor of the GeoCryostatCreator class.
Definition GeoCryostatCreator.cc:66
Belle2::ir::GeoCryostatCreator::m_sensitive
SensitiveDetector * m_sensitive
Sensitive detector.
Definition GeoCryostatCreator.h:117
Belle2::ir::SensitiveDetector
The IR Sensitive Detector class.
Definition SensitiveDetector.h:41
Belle2::sqrt
double sqrt(double a)
sqrt for double
Definition beamHelpers.h:28
Belle2::intersect
int intersect(const TRGCDCLpar &lp1, const TRGCDCLpar &lp2, CLHEP::HepVector &v1, CLHEP::HepVector &v2)
intersection
Definition Lpar.cc:249
Belle2::geometry
Common code concerning the geometry representation of the detector.
Definition CreatorBase.h:25
Belle2::geometry::setVisibility
void setVisibility(G4LogicalVolume &volume, bool visible)
Helper function to quickly set the visibility of a given volume.
Definition utilities.cc:108
Belle2::geometry::setColor
void setColor(G4LogicalVolume &volume, const std::string &color)
Set the color of a logical volume.
Definition utilities.cc:100
Belle2::geometry::GeometryTypes
GeometryTypes
Flag indicating the type of geometry to be used.
Definition GeometryManager.h:36
Belle2
Abstract base class for different kinds of events.
Definition MillepedeAlgorithm.h:17
std
STL namespace.
Belle2::ir::CryostatElement
The struct for CryostatElement.
Definition GeoCryostatCreator.h:31
Belle2::ir::CryostatElement::logi
G4LogicalVolume * logi
Logical volume.
Definition GeoCryostatCreator.h:37
Belle2::ir::CryostatElement::geo
G4VSolid * geo
Solid volume.
Definition GeoCryostatCreator.h:35
Belle2::ir::CryostatElement::transform
G4Transform3D transform
Transformation.
Definition GeoCryostatCreator.h:33