Belle II Software  release-08-01-10
PlumeCreator.cc
1 /**************************************************************************
2  * basf2 (Belle II Analysis Software Framework) *
3  * Author: The Belle II Collaboration *
4  * *
5  * See git log for contributors and copyright holders. *
6  * This file is licensed under LGPL-3.0, see LICENSE.md. *
7  **************************************************************************/
8 
9 #include <beast/plume/geometry/PlumeCreator.h>
10 #include <beast/plume/simulation/SensitiveDetector.h>
11 
12 #include <geometry/Materials.h>
13 #include <geometry/CreatorFactory.h>
14 #include <framework/gearbox/GearDir.h>
15 
16 #include <cmath>
17 #include <boost/format.hpp>
18 #include <boost/foreach.hpp>
19 #include <boost/algorithm/string.hpp>
20 
21 #include <G4LogicalVolume.hh>
22 #include <G4AssemblyVolume.hh>
23 #include <G4PVPlacement.hh>
24 
25 //Shapes
26 #include <G4Box.hh>
27 #include <G4Trd.hh>
28 #include "G4SubtractionSolid.hh"
29 #include <G4UserLimits.hh>
30 #include "G4Tubs.hh"
31 #include <G4TwoVector.hh>
32 //Visualization Attributes
33 #include <G4VisAttributes.hh>
34 #include<G4ExtrudedSolid.hh>
35 
36 using namespace std;
37 using namespace boost;
38 
39 namespace Belle2 {
46  namespace plume {
47 
48  // Register the creator
50  geometry::CreatorFactory<PlumeCreator> PlumeFactory("PLUMECreator");
51 
52  PlumeCreator::PlumeCreator(): m_sensitive(0)
53  {
54  //m_sensitive = new SensitiveDetector();
55  }
56 
57  PlumeCreator::~PlumeCreator()
58  {
59  if (m_sensitive) delete m_sensitive;
60  }
61 
62  void PlumeCreator::create(const GearDir& content, G4LogicalVolume& topVolume, geometry::GeometryTypes /* type */)
63  {
64 
65  m_sensitive = new SensitiveDetector();
66 
67  //color attributions
68  G4VisAttributes* FoamVisAtt = new G4VisAttributes(G4Colour::Blue());
69  G4VisAttributes* KaptonVisAtt = new G4VisAttributes(G4Colour::Red());
70  G4VisAttributes* GlueVisAtt = new G4VisAttributes(G4Colour::White());
71  G4VisAttributes* MetalVisAtt = new G4VisAttributes(G4Colour::Gray());
72  G4VisAttributes* SubstrateVisAtt = new G4VisAttributes(G4Colour::Green());
73  G4VisAttributes* MetalizedVisAtt = new G4VisAttributes(G4Colour::Cyan());
74  G4VisAttributes* EpitaxialVisAtt = new G4VisAttributes(G4Colour(1.0, 1.0, 0.0)); //yellow
75 
76  //lets get the stepsize parameter with a default value of 5 µm
77  double stepSize = content.getLength("stepSize", 5 * CLHEP::um);
78 
79  int LadderID = 0;
80 
81  GearDir activeParams(content, "Ladder");
82  G4double SensorLengthX = (activeParams.getInt("nPixelsX") * activeParams.getLength("pitchX")) * CLHEP::cm;
83  G4double SensorLengthY = (activeParams.getInt("nPixelsY") * activeParams.getLength("pitchY")) * CLHEP::cm;
84 
85  G4double AirGap = activeParams.getLength("AirGap") * CLHEP::cm;
86 
87  G4double SubstrateThickness = activeParams.getLength("SubstrateThickness") * CLHEP::cm;
88  G4double EpitaxialThickness = activeParams.getLength("EpitaxialThickness") * CLHEP::cm;
89  G4double MetalThickness = activeParams.getLength("MetalThickness") * CLHEP::cm;
90  G4double GlueThickness = activeParams.getLength("GlueThickness") * CLHEP::cm;
91  G4double KaptonThickness = activeParams.getLength("KaptonThickness") * CLHEP::cm;
92  G4double AluminiumThickness = activeParams.getLength("AluminiumThickness") * CLHEP::cm;
93  G4double foamlen = activeParams.getLength("Foam/length") * CLHEP::cm;
94  G4double foamwid = activeParams.getLength("Foam/width") * CLHEP::cm;
95  G4double foamthick = activeParams.getLength("Foam/thickness") * CLHEP::cm;
96  G4double foamZ = activeParams.getLength("Foam/zPosition") * CLHEP::cm;
97  G4double foamY = activeParams.getLength("Foam/yShift") * CLHEP::cm;
98  G4double flexlen = activeParams.getLength("Flex/length") * CLHEP::cm;
99  G4double flexwid = activeParams.getLength("Flex/width") * CLHEP::cm;
100  G4double flexZ = activeParams.getLength("Flex/zPosition") * CLHEP::cm;
101  G4double allen1 = activeParams.getLength("AlBat/length1") * CLHEP::cm;
102  G4double allen2 = activeParams.getLength("AlBat/length2") * CLHEP::cm;
103  G4double allen3 = activeParams.getLength("AlBat/length3") * CLHEP::cm;
104  G4double alwid = activeParams.getLength("AlBat/width") * CLHEP::cm;
105  G4double althick1 = activeParams.getLength("AlBat/thickness1") * CLHEP::cm;
106  G4double althick2 = activeParams.getLength("AlBat/thickness2") * CLHEP::cm;
107  G4double althick3 = activeParams.getLength("AlBat/thickness3") * CLHEP::cm;
108 
109  // old geometry
110  /*
111  G4double SensorDistance = activeParams.getLength("SensorDistance") * CLHEP::cm;
112  G4double dx_foam = SensorLengthY / 2. + 0.15 * CLHEP::cm ;
113  G4double dy_foam = (SensorLengthX * 6. + 5.*SensorDistance) / 2.;
114  G4double DistanceFromFoamCenter = 0.1 * CLHEP::cm;
115  //Envelop dimension Thickness not divided by 2 to take into account of the 2 sides of foam
116  G4double dz_env = DistanceFromFoamCenter + KaptonThickness + GlueThickness +
117  AluminiumThickness + SubstrateThickness + EpitaxialThickness +
118  MetalThickness + 6. * AirGap;
119  G4Box* s_env = new G4Box("s_env", dx_foam, dy_foam, dz_env);
120  G4LogicalVolume* l_env = new G4LogicalVolume(s_env, geometry::Materials::get("Al"), "l_env");
121  G4Transform3D transformt = G4RotateZ3D(135. / 180 * M_PI - M_PI / 2.0) * G4Translate3D(0, 61,
122  42.2) * G4RotateX3D(- M_PI / 2.0 - 178. / 180 * M_PI);
123  new G4PVPlacement(transformt, l_env, "p_env1", &topVolume, false, 1);
124  transformt = G4RotateZ3D(225. / 180 * M_PI - M_PI / 2.0) * G4Translate3D(0, 84,
125  -21.8) * G4RotateX3D(- M_PI / 2.0 - 20. / 180 * M_PI);
126  new G4PVPlacement(transformt, l_env, "p_env2", &topVolume, false, 1);*/
127  //---------------
128 
129  G4double dz_ladder = foamthick / 2. + KaptonThickness + GlueThickness +
130  AluminiumThickness + 3. * AirGap;
131  G4double dz_sensor = (SubstrateThickness + EpitaxialThickness +
132  MetalThickness + 2. * AirGap) / 2.;
133 
134  G4double fullLength = allen1 + allen2 + allen3 - (foamZ - foamlen / 2.);
135  double zshift = fullLength / 2. - (allen1 + allen2 + allen3);
136 
137  // Create support ladder
138  G4AssemblyVolume* support = new G4AssemblyVolume();
139  G4Transform3D transl;;
140 
141  //create foam layer
142  G4Box* s_foam = new G4Box("s_foam", foamlen / 2., foamwid / 2., foamthick / 2.);
143  G4LogicalVolume* l_foam = new G4LogicalVolume(s_foam, geometry::Materials::get("SiC"), "PLUME.l_foam");
144  transl = G4Translate3D(foamZ + zshift, foamY, 0);
145  support->AddPlacedVolume(l_foam, transl);
146 
147  //create glue layers
148  G4Box* s_glue = new G4Box("s_glue", flexlen / 2., foamwid / 2., GlueThickness / 2.);
149  G4LogicalVolume* l_glue = new G4LogicalVolume(s_glue, geometry::Materials::get("Glue"), "PLUME.l_glue");
150  G4double r_glue = foamthick / 2. + AirGap + GlueThickness / 2.;
151  transl = G4Translate3D(flexZ + zshift, foamY, -r_glue);
152  support->AddPlacedVolume(l_glue, transl);
153  transl = G4Translate3D(flexZ + zshift, foamY, r_glue);
154  support->AddPlacedVolume(l_glue, transl);
155 
156  //create Kapton layers
157  G4Box* s_kapton = new G4Box("s_kapton", flexlen / 2., flexwid / 2., KaptonThickness / 2.);
158  G4LogicalVolume* l_kapton = new G4LogicalVolume(s_kapton, geometry::Materials::get("Kapton"), "PLUME.l_kapton");
159  G4double r_Kapton = r_glue + AirGap + (GlueThickness + KaptonThickness) / 2.;
160  transl = G4Translate3D(flexZ + zshift, 0, -r_Kapton);
161  support->AddPlacedVolume(l_kapton, transl);
162  transl = G4Translate3D(flexZ + zshift, 0, r_Kapton);
163  support->AddPlacedVolume(l_kapton, transl);
164 
165  //create metal layers
166  G4Box* s_metal = new G4Box("s_metal", flexlen / 2., flexwid / 2., AluminiumThickness / 2.);
167  G4LogicalVolume* l_metal = new G4LogicalVolume(s_metal, geometry::Materials::get("Al"), "PLUME.l_metal");
168  G4double r_metal = r_Kapton + AirGap + (KaptonThickness + AluminiumThickness) / 2.;
169  transl = G4Translate3D(flexZ + zshift, 0, -r_metal);
170  support->AddPlacedVolume(l_metal, transl);
171  transl = G4Translate3D(flexZ + zshift, 0, r_metal);
172  support->AddPlacedVolume(l_metal, transl);
173 
174  //create aluminum bat
175  G4Box* s_bat1p = new G4Box("s_bat1p", allen1 / 2., alwid / 2., althick1 / 2.);
176  double incut = foamZ + foamlen / 2.;
177  G4Box* s_bat1t = new G4Box("s_bat1t", incut, foamwid / 2., althick1 + 0.2 / 2.);
178 
179  G4Transform3D tt = G4Translate3D(-allen1 / 2., foamY, 0);
180  G4SubtractionSolid* s_bat1 = new G4SubtractionSolid("s_bat1", s_bat1p, s_bat1t, tt);
181  G4Box* s_bat2 = new G4Box("s_bat2", allen2 / 2., alwid / 2., althick2 / 2.);
182  G4Box* s_bat3 = new G4Box("s_bat3", allen3 / 2., alwid / 2., althick3 / 2.);
183  G4LogicalVolume* l_bat1 = new G4LogicalVolume(s_bat1, geometry::Materials::get("Al"), "PLUME.l_bat1");
184  G4LogicalVolume* l_bat2 = new G4LogicalVolume(s_bat2, geometry::Materials::get("Al"), "PLUME.l_bat2");
185  G4LogicalVolume* l_bat3 = new G4LogicalVolume(s_bat3, geometry::Materials::get("Al"), "PLUME.l_bat3");
186  transl = G4Translate3D(allen1 / 2. + zshift, 0, 0);
187  support->AddPlacedVolume(l_bat1, transl);
188  transl = G4Translate3D(allen1 + allen2 / 2. + zshift, 0, 0);
189  support->AddPlacedVolume(l_bat2, transl);
190  transl = G4Translate3D(allen1 + allen2 + allen3 / 2. + zshift, 0, 0);
191  support->AddPlacedVolume(l_bat3, transl);
192 
193  l_foam->SetVisAttributes(FoamVisAtt);
194  l_kapton->SetVisAttributes(KaptonVisAtt);
195  l_glue->SetVisAttributes(GlueVisAtt);
196  l_metal->SetVisAttributes(MetalVisAtt);
197 
198 
199  G4String symbol, name;
200  G4double a, zz;
201  G4double density;
202  G4int ncomponents;
203  a = 1.01 * CLHEP::g / CLHEP::mole;
204  G4Element* elH = new G4Element(name = "Hydrogen", symbol = "H", zz = 1., a);
205  a = 12.01 * CLHEP::g / CLHEP::mole;
206  G4Element* elC = new G4Element(name = "Carbon", symbol = "C", zz = 6., a);
207  a = 16.00 * CLHEP::g / CLHEP::mole;
208  G4Element* elO = new G4Element(name = "Oxygen", symbol = "O", zz = 8., a);
209  density = 1.31 * CLHEP::g / CLHEP::cm3;
210  G4Material* peekMat = new G4Material(name = "plumePeek", density, ncomponents = 3);
211  peekMat->AddElementByMassFraction(elC, 0.76);
212  peekMat->AddElementByMassFraction(elH, 0.08);
213  peekMat->AddElementByMassFraction(elO, 0.16);
214  density = 1.5 * CLHEP::g / CLHEP::cm3;
215  G4Material* carbMat = new G4Material(name = "plumeCarb", density, ncomponents = 1);
216  carbMat->AddElementByMassFraction(elC, 1.0);
217 
218  G4Box* s_sensor = new G4Box("s_sensor", SensorLengthX / 2., SensorLengthY / 2., dz_sensor);
219  G4LogicalVolume* l_sensor = new G4LogicalVolume(s_sensor, geometry::Materials::get("G4_AIR"), "PLUME.l_sensor");
220 
221  // Substrate Layer //
222  G4Box* s_substrate = new G4Box("s_substrate", SensorLengthX / 2., SensorLengthY / 2., SubstrateThickness / 2.);
223  G4LogicalVolume* l_substrate = new G4LogicalVolume(s_substrate, geometry::Materials::get("Silicon"), "PLUME.l_substrate");
224  new G4PVPlacement(0, G4ThreeVector(0, 0, -dz_sensor + SubstrateThickness / 2.), l_substrate, "p_substrate", l_sensor, false, 1);
225 
226  // Epitaxial Layer //
227  G4Box* s_epitaxial = new G4Box("s_epitaxial", SensorLengthX / 2., SensorLengthY / 2., EpitaxialThickness / 2.);
228  G4LogicalVolume* l_epitaxial = new G4LogicalVolume(s_epitaxial, geometry::Materials::get("Silicon"), "PLUME.l_epitaxial", 0,
229  m_sensitive);
230  new G4PVPlacement(0, G4ThreeVector(0, 0, -dz_sensor + AirGap + SubstrateThickness + EpitaxialThickness / 2.), l_epitaxial,
231  "p_epitaxial", l_sensor, false, 1);
232  // Metalized Layer //
233  G4Box* s_metalized = new G4Box("s_metalized", SensorLengthX / 2., SensorLengthY / 2., MetalThickness / 2.);
234  G4LogicalVolume* l_metalized = new G4LogicalVolume(s_metalized, geometry::Materials::get("SiO2Al"), "PLUME.l_metalized");
235  new G4PVPlacement(0, G4ThreeVector(0, 0, -dz_sensor + 2 * AirGap + SubstrateThickness + EpitaxialThickness + MetalThickness / 2.),
236  l_metalized, "p_metalized", l_sensor, false, 1);
237 
238  // temporary
239  /*G4LogicalVolume* l_sensorMir = new G4LogicalVolume(s_sensor, geometry::Materials::get("G4_AIR"), "l_sensorMir");
240  new G4PVPlacement(0, G4ThreeVector(0, 0, -dz_sensor + MetalThickness / 2.), l_metalized, "p_metalized", l_sensorMir, false, 1);
241  new G4PVPlacement(0, G4ThreeVector(0, 0, -dz_sensor + MetalThickness + AirGap + EpitaxialThickness / 2.), l_epitaxial,
242  "p_epitaxial", l_sensorMir, false, 1);
243  new G4PVPlacement(0, G4ThreeVector(0, 0, -dz_sensor + MetalThickness + 2 * AirGap + EpitaxialThickness + SubstrateThickness / 2.),
244  l_substrate, "p_substrate", l_sensorMir, false, 1);
245  */
246 
247 
248  l_epitaxial->SetUserLimits(new G4UserLimits(stepSize));
249  l_substrate->SetVisAttributes(SubstrateVisAtt);
250  l_epitaxial->SetVisAttributes(EpitaxialVisAtt);
251  l_metalized->SetVisAttributes(MetalizedVisAtt);
252 
253  // place 12 sensors on support ladder
254  double zSens = dz_ladder + dz_sensor + AirGap;
255  G4RotationMatrix ra;
256  G4ThreeVector Ta(0, 0, 0);
257  G4Transform3D tra(ra, Ta);
258 
259  // build cooling tubes
260  GearDir pipeParams(content, "CoolingPipes");
261  double pipeLen = pipeParams.getLength("length") * CLHEP::cm;
262  double pipeInR = pipeParams.getLength("rIn") * CLHEP::cm;
263  double pipeOutR = pipeParams.getLength("rOut") * CLHEP::cm;
264  G4Tubs* pipe_s = new G4Tubs("pipe_s", pipeInR, pipeOutR, pipeLen / 2., 0, 2 * M_PI);
265 
266  G4LogicalVolume* pipe_l = new G4LogicalVolume(pipe_s, carbMat, "PLUME.l_pipe");
267  double pipeX = pipeParams.getLength("x") * CLHEP::cm;
268  double pipeY = pipeParams.getLength("y") * CLHEP::cm;
269  double pipeZ = pipeParams.getLength("z") * CLHEP::cm;
270  G4double alphaPipe = pipeParams.getAngle("alpha");
271 
272  //GearDir alignPars;
273  G4Box* s_sensors = new G4Box("s_sensors", flexlen / 2., flexwid / 2., dz_sensor + AirGap);
274 
275  for (auto ladder : content.getNodes("Placements/Ladder")) {
276 
277  std::string id = ladder.getString("@id");
278 
279  G4AssemblyVolume* assemblyLadder = new G4AssemblyVolume();
280  assemblyLadder->AddPlacedAssembly(support, tra);
281 
282  for (auto pars : content.getNodes("SensorAlignment/ladder")) {
283  if (pars.getString("@id") == id) {
284  GearDir alignPars(pars);
285 
286  for (auto sidePars : alignPars.getNodes("side")) {
287  unsigned mirror = 0;
288 
289  G4Transform3D transformSens;
290  if (sidePars.getString("@id") == "mirror") mirror = 1;
291 
292  G4LogicalVolume* l_sensors = new G4LogicalVolume(s_sensors, geometry::Materials::get("G4_AIR"), "PLUME.l_sensors");
293 
294  for (auto sensorPars : sidePars.getNodes("sensor")) {
295  double x = sensorPars.getLength("x") * CLHEP::cm + zshift;
296  double y = sensorPars.getLength("y") * CLHEP::cm;
297  int ids = sensorPars.getInt("id");
298  y = mirror ? -y : y;
299  y -= alwid / 2.;
300  double alpha1 = sensorPars.getAngle("alpha") * CLHEP::rad;
301  if (mirror) transformSens = G4Translate3D(x, y,
302  0) * G4RotateZ3D(alpha1) * G4RotateX3D(M_PI); // think if this is correct, rotation and pos shift for mirror side
303  else transformSens = G4Translate3D(x, y, 0) * G4RotateZ3D(-alpha1);
304 
305  new G4PVPlacement(transformSens, l_sensor, "p_sensor", l_sensors, true,
306  (ids + mirror * 6 + LadderID * 12));
307  }
308  transformSens = G4Translate3D(0, 0, mirror ? -zSens : zSens);
309  assemblyLadder->AddPlacedVolume(l_sensors, transformSens);
310  }
311  }
312  }
313 
314 
315 
316  G4double thetaZ = ladder.getAngle("ThetaZ");
317  G4double r = ladder.getLength("r_plume") * CLHEP::cm - zshift * sin(thetaZ);
318  G4double z = ladder.getLength("z_plume") * CLHEP::cm - zshift * cos(thetaZ);
319  G4double phi = ladder.getAngle("Phi");
320  G4double alpha = ladder.getAngle("Alpha");
321 
322 
323  // place cooling pipes
324  G4Transform3D transformPipe = G4Translate3D(pipeZ + zshift, pipeY, pipeX) * G4RotateZ3D(alphaPipe) * G4RotateY3D(+ M_PI / 2.);
325  assemblyLadder->AddPlacedVolume(pipe_l, transformPipe);
326  transformPipe = G4Translate3D(pipeZ + zshift
327  , pipeY, -pipeX) * G4RotateZ3D(alphaPipe) * G4RotateY3D(+ M_PI / 2.);
328  assemblyLadder->AddPlacedVolume(pipe_l, transformPipe);
329 
330 
331  G4Transform3D transform1;
332  if (LadderID == 1) {
333  G4AssemblyVolume* sup1 = buildSupport1();
334  G4AssemblyVolume* sup2 = buildSupport2();
335  transform1 = G4Translate3D(-fullLength / 2. - 18.7, 0., 1.2) * G4RotateY3D(thetaZ) * G4RotateX3D(M_PI / 2.) * G4RotateY3D(M_PI);
336  assemblyLadder->AddPlacedAssembly(sup1, transform1);
337  transform1 = G4Translate3D(fullLength / 2. + 19.5, 0, -2.6) * G4RotateY3D(thetaZ) * G4RotateX3D(M_PI / 2.);
338  assemblyLadder->AddPlacedAssembly(sup2, transform1);
339  }
340 
341  if (LadderID == 0) {
342  G4AssemblyVolume* sup1 = buildSupport3();
343  G4AssemblyVolume* sup2 = buildSupport4();
344  transform1 = G4Translate3D(fullLength / 2. + 5, 0,
345  7.8) * G4RotateY3D(-thetaZ) * G4RotateZ3D(M_PI / 2.) * G4RotateX3D(M_PI / 2.) * G4RotateY3D(M_PI / 2.);
346  assemblyLadder->AddPlacedAssembly(sup1, transform1);
347  transform1 = G4Translate3D(-fullLength / 2. - 31, 0.,
348  -21.7) * G4RotateY3D(-thetaZ) * G4RotateZ3D(M_PI / 2.) * G4RotateX3D(-M_PI / 2.) * G4RotateY3D(M_PI);
349  assemblyLadder->AddPlacedAssembly(sup2, transform1);
350  }
351 
352  G4Transform3D transform = G4RotateZ3D(phi) * G4Translate3D(r, 0,
353  z) * G4RotateY3D(thetaZ) * G4RotateZ3D(alpha + M_PI) * G4RotateY3D(- M_PI / 2.0);
354 
355  assemblyLadder->MakeImprint(&topVolume, transform);
356 
357  LadderID += 1;
358 
359  }
360 
361  }
362 
363 
364  G4AssemblyVolume* PlumeCreator::buildSupport1()
365  {
366 
367  std::vector<G4TwoVector> points = {G4TwoVector(-11.6, 0.371), G4TwoVector(-11.504, -2.378), G4TwoVector(-1.51, -2.029), G4TwoVector(-1.51, -4.13), G4TwoVector(-11.561, -4.481), G4TwoVector(-11.686, -6.629), G4TwoVector(2.584, -6.629), G4TwoVector(4.974, -4.239), G4TwoVector(4.974, 1.761), G4TwoVector(2.0, 1.761), G4TwoVector(0.61, 0.371)};
368 
369  G4Material* peek = G4Material::GetMaterial("plumePeek");
370  G4ExtrudedSolid* s1_peek0 = new G4ExtrudedSolid("s1_peek0", points, 10.0, G4TwoVector(0, 0), 1, G4TwoVector(0, 0), 1);
371  G4LogicalVolume* l1_peek0 = new G4LogicalVolume(s1_peek0, peek, "PLUME.l1_peek0");
372 
373  G4Box* s1_peek1 = new G4Box("s1_peek1", 24. / 2., 6. / 2., 20. / 2.);
374  G4Box* s1_peek2 = new G4Box("s1_peek2", 19.4 / 2., 3. / 2., 20. / 2.);
375  G4LogicalVolume* l1_peek1 = new G4LogicalVolume(s1_peek1, peek, "PLUME.l1_peek1");
376  G4LogicalVolume* l1_peek2 = new G4LogicalVolume(s1_peek2, peek, "PLUME.l1_peek2");
377 
378  G4AssemblyVolume* assemblySup = new G4AssemblyVolume();
379 
380  G4Transform3D transform = G4Translate3D(0, 0., 0);
381 
382  assemblySup->AddPlacedVolume(l1_peek1, transform);
383 
384  transform = G4Translate3D(-16.974, 1.239, 0);
385  assemblySup->AddPlacedVolume(l1_peek0, transform);
386 
387  transform = G4Translate3D(21.7, 1.5, 0);
388  assemblySup->AddPlacedVolume(l1_peek2, transform);
389 
390  G4Trd* s1_al0 = new G4Trd("s1_al0", 12. / 2., 20. / 2., 3. / 2., 3. / 2., 94.5 / 2.);
391  G4Box* s1_al1 = new G4Box("s1_al1", 12. / 2., 20.5 / 2., 3.5 / 2.);
392  G4Box* s1_al2 = new G4Box("s1_al2", 12. / 2., 4.0 / 2., 10.5 / 2.);
393 
394  G4LogicalVolume* l1_al0 = new G4LogicalVolume(s1_al0, geometry::Materials::get("Al"), "PLUME.l1_al0");
395  G4LogicalVolume* l1_al1 = new G4LogicalVolume(s1_al1, geometry::Materials::get("Al"), "PLUME.l1_al1");
396  G4LogicalVolume* l1_al2 = new G4LogicalVolume(s1_al2, geometry::Materials::get("Al"), "PLUME.l1_al2");
397 
398  transform = G4Translate3D(59.25, -1.5, 0) * G4RotateY3D(-M_PI / 2.);
399  assemblySup->AddPlacedVolume(l1_al0, transform);
400 
401  transform = G4Translate3D(108.25, -20.5 / 2., 0) * G4RotateY3D(-M_PI / 2.);
402  assemblySup->AddPlacedVolume(l1_al1, transform);
403 
404  transform = G4Translate3D(115.25, -18.5, 0) * G4RotateY3D(-M_PI / 2.);
405  assemblySup->AddPlacedVolume(l1_al2, transform);
406 
407  return assemblySup;
408  }
409 
410 
411  G4AssemblyVolume* PlumeCreator::buildSupport2()
412  {
413 
414  std::vector<G4TwoVector> points = {G4TwoVector(-10.6, 0), G4TwoVector(-10.6, -1.7), G4TwoVector(-0.606, -2.049), G4TwoVector(-0.606, -4.15), G4TwoVector(-10.6, -3.801), G4TwoVector(-10.6, -6.11), G4TwoVector(2.28, -6.11), G4TwoVector(5.39, -3.0), G4TwoVector(23.4, -3), G4TwoVector(23.4, 0.)};
415  G4Material* peek = G4Material::GetMaterial("plumePeek");
416  G4ExtrudedSolid* s2_peek0 = new G4ExtrudedSolid("s2_peek0", points, 16.0, G4TwoVector(0, 0), 1, G4TwoVector(0, 0), 1);
417  G4LogicalVolume* l2_peek0 = new G4LogicalVolume(s2_peek0, peek, "PLUME.l2_peek0");
418 
419 
420  G4Box* s2_peek1 = new G4Box("s2_peek1", 10. / 2., 6.7 / 2., 12.5 / 2.);
421  G4Box* s2_peek2 = new G4Box("s2_peek2", 39.0 / 2., 4. / 2., 12.5 / 2.);
422  G4LogicalVolume* l2_peek1 = new G4LogicalVolume(s2_peek1, peek, "PLUME.l2_peek1");
423  G4LogicalVolume* l2_peek2 = new G4LogicalVolume(s2_peek2, peek, "PLUME.l2_peek2");
424 
425  G4AssemblyVolume* assemblySup = new G4AssemblyVolume();
426 
427  G4Transform3D transform = G4Translate3D(0, 0., 0);
428 
429  assemblySup->AddPlacedVolume(l2_peek1, transform);
430 
431  transform = G4Translate3D(-18.4, 6.35, 0);
432  assemblySup->AddPlacedVolume(l2_peek0, transform);
433 
434  transform = G4Translate3D(24.5, -1.35, 0);
435  assemblySup->AddPlacedVolume(l2_peek2, transform);
436 
437  G4Box* s2_al0 = new G4Box("s2_al0", 140. / 2., 4. / 2., 12. / 2.);
438  G4LogicalVolume* l2_al0 = new G4LogicalVolume(s2_al0, geometry::Materials::get("Al"), "PLUME.l2_al0");
439 
440  transform = G4Translate3D(-26.0, -5.35, 0);
441  assemblySup->AddPlacedVolume(l2_al0, transform);
442 
443  return assemblySup;
444  }
445 
446 
447  G4AssemblyVolume* PlumeCreator::buildSupport3()
448  {
449 
450  std::vector<G4TwoVector> points = {G4TwoVector(4.7, -59.87), G4TwoVector(/*4.109*/4.7, -68.0), G4TwoVector(19.577, -62.97), G4TwoVector(18.96, -61.07), G4TwoVector(9.449, -64.162), G4TwoVector(8.8, -62.165), G4TwoVector(18.31, -59.075), G4TwoVector(17.693, -57.172), G4TwoVector(6.655, -59.873)};
451  G4Material* peek = G4Material::GetMaterial("plumePeek");
452  G4ExtrudedSolid* s3_peek0 = new G4ExtrudedSolid("s3_peek0", points, 16.0, G4TwoVector(0, 0), 1, G4TwoVector(0, 0), 1);
453  G4LogicalVolume* l3_peek0 = new G4LogicalVolume(s3_peek0, peek, "PLUME.l3_peek0");
454 
455  G4Box* s3_tmp0 = new G4Box("s3_tmp0", 5. / 2., 21.5 / 2., 32. / 2.);
456  G4Box* s3_tmp1 = new G4Box("s3_tmp1", 5.2 / 2., 6.5 / 2., 30. / 2.);
457  G4Transform3D transform = G4Translate3D(0, -1.6, 0);
458  G4SubtractionSolid* s3_peek1 = new G4SubtractionSolid("s3_peek1", s3_tmp0, s3_tmp1, transform);
459 
460  G4Trd* s3_peek2 = new G4Trd("s3_peek2", 5. / 2., 5. / 2., 16., 10., 3.0);
461  G4Box* s3_peek3 = new G4Box("s3_peek3", 3. / 2., 15.5 / 2., 20. / 2.);
462  G4LogicalVolume* l3_peek1 = new G4LogicalVolume(s3_peek1, peek, "PLUME.l3_peek1");
463  G4LogicalVolume* l3_peek2 = new G4LogicalVolume(s3_peek2, peek, "PLUME.l3_peek2");
464  G4LogicalVolume* l3_peek3 = new G4LogicalVolume(s3_peek3, peek, "PLUME.l3_peek3");
465 
466  G4AssemblyVolume* assemblySup = new G4AssemblyVolume();
467 
468  G4ThreeVector Ta(0, 0, 0);
469  G4RotationMatrix ra;
470  G4Transform3D tra(ra, Ta);
471  assemblySup->AddPlacedVolume(l3_peek1, tra);
472  Ta.setY(21.5 / 2. + 3.0);
473  ra.rotateX(-M_PI / 2.);
474  tra = G4Transform3D(ra, Ta);
475  assemblySup->AddPlacedVolume(l3_peek2, tra);
476  Ta.setY(21.5 / 2. + 6.0 + 15.5 / 2.); Ta.setX(-1.0);
477  ra.rotateX(M_PI / 2.);
478  tra = G4Transform3D(ra, Ta);
479  assemblySup->AddPlacedVolume(l3_peek3, tra);
480 
481  Ta.setY(57.25); Ta.setX(-2.2);
482  tra = G4Transform3D(ra, Ta);
483  assemblySup->AddPlacedVolume(l3_peek0, tra);
484 
485 
486  G4Trd* s3_al0 = new G4Trd("s3_al0", 3. / 2., 3. / 2., 10.0, 6.0, 51.1566 / 2.);
487  G4Box* s3_al1 = new G4Box("s3_al1", 12. / 2., 4. / 2., 12. / 2.);
488  G4LogicalVolume* l3_al0 = new G4LogicalVolume(s3_al0, geometry::Materials::get("Al"), "PLUME.l3_al0");
489  G4LogicalVolume* l3_al1 = new G4LogicalVolume(s3_al1, geometry::Materials::get("Al"), "PLUME.l3_al1");
490  ra.rotateX(-M_PI / 2.);
491  Ta.setY(21.5 / 2. + 6.0 + 51.1566 / 2.); Ta.setX(+2.0);
492  tra = G4Transform3D(ra, Ta);
493  assemblySup->AddPlacedVolume(l3_al0, tra);
494  ra.rotateX(M_PI / 2.);
495  Ta.setY(21.5 / 2. + 6.0 + 51.1566 + 2.); Ta.setX(-2.5);
496  tra = G4Transform3D(ra, Ta);
497  assemblySup->AddPlacedVolume(l3_al1, tra);
498  return assemblySup;
499  }
500 
501  G4AssemblyVolume* PlumeCreator::buildSupport4()
502  {
503 
504 
505  std::vector<G4TwoVector> points = {G4TwoVector(-36.8, 6.645), G4TwoVector(-26.65, 9.94), G4TwoVector(-16.04, -3.0), G4TwoVector(3.5, -3.0), G4TwoVector(3.5, 0.0), G4TwoVector(-14.62, 0.0), G4TwoVector(-27.742, 16.0), G4TwoVector(-38.68, 12.446), G4TwoVector(-38.062, 10.544), G4TwoVector(-28.551, 13.634), G4TwoVector(-27.9, 11.637), G4TwoVector(-37.41, 8.547)};
506  G4Material* peek = G4Material::GetMaterial("plumePeek");
507  G4ExtrudedSolid* s4_peek0 = new G4ExtrudedSolid("s4_peek0", points, 10.0, G4TwoVector(0, 0), 1, G4TwoVector(0, 0), 1);
508  G4LogicalVolume* l4_peek0 = new G4LogicalVolume(s4_peek0, peek, "PLUME.l4_peek0");
509 
510  G4Trd* s4_al0 = new G4Trd("s4_al0", 12. / 2., 20. / 2., 3. / 2., 3. / 2., 36.5 / 2.);
511  G4Box* s4_al1 = new G4Box("s4_al1", 12. / 2., 16. / 2., 3.5 / 2.);
512  G4Box* s4_al2 = new G4Box("s4_al2", 12. / 2., 4. / 2., 14. / 2.);
513 
514  G4LogicalVolume* l4_al0 = new G4LogicalVolume(s4_al0, geometry::Materials::get("Al"), "PLUME.l4_al0");
515  G4LogicalVolume* l4_al1 = new G4LogicalVolume(s4_al1, geometry::Materials::get("Al"), "PLUME.l4_al1");
516  G4LogicalVolume* l4_al2 = new G4LogicalVolume(s4_al2, geometry::Materials::get("Al"), "PLUME.l4_al2");
517 
518  G4ThreeVector transl(0, 0, 0);
519  G4RotationMatrix ra;
520  G4Transform3D trans(ra, transl);
521  G4AssemblyVolume* assem_al = new G4AssemblyVolume();
522  assem_al->AddPlacedVolume(l4_al0, trans);
523  transl.setY(-16. / 2. + 3. / 2.); transl.setZ(-36.5 / 2. - 3.5 / 2.);
524  trans = G4Transform3D(ra, transl);
525  assem_al->AddPlacedVolume(l4_al1, trans);
526  transl.setZ(-36.5 / 2. - 14. / 2.); transl.setY(-16.5);
527  trans = G4Transform3D(ra, transl);
528  assem_al->AddPlacedVolume(l4_al2, trans);
529  ra.rotateY(M_PI / 2.); ra.rotateZ(M_PI);
530  transl.setZ(36.5 / 2. - 10.5); transl.setY(1.50);
531  trans = G4Transform3D(ra, transl);
532  assem_al->AddPlacedVolume(l4_peek0, trans);
533 
534  return assem_al;
535  }
536 
537  } // plume namespace
539 } // Belle2 namespace
Belle2::GearDir
GearDir is the basic class used for accessing the parameter store.
Definition: GearDir.h:31
Belle2::gearbox::Interface::getAngle
double getAngle(const std::string &path="") const noexcept(false)
Get the parameter path as a double converted to the standard angle unit.
Definition: Interface.h:299
Belle2::gearbox::Interface::getLength
double getLength(const std::string &path="") const noexcept(false)
Get the parameter path as a double converted to the standard length unit.
Definition: Interface.h:259
Belle2::gearbox::Interface::getNodes
std::vector< GearDir > getNodes(const std::string &path="") const
Get vector of GearDirs which point to all the nodes the given path evaluates to.
Definition: Interface.cc:21
Belle2::gearbox::Interface::getInt
int getInt(const std::string &path="") const noexcept(false)
Get the parameter path as a int.
Definition: Interface.cc:60
Belle2::geometry::Materials::get
static G4Material * get(const std::string &name)
Find given material.
Definition: Materials.h:63
Belle2::plume::PlumeCreator::buildSupport1
G4AssemblyVolume * buildSupport1()
Volume of support1.
Definition: PlumeCreator.cc:364
Belle2::plume::PlumeCreator::buildSupport2
G4AssemblyVolume * buildSupport2()
Volume of support2.
Definition: PlumeCreator.cc:411
Belle2::plume::PlumeCreator::~PlumeCreator
virtual ~PlumeCreator()
Destructor.
Definition: PlumeCreator.cc:57
Belle2::plume::PlumeCreator::create
virtual void create(const GearDir &content, G4LogicalVolume &topVolume, geometry::GeometryTypes type)
Creation of the detector geometry from Gearbox (XML).
Definition: PlumeCreator.cc:62
Belle2::plume::PlumeCreator::buildSupport4
G4AssemblyVolume * buildSupport4()
Volume of support4.
Definition: PlumeCreator.cc:501
Belle2::plume::PlumeCreator::buildSupport3
G4AssemblyVolume * buildSupport3()
Volume of support3.
Definition: PlumeCreator.cc:447
Belle2::plume::PlumeCreator::m_sensitive
SensitiveDetector * m_sensitive
SensitiveDetector PLUME.
Definition: PlumeCreator.h:47
Belle2::plume::SensitiveDetector
Sensitive Detector implementation of the PLUME detector.
Definition: SensitiveDetector.h:22
Belle2::geometry::GeometryTypes
GeometryTypes
Flag indiciating the type of geometry to be used.
Definition: GeometryManager.h:36
Belle2::plume::PlumeFactory
geometry::CreatorFactory< PlumeCreator > PlumeFactory("PLUMECreator")
Creator creates the PLUME geometry.
Belle2
Abstract base class for different kinds of events.
Definition: MillepedeAlgorithm.h:17
Belle2::geometry::CreatorFactory
Very simple class to provide an easy way to register creators with the CreatorManager.
Definition: CreatorFactory.h:31