Belle II Software development
Ph1bpipeCreator.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/ph1bpipe/geometry/Ph1bpipeCreator.h>
10#include <beast/ph1bpipe/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 <G4PVPlacement.hh>
23#include <G4VisAttributes.hh>
24
25//Shapes
26#include <G4Box.hh>
27#include <G4EllipticalTube.hh>
28#include "G4UnionSolid.hh"
29#include "G4SubtractionSolid.hh"
30#include "G4IntersectionSolid.hh"
31#include <G4UserLimits.hh>
32#include "G4Tubs.hh"
33#include "G4Trd.hh"
34
35using namespace std;
36using namespace boost;
37
38namespace Belle2 {
45 namespace ph1bpipe {
46
47 // Register the creator
49 geometry::CreatorFactory<Ph1bpipeCreator> Ph1bpipeFactory("PH1BPIPECreator");
50
51 Ph1bpipeCreator::Ph1bpipeCreator(): m_sensitive(0)
52 {
53 //m_sensitive = new SensitiveDetector();
54 }
55
56 Ph1bpipeCreator::~Ph1bpipeCreator()
57 {
58 if (m_sensitive) delete m_sensitive;
59 }
60
61 void Ph1bpipeCreator::create(const GearDir& content, G4LogicalVolume& topVolume, geometry::GeometryTypes /* type */)
62 {
63
64 m_sensitive = new SensitiveDetector();
65
66 //Beam pipes 6 pillars
67 double pillar_height = 61.9 * CLHEP::cm / 2.;
68 double pillar_length = 3. * CLHEP::cm;
69 double pillar_width = pillar_length;
70 G4VSolid* s_bppillar = new G4Box("s_bppillar", pillar_length, pillar_height, pillar_width);
71 G4LogicalVolume* l_bppillar = new G4LogicalVolume(s_bppillar, geometry::Materials::get("Al"), "l_bppillar", 0, 0);
72 G4VisAttributes* white = new G4VisAttributes(G4Colour(1, 1, 1));
73 white->SetForceAuxEdgeVisible(true);
74 l_bppillar->SetVisAttributes(white);
75 double y_offset = -76. * CLHEP::cm + pillar_height;
76 G4ThreeVector Pillarpos = G4ThreeVector(0, y_offset, -154.0 * CLHEP::cm);
77 new G4PVPlacement(0, Pillarpos, l_bppillar, "p_bppilar1", &topVolume, false, 1);
78 Pillarpos = G4ThreeVector(0, y_offset, 154.0 * CLHEP::cm);
79 new G4PVPlacement(0, Pillarpos, l_bppillar, "p_bppilar2", &topVolume, false, 1);
80 Pillarpos = G4ThreeVector(11.4175236299 * CLHEP::cm, y_offset, -227.758203051 * CLHEP::cm);
81 new G4PVPlacement(0, Pillarpos, l_bppillar, "p_bppilar3", &topVolume, false, 1);
82 Pillarpos = G4ThreeVector(-10.4976636985 * CLHEP::cm, y_offset, 227.758203051 * CLHEP::cm);
83 new G4PVPlacement(0, Pillarpos, l_bppillar, "p_bppilar4", &topVolume, false, 1);
84 Pillarpos = G4ThreeVector(-8.71250756316 * CLHEP::cm, y_offset, -209.819190072 * CLHEP::cm);
85 new G4PVPlacement(0, Pillarpos, l_bppillar, "p_bppilar5", &topVolume, false, 1);
86 Pillarpos = G4ThreeVector(8.71248973173 * CLHEP::cm, y_offset, 209.819190072 * CLHEP::cm);
87 new G4PVPlacement(0, Pillarpos, l_bppillar, "p_bppilar6", &topVolume, false, 1);
88
89 //Central beam pipe reinforcement
90 double x_reih = 2. * CLHEP::cm / 2.;
91 double y_reih = 2.3 * CLHEP::cm / 2.;
92 double z_reih = 48. * CLHEP::cm / 2.;
93 G4VSolid* s_reih = new G4Box("s_reih", x_reih, y_reih, z_reih);
94 G4LogicalVolume* l_reih = new G4LogicalVolume(s_reih, geometry::Materials::get("Al"), "l_reih", 0, 0);
95 l_reih->SetVisAttributes(white);
96 G4ThreeVector Reihpos = G4ThreeVector(72.8780869619 * CLHEP::mm, 0, 1.35841468498 * CLHEP::mm);
97 new G4PVPlacement(0, Reihpos, l_reih, "p_Reih1", &topVolume, false, 1);
98 Reihpos = G4ThreeVector(-72.8780869619 * CLHEP::mm, 0, 1.35841468498 * CLHEP::mm);
99 new G4PVPlacement(0, Reihpos, l_reih, "p_Reih2", &topVolume, false, 1);
100
101 double x_reiv = 2. * CLHEP::cm / 2.;
102 double y_reiv = 5.2 * CLHEP::cm / 2.;
103 double z_reiv = 140. * CLHEP::cm / 2.;
104 G4VSolid* s_reiv = new G4Box("s_reiv", x_reiv, y_reiv, z_reiv);
105 G4LogicalVolume* l_reiv = new G4LogicalVolume(s_reiv, geometry::Materials::get("Al"), "l_reiv", 0, 0);
106 l_reiv->SetVisAttributes(white);
107 //G4ThreeVector Reivpos = G4ThreeVector(0, -77.5018052955 * CLHEP::mm, 0);
108 G4ThreeVector Reivpos = G4ThreeVector(0, -83.0 * CLHEP::mm, 0);
109 new G4PVPlacement(0, Reivpos, l_reiv, "p_Reiv1", &topVolume, false, 1);
110 //Reivpos = G4ThreeVector(0, 77.4981947045 * CLHEP::mm,0 );
111 Reivpos = G4ThreeVector(0, 83.0 * CLHEP::mm, 0);
112 new G4PVPlacement(0, Reivpos, l_reiv, "p_Reiv2", &topVolume, false, 1);
113
114 /*
115 Central beampipe +- pipe_hz = 20cm
116 Flanges of centra BP endcap_hz = 2.2cm thick
117 Distance of the end of xshape from IP xpipe_hz1 = 200cm
118 Length of far beampipe backward xpipePOS_hz = 168.1cm
119 Length of far beampipe backward xpipeMIN_hz = 141.3cm
120 */
121
122 //lets get the stepsize parameter with a default value of 5 µm
123 double stepSize = content.getLength("stepSize", 5 * CLHEP::um);
124// flag_limitStep = true for SynRad simulation
125 //double stepMax = 50. *CLHEP::mm;
126 //cout << " stepMax = " << stepMax << endl;
127 //bool flag_limitStep = false;
128// bool flag_limitStep = true;
129
130// double stepSize = content.getLength("stepSize", 5*CLHEP::um);
131 double SafetyLength = 0.1 * CLHEP ::cm;
132
133 double xpipe_hz1 = content.getLength("xpipe_hz1") * CLHEP::cm;
134 double pipe_hz = content.getLength("pipe_hz") * CLHEP::cm;
135 double pipe_outerRadius_x = content.getLength("pipe_outerRadius_x") * CLHEP::cm;
136 double pipe_outerRadius_y = content.getLength("pipe_outerRadius_y") * CLHEP::cm;
137 double pipe_innerRadius_x = content.getLength("pipe_innerRadius_x") * CLHEP::cm;
138 double pipe_innerRadius_y = content.getLength("pipe_innerRadius_y") * CLHEP::cm;
139 double xpipe_innerRadius = content.getLength("xpipe_innerRadius") * CLHEP::cm;
140 double xpipe_outerRadius = content.getLength("xpipe_outerRadius") * CLHEP::cm;
141 double pipe_innerRadiusTiN_x = content.getLength("pipe_innerRadiusTiN_x") * CLHEP::cm;
142 double pipe_innerRadiusTiN_y = content.getLength("pipe_innerRadiusTiN_y") * CLHEP::cm;
143 double xpipe_innerRadiusTiN = content.getLength("xpipe_innerRadiusTiN") * CLHEP::cm;
144 double endcap_hz = content.getLength("endcap_hz") * CLHEP::cm;
145 double endcap_outerRadius = content.getLength("endcap_outerRadius") * CLHEP::cm;
146 double xpipePOS_hz = content.getLength("xpipePOS_hz") * CLHEP::cm;
147 double xpipeMIN_hz = content.getLength("xpipeMIN_hz") * CLHEP::cm;
148
149 //create ph1bpipe volume
150 double startAngle = 0.*CLHEP::deg;
151 double spanningAngle = 360.*CLHEP::deg;
152 double A1 = 0.0415 * CLHEP::rad;
153// //cout << " A1 = " << A1 << endl;
154 double OBtemp = sqrt(pow(xpipe_hz1, 2) + pow(xpipe_innerRadius / 2., 2));
155 // cout << " OBtemp = " << OBtemp << endl;
156 double BCtemp = OBtemp * sin(A1);
157 // cout << " BCtemp = " << BCtemp << endl;
158 double ABtemp = sqrt(pow(pipe_hz, 2) + pow(OBtemp, 2) - 2 * pipe_hz * OBtemp * cos(A1));
159 // cout << " ABtemp = " << ABtemp << endl;
160 double A2 = asin(BCtemp / ABtemp) * CLHEP::rad;
161 // cout << " A2 = " << A2 << endl;
162 double xpipe_hz = ABtemp - 2 * endcap_hz / cos(A2); // Length of xshape pipe
163 // cout << " xpipe_hz = " << xpipe_hz << endl;
164 double xcont2 = BCtemp + xpipe_outerRadius; // +Z size of AluCont_f trapezoid
165 double xcont1 = xpipe_outerRadius + 2 * endcap_hz * tan(A2); //-Z size of AluCont_f trapezoid
166 double xcont3 = xcont2 + xpipePOS_hz * sin(A1); // +Z size of AluCont_fp trapezoid
167 double xcont4 = xcont3 - 2 * xpipe_outerRadius; // +Z size of AluCont_fps trapezoid
168 double xcont5 = xcont2 - 2 * xpipe_outerRadius; // -Z size of AluCont_fps trapezoid
169 double xcont3M = xcont2 + xpipeMIN_hz * sin(A1); // +Z size of AluCont_bp trapezoid
170 double xcont4M = xcont3M - 2 * xpipe_outerRadius; // +Z size of AluCont_bps trapezoid
171 // cout << " xcont2 = " << xcont2 << " xcont1 = " << xcont1 << endl;
172 // cout << " xcont3 = " << xcont3 << " xcont4 = " << xcont4 << " xcont5 = " << xcont5 << endl;
173 // cout << " xcont3M = " << xcont3M << " xcont4M = " << xcont4M << endl;
174 double dxtr = 0.5 * (ABtemp + 2 * endcap_hz / cos(A2)) * sin(2 * A2);
175 double dztr = (ABtemp + 2 * endcap_hz / cos(A2)) * sin(A2) * sin(A2);
176 // cout << "dxtr = " << dxtr << " dztr = " << dztr << endl;
177
178 string matPipe = content.getString("MaterialPipe");
179 string matTiN = content.getString("MaterialTiN");
180 string vacPipe = content.getString("MatVacuum");
181 G4double tubinR = 0.0 * CLHEP::cm;
182
183 G4VSolid* s_PH1BPIPE = new G4EllipticalTube("s_PH1BPIPE",
184 pipe_outerRadius_x,
185 pipe_outerRadius_y,
186 pipe_hz);
187 G4LogicalVolume* l_PH1BPIPE = new G4LogicalVolume(s_PH1BPIPE, geometry::Materials::get(matPipe), "l_PH1BPIPE", 0, 0);
188 //Lets limit the Geant4 stepsize inside the volume
189 l_PH1BPIPE->SetUserLimits(new G4UserLimits(stepSize));
190 //position central ph1bpipe volume
191 G4ThreeVector PH1BPIPEpos = G4ThreeVector(
192 content.getLength("x_ph1bpipe") * CLHEP::cm,
193 content.getLength("y_ph1bpipe") * CLHEP::cm,
194 content.getLength("z_ph1bpipe") * CLHEP::cm
195 );
196 new G4PVPlacement(0, PH1BPIPEpos, l_PH1BPIPE, "p_PH1BPIPE", &topVolume, false, 0);
197
198 G4VSolid* s_PH1BPIPETiN = new G4EllipticalTube("s_PH1BPIPETiN",
199 pipe_innerRadius_x,
200 pipe_innerRadius_y,
201 pipe_hz);
202 G4LogicalVolume* l_PH1BPIPETiN = new G4LogicalVolume(s_PH1BPIPETiN, geometry::Materials::get(matTiN), "l_PH1BPIPETiN", 0, 0);
203 new G4PVPlacement(0, PH1BPIPEpos, l_PH1BPIPETiN, "p_PH1BPIPETiN", l_PH1BPIPE, false, 0);
204
205 G4VSolid* s_PH1BPIPEV = new G4EllipticalTube("s_PH1BPIPEV",
206 pipe_innerRadiusTiN_x,
207 pipe_innerRadiusTiN_y,
208 pipe_hz);
209 G4VSolid* s_PH1BPIPEVac = new G4IntersectionSolid("s_PH1BPIPEVac", s_PH1BPIPE, s_PH1BPIPEV);
210 G4LogicalVolume* l_PH1BPIPEVac = new G4LogicalVolume(s_PH1BPIPEVac, geometry::Materials::get(vacPipe), "l_PH1BPIPEVac", 0, 0);
211 //if (flag_limitStep) l_PH1BPIPEVac->SetUserLimits(new G4UserLimits(stepMax));
212 new G4PVPlacement(0, PH1BPIPEpos, l_PH1BPIPEVac, "p_PH1BPIPEVac", l_PH1BPIPETiN, false, 0);
213
214 //create central endcaps
215 G4VSolid* s_PH1BPIPEendcap = new G4Tubs("s_PH1BPIPEendcap", 0.,
216 endcap_outerRadius,
217 endcap_hz,
218 startAngle, spanningAngle);
219 G4LogicalVolume* l_PH1BPIPEendcapTop = new G4LogicalVolume(s_PH1BPIPEendcap, geometry::Materials::get(matPipe),
220 "l_PH1BPIPEendcapTop", 0, 0);
221 G4LogicalVolume* l_PH1BPIPEendcapBot = new G4LogicalVolume(s_PH1BPIPEendcap, geometry::Materials::get(matPipe),
222 "l_PH1BPIPEendcapBot", 0, 0);
223 //position central endcaps
224 G4ThreeVector PH1BPIPEendcapposTop = G4ThreeVector(
225 content.getLength("x_ph1bpipe") * CLHEP::cm,
226 content.getLength("y_ph1bpipe") * CLHEP::cm,
227 content.getLength("z_ph1bpipe") * CLHEP::cm + pipe_hz + endcap_hz
228 );
229
230 G4ThreeVector PH1BPIPEendcapposBot = G4ThreeVector(
231 content.getLength("x_ph1bpipe") * CLHEP::cm,
232 content.getLength("y_ph1bpipe") * CLHEP::cm,
233 content.getLength("z_ph1bpipe") * CLHEP::cm - pipe_hz - endcap_hz
234 );
235 new G4PVPlacement(0, PH1BPIPEendcapposTop, l_PH1BPIPEendcapTop, "p_PH1BPIPEendcapTop", &topVolume, false, 0);
236 new G4PVPlacement(0, PH1BPIPEendcapposBot, l_PH1BPIPEendcapBot, "p_PH1BPIPEendcapBot", &topVolume, false, 0);
237
238 G4VSolid* s_PH1BPIPEendcapTiN = new G4EllipticalTube("s_PH1BPIPEendcapTiN",
239 pipe_innerRadius_x,
240 pipe_innerRadius_y,
241 endcap_hz);
242 G4LogicalVolume* l_PH1BPIPEendcapTiNTop = new G4LogicalVolume(s_PH1BPIPEendcapTiN, geometry::Materials::get(matTiN),
243 "l_PH1BPIPEendcapTiNTop", 0, 0);
244 G4LogicalVolume* l_PH1BPIPEendcapTiNBot = new G4LogicalVolume(s_PH1BPIPEendcapTiN, geometry::Materials::get(matTiN),
245 "l_PH1BPIPEendcapTiNBot", 0, 0);
246 new G4PVPlacement(0, G4ThreeVector(0., 0., 0.), l_PH1BPIPEendcapTiNTop, "p_PH1BPIPEendcapTiNTop", l_PH1BPIPEendcapTop, false, 0);
247 new G4PVPlacement(0, G4ThreeVector(0., 0., 0.), l_PH1BPIPEendcapTiNBot, "p_PH1BPIPEendcapTiNBot", l_PH1BPIPEendcapBot, false, 0);
248
249 G4VSolid* s_PH1BPIPEendcapV = new G4EllipticalTube("s_PH1BPIPEendcapV",
250 pipe_innerRadiusTiN_x,
251 pipe_innerRadiusTiN_y,
252 endcap_hz);
253 G4VSolid* s_PH1BPIPEendcapVac = new G4IntersectionSolid("s_PH1BPIPEendcapVac", s_PH1BPIPEendcap, s_PH1BPIPEendcapV);
254 G4LogicalVolume* l_PH1BPIPEendcapVac = new G4LogicalVolume(s_PH1BPIPEendcapVac, geometry::Materials::get(vacPipe),
255 "l_PH1BPIPEendcapVac", 0, 0);
256 //if (flag_limitStep) l_PH1BPIPEendcapVac->SetUserLimits(new G4UserLimits(stepMax));
257 new G4PVPlacement(0, G4ThreeVector(0., 0., 0.), l_PH1BPIPEendcapVac, "p_PH1BPIPEendcapVacTop", l_PH1BPIPEendcapTiNTop, false, 0);
258 new G4PVPlacement(0, G4ThreeVector(0., 0., 0.), l_PH1BPIPEendcapVac, "p_PH1BPIPEendcapVacBot", l_PH1BPIPEendcapTiNBot, false, 0);
259
260 //create x shape tubes forward
261 // Alu trapezoid containing x-shape tube
262 G4VSolid* AluCont_f = new G4Trd("AluCont_f", xcont1, xcont2, xcont1, xcont1, xpipe_hz / 2.0 * cos(A2));
263 G4LogicalVolume* logi_AluCont_f = new G4LogicalVolume(AluCont_f, geometry::Materials::get(matPipe), "logi_AluCont_f", 0, 0);
264 new G4PVPlacement(0, G4ThreeVector(0, 0, pipe_hz + endcap_hz * 2.0 + 0.5 * xpipe_hz * cos(A2)),
265 logi_AluCont_f, "phys_AluCont_f", &topVolume, false, 0);
266// //cout << " AluCont_f z pos = " << pipe_hz + endcap_hz*2.0 + xpipe_hz*cos(A2)/2. << endl;
267// //cout << " AluCont_f zmax pos = " << pipe_hz + endcap_hz*2.0 + xpipe_hz*cos(A2) << endl;
268
269 // create x part
270 G4VSolid* s_Xshapef_11 = new G4Tubs("s_Xshapef_11",
271 tubinR,
272 xpipe_innerRadius,
273 xpipe_hz,
274 startAngle, spanningAngle);
275 G4VSolid* s_Xshapef_12 = new G4Tubs("s_Xshapef_12",
276 tubinR,
277 xpipe_innerRadius * 2.0,
278 xpipe_hz / 2.0,
279 startAngle, spanningAngle);
280 G4VSolid* s_Xshapef_21 = new G4Tubs("s_Xshapef_21",
281 tubinR,
282 xpipe_innerRadiusTiN,
283 xpipe_hz,
284 startAngle, spanningAngle);
285 G4VSolid* s_Xshapef_22 = new G4Tubs("s_Xshapef_22",
286 tubinR,
287 xpipe_innerRadiusTiN * 2.0,
288 xpipe_hz / 2.0,
289 startAngle, spanningAngle);
290 //create TiN layer on
291
292 G4VSolid* s_XshapefTiN_11 = new G4Tubs("s_XshapefTiN_11",
293 tubinR,
294 xpipe_innerRadius,
295 xpipe_hz,
296 startAngle, spanningAngle);
297 G4VSolid* s_XshapefTiN_12 = new G4Tubs("s_XshapefTiN_12",
298 tubinR,
299 xpipe_innerRadius * 2.0,
300 xpipe_hz / 2.0,
301 startAngle, spanningAngle);
302 G4VSolid* s_XshapefTiN_21 = new G4Tubs("s_XshapefTiN_21",
303 tubinR,
304 xpipe_innerRadius,
305 xpipe_hz,
306 startAngle, spanningAngle);
307 G4VSolid* s_XshapefTiN_22 = new G4Tubs("s_XshapefTiN_22",
308 tubinR,
309 xpipe_innerRadius * 2.0,
310 xpipe_hz / 2.0,
311 startAngle, spanningAngle);
312 //Slanted tube1
313 G4Transform3D transform_sXshapef_12 = G4Translate3D(0., 0., 0.);
314 transform_sXshapef_12 = transform_sXshapef_12 * G4RotateY3D(-A2);
315 G4IntersectionSolid* Xshapef1 = new G4IntersectionSolid("Xshapef1", s_Xshapef_11, s_Xshapef_12, transform_sXshapef_12);
316 //Slanted tube2
317 G4Transform3D transform_sXshapef_22 = G4Translate3D(0., 0., 0.);
318 transform_sXshapef_22 = transform_sXshapef_22 * G4RotateY3D(A2);
319 G4IntersectionSolid* Xshapef2 = new G4IntersectionSolid("Xshapef2", s_Xshapef_21, s_Xshapef_22, transform_sXshapef_22);
320 //Slanted tube1TiN
321 G4Transform3D transform_sXshapefTiN_12 = G4Translate3D(0., 0., 0.);
322 transform_sXshapefTiN_12 = transform_sXshapefTiN_12 * G4RotateY3D(-A2);
323 G4IntersectionSolid* XshapefTiN1 = new G4IntersectionSolid("XshapefTiN1", s_XshapefTiN_11, s_XshapefTiN_12,
324 transform_sXshapefTiN_12);
325 //Slanted tube2TiN
326 G4Transform3D transform_sXshapefTiN_22 = G4Translate3D(0., 0., 0.);
327 transform_sXshapefTiN_22 = transform_sXshapefTiN_22 * G4RotateY3D(A2);
328 G4IntersectionSolid* XshapefTiN2 = new G4IntersectionSolid("XshapefTiN2", s_XshapefTiN_21, s_XshapefTiN_22,
329 transform_sXshapefTiN_22);
330
331 // (sXshapeTiN2 + sXshapeTiN1)
332 G4Transform3D transform_XshapefTiN1 = G4Translate3D(dxtr, 0., -dztr);
333 transform_XshapefTiN1 = transform_XshapefTiN1 * G4RotateY3D(2.*A2);
334 G4UnionSolid* XshapeTiNForwx = new G4UnionSolid("XshapeTiNForwx", XshapefTiN2, XshapefTiN1, transform_XshapefTiN1);
335 // Place XshapeTiNForwx into logi_AluCont_f
336 G4RotationMatrix* yRot = new G4RotationMatrix;
337 yRot->rotateY(A2);
338 G4ThreeVector transform_XshapeTiNForwx(-dxtr / 2., 0., 0.);
339 G4IntersectionSolid* XshapeTiNForw = new G4IntersectionSolid("XshapeTiNForw", AluCont_f, XshapeTiNForwx, yRot,
340 transform_XshapeTiNForwx);
341 G4LogicalVolume* l_XshapeTiNForw = new G4LogicalVolume(XshapeTiNForw, geometry::Materials::get(matTiN), "l_XshapeTiNForw", 0, 0);
342 new G4PVPlacement(0, G4ThreeVector(0., 0., 0.), l_XshapeTiNForw, "p_XshapeTiNForw", logi_AluCont_f, false, 0);
343
344 // sXshape2 + sXshape1
345 G4Transform3D transform_Xshapef1 = G4Translate3D(dxtr, 0., -dztr);
346 transform_Xshapef1 = transform_Xshapef1 * G4RotateY3D(2.*A2);
347 G4UnionSolid* XshapeForwx = new G4UnionSolid("XshapeForwx", Xshapef2, Xshapef1, transform_Xshapef1);
348 // Place XshapeForwx into l_XshapeTiNForw
349 G4Transform3D transform_XshapeForwx = G4Translate3D(-dxtr / 2., 0., 0.);
350 transform_XshapeForwx = transform_XshapeForwx * G4RotateY3D(-A2);
351 G4IntersectionSolid* XshapeForw = new G4IntersectionSolid("XshapeForw", AluCont_f, XshapeForwx, transform_XshapeForwx);
352 G4LogicalVolume* l_XshapeForw = new G4LogicalVolume(XshapeForw, geometry::Materials::get(vacPipe), "l_XshapeForw", 0, 0);
353 //if (flag_limitStep) l_XshapeForw ->SetUserLimits(new G4UserLimits(stepMax));
354 new G4PVPlacement(0, G4ThreeVector(0., 0., 0.), l_XshapeForw, "p_XshapeForw", l_XshapeTiNForw, false, 0);
355
356 //create far forward parts
357 // Alu trapezoid containing far parts
358 G4VSolid* AluCont_fpO = new G4Trd("AluCont_fpO", xcont2, xcont3, xcont1, xcont1, xpipePOS_hz / 2.0 * cos(A1));
359 G4VSolid* AluCont_fps = new G4Trd("AluCont_fps", xcont5, xcont4, xcont1, xcont1, xpipePOS_hz / 2.0 * cos(A1));
360 G4Transform3D transform_AluCont_fps = G4Translate3D(0., 0., 0.);
361 G4SubtractionSolid* AluCont_fp = new G4SubtractionSolid("AluCont_fp", AluCont_fpO, AluCont_fps, transform_AluCont_fps);
362 G4LogicalVolume* logi_AluCont_fp = new G4LogicalVolume(AluCont_fp, geometry::Materials::get(matPipe), "logi_AluCont_fp", 0, 0);
363 new G4PVPlacement(0, G4ThreeVector(0, 0, pipe_hz + endcap_hz * 2.0 + xpipe_hz * cos(A2) + xpipePOS_hz / 2.0 * cos(A1)),
364 logi_AluCont_fp, "phys_AluCont_fp", &topVolume, false, 0);
365 //HER far forward part
366 //slanted tubes Vacuum
367 G4VSolid* s_XshapefPOS_11 = new G4Tubs("s_XshapefPOS11",
368 tubinR,
369 xpipe_innerRadius,
370 xpipePOS_hz,
371 startAngle, spanningAngle);
372 G4VSolid* s_XshapefPOS_12 = new G4Tubs("s_XshapefPOS12",
373 tubinR,
374 xpipe_innerRadius * 2,
375 xpipePOS_hz / 2. - 0.7568202457 * SafetyLength,
376 startAngle, spanningAngle);
377 G4Transform3D transform_sXshapefPOS_12 = G4Translate3D(0., 0., 0.);
378 transform_sXshapefPOS_12 = transform_sXshapefPOS_12 * G4RotateY3D(-A1);
379 G4IntersectionSolid* XshapefPOS1 = new G4IntersectionSolid("XshapefPOS1", s_XshapefPOS_11, s_XshapefPOS_12,
380 transform_sXshapefPOS_12);
381 //put HER vacuum part in AluCont_fp
382 G4LogicalVolume* l_XshapefPOS1 = new G4LogicalVolume(XshapefPOS1, geometry::Materials::get(vacPipe), "l_XshapefPOS1", 0, 0);
383 //if (flag_limitStep) l_XshapefPOS1 ->SetUserLimits(new G4UserLimits(stepMax));
384 G4RotationMatrix* yRotP = new G4RotationMatrix;
385 yRotP->rotateY(-A1);
386 new G4PVPlacement(yRotP, G4ThreeVector(2 * endcap_hz * tan(A2) + xpipe_hz * sin(A2) + xpipePOS_hz / 2.*sin(A1), 0., 0.),
387 l_XshapefPOS1, "p_XshapefPOS1", logi_AluCont_fp, false, 0);
388 //LER far forward part
389 //slanted tubes TiN
390 G4VSolid* s_XshapefPOS_21 = new G4Tubs("s_XshapefPOS21",
391 tubinR,
392 xpipe_innerRadius,
393 xpipePOS_hz,
394 startAngle, spanningAngle);
395 G4VSolid* s_XshapefPOS_22 = new G4Tubs("s_XshapefPOS22",
396 tubinR,
397 xpipe_innerRadius * 2,
398 xpipePOS_hz / 2. - 0.7568202457 * SafetyLength,
399 startAngle, spanningAngle);
400 G4Transform3D transform_sXshapefPOS_22 = G4Translate3D(0., 0., 0.);
401 transform_sXshapefPOS_22 = transform_sXshapefPOS_22 * G4RotateY3D(A1);
402 G4IntersectionSolid* XshapefPOS2 = new G4IntersectionSolid("XshapefPOS2", s_XshapefPOS_21, s_XshapefPOS_22,
403 transform_sXshapefPOS_22);
404 //put HER TiN part in AluCont_fp
405 G4LogicalVolume* l_XshapefPOS2 = new G4LogicalVolume(XshapefPOS2, geometry::Materials::get(matTiN), "l_XshapefPOS2", 0, 0);
406 G4RotationMatrix* yRotM = new G4RotationMatrix;
407 yRotM->rotateY(A1);
408 new G4PVPlacement(yRotM, G4ThreeVector(-(2 * endcap_hz * tan(A2) + xpipe_hz * sin(A2) + xpipePOS_hz / 2.*sin(A1)), 0., 0.),
409 l_XshapefPOS2, "p_XshapefPOS2", logi_AluCont_fp, false, 0);
410 //slanted tubes Vacuum
411 G4VSolid* s_XshapefPOS_31 = new G4Tubs("s_XshapefPOS31",
412 tubinR,
413 xpipe_innerRadiusTiN,
414 xpipePOS_hz,
415 startAngle, spanningAngle);
416 G4VSolid* s_XshapefPOS_32 = new G4Tubs("s_XshapefPOS32",
417 tubinR,
418 xpipe_innerRadiusTiN * 2,
419 xpipePOS_hz / 2. - 0.7568202457 * SafetyLength,
420 startAngle, spanningAngle);
421 G4Transform3D transform_sXshapefPOS_32 = G4Translate3D(0., 0., 0.);
422 transform_sXshapefPOS_32 = transform_sXshapefPOS_32 * G4RotateY3D(A1);
423 G4IntersectionSolid* XshapefPOS3 = new G4IntersectionSolid("XshapefPOS3", s_XshapefPOS_31, s_XshapefPOS_32,
424 transform_sXshapefPOS_32);
425 //put HER vacuum part into l_XshapefPOS2
426 G4LogicalVolume* l_XshapefPOS3 = new G4LogicalVolume(XshapefPOS3, geometry::Materials::get(vacPipe), "l_XshapefPOS3", 0, 0);
427 //if (flag_limitStep) l_XshapefPOS3 ->SetUserLimits(new G4UserLimits(stepMax));
428 new G4PVPlacement(0, G4ThreeVector(0., 0., 0.), l_XshapefPOS3, "p_XshapefPOS3", l_XshapefPOS2, false, 0);
429
430 // create x-shape tubes backward
431 // Alu trapezoid containing x-shape tube
432 G4VSolid* AluCont_b = new G4Trd("AluCont_b", xcont2, xcont1, xcont1, xcont1, xpipe_hz / 2.0 * cos(A2));
433 G4LogicalVolume* logi_AluCont_b = new G4LogicalVolume(AluCont_b, geometry::Materials::get(matPipe), "logi_AluCont_b", 0, 0);
434 new G4PVPlacement(0, G4ThreeVector(0, 0, -pipe_hz - endcap_hz * 2.0 - xpipe_hz * cos(A2) / 2.), logi_AluCont_b, "phys_AluCont_b",
435 &topVolume, false, 1);
436 //cout << " logi_AluCont_b z = " << -pipe_hz - endcap_hz*2.0 - xpipe_hz*cos(A2)/2. << endl;
437 //cout << " logi_AluCont_b zmax = " << -pipe_hz - endcap_hz*2.0 - xpipe_hz*cos(A2) << endl;
438
439 // create x part
440 G4VSolid* s_Xshapeb_11 = new G4Tubs("s_Xshapeb_11",
441 tubinR,
442 xpipe_innerRadiusTiN,
443 xpipe_hz,
444 startAngle, spanningAngle);
445 G4VSolid* s_Xshapeb_12 = new G4Tubs("s_Xshapeb_12",
446 tubinR,
447 xpipe_innerRadiusTiN * 2.0,
448 xpipe_hz / 2.0,
449 startAngle, spanningAngle);
450 G4VSolid* s_Xshapeb_21 = new G4Tubs("s_Xshapeb_21",
451 tubinR,
452 xpipe_innerRadius,
453 xpipe_hz,
454 startAngle, spanningAngle);
455 G4VSolid* s_Xshapeb_22 = new G4Tubs("s_Xshapeb_22",
456 tubinR,
457 xpipe_innerRadius * 2.0,
458 xpipe_hz / 2.0,
459 startAngle, spanningAngle);
460 //create TiN layer on
461 G4VSolid* s_XshapebTiN_11 = new G4Tubs("s_XshapebTiN_11",
462 tubinR,
463 xpipe_innerRadius,
464 xpipe_hz,
465 startAngle, spanningAngle);
466 G4VSolid* s_XshapebTiN_12 = new G4Tubs("s_XshapebTiN_12",
467 tubinR,
468 xpipe_innerRadius * 2.0,
469 xpipe_hz / 2.0,
470 startAngle, spanningAngle);
471 G4VSolid* s_XshapebTiN_21 = new G4Tubs("s_XshapebTiN_21",
472 tubinR,
473 xpipe_innerRadius,
474 xpipe_hz,
475 startAngle, spanningAngle);
476 G4VSolid* s_XshapebTiN_22 = new G4Tubs("s_XshapebTiN_22",
477 tubinR,
478 xpipe_innerRadius * 2.0,
479 xpipe_hz / 2.0,
480 startAngle, spanningAngle);
481 //Slanted tube1
482 G4Transform3D transform_sXshapeb_12 = G4Translate3D(0., 0., 0.);
483 transform_sXshapeb_12 = transform_sXshapeb_12 * G4RotateY3D(A2);
484 G4IntersectionSolid* Xshapeb1 = new G4IntersectionSolid("Xshapeb1", s_Xshapeb_11, s_Xshapeb_12, transform_sXshapeb_12);
485 //Slanted tube2
486 G4Transform3D transform_sXshapeb_22 = G4Translate3D(0., 0., 0.);
487 transform_sXshapeb_22 = transform_sXshapeb_22 * G4RotateY3D(-A2);
488 G4IntersectionSolid* Xshapeb2 = new G4IntersectionSolid("Xshapeb2", s_Xshapeb_21, s_Xshapeb_22, transform_sXshapeb_22);
489 //Slanted tube1TiN
490 G4Transform3D transform_sXshapebTiN_12 = G4Translate3D(0., 0., 0.);
491 transform_sXshapebTiN_12 = transform_sXshapebTiN_12 * G4RotateY3D(A2);
492 G4IntersectionSolid* XshapebTiN1 = new G4IntersectionSolid("XshapebTiN1", s_XshapebTiN_11, s_XshapebTiN_12,
493 transform_sXshapebTiN_12);
494 //Slanted tube2TiN
495 G4Transform3D transform_sXshapebTiN_22 = G4Translate3D(0., 0., 0.);
496 transform_sXshapebTiN_22 = transform_sXshapebTiN_22 * G4RotateY3D(-A2);
497 G4IntersectionSolid* XshapebTiN2 = new G4IntersectionSolid("XshapebTiN2", s_XshapebTiN_21, s_XshapebTiN_22,
498 transform_sXshapebTiN_22);
499
500 // (sXshapeTiN2 + sXshapeTiN1)
501 G4Transform3D transform_XshapebTiN1 = G4Translate3D(dxtr, 0., dztr);
502 //cout << "dxtr= " << dxtr << " dztr= " << dztr << endl;;
503 transform_XshapebTiN1 = transform_XshapebTiN1 * G4RotateY3D(-2.*A2);
504 G4UnionSolid* XshapeTiNBackwx = new G4UnionSolid("XshapeTiNBackwx", XshapebTiN2, XshapebTiN1, transform_XshapebTiN1);
505 // Place XshapeTiNBackwx into logi_AluCont_b
506 G4Transform3D transform_XshapeTiNBackwx = G4Translate3D(-dxtr / 2., 0., 0.);
507 transform_XshapeTiNBackwx = transform_XshapeTiNBackwx * G4RotateY3D(A2);
508 G4IntersectionSolid* XshapeTiNBackw = new G4IntersectionSolid("XshapeTiNBackw", AluCont_b, XshapeTiNBackwx,
509 transform_XshapeTiNBackwx);
510 G4LogicalVolume* l_XshapeTiNBackw = new G4LogicalVolume(XshapeTiNBackw, geometry::Materials::get(matTiN), "l_XshapeTiNBackw", 0,
511 0);
512 new G4PVPlacement(0, G4ThreeVector(0., 0., 0.), l_XshapeTiNBackw, "p_XshapeTiNBackw", logi_AluCont_b, false, 0);
513
514 // sXshape2 + sXshape1
515 G4Transform3D transform_Xshapeb1 = G4Translate3D(dxtr, 0., dztr);
516 transform_Xshapeb1 = transform_Xshapeb1 * G4RotateY3D(-2.*A2);
517 G4UnionSolid* XshapeBackwx = new G4UnionSolid("XshapebBackwx", Xshapeb2, Xshapeb1, transform_Xshapeb1);
518 G4Transform3D transform_XshapeBackwx = G4Translate3D(-dxtr / 2., 0., 0.);
519 transform_XshapeBackwx = transform_XshapeBackwx * G4RotateY3D(A2);
520 G4IntersectionSolid* XshapeBackw = new G4IntersectionSolid("XshapeBackw", AluCont_b, XshapeBackwx, transform_XshapeBackwx);
521 G4LogicalVolume* l_XshapeBackw = new G4LogicalVolume(XshapeBackw, geometry::Materials::get(vacPipe), "l_XshapeBackw", 0, 0);
522 //if (flag_limitStep) l_XshapeBackw->SetUserLimits(new G4UserLimits(stepMax));
523 // Place XshapeBackw
524 new G4PVPlacement(0, G4ThreeVector(0., 0., 0.), l_XshapeBackw, "p_XshapeBackw", l_XshapeTiNBackw, false, 0);
525
526 //create far backward parts
527 // Alu trapezoid containing far parts
528 G4VSolid* AluCont_bpO = new G4Trd("AluCont_bpO", xcont3M, xcont2, xcont1, xcont1, xpipeMIN_hz / 2.0 * cos(A1));
529 G4VSolid* AluCont_bps = new G4Trd("AluCont_bps", xcont4M, xcont5, xcont1, xcont1, xpipeMIN_hz / 2.0 * cos(A1));
530 G4Transform3D transform_AluCont_bps = G4Translate3D(0., 0., 0.);
531 G4SubtractionSolid* AluCont_bp = new G4SubtractionSolid("AluCont_bp", AluCont_bpO, AluCont_bps, transform_AluCont_bps);
532 G4LogicalVolume* logi_AluCont_bp = new G4LogicalVolume(AluCont_bp, geometry::Materials::get(matPipe), "logi_AluCont_bp", 0, 0);
533 new G4PVPlacement(0, G4ThreeVector(0, 0, -(pipe_hz + endcap_hz * 2.0 + xpipe_hz * cos(A2) + xpipeMIN_hz / 2.0 * cos(A1))),
534 logi_AluCont_bp, "phys_AluCont_bp", &topVolume, false, 0);
535 //HER far backward part
536 //slanted tubes Vacuum
537 G4VSolid* s_XshapebMIN_11 = new G4Tubs("s_XshapebMIN11",
538 tubinR,
539 xpipe_innerRadius,
540 xpipeMIN_hz,
541 startAngle, spanningAngle);
542 G4VSolid* s_XshapebMIN_12 = new G4Tubs("s_XshapebMIN12",
543 tubinR,
544 xpipe_innerRadius * 2,
545 xpipeMIN_hz / 2. - 0.525641366 * SafetyLength,
546 startAngle, spanningAngle);
547 G4Transform3D transform_sXshapebMIN_12 = G4Translate3D(0., 0., 0.);
548 transform_sXshapebMIN_12 = transform_sXshapebMIN_12 * G4RotateY3D(-A1);
549 G4IntersectionSolid* XshapebMIN1 = new G4IntersectionSolid("XshapebMIN1", s_XshapebMIN_11, s_XshapebMIN_12,
550 transform_sXshapebMIN_12);
551 //put HER vacuum part in AluCont_bp
552 G4LogicalVolume* l_XshapebMIN1 = new G4LogicalVolume(XshapebMIN1, geometry::Materials::get(vacPipe), "l_XshapebMIN1", 0, 0);
553 //if (flag_limitStep) l_XshapebMIN1 ->SetUserLimits(new G4UserLimits(stepMax));
554 new G4PVPlacement(yRotP, G4ThreeVector(-(2 * endcap_hz * tan(A2) + xpipe_hz * sin(A2) + xpipeMIN_hz / 2.*sin(A1)), 0., 0.),
555 l_XshapebMIN1, "p_XshapebMIN1", logi_AluCont_bp, false, 0);
556 //LER far backward part
557 //slanted tubes TiN
558 G4VSolid* s_XshapebMIN_21 = new G4Tubs("s_XshapebMIN21",
559 tubinR,
560 xpipe_innerRadius,
561 xpipeMIN_hz,
562 startAngle, spanningAngle);
563 G4VSolid* s_XshapebMIN_22 = new G4Tubs("s_XshapebMIN22",
564 tubinR,
565 xpipe_innerRadius * 2,
566 xpipeMIN_hz / 2. - 0.525641366 * SafetyLength,
567 startAngle, spanningAngle);
568 G4Transform3D transform_sXshapebMIN_22 = G4Translate3D(0., 0., 0.);
569 transform_sXshapebMIN_22 = transform_sXshapebMIN_22 * G4RotateY3D(A1);
570 G4IntersectionSolid* XshapebMIN2 = new G4IntersectionSolid("XshapebMIN2", s_XshapebMIN_21, s_XshapebMIN_22,
571 transform_sXshapebMIN_22);
572 //put HER TiN part in AluCont_bp
573 G4LogicalVolume* l_XshapebMIN2 = new G4LogicalVolume(XshapebMIN2, geometry::Materials::get(matTiN), "l_XshapebMIN2", 0, 0);
574 new G4PVPlacement(yRotM, G4ThreeVector(2 * endcap_hz * tan(A2) + xpipe_hz * sin(A2) + xpipeMIN_hz / 2.*sin(A1), 0., 0.),
575 l_XshapebMIN2, "p_XshapebMIN2", logi_AluCont_bp, false, 0);
576 //slanted tubes Vacuum
577 G4VSolid* s_XshapebMIN_31 = new G4Tubs("s_XshapebMIN31",
578 tubinR,
579 xpipe_innerRadiusTiN,
580 xpipeMIN_hz,
581 startAngle, spanningAngle);
582 G4VSolid* s_XshapebMIN_32 = new G4Tubs("s_XshapebMIN32",
583 tubinR,
584 xpipe_innerRadiusTiN * 2,
585 xpipeMIN_hz / 2. - 0.525641366 * SafetyLength,
586 startAngle, spanningAngle);
587 G4Transform3D transform_sXshapebMIN_32 = G4Translate3D(0., 0., 0.);
588 transform_sXshapebMIN_32 = transform_sXshapebMIN_32 * G4RotateY3D(A1);
589 G4IntersectionSolid* XshapebMIN3 = new G4IntersectionSolid("XshapebMIN3", s_XshapebMIN_31, s_XshapebMIN_32,
590 transform_sXshapebMIN_32);
591 //put HER vacuum part in AluCont_bp
592 G4LogicalVolume* l_XshapebMIN3 = new G4LogicalVolume(XshapebMIN3, geometry::Materials::get(vacPipe), "l_XshapebMIN3", 0, 0);
593 //if (flag_limitStep) l_XshapebMIN3 ->SetUserLimits(new G4UserLimits(stepMax));
594 new G4PVPlacement(0, G4ThreeVector(0., 0., 0.), l_XshapebMIN3, "p_XshapebMIN3", l_XshapebMIN2, false, 0);
595
596 }
597 } // ph1bpipe namespace
599} // Belle2 namespace
Belle2::GearDir
GearDir is the basic class used for accessing the parameter store.
Definition: GearDir.h:31
Belle2::geometry::Materials::get
static G4Material * get(const std::string &name)
Find given material.
Definition: Materials.h:63
Belle2::ph1bpipe::SensitiveDetector
Sensitive Detector implementation of the PH1BPIPE detector.
Definition: SensitiveDetector.h:22
Belle2::sqrt
double sqrt(double a)
sqrt for double
Definition: beamHelpers.h:28
Belle2::geometry::GeometryTypes
GeometryTypes
Flag indiciating the type of geometry to be used.
Definition: GeometryManager.h:36
Belle2::ph1bpipe::Ph1bpipeFactory
geometry::CreatorFactory< Ph1bpipeCreator > Ph1bpipeFactory("PH1BPIPECreator")
Creator creates the phase 1 beam pipe for |s| < 4 m 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