Belle II Software  release-05-01-25
GeoEKLMCreator.cc
1 /**************************************************************************
2  * BASF2 (Belle Analysis Framework 2) *
3  * Copyright(C) 2010 Belle II Collaboration *
4  * *
5  * Author: The Belle II Collaboration *
6  * Contributors: Galina Pakhlova, Timofey Uglov, Kirill Chilikin, *
7  * Takanori Hara *
8  * *
9  * This software is provided "as is" without any warranty. *
10  **************************************************************************/
11 
12 /* Own header. */
13 #include <klm/eklm/geometry/GeoEKLMCreator.h>
14 
15 /* KLM headers. */
16 #include <klm/eklm/geometry/G4TriangularPrism.h>
17 #include <klm/eklm/simulation/EKLMSensitiveDetector.h>
18 
19 /* Belle 2 headers. */
20 #include <geometry/CreatorFactory.h>
21 #include <geometry/Materials.h>
22 #include <geometry/utilities.h>
23 
24 /* Geant4 headers. */
25 #include <G4Box.hh>
26 #include <G4Polyhedra.hh>
27 #include <G4PVPlacement.hh>
28 #include <G4Region.hh>
29 #include <G4Tubs.hh>
30 #include <G4UnionSolid.hh>
31 
32 /* CLHEP headers. */
33 #include <CLHEP/Units/SystemOfUnits.h>
34 
35 /* C++ headers. */
36 #include <cmath>
37 #include <string>
38 
39 using namespace Belle2;
40 
41 static const char MemErr[] = "Memory allocation error.";
42 
43 /* Register the creator */
44 geometry::CreatorFactory<EKLM::GeoEKLMCreator> GeoEKLMFactory("EKLMCreator");
45 
46 /******************************* CONSTRUCTORS ********************************/
47 
49 {
50  m_Materials.air = nullptr;
51  m_CurVol.section = 1;
52  m_GeoDat = nullptr;
53  m_TransformData = nullptr;
54  m_Solids.plane = nullptr;
55  m_Solids.psheet = nullptr;
56  m_LogVol.psheet = nullptr;
57  m_LogVol.strip = nullptr;
58  m_Solids.groove = nullptr;
59  m_LogVol.groove = nullptr;
60  m_LogVol.scint = nullptr;
61  m_LogVol.segmentsup = nullptr;
63  m_Sensitive = nullptr;
64 }
65 
67 {
68  delete m_TransformData;
69  if (m_Solids.plane != nullptr)
70  deleteVolumes();
71  if (m_Sensitive != nullptr)
72  deleteSensitive();
73 }
74 
75 /***************************** MEMORY ALLOCATION *****************************/
76 
78 {
79  int i, nDiff;
80  m_Solids.plane =
81  (G4VSolid**)malloc(m_GeoDat->getNPlanes() * sizeof(G4VSolid*));
82  if (m_Solids.plane == nullptr)
83  B2FATAL(MemErr);
84  m_Solids.plasticSheetElement =
85  (G4VSolid**)malloc(m_GeoDat->getNStrips() * sizeof(G4VSolid*));
86  if (m_Solids.plasticSheetElement == nullptr)
87  B2FATAL(MemErr);
88  m_Solids.psheet =
89  (G4VSolid**)malloc(m_GeoDat->getNSegments() * sizeof(G4VSolid*));
90  if (m_Solids.psheet == nullptr)
91  B2FATAL(MemErr);
92  m_LogVol.psheet = (G4LogicalVolume**)
93  malloc(m_GeoDat->getNSegments() * sizeof(G4LogicalVolume*));
94  if (m_LogVol.psheet == nullptr)
95  B2FATAL(MemErr);
96  m_LogVol.segment =
97  (G4LogicalVolume**)malloc(m_GeoDat->getNSegments() *
98  sizeof(G4LogicalVolume*));
99  if (m_LogVol.segment == nullptr)
100  B2FATAL(MemErr);
101  m_Solids.stripSegment =
102  (G4VSolid**)malloc(m_GeoDat->getNSegments() * sizeof(G4VSolid*));
103  if (m_Solids.stripSegment == nullptr)
104  B2FATAL(MemErr);
105  m_LogVol.stripSegment =
106  (G4LogicalVolume**)malloc(m_GeoDat->getNSegments() *
107  sizeof(G4LogicalVolume*));
108  if (m_LogVol.stripSegment == nullptr)
109  B2FATAL(MemErr);
110  nDiff = m_GeoDat->getNStripsDifferentLength();
111  m_Solids.strip = (G4VSolid**)malloc(nDiff * sizeof(G4VSolid*));
112  if (m_Solids.strip == nullptr)
113  B2FATAL(MemErr);
114  m_LogVol.strip = (G4LogicalVolume**)malloc(nDiff * sizeof(G4LogicalVolume*));
115  if (m_LogVol.strip == nullptr)
116  B2FATAL(MemErr);
117  m_Solids.groove = (G4VSolid**)malloc(nDiff * sizeof(G4VSolid*));
118  if (m_Solids.groove == nullptr)
119  B2FATAL(MemErr);
120  m_LogVol.groove = (G4LogicalVolume**)malloc(nDiff * sizeof(G4LogicalVolume*));
121  if (m_LogVol.groove == nullptr)
122  B2FATAL(MemErr);
123  m_LogVol.scint = (G4LogicalVolume**)malloc(nDiff * sizeof(G4LogicalVolume*));
124  if (m_LogVol.scint == nullptr)
125  B2FATAL(MemErr);
126  m_LogVol.segmentsup =
127  (G4LogicalVolume***)malloc(m_GeoDat->getNPlanes() *
128  sizeof(G4LogicalVolume**));
129  if (m_LogVol.segmentsup == nullptr)
130  B2FATAL(MemErr);
131  for (i = 0; i < m_GeoDat->getNPlanes(); i++) {
132  m_LogVol.segmentsup[i] =
133  (G4LogicalVolume**)malloc((m_GeoDat->getNSegments() + 1) *
134  sizeof(G4LogicalVolume*));
135  if (m_LogVol.segmentsup[i] == nullptr)
136  B2FATAL(MemErr);
137  }
138  for (i = 0; i < m_GeoDat->getNSegments(); i++)
139  m_LogVol.psheet[i] = nullptr;
140 }
141 
143 {
144  try {
145  m_Sensitive =
146  new EKLMSensitiveDetector("EKLMSensitiveStrip");
147  } catch (std::bad_alloc& ba) {
148  B2FATAL(MemErr);
149  }
150 }
151 
153 {
154  int i;
155  free(m_Solids.plane);
156  free(m_Solids.plasticSheetElement);
157  free(m_Solids.psheet);
158  free(m_LogVol.psheet);
159  free(m_LogVol.segment);
160  free(m_Solids.stripSegment);
161  free(m_LogVol.stripSegment);
162  free(m_Solids.strip);
163  free(m_LogVol.strip);
164  free(m_Solids.groove);
165  free(m_LogVol.groove);
166  free(m_LogVol.scint);
167  for (i = 0; i < m_GeoDat->getNPlanes(); i++)
168  free(m_LogVol.segmentsup[i]);
169  free(m_LogVol.segmentsup);
170 }
171 
173 {
174  delete m_Sensitive;
175 }
176 
177 /********************************** XML DATA *********************************/
178 
180 {
181  m_Materials.air = geometry::Materials::get("Air");
182  m_Materials.polyethylene = geometry::Materials::get("EKLMPolyethylene");
183  m_Materials.polystyrene = geometry::Materials::get("EKLMPolystyrene");
184  m_Materials.polystyrol = geometry::Materials::get("EKLMPolystyrol");
185  m_Materials.gel = geometry::Materials::get("EKLMGel");
186  m_Materials.iron = geometry::Materials::get("EKLMIron");
187  m_Materials.duralumin = geometry::Materials::get("EKLMDuralumin");
188  m_Materials.silicon = geometry::Materials::get("EKLMSilicon");
189 }
190 
191 /*************************** CREATION OF SOLIDS ******************************/
192 
194 {
195  const EKLMGeometry::EndcapStructureGeometry* sectionStructureGeometry =
196  m_GeoDat->getEndcapStructureGeometry();
197  const EKLMGeometry::ElementPosition* sectionPos =
198  m_GeoDat->getSectionPosition();
199  const double z[2] = { -sectionPos->getLength() / 2,
200  sectionPos->getLength() / 2
201  };
202  const double rMin[2] = {0, 0};
203  const double rMax[2] = {sectionPos->getOuterR(), sectionPos->getOuterR()};
204  G4Polyhedra* op = nullptr;
205  G4Tubs* tb = nullptr;
206  try {
207  op = new G4Polyhedra("Section_Octagonal_Prism",
208  sectionStructureGeometry->getPhi(),
209  360. * CLHEP::deg,
210  sectionStructureGeometry->getNSides(),
211  2, z, rMin, rMax);
212  } catch (std::bad_alloc& ba) {
213  B2FATAL(MemErr);
214  }
215  /* Subtraction tube has slightly larger Z size. */
216  try {
217  tb = new G4Tubs("Section_Tube", 0, sectionPos->getInnerR(),
218  sectionPos->getLength() / 2.0 + 1.0 * CLHEP::mm,
219  0.0, 360.0 * CLHEP::deg);
220  } catch (std::bad_alloc& ba) {
221  B2FATAL(MemErr);
222  }
223  try {
224  m_Solids.section = new G4SubtractionSolid("Section", op, tb);
225  } catch (std::bad_alloc& ba) {
226  B2FATAL(MemErr);
227  }
228 }
229 
230 G4LogicalVolume*
232 {
233  G4LogicalVolume* logicLayer = nullptr;
234  try {
235  logicLayer = new G4LogicalVolume(m_Solids.layer, m_Materials.air, name);
236  } catch (std::bad_alloc& ba) {
237  B2FATAL(MemErr);
238  }
239  geometry::setVisibility(*logicLayer, false);
240  return logicLayer;
241 }
242 
244 {
245  const EKLMGeometry::ElementPosition* layerPos = m_GeoDat->getLayerPosition();
246  try {
247  m_Solids.layer =
248  new G4Tubs("Layer", layerPos->getInnerR(), layerPos->getOuterR(),
249  layerPos->getLength() / 2.0, 0.0, 360. * CLHEP::deg);
250  } catch (std::bad_alloc& ba) {
251  B2FATAL(MemErr);
252  }
253 }
254 
255 G4LogicalVolume*
257 {
258  G4LogicalVolume* logicSector = nullptr;
259  try {
260  logicSector = new G4LogicalVolume(m_Solids.sector, m_Materials.air, name);
261  } catch (std::bad_alloc& ba) {
262  B2FATAL(MemErr);
263  }
264  geometry::setVisibility(*logicSector, false);
265  return logicSector;
266 }
267 
269 {
270  const EKLMGeometry::ElementPosition* sectorPos =
271  m_GeoDat->getSectorPosition();
272  try {
273  m_Solids.sector =
274  new G4Tubs("Sector", sectorPos->getInnerR(), sectorPos->getOuterR(),
275  0.5 * sectorPos->getLength(), 0.0, 90. * CLHEP::deg);
276  } catch (std::bad_alloc& ba) {
277  B2FATAL(MemErr);
278  }
279 }
280 
282 {
283  double lz, ang;
284  HepGeom::Transform3D t1;
285  HepGeom::Transform3D t2;
286  G4Tubs* solidCoverTube = nullptr;
287  G4Box* solidCoverBox = nullptr;
288  G4Box* box = nullptr;
289  G4IntersectionSolid* is = nullptr;
290  G4SubtractionSolid* solidCover = nullptr;
291  const EKLMGeometry::ElementPosition* sectorPos =
292  m_GeoDat->getSectorPosition();
293  const EKLMGeometry::ElementPosition* sectorSupportPos =
294  m_GeoDat->getSectorSupportPosition();
295  const EKLMGeometry::SectorSupportGeometry* sectorSupportGeometry =
296  m_GeoDat->getSectorSupportGeometry();
297  const EKLMGeometry::ElementPosition* planePos = m_GeoDat->getPlanePosition();
298  lz = 0.5 * (sectorPos->getLength() - sectorSupportPos->getLength());
299  try {
300  solidCoverTube = new G4Tubs("Cover_Tube", sectorSupportPos->getInnerR(),
301  sectorSupportPos->getOuterR(), 0.5 * lz, 0.0,
302  90.0 * CLHEP::deg);
303  } catch (std::bad_alloc& ba) {
304  B2FATAL(MemErr);
305  }
306  try {
307  solidCoverBox = new G4Box("Cover_Box", 0.5 * sectorSupportPos->getOuterR(),
308  0.5 * sectorSupportPos->getOuterR(), 0.5 * lz);
309  } catch (std::bad_alloc& ba) {
310  B2FATAL(MemErr);
311  }
312  try {
313  box = new G4Box("Cover_SubtractionBox", 0.5 * sectorSupportPos->getOuterR(),
314  0.5 * sectorSupportPos->getOuterR(), lz);
315  } catch (std::bad_alloc& ba) {
316  B2FATAL(MemErr);
317  }
318  t1 = HepGeom::Translate3D(
319  0.5 * planePos->getOuterR() + sectorSupportPos->getX(),
320  0.5 * planePos->getOuterR() + sectorSupportPos->getY(), 0.);
321  ang = sectorSupportGeometry->getCornerAngle();
322  t2 = HepGeom::Translate3D(
323  sectorSupportPos->getX() +
324  0.5 * sectorSupportPos->getOuterR() * cos(ang) -
325  0.5 * sectorSupportPos->getOuterR() * sin(ang),
326  sectorSupportPos->getOuterR() -
327  sectorSupportGeometry->getDeltaLY() +
328  0.5 * sectorSupportPos->getOuterR() * cos(ang) +
329  0.5 * sectorSupportPos->getOuterR() * sin(ang),
330  0.) * HepGeom::RotateZ3D(ang);
331  try {
332  is = new G4IntersectionSolid("Cover_Intersection",
333  solidCoverTube, solidCoverBox, t1);
334  } catch (std::bad_alloc& ba) {
335  B2FATAL(MemErr);
336  }
337  try {
338  solidCover = new G4SubtractionSolid("Cover", is, box, t2);
339  } catch (std::bad_alloc& ba) {
340  B2FATAL(MemErr);
341  }
342  try {
343  m_LogVol.cover =
344  new G4LogicalVolume(solidCover, m_Materials.duralumin, "Cover");
345  } catch (std::bad_alloc& ba) {
346  B2FATAL(MemErr);
347  }
348  geometry::setVisibility(*m_LogVol.cover, false);
349  geometry::setColor(*m_LogVol.cover, "#ff000022");
350 }
351 
352 G4Box* EKLM::GeoEKLMCreator::createSectorSupportBoxX(HepGeom::Transform3D& t)
353 {
354  double x;
355  G4Box* res = nullptr;
356  const EKLMGeometry::ElementPosition* sectorSupportPos =
357  m_GeoDat->getSectorSupportPosition();
358  const EKLMGeometry::SectorSupportGeometry* sectorSupportGeometry =
359  m_GeoDat->getSectorSupportGeometry();
360  x = sqrt(sectorSupportPos->getOuterR() * sectorSupportPos->getOuterR() -
361  sectorSupportPos->getY() * sectorSupportPos->getY());
362  t = HepGeom::Translate3D(0.5 * (x + sectorSupportGeometry->getCorner3().x()),
363  sectorSupportPos->getY() +
364  0.5 * sectorSupportGeometry->getThickness(), 0.);
365  try {
366  res = new G4Box("SectorSupport_BoxX",
367  0.5 * (x - sectorSupportGeometry->getCorner3().x()),
368  0.5 * sectorSupportGeometry->getThickness(),
369  0.5 * sectorSupportPos->getLength());
370  } catch (std::bad_alloc& ba) {
371  B2FATAL(MemErr);
372  }
373  return res;
374 }
375 
376 G4Box* EKLM::GeoEKLMCreator::createSectorSupportBoxY(HepGeom::Transform3D& t)
377 {
378  G4Box* res = nullptr;
379  const EKLMGeometry::ElementPosition* sectorSupportPos =
380  m_GeoDat->getSectorSupportPosition();
381  const EKLMGeometry::SectorSupportGeometry* sectorSupportGeometry =
382  m_GeoDat->getSectorSupportGeometry();
383  t = HepGeom::Translate3D(sectorSupportPos->getX() +
384  0.5 * sectorSupportGeometry->getThickness(),
385  0.5 * (sectorSupportGeometry->getCorner4().y() +
386  sectorSupportGeometry->getCorner1A().y()),
387  0.) * HepGeom::RotateZ3D(90. * CLHEP::deg);
388  try {
389  res = new G4Box("SectorSupport_BoxY",
390  0.5 * (sectorSupportGeometry->getCorner1A().y() -
391  sectorSupportGeometry->getCorner4().y()),
392  0.5 * sectorSupportGeometry->getThickness(),
393  0.5 * sectorSupportPos->getLength());
394  } catch (std::bad_alloc& ba) {
395  B2FATAL(MemErr);
396  }
397  return res;
398 }
399 
400 G4Box* EKLM::GeoEKLMCreator::createSectorSupportBoxTop(HepGeom::Transform3D& t)
401 {
402  double dx;
403  double dy;
404  G4Box* res = nullptr;
405  const EKLMGeometry::ElementPosition* sectorSupportPos =
406  m_GeoDat->getSectorSupportPosition();
407  const EKLMGeometry::SectorSupportGeometry* sectorSupportGeometry =
408  m_GeoDat->getSectorSupportGeometry();
409  t = HepGeom::Translate3D(
410  0.5 * (sectorSupportGeometry->getCorner1A().x() +
411  sectorSupportGeometry->getCorner1B().x() +
412  sectorSupportGeometry->getThickness() *
413  sin(sectorSupportGeometry->getCornerAngle())),
414  0.5 * (sectorSupportGeometry->getCorner1A().y() +
415  sectorSupportGeometry->getCorner1B().y() -
416  sectorSupportGeometry->getThickness() *
417  cos(sectorSupportGeometry->getCornerAngle())),
418  0.) * HepGeom::RotateZ3D(sectorSupportGeometry->getCornerAngle());
419  dx = sectorSupportGeometry->getCorner1B().x() -
420  sectorSupportGeometry->getCorner1A().x();
421  dy = sectorSupportGeometry->getCorner1B().y() -
422  sectorSupportGeometry->getCorner1B().y();
423  try {
424  res = new G4Box("SectorSupport_BoxTop", 0.5 * sqrt(dx * dx + dy * dy),
425  0.5 * sectorSupportGeometry->getThickness(),
426  0.5 * sectorSupportPos->getLength());
427  } catch (std::bad_alloc& ba) {
428  B2FATAL(MemErr);
429  }
430  return res;
431 }
432 
434 {
435  double ang1;
436  double ang2;
437  G4Tubs* res = nullptr;
438  const EKLMGeometry::ElementPosition* sectorSupportPos =
439  m_GeoDat->getSectorSupportPosition();
440  const EKLMGeometry::SectorSupportGeometry* sectorSupportGeometry =
441  m_GeoDat->getSectorSupportGeometry();
442  ang1 = atan2(sectorSupportGeometry->getCorner3().y(),
443  sectorSupportGeometry->getCorner3().x());
444  ang2 = atan2(sectorSupportGeometry->getCorner4().y(),
445  sectorSupportGeometry->getCorner4().x());
446  try {
447  res = new G4Tubs("SectorSupport_InnerTube", sectorSupportPos->getInnerR(),
448  sectorSupportPos->getInnerR() +
449  sectorSupportGeometry->getThickness(),
450  0.5 * sectorSupportPos->getLength(),
451  ang1 * CLHEP::rad, (ang2 - ang1) * CLHEP::rad);
452  } catch (std::bad_alloc& ba) {
453  B2FATAL(MemErr);
454  }
455  return res;
456 }
457 
459 {
460  double x;
461  double ang1;
462  double ang2;
463  double r;
464  G4Tubs* res = nullptr;
465  const EKLMGeometry::ElementPosition* sectorSupportPos =
466  m_GeoDat->getSectorSupportPosition();
467  const EKLMGeometry::SectorSupportGeometry* sectorSupportGeometry =
468  m_GeoDat->getSectorSupportGeometry();
469  r = sectorSupportPos->getOuterR() - sectorSupportGeometry->getThickness();
470  x = sqrt(r * r - sectorSupportPos->getY() * sectorSupportPos->getY());
471  ang1 = atan2(sectorSupportPos->getY(), x);
472  ang2 = atan2(sectorSupportGeometry->getCorner1B().y(),
473  sectorSupportGeometry->getCorner1B().x());
474  try {
475  res = new G4Tubs("SectorSupport_OuterTube", r,
476  sectorSupportPos->getOuterR(),
477  0.5 * sectorSupportPos->getLength(),
478  ang1 * CLHEP::rad, (ang2 - ang1) * CLHEP::rad);
479  } catch (std::bad_alloc& ba) {
480  B2FATAL(MemErr);
481  }
482  return res;
483 }
484 
486 {
487  double lx;
488  double x;
489  G4Tubs* solidCorner1Tube = nullptr;
490  G4Box* solidCorner1Box1 = nullptr;
491  G4Box* solidCorner1Box2 = nullptr;
492  G4IntersectionSolid* is1 = nullptr;
493  G4IntersectionSolid* solidCorner1 = nullptr;
494  HepGeom::Transform3D t1;
495  HepGeom::Transform3D t2;
496  const EKLMGeometry::ElementPosition* sectorSupportPos =
497  m_GeoDat->getSectorSupportPosition();
498  const EKLMGeometry::SectorSupportGeometry* sectorSupportGeometry =
499  m_GeoDat->getSectorSupportGeometry();
500  lx = sectorSupportGeometry->getCornerX() +
501  sectorSupportGeometry->getCorner1LX() -
502  sectorSupportGeometry->getThickness();
503  try {
504  solidCorner1Tube = new G4Tubs(
505  "SectorSupport_Corner1_Tube", 0.,
506  sectorSupportPos->getOuterR() - sectorSupportGeometry->getThickness(),
507  0.5 * sectorSupportGeometry->getCorner1Thickness(),
508  0., 90. * CLHEP::deg);
509  } catch (std::bad_alloc& ba) {
510  B2FATAL(MemErr);
511  }
512  try {
513  solidCorner1Box1 = new G4Box(
514  "SectorSupport_Corner1_Box1", 0.5 * lx,
515  0.5 * sectorSupportPos->getOuterR(),
516  0.5 * sectorSupportGeometry->getCorner1Thickness());
517  } catch (std::bad_alloc& ba) {
518  B2FATAL(MemErr);
519  }
520  try {
521  solidCorner1Box2 =
522  new G4Box("SectorSupport_Corner1_Box2",
523  0.5 * (lx / cos(sectorSupportGeometry->getCornerAngle()) +
524  sectorSupportGeometry->getCorner1Width() *
525  tan(sectorSupportGeometry->getCornerAngle())),
526  0.5 * sectorSupportGeometry->getCorner1Width(),
527  0.5 * sectorSupportGeometry->getCorner1Thickness());
528  } catch (std::bad_alloc& ba) {
529  B2FATAL(MemErr);
530  }
531  x = sectorSupportPos->getX() + 0.5 * (sectorSupportGeometry->getCornerX() +
532  sectorSupportGeometry->getCorner1LX() +
533  sectorSupportGeometry->getThickness());
534  t1 = HepGeom::Translate3D(x, 0.5 * sectorSupportPos->getOuterR(), 0.);
535  t2 = HepGeom::Translate3D(
536  x, sectorSupportGeometry->getCorner1AInner().y() -
537  0.5 * sectorSupportGeometry->getCorner1Width() /
538  cos(sectorSupportGeometry->getCornerAngle()) +
539  0.5 * lx * tan(sectorSupportGeometry->getCornerAngle()), 0.) *
540  HepGeom::RotateZ3D(sectorSupportGeometry->getCornerAngle());
541  try {
542  is1 = new G4IntersectionSolid("SectorSupport_Corner1_Intersection1",
543  solidCorner1Tube, solidCorner1Box1, t1);
544  } catch (std::bad_alloc& ba) {
545  B2FATAL(MemErr);
546  }
547  try {
548  solidCorner1 = new G4IntersectionSolid("SectorSupport_Corner1", is1,
549  solidCorner1Box2, t2);
550  } catch (std::bad_alloc& ba) {
551  B2FATAL(MemErr);
552  }
553  try {
554  m_LogVol.sectorsup.corn1 =
555  new G4LogicalVolume(solidCorner1, m_Materials.duralumin, "Corner1");
556  } catch (std::bad_alloc& ba) {
557  B2FATAL(MemErr);
558  }
559  geometry::setVisibility(*m_LogVol.sectorsup.corn1, true);
560  geometry::setColor(*m_LogVol.sectorsup.corn1, "#ff0000ff");
561 }
562 
564 {
565  G4TriangularPrism* solidCorner2Prism = nullptr;
566  G4SubtractionSolid* solidCorner2 = nullptr;
567  HepGeom::Transform3D t1;
568  const EKLMGeometry::SectorSupportGeometry* sectorSupportGeometry =
569  m_GeoDat->getSectorSupportGeometry();
570  try {
571  solidCorner2Prism =
572  new G4TriangularPrism("SectorSupport_Corner2_Prism",
573  sectorSupportGeometry->getCorner2LY(),
574  90. * CLHEP::deg,
575  sectorSupportGeometry->getCorner2LX(),
576  180. * CLHEP::deg,
577  0.5 * sectorSupportGeometry->getCorner2Thickness());
578  } catch (std::bad_alloc& ba) {
579  B2FATAL(MemErr);
580  }
581  t1 = HepGeom::Translate3D(-sectorSupportGeometry->getCorner2Inner().x(),
582  -sectorSupportGeometry->getCorner2Inner().y(), 0);
583  try {
584  solidCorner2 = new G4SubtractionSolid("SectorSupport_Corner2",
585  solidCorner2Prism->getSolid(),
586  m_Solids.sectorsup.otube, t1);
587  } catch (std::bad_alloc& ba) {
588  B2FATAL(MemErr);
589  }
590  delete solidCorner2Prism;
591  try {
592  m_LogVol.sectorsup.corn2 =
593  new G4LogicalVolume(solidCorner2, m_Materials.duralumin, "Corner2");
594  } catch (std::bad_alloc& ba) {
595  B2FATAL(MemErr);
596  }
597  geometry::setVisibility(*m_LogVol.sectorsup.corn2, true);
598  geometry::setColor(*m_LogVol.sectorsup.corn2, "#ff0000ff");
599 }
600 
602 {
603  G4TriangularPrism* solidCorner3Prism = nullptr;
604  G4SubtractionSolid* solidCorner3 = nullptr;
605  HepGeom::Transform3D t1;
606  const EKLMGeometry::SectorSupportGeometry* sectorSupportGeometry =
607  m_GeoDat->getSectorSupportGeometry();
608  try {
609  solidCorner3Prism =
610  new G4TriangularPrism("SectorSupport_Corner3_Prism",
611  sectorSupportGeometry->getCorner3LX(), 0.,
612  sectorSupportGeometry->getCorner3LY(),
613  90. * CLHEP::deg,
614  0.5 * sectorSupportGeometry->getCorner3Thickness());
615  } catch (std::bad_alloc& ba) {
616  B2FATAL(MemErr);
617  }
618  t1 = HepGeom::Translate3D(-sectorSupportGeometry->getCorner3Prism().x(),
619  -sectorSupportGeometry->getCorner3Prism().y(), 0.);
620  try {
621  solidCorner3 = new G4SubtractionSolid("SectorSupport_Corner3",
622  solidCorner3Prism->getSolid(),
623  m_Solids.sectorsup.itube, t1);
624  } catch (std::bad_alloc& ba) {
625  B2FATAL(MemErr);
626  }
627  delete solidCorner3Prism;
628  try {
629  m_LogVol.sectorsup.corn3 =
630  new G4LogicalVolume(solidCorner3, m_Materials.duralumin, "Corner3");
631  } catch (std::bad_alloc& ba) {
632  B2FATAL(MemErr);
633  }
634  geometry::setVisibility(*m_LogVol.sectorsup.corn3, true);
635  geometry::setColor(*m_LogVol.sectorsup.corn3, "#ff0000ff");
636 }
637 
639 {
640  G4TriangularPrism* solidCorner4Prism = nullptr;
641  G4SubtractionSolid* solidCorner4 = nullptr;
642  HepGeom::Transform3D t1;
643  const EKLMGeometry::SectorSupportGeometry* sectorSupportGeometry =
644  m_GeoDat->getSectorSupportGeometry();
645  try {
646  solidCorner4Prism =
647  new G4TriangularPrism("SectorSupport_Corner4_Prism",
648  sectorSupportGeometry->getCorner4LX(), 0.,
649  sectorSupportGeometry->getCorner4LY(),
650  90. * CLHEP::deg,
651  0.5 * sectorSupportGeometry->getCorner4Thickness());
652  } catch (std::bad_alloc& ba) {
653  B2FATAL(MemErr);
654  }
655  t1 = HepGeom::Translate3D(-sectorSupportGeometry->getCorner4Prism().x(),
656  -sectorSupportGeometry->getCorner4Prism().y(), 0.);
657  try {
658  solidCorner4 = new G4SubtractionSolid("SectorSupport_Corner4",
659  solidCorner4Prism->getSolid(),
660  m_Solids.sectorsup.itube, t1);
661  } catch (std::bad_alloc& ba) {
662  B2FATAL(MemErr);
663  }
664  delete solidCorner4Prism;
665  try {
666  m_LogVol.sectorsup.corn4 =
667  new G4LogicalVolume(solidCorner4, m_Materials.duralumin, "Corner4");
668  } catch (std::bad_alloc& ba) {
669  B2FATAL(MemErr);
670  }
671  geometry::setVisibility(*m_LogVol.sectorsup.corn4, true);
672  geometry::setColor(*m_LogVol.sectorsup.corn4, "#ff0000ff");
673 }
674 
676 {
677  G4Box* solidBoxX;
678  G4Box* solidBoxY;
679  G4Box* solidBoxTop;
680  G4Tubs* solidLimitationTube = nullptr;
681  G4UnionSolid* us1 = nullptr;
682  G4UnionSolid* us2 = nullptr;
683  G4UnionSolid* us3 = nullptr;
684  G4UnionSolid* us4 = nullptr;
685  G4IntersectionSolid* solidSectorSupport = nullptr;
686  HepGeom::Transform3D tbx;
687  HepGeom::Transform3D tby;
688  HepGeom::Transform3D tbt;
689  const EKLMGeometry::ElementPosition* sectorSupportPos =
690  m_GeoDat->getSectorSupportPosition();
691  solidBoxX = createSectorSupportBoxX(tbx);
692  solidBoxY = createSectorSupportBoxY(tby);
693  solidBoxTop = createSectorSupportBoxTop(tbt);
694  m_Solids.sectorsup.otube = createSectorSupportOuterTube();
695  m_Solids.sectorsup.itube = createSectorSupportInnerTube();
696  try {
697  solidLimitationTube = new G4Tubs("SectorSupport_LimitationTube",
698  0., sectorSupportPos->getOuterR(),
699  0.5 * sectorSupportPos->getLength(),
700  0., 90.*CLHEP::deg);
701  } catch (std::bad_alloc& ba) {
702  B2FATAL(MemErr);
703  }
704  try {
705  us1 = new G4UnionSolid("SectorSupport_Union1",
706  m_Solids.sectorsup.itube, solidBoxY, tby);
707  } catch (std::bad_alloc& ba) {
708  B2FATAL(MemErr);
709  }
710  try {
711  us2 = new G4UnionSolid("SectorSupport_Union2",
712  us1, solidBoxX, tbx);
713  } catch (std::bad_alloc& ba) {
714  B2FATAL(MemErr);
715  }
716  try {
717  us3 = new G4UnionSolid("SectorSupport_Union3", us2,
718  m_Solids.sectorsup.otube,
719  HepGeom::Translate3D(0., 0., 0.));
720  } catch (std::bad_alloc& ba) {
721  B2FATAL(MemErr);
722  }
723  try {
724  us4 = new G4UnionSolid("SectorSupport_Union4",
725  us3, solidBoxTop, tbt);
726  } catch (std::bad_alloc& ba) {
727  B2FATAL(MemErr);
728  }
729  try {
730  solidSectorSupport =
731  new G4IntersectionSolid("SectorSupport", us4, solidLimitationTube,
732  HepGeom::Translate3D(0., 0., 0.));
733  } catch (std::bad_alloc& ba) {
734  B2FATAL(MemErr);
735  }
736  try {
737  m_LogVol.sectorsup.supp =
738  new G4LogicalVolume(solidSectorSupport, m_Materials.duralumin, "Support");
739  } catch (std::bad_alloc& ba) {
740  B2FATAL(MemErr);
741  }
742  geometry::setVisibility(*m_LogVol.sectorsup.supp, true);
743  geometry::setColor(*m_LogVol.sectorsup.supp, "#ff0000ff");
744 }
745 
747 {
748  const EKLMGeometry::ElementPosition* layerPos = m_GeoDat->getLayerPosition();
749  const EKLMGeometry::ElementPosition* sectorSupportPos =
750  m_GeoDat->getSectorSupportPosition();
751  try {
752  m_Solids.subtractionBox =
753  new G4Box("SubractionBox", 0.5 * sectorSupportPos->getOuterR(),
754  0.5 * sectorSupportPos->getOuterR(), layerPos->getLength());
755  } catch (std::bad_alloc& ba) {
756  B2FATAL(MemErr);
757  }
758 }
759 
760 G4SubtractionSolid* EKLM::GeoEKLMCreator::
761 cutSolidCorner(const char* name, G4VSolid* solid, G4Box* subtractionBox,
762  HepGeom::Transform3D& transf, bool largerAngles,
763  double x1, double y1, double x2, double y2)
764 {
765  double ang;
766  ang = atan2(y2 - y1, x2 - x1);
767  return cutSolidCorner(name, solid, subtractionBox, transf, largerAngles,
768  x1, y1, ang);
769 }
770 
771 G4SubtractionSolid* EKLM::GeoEKLMCreator::
772 cutSolidCorner(const char* name, G4VSolid* solid, G4Box* subtractionBox,
773  HepGeom::Transform3D& transf, bool largerAngles,
774  double x, double y, double ang)
775 {
776  double lx, ly;
777  HepGeom::Transform3D t;
778  G4SubtractionSolid* ss = nullptr;
779  lx = subtractionBox->GetXHalfLength();
780  ly = subtractionBox->GetYHalfLength();
781  if (largerAngles)
782  t = HepGeom::Translate3D(x + lx * cos(ang) - ly * sin(ang),
783  y + lx * sin(ang) + ly * cos(ang), 0) *
784  HepGeom::RotateZ3D(ang);
785  else
786  t = HepGeom::Translate3D(x + lx * cos(ang) + ly * sin(ang),
787  y + lx * sin(ang) - ly * cos(ang), 0) *
788  HepGeom::RotateZ3D(ang);
789  try {
790  ss = new G4SubtractionSolid(name, solid, subtractionBox, transf * t);
791  } catch (std::bad_alloc& ba) {
792  B2FATAL(MemErr);
793  }
794  return ss;
795 }
796 
798 {
799  double box_x;
800  double box_y;
801  HepGeom::Transform3D t;
802  HepGeom::Transform3D t1;
803  char name[128];
804  G4Tubs* tb = nullptr;
805  G4IntersectionSolid* is = nullptr;
806  G4SubtractionSolid* ss1, *ss2, *ss3, *ss4;
807  const EKLMGeometry::ElementPosition* sectorSupportPos =
808  m_GeoDat->getSectorSupportPosition();
809  const EKLMGeometry::SectorSupportGeometry* sectorSupportGeometry =
810  m_GeoDat->getSectorSupportGeometry();
811  const EKLMGeometry::ElementPosition* planePos = m_GeoDat->getPlanePosition();
812  /* Basic solids. */
813  snprintf(name, 128, "Plane_%d_Tube", n + 1);
814  try {
815  tb = new G4Tubs(name, planePos->getInnerR(), planePos->getOuterR(),
816  0.5 * planePos->getLength(), 0.0, 90.0 * CLHEP::deg);
817  } catch (std::bad_alloc& ba) {
818  B2FATAL(MemErr);
819  }
820  snprintf(name, 128, "Plane_%d_Box", n + 1);
821  box_x = sectorSupportPos->getX() + sectorSupportGeometry->getThickness();
822  box_y = sectorSupportPos->getY() + sectorSupportGeometry->getThickness();
823  /* Calculate transformations for boolean solids. */
824  t1 = HepGeom::Translate3D(m_Solids.subtractionBox->GetXHalfLength() + box_x,
825  m_Solids.subtractionBox->GetXHalfLength() + box_y,
826  0.);
827  /* For rotated plane. */
828  if (n == 0) {
829  t = HepGeom::Rotate3D(180. * CLHEP::deg,
830  HepGeom::Vector3D<double>(1., 1., 0.));
831  t1 = t * t1;
832  } else
833  t = HepGeom::Translate3D(0, 0, 0);
834  /* Boolean solids. */
835  snprintf(name, 128, "Plane_%d_Intersection", n + 1);
836  try {
837  is = new G4IntersectionSolid(name, tb, m_Solids.subtractionBox, t1);
838  } catch (std::bad_alloc& ba) {
839  B2FATAL(MemErr);
840  }
841  snprintf(name, 128, "Plane_%d_Subtraction_1", n + 1);
842  ss1 = cutSolidCorner(name, is, m_Solids.subtractionBox, t, true,
843  sectorSupportGeometry->getCorner1AInner().x(),
844  sectorSupportGeometry->getCorner1AInner().y(),
845  sectorSupportGeometry->getCornerAngle());
846  snprintf(name, 128, "Plane_%d_Subtraction_2", n + 1);
847  ss2 = cutSolidCorner(
848  name, ss1, m_Solids.subtractionBox, t, false,
849  sectorSupportGeometry->getCorner2Inner().x() -
850  sectorSupportGeometry->getCorner2LX(),
851  sectorSupportGeometry->getCorner2Inner().y(),
852  sectorSupportGeometry->getCorner2Inner().x(),
853  sectorSupportGeometry->getCorner2Inner().y() +
854  sectorSupportGeometry->getCorner2LY());
855  snprintf(name, 128, "Plane_%d_Subtraction_3", n + 1);
856  ss3 = cutSolidCorner(
857  name, ss2, m_Solids.subtractionBox, t, false,
858  sectorSupportGeometry->getCorner3Prism().x(),
859  sectorSupportGeometry->getCorner3Prism().y() +
860  sectorSupportGeometry->getCorner3LY(),
861  sectorSupportGeometry->getCorner3Prism().x() +
862  sectorSupportGeometry->getCorner3LX(),
863  sectorSupportGeometry->getCorner3Prism().y());
864  snprintf(name, 128, "Plane_%d_Subtraction_4", n + 1);
865  ss4 = cutSolidCorner(
866  name, ss3, m_Solids.subtractionBox, t, true,
867  sectorSupportGeometry->getCorner4Prism().x() +
868  sectorSupportGeometry->getCorner4LX(),
869  sectorSupportGeometry->getCorner4Prism().y(),
870  sectorSupportGeometry->getCorner4Prism().x(),
871  sectorSupportGeometry->getCorner4Prism().y() +
872  sectorSupportGeometry->getCorner4LY());
873  snprintf(name, 128, "Plane_%d", n + 1);
874  m_Solids.plane[n] = ss4;
875 }
876 
878 createSegmentSupportLogicalVolume(int iPlane, int iSegmentSupport)
879 {
880  HepGeom::Transform3D t1, t2;
881  G4Box* topBox = nullptr;
882  G4Box* midBox = nullptr;
883  G4Box* botBox = nullptr;
884  G4UnionSolid* us = nullptr;
885  G4UnionSolid* solidSegmentSupport = nullptr;
886  std::string segmentSupportName =
887  "SegmentSupport_" + std::to_string(iSegmentSupport) +
888  "_Plane_" + std::to_string(iPlane);
889  const EKLMGeometry::SegmentSupportPosition* segmentSupportPos =
890  m_GeoDat->getSegmentSupportPosition(iPlane, iSegmentSupport);
891  const EKLMGeometry::SegmentSupportGeometry* segmentSupportGeometry =
892  m_GeoDat->getSegmentSupportGeometry();
893  try {
894  topBox = new G4Box("BoxTop_" + segmentSupportName,
895  0.5 * (segmentSupportPos->getLength() -
896  segmentSupportPos->getDeltaLLeft() -
897  segmentSupportPos->getDeltaLRight()),
898  0.5 * segmentSupportGeometry->getTopWidth(),
899  0.5 * segmentSupportGeometry->getTopThickness());
900  } catch (std::bad_alloc& ba) {
901  B2FATAL(MemErr);
902  }
903  try {
904  midBox = new G4Box("BoxMiddle_" + segmentSupportName,
905  0.5 * (segmentSupportPos->getLength() -
906  segmentSupportPos->getDeltaLLeft() -
907  segmentSupportPos->getDeltaLRight()),
908  0.5 * segmentSupportGeometry->getMiddleWidth(),
909  0.5 * segmentSupportGeometry->getMiddleThickness());
910  } catch (std::bad_alloc& ba) {
911  B2FATAL(MemErr);
912  }
913  try {
914  botBox = new G4Box("BoxBottom_" + segmentSupportName,
915  0.5 * segmentSupportPos->getLength(),
916  0.5 * segmentSupportGeometry->getTopWidth(),
917  0.5 * segmentSupportGeometry->getTopThickness());
918  } catch (std::bad_alloc& ba) {
919  B2FATAL(MemErr);
920  }
921  t1 = HepGeom::Translate3D(
922  0., 0., 0.5 * (segmentSupportGeometry->getMiddleThickness() +
923  segmentSupportGeometry->getTopThickness()));
924  t2 = HepGeom::Translate3D(
925  0.5 * (segmentSupportPos->getDeltaLRight() -
926  segmentSupportPos->getDeltaLLeft()), 0.,
927  -0.5 * (segmentSupportGeometry->getMiddleThickness() +
928  segmentSupportGeometry->getTopThickness()));
929  try {
930  us = new G4UnionSolid("Union1_" + segmentSupportName, midBox, topBox, t1);
931  } catch (std::bad_alloc& ba) {
932  B2FATAL(MemErr);
933  }
934  try {
935  solidSegmentSupport = new G4UnionSolid(segmentSupportName, us, botBox, t2);
936  } catch (std::bad_alloc& ba) {
937  B2FATAL(MemErr);
938  }
939  try {
940  m_LogVol.segmentsup[iPlane - 1][iSegmentSupport - 1] =
941  new G4LogicalVolume(solidSegmentSupport, m_Materials.duralumin,
942  segmentSupportName);
943  } catch (std::bad_alloc& ba) {
944  B2FATAL(MemErr);
945  }
946  geometry::setVisibility(*m_LogVol.segmentsup[iPlane - 1][iSegmentSupport - 1],
947  true);
948  geometry::setColor(*m_LogVol.segmentsup[iPlane - 1][iSegmentSupport - 1],
949  "#ff0000ff");
950 }
951 
952 G4VSolid* EKLM::GeoEKLMCreator::
953 unifySolids(G4VSolid** solids, HepGeom::Transform3D* transf,
954  int nSolids, const std::string& name)
955 {
956  G4UnionSolid** u;
957  G4DisplacedSolid* d;
958  G4VSolid** solidArray;
959  HepGeom::Transform3D* inverseTransf;
960  HepGeom::Transform3D t;
961  char str[128];
962  /* cppcheck-suppress variableScope */
963  int n, nUnions, i, i1, i2, k, k1, k2, l, dl;
964  if (nSolids <= 1)
965  B2FATAL("Number of solids to be unified must be greater than 1.");
966  try {
967  inverseTransf = new HepGeom::Transform3D[nSolids];
968  } catch (std::bad_alloc& ba) {
969  B2FATAL(MemErr);
970  }
971  for (i = 0; i < nSolids; i++)
972  inverseTransf[i] = transf[i].inverse();
973  n = nSolids;
974  nUnions = 0;
975  while (n > 1) {
976  if (n % 2 == 0)
977  n = n / 2;
978  else
979  n = n / 2 + 1;
980  nUnions = nUnions + n;
981  }
982  u = (G4UnionSolid**)malloc(sizeof(G4UnionSolid*) * nUnions);
983  if (u == nullptr)
984  B2FATAL(MemErr);
985  n = nSolids;
986  i2 = 0;
987  solidArray = solids;
988  k1 = 0;
989  k2 = nSolids;
990  dl = 1;
991  while (n > 1) {
992  i1 = i2;
993  if (n % 2 == 0)
994  n = n / 2;
995  else
996  n = n / 2 + 1;
997  i2 = i1 + n;
998  k = k1;
999  l = 0;
1000  for (i = i1; i < i2; i++) {
1001  if (k != k2 - 1) {
1002  /* Unify k and k + 1 -> i */
1003  t = inverseTransf[l] * transf[l + dl];
1004  try {
1005  snprintf(str, 128, "_Union_%d", i + 1);
1006  u[i] = new G4UnionSolid(name + str, solidArray[k],
1007  solidArray[k + 1], t);
1008  } catch (std::bad_alloc& ba) {
1009  B2FATAL(MemErr);
1010  }
1011  } else {
1012  /* Copy k -> i */
1013  u[i] = (G4UnionSolid*)solids[k];
1014  }
1015  k = k + 2;
1016  l = l + dl * 2;
1017  }
1018  solidArray = (G4VSolid**)u;
1019  k1 = i1;
1020  k2 = i2;
1021  dl = dl * 2;
1022  }
1023  d = new G4DisplacedSolid(name + "_Displaced", u[nUnions - 1], transf[0]);
1024  free(u);
1025  delete[] inverseTransf;
1026  return d;
1027 }
1028 
1030 {
1031  int i, m, nStrip;
1032  /* cppcheck-suppress variableScope */
1033  double ly;
1034  char name[128];
1035  G4VSolid** elements;
1036  HepGeom::Transform3D* t;
1037  const EKLMGeometry::PlasticSheetGeometry* plasticSheetGeometry =
1038  m_GeoDat->getPlasticSheetGeometry();
1039  const EKLMGeometry::StripGeometry* stripGeometry =
1040  m_GeoDat->getStripGeometry();
1041  nStrip = m_ElementNumbers->getNStripsSegment();
1042  elements = new G4VSolid*[nStrip];
1043  t = new HepGeom::Transform3D[nStrip];
1044  /* Transformations. */
1045  for (i = 0; i < nStrip; i++) {
1046  m = nStrip * iSegment + i;
1047  m_GeoDat->getSheetTransform(&(t[i]), m);
1048  }
1049  /* Sheet elements. */
1050  for (i = 0; i < nStrip; i++) {
1051  snprintf(name, 128, "PlasticSheet_%d_Element_%d", iSegment + 1, i + 1);
1052  ly = stripGeometry->getWidth();
1053  if (i == 0 || i == nStrip - 1)
1054  ly = ly - plasticSheetGeometry->getDeltaL();
1055  m = nStrip * iSegment + i;
1056  const EKLMGeometry::ElementPosition* stripPos =
1057  m_GeoDat->getStripPosition(m + 1);
1058  try {
1059  m_Solids.plasticSheetElement[m] =
1060  new G4Box(name, 0.5 * stripPos->getLength(), 0.5 * ly,
1061  0.5 * plasticSheetGeometry->getWidth());
1062  } catch (std::bad_alloc& ba) {
1063  B2FATAL(MemErr);
1064  }
1065  elements[i] = m_Solids.plasticSheetElement[m];
1066  }
1067  /* Union. */
1068  snprintf(name, 128, "PlasticSheet_%d", iSegment + 1);
1069  m_Solids.psheet[iSegment] = unifySolids(elements, t, nStrip, name);
1070  try {
1071  m_LogVol.psheet[iSegment] =
1072  new G4LogicalVolume(m_Solids.psheet[iSegment],
1073  m_Materials.polystyrol, name);
1074  } catch (std::bad_alloc& ba) {
1075  B2FATAL(MemErr);
1076  }
1077  geometry::setVisibility(*m_LogVol.psheet[iSegment], false);
1078  geometry::setColor(*m_LogVol.psheet[iSegment], "#00ff00ff");
1079  delete[] elements;
1080  delete[] t;
1081 }
1082 
1084 {
1085  /* cppcheck-suppress variableScope */
1086  int i, m, nStrip;
1087  char name[128];
1088  G4VSolid** strips;
1089  HepGeom::Transform3D* t;
1090  nStrip = m_ElementNumbers->getNStripsSegment();
1091  strips = new G4VSolid*[nStrip];
1092  t = new HepGeom::Transform3D[nStrip];
1093  for (i = 0; i < nStrip; i++) {
1094  m = nStrip * iSegment + i;
1095  m_GeoDat->getStripTransform(&(t[i]), m);
1096  strips[i] = m_Solids.strip[m_GeoDat->getStripLengthIndex(m)];
1097  }
1098  snprintf(name, 128, "StripSegment_%d", iSegment + 1);
1099  m_Solids.stripSegment[iSegment] = unifySolids(strips, t, nStrip, name);
1100  try {
1101  m_LogVol.stripSegment[iSegment] =
1102  new G4LogicalVolume(m_Solids.stripSegment[iSegment], m_Materials.air,
1103  name);
1104  } catch (std::bad_alloc& ba) {
1105  B2FATAL(MemErr);
1106  }
1107  geometry::setVisibility(*m_LogVol.stripSegment[iSegment], false);
1108  geometry::setColor(*m_LogVol.stripSegment[iSegment], "#00ff00ff");
1109  delete[] strips;
1110  delete[] t;
1111 }
1112 
1114 {
1115  double z;
1116  char name[128];
1117  G4UnionSolid* u1, *u2;
1118  HepGeom::Transform3D t;
1119  const EKLMGeometry::PlasticSheetGeometry* plasticSheetGeometry =
1120  m_GeoDat->getPlasticSheetGeometry();
1121  const EKLMGeometry::StripGeometry* stripGeometry =
1122  m_GeoDat->getStripGeometry();
1123  z = 0.5 * (stripGeometry->getThickness() + plasticSheetGeometry->getWidth());
1124  snprintf(name, 128, "Segment_%d_Union_1", iSegment + 1);
1125  t = HepGeom::Translate3D(0, 0, -z);
1126  try {
1127  u1 = new G4UnionSolid(name, m_Solids.stripSegment[iSegment],
1128  m_Solids.psheet[iSegment], t);
1129  } catch (std::bad_alloc& ba) {
1130  B2FATAL(MemErr);
1131  }
1132  snprintf(name, 128, "Segment_%d", iSegment + 1);
1133  t = HepGeom::Translate3D(0, 0, z);
1134  try {
1135  u2 = new G4UnionSolid(name, u1, m_Solids.psheet[iSegment], t);
1136  } catch (std::bad_alloc& ba) {
1137  B2FATAL(MemErr);
1138  }
1139  try {
1140  m_LogVol.segment[iSegment] =
1141  new G4LogicalVolume(u2, m_Materials.air, name);
1142  } catch (std::bad_alloc& ba) {
1143  B2FATAL(MemErr);
1144  }
1145  geometry::setVisibility(*m_LogVol.segment[iSegment], false);
1146  geometry::setColor(*m_LogVol.segment[iSegment], "#00ff00ff");
1147 }
1148 
1150 {
1151  int iPos;
1152  char name[128];
1153  const EKLMGeometry::ElementPosition* stripPos;
1154  const EKLMGeometry::StripGeometry* stripGeometry =
1155  m_GeoDat->getStripGeometry();
1156  iPos = m_GeoDat->getStripPositionIndex(iStrip);
1157  stripPos = m_GeoDat->getStripPosition(iPos + 1);
1158  snprintf(name, 128, "Strip_%d", iStrip + 1);
1159  try {
1160  m_Solids.strip[iStrip] = new G4Box(name, 0.5 * stripPos->getLength(),
1161  0.5 * stripGeometry->getWidth(),
1162  0.5 * stripGeometry->getThickness());
1163  } catch (std::bad_alloc& ba) {
1164  B2FATAL(MemErr);
1165  }
1166  try {
1167  m_LogVol.strip[iStrip] =
1168  new G4LogicalVolume(m_Solids.strip[iStrip], m_Materials.polystyrene,
1169  name);
1170  } catch (std::bad_alloc& ba) {
1171  B2FATAL(MemErr);
1172  }
1173  geometry::setVisibility(*m_LogVol.strip[iStrip], true);
1174  geometry::setColor(*m_LogVol.strip[iStrip], "#ffffffff");
1175 }
1176 
1178 {
1179  int iPos;
1180  char name[128];
1181  const EKLMGeometry::ElementPosition* stripPos;
1182  const EKLMGeometry::StripGeometry* stripGeometry =
1183  m_GeoDat->getStripGeometry();
1184  iPos = m_GeoDat->getStripPositionIndex(iStrip);
1185  stripPos = m_GeoDat->getStripPosition(iPos + 1);
1186  snprintf(name, 128, "Groove_%d", iStrip + 1);
1187  try {
1188  m_Solids.groove[iStrip] = new G4Box(name, 0.5 * stripPos->getLength(),
1189  0.5 * stripGeometry->getGrooveWidth(),
1190  0.5 * stripGeometry->getGrooveDepth());
1191  } catch (std::bad_alloc& ba) {
1192  B2FATAL(MemErr);
1193  }
1194  try {
1195  m_LogVol.groove[iStrip] =
1196  new G4LogicalVolume(m_Solids.groove[iStrip], m_Materials.gel, name);
1197  } catch (std::bad_alloc& ba) {
1198  B2FATAL(MemErr);
1199  }
1200  geometry::setVisibility(*m_LogVol.groove[iStrip], true);
1201  geometry::setColor(*m_LogVol.groove[iStrip], "#00ff00ff");
1202 }
1203 
1205 {
1206  int iPos;
1207  char name[128];
1208  const EKLMGeometry::ElementPosition* stripPos;
1209  const EKLMGeometry::StripGeometry* stripGeometry =
1210  m_GeoDat->getStripGeometry();
1211  HepGeom::Transform3D t;
1212  G4Box* b;
1213  G4SubtractionSolid* scintillatorSolid;
1214  iPos = m_GeoDat->getStripPositionIndex(iStrip);
1215  stripPos = m_GeoDat->getStripPosition(iPos + 1);
1216  snprintf(name, 128, "StripSensitive_%d_Box", iStrip + 1);
1217  try {
1218  b = new G4Box(name,
1219  0.5 * stripPos->getLength() -
1220  stripGeometry->getNoScintillationThickness(),
1221  0.5 * stripGeometry->getWidth() -
1222  stripGeometry->getNoScintillationThickness(),
1223  0.5 * stripGeometry->getThickness() -
1224  stripGeometry->getNoScintillationThickness());
1225  } catch (std::bad_alloc& ba) {
1226  B2FATAL(MemErr);
1227  }
1228  snprintf(name, 128, "StripSensitive_%d", iStrip + 1);
1229  t = HepGeom::Translate3D(0., 0., 0.5 * (stripGeometry->getThickness() -
1230  stripGeometry->getGrooveDepth()));
1231  try {
1232  scintillatorSolid =
1233  new G4SubtractionSolid(name, b, m_Solids.groove[iStrip], t);
1234  } catch (std::bad_alloc& ba) {
1235  B2FATAL(MemErr);
1236  }
1237  try {
1238  m_LogVol.scint[iStrip] =
1239  new G4LogicalVolume(scintillatorSolid, m_Materials.polystyrene,
1240  name, 0, m_Sensitive, 0);
1241  } catch (std::bad_alloc& ba) {
1242  B2FATAL(MemErr);
1243  }
1244  geometry::setVisibility(*m_LogVol.scint[iStrip], false);
1245  geometry::setColor(*m_LogVol.scint[iStrip], "#ffffffff");
1246 }
1247 
1249 {
1250  G4Box* box = nullptr;
1251  G4SubtractionSolid* ss1, *ss2, *ss3, *solidDetailA;
1252  double lx, ly;
1253  const EKLMGeometry::ShieldGeometry* shieldGeometry =
1254  m_GeoDat->getShieldGeometry();
1255  const EKLMGeometry::ShieldDetailGeometry* detailA =
1256  shieldGeometry->getDetailA();
1257  HepGeom::Transform3D t = HepGeom::Translate3D(0, 0, 0);
1258  lx = detailA->getLengthX() / 2;
1259  ly = detailA->getLengthY() / 2;
1260  try {
1261  box = new G4Box("ShieldDetailA_Box", lx, ly,
1262  shieldGeometry->getThickness() / 2);
1263  } catch (std::bad_alloc& ba) {
1264  B2FATAL(MemErr);
1265  }
1266  ss1 = cutSolidCorner("ShieldDetailA_Subtraction_1", box,
1267  m_Solids.subtractionBox, t, false,
1268  detailA->getPoint(0)->getX() - lx,
1269  detailA->getPoint(0)->getY() - ly,
1270  detailA->getPoint(1)->getX() - lx,
1271  detailA->getPoint(1)->getY() - ly);
1272  ss2 = cutSolidCorner("ShieldDetailA_Subtraction_2", ss1,
1273  m_Solids.subtractionBox, t, true,
1274  detailA->getPoint(3)->getX() - lx,
1275  detailA->getPoint(3)->getY() - ly,
1276  detailA->getPoint(2)->getX() - lx,
1277  detailA->getPoint(2)->getY() - ly);
1278  ss3 = cutSolidCorner("ShieldDetailA_Subtraction_3", ss2,
1279  m_Solids.subtractionBox, t, false,
1280  detailA->getPoint(3)->getX() - lx,
1281  detailA->getPoint(3)->getY() - ly,
1282  detailA->getPoint(4)->getX() - lx,
1283  detailA->getPoint(4)->getY() - ly);
1284  solidDetailA = cutSolidCorner("ShieldDetailA", ss3,
1285  m_Solids.subtractionBox, t, false,
1286  detailA->getPoint(5)->getX() - lx,
1287  detailA->getPoint(5)->getY() - ly,
1288  detailA->getPoint(6)->getX() - lx,
1289  detailA->getPoint(6)->getY() - ly);
1290  try {
1291  m_LogVol.shield.detailA =
1292  new G4LogicalVolume(solidDetailA, m_Materials.polyethylene,
1293  "ShieldDetailA");
1294  } catch (std::bad_alloc& ba) {
1295  B2FATAL(MemErr);
1296  }
1297  geometry::setVisibility(*m_LogVol.shield.detailA, true);
1298  geometry::setColor(*m_LogVol.shield.detailA, "#00ff00ff");
1299 }
1300 
1302 {
1303  G4Box* box = nullptr;
1304  G4SubtractionSolid* ss1, *solidDetailB;
1305  double lx, ly;
1306  const EKLMGeometry::ShieldGeometry* shieldGeometry =
1307  m_GeoDat->getShieldGeometry();
1308  const EKLMGeometry::ShieldDetailGeometry* detailB =
1309  shieldGeometry->getDetailB();
1310  HepGeom::Transform3D t = HepGeom::Translate3D(0, 0, 0);
1311  lx = detailB->getLengthX() / 2;
1312  ly = detailB->getLengthY() / 2;
1313  try {
1314  box = new G4Box("ShieldDetailB_Box", lx, ly,
1315  shieldGeometry->getThickness() / 2);
1316  } catch (std::bad_alloc& ba) {
1317  B2FATAL(MemErr);
1318  }
1319  ss1 = cutSolidCorner("ShieldDetailB_Subtraction_1", box,
1320  m_Solids.subtractionBox, t, false,
1321  detailB->getPoint(0)->getX() - lx,
1322  detailB->getPoint(0)->getY() - ly,
1323  detailB->getPoint(1)->getX() - lx,
1324  detailB->getPoint(1)->getY() - ly);
1325  solidDetailB = cutSolidCorner("ShieldDetailB", ss1,
1326  m_Solids.subtractionBox, t, false,
1327  detailB->getPoint(2)->getX() - lx,
1328  detailB->getPoint(2)->getY() - ly,
1329  detailB->getPoint(3)->getX() - lx,
1330  detailB->getPoint(3)->getY() - ly);
1331  try {
1332  m_LogVol.shield.detailB =
1333  new G4LogicalVolume(solidDetailB, m_Materials.polyethylene,
1334  "ShieldDetailB");
1335  } catch (std::bad_alloc& ba) {
1336  B2FATAL(MemErr);
1337  }
1338  geometry::setVisibility(*m_LogVol.shield.detailB, true);
1339  geometry::setColor(*m_LogVol.shield.detailB, "#00ff00ff");
1340 }
1341 
1343 {
1344  G4Box* box = nullptr;
1345  G4SubtractionSolid* ss1, *ss2, *ss3, *solidDetailC;
1346  double lx, ly;
1347  const EKLMGeometry::ShieldGeometry* shieldGeometry =
1348  m_GeoDat->getShieldGeometry();
1349  const EKLMGeometry::ShieldDetailGeometry* detailC =
1350  shieldGeometry->getDetailC();
1351  HepGeom::Transform3D t = HepGeom::Translate3D(0, 0, 0);
1352  lx = detailC->getLengthX() / 2;
1353  ly = detailC->getLengthY() / 2;
1354  try {
1355  box = new G4Box("ShieldDetailC_Box", lx, ly,
1356  shieldGeometry->getThickness() / 2);
1357  } catch (std::bad_alloc& ba) {
1358  B2FATAL(MemErr);
1359  }
1360  ss1 = cutSolidCorner("ShieldDetailC_Subtraction_1", box,
1361  m_Solids.subtractionBox, t, false,
1362  detailC->getPoint(0)->getX() - lx,
1363  detailC->getPoint(0)->getY() - ly,
1364  detailC->getPoint(1)->getX() - lx,
1365  detailC->getPoint(1)->getY() - ly);
1366  ss2 = cutSolidCorner("ShieldDetailC_Subtraction_2", ss1,
1367  m_Solids.subtractionBox, t, true,
1368  detailC->getPoint(3)->getX() - lx,
1369  detailC->getPoint(3)->getY() - ly,
1370  detailC->getPoint(2)->getX() - lx,
1371  detailC->getPoint(2)->getY() - ly);
1372  ss3 = cutSolidCorner("ShieldDetailC_Subtraction_3", ss2,
1373  m_Solids.subtractionBox, t, false,
1374  detailC->getPoint(3)->getX() - lx,
1375  detailC->getPoint(3)->getY() - ly,
1376  detailC->getPoint(4)->getX() - lx,
1377  detailC->getPoint(4)->getY() - ly);
1378  solidDetailC = cutSolidCorner("ShieldDetailC", ss3,
1379  m_Solids.subtractionBox, t, false,
1380  detailC->getPoint(5)->getX() - lx,
1381  detailC->getPoint(5)->getY() - ly,
1382  detailC->getPoint(6)->getX() - lx,
1383  detailC->getPoint(6)->getY() - ly);
1384  try {
1385  m_LogVol.shield.detailC =
1386  new G4LogicalVolume(solidDetailC, m_Materials.polyethylene,
1387  "ShieldDetailC");
1388  } catch (std::bad_alloc& ba) {
1389  B2FATAL(MemErr);
1390  }
1391  geometry::setVisibility(*m_LogVol.shield.detailC, true);
1392  geometry::setColor(*m_LogVol.shield.detailC, "#00ff00ff");
1393 }
1394 
1396 {
1397  G4TriangularPrism* solidDetailDPrism;
1398  const EKLMGeometry::ShieldGeometry* shieldGeometry =
1399  m_GeoDat->getShieldGeometry();
1400  const EKLMGeometry::ShieldDetailGeometry* detailD =
1401  shieldGeometry->getDetailD();
1402  try {
1403  solidDetailDPrism =
1404  new G4TriangularPrism("ShieldDetailD_Prism",
1405  detailD->getLengthX(), 0.,
1406  detailD->getLengthY(), 90. * CLHEP::deg,
1407  shieldGeometry->getThickness() / 2);
1408  } catch (std::bad_alloc& ba) {
1409  B2FATAL(MemErr);
1410  }
1411  try {
1412  m_LogVol.shield.detailD =
1413  new G4LogicalVolume(solidDetailDPrism->getSolid(),
1414  m_Materials.polyethylene, "ShieldDetailD");
1415  } catch (std::bad_alloc& ba) {
1416  B2FATAL(MemErr);
1417  }
1418  geometry::setVisibility(*m_LogVol.shield.detailD, true);
1419  geometry::setColor(*m_LogVol.shield.detailD, "#00ff00ff");
1420  delete solidDetailDPrism;
1421 }
1422 
1424 {
1425  int i, j, n;
1426  HepGeom::Transform3D t;
1427  /* Section, layer, sector. */
1428  createSectionSolid();
1429  createLayerSolid();
1430  m_LogVol.shieldLayer = createLayerLogicalVolume("ShieldLayer");
1431  createSectorSolid();
1432  m_LogVol.shieldLayerSector = createSectorLogicalVolume("ShieldLayerSector");
1433  createSectorCoverLogicalVolume();
1434  createSectorSupportLogicalVolume();
1439  createSectorSupportCorner1LogicalVolume();
1440  createSectorSupportCorner2LogicalVolume();
1441  createSectorSupportCorner3LogicalVolume();
1442  createSectorSupportCorner4LogicalVolume();
1443  /* Plane. */
1444  createSubtractionBoxSolid();
1445  for (i = 0; i < m_GeoDat->getNPlanes(); i++) {
1446  createPlaneSolid(i);
1447  /* Segment support. */
1448  for (j = 1; j <= m_GeoDat->getNSegments() + 1; j++)
1449  createSegmentSupportLogicalVolume(i + 1, j);
1450  }
1451  /* Strips. */
1452  n = m_GeoDat->getNStripsDifferentLength();
1453  for (i = 0; i < n; i++) {
1454  createStripLogicalVolume(i);
1455  createStripGrooveLogicalVolume(i);
1456  createScintillatorLogicalVolume(i);
1457  }
1458  /* Plastic sheet elements. */
1459  for (i = 0; i < m_GeoDat->getNSegments(); i++)
1460  createPlasticSheetLogicalVolume(i);
1461  /* Strip segments. */
1462  for (i = 0; i < m_GeoDat->getNSegments(); i++)
1463  createStripSegmentLogicalVolume(i);
1464  /* Segments. */
1465  for (i = 0; i < m_GeoDat->getNSegments(); i++)
1466  createSegmentLogicalVolume(i);
1467  /* Shield layer details. */
1468  createShieldDetailALogicalVolume();
1469  createShieldDetailBLogicalVolume();
1470  createShieldDetailCLogicalVolume();
1471  createShieldDetailDLogicalVolume();
1472 }
1473 
1474 /************************** CREATION OF VOLUMES ******************************/
1475 
1476 G4LogicalVolume*
1477 EKLM::GeoEKLMCreator::createSection(G4LogicalVolume* topVolume) const
1478 {
1479  G4LogicalVolume* logicSection = nullptr;
1480  const HepGeom::Transform3D* t;
1481  std::string sectionName = "Section_" + std::to_string(m_CurVol.section);
1482  try {
1483  logicSection = new G4LogicalVolume(m_Solids.section, m_Materials.iron,
1484  sectionName);
1485  } catch (std::bad_alloc& ba) {
1486  B2FATAL(MemErr);
1487  }
1488  geometry::setVisibility(*logicSection, true);
1489  geometry::setColor(*logicSection, "#ffffff22");
1490  t = m_TransformData->getSectionTransform(m_CurVol.section);
1491  try {
1492  new G4PVPlacement(*t, logicSection, sectionName, topVolume, false,
1493  m_CurVol.section, false);
1494  } catch (std::bad_alloc& ba) {
1495  B2FATAL(MemErr);
1496  }
1497  return logicSection;
1498 }
1499 
1500 G4LogicalVolume* EKLM::GeoEKLMCreator::
1501 createLayer(G4LogicalVolume* section, G4LogicalVolume* layer) const
1502 {
1503  G4LogicalVolume* logicLayer;
1504  const HepGeom::Transform3D* t;
1505  if (layer == nullptr) {
1506  std::string layerName = "Layer_" + std::to_string(m_CurVol.layer) +
1507  "_" + section->GetName();
1508  logicLayer = createLayerLogicalVolume(layerName.c_str());
1509  } else
1510  logicLayer = layer;
1511  t = m_TransformData->getLayerTransform(m_CurVol.section, m_CurVol.layer);
1512  try {
1513  new G4PVPlacement(*t, logicLayer, logicLayer->GetName(), section, false,
1514  m_CurVol.layer, false);
1515  } catch (std::bad_alloc& ba) {
1516  B2FATAL(MemErr);
1517  }
1518  return logicLayer;
1519 }
1520 
1521 G4LogicalVolume* EKLM::GeoEKLMCreator::
1522 createSector(G4LogicalVolume* layer, G4LogicalVolume* sector) const
1523 {
1524  G4LogicalVolume* logicSector;
1525  const HepGeom::Transform3D* t;
1526  if (sector == nullptr) {
1527  std::string sectorName = "Sector_" + std::to_string(m_CurVol.sector) +
1528  "_" + layer->GetName();
1529  logicSector = createSectorLogicalVolume(sectorName.c_str());
1530  } else
1531  logicSector = sector;
1532  t = m_TransformData->getSectorTransform(m_CurVol.section, m_CurVol.layer,
1533  m_CurVol.sector);
1534  try {
1535  new G4PVPlacement(*t, logicSector, logicSector->GetName(), layer, false,
1536  m_CurVol.sector, false);
1537  } catch (std::bad_alloc& ba) {
1538  B2FATAL(MemErr);
1539  }
1540  return logicSector;
1541 }
1542 
1544 createSectorCover(int iCover, G4LogicalVolume* sector) const
1545 {
1546  double z;
1547  HepGeom::Transform3D t;
1548  G4LogicalVolume* lv = m_LogVol.cover;
1549  const EKLMGeometry::ElementPosition* sectorPos =
1550  m_GeoDat->getSectorPosition();
1551  const EKLMGeometry::ElementPosition* sectorSupportPos =
1552  m_GeoDat->getSectorSupportPosition();
1553  z = 0.25 * (sectorPos->getLength() + sectorSupportPos->getLength());
1554  if (iCover == 2)
1555  z = -z;
1556  t = HepGeom::Translate3D(0., 0., z);
1557  try {
1558  new G4PVPlacement(t, lv, lv->GetName() + "_" + sector->GetName(), sector,
1559  false, 1, false);
1560  } catch (std::bad_alloc& ba) {
1561  B2FATAL(MemErr);
1562  }
1563 }
1564 
1566 createSectorSupportCorner1(G4LogicalVolume* sector) const
1567 {
1568  HepGeom::Transform3D t;
1569  G4LogicalVolume* lv = m_LogVol.sectorsup.corn1;
1570  const EKLMGeometry::SectorSupportGeometry* sectorSupportGeometry =
1571  m_GeoDat->getSectorSupportGeometry();
1572  t = HepGeom::Translate3D(0., 0., sectorSupportGeometry->getCorner1Z());
1573  try {
1574  new G4PVPlacement(t, lv, lv->GetName() + "_" + sector->GetName(), sector,
1575  false, 1, false);
1576  } catch (std::bad_alloc& ba) {
1577  B2FATAL(MemErr);
1578  }
1579 }
1580 
1582 createSectorSupportCorner2(G4LogicalVolume* sector) const
1583 {
1584  HepGeom::Transform3D t;
1585  G4LogicalVolume* lv = m_LogVol.sectorsup.corn2;
1586  const EKLMGeometry::SectorSupportGeometry* sectorSupportGeometry =
1587  m_GeoDat->getSectorSupportGeometry();
1588  t = HepGeom::Translate3D(sectorSupportGeometry->getCorner2Inner().x(),
1589  sectorSupportGeometry->getCorner2Inner().y(),
1590  sectorSupportGeometry->getCorner2Z());
1591  try {
1592  new G4PVPlacement(t, lv, lv->GetName() + "_" + sector->GetName(), sector,
1593  false, 1, false);
1594  } catch (std::bad_alloc& ba) {
1595  B2FATAL(MemErr);
1596  }
1597 }
1598 
1600 createSectorSupportCorner3(G4LogicalVolume* sector) const
1601 {
1602  HepGeom::Transform3D t;
1603  G4LogicalVolume* lv = m_LogVol.sectorsup.corn3;
1604  const EKLMGeometry::SectorSupportGeometry* sectorSupportGeometry =
1605  m_GeoDat->getSectorSupportGeometry();
1606  t = HepGeom::Translate3D(sectorSupportGeometry->getCorner3Prism().x(),
1607  sectorSupportGeometry->getCorner3Prism().y(),
1608  sectorSupportGeometry->getCorner3Z());
1609  try {
1610  new G4PVPlacement(t, lv, lv->GetName() + "_" + sector->GetName(), sector,
1611  false, 1, false);
1612  } catch (std::bad_alloc& ba) {
1613  B2FATAL(MemErr);
1614  }
1615 }
1616 
1618 createSectorSupportCorner4(G4LogicalVolume* sector) const
1619 {
1620  HepGeom::Transform3D t;
1621  G4LogicalVolume* lv = m_LogVol.sectorsup.corn4;
1622  const EKLMGeometry::SectorSupportGeometry* sectorSupportGeometry =
1623  m_GeoDat->getSectorSupportGeometry();
1624  t = HepGeom::Translate3D(sectorSupportGeometry->getCorner4Prism().x(),
1625  sectorSupportGeometry->getCorner4Prism().y(),
1626  sectorSupportGeometry->getCorner4Z());
1627  try {
1628  new G4PVPlacement(t, lv, lv->GetName() + "_" + sector->GetName(), sector,
1629  false, 1, false);
1630  } catch (std::bad_alloc& ba) {
1631  B2FATAL(MemErr);
1632  }
1633 }
1634 
1636 createSectorSupport(G4LogicalVolume* sector) const
1637 {
1638  HepGeom::Transform3D t;
1639  G4LogicalVolume* lv = m_LogVol.sectorsup.supp;
1640  const EKLMGeometry::ElementPosition* sectorSupportPos =
1641  m_GeoDat->getSectorSupportPosition();
1642  t = HepGeom::Translate3D(0., 0., sectorSupportPos->getZ());
1643  try {
1644  new G4PVPlacement(t, lv, lv->GetName() + "_" + sector->GetName(), sector,
1645  false, 1, false);
1646  } catch (std::bad_alloc& ba) {
1647  B2FATAL(MemErr);
1648  }
1649 }
1650 
1651 G4LogicalVolume*
1652 EKLM::GeoEKLMCreator::createPlane(G4LogicalVolume* sector) const
1653 {
1654  G4LogicalVolume* logicPlane = nullptr;
1655  const HepGeom::Transform3D* t;
1656  std::string planeName =
1657  "Plane_" + std::to_string(m_CurVol.plane) + "_" + sector->GetName();
1658  try {
1659  logicPlane = new G4LogicalVolume(m_Solids.plane[m_CurVol.plane - 1],
1660  m_Materials.air, planeName);
1661  } catch (std::bad_alloc& ba) {
1662  B2FATAL(MemErr);
1663  }
1664  geometry::setVisibility(*logicPlane, false);
1665  t = m_TransformData->getPlaneTransform(m_CurVol.section, m_CurVol.layer,
1666  m_CurVol.sector, m_CurVol.plane);
1667  try {
1668  new G4PVPlacement(*t, logicPlane, planeName, sector, false,
1669  m_CurVol.plane, false);
1670  } catch (std::bad_alloc& ba) {
1671  B2FATAL(MemErr);
1672  }
1673  return logicPlane;
1674 }
1675 
1677 createSegmentSupport(int iSegmentSupport, G4LogicalVolume* plane) const
1678 {
1679  HepGeom::Transform3D t;
1680  G4LogicalVolume* lv =
1681  m_LogVol.segmentsup[m_CurVol.plane - 1][iSegmentSupport - 1];
1682  const EKLMGeometry::SegmentSupportPosition* segmentSupportPos =
1683  m_GeoDat->getSegmentSupportPosition(m_CurVol.plane, iSegmentSupport);
1684  t = (*m_TransformData->getPlaneDisplacement(m_CurVol.section, m_CurVol.layer,
1685  m_CurVol.sector, m_CurVol.plane)) *
1686  HepGeom::Translate3D(
1687  0.5 * (segmentSupportPos->getDeltaLLeft() -
1688  segmentSupportPos->getDeltaLRight()) +
1689  segmentSupportPos->getX(), segmentSupportPos->getY(),
1690  segmentSupportPos->getZ()) *
1691  HepGeom::RotateX3D(180.0 * CLHEP::deg);
1692  try {
1693  new G4PVPlacement(t, lv, lv->GetName() + "_" + plane->GetName(), plane,
1694  false, 1, false);
1695  } catch (std::bad_alloc& ba) {
1696  B2FATAL(MemErr);
1697  }
1698 }
1699 
1700 void EKLM::GeoEKLMCreator::createPlasticSheet(int iSheetPlane, int iSheet) const
1701 {
1702  double z;
1703  HepGeom::Transform3D t;
1704  const EKLMGeometry::PlasticSheetGeometry* plasticSheetGeometry =
1705  m_GeoDat->getPlasticSheetGeometry();
1706  const EKLMGeometry::StripGeometry* stripGeometry =
1707  m_GeoDat->getStripGeometry();
1708  std::string sheetName =
1709  "Sheet_" + std::to_string(iSheet) +
1710  "_SheetPlane_" + std::to_string(iSheetPlane);
1711  z = 0.5 * (stripGeometry->getThickness() + plasticSheetGeometry->getWidth());
1712  if (iSheetPlane == 2)
1713  z = -z;
1714  t = HepGeom::Translate3D(0, 0, z);
1715  try {
1716  new G4PVPlacement(t, m_LogVol.psheet[iSheet - 1], sheetName,
1717  m_LogVol.segment[iSheet - 1], false, (iSheetPlane - 1) *
1718  m_GeoDat->getNSegments() + iSheet, false);
1719  } catch (std::bad_alloc& ba) {
1720  B2FATAL(MemErr);
1721  }
1722 }
1723 
1725 {
1726  HepGeom::Transform3D t;
1727  std::string segmentName = "StripSegment_" + std::to_string(iSegment);
1728  t = HepGeom::Translate3D(0, 0, 0);
1729  try {
1730  new G4PVPlacement(t, m_LogVol.stripSegment[iSegment - 1], segmentName,
1731  m_LogVol.segment[iSegment - 1], false, iSegment, false);
1732  } catch (std::bad_alloc& ba) {
1733  B2FATAL(MemErr);
1734  }
1735 }
1736 
1737 void EKLM::GeoEKLMCreator::createSegment(G4LogicalVolume* plane) const
1738 {
1739  HepGeom::Transform3D t;
1740  std::string segmentName =
1741  "Segment_" + std::to_string(m_CurVol.segment) + "_" + plane->GetName();
1742  t = (*m_TransformData->getPlaneDisplacement(m_CurVol.section, m_CurVol.layer,
1743  m_CurVol.sector, m_CurVol.plane)) *
1744  (*m_TransformData->getSegmentTransform(
1745  m_CurVol.section, m_CurVol.layer, m_CurVol.sector, m_CurVol.plane,
1746  m_CurVol.segment));
1747  try {
1748  new G4PVPlacement(t, m_LogVol.segment[m_CurVol.segment - 1], segmentName,
1749  plane, false, m_CurVol.segment, false);
1750  } catch (std::bad_alloc& ba) {
1751  B2FATAL(MemErr);
1752  }
1753 }
1754 
1755 void EKLM::GeoEKLMCreator::createStrip(G4LogicalVolume* segment) const
1756 {
1757  int n;
1758  HepGeom::Transform3D t, t2;
1759  G4LogicalVolume* lv;
1760  n = m_GeoDat->getStripLengthIndex(m_CurVol.strip - 1);
1761  m_GeoDat->getStripTransform(&t, m_CurVol.strip - 1);
1762  t2 = t * HepGeom::RotateX3D(180.0 * CLHEP::deg);
1763  lv = m_LogVol.strip[n];
1764  try {
1765  new G4PVPlacement(t2, lv, lv->GetName(), segment, false, m_CurVol.strip,
1766  false);
1767  } catch (std::bad_alloc& ba) {
1768  B2FATAL(MemErr);
1769  }
1770 }
1771 
1773 {
1774  HepGeom::Transform3D t;
1775  G4LogicalVolume* lv;
1776  G4LogicalVolume* lvm;
1777  const EKLMGeometry::StripGeometry* stripGeometry =
1778  m_GeoDat->getStripGeometry();
1779  t = HepGeom::Translate3D(0., 0., 0.5 * (stripGeometry->getThickness() -
1780  stripGeometry->getGrooveDepth()));
1781  lvm = m_LogVol.strip[iStrip];
1782  lv = m_LogVol.groove[iStrip];
1783  try {
1784  new G4PVPlacement(t, lv, lv->GetName(), lvm, false, 1, false);
1785  } catch (std::bad_alloc& ba) {
1786  B2FATAL(MemErr);
1787  }
1788 }
1789 
1791 {
1792  HepGeom::Transform3D t;
1793  G4LogicalVolume* lv;
1794  G4LogicalVolume* lvm;
1795  t = HepGeom::Translate3D(0., 0., 0.);
1796  lvm = m_LogVol.strip[iStrip];
1797  lv = m_LogVol.scint[iStrip];
1798  try {
1799  new G4PVPlacement(t, lv, lv->GetName(), lvm, false, 1, false);
1800  } catch (std::bad_alloc& ba) {
1801  B2FATAL(MemErr);
1802  }
1803 }
1804 
1805 void EKLM::GeoEKLMCreator::createShield(G4LogicalVolume* sector) const
1806 {
1807  HepGeom::Transform3D ta, tb, tc, td, te;
1808  G4LogicalVolume* lv;
1809  double lx, ly;
1810  const double asqrt2 = 1.0 / sqrt(2.0);
1811  const EKLMGeometry::ShieldGeometry* shieldGeometry =
1812  m_GeoDat->getShieldGeometry();
1813  lx = shieldGeometry->getDetailB()->getLengthX() / 2;
1814  ly = shieldGeometry->getDetailB()->getLengthY() / 2;
1815  ta = HepGeom::Translate3D(shieldGeometry->getDetailACenter()->getX(),
1816  shieldGeometry->getDetailACenter()->getY(), 0) *
1817  HepGeom::RotateZ3D(-45.0 * CLHEP::deg);
1818  tb = HepGeom::Translate3D(shieldGeometry->getDetailBCenter()->getX(),
1819  shieldGeometry->getDetailBCenter()->getY(), 0) *
1820  HepGeom::RotateZ3D(-45.0 * CLHEP::deg);
1821  tc = HepGeom::Translate3D(shieldGeometry->getDetailCCenter()->getX(),
1822  shieldGeometry->getDetailCCenter()->getY(), 0) *
1823  HepGeom::RotateZ3D(-45.0 * CLHEP::deg) *
1824  HepGeom::RotateY3D(180.0 * CLHEP::deg);
1825  td = HepGeom::Translate3D(
1826  shieldGeometry->getDetailBCenter()->getX() + asqrt2 * (-lx - ly),
1827  shieldGeometry->getDetailBCenter()->getY() + asqrt2 * (lx - ly), 0) *
1828  HepGeom::RotateZ3D(-45.0 * CLHEP::deg) *
1829  HepGeom::RotateX3D(180.0 * CLHEP::deg);
1830  te = HepGeom::Translate3D(
1831  shieldGeometry->getDetailBCenter()->getX() + asqrt2 * (lx - ly),
1832  shieldGeometry->getDetailBCenter()->getY() + asqrt2 * (-lx - ly), 0) *
1833  HepGeom::RotateZ3D(135.0 * CLHEP::deg);
1834  lv = m_LogVol.shield.detailA;
1835  try {
1836  new G4PVPlacement(ta, lv, lv->GetName(), sector, false, 1, false);
1837  } catch (std::bad_alloc& ba) {
1838  B2FATAL(MemErr);
1839  }
1840  lv = m_LogVol.shield.detailB;
1841  try {
1842  new G4PVPlacement(tb, lv, lv->GetName(), sector, false, 1, false);
1843  } catch (std::bad_alloc& ba) {
1844  B2FATAL(MemErr);
1845  }
1846  lv = m_LogVol.shield.detailC;
1847  try {
1848  new G4PVPlacement(tc, lv, lv->GetName(), sector, false, 1, false);
1849  } catch (std::bad_alloc& ba) {
1850  B2FATAL(MemErr);
1851  }
1852  lv = m_LogVol.shield.detailD;
1853  try {
1854  new G4PVPlacement(td, lv, lv->GetName(), sector, false, 1, false);
1855  } catch (std::bad_alloc& ba) {
1856  B2FATAL(MemErr);
1857  }
1858  try {
1859  new G4PVPlacement(te, lv, "ShieldDetailE", sector, false, 1, false);
1860  } catch (std::bad_alloc& ba) {
1861  B2FATAL(MemErr);
1862  }
1863 }
1864 
1865 bool EKLM::GeoEKLMCreator::detectorLayer(int section, int layer) const
1866 {
1867  return ((section == 1 && layer <= m_GeoDat->getNDetectorLayers(1)) ||
1868  (section == 2 && layer <= m_GeoDat->getNDetectorLayers(2)));
1869 }
1870 
1871 void EKLM::GeoEKLMCreator::create(G4LogicalVolume& topVolume)
1872 {
1873  /* cppcheck-suppress variableScope */
1874  int i, j, imin, imax;
1875  /* cppcheck-suppress variableScope */
1876  G4LogicalVolume* section, *layer, *sector, *plane;
1877  createMaterials();
1878  createSolids();
1879  /* Create physical volumes which are used only once. */
1880  for (i = 0; i < m_GeoDat->getNStripsDifferentLength(); i++) {
1881  createStripGroove(i);
1882  createScintillator(i);
1883  }
1884  for (i = 0; i < m_GeoDat->getNSegments(); i++) {
1885  imin = i * m_ElementNumbers->getNStripsSegment();
1886  imax = (i + 1) * m_ElementNumbers->getNStripsSegment();
1887  for (m_CurVol.strip = imin + 1; m_CurVol.strip <= imax; m_CurVol.strip++)
1888  createStrip(m_LogVol.stripSegment[i]);
1889  }
1890  for (i = 1; i <= m_GeoDat->getNSegments(); i++) {
1891  for (j = 1; j <= 2; j++)
1892  createPlasticSheet(j, i);
1893  createStripSegment(i);
1894  }
1895  /* Create other volumes. */
1896  /* Set up region for production cuts. */
1897  G4Region* aRegion = new G4Region("EKLMEnvelope");
1898  for (m_CurVol.section = 1; m_CurVol.section <= m_GeoDat->getNSections();
1899  m_CurVol.section++) {
1900  section = createSection(&topVolume);
1901  /* Assign same region to each section. */
1902  section->SetRegion(aRegion);
1903  aRegion->AddRootLogicalVolume(section);
1904  for (m_CurVol.layer = 1; m_CurVol.layer <= m_GeoDat->getNLayers();
1905  m_CurVol.layer++) {
1906  if (detectorLayer(m_CurVol.section, m_CurVol.layer)) {
1907  /* Detector layer. */
1908  layer = createLayer(section, nullptr);
1909  for (m_CurVol.sector = 1; m_CurVol.sector <= m_GeoDat->getNSectors();
1910  m_CurVol.sector++) {
1911  sector = createSector(layer, nullptr);
1912  createSectorSupport(sector);
1913  createSectorSupportCorner1(sector);
1914  createSectorSupportCorner2(sector);
1915  createSectorSupportCorner3(sector);
1916  createSectorSupportCorner4(sector);
1917  for (i = 1; i <= 2; i++)
1918  createSectorCover(i, sector);
1919  for (m_CurVol.plane = 1; m_CurVol.plane <= m_GeoDat->getNPlanes();
1920  m_CurVol.plane++) {
1921  plane = createPlane(sector);
1922  for (i = 1; i <= m_GeoDat->getNSegments() + 1; i++)
1923  createSegmentSupport(i, plane);
1924  for (m_CurVol.segment = 1;
1925  m_CurVol.segment <= m_GeoDat->getNSegments();
1926  m_CurVol.segment++)
1927  createSegment(plane);
1928  }
1929  }
1930  } else {
1931  /* Shield layer. */
1932  layer = createLayer(section, m_LogVol.shieldLayer);
1933  for (m_CurVol.sector = 1; m_CurVol.sector <= m_GeoDat->getNSectors();
1934  m_CurVol.sector++)
1935  createSector(layer, m_LogVol.shieldLayerSector);
1936  createSectorSupport(m_LogVol.shieldLayerSector);
1937  createSectorSupportCorner1(m_LogVol.shieldLayerSector);
1938  createSectorSupportCorner2(m_LogVol.shieldLayerSector);
1939  createSectorSupportCorner3(m_LogVol.shieldLayerSector);
1940  createSectorSupportCorner4(m_LogVol.shieldLayerSector);
1941  for (i = 1; i <= 2; i++)
1942  createSectorCover(i, m_LogVol.shieldLayerSector);
1943  createShield(m_LogVol.shieldLayerSector);
1944  }
1945  }
1946  }
1947 }
1948 
1950  G4LogicalVolume& topVolume,
1952 {
1953  (void)content;
1954  (void)type;
1955  m_GeoDat = &(EKLM::GeometryData::Instance(GeometryData::c_Gearbox, &content));
1956  try {
1957  m_TransformData =
1959  } catch (std::bad_alloc& ba) {
1960  B2FATAL(MemErr);
1961  }
1962  newVolumes();
1963  newSensitive();
1964  create(topVolume);
1965 }
1966 
1967 void EKLM::GeoEKLMCreator::createFromDB(const std::string& name,
1968  G4LogicalVolume& topVolume,
1970 {
1971  (void)name;
1972  (void)type;
1974  try {
1975  m_TransformData =
1977  } catch (std::bad_alloc& ba) {
1978  B2FATAL(MemErr);
1979  }
1980  newVolumes();
1981  newSensitive();
1982  create(topVolume);
1983 }
1984 
1986  const IntervalOfValidity& iov)
1987 {
1988  (void)content;
1989  m_GeoDat = &(EKLM::GeometryData::Instance(GeometryData::c_Gearbox, &content));
1990  try {
1991  m_TransformData =
1993  } catch (std::bad_alloc& ba) {
1994  B2FATAL(MemErr);
1995  }
1996  m_GeoDat->saveToDatabase(iov);
1997 }
1998 
Belle2::IntervalOfValidity
A class that describes the interval of experiments/runs for which an object in the database is valid.
Definition: IntervalOfValidity.h:35
Belle2::EKLMGeometry::SectorSupportGeometry::getCorner4LX
double getCorner4LX() const
Get corner 4 X length.
Definition: EKLMGeometry.h:516
Belle2::EKLM::LogicalVolumes::segmentsup
G4LogicalVolume *** segmentsup
Definition: GeoEKLMCreator.h:180
Belle2::EKLMGeometry::SectorSupportGeometry::getCorner1LX
double getCorner1LX() const
Get corner 1 X length.
Definition: EKLMGeometry.h:312
Belle2::EKLM::GeoEKLMCreator::deleteSensitive
void deleteSensitive()
Delete sensitive detectors.
Definition: GeoEKLMCreator.cc:172
Belle2::EKLMGeometry::EndcapStructureGeometry
Endcap srtucture geometry parameters.
Definition: EKLMGeometry.h:46
Belle2::EKLM::GeoEKLMCreator::createSectorSupportLogicalVolume
void createSectorSupportLogicalVolume()
Create sector support logical volume.
Definition: GeoEKLMCreator.cc:675
Belle2::EKLM::GeoEKLMCreator::createSectorSupportCorner4LogicalVolume
void createSectorSupportCorner4LogicalVolume()
Create sector support corner 4 logical volume.
Definition: GeoEKLMCreator.cc:638
Belle2::EKLM::VolumeNumbers::section
int section
Section.
Definition: GeoEKLMCreator.h:203
Belle2::EKLM::GeoEKLMCreator::createSection
G4LogicalVolume * createSection(G4LogicalVolume *topVolume) const
Create section.
Definition: GeoEKLMCreator.cc:1477
Belle2::EKLM::GeoEKLMCreator::cutSolidCorner
G4SubtractionSolid * cutSolidCorner(const char *name, G4VSolid *solid, G4Box *subtractionBox, HepGeom::Transform3D &transf, bool largerAngles, double x1, double y1, double x2, double y2)
Cut corner of a solid.
Definition: GeoEKLMCreator.cc:761
Belle2::EKLM::GeoEKLMCreator::createSegmentSupport
void createSegmentSupport(int iSegmentSupport, G4LogicalVolume *plane) const
Create segment support.
Definition: GeoEKLMCreator.cc:1677
Belle2::EKLM::TransformData
Transformation data.
Definition: TransformData.h:37
Belle2::G4TriangularPrism::getSolid
G4VSolid * getSolid()
Get solid.
Definition: G4TriangularPrism.h:79
Belle2::EKLMGeometry::ElementPosition::getZ
double getZ() const
Get Z coordinate.
Definition: EKLMGeometry.h:207
Belle2::EKLM::GeoEKLMCreator::createShieldDetailALogicalVolume
void createShieldDetailALogicalVolume()
Create shield detail A logical volume.
Definition: GeoEKLMCreator.cc:1248
Belle2::EKLM::GeoEKLMCreator::createStripGroove
void createStripGroove(int iStrip) const
Create strip groove.
Definition: GeoEKLMCreator.cc:1772
Belle2::EKLMGeometry::SectorSupportGeometry::getCorner1Thickness
double getCorner1Thickness() const
Get corner 1 thickness.
Definition: EKLMGeometry.h:346
Belle2::geometry::setColor
void setColor(G4LogicalVolume &volume, const std::string &color)
Set the color of a logical volume.
Definition: utilities.cc:107
Belle2::EKLMGeometry::SegmentSupportPosition::getY
double getY() const
Get Y coordinate.
Definition: EKLMGeometry.h:1128
Belle2::EKLMGeometry::SegmentSupportGeometry
Segment support geometry data.
Definition: EKLMGeometry.h:949
Belle2::EKLMGeometry::ShieldGeometry::getDetailC
const ShieldDetailGeometry * getDetailC() const
Get detail C geometry.
Definition: EKLMGeometry.h:1555
Belle2::EKLMGeometry::SectorSupportGeometry::getCorner2Thickness
double getCorner2Thickness() const
Get corner 2 thickness.
Definition: EKLMGeometry.h:414
Belle2::G4TriangularPrism
Triangular prism.
Definition: G4TriangularPrism.h:35
Belle2::EKLMGeometry::SectorSupportGeometry::getDeltaLY
double getDeltaLY() const
Get outerR - Y of upper edge of BoxY.
Definition: EKLMGeometry.h:278
Belle2::EKLMGeometry::SectorSupportGeometry::getCorner3LX
double getCorner3LX() const
Get corner 3 X length.
Definition: EKLMGeometry.h:448
Belle2::EKLMGeometry::SectorSupportGeometry::getCorner2LY
double getCorner2LY() const
Get corner 2 Y length.
Definition: EKLMGeometry.h:397
Belle2::EKLMGeometry::PlasticSheetGeometry::getDeltaL
double getDeltaL() const
Get Delta L (edge of last strip - edge of plastic sheet distance).
Definition: EKLMGeometry.h:919
Belle2::EKLMGeometry::StripGeometry::getThickness
double getThickness() const
Get thickness.
Definition: EKLMGeometry.h:1216
Belle2::EKLMGeometry::SegmentSupportPosition::getDeltaLRight
double getDeltaLRight() const
Get right Delta L.
Definition: EKLMGeometry.h:1060
Belle2::EKLM::GeoEKLMCreator::createLayerLogicalVolume
G4LogicalVolume * createLayerLogicalVolume(const char *name) const
Create layer logical volume.
Definition: GeoEKLMCreator.cc:231
Belle2::EKLM::GeoEKLMCreator::createSubtractionBoxSolid
void createSubtractionBoxSolid()
Create subtraction box solid.
Definition: GeoEKLMCreator.cc:746
Belle2::EKLM::GeoEKLMCreator::detectorLayer
bool detectorLayer(int section, int layer) const
Check if a given layer is a detector layer.
Definition: GeoEKLMCreator.cc:1865
Belle2::EKLMGeometry::SectorSupportGeometry::getCorner1Width
double getCorner1Width() const
Get corner 1 width.
Definition: EKLMGeometry.h:329
Belle2::EKLM::GeoEKLMCreator::createShieldDetailCLogicalVolume
void createShieldDetailCLogicalVolume()
Create shield detail C logical volume.
Definition: GeoEKLMCreator.cc:1342
Belle2::EKLMGeometry::StripGeometry::getGrooveDepth
double getGrooveDepth() const
Get groove depth.
Definition: EKLMGeometry.h:1233
Belle2::EKLMGeometry::ShieldGeometry
Shield layer geometry data.
Definition: EKLMGeometry.h:1492
Belle2::EKLMGeometry::SegmentSupportPosition::getLength
double getLength() const
Get length.
Definition: EKLMGeometry.h:1094
Belle2::EKLM::GeoEKLMCreator::createSegmentSupportLogicalVolume
void createSegmentSupportLogicalVolume(int iPlane, int iSegmentSupport)
Create segment support logical volume.
Definition: GeoEKLMCreator.cc:878
Belle2::EKLMGeometry::ShieldGeometry::getDetailCCenter
const Point * getDetailCCenter() const
Get detail C center.
Definition: EKLMGeometry.h:1619
Belle2::EKLM::Materials::air
G4Material * air
Air.
Definition: GeoEKLMCreator.h:189
Belle2::EKLMGeometry::SectorSupportGeometry
Sector support geometry data.
Definition: EKLMGeometry.h:249
Belle2::EKLM::Solids::psheet
G4VSolid ** psheet
Definition: GeoEKLMCreator.h:123
Belle2::EKLM::GeoEKLMCreator::create
void create(const GearDir &content, G4LogicalVolume &topVolume, geometry::GeometryTypes type) override
Creation of the detector geometry from Gearbox (XML).
Definition: GeoEKLMCreator.cc:1949
Belle2::EKLM::GeoEKLMCreator::createSectorSupportCorner4
void createSectorSupportCorner4(G4LogicalVolume *sector) const
Create sector support corner 4.
Definition: GeoEKLMCreator.cc:1618
Belle2::EKLMGeometry::ShieldDetailGeometry
Shield layer detail geometry data.
Definition: EKLMGeometry.h:1385
Belle2::EKLM::GeoEKLMCreator::m_Sensitive
EKLMSensitiveDetector * m_Sensitive
Sensitive detector.
Definition: GeoEKLMCreator.h:672
Belle2::EKLMGeometry::SectorSupportGeometry::getCorner1B
const HepGeom::Point3D< double > & getCorner1B() const
Get corner 1B coordinates.
Definition: EKLMGeometry.h:635
Belle2::EKLMGeometry::ElementPosition
Position information for the elements of detector.
Definition: EKLMGeometry.h:110
Belle2::EKLM::GeoEKLMCreator::createSectorSupportBoxX
G4Box * createSectorSupportBoxX(G4Transform3D &t)
Create X side of sector support structure.
Definition: GeoEKLMCreator.cc:352
Belle2::EKLMGeometry::SectorSupportGeometry::getCornerX
double getCornerX() const
Get coordinate X of corner 1.
Definition: EKLMGeometry.h:295
Belle2::EKLMGeometry::StripGeometry::getGrooveWidth
double getGrooveWidth() const
Get groove width.
Definition: EKLMGeometry.h:1250
Belle2::EKLM::GeoEKLMCreator::deleteVolumes
void deleteVolumes()
Delete volumes.
Definition: GeoEKLMCreator.cc:152
Belle2::EKLM::GeoEKLMCreator::createSolids
void createSolids()
Create solids (or logical volumes which must be created only once).
Definition: GeoEKLMCreator.cc:1423
Belle2::EKLM::GeoEKLMCreator::createSegment
void createSegment(G4LogicalVolume *plane) const
Create segment (strips + plastic sheets).
Definition: GeoEKLMCreator.cc:1737
Belle2::EKLM::GeoEKLMCreator::createStripGrooveLogicalVolume
void createStripGrooveLogicalVolume(int iStrip)
Create strip groove logical volume.
Definition: GeoEKLMCreator.cc:1177
Belle2::EKLM::GeometryData::c_Gearbox
@ c_Gearbox
Gearbox (XML).
Definition: GeometryData.h:48
Belle2::EKLM::GeoEKLMCreator::createSectorCoverLogicalVolume
void createSectorCoverLogicalVolume()
Create sector cover solid.
Definition: GeoEKLMCreator.cc:281
Belle2::EKLMGeometry::SegmentSupportGeometry::getMiddleWidth
double getMiddleWidth() const
Get middle part width.
Definition: EKLMGeometry.h:995
Belle2::EKLMGeometry::PlasticSheetGeometry
Plastic sheet geometry data.
Definition: EKLMGeometry.h:890
Belle2::EKLM::GeoEKLMCreator::m_Solids
struct Solids m_Solids
Solids.
Definition: GeoEKLMCreator.h:651
Belle2::EKLMGeometry::EndcapStructureGeometry::getNSides
int getNSides() const
Get number of sides.
Definition: EKLMGeometry.h:80
Belle2::EKLM::GeoEKLMCreator::createSectorSupportCorner3
void createSectorSupportCorner3(G4LogicalVolume *sector) const
Create sector support corner 3.
Definition: GeoEKLMCreator.cc:1600
Belle2::EKLMGeometry::ElementPosition::getInnerR
double getInnerR() const
Get inner radius.
Definition: EKLMGeometry.h:122
Belle2::EKLMGeometry::SectorSupportGeometry::getCorner4Z
double getCorner4Z() const
Get corner 4 Z coordinate.
Definition: EKLMGeometry.h:567
Belle2::geometry::Materials::get
static G4Material * get(const std::string &name)
Find given material.
Definition: Materials.h:65
Belle2::EKLM::GeoEKLMCreator::createShieldDetailBLogicalVolume
void createShieldDetailBLogicalVolume()
Create shield detail B logical volume.
Definition: GeoEKLMCreator.cc:1301
Belle2::EKLM::GeoEKLMCreator::newSensitive
void newSensitive()
Create new sensitive detectors.
Definition: GeoEKLMCreator.cc:142
Belle2::EKLMGeometry::SectorSupportGeometry::getCorner2Z
double getCorner2Z() const
Get corner 2 Z coordinate.
Definition: EKLMGeometry.h:431
Belle2::EKLM::LogicalVolumes::scint
G4LogicalVolume ** scint
Definition: GeoEKLMCreator.h:178
Belle2::EKLM::GeoEKLMCreator::createSectorSupportCorner1LogicalVolume
void createSectorSupportCorner1LogicalVolume()
Create sector support corner 1 logical volume.
Definition: GeoEKLMCreator.cc:485
Belle2::EKLMGeometry::StripGeometry::getNoScintillationThickness
double getNoScintillationThickness() const
Get nonscintillating layer thickness.
Definition: EKLMGeometry.h:1267
Belle2::EKLM::GeoEKLMCreator::createSectorSupportInnerTube
G4Tubs * createSectorSupportInnerTube()
Create inner tube of sector support structure.
Definition: GeoEKLMCreator.cc:433
Belle2::EKLM::GeoEKLMCreator::createSectorSupportCorner2
void createSectorSupportCorner2(G4LogicalVolume *sector) const
Create sector support corner 2.
Definition: GeoEKLMCreator.cc:1582
Belle2::EKLM::GeoEKLMCreator::createSectorSupportBoxY
G4Box * createSectorSupportBoxY(G4Transform3D &t)
Create Y side of sector support structure.
Definition: GeoEKLMCreator.cc:376
Belle2::EKLMGeometry::SegmentSupportPosition
Segment support position.
Definition: EKLMGeometry.h:1048
Belle2::EKLM::GeoEKLMCreator::createPlasticSheet
void createPlasticSheet(int iSheetPlane, int iSheet) const
Create plastic sheet.
Definition: GeoEKLMCreator.cc:1700
Belle2::EKLMGeometry::SectorSupportGeometry::getCorner1AInner
const HepGeom::Point3D< double > & getCorner1AInner() const
Get corner 1A coordinates (inner side).
Definition: EKLMGeometry.h:618
Belle2::EKLMGeometry::SectorSupportGeometry::getCorner1Z
double getCorner1Z() const
Get corner 1 Z coordinate.
Definition: EKLMGeometry.h:363
Belle2::EKLM::GeoEKLMCreator::createShield
void createShield(G4LogicalVolume *sector) const
Create shield.
Definition: GeoEKLMCreator.cc:1805
Belle2::EKLM::GeoEKLMCreator::createFromDB
void createFromDB(const std::string &name, G4LogicalVolume &topVolume, geometry::GeometryTypes type) override
Creation of the detector geometry from database.
Definition: GeoEKLMCreator.cc:1967
Belle2::EKLMGeometry::SegmentSupportPosition::getDeltaLLeft
double getDeltaLLeft() const
Get left Delta L.
Definition: EKLMGeometry.h:1077
Belle2::EKLMGeometry::ShieldDetailGeometry::getLengthY
double getLengthY() const
Get Y length.
Definition: EKLMGeometry.h:1429
Belle2::EKLMGeometry::SectorSupportGeometry::getCorner4Thickness
double getCorner4Thickness() const
Get corner 4 thickness.
Definition: EKLMGeometry.h:550
Belle2::EKLM::GeoEKLMCreator::createLayerSolid
void createLayerSolid()
Create layer solid.
Definition: GeoEKLMCreator.cc:243
Belle2::EKLM::GeoEKLMCreator::createSectorSupportCorner1
void createSectorSupportCorner1(G4LogicalVolume *sector) const
Create sector support corner 1.
Definition: GeoEKLMCreator.cc:1566
Belle2::EKLMGeometry::SectorSupportGeometry::getCorner3Thickness
double getCorner3Thickness() const
Get corner 3 thickness.
Definition: EKLMGeometry.h:482
Belle2::EKLMGeometry::SectorSupportGeometry::getCorner3Z
double getCorner3Z() const
Get corner 3 Z coordinate.
Definition: EKLMGeometry.h:499
Belle2::EKLMGeometry::SectorSupportGeometry::getThickness
double getThickness() const
Get thickness.
Definition: EKLMGeometry.h:261
Belle2::EKLMGeometry::SectorSupportGeometry::getCorner2LX
double getCorner2LX() const
Get corner 2 X length.
Definition: EKLMGeometry.h:380
Belle2::EKLMGeometry::SectorSupportGeometry::getCornerAngle
double getCornerAngle() const
Get corner 1 angle.
Definition: EKLMGeometry.h:584
Belle2::EKLM::GeoEKLMCreator::createPlaneSolid
void createPlaneSolid(int n)
Create plane solid.
Definition: GeoEKLMCreator.cc:797
Belle2
Abstract base class for different kinds of events.
Definition: MillepedeAlgorithm.h:19
Belle2::EKLMGeometry::SectorSupportGeometry::getCorner3LY
double getCorner3LY() const
Get corner 3 Y length.
Definition: EKLMGeometry.h:465
Belle2::EKLM::GeoEKLMCreator::m_ElementNumbers
const EKLMElementNumbers * m_ElementNumbers
Element numbers.
Definition: GeoEKLMCreator.h:663
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::EKLM::GeoEKLMCreator::createScintillator
void createScintillator(int iStrip) const
Create scintillator.
Definition: GeoEKLMCreator.cc:1790
Belle2::EKLMGeometry::ShieldDetailGeometry::getPoint
const Point * getPoint(int i) const
Get point.
Definition: EKLMGeometry.cc:135
Belle2::EKLM::GeoEKLMCreator::createSectorSupportOuterTube
G4Tubs * createSectorSupportOuterTube()
Create outer tube of sector support structure.
Definition: GeoEKLMCreator.cc:458
Belle2::EKLM::GeometryData::c_Database
@ c_Database
Database.
Definition: GeometryData.h:51
Belle2::EKLM::GeoEKLMCreator::createStrip
void createStrip(G4LogicalVolume *segment) const
Create strip.
Definition: GeoEKLMCreator.cc:1755
Belle2::GearDir
GearDir is the basic class used for accessing the parameter store.
Definition: GearDir.h:41
Belle2::EKLMGeometry::ElementPosition::getX
double getX() const
Get X coordinate.
Definition: EKLMGeometry.h:173
Belle2::EKLM::GeoEKLMCreator::createScintillatorLogicalVolume
void createScintillatorLogicalVolume(int iStrip)
Create scintillator logical volume.
Definition: GeoEKLMCreator.cc:1204
Belle2::EKLMElementNumbers::Instance
static const EKLMElementNumbers & Instance()
Instantiation.
Definition: EKLMElementNumbers.cc:20
Belle2::EKLM::GeoEKLMCreator::createShieldDetailDLogicalVolume
void createShieldDetailDLogicalVolume()
Create shield detail D logical volume.
Definition: GeoEKLMCreator.cc:1395
Belle2::EKLMGeometry::Point::getX
double getX() const
Get X coordinate.
Definition: EKLMGeometry.h:1338
Belle2::EKLM::GeoEKLMCreator::createPlasticSheetLogicalVolume
void createPlasticSheetLogicalVolume(int iSegment)
Create plastic sheet logical volume.
Definition: GeoEKLMCreator.cc:1029
Belle2::EKLM::Solids::groove
G4VSolid ** groove
Definition: GeoEKLMCreator.h:125
Belle2::EKLMGeometry::SectorSupportGeometry::getCorner3
const HepGeom::Point3D< double > & getCorner3() const
Get corner 3 coordinates.
Definition: EKLMGeometry.h:686
Belle2::EKLM::GeoEKLMCreator::createSegmentLogicalVolume
void createSegmentLogicalVolume(int iSegment)
Create segment logical volume (strips + plastic sheets).
Definition: GeoEKLMCreator.cc:1113
Belle2::EKLM::GeoEKLMCreator::createMaterials
void createMaterials()
Creation of materials.
Definition: GeoEKLMCreator.cc:179
Belle2::EKLM::GeoEKLMCreator::createSectorCover
void createSectorCover(int iCover, G4LogicalVolume *sector) const
Create sector cover.
Definition: GeoEKLMCreator.cc:1544
Belle2::EKLM::GeoEKLMCreator::m_GeoDat
const GeometryData * m_GeoDat
Geometry data.
Definition: GeoEKLMCreator.h:669
Belle2::EKLM::GeoEKLMCreator::createSectorSupportBoxTop
G4Box * createSectorSupportBoxTop(G4Transform3D &t)
Create box in the cutted corner of sector support structure.
Definition: GeoEKLMCreator.cc:400
Belle2::EKLM::GeoEKLMCreator::createSectorLogicalVolume
G4LogicalVolume * createSectorLogicalVolume(const char *name) const
Create sector logical volume.
Definition: GeoEKLMCreator.cc:256
Belle2::EKLM::LogicalVolumes::strip
G4LogicalVolume ** strip
Definition: GeoEKLMCreator.h:176
Belle2::EKLMGeometry::StripGeometry
Strip geometry data.
Definition: EKLMGeometry.h:1187
Belle2::EKLMGeometry::SegmentSupportPosition::getX
double getX() const
Get X coordinate.
Definition: EKLMGeometry.h:1111
Belle2::EKLM::GeoEKLMCreator::m_CurVol
struct VolumeNumbers m_CurVol
Current volumes.
Definition: GeoEKLMCreator.h:660
Belle2::EKLM::GeoEKLMCreator::unifySolids
G4VSolid * unifySolids(G4VSolid **solids, HepGeom::Transform3D *transf, int nSolids, const std::string &name)
Unify a group of solids.
Definition: GeoEKLMCreator.cc:953
Belle2::EKLMGeometry::SectorSupportGeometry::getCorner3Prism
const HepGeom::Point3D< double > & getCorner3Prism() const
Get coordinates of the corner of corner 3 prism.
Definition: EKLMGeometry.h:720
Belle2::EKLM::GeoEKLMCreator::GeoEKLMCreator
GeoEKLMCreator()
Constructor.
Definition: GeoEKLMCreator.cc:48
Belle2::EKLMGeometry::PlasticSheetGeometry::getWidth
double getWidth() const
Get width.
Definition: EKLMGeometry.h:902
Belle2::EKLMGeometry::ShieldGeometry::getDetailD
const ShieldDetailGeometry * getDetailD() const
Get detail D geometry.
Definition: EKLMGeometry.h:1572
Belle2::EKLMGeometry::StripGeometry::getWidth
double getWidth() const
Get width.
Definition: EKLMGeometry.h:1199
Belle2::EKLM::GeoEKLMCreator::m_TransformData
TransformData * m_TransformData
Transformation data.
Definition: GeoEKLMCreator.h:666
Belle2::EKLMGeometry::SectorSupportGeometry::getCorner1A
const HepGeom::Point3D< double > & getCorner1A() const
Get corner 1A coordinates.
Definition: EKLMGeometry.h:601
Belle2::EKLM::GeoEKLMCreator::createPayloads
void createPayloads(const GearDir &content, const IntervalOfValidity &iov) override
Creation of payloads.
Definition: GeoEKLMCreator.cc:1985
Belle2::EKLMGeometry::SectorSupportGeometry::getCorner4LY
double getCorner4LY() const
Get corner 4 Y length.
Definition: EKLMGeometry.h:533
Belle2::EKLM::GeoEKLMCreator::createStripLogicalVolume
void createStripLogicalVolume(int iStrip)
Create strip logical volume.
Definition: GeoEKLMCreator.cc:1149
Belle2::EKLMGeometry::ShieldGeometry::getDetailACenter
const Point * getDetailACenter() const
Get detail A center.
Definition: EKLMGeometry.h:1589
Belle2::EKLMGeometry::ShieldDetailGeometry::getLengthX
double getLengthX() const
Get X length.
Definition: EKLMGeometry.h:1412
Belle2::EKLM::GeoEKLMCreator::createStripSegment
void createStripSegment(int iSegment) const
Create strip segment.
Definition: GeoEKLMCreator.cc:1724
Belle2::EKLM::GeoEKLMCreator::createLayer
G4LogicalVolume * createLayer(G4LogicalVolume *section, G4LogicalVolume *layer) const
Create layer.
Definition: GeoEKLMCreator.cc:1501
Belle2::EKLM::TransformData::c_Displacement
@ c_Displacement
Use displacement data (for geometry).
Definition: TransformData.h:46
Belle2::EKLMGeometry::ElementPosition::getOuterR
double getOuterR() const
Get outer radius.
Definition: EKLMGeometry.h:139
Belle2::EKLM::GeoEKLMCreator::m_Materials
struct Materials m_Materials
Materials.
Definition: GeoEKLMCreator.h:657
Belle2::EKLMGeometry::SegmentSupportGeometry::getMiddleThickness
double getMiddleThickness() const
Get middle part thickness.
Definition: EKLMGeometry.h:1012
Belle2::EKLM::GeoEKLMCreator::createSectionSolid
void createSectionSolid()
Create section solid.
Definition: GeoEKLMCreator.cc:193
Belle2::EKLMGeometry::Point::getY
double getY() const
Get Y coordinate.
Definition: EKLMGeometry.h:1355
Belle2::EKLM::GeoEKLMCreator::newVolumes
void newVolumes()
Create new volumes.
Definition: GeoEKLMCreator.cc:77
Belle2::EKLM::Solids::plane
G4VSolid ** plane
Definition: GeoEKLMCreator.h:120
Belle2::EKLM::GeoEKLMCreator::createSector
G4LogicalVolume * createSector(G4LogicalVolume *layer, G4LogicalVolume *sector) const
Create sector.
Definition: GeoEKLMCreator.cc:1522
Belle2::EKLMGeometry::ShieldGeometry::getThickness
double getThickness() const
Get thickness.
Definition: EKLMGeometry.h:1504
Belle2::EKLM::GeoEKLMCreator::createSectorSupportCorner2LogicalVolume
void createSectorSupportCorner2LogicalVolume()
Create sector support corner 2 logical volume.
Definition: GeoEKLMCreator.cc:563
Belle2::EKLM::LogicalVolumes::groove
G4LogicalVolume ** groove
Definition: GeoEKLMCreator.h:177
Belle2::EKLMGeometry::ElementPosition::getLength
double getLength() const
Get length.
Definition: EKLMGeometry.h:156
Belle2::EKLMGeometry::SectorSupportGeometry::getCorner2Inner
const HepGeom::Point3D< double > & getCorner2Inner() const
Get corner 2 coordinates (inner side).
Definition: EKLMGeometry.h:669
Belle2::EKLM::EKLMSensitiveDetector
The Class for EKLM Sensitive Detector.
Definition: EKLMSensitiveDetector.h:44
Belle2::EKLM::GeoEKLMCreator::createStripSegmentLogicalVolume
void createStripSegmentLogicalVolume(int iSegment)
Create strip segment logical volume.
Definition: GeoEKLMCreator.cc:1083
Belle2::EKLMGeometry::EndcapStructureGeometry::getPhi
double getPhi() const
Get starting angle of the octagonal endcap structure shape.
Definition: EKLMGeometry.h:63
Belle2::EKLM::LogicalVolumes::psheet
G4LogicalVolume ** psheet
Definition: GeoEKLMCreator.h:179
Belle2::EKLMGeometry::SegmentSupportGeometry::getTopWidth
double getTopWidth() const
Get top part width.
Definition: EKLMGeometry.h:961
Belle2::EKLM::GeoEKLMCreator::createSectorSupportCorner3LogicalVolume
void createSectorSupportCorner3LogicalVolume()
Create sector support corner 3 logical volume.
Definition: GeoEKLMCreator.cc:601
Belle2::EKLMGeometry::ElementPosition::getY
double getY() const
Get Y coordinate.
Definition: EKLMGeometry.h:190
Belle2::EKLMGeometry::SegmentSupportGeometry::getTopThickness
double getTopThickness() const
Get top part thickness.
Definition: EKLMGeometry.h:978
Belle2::EKLMGeometry::SectorSupportGeometry::getCorner4Prism
const HepGeom::Point3D< double > & getCorner4Prism() const
Get coordinates of the corner of corner 4 prism.
Definition: EKLMGeometry.h:771
Belle2::geometry::GeometryTypes
GeometryTypes
Flag indiciating the type of geometry to be used.
Definition: GeometryManager.h:39
Belle2::EKLM::GeoEKLMCreator::m_LogVol
struct LogicalVolumes m_LogVol
Logical volumes.
Definition: GeoEKLMCreator.h:654
Belle2::EKLMGeometry::ShieldGeometry::getDetailA
const ShieldDetailGeometry * getDetailA() const
Get detail A geometry.
Definition: EKLMGeometry.h:1521
Belle2::EKLM::GeometryData::Instance
static const GeometryData & Instance(enum DataSource dataSource=c_Database, const GearDir *gearDir=nullptr)
Instantiation.
Definition: GeometryData.cc:35
Belle2::EKLM::GeoEKLMCreator::createPlane
G4LogicalVolume * createPlane(G4LogicalVolume *sector) const
Create plane.
Definition: GeoEKLMCreator.cc:1652
Belle2::EKLMGeometry::SectorSupportGeometry::getCorner4
const HepGeom::Point3D< double > & getCorner4() const
Get corner 4 coordinates.
Definition: EKLMGeometry.h:737
Belle2::EKLMGeometry::ShieldGeometry::getDetailB
const ShieldDetailGeometry * getDetailB() const
Get detail B geometry.
Definition: EKLMGeometry.h:1538
Belle2::EKLM::GeoEKLMCreator::~GeoEKLMCreator
~GeoEKLMCreator()
Destructor.
Definition: GeoEKLMCreator.cc:66
Belle2::EKLMGeometry::ShieldGeometry::getDetailBCenter
const Point * getDetailBCenter() const
Get detail B center.
Definition: EKLMGeometry.h:1604
Belle2::EKLMGeometry::SegmentSupportPosition::getZ
double getZ() const
Get Z coordinate.
Definition: EKLMGeometry.h:1145
Belle2::EKLM::GeoEKLMCreator::createSectorSolid
void createSectorSolid()
Create sector solid.
Definition: GeoEKLMCreator.cc:268
Belle2::EKLM::GeoEKLMCreator::createSectorSupport
void createSectorSupport(G4LogicalVolume *sector) const
Create sector support structure (main part without corners).
Definition: GeoEKLMCreator.cc:1636