Belle II Software development
GeoFarBeamLineCreator.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/GeoFarBeamLineCreator.h>
10
11#include <geometry/Materials.h>
12#include <geometry/CreatorFactory.h>
13#include <geometry/utilities.h>
14#include <framework/gearbox/Unit.h>
15#include <ir/simulation/SensitiveDetector.h>
16#include <simulation/background/BkgSensitiveDetector.h>
17
18#include <cmath>
19#include <boost/algorithm/string.hpp>
20
21#include <G4LogicalVolume.hh>
22#include <G4PVPlacement.hh>
23
24//Shapes
25#include <G4Box.hh>
26#include <G4Tubs.hh>
27#include <G4Torus.hh>
28#include <G4Polycone.hh>
29#include <G4Trd.hh>
30#include <G4Trap.hh>
31#include <G4IntersectionSolid.hh>
32#include <G4SubtractionSolid.hh>
33#include <G4UnionSolid.hh>
34#include <G4MultiUnion.hh>
35#include <G4UserLimits.hh>
36
37using namespace std;
38
39namespace Belle2 {
44
45
46 using namespace geometry;
47
48 namespace ir {
49
50 //-----------------------------------------------------------------
51 // Register the Creator
52 //-----------------------------------------------------------------
53
54 geometry::CreatorFactory<GeoFarBeamLineCreator> GeoFarBeamLineFactory("FarBeamLineCreator");
55
56 //-----------------------------------------------------------------
57 // Implementation
58 //-----------------------------------------------------------------
59
64
69
70 void GeoFarBeamLineCreator::createGeometry(G4LogicalVolume& topVolume, GeometryTypes)
71 {
72 // basf2 uses cm, Geant4 uses mm
73 const double unitFactor = Unit::cm / Unit::mm;
74
75 const int N = 2;
76
77 double stepMax = 5.0 * Unit::mm * unitFactor;
78 int flag_limitStep = int(m_config.getParameter("LimitStepLength"));
79
80
81 // keep created elements
82 map<string, FarBeamLineElement> elements;
83
84
85 //--------------
86 //- limits
87
88 //--------------
89 //- TubeR
90
91 FarBeamLineElement tubeR;
92
93 //get parameters from .xml file
94 std::string prep = "TubeR.";
95
96 int TubeR_N = int(m_config.getParameter(prep + "N"));
97
98 std::vector<double> TubeR_Z(TubeR_N);
99 std::vector<double> TubeR_R(TubeR_N);
100 std::vector<double> TubeR_r(TubeR_N);
101
102 for (int i = 0; i < TubeR_N; ++i) {
103 ostringstream ossZID;
104 ossZID << "Z" << i;
105
106 ostringstream ossRID;
107 ossRID << "R" << i;
108
109 ostringstream ossrID;
110 ossrID << "r" << i;
111
112 TubeR_Z[i] = m_config.getParameter(prep + ossZID.str()) * unitFactor;
113 TubeR_R[i] = m_config.getParameter(prep + ossRID.str()) * unitFactor;
114 TubeR_r[i] = m_config.getParameter(prep + ossrID.str(), 0.0) * unitFactor;
115 }
116
117 tubeR.transform = G4Translate3D(0.0, 0.0, 0.0);
118
119 //define geometry
120 tubeR.geo = new G4Polycone("geo_TubeR_name", 0.0, 2 * M_PI, TubeR_N, &(TubeR_Z[0]), &(TubeR_r[0]), &(TubeR_R[0]));
121
122 tubeR.logi = NULL;
123
124 elements["TubeR"] = tubeR;
125
126 //--------------
127 //- TubeL
128
129 FarBeamLineElement tubeL;
130
131 //get parameters from .xml file
132 prep = "TubeL.";
133
134 int TubeL_N = int(m_config.getParameter(prep + "N"));
135
136 std::vector<double> TubeL_Z(TubeL_N);
137 std::vector<double> TubeL_R(TubeL_N);
138 std::vector<double> TubeL_r(TubeL_N);
139
140 for (int i = 0; i < TubeL_N; ++i) {
141 ostringstream ossZID;
142 ossZID << "Z" << i;
143
144 ostringstream ossRID;
145 ossRID << "R" << i;
146
147 ostringstream ossrID;
148 ossrID << "r" << i;
149
150 TubeL_Z[i] = m_config.getParameter(prep + ossZID.str()) * unitFactor;
151 TubeL_R[i] = m_config.getParameter(prep + ossRID.str()) * unitFactor;
152 TubeL_r[i] = m_config.getParameter(prep + ossrID.str(), 0.0) * unitFactor;
153 }
154
155 tubeL.transform = G4Translate3D(0.0, 0.0, 0.0);
156
157 //define geometry
158 tubeL.geo = new G4Polycone("geo_TubeL_name", 0.0, 2 * M_PI, TubeL_N, &(TubeL_Z[0]), &(TubeL_r[0]), &(TubeL_R[0]));
159
160 tubeL.logi = NULL;
161
162 elements["TubeL"] = tubeL;
163
164 std::vector<double> zero_r(N, 0.);
165
166 std::vector<std::string> straightSections;
167 boost::split(straightSections, m_config.getParameterStr("Straight"), boost::is_any_of(" "));
168 for (const auto& name : straightSections) {
169 //--------------
170 //- Create straight element
171
172 prep = name + ".";
173 string type = m_config.getParameterStr(prep + "type");
174
175
176 FarBeamLineElement polycone;
177
178 std::vector<double> Polycone_Z(N);
179 std::vector<double> Polycone_R(N);
180 std::vector<double> Polycone_r(N);
181 Polycone_Z[0] = 0;
182 Polycone_Z[1] = m_config.getParameter(prep + "L") * unitFactor;
183 Polycone_R[0] = m_config.getParameter(prep + "R") * unitFactor;
184 Polycone_R[1] = m_config.getParameter(prep + "R") * unitFactor;
185 Polycone_r[0] = m_config.getParameter(prep + "r") * unitFactor;
186 Polycone_r[1] = m_config.getParameter(prep + "r") * unitFactor;
187
188 double Polycone_X0 = m_config.getParameter(prep + "X0") * unitFactor;
189 double Polycone_Y0 = m_config.getParameter(prep + "Y0", 0) * unitFactor;
190 double Polycone_Z0 = m_config.getParameter(prep + "Z0") * unitFactor;
191 double Polycone_PHI = m_config.getParameter(prep + "PHI");
192 double Polycone_PHIYZ = m_config.getParameter(prep + "PHIYZ", 0);
193
194 polycone.transform = G4Translate3D(Polycone_X0, Polycone_Y0, Polycone_Z0);
195 polycone.transform = polycone.transform * G4RotateY3D(Polycone_PHI / Unit::rad);
196 if (Polycone_PHIYZ != 0)
197 polycone.transform = polycone.transform * G4RotateX3D(Polycone_PHIYZ / Unit::rad);
198
199 //define geometry
200 string subtract = m_config.getParameterStr(prep + "Subtract", "");
201 string intersect = m_config.getParameterStr(prep + "Intersect", "");
202
203 string geo_polyconexx_name = "geo_" + name + "xx_name";
204 string geo_polyconex_name = "geo_" + name + "x_name";
205 string geo_polycone_name = "geo_" + name + "_name";
206
207 G4VSolid* geo_polyconexx(NULL), *geo_polycone(NULL);
208
209 if (subtract != "" || intersect != "")
210 if (type == "pipe") // for pipes inner space will be created as vacuum
211 geo_polyconexx = new G4Polycone(geo_polyconexx_name, 0.0, 2 * M_PI, N, &(Polycone_Z[0]), &(zero_r[0]), &(Polycone_R[0]));
212 else
213 geo_polyconexx = new G4Polycone(geo_polyconexx_name, 0.0, 2 * M_PI, N, &(Polycone_Z[0]), &(Polycone_r[0]), &(Polycone_R[0]));
214 else if (type == "pipe") // for pipes inner space will be created as vacuum
215 geo_polycone = new G4Polycone(geo_polycone_name, 0.0, 2 * M_PI, N, &(Polycone_Z[0]), &(zero_r[0]), &(Polycone_R[0]));
216 else
217 geo_polycone = new G4Polycone(geo_polycone_name, 0.0, 2 * M_PI, N, &(Polycone_Z[0]), &(Polycone_r[0]), &(Polycone_R[0]));
218
219
220 if (subtract != "" && intersect != "") {
221 G4VSolid* geo_polyconex = new G4SubtractionSolid(geo_polyconex_name, geo_polyconexx, elements[subtract].geo,
222 polycone.transform.inverse()*elements[subtract].transform);
223 geo_polycone = new G4IntersectionSolid(geo_polycone_name, geo_polyconex, elements[intersect].geo,
224 polycone.transform.inverse()*elements[intersect].transform);
225 } else if (subtract != "")
226 geo_polycone = new G4SubtractionSolid(geo_polycone_name, geo_polyconexx, elements[subtract].geo,
227 polycone.transform.inverse()*elements[subtract].transform);
228 else if (intersect != "")
229 geo_polycone = new G4IntersectionSolid(geo_polycone_name, geo_polyconexx, elements[intersect].geo,
230 polycone.transform.inverse()*elements[intersect].transform);
231
232 polycone.geo = geo_polycone;
233
234 // define logical volume
235 string strMat_polycone = m_config.getParameterStr(prep + "Material");
236 G4Material* mat_polycone = Materials::get(strMat_polycone);
237 string logi_polycone_name = "logi_" + name + "_name";
238 G4LogicalVolume* logi_polycone = new G4LogicalVolume(polycone.geo, mat_polycone, logi_polycone_name);
239 setColor(*logi_polycone, "#CC0000");
240 setVisibility(*logi_polycone, false);
241
242 polycone.logi = logi_polycone;
243
244 //put volume
245 string phys_polycone_name = "phys_" + name + "_name";
246 new G4PVPlacement(polycone.transform, logi_polycone, phys_polycone_name, &topVolume, false, 0);
247
248 elements[name] = polycone;
249
250 double sum = 0.0;
251 for (int i = 0; i < N; ++i)
252 sum += Polycone_r[i]; // check that there is a space inside a pipe
253 if (type == "pipe" && sum != 0) { // add vacuum inside a pipe
254
255 FarBeamLineElement vacuum;
256
257 string nameVac = name + "Vac";
258
259 //define geometry
260 string geo_vacuumxx_name = "geo_" + nameVac + "xx_name";
261 string geo_vacuum_name = "geo_" + nameVac + "_name";
262
263 G4VSolid* geo_vacuumxx, *geo_vacuum;
264
265 geo_vacuumxx = new G4Polycone(geo_vacuumxx_name, 0.0, 2 * M_PI, N, &(Polycone_Z[0]), &(zero_r[0]), &(Polycone_r[0]));
266 geo_vacuum = new G4IntersectionSolid(geo_vacuumxx_name, geo_vacuumxx, geo_polycone);
267
268 vacuum.geo = geo_vacuum;
269 vacuum.transform = polycone.transform;
270
271 // define logical volume
272 G4Material* mat_vacuum = Materials::get("Vacuum");
273 string logi_vacuum_name = "logi_" + nameVac + "_name";
274 G4LogicalVolume* logi_vacuum = new G4LogicalVolume(vacuum.geo, mat_vacuum, logi_vacuum_name);
275 if (flag_limitStep) logi_vacuum->SetUserLimits(new G4UserLimits(stepMax));
276 setColor(*logi_vacuum, "#000000");
277 setVisibility(*logi_vacuum, false);
278
279 vacuum.logi = logi_vacuum;
280
281 //put volume
282 string phys_vacuum_name = "phys_" + nameVac + "_name";
283 //new G4PVPlacement(vacuum.transform, logi_vacuum, phys_vacuum_name, &topVolume, false, 0);
284 new G4PVPlacement(0, G4ThreeVector(0, 0, 0), logi_vacuum, phys_vacuum_name, logi_polycone, false, 0);
285
286 elements[nameVac] = vacuum;
287 }
288 }
289
290
291 std::vector<std::string> bendingSections;
292 boost::split(bendingSections, m_config.getParameterStr("Bending"), boost::is_any_of(" "));
293 for (const auto& name : bendingSections) {
294 //--------------
295 //- Create torus element
296
297 prep = name + ".";
298 string type = m_config.getParameterStr(prep + "type");
299
300 FarBeamLineElement torus;
301
302 double torus_r = m_config.getParameter(prep + "r") * unitFactor;
303 double torus_R = m_config.getParameter(prep + "R") * unitFactor;
304 double torus_RT = m_config.getParameter(prep + "RT") * unitFactor;
305 double torus_X0 = m_config.getParameter(prep + "X0") * unitFactor;
306 double torus_Z0 = m_config.getParameter(prep + "Z0") * unitFactor;
307 double torus_SPHI = m_config.getParameter(prep + "SPHI");
308 double torus_DPHI = m_config.getParameter(prep + "DPHI");
309
310 torus.transform = G4Translate3D(torus_X0, 0.0, torus_Z0);
311 torus.transform = torus.transform * G4RotateX3D(M_PI / 2 / Unit::rad);
312
313 //define geometry
314 string subtract = m_config.getParameterStr(prep + "Subtract", "");
315 string intersect = m_config.getParameterStr(prep + "Intersect", "");
316
317 string geo_torusxx_name = "geo_" + name + "xx_name";
318 string geo_torusx_name = "geo_" + name + "x_name";
319 string geo_torus_name = "geo_" + name + "_name";
320
321 G4VSolid* geo_torus(NULL);
322
323 if (subtract != "" || intersect != "") {
324 G4VSolid* geo_torusxx(NULL);
325 if (type == "pipe") // for pipes inner space will be created as vacuum
326 geo_torusxx = new G4Torus(geo_torusxx_name, 0, torus_R, torus_RT, torus_SPHI, torus_DPHI);
327 else
328 geo_torusxx = new G4Torus(geo_torusxx_name, torus_r, torus_R, torus_RT, torus_SPHI, torus_DPHI);
329 if (subtract != "" && intersect != "") {
330 G4VSolid* geo_torusx = new G4SubtractionSolid(geo_torusx_name, geo_torusxx, elements[subtract].geo,
331 torus.transform.inverse()*elements[subtract].transform);
332 geo_torus = new G4IntersectionSolid(geo_torus_name, geo_torusx, elements[intersect].geo,
333 torus.transform.inverse()*elements[intersect].transform);
334 } else if (subtract != "")
335 geo_torus = new G4SubtractionSolid(geo_torus_name, geo_torusxx, elements[subtract].geo,
336 torus.transform.inverse()*elements[subtract].transform);
337 else
338 geo_torus = new G4IntersectionSolid(geo_torus_name, geo_torusxx, elements[intersect].geo,
339 torus.transform.inverse()*elements[intersect].transform);
340 } else if (type == "pipe") // for pipes inner space will be created as vacuum
341 geo_torus = new G4Torus(geo_torus_name, 0, torus_R, torus_RT, torus_SPHI, torus_DPHI);
342 else
343 geo_torus = new G4Torus(geo_torus_name, torus_r, torus_R, torus_RT, torus_SPHI, torus_DPHI);
344
345 torus.geo = geo_torus;
346
347 // define logical volume
348 string strMat_torus = m_config.getParameterStr(prep + "Material");
349 G4Material* mat_torus = Materials::get(strMat_torus);
350 string logi_torus_name = "logi_" + name + "_name";
351 G4LogicalVolume* logi_torus = new G4LogicalVolume(torus.geo, mat_torus, logi_torus_name);
352 setColor(*logi_torus, "#CC0000");
353 setVisibility(*logi_torus, false);
354
355 torus.logi = logi_torus;
356
357 //put volume
358 string phys_torus_name = "phys_" + name + "_name";
359 new G4PVPlacement(torus.transform, logi_torus, phys_torus_name, &topVolume, false, 0);
360
361 elements[name] = torus;
362
363 if (type == "pipe" && torus_r != 0) { // add vacuum inside a pipe
364
365 FarBeamLineElement vacuum;
366
367 string nameVac = name + "Vac";
368
369 //define geometry
370 string geo_vacuumxx_name = "geo_" + nameVac + "xx_name";
371 string geo_vacuum_name = "geo_" + nameVac + "_name";
372
373 G4VSolid* geo_vacuumxx, *geo_vacuum;
374
375 geo_vacuumxx = new G4Torus(geo_vacuumxx_name, 0.0, torus_r, torus_RT, torus_SPHI, torus_DPHI);
376 geo_vacuum = new G4IntersectionSolid(geo_vacuum_name, geo_vacuumxx, geo_torus);
377
378 vacuum.geo = geo_vacuum;
379 vacuum.transform = torus.transform;
380
381 // define logical volume
382 G4Material* mat_vacuum = Materials::get("Vacuum");
383 string logi_vacuum_name = "logi_" + nameVac + "_name";
384 G4LogicalVolume* logi_vacuum = new G4LogicalVolume(vacuum.geo, mat_vacuum, logi_vacuum_name);
385 if (flag_limitStep) logi_vacuum->SetUserLimits(new G4UserLimits(stepMax));
386 setColor(*logi_vacuum, "#000000");
387 setVisibility(*logi_vacuum, false);
388
389 vacuum.logi = logi_vacuum;
390
391 //put volume
392 string phys_vacuum_name = "phys_" + nameVac + "_name";
393 //new G4PVPlacement(vacuum.transform, logi_vacuum, phys_vacuum_name, &topVolume, false, 0);
394 new G4PVPlacement(0, G4ThreeVector(0, 0, 0), logi_vacuum, phys_vacuum_name, logi_torus, false, 0);
395
396 elements[nameVac] = vacuum;
397 }
398 }
399
400
401 //--------------------------------------------------------------------------------------------
402 //- Gate shields, end-of-tunnel concrete shields, polyethylene shields, collimator shields
403
404 std::vector<std::string> shields;
405 boost::split(shields, m_config.getParameterStr("Shield"), boost::is_any_of(" "));
406 for (const auto& name : shields) {
407 prep = name + ".";
408
409 //- Shield made as box with optional subtracted box-shaped inner space (hole)
410
411 double shield_W = m_config.getParameter(prep + "W") * unitFactor;
412 double shield_H = m_config.getParameter(prep + "H") * unitFactor;
413 double shield_L = m_config.getParameter(prep + "L") * unitFactor;
414 double shield_X0 = m_config.getParameter(prep + "X0") * unitFactor;
415 double shield_Y0 = m_config.getParameter(prep + "Y0") * unitFactor;
416 double shield_Z0 = m_config.getParameter(prep + "Z0") * unitFactor;
417
418 double shield_hole_W = m_config.getParameter(prep + "holeW", 0) * unitFactor;
419 double shield_hole_H = m_config.getParameter(prep + "holeH", 0) * unitFactor;
420 double shield_hole_L = m_config.getParameter(prep + "holeL", 0) * unitFactor;
421 double shield_hole_dX = m_config.getParameter(prep + "holeDX", 0) * unitFactor;
422 double shield_hole_dY = m_config.getParameter(prep + "holeDY", 0) * unitFactor;
423 double shield_hole_dZ = m_config.getParameter(prep + "holeDZ", 0) * unitFactor;
424
425 double shield_PHI = m_config.getParameter(prep + "PHI");
426
427 // storable element
428 FarBeamLineElement shield;
429
430 shield.transform = G4Translate3D(shield_X0, shield_Y0, shield_Z0);
431 shield.transform = shield.transform * G4RotateY3D(shield_PHI / Unit::rad);
432
433 G4Transform3D transform_shield_hole = G4Translate3D(shield_hole_dX, shield_hole_dY, shield_hole_dZ);
434
435 //define geometry
436 string geo_shieldx_name = "geo_" + name + "x_name";
437 string geo_shield_hole_name = "geo_" + name + "_hole_name";
438 string geo_shield_name = "geo_" + name + "_name";
439
440 if (shield_hole_W == 0 || shield_hole_H == 0 || shield_hole_L == 0) {
441 G4Box* geo_shield = new G4Box(geo_shield_name, shield_W / 2.0, shield_H / 2.0, shield_L / 2.0);
442
443 shield.geo = geo_shield;
444 } else {
445 G4Box* geo_shieldx = new G4Box(geo_shieldx_name, shield_W / 2.0, shield_H / 2.0, shield_L / 2.0);
446 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);
447 G4SubtractionSolid* geo_shield = new G4SubtractionSolid(geo_shield_name, geo_shieldx, geo_shield_hole,
448 transform_shield_hole);
449
450 shield.geo = geo_shield;
451 }
452
453 string strMat_shield = m_config.getParameterStr(prep + "Material");
454 G4Material* mat_shield = Materials::get(strMat_shield);
455
456 string logi_shield_name = "logi_" + name + "_name";
457 G4LogicalVolume* logi_shield = new G4LogicalVolume(shield.geo, mat_shield, logi_shield_name);
458
459 shield.logi = logi_shield;
460
461 //put volume
462 setColor(*logi_shield, "#0000CC");
463 //setVisibility(*logi_shield, false);
464 string phys_shield_name = "phys_" + name + "_name";
465 new G4PVPlacement(shield.transform, shield.logi, phys_shield_name, &topVolume, false, 0);
466
467 elements[name] = shield;
468 }
469
470
471 //--------------
472 //- Tube (virtual tube for radiation level study)
473
474 //define geometry
475 G4Tubs* geo_Tube = new G4Tubs("geo_Tube_name", 3995 * CLHEP::mm, 4000 * CLHEP::mm, 29 * CLHEP::m, 0. * CLHEP::deg, 360.*CLHEP::deg);
476 G4Material* mat_Tube = Materials::get("G4_Si");
477 G4LogicalVolume* logi_Tube = new G4LogicalVolume(geo_Tube, mat_Tube, "logi_Tube_name");
478
479 //put volume
480 setColor(*logi_Tube, "#CC0000");
481 setVisibility(*logi_Tube, false);
482 bool radiation_study = false;
483 // cppcheck-suppress knownConditionTrueFalse
484 if (radiation_study && elements.count("GateShieldL")) {
485 new G4PVPlacement(elements["GateShieldL"].transform, logi_Tube, "phys_Tube_name", &topVolume, false, 0);
486 }
487
488
489 //---------------------------
490 // for dose simulation
491 //---------------------------
492
493 // cppcheck-suppress knownConditionTrueFalse
494 if (radiation_study) {
495 //neutron shield (poly)
496 if (elements.count("PolyShieldL"))
497 elements["PolyShieldL"].logi->SetSensitiveDetector(new BkgSensitiveDetector("IR", 1001));
498 if (elements.count("PolyShieldR"))
499 elements["PolyShieldR"].logi->SetSensitiveDetector(new BkgSensitiveDetector("IR", 1002));
500
501 //additional neutron shield (concrete)
502 if (elements.count("ConcreteShieldL"))
503 elements["ConcreteShieldL"].logi->SetSensitiveDetector(new BkgSensitiveDetector("IR", 1003));
504 if (elements.count("ConcreteShieldR"))
505 elements["ConcreteShieldR"].logi->SetSensitiveDetector(new BkgSensitiveDetector("IR", 1004));
506
507 //gate shield (concrete)
508 if (elements.count("GateShieldL"))
509 elements["GateShieldL"].logi->SetSensitiveDetector(new BkgSensitiveDetector("IR", 1005));
510 if (elements.count("GateShieldR"))
511 elements["GateShieldR"].logi->SetSensitiveDetector(new BkgSensitiveDetector("IR", 1006));
512
513 //virtual material outside gate-shield
514 logi_Tube->SetSensitiveDetector(new BkgSensitiveDetector("IR", 1007));
515 }
516
517
518 //------------------
519 //- Collimators
520
521 std::vector<std::string> collimators;
522 boost::split(collimators, m_config.getParameterStr("Collimator"), boost::is_any_of(" "));
523 for (const auto& name : collimators) {
524 //- Collimators consist of two independent jaws (trapezoids), identical in shape, positioned opposite to each other
525 //- Each jaw consists of copper body and high Z head
526
527 prep = name + ".";
528
529 string type = m_config.getParameterStr(prep + "type");
530 string motherVolume = m_config.getParameterStr(prep + "MotherVolume");
531 string motherVolumeVacuum = motherVolume + "Vac";
532
533 // If zz < 0 (positioned at negative z) vertical collimator is flipped when rotated into Mother Volume system
534 G4Scale3D scale;
535 G4Rotate3D rotation;
536 G4Translate3D translation;
537 elements[motherVolumeVacuum].transform.getDecomposition(scale, rotation, translation);
538 double zz = rotation.zz();
539
540 // d1, d2 are collimator jaws displacements from beam center, d1<0, d2>0
541 // Z is collimator position inside its Mother Volume
542 double collimator_d1 = m_config.getParameter(prep + "d1") * unitFactor;
543 double collimator_d2 = m_config.getParameter(prep + "d2") * unitFactor;
544 double collimator_fullH = m_config.getParameter(prep + "fullH") * unitFactor;
545 double collimator_headH = m_config.getParameter(prep + "headH") * unitFactor;
546 double collimator_minW = m_config.getParameter(prep + "minW") * unitFactor;
547 double collimator_maxW = m_config.getParameter(prep + "maxW") * unitFactor;
548 double collimator_th = m_config.getParameter(prep + "th") * unitFactor;
549 double collimator_Z = m_config.getParameter(prep + "Z") * unitFactor;
550
551 B2WARNING("Collimator " << name << " displacement d1 is set to " << collimator_d1 << "mm (must be negative)");
552 B2WARNING("Collimator " << name << " displacement d2 is set to " << collimator_d2 << "mm (must be positive)");
553
554
555 // Collimator heads
556
557 // dx1,2 dy1,2 dz are trapezoid dimensions
558 double head_dx1;
559 double head_dx2;
560 double head_dy1;
561 double head_dy2;
562 double head_dz = collimator_headH / 2.0;
563 if (type == "vertical") {
564 head_dx1 = collimator_th / 2.0;
565 head_dx2 = collimator_th / 2.0;
566 head_dy1 = ((collimator_maxW - collimator_minW) * collimator_headH / collimator_fullH + collimator_minW) / 2.0;
567 head_dy2 = collimator_minW / 2.0;
568 } else {
569 head_dx1 = ((collimator_maxW - collimator_minW) * collimator_headH / collimator_fullH + collimator_minW) / 2.0;
570 head_dx2 = collimator_minW / 2.0;
571 head_dy1 = collimator_th / 2.0;
572 head_dy2 = collimator_th / 2.0;
573 }
574
575 // storable elements
576 FarBeamLineElement collimator_head1;
577 FarBeamLineElement collimator_head2;
578
579 // move collimator to position on beam line
580 G4Transform3D transform_head1 = G4Translate3D(0.0, 0.0, collimator_Z);
581 G4Transform3D transform_head2 = G4Translate3D(0.0, 0.0, collimator_Z);
582
583 // rotate and move collimator jaws to their relative positions
584 if (type == "vertical") {
585 transform_head1 = transform_head1 * G4Translate3D(0.0, -head_dz + collimator_d1, 0.0);
586 transform_head1 = transform_head1 * G4RotateX3D(-M_PI / 2 / Unit::rad);
587
588 transform_head2 = transform_head2 * G4Translate3D(0.0, head_dz + collimator_d2, 0.0);
589 transform_head2 = transform_head2 * G4RotateX3D(M_PI / 2 / Unit::rad);
590 } else {
591 if (zz > 0) {
592 transform_head1 = transform_head1 * G4Translate3D(-head_dz + collimator_d1, 0.0, 0.0);
593 transform_head1 = transform_head1 * G4RotateY3D(M_PI / 2 / Unit::rad);
594
595 transform_head2 = transform_head2 * G4Translate3D(head_dz + collimator_d2, 0.0, 0.0);
596 transform_head2 = transform_head2 * G4RotateY3D(-M_PI / 2 / Unit::rad);
597 } else {
598 transform_head1 = transform_head1 * G4Translate3D(head_dz - collimator_d1, 0.0, 0.0);
599 transform_head1 = transform_head1 * G4RotateY3D(-M_PI / 2 / Unit::rad);
600
601 transform_head2 = transform_head2 * G4Translate3D(-head_dz - collimator_d2, 0.0, 0.0);
602 transform_head2 = transform_head2 * G4RotateY3D(M_PI / 2 / Unit::rad);
603 }
604 }
605
606 collimator_head1.transform = transform_head1;
607 collimator_head2.transform = transform_head2;
608
609 // define geometry
610 string geo_headx_name = "geo_" + name + "_headx_name";
611
612 string geo_head1_name = "geo_" + name + "_head1_name";
613 string geo_head2_name = "geo_" + name + "_head2_name";
614
615 G4VSolid* geo_headx = new G4Trd(geo_headx_name, head_dx1, head_dx2, head_dy1, head_dy2, head_dz);
616
617 G4VSolid* geo_head1 = new G4IntersectionSolid(geo_head1_name, geo_headx, elements[motherVolumeVacuum].geo,
618 collimator_head1.transform.inverse());
619 G4VSolid* geo_head2 = new G4IntersectionSolid(geo_head2_name, geo_headx, elements[motherVolumeVacuum].geo,
620 collimator_head2.transform.inverse());
621
622 collimator_head1.geo = geo_head1;
623 collimator_head2.geo = geo_head2;
624
625 // define logical volume
626 string strMat_head = m_config.getParameterStr(prep + "HeadMaterial");
627 G4Material* mat_head = Materials::get(strMat_head);
628 string logi_head1_name = "logi_" + name + "_head1_name";
629 string logi_head2_name = "logi_" + name + "_head2_name";
630 G4LogicalVolume* logi_head1 = new G4LogicalVolume(geo_head1, mat_head, logi_head1_name);
631 G4LogicalVolume* logi_head2 = new G4LogicalVolume(geo_head2, mat_head, logi_head2_name);
632 setColor(*logi_head1, "#CC0000");
633 setColor(*logi_head2, "#CC0000");
634 setVisibility(*logi_head1, false);
635 setVisibility(*logi_head2, false);
636
637 // check if collimator is inside beam pipe
638 double volume_head1 = logi_head1->GetSolid()->GetCubicVolume();
639 double volume_head2 = logi_head2->GetSolid()->GetCubicVolume();
640
641 collimator_head1.logi = logi_head1;
642 collimator_head2.logi = logi_head2;
643
644 // put volume
645 string phys_head1_name = "phys_" + name + "_head1" + "_name";
646 string phys_head2_name = "phys_" + name + "_head2" + "_name";
647 if (volume_head1 != 0)
648 new G4PVPlacement(collimator_head1.transform, logi_head1, phys_head1_name, elements[motherVolumeVacuum].logi, false, 0);
649 if (volume_head2 != 0)
650 new G4PVPlacement(collimator_head2.transform, logi_head2, phys_head2_name, elements[motherVolumeVacuum].logi, false, 0);
651
652 // to use it later in "intersect" and "subtract"
653 collimator_head1.transform = collimator_head1.transform * elements[motherVolumeVacuum].transform;
654 collimator_head2.transform = collimator_head2.transform * elements[motherVolumeVacuum].transform;
655
656 string name_head1 = name + "_head1";
657 string name_head2 = name + "_head2";
658 elements[name_head1] = collimator_head1;
659 elements[name_head2] = collimator_head2;
660
661
662 // Collimator bodies
663
664 // dx1,2 dy1,2 dz are trapezoid dimensions
665 double body_dx1;
666 double body_dx2;
667 double body_dy1;
668 double body_dy2;
669 double body_dz = (collimator_fullH - collimator_headH) / 2.0;
670 if (type == "vertical") {
671 body_dx1 = collimator_th / 2.0;
672 body_dx2 = collimator_th / 2.0;
673 body_dy1 = collimator_maxW / 2.0;
674 body_dy2 = ((collimator_maxW - collimator_minW) * collimator_headH / collimator_fullH + collimator_minW) / 2.0;
675 } else {
676 body_dx1 = collimator_maxW / 2.0;
677 body_dx2 = ((collimator_maxW - collimator_minW) * collimator_headH / collimator_fullH + collimator_minW) / 2.0;
678 body_dy1 = collimator_th / 2.0;
679 body_dy2 = collimator_th / 2.0;
680 }
681
682 // storable elements
683 FarBeamLineElement collimator_body1;
684 FarBeamLineElement collimator_body2;
685
686 // reuse head transformation with additional shift
687 if (type == "vertical") {
688 collimator_body1.transform = G4Translate3D(0.0, -head_dz - body_dz, 0.0) * transform_head1;
689 collimator_body2.transform = G4Translate3D(0.0, head_dz + body_dz, 0.0) * transform_head2;
690 } else {
691 if (zz > 0) {
692 collimator_body1.transform = G4Translate3D(-head_dz - body_dz, 0.0, 0.0) * transform_head1;
693 collimator_body2.transform = G4Translate3D(head_dz + body_dz, 0.0, 0.0) * transform_head2;
694 } else {
695 collimator_body1.transform = G4Translate3D(head_dz + body_dz, 0.0, 0.0) * transform_head1;
696 collimator_body2.transform = G4Translate3D(-head_dz - body_dz, 0.0, 0.0) * transform_head2;
697 }
698 }
699
700 // define geometry
701 string geo_bodyx_name = "geo_" + name + "_bodyx_name";
702
703 string geo_body1_name = "geo_" + name + "_body1_name";
704 string geo_body2_name = "geo_" + name + "_body2_name";
705
706 G4VSolid* geo_bodyx = new G4Trd(geo_bodyx_name, body_dx1, body_dx2, body_dy1, body_dy2, body_dz);
707
708 G4VSolid* geo_body1 = new G4IntersectionSolid(geo_body1_name, geo_bodyx, elements[motherVolumeVacuum].geo,
709 collimator_body1.transform.inverse());
710 G4VSolid* geo_body2 = new G4IntersectionSolid(geo_body2_name, geo_bodyx, elements[motherVolumeVacuum].geo,
711 collimator_body2.transform.inverse());
712
713 collimator_body1.geo = geo_body1;
714 collimator_body2.geo = geo_body2;
715
716 // define logical volume
717 string strMat_body = m_config.getParameterStr(prep + "Material");
718 G4Material* mat_body = Materials::get(strMat_body);
719 string logi_body1_name = "logi_" + name + "_body1_name";
720 string logi_body2_name = "logi_" + name + "_body2_name";
721 G4LogicalVolume* logi_body1 = new G4LogicalVolume(geo_body1, mat_body, logi_body1_name);
722 G4LogicalVolume* logi_body2 = new G4LogicalVolume(geo_body2, mat_body, logi_body2_name);
723 setColor(*logi_body1, "#CC0000");
724 setColor(*logi_body2, "#CC0000");
725 setVisibility(*logi_body1, false);
726 setVisibility(*logi_body2, false);
727
728 // check if collimator is inside beam pipe
729 double volume_body1 = logi_body1->GetSolid()->GetCubicVolume();
730 double volume_body2 = logi_body2->GetSolid()->GetCubicVolume();
731
732 collimator_body1.logi = logi_body1;
733 collimator_body2.logi = logi_body2;
734
735 // put volume
736 string phys_body1_name = "phys_" + name + "_body1" + "_name";
737 string phys_body2_name = "phys_" + name + "_body2" + "_name";
738 if (volume_body1 != 0)
739 new G4PVPlacement(collimator_body1.transform, logi_body1, phys_body1_name, elements[motherVolumeVacuum].logi, false, 0);
740 if (volume_body2 != 0)
741 new G4PVPlacement(collimator_body2.transform, logi_body2, phys_body2_name, elements[motherVolumeVacuum].logi, false, 0);
742
743 // to use it later in "intersect" and "subtract"
744 collimator_body1.transform = collimator_body1.transform * elements[motherVolumeVacuum].transform;
745 collimator_body2.transform = collimator_body2.transform * elements[motherVolumeVacuum].transform;
746
747 string name_body1 = name + "_body1";
748 string name_body2 = name + "_body2";
749 elements[name_body1] = collimator_body1;
750 elements[name_body2] = collimator_body2;
751 }
752
753
754 //----------
755 //- Additional shields added during LS1
756
757 //--------------
758 //- Additional concrete shield left (backward)
759 //- Fills gap between end-of-tunnel shield and QCS
760
761 if (m_config.getParameter("ACSL.box1_W", -1) > 0) { // Run2
762 FarBeamLineElement ACSL;
763
764 //get parameters from .xml file
765 std::string name = "ACSL";
766 prep = name + ".";
767
768 double acsl_X0 = m_config.getParameter(prep + "X0") * unitFactor;
769 double acsl_Y0 = m_config.getParameter(prep + "Y0") * unitFactor;
770 double acsl_Z0 = m_config.getParameter(prep + "Z0") * unitFactor;
771 double acsl_PHI = m_config.getParameter(prep + "PHI");
772
773 double acsl_box1_W = m_config.getParameter(prep + "box1_W") * unitFactor;
774 double acsl_box1_H = m_config.getParameter(prep + "box1_H") * unitFactor;
775 double acsl_box1_L = m_config.getParameter(prep + "box1_L") * unitFactor;
776
777 double acsl_box2_W = m_config.getParameter(prep + "box2_W") * unitFactor;
778 double acsl_box2_H = m_config.getParameter(prep + "box2_H") * unitFactor;
779 double acsl_box2_L = m_config.getParameter(prep + "box2_L") * unitFactor;
780 double acsl_box2_dX = m_config.getParameter(prep + "box2_dX") * unitFactor;
781 double acsl_box2_dY = m_config.getParameter(prep + "box2_dY") * unitFactor;
782 double acsl_box2_dZ = m_config.getParameter(prep + "box2_dZ") * unitFactor;
783
784 double acsl_trd1_X1 = m_config.getParameter(prep + "trd1_X1") * unitFactor;
785 double acsl_trd1_X2 = m_config.getParameter(prep + "trd1_X2") * unitFactor;
786 double acsl_trd1_Y1 = m_config.getParameter(prep + "trd1_Y1") * unitFactor;
787 double acsl_trd1_Y2 = m_config.getParameter(prep + "trd1_Y2") * unitFactor;
788 double acsl_trd1_Z = m_config.getParameter(prep + "trd1_Z") * unitFactor;
789 double acsl_trd1_dX = m_config.getParameter(prep + "trd1_dX") * unitFactor;
790 double acsl_trd1_dY = m_config.getParameter(prep + "trd1_dY") * unitFactor;
791 double acsl_trd1_dZ = m_config.getParameter(prep + "trd1_dZ") * unitFactor;
792 double acsl_trd1_PHI = m_config.getParameter(prep + "trd1_PHI");
793
794 double acsl_trd2_X1 = m_config.getParameter(prep + "trd2_X1") * unitFactor;
795 double acsl_trd2_X2 = m_config.getParameter(prep + "trd2_X2") * unitFactor;
796 double acsl_trd2_Y1 = m_config.getParameter(prep + "trd2_Y1") * unitFactor;
797 double acsl_trd2_Y2 = m_config.getParameter(prep + "trd2_Y2") * unitFactor;
798 double acsl_trd2_Z = m_config.getParameter(prep + "trd2_Z") * unitFactor;
799 double acsl_trd2_dX = m_config.getParameter(prep + "trd2_dX") * unitFactor;
800 double acsl_trd2_dY = m_config.getParameter(prep + "trd2_dY") * unitFactor;
801 double acsl_trd2_dZ = m_config.getParameter(prep + "trd2_dZ") * unitFactor;
802 double acsl_trd2_PHI = m_config.getParameter(prep + "trd2_PHI");
803
804 // solids
805 string geo_box1_name = "geo_" + name + "_box1_name";
806 string geo_box2_name = "geo_" + name + "_box2_name";
807 string geo_trd1_name = "geo_" + name + "_trd1_name";
808 string geo_trd2_name = "geo_" + name + "_trd2_name";
809 string geo_acsl_name = "geo_" + name + "_name";
810
811 G4Box* geo_box1 = new G4Box(geo_box1_name, acsl_box1_W / 2.0, acsl_box1_H / 2.0, acsl_box1_L / 2.0);
812 G4Box* geo_box2 = new G4Box(geo_box2_name, acsl_box2_W / 2.0, acsl_box2_H / 2.0, acsl_box2_L / 2.0);
813 G4Trd* geo_trd1 = new G4Trd(geo_trd1_name, acsl_trd1_X1, acsl_trd1_X2, acsl_trd1_Y1, acsl_trd1_Y2, acsl_trd1_Z);
814 G4Trd* geo_trd2 = new G4Trd(geo_trd2_name, acsl_trd2_X1, acsl_trd2_X2, acsl_trd2_Y1, acsl_trd2_Y2, acsl_trd2_Z);
815
816 // transformations
817 // G4Transform3D box1_trans = G4Translate3D(0, 0, 0);
818
819 G4Transform3D box2_trans = G4Translate3D(acsl_box2_dX, acsl_box2_dY, acsl_box2_dZ);
820
821 G4Transform3D trd1_trans = G4Translate3D(acsl_trd1_dX, acsl_trd1_dY, acsl_trd1_dZ);
822 trd1_trans = trd1_trans * G4RotateY3D(acsl_trd1_PHI / Unit::rad);
823
824 G4Transform3D trd2_trans = G4Translate3D(acsl_trd2_dX, acsl_trd2_dY, acsl_trd2_dZ);
825 trd2_trans = trd2_trans * G4RotateY3D(acsl_trd2_PHI / Unit::rad);
826
827 ACSL.transform = G4Translate3D(acsl_X0, acsl_Y0, acsl_Z0);
828 ACSL.transform = ACSL.transform * G4RotateY3D(acsl_PHI / Unit::rad);;
829
830 /******************
831 not supported yet by Geant4VM
832
833 // composite solid
834 G4MultiUnion* geo_acsl = new G4MultiUnion(geo_acsl_name);
835 geo_acsl->AddNode(*geo_box1, box1_trans);
836 geo_acsl->AddNode(*geo_box2, box2_trans);
837 geo_acsl->AddNode(*geo_trd1, trd1_trans);
838 geo_acsl->AddNode(*geo_trd2, trd2_trans);
839 geo_acsl->Voxelize();
840 ***********************/
841
842 string geo_interm1_name = "geo_" + name + "_interm1_name";
843 string geo_interm2_name = "geo_" + name + "_interm2_name";
844 G4UnionSolid* geo_interm1 = new G4UnionSolid(geo_interm1_name, geo_box1, geo_box2, box2_trans);
845 G4UnionSolid* geo_interm2 = new G4UnionSolid(geo_interm2_name, geo_interm1, geo_trd1, trd1_trans);
846 G4UnionSolid* geo_acsl = new G4UnionSolid(geo_acsl_name, geo_interm2, geo_trd2, trd2_trans);
847
848 ACSL.geo = geo_acsl;
849
850 // define logical volume
851 string strMat_acsl = m_config.getParameterStr(prep + "Material");
852 G4Material* mat_acsl = Materials::get(strMat_acsl);
853 string logi_acsl_name = "logi_" + name + "_name";
854 G4LogicalVolume* logi_acsl = new G4LogicalVolume(geo_acsl, mat_acsl, logi_acsl_name);
855 setColor(*logi_acsl, "#00CC00");
856 setVisibility(*logi_acsl, false);
857
858 ACSL.logi = logi_acsl;
859
860 //put volume
861 string phys_acsl_name = "phys_" + name + "_name";
862 new G4PVPlacement(ACSL.transform, ACSL.logi, phys_acsl_name, &topVolume, false, 0);
863
864 // elements[name] = ACSL;
865
866
867 //--------------
868 //- Additional concrete shield right (forward)
869 //- Fills gap between end-of-tunnel shield and QCS
870
871 // Consists of two disjoined trapezoids
872 // Part 1
873
874 FarBeamLineElement ACSR1;
875
876 //get parameters from .xml file
877 name = "ACSR1";
878 prep = name + ".";
879
880 double acsr1_X0 = m_config.getParameter(prep + "X0") * unitFactor;
881 double acsr1_Y0 = m_config.getParameter(prep + "Y0") * unitFactor;
882 double acsr1_Z0 = m_config.getParameter(prep + "Z0") * unitFactor;
883 double acsr1_PHI0 = m_config.getParameter(prep + "PHI0");
884
885 double acsr1_X1 = m_config.getParameter(prep + "X1") * unitFactor;
886 double acsr1_X2 = m_config.getParameter(prep + "X2") * unitFactor;
887 double acsr1_Y1 = m_config.getParameter(prep + "Y1") * unitFactor;
888 double acsr1_Y2 = m_config.getParameter(prep + "Y2") * unitFactor;
889 double acsr1_Z = m_config.getParameter(prep + "Z") * unitFactor;
890 double acsr1_THETA = m_config.getParameter(prep + "THETA");
891 double acsr1_PHI = m_config.getParameter(prep + "PHI");
892 double acsr1_ANG = m_config.getParameter(prep + "ANG");
893
894 double acsr1_dx = (acsr1_X1 - acsr1_X2) / 2.0;
895 double acsr1_dy = (acsr1_Y2 - acsr1_Y1) / 2.0;
896
897 // G4ThreeVector acsr1_pt[8];
898 // acsr1_pt[0] = G4ThreeVector( -acsr1_X1 + acsr1_dx, -acsr1_Y1 + acsr1_dy, -acsr1_Z);
899 // acsr1_pt[1] = G4ThreeVector( acsr1_X1 + acsr1_dx, -acsr1_Y1 + acsr1_dy, -acsr1_Z);
900 // acsr1_pt[2] = G4ThreeVector( -acsr1_X1 + acsr1_dx, acsr1_Y1 + acsr1_dy, -acsr1_Z);
901 // acsr1_pt[3] = G4ThreeVector( acsr1_X1 + acsr1_dx, acsr1_Y1 + acsr1_dy, -acsr1_Z);
902 // acsr1_pt[4] = G4ThreeVector( -acsr1_X1 + acsr1_dx, -2.0*acsr1_Y2 + acsr1_Y1 + acsr1_dy, acsr1_Z);
903 // acsr1_pt[5] = G4ThreeVector( 2.0*acsr1_X2 -acsr1_X1 + acsr1_dx, -2.0*acsr1_Y2 + acsr1_Y1 + acsr1_dy, acsr1_Z);
904 // acsr1_pt[6] = G4ThreeVector( -acsr1_X1 + acsr1_dx, acsr1_Y1 + acsr1_dy, acsr1_Z);
905 // acsr1_pt[7] = G4ThreeVector( 2.0*acsr1_X2 -acsr1_X1 + acsr1_dx, acsr1_Y1 + acsr1_dy, acsr1_Z);
906
907 // solids
908 string geo_acsr1_name = "geo_" + name + "_name";
909 G4Trap* geo_acsr1 = new G4Trap(geo_acsr1_name, acsr1_Z, acsr1_THETA, acsr1_PHI, acsr1_Y1, acsr1_X1, acsr1_X1, acsr1_ANG, acsr1_Y2,
910 acsr1_X2, acsr1_X2, acsr1_ANG);
911 // G4Trap* geo_acsr1 = new G4Trap(geo_acsr1_name, acsr1_pt);
912
913 ACSR1.geo = geo_acsr1;
914
915 // transformations
916 ACSR1.transform = G4Translate3D(acsr1_X0, acsr1_Y0 - acsr1_dy, acsr1_Z0 - acsr1_dx);
917 ACSR1.transform = ACSR1.transform * G4RotateY3D(acsr1_PHI0 / Unit::rad);;
918
919 // define logical volume
920 string strMat_acsr1 = m_config.getParameterStr(prep + "Material");
921 G4Material* mat_acsr1 = Materials::get(strMat_acsr1);
922 string logi_acsr1_name = "logi_" + name + "_name";
923 G4LogicalVolume* logi_acsr1 = new G4LogicalVolume(geo_acsr1, mat_acsr1, logi_acsr1_name);
924 setColor(*logi_acsr1, "#00CC00");
925 setVisibility(*logi_acsr1, false);
926
927 ACSR1.logi = logi_acsr1;
928
929 //put volume
930 string phys_acsr1_name = "phys_" + name + "_name";
931 new G4PVPlacement(ACSR1.transform, ACSR1.logi, phys_acsr1_name, &topVolume, false, 0);
932
933 // elements[name] = ACSR1;
934
935 //--------------
936 // Part 2
937
938 FarBeamLineElement ACSR2;
939
940 //get parameters from .xml file
941 name = "ACSR2";
942 prep = name + ".";
943
944 double acsr2_X0 = m_config.getParameter(prep + "X0") * unitFactor;
945 double acsr2_Y0 = m_config.getParameter(prep + "Y0") * unitFactor;
946 double acsr2_Z0 = m_config.getParameter(prep + "Z0") * unitFactor;
947 double acsr2_PHI0 = m_config.getParameter(prep + "PHI0");
948
949 double acsr2_X1 = m_config.getParameter(prep + "X1") * unitFactor;
950 double acsr2_X2 = m_config.getParameter(prep + "X2") * unitFactor;
951 double acsr2_Y1 = m_config.getParameter(prep + "Y1") * unitFactor;
952 double acsr2_Y2 = m_config.getParameter(prep + "Y2") * unitFactor;
953 double acsr2_Z = m_config.getParameter(prep + "Z") * unitFactor;
954 double acsr2_THETA = m_config.getParameter(prep + "THETA");
955 double acsr2_PHI = m_config.getParameter(prep + "PHI");
956 double acsr2_ANG = m_config.getParameter(prep + "ANG");
957
958 double acsr2_dx = (acsr2_X1 - acsr2_X2) / 2.0;
959 double acsr2_dy = (acsr2_Y2 - acsr2_Y1) / 2.0;
960
961 // G4ThreeVector acsr2_pt[8];
962 // acsr2_pt[0] = G4ThreeVector( -acsr2_X1 + acsr2_dx, -acsr2_Y1 + acsr2_dy, -acsr2_Z);
963 // acsr2_pt[1] = G4ThreeVector( acsr2_X1 + acsr2_dx, -acsr2_Y1 + acsr2_dy, -acsr2_Z);
964 // acsr2_pt[2] = G4ThreeVector( -acsr2_X1 + acsr2_dx, acsr2_Y1 + acsr2_dy, -acsr2_Z);
965 // acsr2_pt[3] = G4ThreeVector( acsr2_X1 + acsr2_dx, acsr2_Y1 + acsr2_dy, -acsr2_Z);
966 // acsr2_pt[4] = G4ThreeVector( -acsr2_X1 + acsr2_dx, -2.0*acsr2_Y2 + acsr2_Y1 + acsr2_dy, acsr2_Z);
967 // acsr2_pt[5] = G4ThreeVector( 2.0*acsr2_X2 -acsr2_X1 + acsr2_dx, -2.0*acsr2_Y2 + acsr2_Y1 + acsr2_dy, acsr2_Z);
968 // acsr2_pt[6] = G4ThreeVector( -acsr2_X1 + acsr2_dx, acsr2_Y1 + acsr2_dy, acsr2_Z);
969 // acsr2_pt[7] = G4ThreeVector( 2.0*acsr2_X2 -acsr2_X1 + acsr2_dx, acsr2_Y1 + acsr2_dy, acsr2_Z);
970
971 // solids
972 string geo_acsr2_name = "geo_" + name + "_name";
973 G4Trap* geo_acsr2 = new G4Trap(geo_acsr2_name, acsr2_Z, acsr2_THETA, acsr2_PHI, acsr2_Y1, acsr2_X1, acsr2_X1, acsr2_ANG, acsr2_Y2,
974 acsr2_X2, acsr2_X2, acsr2_ANG);
975 // G4Trap* geo_acsr2 = new G4Trap(geo_acsr2_name, acsr2_pt);
976
977 ACSR2.geo = geo_acsr2;
978
979 // transformations
980 ACSR2.transform = G4Translate3D(acsr2_X0, acsr2_Y0 - acsr2_dy, acsr2_Z0 - acsr2_dx);
981 ACSR2.transform = ACSR2.transform * G4RotateY3D(acsr2_PHI0 / Unit::rad);;
982
983 // define logical volume
984 string strMat_acsr2 = m_config.getParameterStr(prep + "Material");
985 G4Material* mat_acsr2 = Materials::get(strMat_acsr2);
986 string logi_acsr2_name = "logi_" + name + "_name";
987 G4LogicalVolume* logi_acsr2 = new G4LogicalVolume(geo_acsr2, mat_acsr2, logi_acsr2_name);
988 setColor(*logi_acsr2, "#00CC00");
989 setVisibility(*logi_acsr2, false);
990
991 ACSR2.logi = logi_acsr2;
992
993 //put volume
994 string phys_acsr2_name = "phys_" + name + "_name";
995 new G4PVPlacement(ACSR2.transform, ACSR2.logi, phys_acsr2_name, &topVolume, false, 0);
996
997 // elements[name] = ACSR2;
998
999
1000 //--------------
1001 //- Additional polyethilene shield left (backward)
1002 //- Fills gap between PolyShield and QCS
1003
1004 // Consists of two disjoined parts
1005 // Part 1
1006
1007 FarBeamLineElement APSL1;
1008
1009 //get parameters from .xml file
1010 name = "APSL1";
1011 prep = name + ".";
1012
1013 double apsl1_W = m_config.getParameter(prep + "W") * unitFactor;
1014 double apsl1_H = m_config.getParameter(prep + "H") * unitFactor;
1015 double apsl1_L = m_config.getParameter(prep + "L") * unitFactor;
1016 double apsl1_X0 = m_config.getParameter(prep + "X0") * unitFactor;
1017 double apsl1_Y0 = m_config.getParameter(prep + "Y0") * unitFactor;
1018 double apsl1_Z0 = m_config.getParameter(prep + "Z0") * unitFactor;
1019 double apsl1_hole_R = m_config.getParameter(prep + "holeR") * unitFactor;
1020 double apsl1_hole_D = m_config.getParameter(prep + "holeD") * unitFactor;
1021 double apsl1_hole_dX = m_config.getParameter(prep + "holeDX") * unitFactor;
1022 double apsl1_hole_dY = m_config.getParameter(prep + "holeDY") * unitFactor;
1023 double apsl1_hole_dZ = m_config.getParameter(prep + "holeDZ") * unitFactor;
1024 double apsl1_PHI = m_config.getParameter(prep + "PHI");
1025
1026 // transformations
1027 APSL1.transform = G4Translate3D(apsl1_X0, apsl1_Y0, apsl1_Z0);
1028 APSL1.transform = APSL1.transform * G4RotateY3D(apsl1_PHI / Unit::rad);;
1029
1030 G4Transform3D transform_apsl1_hole = G4Translate3D(apsl1_hole_dX, apsl1_hole_dY, apsl1_hole_dZ);
1031
1032 //define geometry
1033 string geo_apsl1_box_name = "geo_" + name + "_box_name";
1034 string geo_apsl1_hole_name = "geo_" + name + "_hole_name";
1035 string geo_apsl1_name = "geo_" + name + "_name";
1036
1037 G4Box* geo_apsl1_box = new G4Box(geo_apsl1_box_name, apsl1_W / 2.0, apsl1_H / 2.0, apsl1_L / 2.0);
1038 G4Tubs* geo_apsl1_hole = new G4Tubs(geo_apsl1_hole_name, 0.0, apsl1_hole_R, apsl1_hole_D / 2.0, 0.0, 2.0 * M_PI);
1039 G4SubtractionSolid* geo_apsl1 = new G4SubtractionSolid(geo_apsl1_name, geo_apsl1_box, geo_apsl1_hole, transform_apsl1_hole);
1040
1041 APSL1.geo = geo_apsl1;
1042
1043 // define logical volume
1044 string strMat_apsl1 = m_config.getParameterStr(prep + "Material");
1045 G4Material* mat_apsl1 = Materials::get(strMat_apsl1);
1046 string logi_apsl1_name = "logi_" + name + "_name";
1047 G4LogicalVolume* logi_apsl1 = new G4LogicalVolume(geo_apsl1, mat_apsl1, logi_apsl1_name);
1048 setColor(*logi_apsl1, "#00CC00");
1049 setVisibility(*logi_apsl1, false);
1050
1051 APSL1.logi = logi_apsl1;
1052
1053 //put volume
1054 string phys_apsl1_name = "phys_" + name + "_name";
1055 new G4PVPlacement(APSL1.transform, APSL1.logi, phys_apsl1_name, &topVolume, false, 0);
1056
1057 // elements[name] = APSL1;
1058
1059 //--------------
1060 // Part 2
1061
1062 FarBeamLineElement APSL2;
1063
1064 //get parameters from .xml file
1065 name = "APSL2";
1066 prep = name + ".";
1067
1068 double apsl2_W = m_config.getParameter(prep + "W") * unitFactor;
1069 double apsl2_H = m_config.getParameter(prep + "H") * unitFactor;
1070 double apsl2_L = m_config.getParameter(prep + "L") * unitFactor;
1071 double apsl2_X0 = m_config.getParameter(prep + "X0") * unitFactor;
1072 double apsl2_Y0 = m_config.getParameter(prep + "Y0") * unitFactor;
1073 double apsl2_Z0 = m_config.getParameter(prep + "Z0") * unitFactor;
1074 double apsl2_hole_R = m_config.getParameter(prep + "holeR") * unitFactor;
1075 double apsl2_hole_D = m_config.getParameter(prep + "holeD") * unitFactor;
1076 double apsl2_hole_dX = m_config.getParameter(prep + "holeDX") * unitFactor;
1077 double apsl2_hole_dY = m_config.getParameter(prep + "holeDY") * unitFactor;
1078 double apsl2_hole_dZ = m_config.getParameter(prep + "holeDZ") * unitFactor;
1079 double apsl2_PHI = m_config.getParameter(prep + "PHI");
1080
1081 // transformations
1082 APSL2.transform = G4Translate3D(apsl2_X0, apsl2_Y0, apsl2_Z0);
1083 APSL2.transform = APSL2.transform * G4RotateY3D(apsl2_PHI / Unit::rad);;
1084
1085 G4Transform3D transform_apsl2_hole = G4Translate3D(apsl2_hole_dX, apsl2_hole_dY, apsl2_hole_dZ);
1086
1087 //define geometry
1088 string geo_apsl2_box_name = "geo_" + name + "_box_name";
1089 string geo_apsl2_hole_name = "geo_" + name + "_hole_name";
1090 string geo_apsl2_name = "geo_" + name + "_name";
1091
1092 G4Box* geo_apsl2_box = new G4Box(geo_apsl2_box_name, apsl2_W / 2.0, apsl2_H / 2.0, apsl2_L / 2.0);
1093 G4Tubs* geo_apsl2_hole = new G4Tubs(geo_apsl2_hole_name, 0.0, apsl2_hole_R, apsl2_hole_D / 2.0, 0.0, 2.0 * M_PI);
1094 G4SubtractionSolid* geo_apsl2 = new G4SubtractionSolid(geo_apsl2_name, geo_apsl2_box, geo_apsl2_hole, transform_apsl2_hole);
1095
1096 APSL2.geo = geo_apsl2;
1097
1098 // define logical volume
1099 string strMat_apsl2 = m_config.getParameterStr(prep + "Material");
1100 G4Material* mat_apsl2 = Materials::get(strMat_apsl2);
1101 string logi_apsl2_name = "logi_" + name + "_name";
1102 G4LogicalVolume* logi_apsl2 = new G4LogicalVolume(geo_apsl2, mat_apsl2, logi_apsl2_name);
1103 setColor(*logi_apsl2, "#00CC00");
1104 setVisibility(*logi_apsl2, false);
1105
1106 APSL2.logi = logi_apsl2;
1107
1108 //put volume
1109 string phys_apsl2_name = "phys_" + name + "_name";
1110 new G4PVPlacement(APSL2.transform, APSL2.logi, phys_apsl2_name, &topVolume, false, 0);
1111
1112 // elements[name] = APSL2;
1113
1114
1115 //--------------
1116 //- Additional polyethilene shield right (forward)
1117 //- Fills gap between PolyShield and QCS
1118
1119 // Consists of two disjoined parts
1120 // Part 1
1121
1122 FarBeamLineElement APSR1;
1123
1124 //get parameters from .xml file
1125 name = "APSR1";
1126 prep = name + ".";
1127
1128 double apsr1_W = m_config.getParameter(prep + "W") * unitFactor;
1129 double apsr1_H = m_config.getParameter(prep + "H") * unitFactor;
1130 double apsr1_L = m_config.getParameter(prep + "L") * unitFactor;
1131 double apsr1_X0 = m_config.getParameter(prep + "X0") * unitFactor;
1132 double apsr1_Y0 = m_config.getParameter(prep + "Y0") * unitFactor;
1133 double apsr1_Z0 = m_config.getParameter(prep + "Z0") * unitFactor;
1134 double apsr1_hole_R = m_config.getParameter(prep + "holeR") * unitFactor;
1135 double apsr1_hole_D = m_config.getParameter(prep + "holeD") * unitFactor;
1136 double apsr1_hole_dX = m_config.getParameter(prep + "holeDX") * unitFactor;
1137 double apsr1_hole_dY = m_config.getParameter(prep + "holeDY") * unitFactor;
1138 double apsr1_hole_dZ = m_config.getParameter(prep + "holeDZ") * unitFactor;
1139 double apsr1_PHI = m_config.getParameter(prep + "PHI");
1140
1141 // transformations
1142 APSR1.transform = G4Translate3D(apsr1_X0, apsr1_Y0, apsr1_Z0);
1143 APSR1.transform = APSR1.transform * G4RotateY3D(apsr1_PHI / Unit::rad);;
1144
1145 G4Transform3D transform_apsr1_hole = G4Translate3D(apsr1_hole_dX, apsr1_hole_dY, apsr1_hole_dZ);
1146
1147 //define geometry
1148 string geo_apsr1_box_name = "geo_" + name + "_box_name";
1149 string geo_apsr1_hole_name = "geo_" + name + "_hole_name";
1150 string geo_apsr1_name = "geo_" + name + "_name";
1151
1152 G4Box* geo_apsr1_box = new G4Box(geo_apsr1_box_name, apsr1_W / 2.0, apsr1_H / 2.0, apsr1_L / 2.0);
1153 G4Tubs* geo_apsr1_hole = new G4Tubs(geo_apsr1_hole_name, 0.0, apsr1_hole_R, apsr1_hole_D / 2.0, 0.0, 2.0 * M_PI);
1154 G4SubtractionSolid* geo_apsr1 = new G4SubtractionSolid(geo_apsr1_name, geo_apsr1_box, geo_apsr1_hole, transform_apsr1_hole);
1155
1156 APSR1.geo = geo_apsr1;
1157
1158 // define logical volume
1159 string strMat_apsr1 = m_config.getParameterStr(prep + "Material");
1160 G4Material* mat_apsr1 = Materials::get(strMat_apsr1);
1161 string logi_apsr1_name = "logi_" + name + "_name";
1162 G4LogicalVolume* logi_apsr1 = new G4LogicalVolume(geo_apsr1, mat_apsr1, logi_apsr1_name);
1163 setColor(*logi_apsr1, "#00CC00");
1164 setVisibility(*logi_apsr1, false);
1165
1166 APSR1.logi = logi_apsr1;
1167
1168 //put volume
1169 string phys_apsr1_name = "phys_" + name + "_name";
1170 new G4PVPlacement(APSR1.transform, APSR1.logi, phys_apsr1_name, &topVolume, false, 0);
1171
1172 // elements[name] = APSR1;
1173
1174 //--------------
1175 // Part 2
1176
1177 FarBeamLineElement APSR2;
1178
1179 //get parameters from .xml file
1180 name = "APSR2";
1181 prep = name + ".";
1182
1183 double apsr2_W = m_config.getParameter(prep + "W") * unitFactor;
1184 double apsr2_H = m_config.getParameter(prep + "H") * unitFactor;
1185 double apsr2_L = m_config.getParameter(prep + "L") * unitFactor;
1186 double apsr2_X0 = m_config.getParameter(prep + "X0") * unitFactor;
1187 double apsr2_Y0 = m_config.getParameter(prep + "Y0") * unitFactor;
1188 double apsr2_Z0 = m_config.getParameter(prep + "Z0") * unitFactor;
1189 double apsr2_hole_R = m_config.getParameter(prep + "holeR") * unitFactor;
1190 double apsr2_hole_D = m_config.getParameter(prep + "holeD") * unitFactor;
1191 double apsr2_hole_dX = m_config.getParameter(prep + "holeDX") * unitFactor;
1192 double apsr2_hole_dY = m_config.getParameter(prep + "holeDY") * unitFactor;
1193 double apsr2_hole_dZ = m_config.getParameter(prep + "holeDZ") * unitFactor;
1194 double apsr2_PHI = m_config.getParameter(prep + "PHI");
1195
1196 // transformations
1197 APSR2.transform = G4Translate3D(apsr2_X0, apsr2_Y0, apsr2_Z0);
1198 APSR2.transform = APSR2.transform * G4RotateY3D(apsr2_PHI / Unit::rad);;
1199
1200 G4Transform3D transform_apsr2_hole = G4Translate3D(apsr2_hole_dX, apsr2_hole_dY, apsr2_hole_dZ);
1201
1202 //define geometry
1203 string geo_apsr2_box_name = "geo_" + name + "_box_name";
1204 string geo_apsr2_hole_name = "geo_" + name + "_hole_name";
1205 string geo_apsr2_name = "geo_" + name + "_name";
1206
1207 G4Box* geo_apsr2_box = new G4Box(geo_apsr2_box_name, apsr2_W / 2.0, apsr2_H / 2.0, apsr2_L / 2.0);
1208 G4Tubs* geo_apsr2_hole = new G4Tubs(geo_apsr2_hole_name, 0.0, apsr2_hole_R, apsr2_hole_D / 2.0, 0.0, 2.0 * M_PI);
1209 G4SubtractionSolid* geo_apsr2 = new G4SubtractionSolid(geo_apsr2_name, geo_apsr2_box, geo_apsr2_hole, transform_apsr2_hole);
1210
1211 APSR2.geo = geo_apsr2;
1212
1213 // define logical volume
1214 string strMat_apsr2 = m_config.getParameterStr(prep + "Material");
1215 G4Material* mat_apsr2 = Materials::get(strMat_apsr2);
1216 string logi_apsr2_name = "logi_" + name + "_name";
1217 G4LogicalVolume* logi_apsr2 = new G4LogicalVolume(geo_apsr2, mat_apsr2, logi_apsr2_name);
1218 setColor(*logi_apsr2, "#00CC00");
1219 setVisibility(*logi_apsr2, false);
1220
1221 APSR2.logi = logi_apsr2;
1222
1223 //put volume
1224 string phys_apsr2_name = "phys_" + name + "_name";
1225 new G4PVPlacement(APSR2.transform, APSR2.logi, phys_apsr2_name, &topVolume, false, 0);
1226
1227 // elements[name] = APSR2;
1228
1229
1230 //---------------------------
1231 // dose calculation
1232 //---------------------------
1233 //if (elements.count("ACSL")) elements["ACSL"].logi->SetSensitiveDetector(new BkgSensitiveDetector("IR", 2001));
1234 //if (elements.count("ACSR1")) elements["ACSR1"].logi->SetSensitiveDetector(new BkgSensitiveDetector("IR", 2002));
1235 //if (elements.count("ACSR2")) elements["ACSR2"].logi->SetSensitiveDetector(new BkgSensitiveDetector("IR", 2003));
1236 //if (elements.count("APSL1")) elements["APSL1"].logi->SetSensitiveDetector(new BkgSensitiveDetector("IR", 2004));
1237 //if (elements.count("APSL2")) elements["APSL2"].logi->SetSensitiveDetector(new BkgSensitiveDetector("IR", 2005));
1238 //if (elements.count("APSR1")) elements["APSR1"].logi->SetSensitiveDetector(new BkgSensitiveDetector("IR", 2006));
1239 //if (elements.count("APSR2")) elements["APSR2"].logi->SetSensitiveDetector(new BkgSensitiveDetector("IR", 2007));
1240 }
1241 }
1242 }
1244}
1245
Belle2::BkgSensitiveDetector
The Class for BeamBackground Sensitive Detector.
Definition BkgSensitiveDetector.h:25
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::GeoFarBeamLineCreator::m_config
FarBeamLineGeo m_config
geometry parameters object
Definition GeoFarBeamLineCreator.h:118
Belle2::ir::GeoFarBeamLineCreator::GeoFarBeamLineCreator
GeoFarBeamLineCreator()
Constructor of the GeoFarBeamLineCreator class.
Definition GeoFarBeamLineCreator.cc:60
Belle2::ir::GeoFarBeamLineCreator::~GeoFarBeamLineCreator
virtual ~GeoFarBeamLineCreator()
The destructor of the GeoFarBeamLineCreator class.
Definition GeoFarBeamLineCreator.cc:65
Belle2::ir::GeoFarBeamLineCreator::createGeometry
void createGeometry(G4LogicalVolume &topVolume, geometry::GeometryTypes type)
Create detector geometry.
Definition GeoFarBeamLineCreator.cc:70
Belle2::ir::GeoFarBeamLineCreator::m_sensitive
SensitiveDetector * m_sensitive
Sensitive detector.
Definition GeoFarBeamLineCreator.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
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::FarBeamLineElement
The struct for FarBeamLineElement.
Definition GeoFarBeamLineCreator.h:30
Belle2::ir::FarBeamLineElement::logi
G4LogicalVolume * logi
Logical volume.
Definition GeoFarBeamLineCreator.h:36
Belle2::ir::FarBeamLineElement::transform
G4Transform3D transform
Transformation.
Definition GeoFarBeamLineCreator.h:32