Belle II Software development
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
36using namespace std;
37using namespace boost;
38
39namespace 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
std
STL namespace.
Belle2::geometry::CreatorFactory
Very simple class to provide an easy way to register creators with the CreatorManager.
Definition: CreatorFactory.h:31