Belle II Software  release-05-01-25
GeoFarBeamLineCreator.cc
1 /**************************************************************************
2  * BASF2 (Belle Analysis Framework 2) *
3  * Copyright(C) 2010 - Belle II Collaboration *
4  * *
5  * Author: The Belle II Collaboration *
6  * Contributors: Hiroyuki Nakayama, Luka Santelj *
7  * *
8  * This software is provided "as is" without any warranty. *
9  **************************************************************************/
10 
11 #include <ir/geometry/GeoFarBeamLineCreator.h>
12 
13 #include <geometry/Materials.h>
14 #include <geometry/CreatorFactory.h>
15 #include <geometry/utilities.h>
16 #include <framework/gearbox/Unit.h>
17 #include <ir/simulation/SensitiveDetector.h>
18 #include <simulation/background/BkgSensitiveDetector.h>
19 
20 #include <cmath>
21 #include <boost/format.hpp>
22 #include <boost/foreach.hpp>
23 #include <boost/algorithm/string.hpp>
24 
25 #include <G4LogicalVolume.hh>
26 #include <G4PVPlacement.hh>
27 
28 //Shapes
29 #include <G4Box.hh>
30 #include <G4Tubs.hh>
31 #include <G4Torus.hh>
32 #include <G4Polycone.hh>
33 #include <G4IntersectionSolid.hh>
34 #include <G4SubtractionSolid.hh>
35 #include <G4UserLimits.hh>
36 
37 using namespace std;
38 using namespace boost;
39 
40 namespace Belle2 {
47  using namespace geometry;
48 
49  namespace ir {
50 
51  //-----------------------------------------------------------------
52  // Register the Creator
53  //-----------------------------------------------------------------
54 
55  geometry::CreatorFactory<GeoFarBeamLineCreator> GeoFarBeamLineFactory("FarBeamLineCreator");
56 
57  //-----------------------------------------------------------------
58  // Implementation
59  //-----------------------------------------------------------------
60 
61  GeoFarBeamLineCreator::GeoFarBeamLineCreator()
62  {
63  m_sensitive = new SensitiveDetector();
64  }
65 
66  GeoFarBeamLineCreator::~GeoFarBeamLineCreator()
67  {
68  delete m_sensitive;
69  }
70 
71  void GeoFarBeamLineCreator::createGeometry(G4LogicalVolume& topVolume, GeometryTypes)
72  {
73 
74  const int N = 2;
75 
76  double stepMax = 5.0 * Unit::mm;
77  int flag_limitStep = int(m_config.getParameter("LimitStepLength"));
78 
79 
80  //double unitFactor = 10.0;
81  const double unitFactor = Unit::cm / Unit::mm;
82 
83  map<string, FarBeamLineElement> elements;
84 
85 
86  //--------------
87  //- limits
88 
89  //--------------
90  //- TubeR
91 
92  FarBeamLineElement tubeR;
93 
94  //get parameters from .xml file
95  std::string prep = "TubeR.";
96 
97  int TubeR_N = int(m_config.getParameter(prep + "N"));
98 
99  std::vector<double> TubeR_Z(TubeR_N);
100  std::vector<double> TubeR_R(TubeR_N);
101  std::vector<double> TubeR_r(TubeR_N);
102 
103  for (int i = 0; i < TubeR_N; ++i) {
104  ostringstream ossZID;
105  ossZID << "Z" << i;
106 
107  ostringstream ossRID;
108  ossRID << "R" << i;
109 
110  ostringstream ossrID;
111  ossrID << "r" << i;
112 
113  TubeR_Z[i] = m_config.getParameter(prep + ossZID.str()) * unitFactor;
114  TubeR_R[i] = m_config.getParameter(prep + ossRID.str()) * unitFactor;
115  TubeR_r[i] = m_config.getParameter(prep + ossrID.str(), 0.0) * unitFactor;
116  }
117 
118  tubeR.transform = G4Translate3D(0.0, 0.0, 0.0);
119 
120  //define geometry
121  tubeR.geo = new G4Polycone("geo_TubeR_name", 0.0, 2 * M_PI, TubeR_N, &(TubeR_Z[0]), &(TubeR_r[0]), &(TubeR_R[0]));
122 
123  elements["TubeR"] = tubeR;
124 
125  //--------------
126  //- TubeL
127 
128  FarBeamLineElement tubeL;
129 
130  //get parameters from .xml file
131  prep = "TubeL.";
132 
133  int TubeL_N = int(m_config.getParameter(prep + "N"));
134 
135  std::vector<double> TubeL_Z(TubeL_N);
136  std::vector<double> TubeL_R(TubeL_N);
137  std::vector<double> TubeL_r(TubeL_N);
138 
139  for (int i = 0; i < TubeL_N; ++i) {
140  ostringstream ossZID;
141  ossZID << "Z" << i;
142 
143  ostringstream ossRID;
144  ossRID << "R" << i;
145 
146  ostringstream ossrID;
147  ossrID << "r" << i;
148 
149  TubeL_Z[i] = m_config.getParameter(prep + ossZID.str()) * unitFactor;
150  TubeL_R[i] = m_config.getParameter(prep + ossRID.str()) * unitFactor;
151  TubeL_r[i] = m_config.getParameter(prep + ossrID.str(), 0.0) * unitFactor;
152  }
153 
154  tubeL.transform = G4Translate3D(0.0, 0.0, 0.0);
155 
156  //define geometry
157  tubeL.geo = new G4Polycone("geo_TubeL_name", 0.0, 2 * M_PI, TubeL_N, &(TubeL_Z[0]), &(TubeL_r[0]), &(TubeL_R[0]));
158 
159  elements["TubeL"] = tubeL;
160 
161  std::vector<double> zero_r(N, 0.);
162 
163  std::vector<std::string> straightSections;
164  boost::split(straightSections, m_config.getParameterStr("Straight"), boost::is_any_of(" "));
165  for (const auto& name : straightSections) {
166  //--------------
167  //- Create straight element
168 
169  prep = name + ".";
170  string type = m_config.getParameterStr(prep + "type");
171 
172 
173  FarBeamLineElement polycone;
174 
175  std::vector<double> Polycone_Z(N);
176  std::vector<double> Polycone_R(N);
177  std::vector<double> Polycone_r(N);
178  Polycone_Z[0] = 0;
179  Polycone_Z[1] = m_config.getParameter(prep + "L") * unitFactor;
180  Polycone_R[0] = m_config.getParameter(prep + "R") * unitFactor;
181  Polycone_R[1] = m_config.getParameter(prep + "R") * unitFactor;
182  Polycone_r[0] = m_config.getParameter(prep + "r") * unitFactor;
183  Polycone_r[1] = m_config.getParameter(prep + "r") * unitFactor;
184 
185  double Polycone_X0 = m_config.getParameter(prep + "X0") * unitFactor;
186  double Polycone_Z0 = m_config.getParameter(prep + "Z0") * unitFactor;
187  double Polycone_PHI = m_config.getParameter(prep + "PHI");
188 
189  polycone.transform = G4Translate3D(Polycone_X0, 0.0, Polycone_Z0);
190  polycone.transform = polycone.transform * G4RotateY3D(Polycone_PHI / Unit::rad);
191 
192  //define geometry
193  string subtract = m_config.getParameterStr(prep + "Subtract", "");
194  string intersect = m_config.getParameterStr(prep + "Intersect", "");
195 
196  string geo_polyconexx_name = "geo_" + name + "xx_name";
197  string geo_polyconex_name = "geo_" + name + "x_name";
198  string geo_polycone_name = "geo_" + name + "_name";
199 
200  G4VSolid* geo_polyconexx(NULL), *geo_polycone(NULL);
201 
202  if (subtract != "" || intersect != "")
203  if (type == "pipe") // for pipes inner space will be created as vacuum
204  geo_polyconexx = new G4Polycone(geo_polyconexx_name, 0.0, 2 * M_PI, N, &(Polycone_Z[0]), &(zero_r[0]), &(Polycone_R[0]));
205  else
206  geo_polyconexx = new G4Polycone(geo_polyconexx_name, 0.0, 2 * M_PI, N, &(Polycone_Z[0]), &(Polycone_r[0]), &(Polycone_R[0]));
207  else if (type == "pipe") // for pipes inner space will be created as vacuum
208  geo_polycone = new G4Polycone(geo_polycone_name, 0.0, 2 * M_PI, N, &(Polycone_Z[0]), &(zero_r[0]), &(Polycone_R[0]));
209  else
210  geo_polycone = new G4Polycone(geo_polycone_name, 0.0, 2 * M_PI, N, &(Polycone_Z[0]), &(Polycone_r[0]), &(Polycone_R[0]));
211 
212 
213  if (subtract != "" && intersect != "") {
214  G4VSolid* geo_polyconex = new G4SubtractionSolid(geo_polyconex_name, geo_polyconexx, elements[subtract].geo,
215  polycone.transform.inverse()*elements[subtract].transform);
216  geo_polycone = new G4IntersectionSolid(geo_polycone_name, geo_polyconex, elements[intersect].geo,
217  polycone.transform.inverse()*elements[intersect].transform);
218  } else if (subtract != "")
219  geo_polycone = new G4SubtractionSolid(geo_polycone_name, geo_polyconexx, elements[subtract].geo,
220  polycone.transform.inverse()*elements[subtract].transform);
221  else if (intersect != "")
222  geo_polycone = new G4IntersectionSolid(geo_polycone_name, geo_polyconexx, elements[intersect].geo,
223  polycone.transform.inverse()*elements[intersect].transform);
224 
225  polycone.geo = geo_polycone;
226 
227  // define logical volume
228  string strMat_polycone = m_config.getParameterStr(prep + "Material");
229  G4Material* mat_polycone = Materials::get(strMat_polycone);
230  string logi_polycone_name = "logi_" + name + "_name";
231  G4LogicalVolume* logi_polycone = new G4LogicalVolume(polycone.geo, mat_polycone, logi_polycone_name);
232  setColor(*logi_polycone, "#CC0000");
233  setVisibility(*logi_polycone, false);
234 
235  //put volume
236  string phys_polycone_name = "phys_" + name + "_name";
237  new G4PVPlacement(polycone.transform, logi_polycone, phys_polycone_name, &topVolume, false, 0);
238 
239  elements[name] = polycone;
240 
241  double sum = 0.0;
242  for (int i = 0; i < N; ++i)
243  sum += Polycone_r[i]; // check that there is a space inside a pipe
244  if (type == "pipe" && sum != 0) { // add vacuum inside a pipe
245 
246  FarBeamLineElement vacuum;
247 
248  string nameVac = name + "Vac";
249 
250  //define geometry
251  string geo_vacuumxx_name = "geo_" + nameVac + "xx_name";
252  string geo_vacuum_name = "geo_" + nameVac + "_name";
253 
254  G4VSolid* geo_vacuumxx, *geo_vacuum;
255 
256  geo_vacuumxx = new G4Polycone(geo_vacuumxx_name, 0.0, 2 * M_PI, N, &(Polycone_Z[0]), &(zero_r[0]), &(Polycone_r[0]));
257  geo_vacuum = new G4IntersectionSolid(geo_vacuumxx_name, geo_vacuumxx, geo_polycone);
258 
259  vacuum.geo = geo_vacuum;
260  vacuum.transform = polycone.transform;
261 
262  // define logical volume
263  G4Material* mat_vacuum = Materials::get("Vacuum");
264  string logi_vacuum_name = "logi_" + nameVac + "_name";
265  G4LogicalVolume* logi_vacuum = new G4LogicalVolume(vacuum.geo, mat_vacuum, logi_vacuum_name);
266  if (flag_limitStep) logi_vacuum->SetUserLimits(new G4UserLimits(stepMax));
267  setColor(*logi_vacuum, "#000000");
268  setVisibility(*logi_vacuum, false);
269 
270  //put volume
271  string phys_vacuum_name = "phys_" + nameVac + "_name";
272  //new G4PVPlacement(vacuum.transform, logi_vacuum, phys_vacuum_name, &topVolume, false, 0);
273  new G4PVPlacement(0, G4ThreeVector(0, 0, 0), logi_vacuum, phys_vacuum_name, logi_polycone, false, 0);
274 
275  elements[nameVac] = vacuum;
276  }
277  }
278 
279 
280  std::vector<std::string> bendingSections;
281  boost::split(bendingSections, m_config.getParameterStr("Bending"), boost::is_any_of(" "));
282  for (const auto& name : bendingSections) {
283  //--------------
284  //- Create torus element
285 
286  prep = name + ".";
287  string type = m_config.getParameterStr(prep + "type");
288 
289  FarBeamLineElement torus;
290 
291  double torus_r = m_config.getParameter(prep + "r") * unitFactor;
292  double torus_R = m_config.getParameter(prep + "R") * unitFactor;
293  double torus_RT = m_config.getParameter(prep + "RT") * unitFactor;
294  double torus_X0 = m_config.getParameter(prep + "X0") * unitFactor;
295  double torus_Z0 = m_config.getParameter(prep + "Z0") * unitFactor;
296  double torus_SPHI = m_config.getParameter(prep + "SPHI");
297  double torus_DPHI = m_config.getParameter(prep + "DPHI");
298 
299  torus.transform = G4Translate3D(torus_X0, 0.0, torus_Z0);
300  torus.transform = torus.transform * G4RotateX3D(M_PI / 2 / Unit::rad);
301 
302  //define geometry
303  string subtract = m_config.getParameterStr(prep + "Subtract", "");
304  string intersect = m_config.getParameterStr(prep + "Intersect", "");
305 
306  string geo_torusxx_name = "geo_" + name + "xx_name";
307  string geo_torusx_name = "geo_" + name + "x_name";
308  string geo_torus_name = "geo_" + name + "_name";
309 
310  G4VSolid* geo_torusxx(NULL), *geo_torus(NULL);
311 
312  if (subtract != "" || intersect != "")
313  if (type == "pipe") // for pipes inner space will be created as vacuum
314  geo_torusxx = new G4Torus(geo_torusxx_name, 0, torus_R, torus_RT, torus_SPHI, torus_DPHI);
315  else
316  geo_torusxx = new G4Torus(geo_torusxx_name, torus_r, torus_R, torus_RT, torus_SPHI, torus_DPHI);
317  else if (type == "pipe") // for pipes inner space will be created as vacuum
318  geo_torus = new G4Torus(geo_torus_name, 0, torus_R, torus_RT, torus_SPHI, torus_DPHI);
319  else
320  geo_torus = new G4Torus(geo_torus_name, torus_r, torus_R, torus_RT, torus_SPHI, torus_DPHI);
321 
322  if (subtract != "" && intersect != "") {
323  G4VSolid* geo_torusx = new G4SubtractionSolid(geo_torusx_name, geo_torusxx, elements[subtract].geo,
324  torus.transform.inverse()*elements[subtract].transform);
325  geo_torus = new G4IntersectionSolid(geo_torus_name, geo_torusx, elements[intersect].geo,
326  torus.transform.inverse()*elements[intersect].transform);
327  } else if (subtract != "")
328  geo_torus = new G4SubtractionSolid(geo_torus_name, geo_torusxx, elements[subtract].geo,
329  torus.transform.inverse()*elements[subtract].transform);
330  else if (intersect != "")
331  geo_torus = new G4IntersectionSolid(geo_torus_name, geo_torusxx, elements[intersect].geo,
332  torus.transform.inverse()*elements[intersect].transform);
333 
334  torus.geo = geo_torus;
335 
336  // define logical volume
337  string strMat_torus = m_config.getParameterStr(prep + "Material");
338  G4Material* mat_torus = Materials::get(strMat_torus);
339  string logi_torus_name = "logi_" + name + "_name";
340  G4LogicalVolume* logi_torus = new G4LogicalVolume(torus.geo, mat_torus, logi_torus_name);
341  setColor(*logi_torus, "#CC0000");
342  setVisibility(*logi_torus, false);
343 
344  //put volume
345  string phys_torus_name = "phys_" + name + "_name";
346  new G4PVPlacement(torus.transform, logi_torus, phys_torus_name, &topVolume, false, 0);
347 
348  elements[name] = torus;
349 
350  if (type == "pipe" && torus_r != 0) { // add vacuum inside a pipe
351 
352  FarBeamLineElement vacuum;
353 
354  string nameVac = name + "Vac";
355 
356  //define geometry
357  string geo_vacuumxx_name = "geo_" + nameVac + "xx_name";
358  string geo_vacuum_name = "geo_" + nameVac + "_name";
359 
360  G4VSolid* geo_vacuumxx, *geo_vacuum;
361 
362  geo_vacuumxx = new G4Torus(geo_vacuumxx_name, 0.0, torus_r, torus_RT, torus_SPHI, torus_DPHI);
363  geo_vacuum = new G4IntersectionSolid(geo_vacuum_name, geo_vacuumxx, geo_torus);
364 
365  vacuum.geo = geo_vacuum;
366  vacuum.transform = torus.transform;
367 
368  // define logical volume
369  G4Material* mat_vacuum = Materials::get("Vacuum");
370  string logi_vacuum_name = "logi_" + nameVac + "_name";
371  G4LogicalVolume* logi_vacuum = new G4LogicalVolume(vacuum.geo, mat_vacuum, logi_vacuum_name);
372  if (flag_limitStep) logi_vacuum->SetUserLimits(new G4UserLimits(stepMax));
373  setColor(*logi_vacuum, "#000000");
374  setVisibility(*logi_vacuum, false);
375 
376  //put volume
377  string phys_vacuum_name = "phys_" + nameVac + "_name";
378  //new G4PVPlacement(vacuum.transform, logi_vacuum, phys_vacuum_name, &topVolume, false, 0);
379  new G4PVPlacement(0, G4ThreeVector(0, 0, 0), logi_vacuum, phys_vacuum_name, logi_torus, false, 0);
380 
381  elements[nameVac] = vacuum;
382  }
383  }
384 
385 
386  //--------------
387  //- concrete wall
388 
389  //--------------
390  //- GateShield (gate shield)
391 
392  //get parameters from .xml file
393  prep = "GateShield.";
394 
395  double GateShield_X = m_config.getParameter(prep + "X") * unitFactor;
396  double GateShield_Y = m_config.getParameter(prep + "Y") * unitFactor;
397  double GateShield_Z = m_config.getParameter(prep + "Z") * unitFactor;
398  double TUN_X = m_config.getParameter(prep + "TUNX") * unitFactor;
399  double TUN_Y = m_config.getParameter(prep + "TUNY") * unitFactor;
400  double DET_Z = m_config.getParameter(prep + "DETZ") * unitFactor;
401  double DET_DZ = m_config.getParameter(prep + "DETDZ") * unitFactor;
402  double ROT = m_config.getParameter(prep + "ROT");
403 
404  G4Transform3D transform_DET = G4Translate3D(0.0, 0.0, DET_DZ);
405  G4Transform3D transform_ROT = G4Translate3D(0.0, 0.0, 0.0);
406  transform_ROT = transform_ROT * G4RotateY3D(ROT / Unit::rad);
407 
408  //define geometry
409  // wall is made from the box by excluding spaces for detector and tunnel
410  G4Box* geo_GateShieldxx = new G4Box("geo_GateShieldxx_name", GateShield_X, GateShield_Y, GateShield_Z);
411  G4Box* geo_TUN = new G4Box("geo_TUN_name", TUN_X, TUN_Y, GateShield_Z);
412  G4SubtractionSolid* geo_GateShieldx = new G4SubtractionSolid("geo_GateShieldx_name", geo_GateShieldxx, geo_TUN);
413  G4Box* geo_DET = new G4Box("geo_DET_name", GateShield_X, GateShield_Y, DET_Z);
414  G4SubtractionSolid* geo_GateShield = new G4SubtractionSolid("geo_GateShield_name", geo_GateShieldx, geo_DET, transform_DET);
415 
416  string strMat_GateShield = m_config.getParameterStr(prep + "Material");
417  G4Material* mat_GateShield = Materials::get(strMat_GateShield);
418  G4LogicalVolume* logi_GateShield = new G4LogicalVolume(geo_GateShield, mat_GateShield, "logi_GateShield_name");
419 
420  //put volume
421  setColor(*logi_GateShield, "#CC0000");
422  //setVisibility(*logi_GateShield, false);
423  new G4PVPlacement(transform_ROT, logi_GateShield, "phys_GateShield_name", &topVolume, false, 0);
424 
425 
426 
427  //--------------
428  //- Tube (virtual tube for radiation level study)
429 
430  //define geometry
431  G4Tubs* geo_Tube = new G4Tubs("geo_Tube_name", 3995 * CLHEP::mm, 4000 * CLHEP::mm, 29 * CLHEP::m, 0. * CLHEP::deg, 360.*CLHEP::deg);
432  G4Material* mat_Tube = Materials::get("G4_Si");
433  G4LogicalVolume* logi_Tube = new G4LogicalVolume(geo_Tube, mat_Tube, "logi_Tube_name");
434 
435  //put volume
436  setColor(*logi_Tube, "#CC0000");
437  //setVisibility(*logi_Tube, false);
438  bool radiation_study = false;
439  // cppcheck-suppress knownConditionTrueFalse
440  if (radiation_study) {
441  new G4PVPlacement(transform_ROT, logi_Tube, "phys_Tube_name", &topVolume, false, 0);
442  }
443 
444 
445  //--------------
446  //- polyethylene shields
447 
448  //--------------
449  //- PolyShieldR
450 
451  //get parameters from .xml file
452  prep = "PolyShieldR.";
453 
454  double PolyShieldR_Xp = m_config.getParameter(prep + "Xp") * unitFactor;
455  double PolyShieldR_Xm = m_config.getParameter(prep + "Xm") * unitFactor;
456  double PolyShieldR_Y = m_config.getParameter(prep + "Y") * unitFactor;
457  double PolyShieldR_Z = m_config.getParameter(prep + "Z") * unitFactor;
458  double PolyShieldR_DZ = m_config.getParameter(prep + "DZ") * unitFactor;
459  double PolyShieldR_r = m_config.getParameter(prep + "r") * unitFactor;
460  double PolyShieldR_dx = m_config.getParameter(prep + "dx") * unitFactor;
461 
462  double PolyShieldR_X = (PolyShieldR_Xp + PolyShieldR_Xm) / 2;
463  G4Transform3D transform_polyShieldR = G4Translate3D((PolyShieldR_Xp - PolyShieldR_Xm) / 2, 0.0, PolyShieldR_DZ);
464  G4Transform3D transform_polyShieldR_Hole = G4Translate3D(PolyShieldR_dx, 0.0, 0.0);
465 
466  //define geometry
467  G4Box* geo_polyShieldRx = new G4Box("geo_polyShieldRx_name", PolyShieldR_X, PolyShieldR_Y, PolyShieldR_Z);
468  G4Tubs* geo_polyShieldR_Hole = new G4Tubs("geo_polyShieldRxx_name", 0 * CLHEP::mm, PolyShieldR_r, PolyShieldR_Z, 0. * CLHEP::deg,
469  360.*CLHEP::deg);
470  G4SubtractionSolid* geo_polyShieldR
471  = new G4SubtractionSolid("geo_polyShieldR_name", geo_polyShieldRx, geo_polyShieldR_Hole, transform_polyShieldR_Hole);
472 
473  string strMat_polyShieldR = m_config.getParameterStr(prep + "Material");
474  G4Material* mat_polyShieldR = Materials::get(strMat_polyShieldR);
475  G4LogicalVolume* logi_polyShieldR = new G4LogicalVolume(geo_polyShieldR, mat_polyShieldR, "logi_polyShieldR_name");
476 
477  //put volume
478  setColor(*logi_polyShieldR, "#0000CC");
479  //setVisibility(*logi_polyShieldL, false);
480  new G4PVPlacement(transform_polyShieldR, logi_polyShieldR, "phys_polyShieldR_name", &topVolume, false, 0);
481 
482  //--------------
483  //- PolyShieldL
484 
485  //get parameters from .xml file
486  prep = "PolyShieldL.";
487 
488  double PolyShieldL_Xp = m_config.getParameter(prep + "Xp") * unitFactor;
489  double PolyShieldL_Xm = m_config.getParameter(prep + "Xm") * unitFactor;
490  double PolyShieldL_Y = m_config.getParameter(prep + "Y") * unitFactor;
491  double PolyShieldL_Z = m_config.getParameter(prep + "Z") * unitFactor;
492  double PolyShieldL_DZ = m_config.getParameter(prep + "DZ") * unitFactor;
493  double PolyShieldL_r = m_config.getParameter(prep + "r") * unitFactor;
494  double PolyShieldL_dx = m_config.getParameter(prep + "dx") * unitFactor;
495 
496  double PolyShieldL_X = (PolyShieldL_Xp + PolyShieldL_Xm) / 2;
497  G4Transform3D transform_polyShieldL = G4Translate3D((PolyShieldL_Xp - PolyShieldL_Xm) / 2, 0.0, PolyShieldL_DZ);
498  G4Transform3D transform_polyShieldL_Hole = G4Translate3D(PolyShieldL_dx, 0.0, 0.0);
499 
500  //define geometry
501  G4Box* geo_polyShieldLxx = new G4Box("geo_polyShieldLxx_name", PolyShieldL_X, PolyShieldL_Y, PolyShieldL_Z);
502  G4Tubs* geo_polyShieldL_Hole = new G4Tubs("geo_polyShieldLxxx_name", 0 * CLHEP::mm, PolyShieldL_r, PolyShieldL_Z, 0. * CLHEP::deg,
503  360.*CLHEP::deg);
504  G4SubtractionSolid* geo_polyShieldLx
505  = new G4SubtractionSolid("geo_polyShieldLx_name", geo_polyShieldLxx, geo_polyShieldL_Hole, transform_polyShieldL_Hole);
506  G4SubtractionSolid* geo_polyShieldL
507  = new G4SubtractionSolid("geo_polyShieldL_name", geo_polyShieldLx, geo_GateShield, transform_polyShieldL.inverse()*transform_ROT);
508 
509  string strMat_polyShieldL = m_config.getParameterStr(prep + "Material");
510  G4Material* mat_polyShieldL = Materials::get(strMat_polyShieldL);
511  G4LogicalVolume* logi_polyShieldL = new G4LogicalVolume(geo_polyShieldL, mat_polyShieldL, "logi_polyShieldL_name");
512 
513  //put volume
514  setColor(*logi_polyShieldL, "#0000CC");
515  //setVisibility(*logi_polyShieldL, false);
516  new G4PVPlacement(transform_polyShieldL, logi_polyShieldL, "phys_polyShieldL_name", &topVolume, false, 0);
517 
518  //--------------
519  //- concrete tunnel-end shields
520 
521  //--------------
522  //- ConcreteShieldR
523 
524  //get parameters from .xml file
525  prep = "ConcreteShieldR.";
526 
527  double ConcreteShieldR_X = m_config.getParameter(prep + "X") * unitFactor;
528  double ConcreteShieldR_Y = m_config.getParameter(prep + "Y") * unitFactor;
529  double ConcreteShieldR_Z = m_config.getParameter(prep + "Z") * unitFactor;
530  double ConcreteShieldR_DZ = m_config.getParameter(prep + "DZ") * unitFactor;
531  double ConcreteShieldR_x = m_config.getParameter(prep + "x") * unitFactor;
532  double ConcreteShieldR_y = m_config.getParameter(prep + "y") * unitFactor;
533  double ConcreteShieldR_dx = m_config.getParameter(prep + "dx") * unitFactor;
534  double ConcreteShieldR_dy = m_config.getParameter(prep + "dy") * unitFactor;
535 
536  G4Transform3D transform_ConcreteShieldR = G4Translate3D(0.0, 0.0, ConcreteShieldR_DZ);
537  transform_ConcreteShieldR = transform_ROT * transform_ConcreteShieldR;
538  G4Transform3D transform_ConcreteShieldR_Hole = G4Translate3D(ConcreteShieldR_dx, ConcreteShieldR_dy, 0.0);
539 
540 
541  //define geometry
542  G4Box* geo_ConcreteShieldRx = new G4Box("geo_ConcreteShieldRx_name", ConcreteShieldR_X, ConcreteShieldR_Y, ConcreteShieldR_Z);
543  G4Box* geo_ConcreteShieldR_Hole = new G4Box("geo_ConcreteShieldRxx_name", ConcreteShieldR_x, ConcreteShieldR_y, ConcreteShieldR_Z);
544  G4SubtractionSolid* geo_ConcreteShieldR = new G4SubtractionSolid("geo_ConcreteShieldR_name", geo_ConcreteShieldRx,
545  geo_ConcreteShieldR_Hole, transform_ConcreteShieldR_Hole);
546 
547  string strMat_ConcreteShieldR = m_config.getParameterStr(prep + "Material");
548  G4Material* mat_ConcreteShieldR = Materials::get(strMat_ConcreteShieldR);
549  G4LogicalVolume* logi_ConcreteShieldR = new G4LogicalVolume(geo_ConcreteShieldR, mat_ConcreteShieldR, "logi_ConcreteShieldR_name");
550 
551  //put volume
552  setColor(*logi_ConcreteShieldR, "#0000CC");
553  //setVisibility(*logi_ConcreteShieldR, false);
554  new G4PVPlacement(transform_ConcreteShieldR, logi_ConcreteShieldR, "phys_ConcreteShieldR_name", &topVolume, false, 0);
555 
556  //--------------
557  //- ConcreteShieldL
558 
559  //get parameters from .xml file
560  prep = "ConcreteShieldL.";
561 
562  double ConcreteShieldL_X = m_config.getParameter(prep + "X") * unitFactor;
563  double ConcreteShieldL_Y = m_config.getParameter(prep + "Y") * unitFactor;
564  double ConcreteShieldL_Z = m_config.getParameter(prep + "Z") * unitFactor;
565  double ConcreteShieldL_DZ = m_config.getParameter(prep + "DZ") * unitFactor;
566  double ConcreteShieldL_x = m_config.getParameter(prep + "x") * unitFactor;
567  double ConcreteShieldL_y = m_config.getParameter(prep + "y") * unitFactor;
568  double ConcreteShieldL_dx = m_config.getParameter(prep + "dx") * unitFactor;
569  double ConcreteShieldL_dy = m_config.getParameter(prep + "dy") * unitFactor;
570 
571  G4Transform3D transform_ConcreteShieldL = G4Translate3D(0.0, 0.0, ConcreteShieldL_DZ);
572  transform_ConcreteShieldL = transform_ROT * transform_ConcreteShieldL;
573  G4Transform3D transform_ConcreteShieldL_Hole = G4Translate3D(ConcreteShieldL_dx, ConcreteShieldL_dy, 0.0);
574 
575  //define geometry
576  G4Box* geo_ConcreteShieldLx = new G4Box("geo_ConcreteShieldLx_name", ConcreteShieldL_X, ConcreteShieldL_Y, ConcreteShieldL_Z);
577  G4Box* geo_ConcreteShieldL_Hole = new G4Box("geo_ConcreteShieldLxx_name", ConcreteShieldL_x, ConcreteShieldL_y, ConcreteShieldL_Z);
578  G4SubtractionSolid* geo_ConcreteShieldL = new G4SubtractionSolid("geo_ConcreteShieldL_name", geo_ConcreteShieldLx,
579  geo_ConcreteShieldL_Hole, transform_ConcreteShieldL_Hole);
580 
581  string strMat_ConcreteShieldL = m_config.getParameterStr(prep + "Material");
582  G4Material* mat_ConcreteShieldL = Materials::get(strMat_ConcreteShieldL);
583  G4LogicalVolume* logi_ConcreteShieldL = new G4LogicalVolume(geo_ConcreteShieldL, mat_ConcreteShieldL, "logi_ConcreteShieldL_name");
584 
585  //put volume
586  setColor(*logi_ConcreteShieldL, "#0000CC");
587  //setVisibility(*logi_ConcreteShieldL, false);
588  new G4PVPlacement(transform_ConcreteShieldL, logi_ConcreteShieldL, "phys_ConcreteShieldL_name", &topVolume, false, 0);
589 
590 
591  //---------------------------
592  // for dose simulation
593  //---------------------------
594 
595  //neutron shield (poly)
596  //logi_polyShieldL->SetSensitiveDetector(new BkgSensitiveDetector("IR", 1001));
597  //logi_polyShieldR->SetSensitiveDetector(new BkgSensitiveDetector("IR", 1002));
598 
599  //additional neutron shield (concrete)
600  //logi_ConcreteShieldL->SetSensitiveDetector(new BkgSensitiveDetector("IR", 1003));
601  //logi_ConcreteShieldR->SetSensitiveDetector(new BkgSensitiveDetector("IR", 1004));
602 
603  //gate shield (concrete)
604  //logi_GateShield->SetSensitiveDetector(new BkgSensitiveDetector("IR", 1005));
605 
606  //virtual material outsire gate-shield
607 
608  // cppcheck-suppress knownConditionTrueFalse
609  if (radiation_study) {
610  logi_Tube->SetSensitiveDetector(new BkgSensitiveDetector("IR", 1006));
611  }
612 
613  }
614  }
616 }
Belle2::geometry::setColor
void setColor(G4LogicalVolume &volume, const std::string &color)
Set the color of a logical volume.
Definition: utilities.cc:107
Belle2::BkgSensitiveDetector
The Class for BeamBackground Sensitive Detector.
Definition: BkgSensitiveDetector.h:34
Belle2::ir::FarBeamLineElement::transform
G4Transform3D transform
Transformation.
Definition: GeoFarBeamLineCreator.h:42
Belle2
Abstract base class for different kinds of events.
Definition: MillepedeAlgorithm.h:19
Belle2::geometry::setVisibility
void setVisibility(G4LogicalVolume &volume, bool visible)
Helper function to quickly set the visibility of a given volume.
Definition: utilities.cc:115
Belle2::ir::SensitiveDetector
The IR Sensitive Detector class.
Definition: SensitiveDetector.h:54
Belle2::ir::FarBeamLineElement
The struct for FarBeamLineElement.
Definition: GeoFarBeamLineCreator.h:40
Belle2::geometry::GeometryTypes
GeometryTypes
Flag indiciating the type of geometry to be used.
Definition: GeometryManager.h:39
Belle2::intersect
int intersect(const TRGCDCLpar &lp1, const TRGCDCLpar &lp2, CLHEP::HepVector &v1, CLHEP::HepVector &v2)
intersection
Definition: Lpar.cc:253
Belle2::ir::FarBeamLineElement::geo
G4VSolid * geo
Solid volume.
Definition: GeoFarBeamLineCreator.h:44