Belle II Software development
Public Member Functions | Protected Attributes | List of all members
Ph1bpipeCreator Class Reference

The creator for the PH1BPIPE geometry. More...

#include <Ph1bpipeCreator.h>

Inheritance diagram for Ph1bpipeCreator:
CreatorBase

Public Member Functions

virtual void create (const GearDir &content, G4LogicalVolume &topVolume, geometry::GeometryTypes type)
 Create the PH1BPIPE geometry.
 
 BELLE2_DEFINE_EXCEPTION (DBNotImplemented, "Cannot create geometry from Database.")
 Exception that will be thrown in createFromDB if member is not yet implemented by creator.
 
virtual void createFromDB (const std::string &name, G4LogicalVolume &topVolume, GeometryTypes type)
 Function to create the geometry from the Database.
 
virtual void createPayloads (const GearDir &content, const IntervalOfValidity &iov)
 Function to create the geometry database.
 

Protected Attributes

SensitiveDetector * m_sensitive
 SensitiveDetector phase 1 beam pipe.
 

Detailed Description

The creator for the PH1BPIPE geometry.

Definition at line 27 of file Ph1bpipeCreator.h.

Constructor & Destructor Documentation

◆ Ph1bpipeCreator()

Ph1bpipeCreator ( )

Definition at line 51 of file Ph1bpipeCreator.cc.

51 : m_sensitive(0)
52 {
53 //m_sensitive = new SensitiveDetector();
54 }
Belle2::ph1bpipe::Ph1bpipeCreator::m_sensitive
SensitiveDetector * m_sensitive
SensitiveDetector phase 1 beam pipe.
Definition: Ph1bpipeCreator.h:38

◆ ~Ph1bpipeCreator()

~Ph1bpipeCreator ( )
virtual

Definition at line 56 of file Ph1bpipeCreator.cc.

57 {
58 if (m_sensitive) delete m_sensitive;
59 }

Member Function Documentation

◆ create()

void create ( const GearDir &  content,
G4LogicalVolume &  topVolume,
geometry::GeometryTypes  type 
)
virtual

Create the PH1BPIPE geometry.

Implements CreatorBase.

Definition at line 61 of file Ph1bpipeCreator.cc.

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 }
Belle2::geometry::Materials::get
static G4Material * get(const std::string &name)
Find given material.
Definition: Materials.h:63
Belle2::sqrt
double sqrt(double a)
sqrt for double
Definition: beamHelpers.h:28
Belle2::PXD::SensitiveDetector
VXD::SensitiveDetector< PXDSimHit, PXDTrueHit > SensitiveDetector
The PXD Sensitive Detector class.
Definition: SensitiveDetector.h:23

◆ createFromDB()

void createFromDB ( const std::string &  name,
G4LogicalVolume &  topVolume,
GeometryTypes  type 
)
virtualinherited

Function to create the geometry from the Database.

Parameters
namename of the component in the database, could be used to disambiguate multiple components created with the same creator
topVolumeTop volume in which the geometry has to be placed
typeType of geometry to be build

Reimplemented in GeoMagneticField, GeoARICHCreator, BeamabortCreator, GeoCDCCreator, GeoCDCCreatorReducedCDC, GeoECLCreator, MyDBCreator, GeoBeamPipeCreator, GeoCryostatCreator, GeoFarBeamLineCreator, GeoBKLMCreator, GeoEKLMCreator, GeoKLMCreator, GeoPXDCreator, GeoCOILCreator, GeoServiceMaterialCreator, GeoSTRCreator, GeoSVDCreator, GeoTOPCreator, GeoHeavyMetalShieldCreator, and GeoVXDServiceCreator.

Definition at line 17 of file CreatorBase.cc.

18 {
19 //Do nothing but raise exception that we don't do anything
20 throw DBNotImplemented();
21 }

◆ createPayloads()

void createPayloads ( const GearDir &  content,
const IntervalOfValidity &  iov 
)
virtualinherited

Function to create the geometry database.

This function should be implemented to convert Gearbox parameters to one ore more database payloads

Parameters
contentGearDir pointing to the parameters which should be used for construction
iovinterval of validity to use when generating payloads

Reimplemented in GeoARICHCreator, BeamabortCreator, GeoCDCCreator, GeoCDCCreatorReducedCDC, GeoECLCreator, GeoMagneticField, MyDBCreator, GeoBeamPipeCreator, GeoCryostatCreator, GeoFarBeamLineCreator, GeoBKLMCreator, GeoEKLMCreator, GeoKLMCreator, GeoPXDCreator, GeoCOILCreator, GeoServiceMaterialCreator, GeoSTRCreator, GeoSVDCreator, GeoTOPCreator, GeoHeavyMetalShieldCreator, and GeoVXDServiceCreator.

Definition at line 24 of file CreatorBase.cc.

24{}

Member Data Documentation

◆ m_sensitive

SensitiveDetector* m_sensitive
protected

SensitiveDetector phase 1 beam pipe.

Definition at line 38 of file Ph1bpipeCreator.h.

The documentation for this class was generated from the following files: