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//Shapes
24#include <G4Box.hh>
25#include <G4Trd.hh>
26#include <G4Tubs.hh>
27#include <G4Polycone.hh>
28#include <G4EllipticalTube.hh>
29#include <G4UnionSolid.hh>
30#include <G4IntersectionSolid.hh>
31#include <G4SubtractionSolid.hh>
32#include <G4UserLimits.hh>
33
34using namespace std;
35
36namespace Belle2 {
43 using namespace geometry;
44
45 namespace ir {
46
47 //-----------------------------------------------------------------
48 // Register the Creator
49 //-----------------------------------------------------------------
50
51 geometry::CreatorFactory<GeoCryostatCreator> GeoCryostatFactory("CryostatCreator");
52
53 //-----------------------------------------------------------------
54 // Implementation
55 //-----------------------------------------------------------------
56
57 GeoCryostatCreator::GeoCryostatCreator()
58 {
59 m_sensitive = new SensitiveDetector();
60 }
61
62 GeoCryostatCreator::~GeoCryostatCreator()
63 {
64 delete m_sensitive;
65 }
66
67 void GeoCryostatCreator::createGeometry(G4LogicalVolume& topVolume, GeometryTypes)
68 {
69
70 //###### R side index ######
71 //
72 // +- A1spc1+A1spc2
73 // +- A2wal1
74 // +- A3wal1
75 // +- A3wal2
76 // +- A4mag1
77 // +- A4mag2
78 // +- A4mag3
79 // +- A4mag4
80 //
81 // +- B1spc1+B1spc2
82 // +- B2wal1
83 // +- B3wal1
84 // +- B3wal2
85 // +- B4mag1
86 // +- B4mag2
87 // +- B4mag3
88 // +- B4mag4
89 //
90 // +- C1wal1
91 // +- C2spc1
92 // +- C3wal1
93 // +- C4spc1
94 // +- C5wal1
95 // +- C6spc1
96 // +- C7lyr1
97 // +- C7lyr2
98 // +- C7lyr3
99 // +- C7lyr4
100 // +- C7lyr5
101 // +- C2spc2
102 // +- C3wal2
103 // +- C4spc2
104 // +- C5wal2
105 // +- C6spc2
106 // +- C7wal1
107 // +- C5wal3
108 // +- C5wal4
109 // +- C3wal3
110 // +- C2spc3
111 // +- C1wal2
112 //
113 //###### L side index ######
114 //
115 // +- D1spc1
116 // +- D2wal1
117 // +- D3wal1
118 // +- D3wal2
119 // +- D4mag1
120 // +- D4mag2
121 // +- D4mag3
122 //
123 // +- E1spc1
124 // +- E2wal1
125 // +- E3wal1
126 // +- E4mag1
127 // +- E4mag2
128 // +- E4mag3
129 //
130 // +- F1wal1
131 // +- F2spc1
132 // +- F3wal1
133 // +- F4spc1
134 // +- F5wal1
135 // +- F6spc1
136 // +- F7lyr1
137 // +- F7lyr2
138 // +- F7lyr3
139 // +- F7lyr4
140 // +- F7lyr5
141 // +- F3wal2
142 // +- F3wal3
143 // +- F3wal4
144 // +- F1wal2
145
146 double stepMax = 5.0 * Unit::mm;
147 int flag_limitStep = int(m_config.getParameter("LimitStepLength"));
148
149 const double unitFactor = Unit::cm / Unit::mm;
150
151 double crossingAngleHER = m_config.getParameter("CrossingAngle.HER", 0.0415);
152 double crossingAngleLER = m_config.getParameter("CrossingAngle.LER", -0.0415);
153
154 G4Transform3D transform_HER = G4Translate3D(0., 0., 0.);
155 transform_HER = transform_HER * G4RotateY3D(crossingAngleHER);
156
157 G4Transform3D transform_LER = G4Translate3D(0., 0., 0.);
158 transform_LER = transform_LER * G4RotateY3D(crossingAngleLER);
159
160 map<string, CryostatElement> elements;
161
162 //--------------
163 //- Bounding shapes
164
165 // right bounding shape 1
166 CryostatElement tubeR;
167 std::string prep = "TubeR.";
168
169 const int TubeR_N = int(m_config.getParameter(prep + "N"));
170
171 std::vector<double> TubeR_Z(TubeR_N);
172 std::vector<double> TubeR_R(TubeR_N);
173 std::vector<double> TubeR_r(TubeR_N);
174
175 for (int i = 0; i < TubeR_N; ++i) {
176 ostringstream ossZID;
177 ossZID << "Z" << i;
178
179 ostringstream ossRID;
180 ossRID << "R" << i;
181
182 ostringstream ossrID;
183 ossrID << "r" << i;
184
185 TubeR_Z[i] = m_config.getParameter(prep + ossZID.str()) * unitFactor;
186 TubeR_R[i] = m_config.getParameter(prep + ossRID.str()) * unitFactor;
187 TubeR_r[i] = m_config.getParameter(prep + ossrID.str(), 0.0) * unitFactor;
188 }
189
190 tubeR.transform = G4Translate3D(0., 0., 0.);
191 tubeR.geo = new G4Polycone("geo_TubeR_name", 0, 2 * M_PI, TubeR_N, &(TubeR_Z[0]), &(TubeR_r[0]), &(TubeR_R[0]));
192 tubeR.logi = NULL;
193 elements["TubeR"] = tubeR;
194
195 // right bounding shape 2
196 CryostatElement tubeR2;
197 prep = "TubeR2.";
198 const int TubeR2_N = int(m_config.getParameter(prep + "N"));
199
200 std::vector<double> TubeR2_Z(TubeR2_N);
201 std::vector<double> TubeR2_R(TubeR2_N);
202 std::vector<double> TubeR2_r(TubeR2_N);
203
204 for (int i = 0; i < TubeR2_N; ++i) {
205 ostringstream ossZID;
206 ossZID << "Z" << i;
207
208 ostringstream ossRID;
209 ossRID << "R" << i;
210
211 ostringstream ossrID;
212 ossrID << "r" << i;
213
214 TubeR2_Z[i] = m_config.getParameter(prep + ossZID.str()) * unitFactor;
215 TubeR2_R[i] = m_config.getParameter(prep + ossRID.str()) * unitFactor;
216 TubeR2_r[i] = m_config.getParameter(prep + ossrID.str(), 0.0) * unitFactor;
217 }
218
219 tubeR2.transform = G4Translate3D(0., 0., 0.);
220 tubeR2.geo = new G4Polycone("geo_TubeR2_name", 0, 2 * M_PI, TubeR2_N, &(TubeR2_Z[0]), &(TubeR2_r[0]), &(TubeR2_R[0]));
221 tubeR2.logi = NULL;
222 elements["TubeR2"] = tubeR2;
223
224 // left bounding shape
225 CryostatElement tubeL;
226 prep = "TubeL.";
227 const int TubeL_N = int(m_config.getParameter(prep + "N"));
228
229 std::vector<double> TubeL_Z(TubeL_N);
230 std::vector<double> TubeL_R(TubeL_N);
231 std::vector<double> TubeL_r(TubeL_N);
232
233 for (int i = 0; i < TubeL_N; ++i) {
234 ostringstream ossZID;
235 ossZID << "Z" << i;
236
237 ostringstream ossRID;
238 ossRID << "R" << i;
239
240 ostringstream ossrID;
241 ossrID << "r" << i;
242
243 TubeL_Z[i] = m_config.getParameter(prep + ossZID.str()) * unitFactor;
244 TubeL_R[i] = m_config.getParameter(prep + ossRID.str()) * unitFactor;
245 TubeL_r[i] = m_config.getParameter(prep + ossrID.str()) * unitFactor;
246 }
247
248 tubeL.transform = G4Translate3D(0., 0., 0.);
249 tubeL.geo = new G4Polycone("geo_TubeL_name", 0, 2 * M_PI, TubeL_N, &(TubeL_Z[0]), &(TubeL_r[0]), &(TubeL_R[0]));
250 tubeL.logi = NULL;
251 elements["TubeL"] = tubeL;
252
253 //--------------
254 // Special cases with complex geometry
255
256 //--------------
257 //- A1spc1 and B1spc1
258
259 // space containing all structures around right HER beam pipe, part 1
260 CryostatElement A1spc1;
261 prep = "A1spc1.";
262 const int A1spc1_N = int(m_config.getParameter(prep + "N"));
263
264 std::vector<double> A1spc1_Z(A1spc1_N);
265 std::vector<double> A1spc1_r(A1spc1_N);
266 std::vector<double> A1spc1_R(A1spc1_N);
267
268 for (int i = 0; i < A1spc1_N; ++i) {
269 ostringstream ossZID;
270 ossZID << "Z" << i;
271
272 ostringstream ossRID;
273 ossRID << "R" << i;
274
275 ostringstream ossrID;
276 ossrID << "r" << i;
277
278 A1spc1_Z[i] = m_config.getParameter(prep + ossZID.str()) * unitFactor;
279 A1spc1_R[i] = m_config.getParameter(prep + ossRID.str()) * unitFactor;
280 A1spc1_r[i] = m_config.getParameter(prep + ossrID.str(), 0.0) * unitFactor;
281 }
282
283 A1spc1.transform = transform_HER;
284 G4Polycone* geo_A1spc1xx = new G4Polycone("geo_A1spc1xx_name", 0, 2 * M_PI, A1spc1_N, &(A1spc1_Z[0]), &(A1spc1_r[0]),
285 &(A1spc1_R[0]));
286
287 // space containing all structures around right HER beam pipe, part 2
288 CryostatElement A1spc2;
289 prep = "A1spc2.";
290 const int A1spc2_N = int(m_config.getParameter(prep + "N"));
291
292 std::vector<double> A1spc2_Z(A1spc2_N);
293 std::vector<double> A1spc2_R(A1spc2_N);
294 std::vector<double> A1spc2_r(A1spc2_N);
295
296 for (int i = 0; i < A1spc2_N; ++i) {
297 ostringstream ossZID;
298 ossZID << "Z" << i;
299
300 ostringstream ossRID;
301 ossRID << "R" << i;
302
303 ostringstream ossrID;
304 ossrID << "r" << i;
305
306 A1spc2_Z[i] = m_config.getParameter(prep + ossZID.str()) * unitFactor;
307 A1spc2_R[i] = m_config.getParameter(prep + ossRID.str()) * unitFactor;
308 A1spc2_r[i] = m_config.getParameter(prep + ossrID.str(), 0.0) * unitFactor;
309 }
310
311 A1spc2.transform = transform_HER;
312 G4Polycone* geo_A1spc2xx = new G4Polycone("geo_A1spc2xx_name", 0, 2 * M_PI, A1spc2_N, &(A1spc2_Z[0]), &(A1spc2_r[0]),
313 &(A1spc2_R[0]));
314
315 // space containing all structures around right LER beam pipe, part 1
316 CryostatElement B1spc1;
317 prep = "B1spc1.";
318 const int B1spc1_N = int(m_config.getParameter(prep + "N"));
319
320 std::vector<double> B1spc1_Z(B1spc1_N);
321 std::vector<double> B1spc1_R(B1spc1_N);
322 std::vector<double> B1spc1_r(B1spc1_N);
323
324 for (int i = 0; i < B1spc1_N; ++i) {
325 ostringstream ossZID;
326 ossZID << "Z" << i;
327
328 ostringstream ossRID;
329 ossRID << "R" << i;
330
331 ostringstream ossrID;
332 ossrID << "r" << i;
333
334 B1spc1_Z[i] = m_config.getParameter(prep + ossZID.str()) * unitFactor;
335 B1spc1_R[i] = m_config.getParameter(prep + ossRID.str()) * unitFactor;
336 B1spc1_r[i] = m_config.getParameter(prep + ossrID.str(), 0.0) * unitFactor;
337 }
338
339 B1spc1.transform = transform_LER;
340 G4Polycone* geo_B1spc1xx = new G4Polycone("geo_B1spc1xx_name", 0, 2 * M_PI, B1spc1_N, &(B1spc1_Z[0]), &(B1spc1_r[0]),
341 &(B1spc1_R[0]));
342
343 // space containing all structures around right LER beam pipe, part 2
344 CryostatElement B1spc2;
345 prep = "B1spc2.";
346 const int B1spc2_N = int(m_config.getParameter(prep + "N"));
347
348 std::vector<double> B1spc2_Z(B1spc2_N);
349 std::vector<double> B1spc2_R(B1spc2_N);
350 std::vector<double> B1spc2_r(B1spc2_N);
351
352 for (int i = 0; i < B1spc2_N; ++i) {
353 ostringstream ossZID;
354 ossZID << "Z" << i;
355
356 ostringstream ossRID;
357 ossRID << "R" << i;
358
359 ostringstream ossrID;
360 ossrID << "r" << i;
361
362 B1spc2_Z[i] = m_config.getParameter(prep + ossZID.str()) * unitFactor;
363 B1spc2_R[i] = m_config.getParameter(prep + ossRID.str()) * unitFactor;
364 B1spc2_r[i] = m_config.getParameter(prep + ossrID.str(), 0.0) * unitFactor;
365 }
366
367 B1spc2.transform = transform_LER;
368 G4Polycone* geo_B1spc2xx = new G4Polycone("geo_B1spc2xx_name", 0, 2 * M_PI, B1spc2_N, &(B1spc2_Z[0]), &(B1spc2_r[0]),
369 &(B1spc2_R[0]));
370
371 // final cut
372 B1spc2.geo = new G4IntersectionSolid("geo_B1spc2_name", geo_B1spc2xx, elements["TubeR2"].geo, B1spc2.transform.inverse());
373 B1spc2.logi = NULL;
374
375 G4IntersectionSolid* geo_B1spc1x = new G4IntersectionSolid("geo_B1spc1x_name", geo_B1spc1xx, elements["TubeR"].geo,
376 B1spc1.transform.inverse());
377 B1spc1.geo = new G4UnionSolid("geo_B1spc1_name", geo_B1spc1x, B1spc2.geo);
378
379 A1spc2.geo = new G4IntersectionSolid("geo_A1spc2_name", geo_A1spc2xx, elements["TubeR2"].geo, A1spc2.transform.inverse());
380 A1spc2.logi = NULL;
381
382 G4IntersectionSolid* geo_A1spc1xy = new G4IntersectionSolid("geo_A1spc1xy_name", geo_A1spc1xx, elements["TubeR"].geo,
383 A1spc1.transform.inverse());
384 G4UnionSolid* geo_A1spc1x = new G4UnionSolid("geo_A1spc1x_name", geo_A1spc1xy, A1spc2.geo);
385 A1spc1.geo = new G4SubtractionSolid("geo_A1spc1_name", geo_A1spc1x, B1spc1.geo, A1spc1.transform.inverse()*B1spc1.transform);
386
387 string strMat_A1spc1 = m_config.getParameterStr("A1spc1.Material");
388 G4Material* mat_A1spc1 = Materials::get(strMat_A1spc1);
389 A1spc1.logi = new G4LogicalVolume(A1spc1.geo, mat_A1spc1, "logi_A1spc1_name");
390 if (flag_limitStep)
391 A1spc1.logi->SetUserLimits(new G4UserLimits(stepMax));
392
393 //put volume
394 setColor(*A1spc1.logi, "#CC0000");
395 //setVisibility(*A1spc1.logi, false);
396 new G4PVPlacement(A1spc1.transform, A1spc1.logi, "phys_A1spc1_name", &topVolume, false, 0);
397
398 string strMat_B1spc1 = m_config.getParameterStr("B1spc1.Material");
399 G4Material* mat_B1spc1 = Materials::get(strMat_B1spc1);
400 B1spc1.logi = new G4LogicalVolume(B1spc1.geo, mat_B1spc1, "logi_B1spc1_name");
401 if (flag_limitStep)
402 B1spc1.logi->SetUserLimits(new G4UserLimits(stepMax));
403
404 //put volume
405 setColor(*B1spc1.logi, "#CC0000");
406 //setVisibility(*B1spc1.logi, false);
407 new G4PVPlacement(B1spc1.transform, B1spc1.logi, "phys_B1spc1_name", &topVolume, false, 0);
408
409 elements["A1spc1"] = A1spc1;
410 elements["A1spc2"] = A1spc2;
411 elements["B1spc1"] = B1spc1;
412 elements["B1spc2"] = B1spc2;
413
414 //--------------
415 //- C1wal1
416
417 //get parameters from .xml file
418 CryostatElement C1wal1;
419 prep = "C1wal1.";
420 const int C1wal1_N = m_config.getParameter(prep + "N");
421
422 std::vector<double> C1wal1_Z(C1wal1_N);
423 std::vector<double> C1wal1_R(C1wal1_N);
424 std::vector<double> C1wal1_r(C1wal1_N);
425
426 for (int i = 0; i < C1wal1_N; ++i) {
427 ostringstream ossZID;
428 ossZID << "Z" << i;
429
430 ostringstream ossRID;
431 ossRID << "R" << i;
432
433 ostringstream ossrID;
434 ossrID << "r" << i;
435
436 C1wal1_Z[i] = m_config.getParameter(prep + ossZID.str()) * unitFactor;
437 C1wal1_R[i] = m_config.getParameter(prep + ossRID.str()) * unitFactor;
438 C1wal1_r[i] = m_config.getParameter(prep + ossrID.str(), 0.0) * unitFactor;
439 }
440
441 C1wal1.transform = G4Translate3D(0., 0., 0.);
442
443 //define geometry
444 G4Polycone* geo_C1wal1xxx = new G4Polycone("geo_C1wal1xxx_name", 0, 2 * M_PI, C1wal1_N, &(C1wal1_Z[0]), &(C1wal1_r[0]),
445 &(C1wal1_R[0]));
446 G4IntersectionSolid* geo_C1wal1xx = new G4IntersectionSolid("geo_C1wal1xx_name", geo_C1wal1xxx, elements["TubeR"].geo,
447 elements["TubeR"].transform);
448 G4SubtractionSolid* geo_C1wal1x = new G4SubtractionSolid("geo_C1wal1x_name", geo_C1wal1xx, elements["A1spc1"].geo,
449 elements["A1spc1"].transform);
450 C1wal1.geo = new G4SubtractionSolid("geo_C1wal1_name", geo_C1wal1x, elements["B1spc1"].geo, elements["B1spc1"].transform);
451
452 string strMat_C1wal1 = m_config.getParameterStr(prep + "Material");
453 G4Material* mat_C1wal1 = Materials::get(strMat_C1wal1);
454 C1wal1.logi = new G4LogicalVolume(C1wal1.geo, mat_C1wal1, "logi_C1wal1_name");
455
456 //put volume
457 setColor(*C1wal1.logi, "#CC0000");
458 setVisibility(*C1wal1.logi, false);
459 new G4PVPlacement(0, G4ThreeVector(0, 0, 0), C1wal1.logi, "phys_C1wal1_name", &topVolume, false, 0);
460
461 elements["C1wal1"] = C1wal1;
462
463 //--------------
464 //- D1spc1 and E1spc1
465
466 // space containing all structures around left HER beam pipe
467 CryostatElement D1spc1;
468 prep = "D1spc1.";
469 const int D1spc1_N = m_config.getParameter(prep + "N");
470
471 std::vector<double> D1spc1_Z(D1spc1_N);
472 std::vector<double> D1spc1_r(D1spc1_N);
473 std::vector<double> D1spc1_R(D1spc1_N);
474
475 for (int i = 0; i < D1spc1_N; ++i) {
476 ostringstream ossZID;
477 ossZID << "Z" << i;
478
479 ostringstream ossRID;
480 ossRID << "R" << i;
481
482 ostringstream ossrID;
483 ossrID << "r" << i;
484
485 D1spc1_Z[i] = m_config.getParameter(prep + ossZID.str()) * unitFactor;
486 D1spc1_R[i] = m_config.getParameter(prep + ossRID.str()) * unitFactor;
487 D1spc1_r[i] = m_config.getParameter(prep + ossrID.str(), 0.0) * unitFactor;
488 }
489
490 D1spc1.transform = transform_HER;
491 G4Polycone* geo_D1spc1xx = new G4Polycone("geo_D1spc1xx_name", 0, 2 * M_PI, D1spc1_N, &(D1spc1_Z[0]), &(D1spc1_r[0]),
492 &(D1spc1_R[0]));
493
494 // space containing all structures around left LER beam pipe
495 CryostatElement E1spc1;
496 prep = "E1spc1.";
497 const int E1spc1_N = int(m_config.getParameter(prep + "N"));
498
499 std::vector<double> E1spc1_Z(E1spc1_N);
500 std::vector<double> E1spc1_R(E1spc1_N);
501 std::vector<double> E1spc1_r(E1spc1_N);
502
503 for (int i = 0; i < E1spc1_N; ++i) {
504 ostringstream ossZID;
505 ossZID << "Z" << i;
506
507 ostringstream ossRID;
508 ossRID << "R" << i;
509
510 ostringstream ossrID;
511 ossrID << "r" << i;
512
513 E1spc1_Z[i] = m_config.getParameter(prep + ossZID.str()) * unitFactor;
514 E1spc1_R[i] = m_config.getParameter(prep + ossRID.str()) * unitFactor;
515 E1spc1_r[i] = m_config.getParameter(prep + ossrID.str(), 0.0) * unitFactor;
516 }
517
518 E1spc1.transform = transform_LER;
519 G4Polycone* geo_E1spc1xx = new G4Polycone("geo_E1spc1xx_name", 0, 2 * M_PI, E1spc1_N, &(E1spc1_Z[0]), &(E1spc1_r[0]),
520 &(E1spc1_R[0]));
521
522 // final cut
523 G4IntersectionSolid* geo_D1spc1x = new G4IntersectionSolid("geo_D1spc1x_name", geo_D1spc1xx, elements["TubeL"].geo,
524 D1spc1.transform.inverse());
525 E1spc1.geo = new G4IntersectionSolid("geo_E1spc1_name", geo_E1spc1xx, elements["TubeL"].geo, E1spc1.transform.inverse());
526 D1spc1.geo = new G4SubtractionSolid("geo_D1spc1_name", geo_D1spc1x, E1spc1.geo, D1spc1.transform.inverse()*E1spc1.transform);
527
528 string strMat_D1spc1 = m_config.getParameterStr("D1spc1.Material");
529 G4Material* mat_D1spc1 = Materials::get(strMat_D1spc1);
530 D1spc1.logi = new G4LogicalVolume(D1spc1.geo, mat_D1spc1, "logi_D1spc1_name");
531 if (flag_limitStep)
532 D1spc1.logi->SetUserLimits(new G4UserLimits(stepMax));
533
534 //put volume
535 setColor(*D1spc1.logi, "#CC0000");
536 //setVisibility(*D1spc1.logi, false);
537 new G4PVPlacement(D1spc1.transform, D1spc1.logi, "phys_D1spc1_name", &topVolume, false, 0);
538
539 string strMat_E1spc1 = m_config.getParameterStr(prep + "Material");
540 G4Material* mat_E1spc1 = Materials::get(strMat_E1spc1);
541 E1spc1.logi = new G4LogicalVolume(E1spc1.geo, mat_E1spc1, "logi_E1spc1_name");
542 if (flag_limitStep)
543 E1spc1.logi->SetUserLimits(new G4UserLimits(stepMax));
544
545 //put volume
546 setColor(*E1spc1.logi, "#CC0000");
547 //setVisibility(*E1spc1.logi, false);
548 new G4PVPlacement(E1spc1.transform, E1spc1.logi, "phys_E1spc1_name", &topVolume, false, 0);
549
550 elements["E1spc1"] = E1spc1;
551 elements["D1spc1"] = D1spc1;
552
553
554 //--------------
555 //- F1wal1
556
557 //get parameters from .xml file
558 CryostatElement F1wal1;
559 prep = "F1wal1.";
560 const int F1wal1_N = int(m_config.getParameter(prep + "N"));
561
562 std::vector<double> F1wal1_Z(F1wal1_N);
563 std::vector<double> F1wal1_R(F1wal1_N);
564 std::vector<double> F1wal1_r(F1wal1_N);
565
566 for (int i = 0; i < F1wal1_N; ++i) {
567 ostringstream ossZID;
568 ossZID << "Z" << i;
569
570 ostringstream ossRID;
571 ossRID << "R" << i;
572
573 ostringstream ossrID;
574 ossrID << "r" << i;
575
576 F1wal1_Z[i] = m_config.getParameter(prep + ossZID.str()) * unitFactor;
577 F1wal1_R[i] = m_config.getParameter(prep + ossRID.str()) * unitFactor;
578 F1wal1_r[i] = m_config.getParameter(prep + ossrID.str(), 0.0) * unitFactor;
579 }
580
581 F1wal1.transform = G4Translate3D(0., 0., 0.);
582
583 //define geometry
584 G4Polycone* geo_F1wal1xxx = new G4Polycone("geo_F1wal1xxx_name", 0, 2 * M_PI, F1wal1_N, &(F1wal1_Z[0]), &(F1wal1_r[0]),
585 &(F1wal1_R[0]));
586 G4IntersectionSolid* geo_F1wal1xx = new G4IntersectionSolid("geo_F1wal1xx_name", geo_F1wal1xxx, elements["TubeL"].geo,
587 elements["TubeL"].transform);
588 G4SubtractionSolid* geo_F1wal1x = new G4SubtractionSolid("geo_F1wal1x_name", geo_F1wal1xx, elements["D1spc1"].geo,
589 elements["D1spc1"].transform);
590 F1wal1.geo = new G4SubtractionSolid("geo_F1wal1_name", geo_F1wal1x, elements["E1spc1"].geo, elements["E1spc1"].transform);
591
592 string strMat_F1wal1 = m_config.getParameterStr(prep + "Material");
593 G4Material* mat_F1wal1 = Materials::get(strMat_F1wal1);
594 F1wal1.logi = new G4LogicalVolume(F1wal1.geo, mat_F1wal1, "logi_F1wal1_name");
595
596 //put volume
597 setColor(*F1wal1.logi, "#CC0000");
598 setVisibility(*F1wal1.logi, false);
599 new G4PVPlacement(F1wal1.transform, F1wal1.logi, "phys_F1wal1_name", &topVolume, false, 0);
600
601 elements["F1wal1"] = F1wal1;
602
603
604 //--------------
605 //- Cryostats' supports
606
607 std::vector<std::string> supports;
608 boost::split(supports, m_config.getParameterStr("Support"), boost::is_any_of(" "));
609 for (const auto& name : supports) {
610 // storable element
611 CryostatElement sup;
612 prep = name + ".";
613
614 double box_W = m_config.getParameter(prep + "W") * unitFactor;
615 double box_H = m_config.getParameter(prep + "H") * unitFactor;
616 double box_L = m_config.getParameter(prep + "L") * unitFactor;
617 double box_X0 = m_config.getParameter(prep + "X0") * unitFactor;
618 double box_Y0 = m_config.getParameter(prep + "Y0") * unitFactor;
619 double box_Z0 = m_config.getParameter(prep + "Z0") * unitFactor;
620
621 double trd_W1 = m_config.getParameter(prep + "trdW1") * unitFactor;
622 double trd_W2 = m_config.getParameter(prep + "trdW2") * unitFactor;
623 double trd_L = m_config.getParameter(prep + "trdL") * unitFactor;
624 double trd_H = m_config.getParameter(prep + "trdH") * unitFactor;
625 double trd_X0 = m_config.getParameter(prep + "trdX0") * unitFactor;
626 double trd_Y0 = m_config.getParameter(prep + "trdY0") * unitFactor;
627 double trd_Z0 = m_config.getParameter(prep + "trdZ0") * unitFactor;
628
629 double sup_PHI = m_config.getParameter(prep + "PHI");
630
631 int sup_cut_N = int(m_config.getParameter(prep + "N", 0));
632
633 // transformations
634 G4Transform3D transform_box = G4Translate3D(box_X0, box_Y0, box_Z0);
635 transform_box = transform_box * G4RotateY3D(sup_PHI / Unit::rad);
636
637 G4Transform3D transform_trd = G4Translate3D(trd_X0, trd_Y0, trd_Z0);
638 transform_trd = transform_trd * G4RotateY3D(sup_PHI / Unit::rad) * G4RotateX3D(M_PI / 2.0 / Unit::rad);
639
640 //define geometry
641 string geo_box_name = "geo_" + name + "_box_name";
642 string geo_trd_name = "geo_" + name + "_trd_name";
643
644 string geo_sup_name;
645 if (sup_cut_N == 0) {
646 geo_sup_name = "geo_" + name + "_name";
647 } else {
648 geo_sup_name = "geo_" + name + "_x_name";
649 }
650
651 G4Box* geo_box = new G4Box(geo_box_name, box_W / 2.0, box_H / 2.0, box_L / 2.0);
652 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);
653
654 G4VSolid* geo_sup = new G4UnionSolid(geo_sup_name, geo_box, geo_trd, transform_box.inverse() * transform_trd);
655
656 // cuts
657 for (int i = 0; i < sup_cut_N; ++i) {
658 ostringstream oss_block_num;
659 oss_block_num << i;
660
661 double cut_type = m_config.getParameter(prep + "cutType" + oss_block_num.str());
662 string geo_supx_name;
663 if (i == sup_cut_N - 1) {
664 geo_supx_name = "geo_" + name + "_name";
665 } else {
666 geo_sup_name = "geo_" + name + "_x" + oss_block_num.str() + "_name";
667 }
668 string geo_cut_name = "geo_" + name + "_cut" + oss_block_num.str() + "_name";
669
670 G4VSolid* geo_cut;
671 //if(cut_type == "Box")
672 if (cut_type == 0.0) {
673 double cut_L = m_config.getParameter(prep + "cutL" + oss_block_num.str()) * unitFactor;
674 double cut_W = m_config.getParameter(prep + "cutW" + oss_block_num.str()) * unitFactor;
675 double cut_H = m_config.getParameter(prep + "cutH" + oss_block_num.str()) * unitFactor;
676
677 geo_cut = new G4Box(geo_cut_name, cut_W / 2.0, cut_H / 2.0, cut_L / 2.0);
678 // else if(cut_type == "Tubs")
679 } else { // if (cut_type != 0.0) {
680 double cut_L = m_config.getParameter(prep + "cutL" + oss_block_num.str()) * unitFactor;
681 double cut_R = m_config.getParameter(prep + "cutR" + oss_block_num.str()) * unitFactor;
682
683 geo_cut = new G4Tubs(geo_cut_name, 0.0, cut_R, cut_L / 2.0, 0.0, 2.0 * M_PI);
684 }
685 //} else
686 // continue;
687
688 double cut_X0 = m_config.getParameter(prep + "cutDX" + oss_block_num.str()) * unitFactor;
689 double cut_Y0 = m_config.getParameter(prep + "cutDY" + oss_block_num.str()) * unitFactor;
690 double cut_Z0 = m_config.getParameter(prep + "cutDZ" + oss_block_num.str()) * unitFactor;
691 double cut_PHI = m_config.getParameter(prep + "cutPHI" + oss_block_num.str(), 0.0);
692 double cut_TH = m_config.getParameter(prep + "cutTH" + oss_block_num.str(), 0.0);
693
694 G4Transform3D cut_transform = G4Translate3D(cut_X0, cut_Y0, cut_Z0);
695 cut_transform = cut_transform * G4RotateX3D(cut_PHI / Unit::rad);
696 cut_transform = cut_transform * G4RotateZ3D(cut_TH / Unit::rad);
697
698 geo_sup = new G4SubtractionSolid(geo_sup_name, geo_sup, geo_cut, cut_transform);
699 }
700
701 sup.geo = geo_sup;
702 sup.transform = transform_box;
703
704 string strMat_sup = m_config.getParameterStr(prep + "Material");
705 G4Material* mat_sup = Materials::get(strMat_sup);
706
707 string logi_sup_name = "logi_" + name + "_name";
708 G4LogicalVolume* logi_sup = new G4LogicalVolume(sup.geo, mat_sup, logi_sup_name);
709
710 sup.logi = logi_sup;
711
712 //put volume
713 setColor(*logi_sup, "#0000CC");
714 //setVisibility(*logi_sup, false);
715 string phys_sup_name = "phys_" + name + "_name";
716 new G4PVPlacement(sup.transform, sup.logi, phys_sup_name, &topVolume, false, 0);
717
718 elements[name] = sup;
719 }
720
721
722 //--------------
723 //- Rest of elements with typical geometry
724
725 std::vector<std::string> straightSections;
726 boost::split(straightSections, m_config.getParameterStr("Straight"), boost::is_any_of(" "));
727 for (const auto& name : straightSections) {
728 prep = name + ".";
729
730 CryostatElement polycone;
731
732 int N = int(m_config.getParameter(prep + "N"));
733
734 std::vector<double> Z(N);
735 std::vector<double> R(N);
736 std::vector<double> r(N);
737
738 for (int i = 0; i < N; ++i) {
739 ostringstream ossZID;
740 ossZID << "Z" << i;
741
742 ostringstream ossRID;
743 ossRID << "R" << i;
744
745 ostringstream ossrID;
746 ossrID << "r" << i;
747
748 Z[i] = m_config.getParameter(prep + ossZID.str()) * unitFactor;
749 R[i] = m_config.getParameter(prep + ossRID.str()) * unitFactor;
750 r[i] = m_config.getParameter(prep + ossrID.str(), 0.0) * unitFactor;
751 }
752
753 polycone.transform = G4Translate3D(0.0, 0.0, 0.0);
754
755 //define geometry
756 string motherVolume = m_config.getParameterStr(prep + "MotherVolume");
757 string subtract = m_config.getParameterStr(prep + "Subtract", "");
758 string intersect = m_config.getParameterStr(prep + "Intersect", "");
759
760 string geo_polyconexx_name = "geo_" + name + "xx_name";
761 string geo_polyconex_name = "geo_" + name + "x_name";
762 string geo_polycone_name = "geo_" + name + "_name";
763
764 G4VSolid* geo_polyconexx, *geo_polycone;
765
766 if (subtract != "" && intersect != "") {
767 geo_polyconexx = new G4Polycone(geo_polyconexx_name, 0.0, 2 * M_PI, N, &(Z[0]), &(r[0]), &(R[0]));
768 G4VSolid* geo_polyconex = new G4SubtractionSolid(geo_polyconex_name, geo_polyconexx, elements[subtract].geo,
769 elements[motherVolume].transform.inverse()*polycone.transform.inverse()*elements[subtract].transform);
770 geo_polycone = new G4IntersectionSolid(geo_polycone_name, geo_polyconex, elements[intersect].geo,
771 elements[motherVolume].transform.inverse()*polycone.transform.inverse()*elements[intersect].transform);
772 } else if (subtract != "") {
773 geo_polyconexx = new G4Polycone(geo_polyconexx_name, 0.0, 2 * M_PI, N, &(Z[0]), &(r[0]), &(R[0]));
774 geo_polycone = new G4SubtractionSolid(geo_polycone_name, geo_polyconexx, elements[subtract].geo,
775 elements[motherVolume].transform.inverse()*polycone.transform.inverse()*elements[subtract].transform);
776 } else if (intersect != "") {
777 geo_polyconexx = new G4Polycone(geo_polyconexx_name, 0.0, 2 * M_PI, N, &(Z[0]), &(r[0]), &(R[0]));
778 geo_polycone = new G4IntersectionSolid(geo_polycone_name, geo_polyconexx, elements[intersect].geo,
779 elements[motherVolume].transform.inverse()*polycone.transform.inverse()*elements[intersect].transform);
780 } else
781 geo_polycone = new G4Polycone(geo_polycone_name, 0.0, 2 * M_PI, N, &(Z[0]), &(r[0]), &(R[0]));
782
783 polycone.geo = geo_polycone;
784
785 // define logical volume
786 string strMat_polycone = m_config.getParameterStr(prep + "Material");
787 G4Material* mat_polycone = Materials::get(strMat_polycone);
788 string logi_polycone_name = "logi_" + name + "_name";
789 polycone.logi = new G4LogicalVolume(polycone.geo, mat_polycone, logi_polycone_name);
790 setColor(*polycone.logi, "#CC0000");
791 setVisibility(*polycone.logi, false);
792
793 //put volume
794 string phys_polycone_name = "phys_" + name + "_name";
795 new G4PVPlacement(polycone.transform, polycone.logi, phys_polycone_name, elements[motherVolume].logi, false, 0);
796
797 //to use it later in "intersect" and "subtract"
798 polycone.transform = polycone.transform * elements[motherVolume].transform;
799
800 elements[name] = polycone;
801 }
802
803
804 //--------------------------------------------------------------------------------------------
805 //- Shields
806
807 std::vector<std::string> shields;
808 boost::split(shields, m_config.getParameterStr("Shield"), boost::is_any_of(" "));
809 for (const auto& name : shields) {
810 prep = name + ".";
811
812 //- Shield made as box with optional subtracted box-shaped inner space (hole)
813
814 double shield_W = m_config.getParameter(prep + "W") * unitFactor;
815 double shield_H = m_config.getParameter(prep + "H") * unitFactor;
816 double shield_L = m_config.getParameter(prep + "L") * unitFactor;
817 double shield_X0 = m_config.getParameter(prep + "X0") * unitFactor;
818 double shield_Y0 = m_config.getParameter(prep + "Y0") * unitFactor;
819 double shield_Z0 = m_config.getParameter(prep + "Z0") * unitFactor;
820
821 double shield_hole_W = m_config.getParameter(prep + "holeW", 0) * unitFactor;
822 double shield_hole_H = m_config.getParameter(prep + "holeH", 0) * unitFactor;
823 double shield_hole_L = m_config.getParameter(prep + "holeL", 0) * unitFactor;
824 double shield_hole_dX = m_config.getParameter(prep + "holeDX", 0) * unitFactor;
825 double shield_hole_dY = m_config.getParameter(prep + "holeDY", 0) * unitFactor;
826 double shield_hole_dZ = m_config.getParameter(prep + "holeDZ", 0) * unitFactor;
827
828 double shield_PHI = m_config.getParameter(prep + "PHI");
829
830 // storable element
831 CryostatElement shield;
832
833 shield.transform = G4Translate3D(shield_X0, shield_Y0, shield_Z0);
834 shield.transform = shield.transform * G4RotateY3D(shield_PHI / Unit::rad);
835
836 G4Transform3D transform_shield_hole = G4Translate3D(shield_hole_dX, shield_hole_dY, shield_hole_dZ);
837
838 //define geometry
839 string geo_shieldx_name = "geo_" + name + "x_name";
840 string geo_shield_hole_name = "geo_" + name + "_hole_name";
841 string geo_shield_name = "geo_" + name + "_name";
842
843 if (shield_hole_W == 0 || shield_hole_H == 0 || shield_hole_L == 0) {
844 G4Box* geo_shield = new G4Box(geo_shield_name, shield_W / 2.0, shield_H / 2.0, shield_L / 2.0);
845
846 shield.geo = geo_shield;
847 } else {
848 G4Box* geo_shieldx = new G4Box(geo_shieldx_name, shield_W / 2.0, shield_H / 2.0, shield_L / 2.0);
849 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);
850 G4SubtractionSolid* geo_shield = new G4SubtractionSolid(geo_shield_name, geo_shieldx, geo_shield_hole,
851 transform_shield_hole);
852
853 shield.geo = geo_shield;
854 }
855
856 string strMat_shield = m_config.getParameterStr(prep + "Material");
857 G4Material* mat_shield = Materials::get(strMat_shield);
858
859 string logi_shield_name = "logi_" + name + "_name";
860 G4LogicalVolume* logi_shield = new G4LogicalVolume(shield.geo, mat_shield, logi_shield_name);
861
862 shield.logi = logi_shield;
863
864 //put volume
865 setColor(*logi_shield, "#0000CC");
866 //setVisibility(*logi_shield, false);
867 string phys_shield_name = "phys_" + name + "_name";
868 new G4PVPlacement(shield.transform, shield.logi, phys_shield_name, &topVolume, false, 0);
869
870 elements[name] = shield;
871 }
872
873
874 // RVC connection structure (simplified shape)
875 G4Tubs* geo_rvcR = new G4Tubs("geo_rvcR", 60, 60 + 60, (620 - 560) / 2., 0, 2 * M_PI);
876 G4LogicalVolume* logi_rvcR = new G4LogicalVolume(geo_rvcR, Materials::get("SUS316L"), "logi_rvcR_name");
877 new G4PVPlacement(0, G4ThreeVector(0, 0, (620 + 560) / 2.), logi_rvcR, "phys_rvcR_name", &topVolume, false, 0);
878
879 G4Tubs* geo_rvcL = new G4Tubs("geo_rvcL", 60, 60 + 60, (-560 - (-620)) / 2., 0, 2 * M_PI);
880 G4LogicalVolume* logi_rvcL = new G4LogicalVolume(geo_rvcL, Materials::get("SUS316L"), "logi_rvcL_name");
881 new G4PVPlacement(0, G4ThreeVector(0, 0, (-620 - 560) / 2.), logi_rvcL, "phys_rvcL_name", &topVolume, false, 0);
882
883 // Added 10 Nov 2018
884 // Elliptical inner surface around QC1LE
885 G4EllipticalTube* geo_elp_QC1LEx = new G4EllipticalTube("geo_elp_QC1LEx", 10.5, 13.5, (-675 - (-1225)) / 2.); //in mm
886 G4IntersectionSolid* geo_elp_QC1LE = new G4IntersectionSolid("geo_elp_QC1LE", elements["D2wal1"].geo, geo_elp_QC1LEx,
887 G4Translate3D(0, 0, (-675 - 1225) / 2.));
888 G4LogicalVolume* logi_elp_QC1LE = new G4LogicalVolume(geo_elp_QC1LE, Materials::get("Vacuum"), "logi_elp_QC1LE_name");
889 new G4PVPlacement(0, G4ThreeVector(0, 0, 0), logi_elp_QC1LE, "phys_elp_QC1LE_name", elements["D2wal1"].logi, false, 0);
890 // Elliptical inner surface around QC1LP
891 G4EllipticalTube* geo_elp_QC1LPx = new G4EllipticalTube("geo_elp_QC1LPx", 10.5, 13.5, (-675 - (-1225)) / 2.); //in mm
892 G4IntersectionSolid* geo_elp_QC1LP = new G4IntersectionSolid("geo_elp_QC1LP", elements["E2wal1"].geo, geo_elp_QC1LPx,
893 G4Translate3D(0, 0, (-675 - 1225) / 2.));
894 G4LogicalVolume* logi_elp_QC1LP = new G4LogicalVolume(geo_elp_QC1LP, Materials::get("Vacuum"), "logi_elp_QC1LP_name");
895 new G4PVPlacement(0, G4ThreeVector(0, 0, 0), logi_elp_QC1LP, "phys_elp_QC1LP_name", elements["E2wal1"].logi, false, 0);
896 // Elliptical inner surface around QC1RE
897 G4EllipticalTube* geo_elp_QC1REx = new G4EllipticalTube("geo_elp_QC1REx", 10.5, 13.5, (1225 - 675) / 2.); //in mm
898 G4IntersectionSolid* geo_elp_QC1RE = new G4IntersectionSolid("geo_elp_QC1RE", elements["A2wal1"].geo, geo_elp_QC1REx,
899 G4Translate3D(0, 0, (1225 + 675) / 2.));
900 G4LogicalVolume* logi_elp_QC1RE = new G4LogicalVolume(geo_elp_QC1RE, Materials::get("Vacuum"), "logi_elp_QC1RE_name");
901 new G4PVPlacement(0, G4ThreeVector(0, 0, 0), logi_elp_QC1RE, "phys_elp_QC1RE_name", elements["A2wal1"].logi, false, 0);
902 // Elliptical inner surface around QC1RP
903 G4EllipticalTube* geo_elp_QC1RPx = new G4EllipticalTube("geo_elp_QC1RPx", 10.5, 13.5, (1225 - 675) / 2.); //in mm
904 G4IntersectionSolid* geo_elp_QC1RP = new G4IntersectionSolid("geo_elp_QC1RP", elements["B2wal1"].geo, geo_elp_QC1RPx,
905 G4Translate3D(0, 0, (1225 + 675) / 2.));
906 G4LogicalVolume* logi_elp_QC1RP = new G4LogicalVolume(geo_elp_QC1RP, Materials::get("Vacuum"), "logi_elp_QC1RP_name");
907 new G4PVPlacement(0, G4ThreeVector(0, 0, 0), logi_elp_QC1RP, "phys_elp_QC1RP_name", elements["B2wal1"].logi, false, 0);
908
909
910 //---------------------------
911 // for dose simulation
912 //---------------------------
913
914 /*
915 logi_A1spc1 ->SetSensitiveDetector(new BkgSensitiveDetector("IR", 101));
916 logi_A1spc2 ->SetSensitiveDetector(new BkgSensitiveDetector("IR", 102));
917 logi_A2wal1 ->SetSensitiveDetector(new BkgSensitiveDetector("IR", 103));
918 logi_A3wal1 ->SetSensitiveDetector(new BkgSensitiveDetector("IR", 104));
919 logi_A3wal2 ->SetSensitiveDetector(new BkgSensitiveDetector("IR", 105));
920 logi_A4mag1 ->SetSensitiveDetector(new BkgSensitiveDetector("IR", 106));
921 logi_A4mag2p1 ->SetSensitiveDetector(new BkgSensitiveDetector("IR", 107));
922 logi_A4mag2p2 ->SetSensitiveDetector(new BkgSensitiveDetector("IR", 108));
923 logi_A4mag2p3 ->SetSensitiveDetector(new BkgSensitiveDetector("IR", 109));
924 logi_A4mag2p4 ->SetSensitiveDetector(new BkgSensitiveDetector("IR", 110));
925 logi_A4mag3p1 ->SetSensitiveDetector(new BkgSensitiveDetector("IR", 111));
926 logi_A4mag3p2 ->SetSensitiveDetector(new BkgSensitiveDetector("IR", 112));
927 logi_A4mag4p1 ->SetSensitiveDetector(new BkgSensitiveDetector("IR", 113));
928 logi_A4mag4p2 ->SetSensitiveDetector(new BkgSensitiveDetector("IR", 114));
929 logi_A4mag4p3 ->SetSensitiveDetector(new BkgSensitiveDetector("IR", 115));
930 logi_A4mag4p4 ->SetSensitiveDetector(new BkgSensitiveDetector("IR", 116));
931 logi_A4mag4p5 ->SetSensitiveDetector(new BkgSensitiveDetector("IR", 117));
932 logi_A4mag4p6 ->SetSensitiveDetector(new BkgSensitiveDetector("IR", 118));
933 logi_A4mag4p7 ->SetSensitiveDetector(new BkgSensitiveDetector("IR", 119));
934 logi_A4mag4p8 ->SetSensitiveDetector(new BkgSensitiveDetector("IR", 120));
935 logi_A4mag4p9 ->SetSensitiveDetector(new BkgSensitiveDetector("IR", 121));
936 logi_B1spc1 ->SetSensitiveDetector(new BkgSensitiveDetector("IR", 122));
937 logi_B1spc2 ->SetSensitiveDetector(new BkgSensitiveDetector("IR", 123));
938 logi_B2wal1 ->SetSensitiveDetector(new BkgSensitiveDetector("IR", 124));
939 logi_B3wal1 ->SetSensitiveDetector(new BkgSensitiveDetector("IR", 125));
940 logi_B3wal2 ->SetSensitiveDetector(new BkgSensitiveDetector("IR", 126));
941 logi_B4mag1p1 ->SetSensitiveDetector(new BkgSensitiveDetector("IR", 127));
942 logi_B4mag1p2 ->SetSensitiveDetector(new BkgSensitiveDetector("IR", 128));
943 logi_B4mag1p3 ->SetSensitiveDetector(new BkgSensitiveDetector("IR", 129));
944 logi_B4mag2 ->SetSensitiveDetector(new BkgSensitiveDetector("IR", 130));
945 logi_B4mag3p1 ->SetSensitiveDetector(new BkgSensitiveDetector("IR", 131));
946 logi_B4mag3p2 ->SetSensitiveDetector(new BkgSensitiveDetector("IR", 132));
947 logi_B4mag3p3 ->SetSensitiveDetector(new BkgSensitiveDetector("IR", 133));
948 logi_B4mag3p4 ->SetSensitiveDetector(new BkgSensitiveDetector("IR", 134));
949 logi_B4mag3p5 ->SetSensitiveDetector(new BkgSensitiveDetector("IR", 135));
950 logi_B4mag3p6 ->SetSensitiveDetector(new BkgSensitiveDetector("IR", 136));
951 logi_B4mag4p1 ->SetSensitiveDetector(new BkgSensitiveDetector("IR", 137));
952 logi_B4mag4p7 ->SetSensitiveDetector(new BkgSensitiveDetector("IR", 138));
953 logi_B4mag4p8 ->SetSensitiveDetector(new BkgSensitiveDetector("IR", 139));
954 logi_B4mag4p9 ->SetSensitiveDetector(new BkgSensitiveDetector("IR", 140));
955 logi_C1wal1 ->SetSensitiveDetector(new BkgSensitiveDetector("IR", 141));
956 logi_C1wal2 ->SetSensitiveDetector(new BkgSensitiveDetector("IR", 142));
957 logi_C2spc1 ->SetSensitiveDetector(new BkgSensitiveDetector("IR", 143));
958 logi_C2spc2 ->SetSensitiveDetector(new BkgSensitiveDetector("IR", 144));
959 logi_C2spc3 ->SetSensitiveDetector(new BkgSensitiveDetector("IR", 145));
960 logi_C3wal1 ->SetSensitiveDetector(new BkgSensitiveDetector("IR", 146));
961 logi_C3wal2 ->SetSensitiveDetector(new BkgSensitiveDetector("IR", 147));
962 logi_C4spc1 ->SetSensitiveDetector(new BkgSensitiveDetector("IR", 148));
963 logi_C4spc2 ->SetSensitiveDetector(new BkgSensitiveDetector("IR", 149));
964 logi_C5wal1 ->SetSensitiveDetector(new BkgSensitiveDetector("IR", 150));
965 logi_C5wal2 ->SetSensitiveDetector(new BkgSensitiveDetector("IR", 151));
966 logi_C5wal3 ->SetSensitiveDetector(new BkgSensitiveDetector("IR", 152));
967 logi_C6spc1 ->SetSensitiveDetector(new BkgSensitiveDetector("IR", 153));
968 logi_C6spc2 ->SetSensitiveDetector(new BkgSensitiveDetector("IR", 154));
969 logi_C7wal1 ->SetSensitiveDetector(new BkgSensitiveDetector("IR", 155));
970 logi_C7lyr1 ->SetSensitiveDetector(new BkgSensitiveDetector("IR", 156));
971 logi_C7lyr2 ->SetSensitiveDetector(new BkgSensitiveDetector("IR", 157));
972 logi_C7lyr3 ->SetSensitiveDetector(new BkgSensitiveDetector("IR", 158));
973 logi_C7lyr4 ->SetSensitiveDetector(new BkgSensitiveDetector("IR", 159));
974 logi_C7lyr5 ->SetSensitiveDetector(new BkgSensitiveDetector("IR", 160));
975 logi_D1spc1 ->SetSensitiveDetector(new BkgSensitiveDetector("IR", 161));
976 logi_D2wal1 ->SetSensitiveDetector(new BkgSensitiveDetector("IR", 162));
977 logi_D3wal1 ->SetSensitiveDetector(new BkgSensitiveDetector("IR", 163));
978 logi_D3wal2 ->SetSensitiveDetector(new BkgSensitiveDetector("IR", 164));
979 logi_D4mag1 ->SetSensitiveDetector(new BkgSensitiveDetector("IR", 165));
980 logi_D4mag2p1 ->SetSensitiveDetector(new BkgSensitiveDetector("IR", 166));
981 logi_D4mag2p2 ->SetSensitiveDetector(new BkgSensitiveDetector("IR", 167));
982 logi_D4mag2p3 ->SetSensitiveDetector(new BkgSensitiveDetector("IR", 168));
983 logi_D4mag2p4 ->SetSensitiveDetector(new BkgSensitiveDetector("IR", 169));
984 logi_D4mag3p1 ->SetSensitiveDetector(new BkgSensitiveDetector("IR", 170));
985 logi_D4mag3p2 ->SetSensitiveDetector(new BkgSensitiveDetector("IR", 171));
986 logi_D4mag3p3 ->SetSensitiveDetector(new BkgSensitiveDetector("IR", 172));
987 logi_D4mag3p4 ->SetSensitiveDetector(new BkgSensitiveDetector("IR", 173));
988 logi_D4mag3p5 ->SetSensitiveDetector(new BkgSensitiveDetector("IR", 174));
989 logi_D4mag3p6 ->SetSensitiveDetector(new BkgSensitiveDetector("IR", 175));
990 logi_E1spc1 ->SetSensitiveDetector(new BkgSensitiveDetector("IR", 176));
991 logi_E2wal1 ->SetSensitiveDetector(new BkgSensitiveDetector("IR", 177));
992 logi_E3wal1 ->SetSensitiveDetector(new BkgSensitiveDetector("IR", 178));
993 logi_E4mag1p1 ->SetSensitiveDetector(new BkgSensitiveDetector("IR", 179));
994 logi_E4mag1p2 ->SetSensitiveDetector(new BkgSensitiveDetector("IR", 180));
995 logi_E4mag1p3 ->SetSensitiveDetector(new BkgSensitiveDetector("IR", 181));
996 logi_E4mag2 ->SetSensitiveDetector(new BkgSensitiveDetector("IR", 182));
997 logi_E4mag3p1 ->SetSensitiveDetector(new BkgSensitiveDetector("IR", 183));
998 logi_E4mag3p2 ->SetSensitiveDetector(new BkgSensitiveDetector("IR", 184));
999 logi_E4mag3p3 ->SetSensitiveDetector(new BkgSensitiveDetector("IR", 185));
1000 logi_E4mag3p4 ->SetSensitiveDetector(new BkgSensitiveDetector("IR", 186));
1001 logi_E4mag3p5 ->SetSensitiveDetector(new BkgSensitiveDetector("IR", 187));
1002 logi_F1wal1 ->SetSensitiveDetector(new BkgSensitiveDetector("IR", 188));
1003 logi_F1wal2 ->SetSensitiveDetector(new BkgSensitiveDetector("IR", 189));
1004 logi_F2spc1 ->SetSensitiveDetector(new BkgSensitiveDetector("IR", 190));
1005 logi_F2spc2 ->SetSensitiveDetector(new BkgSensitiveDetector("IR", 191));
1006 logi_F2spc3 ->SetSensitiveDetector(new BkgSensitiveDetector("IR", 192));
1007 logi_F3wal1 ->SetSensitiveDetector(new BkgSensitiveDetector("IR", 193));
1008 logi_F3wal2 ->SetSensitiveDetector(new BkgSensitiveDetector("IR", 194));
1009 logi_F3wal3 ->SetSensitiveDetector(new BkgSensitiveDetector("IR", 195));
1010 logi_F4spc1 ->SetSensitiveDetector(new BkgSensitiveDetector("IR", 196));
1011 logi_F5wal1 ->SetSensitiveDetector(new BkgSensitiveDetector("IR", 197));
1012 logi_F6spc1 ->SetSensitiveDetector(new BkgSensitiveDetector("IR", 198));
1013 logi_F7lyr1 ->SetSensitiveDetector(new BkgSensitiveDetector("IR", 199));
1014 logi_F7lyr2 ->SetSensitiveDetector(new BkgSensitiveDetector("IR", 200));
1015 logi_F7lyr3 ->SetSensitiveDetector(new BkgSensitiveDetector("IR", 201));
1016 logi_F7lyr4 ->SetSensitiveDetector(new BkgSensitiveDetector("IR", 202));
1017 logi_F7lyr5 ->SetSensitiveDetector(new BkgSensitiveDetector("IR", 203));
1018 */
1019
1020 }
1021 }
1023}
R
double R
typedef autogenerated by FFTW
Definition: DiscreteCosineTransform_31points.cc:35
Belle2::IRGeoBase::getParameterStr
const std::string & getParameterStr(const std::string &name) const
Get string parameter.
Definition: IRGeoBase.h:64
Belle2::IRGeoBase::getParameter
double getParameter(const std::string &name) const
Get parameter value.
Definition: IRGeoBase.h:41
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:57
Belle2::ir::GeoCryostatCreator::~GeoCryostatCreator
virtual ~GeoCryostatCreator()
The destructor of the GeoCryostatCreator class.
Definition: GeoCryostatCreator.cc:62
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:67
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::intersect
int intersect(const TRGCDCLpar &lp1, const TRGCDCLpar &lp2, CLHEP::HepVector &v1, CLHEP::HepVector &v2)
intersection
Definition: Lpar.cc:249
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