Belle II Software  release-06-02-00
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  G4double fractionmass;
204  a = 1.01 * CLHEP::g / CLHEP::mole;
205  G4Element* elH = new G4Element(name = "Hydrogen", symbol = "H" , zz = 1., a);
206  a = 12.01 * CLHEP::g / CLHEP::mole;
207  G4Element* elC = new G4Element(name = "Carbon" , symbol = "C" , zz = 6., a);
208  a = 16.00 * CLHEP::g / CLHEP::mole;
209  G4Element* elO = new G4Element(name = "Oxygen" , symbol = "O" , zz = 8., a);
210  density = 1.31 * CLHEP::g / CLHEP::cm3;
211  G4Material* peekMat = new G4Material(name = "plumePeek" , density, ncomponents = 3);
212  peekMat->AddElement(elC, fractionmass = 0.76);
213  peekMat->AddElement(elH, fractionmass = 0.08);
214  peekMat->AddElement(elO, fractionmass = 0.16);
215  density = 1.5 * CLHEP::g / CLHEP::cm3;
216  G4Material* carbMat = new G4Material(name = "plumeCarb" , density, ncomponents = 1);
217  carbMat->AddElement(elC, fractionmass = 1.0);
218 
219  G4Box* s_sensor = new G4Box("s_sensor", SensorLengthX / 2., SensorLengthY / 2., dz_sensor);
220  G4LogicalVolume* l_sensor = new G4LogicalVolume(s_sensor, geometry::Materials::get("G4_AIR"), "PLUME.l_sensor");
221 
222  // Substrate Layer //
223  G4Box* s_substrate = new G4Box("s_substrate", SensorLengthX / 2. , SensorLengthY / 2. , SubstrateThickness / 2.);
224  G4LogicalVolume* l_substrate = new G4LogicalVolume(s_substrate, geometry::Materials::get("Silicon"), "PLUME.l_substrate");
225  new G4PVPlacement(0, G4ThreeVector(0, 0, -dz_sensor + SubstrateThickness / 2.), l_substrate, "p_substrate", l_sensor, false, 1);
226 
227  // Epitaxial Layer //
228  G4Box* s_epitaxial = new G4Box("s_epitaxial", SensorLengthX / 2. , SensorLengthY / 2., EpitaxialThickness / 2.);
229  G4LogicalVolume* l_epitaxial = new G4LogicalVolume(s_epitaxial, geometry::Materials::get("Silicon"), "PLUME.l_epitaxial", 0,
230  m_sensitive);
231  new G4PVPlacement(0, G4ThreeVector(0, 0, -dz_sensor + AirGap + SubstrateThickness + EpitaxialThickness / 2.), l_epitaxial,
232  "p_epitaxial", l_sensor, false, 1);
233  // Metalized Layer //
234  G4Box* s_metalized = new G4Box("s_metalized", SensorLengthX / 2. , SensorLengthY / 2. , MetalThickness / 2.);
235  G4LogicalVolume* l_metalized = new G4LogicalVolume(s_metalized, geometry::Materials::get("SiO2Al"), "PLUME.l_metalized");
236  new G4PVPlacement(0, G4ThreeVector(0, 0, -dz_sensor + 2 * AirGap + SubstrateThickness + EpitaxialThickness + MetalThickness / 2.),
237  l_metalized, "p_metalized", l_sensor, false, 1);
238 
239  // temporary
240  /*G4LogicalVolume* l_sensorMir = new G4LogicalVolume(s_sensor, geometry::Materials::get("G4_AIR"), "l_sensorMir");
241  new G4PVPlacement(0, G4ThreeVector(0, 0, -dz_sensor + MetalThickness / 2.), l_metalized, "p_metalized", l_sensorMir, false, 1);
242  new G4PVPlacement(0, G4ThreeVector(0, 0, -dz_sensor + MetalThickness + AirGap + EpitaxialThickness / 2.), l_epitaxial,
243  "p_epitaxial", l_sensorMir, false, 1);
244  new G4PVPlacement(0, G4ThreeVector(0, 0, -dz_sensor + MetalThickness + 2 * AirGap + EpitaxialThickness + SubstrateThickness / 2.),
245  l_substrate, "p_substrate", l_sensorMir, false, 1);
246  */
247 
248 
249  l_epitaxial->SetUserLimits(new G4UserLimits(stepSize));
250  l_substrate->SetVisAttributes(SubstrateVisAtt);
251  l_epitaxial->SetVisAttributes(EpitaxialVisAtt);
252  l_metalized->SetVisAttributes(MetalizedVisAtt);
253 
254  // place 12 sensors on support ladder
255  double zSens = dz_ladder + dz_sensor + AirGap;
256  G4RotationMatrix ra;
257  G4ThreeVector Ta(0, 0, 0);
258  G4Transform3D tra(ra, Ta);
259 
260  // build cooling tubes
261  GearDir pipeParams(content, "CoolingPipes");
262  double pipeLen = pipeParams.getLength("length") * CLHEP::cm;
263  double pipeInR = pipeParams.getLength("rIn") * CLHEP::cm;
264  double pipeOutR = pipeParams.getLength("rOut") * CLHEP::cm;
265  G4Tubs* pipe_s = new G4Tubs("pipe_s", pipeInR, pipeOutR, pipeLen / 2., 0, 2 * M_PI);
266 
267  G4LogicalVolume* pipe_l = new G4LogicalVolume(pipe_s, carbMat, "PLUME.l_pipe");
268  double pipeX = pipeParams.getLength("x") * CLHEP::cm;
269  double pipeY = pipeParams.getLength("y") * CLHEP::cm;
270  double pipeZ = pipeParams.getLength("z") * CLHEP::cm;
271  G4double alphaPipe = pipeParams.getAngle("alpha");
272 
273  //GearDir alignPars;
274  G4Box* s_sensors = new G4Box("s_sensors", flexlen / 2., flexwid / 2., dz_sensor + AirGap);
275 
276  for (auto ladder : content.getNodes("Placements/Ladder")) {
277 
278  std::string id = ladder.getString("@id");
279 
280  G4AssemblyVolume* assemblyLadder = new G4AssemblyVolume();
281  assemblyLadder->AddPlacedAssembly(support, tra);
282 
283  for (auto pars : content.getNodes("SensorAlignment/ladder")) {
284  if (pars.getString("@id") == id) {
285  GearDir alignPars(pars);
286 
287  for (auto sidePars : alignPars.getNodes("side")) {
288  unsigned mirror = 0;
289 
290  G4Transform3D transformSens;
291  if (sidePars.getString("@id") == "mirror") mirror = 1;
292 
293  G4LogicalVolume* l_sensors = new G4LogicalVolume(s_sensors, geometry::Materials::get("G4_AIR"), "PLUME.l_sensors");
294 
295  for (auto sensorPars : sidePars.getNodes("sensor")) {
296  double x = sensorPars.getLength("x") * CLHEP::cm + zshift;
297  double y = sensorPars.getLength("y") * CLHEP::cm;
298  int ids = sensorPars.getInt("id");
299  y = mirror ? -y : y;
300  y -= alwid / 2.;
301  double alpha1 = sensorPars.getAngle("alpha") * CLHEP::rad;
302  if (mirror) transformSens = G4Translate3D(x, y,
303  0) * G4RotateZ3D(alpha1) * G4RotateX3D(M_PI); // think if this is correct, rotation and pos shift for mirror side
304  else transformSens = G4Translate3D(x, y, 0) * G4RotateZ3D(-alpha1);
305 
306  new G4PVPlacement(transformSens, l_sensor, "p_sensor", l_sensors, true,
307  (ids + mirror * 6 + LadderID * 12));
308  }
309  transformSens = G4Translate3D(0, 0, mirror ? -zSens : zSens);
310  assemblyLadder->AddPlacedVolume(l_sensors, transformSens);
311  }
312  }
313  }
314 
315 
316 
317  G4double thetaZ = ladder.getAngle("ThetaZ");
318  G4double r = ladder.getLength("r_plume") * CLHEP::cm - zshift * sin(thetaZ);
319  G4double z = ladder.getLength("z_plume") * CLHEP::cm - zshift * cos(thetaZ);
320  G4double phi = ladder.getAngle("Phi");
321  G4double alpha = ladder.getAngle("Alpha");
322 
323 
324  // place cooling pipes
325  G4Transform3D transformPipe = G4Translate3D(pipeZ + zshift, pipeY, pipeX) * G4RotateZ3D(alphaPipe) * G4RotateY3D(+ M_PI / 2.);
326  assemblyLadder->AddPlacedVolume(pipe_l, transformPipe);
327  transformPipe = G4Translate3D(pipeZ + zshift
328  , pipeY, -pipeX) * G4RotateZ3D(alphaPipe) * G4RotateY3D(+ M_PI / 2.);
329  assemblyLadder->AddPlacedVolume(pipe_l, transformPipe);
330 
331 
332  G4Transform3D transform1;
333  if (LadderID == 1) {
334  G4AssemblyVolume* sup1 = buildSupport1();
335  G4AssemblyVolume* sup2 = buildSupport2();
336  transform1 = G4Translate3D(-fullLength / 2. - 18.7, 0., 1.2) * G4RotateY3D(thetaZ) * G4RotateX3D(M_PI / 2.) * G4RotateY3D(M_PI);
337  assemblyLadder->AddPlacedAssembly(sup1, transform1);
338  transform1 = G4Translate3D(fullLength / 2. + 19.5, 0, -2.6) * G4RotateY3D(thetaZ) * G4RotateX3D(M_PI / 2.);
339  assemblyLadder->AddPlacedAssembly(sup2, transform1);
340  }
341 
342  if (LadderID == 0) {
343  G4AssemblyVolume* sup1 = buildSupport3();
344  G4AssemblyVolume* sup2 = buildSupport4();
345  transform1 = G4Translate3D(fullLength / 2. + 5, 0,
346  7.8) * G4RotateY3D(-thetaZ) * G4RotateZ3D(M_PI / 2.) * G4RotateX3D(M_PI / 2.) * G4RotateY3D(M_PI / 2.);
347  assemblyLadder->AddPlacedAssembly(sup1, transform1);
348  transform1 = G4Translate3D(-fullLength / 2. - 31, 0.,
349  -21.7) * G4RotateY3D(-thetaZ) * G4RotateZ3D(M_PI / 2.) * G4RotateX3D(-M_PI / 2.) * G4RotateY3D(M_PI);
350  assemblyLadder->AddPlacedAssembly(sup2, transform1);
351  }
352 
353  G4Transform3D transform = G4RotateZ3D(phi) * G4Translate3D(r, 0,
354  z) * G4RotateY3D(thetaZ) * G4RotateZ3D(alpha + M_PI) * G4RotateY3D(- M_PI / 2.0);
355 
356  assemblyLadder->MakeImprint(&topVolume, transform);
357 
358  LadderID += 1;
359 
360  }
361 
362  }
363 
364 
365  G4AssemblyVolume* PlumeCreator::buildSupport1()
366  {
367 
368  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)};
369 
370  G4Material* peek = G4Material::GetMaterial("plumePeek");
371  G4ExtrudedSolid* s1_peek0 = new G4ExtrudedSolid("s1_peek0", points, 10.0, G4TwoVector(0, 0), 1, G4TwoVector(0, 0), 1);
372  G4LogicalVolume* l1_peek0 = new G4LogicalVolume(s1_peek0, peek, "PLUME.l1_peek0");
373 
374  G4Box* s1_peek1 = new G4Box("s1_peek1", 24. / 2., 6. / 2. , 20. / 2.);
375  G4Box* s1_peek2 = new G4Box("s1_peek2", 19.4 / 2., 3. / 2. , 20. / 2.);
376  G4LogicalVolume* l1_peek1 = new G4LogicalVolume(s1_peek1, peek, "PLUME.l1_peek1");
377  G4LogicalVolume* l1_peek2 = new G4LogicalVolume(s1_peek2, peek, "PLUME.l1_peek2");
378 
379  G4AssemblyVolume* assemblySup = new G4AssemblyVolume();
380 
381  G4Transform3D transform = G4Translate3D(0, 0., 0);
382 
383  assemblySup->AddPlacedVolume(l1_peek1, transform);
384 
385  transform = G4Translate3D(-16.974, 1.239, 0);
386  assemblySup->AddPlacedVolume(l1_peek0, transform);
387 
388  transform = G4Translate3D(21.7, 1.5, 0);
389  assemblySup->AddPlacedVolume(l1_peek2, transform);
390 
391  G4Trd* s1_al0 = new G4Trd("s1_al0", 12. / 2. , 20. / 2. , 3. / 2., 3. / 2., 94.5 / 2.);
392  G4Box* s1_al1 = new G4Box("s1_al1", 12. / 2. , 20.5 / 2. , 3.5 / 2.);
393  G4Box* s1_al2 = new G4Box("s1_al2", 12. / 2. , 4.0 / 2. , 10.5 / 2.);
394 
395  G4LogicalVolume* l1_al0 = new G4LogicalVolume(s1_al0, geometry::Materials::get("Al"), "PLUME.l1_al0");
396  G4LogicalVolume* l1_al1 = new G4LogicalVolume(s1_al1, geometry::Materials::get("Al"), "PLUME.l1_al1");
397  G4LogicalVolume* l1_al2 = new G4LogicalVolume(s1_al2, geometry::Materials::get("Al"), "PLUME.l1_al2");
398 
399  transform = G4Translate3D(59.25, -1.5, 0) * G4RotateY3D(-M_PI / 2.);
400  assemblySup->AddPlacedVolume(l1_al0, transform);
401 
402  transform = G4Translate3D(108.25, -20.5 / 2., 0) * G4RotateY3D(-M_PI / 2.);
403  assemblySup->AddPlacedVolume(l1_al1, transform);
404 
405  transform = G4Translate3D(115.25, -18.5, 0) * G4RotateY3D(-M_PI / 2.);
406  assemblySup->AddPlacedVolume(l1_al2, transform);
407 
408  return assemblySup;
409  }
410 
411 
412  G4AssemblyVolume* PlumeCreator::buildSupport2()
413  {
414 
415  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.)};
416  G4Material* peek = G4Material::GetMaterial("plumePeek");
417  G4ExtrudedSolid* s2_peek0 = new G4ExtrudedSolid("s2_peek0", points, 16.0, G4TwoVector(0, 0), 1, G4TwoVector(0, 0), 1);
418  G4LogicalVolume* l2_peek0 = new G4LogicalVolume(s2_peek0, peek, "PLUME.l2_peek0");
419 
420 
421  G4Box* s2_peek1 = new G4Box("s2_peek1", 10. / 2. , 6.7 / 2. , 12.5 / 2.);
422  G4Box* s2_peek2 = new G4Box("s2_peek2", 39.0 / 2., 4. / 2. , 12.5 / 2.);
423  G4LogicalVolume* l2_peek1 = new G4LogicalVolume(s2_peek1, peek, "PLUME.l2_peek1");
424  G4LogicalVolume* l2_peek2 = new G4LogicalVolume(s2_peek2, peek, "PLUME.l2_peek2");
425 
426  G4AssemblyVolume* assemblySup = new G4AssemblyVolume();
427 
428  G4Transform3D transform = G4Translate3D(0, 0., 0);
429 
430  assemblySup->AddPlacedVolume(l2_peek1, transform);
431 
432  transform = G4Translate3D(-18.4, 6.35, 0);
433  assemblySup->AddPlacedVolume(l2_peek0, transform);
434 
435  transform = G4Translate3D(24.5, -1.35, 0);
436  assemblySup->AddPlacedVolume(l2_peek2, transform);
437 
438  G4Box* s2_al0 = new G4Box("s2_al0", 140. / 2. , 4. / 2. , 12. / 2.);
439  G4LogicalVolume* l2_al0 = new G4LogicalVolume(s2_al0, geometry::Materials::get("Al"), "PLUME.l2_al0");
440 
441  transform = G4Translate3D(-26.0, -5.35, 0);
442  assemblySup->AddPlacedVolume(l2_al0, transform);
443 
444  return assemblySup;
445  }
446 
447 
448  G4AssemblyVolume* PlumeCreator::buildSupport3()
449  {
450 
451  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)};
452  G4Material* peek = G4Material::GetMaterial("plumePeek");
453  G4ExtrudedSolid* s3_peek0 = new G4ExtrudedSolid("s3_peek0", points, 16.0, G4TwoVector(0, 0), 1, G4TwoVector(0, 0), 1);
454  G4LogicalVolume* l3_peek0 = new G4LogicalVolume(s3_peek0, peek, "PLUME.l3_peek0");
455 
456  G4Box* s3_tmp0 = new G4Box("s3_tmp0", 5. / 2. , 21.5 / 2., 32. / 2.);
457  G4Box* s3_tmp1 = new G4Box("s3_tmp1", 5.2 / 2. , 6.5 / 2., 30. / 2.);
458  G4Transform3D transform = G4Translate3D(0, -1.6, 0);
459  G4SubtractionSolid* s3_peek1 = new G4SubtractionSolid("s3_peek1", s3_tmp0, s3_tmp1, transform);
460 
461  G4Trd* s3_peek2 = new G4Trd("s3_peek2", 5. / 2., 5. / 2., 16., 10., 3.0);
462  G4Box* s3_peek3 = new G4Box("s3_peek3", 3. / 2. , 15.5 / 2., 20. / 2.);
463  G4LogicalVolume* l3_peek1 = new G4LogicalVolume(s3_peek1, peek, "PLUME.l3_peek1");
464  G4LogicalVolume* l3_peek2 = new G4LogicalVolume(s3_peek2, peek, "PLUME.l3_peek2");
465  G4LogicalVolume* l3_peek3 = new G4LogicalVolume(s3_peek3, peek, "PLUME.l3_peek3");
466 
467  G4AssemblyVolume* assemblySup = new G4AssemblyVolume();
468 
469  G4ThreeVector Ta(0, 0, 0);
470  G4RotationMatrix ra;
471  G4Transform3D tra(ra, Ta);
472  assemblySup->AddPlacedVolume(l3_peek1, tra);
473  Ta.setY(21.5 / 2. + 3.0);
474  ra.rotateX(-M_PI / 2.);
475  tra = G4Transform3D(ra, Ta);
476  assemblySup->AddPlacedVolume(l3_peek2, tra);
477  Ta.setY(21.5 / 2. + 6.0 + 15.5 / 2.); Ta.setX(-1.0);
478  ra.rotateX(M_PI / 2.);
479  tra = G4Transform3D(ra, Ta);
480  assemblySup->AddPlacedVolume(l3_peek3, tra);
481 
482  Ta.setY(57.25); Ta.setX(-2.2);
483  tra = G4Transform3D(ra, Ta);
484  assemblySup->AddPlacedVolume(l3_peek0, tra);
485 
486 
487  G4Trd* s3_al0 = new G4Trd("s3_al0", 3. / 2. , 3. / 2., 10.0, 6.0, 51.1566 / 2.);
488  G4Box* s3_al1 = new G4Box("s3_al1", 12. / 2. , 4. / 2. , 12. / 2.);
489  G4LogicalVolume* l3_al0 = new G4LogicalVolume(s3_al0, geometry::Materials::get("Al"), "PLUME.l3_al0");
490  G4LogicalVolume* l3_al1 = new G4LogicalVolume(s3_al1, geometry::Materials::get("Al"), "PLUME.l3_al1");
491  ra.rotateX(-M_PI / 2.);
492  Ta.setY(21.5 / 2. + 6.0 + 51.1566 / 2.); Ta.setX(+2.0);
493  tra = G4Transform3D(ra, Ta);
494  assemblySup->AddPlacedVolume(l3_al0, tra);
495  ra.rotateX(M_PI / 2.);
496  Ta.setY(21.5 / 2. + 6.0 + 51.1566 + 2.); Ta.setX(-2.5);
497  tra = G4Transform3D(ra, Ta);
498  assemblySup->AddPlacedVolume(l3_al1, tra);
499  return assemblySup;
500  }
501 
502  G4AssemblyVolume* PlumeCreator::buildSupport4()
503  {
504 
505 
506  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)};
507  G4Material* peek = G4Material::GetMaterial("plumePeek");
508  G4ExtrudedSolid* s4_peek0 = new G4ExtrudedSolid("s4_peek0", points, 10.0, G4TwoVector(0, 0), 1, G4TwoVector(0, 0), 1);
509  G4LogicalVolume* l4_peek0 = new G4LogicalVolume(s4_peek0, peek, "PLUME.l4_peek0");
510 
511  G4Trd* s4_al0 = new G4Trd("s4_al0", 12. / 2. , 20. / 2. , 3. / 2., 3. / 2., 36.5 / 2.);
512  G4Box* s4_al1 = new G4Box("s4_al1", 12. / 2. , 16. / 2. , 3.5 / 2.);
513  G4Box* s4_al2 = new G4Box("s4_al2", 12. / 2. , 4. / 2. , 14. / 2.);
514 
515  G4LogicalVolume* l4_al0 = new G4LogicalVolume(s4_al0, geometry::Materials::get("Al"), "PLUME.l4_al0");
516  G4LogicalVolume* l4_al1 = new G4LogicalVolume(s4_al1, geometry::Materials::get("Al"), "PLUME.l4_al1");
517  G4LogicalVolume* l4_al2 = new G4LogicalVolume(s4_al2, geometry::Materials::get("Al"), "PLUME.l4_al2");
518 
519  G4ThreeVector transl(0, 0, 0);
520  G4RotationMatrix ra;
521  G4Transform3D trans(ra, transl);
522  G4AssemblyVolume* assem_al = new G4AssemblyVolume();
523  assem_al->AddPlacedVolume(l4_al0, trans);
524  transl.setY(-16. / 2. + 3. / 2.); transl.setZ(-36.5 / 2. - 3.5 / 2.);
525  trans = G4Transform3D(ra, transl);
526  assem_al->AddPlacedVolume(l4_al1, trans);
527  transl.setZ(-36.5 / 2. - 14. / 2.); transl.setY(-16.5);
528  trans = G4Transform3D(ra, transl);
529  assem_al->AddPlacedVolume(l4_al2, trans);
530  ra.rotateY(M_PI / 2.); ra.rotateZ(M_PI);
531  transl.setZ(36.5 / 2. - 10.5); transl.setY(1.50);
532  trans = G4Transform3D(ra, transl);
533  assem_al->AddPlacedVolume(l4_peek0, trans);
534 
535  return assem_al;
536  }
537 
538  } // plume namespace
540 } // 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:365
Belle2::plume::PlumeCreator::buildSupport2
G4AssemblyVolume * buildSupport2()
Volume of support2.
Definition: PlumeCreator.cc:412
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:502
Belle2::plume::PlumeCreator::buildSupport3
G4AssemblyVolume * buildSupport3()
Volume of support3.
Definition: PlumeCreator.cc:448
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