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