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

The creator for the BeamPipe geometry of the Belle II detector. More...

#include <GeoBeamPipeCreator.h>

Inheritance diagram for GeoBeamPipeCreator:
CreatorBase

Public Member Functions

 GeoBeamPipeCreator ()
 Constructor of the GeoBeamPipeCreator class.
 
virtual ~GeoBeamPipeCreator () override
 The destructor of the GeoBeamPipeCreator class.
 
virtual void create (const GearDir &content, G4LogicalVolume &topVolume, geometry::GeometryTypes type) override
 Creates the ROOT Objects for the BeamPipe geometry.
 
virtual void createPayloads (const GearDir &content, const IntervalOfValidity &iov) override
 creates DB payload for BeamPipeGeo class
 
virtual void createFromDB (const std::string &name, G4LogicalVolume &topVolume, geometry::GeometryTypes type) override
 Create the geometry from the Database.
 
 BELLE2_DEFINE_EXCEPTION (DBNotImplemented, "Cannot create geometry from Database.")
 Exception that will be thrown in createFromDB if member is not yet implemented by creator.
 

Protected Attributes

std::vector< SensitiveDetector * > m_sensitive
 Sensitive detector.
 
BeamPipeGeo m_config
 geometry parameters object
 

Private Member Functions

BeamPipeGeo createConfiguration (const GearDir &param)
 Reads IR geometry parameters from the xml files and createst DB class BeamPipeGeo.
 
void createGeometry (G4LogicalVolume &topVolume, geometry::GeometryTypes type)
 Create detector geometry.
 

Detailed Description

The creator for the BeamPipe geometry of the Belle II detector.

Definition at line 32 of file GeoBeamPipeCreator.h.

Constructor & Destructor Documentation

◆ GeoBeamPipeCreator()

GeoBeamPipeCreator ( )

Constructor of the GeoBeamPipeCreator class.

Definition at line 56 of file GeoBeamPipeCreator.cc.

57 {
58 }

◆ ~GeoBeamPipeCreator()

~GeoBeamPipeCreator ( )
overridevirtual

The destructor of the GeoBeamPipeCreator class.

Definition at line 60 of file GeoBeamPipeCreator.cc.

61 {
62 //Delete all sensitive detectors
63 for (SensitiveDetector* sensitive : m_sensitive) {
64 delete sensitive;
65 }
66 m_sensitive.clear();
67 }

Member Function Documentation

◆ create()

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

Creates the ROOT Objects for the BeamPipe geometry.

Parameters
contentA reference to the content part of the parameter description, which should to be used to create the ROOT objects.
topVolumeGeant4 logical top volume.
typeGeometry type.

Implements CreatorBase.

Definition at line 67 of file GeoBeamPipeCreator.h.

68 {
69 m_config = createConfiguration(content);
70
71 // override geometry configuration from the DB
72 DBStore::Instance().addConstantOverride("BeamPipeGeo", new BeamPipeGeo(m_config));
73
74 createGeometry(topVolume, type);
75 }

◆ createConfiguration()

BeamPipeGeo createConfiguration ( const GearDir & param)
inlineprivate

Reads IR geometry parameters from the xml files and createst DB class BeamPipeGeo.

Definition at line 36 of file GeoBeamPipeCreator.h.

37 {
38 BeamPipeGeo BeamPipeGeoConfig;
39 BeamPipeGeoConfig.initialize(param);
40 return BeamPipeGeoConfig;
41 }

◆ createFromDB()

virtual void createFromDB ( const std::string & name,
G4LogicalVolume & topVolume,
geometry::GeometryTypes type )
inlineoverridevirtual

Create the geometry from the Database.

Reimplemented from CreatorBase.

Definition at line 86 of file GeoBeamPipeCreator.h.

87 {
88 DBObjPtr<BeamPipeGeo> dbObj;
89 if (!dbObj) {
90 // Check that we found the object and if not report the problem
91 B2FATAL("No configuration for " << name << " found.");
92 }
93 m_config = *dbObj;
94 createGeometry(topVolume, type);
95 }

◆ createGeometry()

void createGeometry ( G4LogicalVolume & topVolume,
geometry::GeometryTypes type )
private

Create detector geometry.

Parameters
topVolumeGeant4 logical top volume.
typeGeometry type.

Definition at line 69 of file GeoBeamPipeCreator.cc.

70 {
71
72 //########## Index ########## (outdated)
73 //
74 // "IP pipe" -9.0 cm to 13.85 cm
75 // Lv1SUS
76 // Lv2OutBe
77 // Lv2InBe
78 // Lv2Paraf
79 // Lv2Vacuum
80 // Lv3AuCoat
81 // "crotch pipe Forward " 13.85 cm to 40.0 cm
82 // Lv1TaFwd
83 // Lv2VacFwd
84 // "crotch pipe Backward " -9.0 cm to -40.0 cm
85 // Lv1TaBwd
86 // Lv2VacBwd
87 // "beam pipe more Forward " 40.0 cm to 63.35 cm
88 // Lv1TaLERUp
89 // Lv2VacLERUp
90 // Lv1TaHERDwn
91 // Lv2VacHERDwn
92 // "beam pipe more Backward " -40.0 cm to -62.725 cm
93 // Lv1TaHERUp
94 // Lv2VacHERUp
95 // Lv1TaLERDwn
96 // Lv2VacLERDwn
97 // Tangusten End Mounts
98 // PXDMountFwd
99 // PXDMountFixtureFwd
100 // PXDMountBwd
101 // PXDMountFixtureBwd
102 //
103 //###########################
104
105 // basf2 uses cm, Geant4 uses mm
106 const double unitFactor = Unit::cm / Unit::mm;
107
108 double SafetyLength = m_config.getParameter("Safety.L1") * unitFactor;
109
110 double stepMax = 5.0 * Unit::mm * unitFactor;
111 int flag_limitStep = int(m_config.getParameter("LimitStepLength"));
112
113 double A11 = 0.03918;
114
115 //---------------------------
116 // for dose simulation
117 //---------------------------
118 int Index_sensi = 11;
119
120 // Check xml file to see geometry of which run period we use
121 // Lv2OutTi added for Phase 3
122 // Lv2AuCoat added during LS1
123 // Default is Run2 (phase 3 after LS1, not phase2 and not Run 1 (early phase 3 before LS1))
124 bool phase2 = false;
125 bool Run1 = false; // aka early phase 3
126 if (m_config.getParameter("Lv2OutTi.R1", -1.0) < 0.0) {
127 phase2 = true;
128 } else if (m_config.getParameter("Lv2AuCoat.R1", -1.0) < 0.0) {
129 Run1 = true;
130 }
131
132
133
134 // debug
135 //cout << endl << "!!! Creating a Beampipe copy..." << endl << endl;
136
139
142
143 // Get parameters from .xml file
144 string prep = "AreaTubeFwd.";
145
146 const int AreaTubeFwd_num = 2;
147
148 double AreaTubeFwd_Z[AreaTubeFwd_num];
149 AreaTubeFwd_Z[0] = m_config.getParameter(prep + "D1") * unitFactor;
150 AreaTubeFwd_Z[1] = m_config.getParameter(prep + "D2") * unitFactor;
151
152 double AreaTubeFwd_rI[AreaTubeFwd_num];
153 for (int i = 0; i < AreaTubeFwd_num; ++i) {
154 AreaTubeFwd_rI[i] = 0.0;
155 }
156
157 double AreaTubeFwd_rO[AreaTubeFwd_num];
158 AreaTubeFwd_rO[0] = m_config.getParameter(prep + "R1") * unitFactor;
159 AreaTubeFwd_rO[1] = AreaTubeFwd_rO[0];
160
161 // Define geometry
162 G4Polycone* geo_AreaTubeFwdpcon = new G4Polycone("geo_AreaTubeFwdpcon_name", 0, 2 * M_PI, AreaTubeFwd_num, AreaTubeFwd_Z,
163 AreaTubeFwd_rI, AreaTubeFwd_rO);
164
167
168 // Get parameters from .xml file
169 prep = "AreaTubeBwd.";
170
171 const int AreaTubeBwd_num = 2;
172
173 double AreaTubeBwd_Z[AreaTubeBwd_num];
174 AreaTubeBwd_Z[0] = m_config.getParameter(prep + "D1") * unitFactor;
175 AreaTubeBwd_Z[1] = m_config.getParameter(prep + "D2") * unitFactor;
176
177 double AreaTubeBwd_rI[AreaTubeBwd_num];
178 for (int i = 0; i < AreaTubeBwd_num; ++i) {
179 AreaTubeBwd_rI[i] = 0.0;
180 }
181
182 double AreaTubeBwd_rO[AreaTubeBwd_num];
183 AreaTubeBwd_rO[0] = m_config.getParameter(prep + "R1") * unitFactor;
184 AreaTubeBwd_rO[1] = AreaTubeBwd_rO[0];
185
186 // Define geometry
187 G4Polycone* geo_AreaTubeBwdpcon = new G4Polycone("geo_AreaTubeBwdpcon_name", 0, 2 * M_PI, AreaTubeBwd_num, AreaTubeBwd_Z,
188 AreaTubeBwd_rI, AreaTubeBwd_rO);
189
190 //----------
191 //- Lv1TaLERUp
192
193 // Get parameters from .xml file
194 prep = "Lv1TaLERUp.";
195
196 double Lv1TaLERUp_A1 = m_config.getParameter(prep + "A1");
197
198 int Lv1TaLERUp_num = int(m_config.getParameter(prep + "N"));
199 vector<double> Lv1TaLERUp_Z(Lv1TaLERUp_num);
200 vector<double> Lv1TaLERUp_rI(Lv1TaLERUp_num);
201 vector<double> Lv1TaLERUp_rO(Lv1TaLERUp_num);
202 for (int i = 0; i < Lv1TaLERUp_num; ++i) {
203 ostringstream ossZ_Lv1TaLERUp;
204 ossZ_Lv1TaLERUp << "L" << i;
205
206 ostringstream ossR_Lv1TaLERUp;
207 ossR_Lv1TaLERUp << "R" << i;
208
209 Lv1TaLERUp_Z[i] = m_config.getParameter(prep + ossZ_Lv1TaLERUp.str()) * unitFactor;
210 Lv1TaLERUp_rO[i] = m_config.getParameter(prep + ossR_Lv1TaLERUp.str()) * unitFactor;
211 }
212 for (int i = 0; i < Lv1TaLERUp_num; ++i) {
213 Lv1TaLERUp_rI[i] = 0.0;
214 }
215
216 string strMat_Lv1TaLERUp = m_config.getParameterStr(prep + "Material");
217 G4Material* mat_Lv1TaLERUp = Materials::get(strMat_Lv1TaLERUp);
218
219 // Define geometry
220 G4Polycone* geo_Lv1TaLERUppcon = new G4Polycone("geo_Lv1TaLERUppcon_name", 0, 2 * M_PI, Lv1TaLERUp_num, &(Lv1TaLERUp_Z[0]),
221 &(Lv1TaLERUp_rI[0]),
222 &(Lv1TaLERUp_rO[0]));
223 G4Transform3D transform_AreaTubeFwdForLER = G4Translate3D(0., 0., 0.);
224 transform_AreaTubeFwdForLER = transform_AreaTubeFwdForLER * G4RotateY3D(-Lv1TaLERUp_A1);
225 G4IntersectionSolid* geo_Lv1TaLERUp = new G4IntersectionSolid("geo_Lv1TaLERUp_name", geo_Lv1TaLERUppcon, geo_AreaTubeFwdpcon,
226 transform_AreaTubeFwdForLER);
227 G4LogicalVolume* logi_Lv1TaLERUp = new G4LogicalVolume(geo_Lv1TaLERUp, mat_Lv1TaLERUp, "logi_Lv1TaLERUp_name");
228
229 // Put volume
230 setColor(*logi_Lv1TaLERUp, "#0000CC");
231 G4Transform3D transform_Lv1TaLERUp = G4Translate3D(0., 0., 0.);
232 transform_Lv1TaLERUp = transform_Lv1TaLERUp * G4RotateY3D(Lv1TaLERUp_A1);
233 new G4PVPlacement(transform_Lv1TaLERUp, logi_Lv1TaLERUp, "phys_Lv1TaLERUp_name", &topVolume, false, 0);
234
235
236 //----------
237 //- Lv1TaHERUp
238
239 // Get parameters from .xml file
240 prep = "Lv1TaHERUp.";
241
242 double Lv1TaHERUp_A1 = m_config.getParameter(prep + "A1");
243
244 int Lv1TaHERUp_num = int(m_config.getParameter(prep + "N"));
245 vector<double> Lv1TaHERUp_Z(Lv1TaHERUp_num);
246 vector<double> Lv1TaHERUp_rI(Lv1TaHERUp_num);
247 vector<double> Lv1TaHERUp_rO(Lv1TaHERUp_num);
248 for (int i = 0; i < Lv1TaHERUp_num; ++i) {
249 ostringstream ossZ_Lv1TaHERUp;
250 ossZ_Lv1TaHERUp << "L" << i;
251
252 ostringstream ossR_Lv1TaHERUp;
253 ossR_Lv1TaHERUp << "R" << i;
254
255 Lv1TaHERUp_Z[i] = m_config.getParameter(prep + ossZ_Lv1TaHERUp.str()) * unitFactor;
256 Lv1TaHERUp_rO[i] = m_config.getParameter(prep + ossR_Lv1TaHERUp.str()) * unitFactor;
257 }
258 for (int i = 0; i < Lv1TaHERUp_num; ++i) {
259 Lv1TaHERUp_rI[i] = 0.0;
260 }
261
262 string strMat_Lv1TaHERUp = m_config.getParameterStr(prep + "Material");
263 G4Material* mat_Lv1TaHERUp = Materials::get(strMat_Lv1TaHERUp);
264
265 // Define geometry
266 G4Polycone* geo_Lv1TaHERUppcon = new G4Polycone("geo_Lv1TaHERUppcon_name", 0, 2 * M_PI, Lv1TaHERUp_num, &(Lv1TaHERUp_Z[0]),
267 &(Lv1TaHERUp_rI[0]),
268 &(Lv1TaHERUp_rO[0]));
269 G4Transform3D transform_AreaTubeBwdForHER = G4Translate3D(0., 0., 0.);
270 transform_AreaTubeBwdForHER = transform_AreaTubeBwdForHER * G4RotateY3D(-Lv1TaHERUp_A1);
271 G4IntersectionSolid* geo_Lv1TaHERUp = new G4IntersectionSolid("", geo_Lv1TaHERUppcon, geo_AreaTubeBwdpcon,
272 transform_AreaTubeBwdForHER);
273 G4LogicalVolume* logi_Lv1TaHERUp = new G4LogicalVolume(geo_Lv1TaHERUp, mat_Lv1TaHERUp, "logi_Lv1TaHERUp_name");
274
275 // Put volume
276 setColor(*logi_Lv1TaHERUp, "#00CC00");
277 G4Transform3D transform_Lv1TaHERUp = G4Translate3D(0., 0., 0.);
278 transform_Lv1TaHERUp = transform_Lv1TaHERUp * G4RotateY3D(Lv1TaHERUp_A1);
279 new G4PVPlacement(transform_Lv1TaHERUp, logi_Lv1TaHERUp, "phys_Lv1TaHERUp_name", &topVolume, false, 0);
280
281
282 //----------
283 //- Lv1TaLERDwn
284
285 // Get parameters from .xml file
286 prep = "Lv1TaLERDwn.";
287
288 double Lv1TaLERDwn_A1 = m_config.getParameter(prep + "A1");
289
290 int Lv1TaLERDwn_num = int(m_config.getParameter(prep + "N"));
291 vector<double> Lv1TaLERDwn_Z(Lv1TaLERDwn_num);
292 vector<double> Lv1TaLERDwn_rI(Lv1TaLERDwn_num);
293 vector<double> Lv1TaLERDwn_rO(Lv1TaLERDwn_num);
294 for (int i = 0; i < Lv1TaLERDwn_num; ++i) {
295 ostringstream ossZ_Lv1TaLERDwn;
296 ossZ_Lv1TaLERDwn << "L" << i;
297
298 ostringstream ossR_Lv1TaLERDwn;
299 ossR_Lv1TaLERDwn << "R" << i;
300
301 Lv1TaLERDwn_Z[i] = m_config.getParameter(prep + ossZ_Lv1TaLERDwn.str()) * unitFactor;
302 Lv1TaLERDwn_rO[i] = m_config.getParameter(prep + ossR_Lv1TaLERDwn.str()) * unitFactor;
303 }
304 for (int i = 0; i < Lv1TaLERDwn_num; ++i) {
305 Lv1TaLERDwn_rI[i] = 0.0;
306 }
307
308 string strMat_Lv1TaLERDwn = m_config.getParameterStr(prep + "Material");
309 G4Material* mat_Lv1TaLERDwn = Materials::get(strMat_Lv1TaLERDwn);
310
311 // Define geometry
312 G4Polycone* geo_Lv1TaLERDwnpcon = new G4Polycone("geo_Lv1TaLERDwnpcon_name", 0, 2 * M_PI, Lv1TaLERDwn_num, &(Lv1TaLERDwn_Z[0]),
313 &(Lv1TaLERDwn_rI[0]), &(Lv1TaLERDwn_rO[0]));
314 G4Transform3D transform_AreaTubeBwdForLER = G4Translate3D(0., 0., 0.);
315 transform_AreaTubeBwdForLER = transform_AreaTubeBwdForLER * G4RotateY3D(-Lv1TaLERDwn_A1);
316 G4IntersectionSolid* geo_Lv1TaLERDwn = new G4IntersectionSolid("", geo_Lv1TaLERDwnpcon, geo_AreaTubeBwdpcon,
317 transform_AreaTubeBwdForLER);
318 G4LogicalVolume* logi_Lv1TaLERDwn = new G4LogicalVolume(geo_Lv1TaLERDwn, mat_Lv1TaLERDwn, "logi_Lv1TaLERDwn_name");
319
320 // Put volume
321 setColor(*logi_Lv1TaLERDwn, "#0000CC");
322 G4Transform3D transform_Lv1TaLERDwn = G4Translate3D(0., 0., 0.);
323 transform_Lv1TaLERDwn = transform_Lv1TaLERDwn * G4RotateY3D(Lv1TaLERDwn_A1);
324 new G4PVPlacement(transform_Lv1TaLERDwn, logi_Lv1TaLERDwn, "phys_Lv1TaLERDwn_name", &topVolume, false, 0);
325
326
327 //----------
328 //- Lv1TaHERDwn
329
330 // Get parameters from .xml file
331 prep = "Lv1TaHERDwn.";
332
333 double Lv1TaHERDwn_A1 = m_config.getParameter(prep + "A1");
334
335 int Lv1TaHERDwn_num = int(m_config.getParameter(prep + "N"));
336 vector<double> Lv1TaHERDwn_Z(Lv1TaHERDwn_num);
337 vector<double> Lv1TaHERDwn_rI(Lv1TaHERDwn_num);
338 vector<double> Lv1TaHERDwn_rO(Lv1TaHERDwn_num);
339 for (int i = 0; i < Lv1TaHERDwn_num; ++i) {
340 ostringstream ossZ_Lv1TaHERDwn;
341 ossZ_Lv1TaHERDwn << "L" << i;
342
343 ostringstream ossR_Lv1TaHERDwn;
344 ossR_Lv1TaHERDwn << "R" << i;
345
346 Lv1TaHERDwn_Z[i] = m_config.getParameter(prep + ossZ_Lv1TaHERDwn.str()) * unitFactor;
347 Lv1TaHERDwn_rO[i] = m_config.getParameter(prep + ossR_Lv1TaHERDwn.str()) * unitFactor;
348 }
349 for (int i = 0; i < Lv1TaHERDwn_num; ++i) {
350 Lv1TaHERDwn_rI[i] = 0.0;
351 }
352
353 string strMat_Lv1TaHERDwn = m_config.getParameterStr(prep + "Material");
354 G4Material* mat_Lv1TaHERDwn = Materials::get(strMat_Lv1TaHERDwn);
355
356 // Define geometry
357 G4Polycone* geo_Lv1TaHERDwnpcon = new G4Polycone("geo_Lv1TaHERDwnpcon_name", 0, 2 * M_PI, Lv1TaHERDwn_num, &(Lv1TaHERDwn_Z[0]),
358 &(Lv1TaHERDwn_rI[0]), &(Lv1TaHERDwn_rO[0]));
359 G4Transform3D transform_AreaTubeFwdForHER = G4Translate3D(0., 0., 0.);
360 transform_AreaTubeFwdForHER = transform_AreaTubeFwdForHER * G4RotateY3D(-Lv1TaHERDwn_A1);
361 G4IntersectionSolid* geo_Lv1TaHERDwn = new G4IntersectionSolid("", geo_Lv1TaHERDwnpcon, geo_AreaTubeFwdpcon,
362 transform_AreaTubeFwdForHER);
363 G4LogicalVolume* logi_Lv1TaHERDwn = new G4LogicalVolume(geo_Lv1TaHERDwn, mat_Lv1TaHERDwn, "logi_Lv1TaHERDwn_name");
364
365 // Put volume
366 setColor(*logi_Lv1TaHERDwn, "#00CC00");
367 G4Transform3D transform_Lv1TaHERDwn = G4Translate3D(0., 0., 0.);
368 transform_Lv1TaHERDwn = transform_Lv1TaHERDwn * G4RotateY3D(Lv1TaHERDwn_A1);
369 new G4PVPlacement(transform_Lv1TaHERDwn, logi_Lv1TaHERDwn, "phys_Lv1TaHERDwn_name", &topVolume, false, 0);
370
371
372 //----------
373 //- Lv1SUS
374
375 // Get parameters from .xml file
376 prep = "Lv1SUS.";
377
378 int Lv1SUS_num = int(m_config.getParameter(prep + "N"));
379 vector<double> Lv1SUS_Z(Lv1SUS_num);
380 vector<double> Lv1SUS_rI(Lv1SUS_num);
381 vector<double> Lv1SUS_rO(Lv1SUS_num);
382
383 for (int i = 0; i < Lv1SUS_num; ++i) {
384 ostringstream ossZID;
385 ossZID << "Z" << i;
386
387 ostringstream ossrOID;
388 ossrOID << "R" << i;
389
390 ostringstream ossrIID;
391 ossrIID << "r" << i;
392
393 Lv1SUS_Z[i] = m_config.getParameter(prep + ossZID.str()) * unitFactor;
394 Lv1SUS_rO[i] = m_config.getParameter(prep + ossrOID.str()) * unitFactor;
395 Lv1SUS_rI[i] = m_config.getParameter(prep + ossrIID.str(), 0.0) * unitFactor;
396 }
397
398 // Material
399 string strMat_Lv1SUS = m_config.getParameterStr(prep + "Material");
400 G4Material* mat_Lv1SUS = Materials::get(strMat_Lv1SUS);
401
402 // Define geometry
403 G4Polycone* geo_Lv1SUS = new G4Polycone("geo_Lv1SUS_name", 0, 2 * M_PI, Lv1SUS_num, &(Lv1SUS_Z[0]), &(Lv1SUS_rI[0]),
404 &(Lv1SUS_rO[0]));
405 G4LogicalVolume* logi_Lv1SUS = new G4LogicalVolume(geo_Lv1SUS, mat_Lv1SUS, "logi_Lv1SUS_name");
406
407 // Put volume
408 setColor(*logi_Lv1SUS, "#666666");
409 new G4PVPlacement(0, G4ThreeVector(0, 0, 0), logi_Lv1SUS, "phys_Lv1SUS_name", &topVolume, false, 0);
410
411
412 //----------
413 //- Lv2OutBe
414 //-
415 //----------
416
417 // Get parameters from .xml file
418 prep = "Lv2OutBe.";
419
420 const int Lv2OutBe_num = 2;
421
422 double Lv2OutBe_Z[Lv2OutBe_num];
423 Lv2OutBe_Z[0] = m_config.getParameter(prep + "L1") * unitFactor;
424 Lv2OutBe_Z[1] = m_config.getParameter(prep + "L2") * unitFactor;
425
426 double Lv2OutBe_rI[Lv2OutBe_num];
427 Lv2OutBe_rI[0] = m_config.getParameter(prep + "R1") * unitFactor;
428 Lv2OutBe_rI[1] = Lv2OutBe_rI[0];
429
430 double Lv2OutBe_rO[Lv2OutBe_num];
431 Lv2OutBe_rO[0] = m_config.getParameter(prep + "R2") * unitFactor;
432 Lv2OutBe_rO[1] = Lv2OutBe_rO[0];
433
434 string strMat_Lv2OutBe = m_config.getParameterStr(prep + "Material");
435 G4Material* mat_Lv2OutBe = Materials::get(strMat_Lv2OutBe);
436
437 // Define geometry
438 G4Polycone* geo_Lv2OutBe = new G4Polycone("geo_Lv2OutBe_name", 0, 2 * M_PI, Lv2OutBe_num, Lv2OutBe_Z, Lv2OutBe_rI, Lv2OutBe_rO);
439 G4LogicalVolume* logi_Lv2OutBe = new G4LogicalVolume(geo_Lv2OutBe, mat_Lv2OutBe, "logi_Lv2OutBe_name");
440
441 // Put volume
442 setColor(*logi_Lv2OutBe, "#333300");
443 new G4PVPlacement(0, G4ThreeVector(0, 0, 0), logi_Lv2OutBe, "phys_Lv2OutBe_name", logi_Lv1SUS, false, 0);
444
445
446 //----------
447 //- Lv2InBe
448 //-
449 //----------
450
451 // Get parameters from .xml file
452 prep = "Lv2InBe.";
453
454 const int Lv2InBe_num = 2;
455
456 double Lv2InBe_Z[Lv2InBe_num];
457 Lv2InBe_Z[0] = m_config.getParameter(prep + "L1") * unitFactor;
458 Lv2InBe_Z[1] = m_config.getParameter(prep + "L2") * unitFactor;
459
460 double Lv2InBe_rI[Lv2InBe_num];
461 Lv2InBe_rI[0] = m_config.getParameter(prep + "R1") * unitFactor;
462 Lv2InBe_rI[1] = Lv2InBe_rI[0];
463
464 double Lv2InBe_rO[Lv2InBe_num];
465 Lv2InBe_rO[0] = m_config.getParameter(prep + "R2") * unitFactor;
466 Lv2InBe_rO[1] = Lv2InBe_rO[0];
467
468 string strMat_Lv2InBe = m_config.getParameterStr(prep + "Material");
469 G4Material* mat_Lv2InBe = Materials::get(strMat_Lv2InBe);
470
471 // Define geometry
472 G4Polycone* geo_Lv2InBe = new G4Polycone("geo_Lv2InBe_name", 0, 2 * M_PI, Lv2InBe_num, Lv2InBe_Z, Lv2InBe_rI, Lv2InBe_rO);
473 G4LogicalVolume* logi_Lv2InBe = new G4LogicalVolume(geo_Lv2InBe, mat_Lv2InBe, "logi_Lv2InBe_name");
474
475 // Put volume
476 setColor(*logi_Lv2InBe, "#333300");
477 new G4PVPlacement(0, G4ThreeVector(0, 0, 0), logi_Lv2InBe, "phys_Lv2InBe_name", logi_Lv1SUS, false, 0);
478
479 //----------
480 //- Lv2Vacuum
481 prep = "Lv2Vacuum.";
482 G4UnionSolid* geo_Lv2Vacuumx = NULL;
483 if (phase2 || Run1) {
484 // Get parameters from .xml file
485 double Lv2Vacuum_L1 = m_config.getParameter(prep + "L1") * unitFactor;
486 double Lv2Vacuum_L2 = m_config.getParameter(prep + "L2") * unitFactor;
487 double Lv2Vacuum_L3 = m_config.getParameter(prep + "L3") * unitFactor;
488 double Lv2Vacuum_L4 = m_config.getParameter(prep + "L4") * unitFactor;
489 double Lv2Vacuum_R1 = m_config.getParameter(prep + "R1") * unitFactor;
490 double Lv2Vacuum_R2 = m_config.getParameter(prep + "R2") * unitFactor;
491 double Lv2Vacuum_R3 = m_config.getParameter(prep + "R3") * unitFactor;
492 //double Lv2Vacuum_A1 = cLv2Vacuum.getAngle("A1");
493 double Lv2Vacuum_A2 = m_config.getParameter(prep + "A2");
494
495 // Part 1
496 const int Lv2Vacuum1_num = 2;
497
498 double Lv2Vacuum1_Z[Lv2Vacuum1_num];
499 Lv2Vacuum1_Z[0] = Lv2Vacuum_L1;
500 Lv2Vacuum1_Z[1] = Lv2Vacuum_L2;
501 double Lv2Vacuum1_rI[Lv2Vacuum1_num];
502 for (int tmpn = 0; tmpn < Lv2Vacuum1_num; ++tmpn) {
503 Lv2Vacuum1_rI[tmpn] = 0.0;
504 }
505 double Lv2Vacuum1_rO[Lv2Vacuum1_num];
506 Lv2Vacuum1_rO[0] = Lv2Vacuum_R1;
507 Lv2Vacuum1_rO[1] = Lv2Vacuum_R1;
508 // Part 2
509 double Lv2Vacuum2_Z1 = 2. * Lv2Vacuum_L3;
510 double Lv2Vacuum2_rI1 = 0.0;
511 double Lv2Vacuum2_rO1 = Lv2Vacuum_R2;
512
513 double Lv2Vacuum2_Z2 = (Lv2Vacuum_L3 * cos(Lv2Vacuum_A2)) + SafetyLength;
514 double Lv2Vacuum2_rI2 = 0.0;
515 double Lv2Vacuum2_rO2 = 2 * Lv2Vacuum_R2;
516 // Part 3
517 const int Lv2Vacuum3_num = 2;
518
519 double Lv2Vacuum3_Z[Lv2Vacuum3_num];
520 Lv2Vacuum3_Z[0] = 0.0;
521 Lv2Vacuum3_Z[1] = Lv2Vacuum_L4;
522 double Lv2Vacuum3_rI[Lv2Vacuum3_num];
523 for (int tmpn = 0; tmpn < Lv2Vacuum3_num; ++tmpn) {
524 Lv2Vacuum3_rI[tmpn] = 0.0;
525 }
526 double Lv2Vacuum3_rO[Lv2Vacuum3_num];
527 Lv2Vacuum3_rO[0] = Lv2Vacuum_R3;
528 Lv2Vacuum3_rO[1] = Lv2Vacuum_R3;
529
530 // Define geometry
531 // Part 1
532 G4Polycone* geo_Lv2VacuumPart1 = new G4Polycone("geo_Lv2VacuumPart1_name", 0, 2 * M_PI, Lv2Vacuum1_num, Lv2Vacuum1_Z, Lv2Vacuum1_rI,
533 Lv2Vacuum1_rO);
534 // Part 2
535 G4Tubs* geo_Lv2VacuumPart2_1 = new G4Tubs("geo_Lv2VacuumPart2_1_name", Lv2Vacuum2_rI1, Lv2Vacuum2_rO1, Lv2Vacuum2_Z1, 0, 2 * M_PI);
536 G4Tubs* geo_Lv2VacuumPart2_2 = new G4Tubs("geo_Lv2VacuumPart2_2_name", Lv2Vacuum2_rI2, Lv2Vacuum2_rO2, Lv2Vacuum2_Z2, 0, 2 * M_PI);
537 G4Transform3D transform_Lv2VacuumPart2_2 = G4Translate3D(0., 0., 0.);
538 transform_Lv2VacuumPart2_2 = transform_Lv2VacuumPart2_2 * G4RotateY3D(-Lv2Vacuum_A2);
539 G4IntersectionSolid* geo_Lv2VacuumPart2 = new G4IntersectionSolid("geo_Lv2VacuumPart2_name", geo_Lv2VacuumPart2_1,
540 geo_Lv2VacuumPart2_2, transform_Lv2VacuumPart2_2);
541 // Part 3
542 G4Polycone* geo_Lv2VacuumPart3 = new G4Polycone("geo_Lv2VacuumPart3_name", 0, 2 * M_PI, Lv2Vacuum3_num, Lv2Vacuum3_Z, Lv2Vacuum3_rI,
543 Lv2Vacuum3_rO);
544 // Part1+2+3
545 // G4Transform3D transform_Lv2VacuumPart3 = G4Translate3D(0., 0., 0.);
546 G4Transform3D transform_Lv2VacuumPart3 = G4Translate3D(-0.5, 0., 0.);
547 // A11 instead of A1
548 transform_Lv2VacuumPart3 = transform_Lv2VacuumPart3 * G4RotateY3D(-A11);
549 G4UnionSolid* geo_Lv2Vacuumxx = new G4UnionSolid("geo_Lv2Vacuumxx_name", geo_Lv2VacuumPart1, geo_Lv2VacuumPart3,
550 transform_Lv2VacuumPart3);
551 G4Transform3D transform_Lv2VacuumPart2 = G4Translate3D(Lv2Vacuum_L3 * sin(Lv2Vacuum_A2), 0.,
552 Lv2Vacuum_L2 + Lv2Vacuum_L3 * cos(Lv2Vacuum_A2));
553 transform_Lv2VacuumPart2 = transform_Lv2VacuumPart2 * G4RotateY3D(Lv2Vacuum_A2);
554 geo_Lv2Vacuumx = new G4UnionSolid("geo_Lv2Vacuumx_name", geo_Lv2Vacuumxx, geo_Lv2VacuumPart2,
555 transform_Lv2VacuumPart2);
556 } else { // Run2
557 double Lv2Vacuum_L1 = m_config.getParameter(prep + "L1") * unitFactor;
558 double Lv2Vacuum_L2 = m_config.getParameter(prep + "L2") * unitFactor;
559 double Lv2Vacuum_L3 = m_config.getParameter(prep + "L3") * unitFactor;
560 // double Lv2Vacuum_L4 = m_config.getParameter(prep + "L4") * unitFactor;
561 double Lv2Vacuum_D1 = m_config.getParameter(prep + "D1") * unitFactor;
562 double Lv2Vacuum_D2 = m_config.getParameter(prep + "D2") * unitFactor;
563 double Lv2Vacuum_D3 = m_config.getParameter(prep + "D3") * unitFactor;
564 double Lv2Vacuum_D4 = m_config.getParameter(prep + "D4") * unitFactor;
565 double Lv2Vacuum_D5 = m_config.getParameter(prep + "D5") * unitFactor;
566 double Lv2Vacuum_D6 = m_config.getParameter(prep + "D6") * unitFactor;
567 double Lv2Vacuum_S1 = m_config.getParameter(prep + "S1") * unitFactor;
568 double Lv2Vacuum_R1 = m_config.getParameter(prep + "R1") * unitFactor;
569 double Lv2Vacuum_R2 = m_config.getParameter(prep + "R2") * unitFactor;
570 //double Lv2Vacuum_R3 = m_config.getParameter(prep + "R3") * unitFactor;
571 double Lv2Vacuum_P1 = m_config.getParameter(prep + "P1") * unitFactor;
572 //double Lv2Vacuum_A1 = cLv2Vacuum.getAngle("A1");
573 double Lv2Vacuum_A1 = m_config.getParameter(prep + "A1");
574 double Lv2Vacuum_A2 = m_config.getParameter(prep + "A2");
575 double Lv2Vacuum_A3 = m_config.getParameter(prep + "A3");
576
577 // Part 1
578 const int Lv2Vacuum1_num = 2;
579
580 double Lv2Vacuum1_Z[Lv2Vacuum1_num];
581 Lv2Vacuum1_Z[0] = Lv2Vacuum_L1;
582 Lv2Vacuum1_Z[1] = Lv2Vacuum_L2;
583 double Lv2Vacuum1_rI[Lv2Vacuum1_num];
584 for (int tmpn = 0; tmpn < Lv2Vacuum1_num; ++tmpn) {
585 Lv2Vacuum1_rI[tmpn] = 0.0;
586 }
587 double Lv2Vacuum1_rO[Lv2Vacuum1_num];
588 Lv2Vacuum1_rO[0] = Lv2Vacuum_R1;
589 Lv2Vacuum1_rO[1] = Lv2Vacuum_R1;
590 // Part 2
591 double Lv2Vacuum2_Z1 = 2. * Lv2Vacuum_L3;
592 double Lv2Vacuum2_rI1 = 0.0;
593 double Lv2Vacuum2_rO1 = Lv2Vacuum_R2;
594
595 double Lv2Vacuum2_Z2 = (Lv2Vacuum_L3 * cos(Lv2Vacuum_A2)) + SafetyLength;
596 double Lv2Vacuum2_rI2 = 0.0;
597 double Lv2Vacuum2_rO2 = 2 * Lv2Vacuum_R2;
598 // Part 3
599 // const int Lv2Vacuum3_num = 2;
600
601
602 // double Lv2Vacuum3_Z[Lv2Vacuum3_num];
603 // Lv2Vacuum3_Z[0] = 0.0;
604 // Lv2Vacuum3_Z[1] = Lv2Vacuum_L4;
605 // double Lv2Vacuum3_rI[Lv2Vacuum3_num];
606 // for (int tmpn = 0; tmpn < Lv2Vacuum3_num; ++tmpn) {
607 // Lv2Vacuum3_rI[tmpn] = 0.0;
608 // }
609 // double Lv2Vacuum3_rO[Lv2Vacuum3_num];
610 // Lv2Vacuum3_rO[0] = Lv2Vacuum_R3;
611 // Lv2Vacuum3_rO[1] = Lv2Vacuum_R3;
612
613 double Lv2Vacuum3_dx1 = Lv2Vacuum_D1;
614 double Lv2Vacuum3_dx2 = Lv2Vacuum_D2;
615 double Lv2Vacuum3_dy1 = Lv2Vacuum_D3;
616 double Lv2Vacuum3_dy2 = Lv2Vacuum_D4;
617 double Lv2Vacuum3_dz = Lv2Vacuum_D5;
618 double Lv2Vacuum3_Dz = Lv2Vacuum_D6;
619 double Lv2Vacuum3_L_a = Lv2Vacuum_S1;
620 double Lv2Vacuum3_L_b = Lv2Vacuum3_L_a * sin(Lv2Vacuum_A3);
621 double Lv2Vacuum3_pXYZ = Lv2Vacuum_P1;
622
623 // Define geometry
624 // Part 1
625 G4Polycone* geo_Lv2VacuumPart1 = new G4Polycone("geo_Lv2VacuumPart1_name", 0, 2 * M_PI, Lv2Vacuum1_num, Lv2Vacuum1_Z, Lv2Vacuum1_rI,
626 Lv2Vacuum1_rO);
627 // Part 2
628 G4Tubs* geo_Lv2VacuumPart2_1 = new G4Tubs("geo_Lv2VacuumPart2_1_name", Lv2Vacuum2_rI1, Lv2Vacuum2_rO1, Lv2Vacuum2_Z1, 0, 2 * M_PI);
629 G4Tubs* geo_Lv2VacuumPart2_2 = new G4Tubs("geo_Lv2VacuumPart2_2_name", Lv2Vacuum2_rI2, Lv2Vacuum2_rO2, Lv2Vacuum2_Z2, 0, 2 * M_PI);
630 G4Transform3D transform_Lv2VacuumPart2_2 = G4Translate3D(0., 0., 0.);
631 transform_Lv2VacuumPart2_2 = transform_Lv2VacuumPart2_2 * G4RotateY3D(-Lv2Vacuum_A2);
632 G4IntersectionSolid* geo_Lv2VacuumPart2 = new G4IntersectionSolid("geo_Lv2VacuumPart2_name", geo_Lv2VacuumPart2_1,
633 geo_Lv2VacuumPart2_2, transform_Lv2VacuumPart2_2);
634 // Part 3
635 // G4Polycone* geo_Lv2VacuumPart3 = new G4Polycone("geo_Lv2VacuumPart3_name", 0, 2 * M_PI, Lv2Vacuum3_num, Lv2Vacuum3_Z, Lv2Vacuum3_rI,
636 // Lv2Vacuum3_rO);
637 G4Trd* geo_Lv2VacuumPart3_1 = new G4Trd("geo_Lv2VacuumPart3_1_name", Lv2Vacuum3_dx1, Lv2Vacuum3_dx2, Lv2Vacuum3_dy1, Lv2Vacuum3_dy2,
638 Lv2Vacuum3_dz);
639 G4EllipticalTube* geo_Lv2VacuumPart3_2 = new G4EllipticalTube("geo_Lv2VacuumPart3_2_name", Lv2Vacuum3_L_b, Lv2Vacuum3_L_a,
640 Lv2Vacuum3_Dz);
641 G4Box* geo_Lv2VacuumPart3_3 = new G4Box("geo_Lv2VacuumPart3_3_name", Lv2Vacuum3_pXYZ, Lv2Vacuum3_pXYZ, Lv2Vacuum3_pXYZ);
642
643 G4Transform3D transform_Lv2VacuumPart3_1 = G4Translate3D(0.5, 0., 0.);
644 transform_Lv2VacuumPart3_1 = transform_Lv2VacuumPart3_1 * G4RotateY3D(M_PI / 2 - Lv2Vacuum_A3);
645 G4UnionSolid* geo_Lv2VacuumPart3xx = new G4UnionSolid("geo_Lv2VacuumPart3xx_name", geo_Lv2VacuumPart3_1, geo_Lv2VacuumPart3_2,
646 transform_Lv2VacuumPart3_1);
647
648 G4Transform3D transform_Lv2VacuumPart3_2 = G4Translate3D(-0.5, 0., 0.);
649 transform_Lv2VacuumPart3_2 = transform_Lv2VacuumPart3_2 * G4RotateY3D(Lv2Vacuum_A3 - M_PI / 2);
650 G4UnionSolid* geo_Lv2VacuumPart3x = new G4UnionSolid("geo_Lv2VacuumPart3x_name", geo_Lv2VacuumPart3xx, geo_Lv2VacuumPart3_2,
651 transform_Lv2VacuumPart3_2);
652
653 // This variable is unused
654 //G4Transform3D transform_Lv2VacuumPart2_3 = G4Translate3D(0., 0., 0.);
655 G4IntersectionSolid* geo_Lv2VacuumPart3 = new G4IntersectionSolid("geo_Lv2VacuumPart3_name", geo_Lv2VacuumPart3x,
656 geo_Lv2VacuumPart3_3);
657 // Part1+2+3
658 // G4Transform3D transform_Lv2VacuumPart3 = G4Translate3D(0., 0., 0.);
659 G4Transform3D transform_Lv2VacuumPart3 = G4Translate3D(-(67.5 + 85) * sin(Lv2Vacuum_A1), 0., (67.5 + 85) * cos(Lv2Vacuum_A1));
660 transform_Lv2VacuumPart3 = transform_Lv2VacuumPart3 * G4RotateY3D(M_PI - Lv2Vacuum_A1);
661 G4UnionSolid* geo_Lv2Vacuumxx = new G4UnionSolid("geo_Lv2Vacuumxx_name", geo_Lv2VacuumPart1, geo_Lv2VacuumPart3,
662 transform_Lv2VacuumPart3);
663 G4Transform3D transform_Lv2VacuumPart2 = G4Translate3D(Lv2Vacuum_L3 * sin(Lv2Vacuum_A2), 0.,
664 Lv2Vacuum_L2 + Lv2Vacuum_L3 * cos(Lv2Vacuum_A2));
665 transform_Lv2VacuumPart2 = transform_Lv2VacuumPart2 * G4RotateY3D(Lv2Vacuum_A2);
666 geo_Lv2Vacuumx = new G4UnionSolid("geo_Lv2Vacuumx_name", geo_Lv2Vacuumxx, geo_Lv2VacuumPart2,
667 transform_Lv2VacuumPart2);
668 }
669
670 // Material
671 string strMat_Lv2Vacuum = m_config.getParameterStr(prep + "Material");
672 G4Material* mat_Lv2Vacuum = Materials::get(strMat_Lv2Vacuum);
673
674 // Intersection with mother
675 G4IntersectionSolid* geo_Lv2Vacuum = new G4IntersectionSolid("geo_Lv2Vacuum_name", geo_Lv2Vacuumx, geo_Lv1SUS);
676 G4LogicalVolume* logi_Lv2Vacuum = new G4LogicalVolume(geo_Lv2Vacuum, mat_Lv2Vacuum, "logi_Lv2Vacuum_name");
677 if (flag_limitStep) logi_Lv2Vacuum->SetUserLimits(new G4UserLimits(stepMax));
678
679 // Put volume
680 setColor(*logi_Lv2Vacuum, "#CCCCCC");
681 new G4PVPlacement(0, G4ThreeVector(0, 0, 0), logi_Lv2Vacuum, "phys_Lv2Vacuum_name", logi_Lv1SUS, false, 0);
682
683
684 //----------
685 //- Lv2Paraf
686
687 // Part 1
688 prep = "Lv2Paraf1.";
689
690 int Lv2Paraf1_num = int(m_config.getParameter(prep + "N"));
691 vector<double> Lv2Paraf1_Z(Lv2Paraf1_num);
692 vector<double> Lv2Paraf1_rI(Lv2Paraf1_num);
693 vector<double> Lv2Paraf1_rO(Lv2Paraf1_num);
694
695 for (int i = 0; i < Lv2Paraf1_num; ++i) {
696 ostringstream ossZID;
697 ossZID << "Z" << i;
698
699 ostringstream ossrOID;
700 ossrOID << "R" << i;
701
702 ostringstream ossrIID;
703 ossrIID << "r" << i;
704
705 Lv2Paraf1_Z[i] = m_config.getParameter(prep + ossZID.str()) * unitFactor;
706 Lv2Paraf1_rO[i] = m_config.getParameter(prep + ossrOID.str()) * unitFactor;
707 Lv2Paraf1_rI[i] = m_config.getParameter(prep + ossrIID.str(), 0.0) * unitFactor;
708 }
709
710 // Part 2
711 prep = "Lv2Paraf2.";
712
713 int Lv2Paraf2_num = int(m_config.getParameter(prep + "N"));
714 vector<double> Lv2Paraf2_Z(Lv2Paraf2_num);
715 vector<double> Lv2Paraf2_rI(Lv2Paraf2_num);
716 vector<double> Lv2Paraf2_rO(Lv2Paraf2_num);
717
718 for (int i = 0; i < Lv2Paraf2_num; ++i) {
719 ostringstream ossZID;
720 ossZID << "Z" << i;
721
722 ostringstream ossrOID;
723 ossrOID << "R" << i;
724
725 ostringstream ossrIID;
726 ossrIID << "r" << i;
727
728 Lv2Paraf2_Z[i] = m_config.getParameter(prep + ossZID.str()) * unitFactor;
729 Lv2Paraf2_rO[i] = m_config.getParameter(prep + ossrOID.str()) * unitFactor;
730 Lv2Paraf2_rI[i] = m_config.getParameter(prep + ossrIID.str(), 0.0) * unitFactor;
731 }
732
733 // Material
734 string strMat_Lv2Paraf = m_config.getParameterStr(prep + "Material");
735 G4Material* mat_Lv2Paraf = Materials::get(strMat_Lv2Paraf);
736
737 // Define geometry
738 G4Polycone* geo_Lv2Parafpcon1 = new G4Polycone("geo_Lv2Parafpcon1_name", 0, 2 * M_PI, Lv2Paraf1_num, &(Lv2Paraf1_Z[0]),
739 &(Lv2Paraf1_rI[0]),
740 &(Lv2Paraf1_rO[0]));
741 G4Polycone* geo_Lv2Parafpcon2 = new G4Polycone("geo_Lv2Parafpcon2_name", 0, 2 * M_PI, Lv2Paraf2_num, &(Lv2Paraf2_Z[0]),
742 &(Lv2Paraf2_rI[0]),
743 &(Lv2Paraf2_rO[0]));
744 G4SubtractionSolid* geo_Lv2Paraf = new G4SubtractionSolid("geo_Lv2Paraf_name", geo_Lv2Parafpcon1, geo_Lv2Parafpcon2);
745 G4LogicalVolume* logi_Lv2Paraf = new G4LogicalVolume(geo_Lv2Paraf, mat_Lv2Paraf, "logi_Lv2Paraf_name");
746
747 // Put volume
748 setColor(*logi_Lv2Paraf, "#00CCCC");
749 new G4PVPlacement(0, G4ThreeVector(0, 0, 0), logi_Lv2Paraf, "phys_Lv2Paraf_name", logi_Lv1SUS, false, 0);
750
751
752 //----------
753 //- Lv3AuCoat
754
755 // Get parameters from .xml file
756 prep = "Lv3AuCoat.";
757
758 const int Lv3AuCoat_num = 2;
759
760 double Lv3AuCoat_Z[Lv3AuCoat_num];
761 Lv3AuCoat_Z[0] = m_config.getParameter(prep + "L1") * unitFactor;
762 Lv3AuCoat_Z[1] = m_config.getParameter(prep + "L2") * unitFactor;
763
764 double Lv3AuCoat_rI[Lv3AuCoat_num];
765 Lv3AuCoat_rI[0] = m_config.getParameter(prep + "R1") * unitFactor;
766 Lv3AuCoat_rI[1] = Lv3AuCoat_rI[0];
767
768 double Lv3AuCoat_rO[Lv3AuCoat_num];
769 Lv3AuCoat_rO[0] = m_config.getParameter(prep + "R2") * unitFactor;
770 Lv3AuCoat_rO[1] = Lv3AuCoat_rO[0];
771
772 string strMat_Lv3AuCoat = m_config.getParameterStr(prep + "Material");
773 G4Material* mat_Lv3AuCoat = Materials::get(strMat_Lv3AuCoat);
774
775 // Define geometry
776 G4Polycone* geo_Lv3AuCoat = new G4Polycone("geo_Lv3AuCoat_name", 0, 2 * M_PI, Lv3AuCoat_num, Lv3AuCoat_Z, Lv3AuCoat_rI,
777 Lv3AuCoat_rO);
778 G4LogicalVolume* logi_Lv3AuCoat = new G4LogicalVolume(geo_Lv3AuCoat, mat_Lv3AuCoat, "logi_Lv3AuCoat_name");
779
780 // Put volume
781 setColor(*logi_Lv3AuCoat, "#CCCC00");
782 new G4PVPlacement(0, G4ThreeVector(0, 0, 0), logi_Lv3AuCoat, "phys_Lv3AuCoat_name", logi_Lv2Vacuum, false, 0);
783
784
787
788 // Get parameters from .xml file
789 prep = "Flange.";
790
791 double Flange_R = m_config.getParameter(prep + "R") * unitFactor;
792 double Flange_L1 = m_config.getParameter(prep + "L1") * unitFactor;
793 double Flange_L2 = m_config.getParameter(prep + "L2") * unitFactor;
794 double Flange_D = m_config.getParameter(prep + "D") * unitFactor;
795 double Flange_T = m_config.getParameter(prep + "T") * unitFactor;
796
797 // Define geometry
798 //G4Box* geo_Flange0 = new G4Box("geo_Flange0_name", Flange_L2, Flange_R, Flange_T);
799 G4Tubs* geo_Flange0 = new G4Tubs("geo_Flange0_name", 0, Flange_L2, Flange_T, 0, 2 * M_PI);
800 G4Tubs* geo_Flange1 = new G4Tubs("geo_Flange1_name", 0, Flange_R, Flange_T, 0, 2 * M_PI);
801 G4Tubs* geo_Flange2 = new G4Tubs("geo_Flange2_name", 0, Flange_R, Flange_T, 0, 2 * M_PI);
802
803 G4UnionSolid* geo_Flange_x = new G4UnionSolid("geo_Flange_x_name", geo_Flange1, geo_Flange2, G4Translate3D(-Flange_L1 * 2, 0, 0));
804 G4IntersectionSolid* geo_Flange = new G4IntersectionSolid("geo_Flange_name", geo_Flange0, geo_Flange_x, G4Translate3D(Flange_L1, 0,
805 0));
806
807
810
811
812 // Avoid overlap with HeavyMetalShield
813 prep = "HMS.";
814 int HMS_num = int(m_config.getParameter(prep + "N"));
815 vector<double> HMS_Z(HMS_num);
816 vector<double> HMS_rI(HMS_num);
817 vector<double> HMS_rO(HMS_num);
818
819 for (int i = 0; i < HMS_num; ++i) {
820 ostringstream ossZID;
821 ossZID << "Z" << i;
822
823 ostringstream ossrIID;
824 ossrIID << "rI" << i;
825
826 ostringstream ossrOID;
827 ossrOID << "rO" << i;
828
829 HMS_Z[i] = m_config.getParameter(prep + ossZID.str()) * unitFactor;
830 HMS_rI[i] = m_config.getParameter(prep + ossrIID.str()) * unitFactor;
831 HMS_rO[i] = m_config.getParameter(prep + ossrOID.str()) * unitFactor;
832 }
833
834 G4Polycone* geo_HMS = new G4Polycone("geo_HMS_name", 0, 2 * M_PI, HMS_num, &(HMS_Z[0]), &(HMS_rI[0]), &(HMS_rO[0]));
835
836
837 //----------
838 //- Lv1TaFwd
839
840 prep = "Lv1TaFwd.";
841 // The following variables are used in creation of other components below
842 double Lv1TaFwd_D1 = m_config.getParameter(prep + "D1") * unitFactor;
843 double Lv1TaFwd_L1 = m_config.getParameter(prep + "L1") * unitFactor;
844 double Lv1TaFwd_aL1 = m_config.getParameter(prep + "aL1", 0.0) * unitFactor;
845 double Lv1TaFwd_aL2 = m_config.getParameter(prep + "aL2", 0.0) * unitFactor;
846 double Lv1TaFwd_aL3 = m_config.getParameter(prep + "aL3", 0.0) * unitFactor;
847 G4SubtractionSolid* geo_Lv1TaFwd = NULL;
848 G4VSolid* geo_Lv1TaFwd_d = NULL;
849 G4LogicalVolume* logi_Lv1TaFwd = NULL;
850 if (phase2) {
851 // Get parameters from .xml file
852 double Lv1TaFwd_L2 = m_config.getParameter(prep + "L2") * unitFactor;
853 double Lv1TaFwd_L3 = m_config.getParameter(prep + "L3") * unitFactor;
854 double Lv1TaFwd_T1 = m_config.getParameter(prep + "T1") * unitFactor;
855
856 string strMat_Lv1TaFwd = m_config.getParameterStr(prep + "Material");
857 G4Material* mat_Lv1TaFwd = Materials::get(strMat_Lv1TaFwd);
858
859 //define geometry
860 G4Trd* geo_Lv1TaFwd_xx = new G4Trd("geo_Lv1TaFwd_xx_name", Lv1TaFwd_L2, Lv1TaFwd_L3, Lv1TaFwd_T1, Lv1TaFwd_T1, Lv1TaFwd_L1 / 2.0);
861 G4UnionSolid* geo_Lv1TaFwd_x
862 = new G4UnionSolid("geo_Lv1TaFwd_x_name", geo_Lv1TaFwd_xx, geo_Flange,
863 G4Translate3D(0, 0, Flange_D - (Lv1TaFwd_D1 + Lv1TaFwd_L1 / 2.0)));
864
865 geo_Lv1TaFwd = new G4SubtractionSolid("geo_Lv1TaFwd_name", geo_Lv1TaFwd_x, geo_HMS,
866 G4Translate3D(0, 0, -(Lv1TaFwd_D1 + Lv1TaFwd_L1 / 2.0)));
867
868 logi_Lv1TaFwd = new G4LogicalVolume(geo_Lv1TaFwd, mat_Lv1TaFwd, "logi_Lv1TaFwd_name");
869
870 // Put volume at (0.,0.,D1 + L1/2)
871 setColor(*logi_Lv1TaFwd, "#333333");
872 new G4PVPlacement(0, G4ThreeVector(0, 0, Lv1TaFwd_D1 + Lv1TaFwd_L1 / 2.0), logi_Lv1TaFwd, "phys_Lv1TaFwd_name", &topVolume, false,
873 0);
874 } else {
875 // Get parameters from .xml file
876 //double Lv1TaFwd_L2 = m_config.getParameter(prep + "L2") * unitFactor;
877 //double Lv1TaFwd_L3 = m_config.getParameter(prep + "L3") * unitFactor;
878 double Lv1TaFwd_T1 = m_config.getParameter(prep + "T1") * unitFactor;
879 double Lv1TaFwd_aR1 = m_config.getParameter(prep + "aR1") * unitFactor;
880 double Lv1TaFwd_aR2 = m_config.getParameter(prep + "aR2") * unitFactor;
881 double Lv1TaFwd_bL1 = Lv1TaFwd_L1 - Lv1TaFwd_aL1 - Lv1TaFwd_aL2 - Lv1TaFwd_aL3;
882 double Lv1TaFwd_bL2 = m_config.getParameter(prep + "bL2") * unitFactor;
883 double Lv1TaFwd_bL3 = m_config.getParameter(prep + "bL3") * unitFactor;
884
885 string strMat_Lv1TaFwd = m_config.getParameterStr(prep + "Material");
886 G4Material* mat_Lv1TaFwd = Materials::get(strMat_Lv1TaFwd);
887
888 // Define geometry
889 //G4Trd* geo_Lv1TaFwd_xx = new G4Trd("geo_Lv1TaFwd_xx_name", Lv1TaFwd_L2, Lv1TaFwd_L3, Lv1TaFwd_T1, Lv1TaFwd_T1, Lv1TaFwd_L1 / 2.0);
890 double Lv1TaFwd_aR[4] = {Lv1TaFwd_aR1, Lv1TaFwd_aR1, Lv1TaFwd_aR2, Lv1TaFwd_aR2};
891 double Lv1TaFwd_ar[4] = {0, 0, 0, 0};
892 double Lv1TaFwd_aL[4] = { -Lv1TaFwd_L1 / 2.0 + 0,
893 -Lv1TaFwd_L1 / 2.0 + Lv1TaFwd_aL1,
894 -Lv1TaFwd_L1 / 2.0 + Lv1TaFwd_aL1 + Lv1TaFwd_aL2,
895 -Lv1TaFwd_L1 / 2.0 + Lv1TaFwd_aL1 + Lv1TaFwd_aL2 + Lv1TaFwd_aL3
896 };
897
898 G4VSolid* geo_Lv1TaFwd_a = new G4Polycone("geo_Lv1TaFwd_a_name", 0, 2 * M_PI, 4, Lv1TaFwd_aL, Lv1TaFwd_ar, Lv1TaFwd_aR);
899 G4VSolid* geo_Lv1TaFwd_b = new G4Trd("geo_Lv1TaFwd_b_name", Lv1TaFwd_bL2, Lv1TaFwd_bL3, Lv1TaFwd_T1, Lv1TaFwd_T1,
900 Lv1TaFwd_bL1 / 2.0);
901 G4VSolid* geo_Lv1TaFwd_c = new G4Box("geo_Lv1TaFwd_c_name", 200, Lv1TaFwd_T1, (Lv1TaFwd_aL1 + Lv1TaFwd_aL2 + Lv1TaFwd_aL3) / 2.0);
902 geo_Lv1TaFwd_d = new G4IntersectionSolid("geo_Lv1TaFwd_d_name", geo_Lv1TaFwd_a, geo_Lv1TaFwd_c, G4Translate3D(0, 0,
903 -Lv1TaFwd_L1 / 2.0 + (Lv1TaFwd_aL1 + Lv1TaFwd_aL2 + Lv1TaFwd_aL3) / 2.0));
904 G4VSolid* geo_Lv1TaFwd_xx = new G4UnionSolid("geo_Lv1TaFwd_xx_name", geo_Lv1TaFwd_d, geo_Lv1TaFwd_b, G4Translate3D(0, 0,
905 Lv1TaFwd_L1 / 2.0 - Lv1TaFwd_bL1 / 2.0));
906 G4UnionSolid* geo_Lv1TaFwd_x
907 = new G4UnionSolid("geo_Lv1TaFwd_x_name", geo_Lv1TaFwd_xx, geo_Flange,
908 G4Translate3D(0, 0, Flange_D - (Lv1TaFwd_D1 + Lv1TaFwd_L1 / 2.0)));
909
910 geo_Lv1TaFwd = new G4SubtractionSolid("geo_Lv1TaFwd_name", geo_Lv1TaFwd_x, geo_HMS,
911 G4Translate3D(0, 0, -(Lv1TaFwd_D1 + Lv1TaFwd_L1 / 2.0)));
912
913 logi_Lv1TaFwd = new G4LogicalVolume(geo_Lv1TaFwd, mat_Lv1TaFwd, "logi_Lv1TaFwd_name");
914
915 // Put volume at (0.,0.,D1 + L1/2)
916 setColor(*logi_Lv1TaFwd, "#333333");
917 new G4PVPlacement(0, G4ThreeVector(0, 0, Lv1TaFwd_D1 + Lv1TaFwd_L1 / 2.0), logi_Lv1TaFwd, "phys_Lv1TaFwd_name", &topVolume, false,
918 0);
919 }
920
921
922 //----------
923 //- Lv2VacFwd
924
925 // Get parameters from .xml file
926 prep = "Lv2VacFwd.";
927
928 double Lv2VacFwd_D1 = m_config.getParameter(prep + "D1") * unitFactor;
929 double Lv2VacFwd_D2 = m_config.getParameter(prep + "D2") * unitFactor;
930 double Lv2VacFwd_D3 = m_config.getParameter(prep + "D3") * unitFactor;
931 double Lv2VacFwd_L1 = m_config.getParameter(prep + "L1") * unitFactor;
932 double Lv2VacFwd_L2 = m_config.getParameter(prep + "L2") * unitFactor;
933 double Lv2VacFwd_L3 = m_config.getParameter(prep + "L3") * unitFactor;
934 double Lv2VacFwd_R1 = m_config.getParameter(prep + "R1") * unitFactor;
935 double Lv2VacFwd_R2 = m_config.getParameter(prep + "R2") * unitFactor;
936 double Lv2VacFwd_R3 = m_config.getParameter(prep + "R3") * unitFactor;
937 double Lv2VacFwd_R4 = m_config.getParameter(prep + "R4") * unitFactor;
938 double Lv2VacFwd_A1 = m_config.getParameter(prep + "A1");
939 double Lv2VacFwd_A2 = m_config.getParameter(prep + "A2");
940
941 string strMat_Lv2VacFwd = m_config.getParameterStr(prep + "Material");
942 G4Material* mat_Lv2VacFwd = Materials::get(strMat_Lv2VacFwd);
943
944 // Part 1
945 double Lv2VacFwd1_Z1 = sqrt(Lv2VacFwd_D1 * Lv2VacFwd_D1 + Lv2VacFwd_D2 * Lv2VacFwd_D2 - 2.*Lv2VacFwd_D1 * Lv2VacFwd_D2 * cos(
946 Lv2VacFwd_A1));
947 double Lv2VacFwd1_rI1 = 0.0;
948 double Lv2VacFwd1_rO1 = Lv2VacFwd_R1;
949
950 double Lv2VacFwd1_Z2 = (Lv2VacFwd1_Z1 / 2. * cos(Lv2VacFwd_A2)) + SafetyLength;
951 double Lv2VacFwd1_rI2 = 0.0;
952 double Lv2VacFwd1_rO2 = 2 * Lv2VacFwd_R1;
953 // Part 2
954 double Lv2VacFwd2_Z1 = Lv2VacFwd_L1;
955 double Lv2VacFwd2_rI1 = 0.0;
956 double Lv2VacFwd2_rO1 = Lv2VacFwd_R2;
957
958 double Lv2VacFwd2_Z2 = (Lv2VacFwd_L1 / 2. * cos(Lv2VacFwd_A2)) + SafetyLength;
959 double Lv2VacFwd2_rI2 = 0.0;
960 double Lv2VacFwd2_rO2 = 2 * Lv2VacFwd_R2;
961 // Part 3
962 const int Lv2VacFwd3_num1 = 2; // Cylindrical part
963 const int Lv2VacFwd3_num2 = 3; // Policone part
964 //-----------> Cylindrical part
965 double Lv2VacFwd_Z1[Lv2VacFwd3_num1];
966 Lv2VacFwd_Z1[0] = 0.0;
967// Lv2VacFwd_Z1[1] = Lv2VacFwd_D3 - Lv2VacFwd_L2;
968 Lv2VacFwd_Z1[1] = Lv2VacFwd_D3 - Lv2VacFwd_L2 + 0.03 * SafetyLength;
969 double Lv2VacFwd_rI1[Lv2VacFwd3_num1];
970 for (int tmpn = 0; tmpn < Lv2VacFwd3_num1; ++tmpn) {
971 Lv2VacFwd_rI1[tmpn] = 0.0;
972 }
973 double Lv2VacFwd_rO1[Lv2VacFwd3_num1];
974 Lv2VacFwd_rO1[0] = Lv2VacFwd_R3;
975 Lv2VacFwd_rO1[1] = Lv2VacFwd_R3;
976 //<---------------
977 //----------->Policone part
978 double Lv2VacFwd_Z2[Lv2VacFwd3_num2];
979 Lv2VacFwd_Z2[0] = Lv2VacFwd_D3 - Lv2VacFwd_L2;
980 Lv2VacFwd_Z2[1] = Lv2VacFwd_D3;
981 Lv2VacFwd_Z2[2] = Lv2VacFwd_D3 + Lv2VacFwd_L3;
982 double Lv2VacFwd_rI2[Lv2VacFwd3_num2];
983 for (int tmpn = 0; tmpn < Lv2VacFwd3_num2; ++tmpn) {
984 Lv2VacFwd_rI2[tmpn] = 0.0;
985 }
986 double Lv2VacFwd_rO2[Lv2VacFwd3_num2];
987 Lv2VacFwd_rO2[0] = Lv2VacFwd_R3;
988 Lv2VacFwd_rO2[1] = Lv2VacFwd_R4;
989 Lv2VacFwd_rO2[2] = Lv2VacFwd_R4;
990 //<-------------------
991
992
993 // Define geometry
994 // Part 1
995 G4Tubs* geo_Lv2VacFwdPart1_1 = new G4Tubs("geo_Lv2VacFwdPart1_1_name", Lv2VacFwd1_rI1, Lv2VacFwd1_rO1, Lv2VacFwd1_Z1, 0, 2 * M_PI);
996 G4Tubs* geo_Lv2VacFwdPart1_2 = new G4Tubs("geo_Lv2VacFwdPart1_2_name", Lv2VacFwd1_rI2, Lv2VacFwd1_rO2, Lv2VacFwd1_Z2, 0, 2 * M_PI);
997 //Slanted tube of Part 1
998 G4Transform3D transform_Lv2VacFwdPart1_2 = G4Translate3D(0., 0., 0.);
999 transform_Lv2VacFwdPart1_2 = transform_Lv2VacFwdPart1_2 * G4RotateY3D(-Lv2VacFwd_A2 / 2.);
1000 G4IntersectionSolid* geo_Lv2VacFwdPart1 = new G4IntersectionSolid("geo_Lv2VacFwdPart1_name", geo_Lv2VacFwdPart1_1,
1001 geo_Lv2VacFwdPart1_2, transform_Lv2VacFwdPart1_2);
1002 // Part 2
1003 G4Tubs* geo_Lv2VacFwdPart2_1 = new G4Tubs("geo_Lv2VacFwdPart2_1_name", Lv2VacFwd2_rI1, Lv2VacFwd2_rO1, Lv2VacFwd2_Z1, 0, 2 * M_PI);
1004 G4Tubs* geo_Lv2VacFwdPart2_2 = new G4Tubs("geo_Lv2VacFwdPart2_2_name", Lv2VacFwd2_rI2, Lv2VacFwd2_rO2, Lv2VacFwd2_Z2, 0, 2 * M_PI);
1005 //Slanted tube of Part 2
1006 G4Transform3D transform_Lv2VacFwdPart2_2 = G4Translate3D(0., 0., 0.);
1007 transform_Lv2VacFwdPart2_2 = transform_Lv2VacFwdPart2_2 * G4RotateY3D(Lv2VacFwd_A2 / 2.);
1008 G4IntersectionSolid* geo_Lv2VacFwdPart2 = new G4IntersectionSolid("geo_Lv2VacFwdPart2_name", geo_Lv2VacFwdPart2_1,
1009 geo_Lv2VacFwdPart2_2, transform_Lv2VacFwdPart2_2);
1010 // Part 3
1011// G4Polycone* geo_Lv2VacFwdPart3 = new G4Polycone("geo_Lv2VacFwdPart3", 0, 2 * M_PI, Lv2VacFwd3_num, Lv2VacFwd_Z, Lv2VacFwd_rI, Lv2VacFwd_rO);
1012 G4Polycone* geo_Lv2VacFwdPart3_1 = new G4Polycone("geo_Lv2VacFwdPart3_1", 0, 2 * M_PI, Lv2VacFwd3_num1, Lv2VacFwd_Z1, Lv2VacFwd_rI1,
1013 Lv2VacFwd_rO1);
1014 G4Polycone* geo_Lv2VacFwdPart3_2 = new G4Polycone("geo_Lv2VacFwdPart3_2", 0, 2 * M_PI, Lv2VacFwd3_num2, Lv2VacFwd_Z2, Lv2VacFwd_rI2,
1015 Lv2VacFwd_rO2);
1016 G4Transform3D transform_Lv2VacFwdPart3_1 = G4Translate3D(-0.5, 0., 0.);
1017 transform_Lv2VacFwdPart3_1 = transform_Lv2VacFwdPart3_1 * G4RotateY3D(Lv2VacFwd_A1 - A11);
1018 G4UnionSolid* geo_Lv2VacFwdPart3 = new G4UnionSolid("geo_Lv2VacFwdPart3_name", geo_Lv2VacFwdPart3_2, geo_Lv2VacFwdPart3_1,
1019 transform_Lv2VacFwdPart3_1);
1020 // Part1+2+3
1021 //tmp begin
1022 G4Transform3D transform_Lv2VacFwdPart1 = G4Translate3D((Lv2VacFwd_D1 * sin(Lv2VacFwd_A1) + Lv2VacFwd_D2 * sin(
1023 2.*Lv2VacFwd_A1)) / 2.,
1024 0.,
1025 (Lv2VacFwd_D1 * cos(Lv2VacFwd_A1) + Lv2VacFwd_D2 * cos(2.*Lv2VacFwd_A1)) / 2.);
1026 //G4Transform3D transform_Lv2VacFwdPart1 = G4Translate3D((Lv2VacFwd_D1 * sin(Lv2VacFwd_A1) + Lv2VacFwd_D2 * sin(2.*Lv2VacFwd_A1)) / 1.9 ,
1027 // 0.,
1028 // (Lv2VacFwd_D1 * cos(Lv2VacFwd_A1) + Lv2VacFwd_D2 * cos(2.*Lv2VacFwd_A1)) / 1.9);
1029 transform_Lv2VacFwdPart1 = transform_Lv2VacFwdPart1 * G4RotateY3D(Lv2VacFwd_A1 + Lv2VacFwd_A2);
1030
1031 G4Transform3D transform_Lv2VacFwdPart2 = G4Translate3D(Lv2VacFwd_D2 * sin(2.*Lv2VacFwd_A1) + Lv2VacFwd_L1 * sin(
1032 2.*Lv2VacFwd_A1) / 2.0,
1033 0.,
1034 Lv2VacFwd_D2 * cos(2.*Lv2VacFwd_A1) + Lv2VacFwd_L1 * cos(2.*Lv2VacFwd_A1) / 2.0);
1035 //G4Transform3D transform_Lv2VacFwdPart2 = G4Translate3D(Lv2VacFwd_D2 * sin(2.*Lv2VacFwd_A1) + Lv2VacFwd_L1 * sin(2.*Lv2VacFwd_A1) / 2.05,
1036 // 0.,
1037 // Lv2VacFwd_D2 * cos(2.*Lv2VacFwd_A1) + Lv2VacFwd_L1 * cos(2.*Lv2VacFwd_A1) / 2.05);
1038 //tmp end
1039 transform_Lv2VacFwdPart2 = transform_Lv2VacFwdPart2 * G4RotateY3D(2.*Lv2VacFwd_A1);
1040
1041 G4UnionSolid* geo_Lv2VacFwdxx = new G4UnionSolid("geo_Lv2VacFwdxx_name", geo_Lv2VacFwdPart3, geo_Lv2VacFwdPart1,
1042 transform_Lv2VacFwdPart1);
1043 G4UnionSolid* geo_Lv2VacFwdx = new G4UnionSolid("geo_Lv2VacFwdx_name", geo_Lv2VacFwdxx, geo_Lv2VacFwdPart2,
1044 transform_Lv2VacFwdPart2);
1045 // Intersection
1046 G4Transform3D transform_Lv2VacFwd = G4Translate3D(0., 0., -Lv1TaFwd_D1 - Lv1TaFwd_L1 / 2.);
1047 transform_Lv2VacFwd = transform_Lv2VacFwd * G4RotateY3D(-Lv2VacFwd_A1);
1048
1049 G4IntersectionSolid* geo_Lv2VacFwd = new G4IntersectionSolid("geo_Lv2VacFwd_name", geo_Lv1TaFwd, geo_Lv2VacFwdx,
1050 transform_Lv2VacFwd);
1051 G4LogicalVolume* logi_Lv2VacFwd = new G4LogicalVolume(geo_Lv2VacFwd, mat_Lv2VacFwd, "logi_Lv2VacFwd_name");
1052 if (flag_limitStep) logi_Lv2VacFwd->SetUserLimits(new G4UserLimits(stepMax));
1053
1054 // Put volume
1055 setColor(*logi_Lv2VacFwd, "#CCCCCC");
1056 //you must set this invisible, otherwise encounter segV.
1057 setVisibility(*logi_Lv2VacFwd, false);
1058 new G4PVPlacement(0, G4ThreeVector(0., 0., 0.), logi_Lv2VacFwd, "phys_Lv2VacFwd_name", logi_Lv1TaFwd, false, 0);
1059
1060
1063
1064 //----------
1065 //- Lv1TaBwd
1066
1067 prep = "Lv1TaBwd.";
1068 // The following variables are used in creation of other components below
1069 double Lv1TaBwd_D1 = m_config.getParameter(prep + "D1") * unitFactor;
1070 double Lv1TaBwd_L1 = m_config.getParameter(prep + "L1") * unitFactor;
1071 double Lv1TaBwd_aL1 = m_config.getParameter(prep + "aL1", 0.0) * unitFactor;
1072 double Lv1TaBwd_aL2 = m_config.getParameter(prep + "aL2", 0.0) * unitFactor;
1073 double Lv1TaBwd_aL3 = m_config.getParameter(prep + "aL3", 0.0) * unitFactor;
1074 G4UnionSolid* geo_Lv1TaBwd = NULL;
1075 G4VSolid* geo_Lv1TaBwd_d = NULL;
1076 G4LogicalVolume* logi_Lv1TaBwd = NULL;
1077 if (phase2) {
1078 // Get parameters from .xml file
1079 double Lv1TaBwd_L2 = m_config.getParameter(prep + "L2") * unitFactor;
1080 double Lv1TaBwd_L3 = m_config.getParameter(prep + "L3") * unitFactor;
1081 double Lv1TaBwd_T1 = m_config.getParameter(prep + "T1") * unitFactor;
1082 //
1083 string strMat_Lv1TaBwd = m_config.getParameterStr(prep + "Material");
1084 G4Material* mat_Lv1TaBwd = Materials::get(strMat_Lv1TaBwd);
1085
1086 //define geometry
1087 G4Trd* geo_Lv1TaBwd_x = new G4Trd("geo_Lv1TaBwd_x_name", Lv1TaBwd_L2, Lv1TaBwd_L3, Lv1TaBwd_T1, Lv1TaBwd_T1, Lv1TaBwd_L1 / 2.0);
1088 geo_Lv1TaBwd = new G4UnionSolid("geo_Lv1TaBwd_name", geo_Lv1TaBwd_x, geo_Flange,
1089 G4Translate3D(0, 0, -Flange_D - (-Lv1TaBwd_D1 - Lv1TaBwd_L1 / 2.0)));
1090 logi_Lv1TaBwd = new G4LogicalVolume(geo_Lv1TaBwd, mat_Lv1TaBwd, "logi_Lv1TaBwd_name");
1091
1092 //- put volume
1093 setColor(*logi_Lv1TaBwd, "#333333");
1094 new G4PVPlacement(0, G4ThreeVector(0, 0, -Lv1TaBwd_D1 - Lv1TaBwd_L1 / 2.0), logi_Lv1TaBwd, "phys_Lv1TaBwd_name", &topVolume, false,
1095 0);
1096 } else {
1097 // Get parameters from .xml file
1098 //double Lv1TaBwd_L2 = m_config.getParameter(prep + "L2") * unitFactor;
1099 //double Lv1TaBwd_L3 = m_config.getParameter(prep + "L3") * unitFactor;
1100 double Lv1TaBwd_T1 = m_config.getParameter(prep + "T1") * unitFactor;
1101 double Lv1TaBwd_aR1 = m_config.getParameter(prep + "aR1") * unitFactor;
1102 double Lv1TaBwd_aR2 = m_config.getParameter(prep + "aR2") * unitFactor;
1103 double Lv1TaBwd_bL1 = Lv1TaBwd_L1 - Lv1TaBwd_aL1 - Lv1TaBwd_aL2 - Lv1TaBwd_aL3;
1104 double Lv1TaBwd_bL2 = m_config.getParameter(prep + "bL2") * unitFactor;
1105 double Lv1TaBwd_bL3 = m_config.getParameter(prep + "bL3") * unitFactor;
1106
1107 string strMat_Lv1TaBwd = m_config.getParameterStr(prep + "Material");
1108 G4Material* mat_Lv1TaBwd = Materials::get(strMat_Lv1TaBwd);
1109
1110 // Define geometry
1111 //G4Trd* geo_Lv1TaBwd_x = new G4Trd("geo_Lv1TaBwd_x_name", Lv1TaBwd_L2, Lv1TaBwd_L3, Lv1TaBwd_T1, Lv1TaBwd_T1, Lv1TaBwd_L1 / 2.0);
1112 double Lv1TaBwd_aR[4] = {Lv1TaBwd_aR2, Lv1TaBwd_aR2, Lv1TaBwd_aR1, Lv1TaBwd_aR1};
1113 double Lv1TaBwd_ar[4] = {0, 0, 0, 0};
1114 double Lv1TaBwd_aL[4] = { +Lv1TaBwd_L1 / 2.0 - (Lv1TaBwd_aL1 + Lv1TaBwd_aL2 + Lv1TaBwd_aL3),
1115 +Lv1TaBwd_L1 / 2.0 - (Lv1TaBwd_aL1 + Lv1TaBwd_aL2),
1116 +Lv1TaBwd_L1 / 2.0 - (Lv1TaBwd_aL1),
1117 +Lv1TaBwd_L1 / 2.0 - 0
1118 };
1119 G4VSolid* geo_Lv1TaBwd_a = new G4Polycone("geo_Lv1TaBwd_a_name", 0, 2 * M_PI, 4, Lv1TaBwd_aL, Lv1TaBwd_ar, Lv1TaBwd_aR);
1120 G4VSolid* geo_Lv1TaBwd_b = new G4Trd("geo_Lv1TaBwd_b_name", Lv1TaBwd_bL2, Lv1TaBwd_bL3, Lv1TaBwd_T1, Lv1TaBwd_T1,
1121 Lv1TaBwd_bL1 / 2.0);
1122 G4VSolid* geo_Lv1TaBwd_c = new G4Box("geo_Lv1TaBwd_c_name", 200, Lv1TaBwd_T1, (Lv1TaBwd_aL1 + Lv1TaBwd_aL2 + Lv1TaBwd_aL3) / 2.0);
1123 geo_Lv1TaBwd_d = new G4IntersectionSolid("geo_Lv1TaBwd_d_name", geo_Lv1TaBwd_a, geo_Lv1TaBwd_c, G4Translate3D(0, 0,
1124 +Lv1TaBwd_L1 / 2.0 - (Lv1TaBwd_aL1 + Lv1TaBwd_aL2 + Lv1TaBwd_aL3) / 2.0));
1125 G4VSolid* geo_Lv1TaBwd_x = new G4UnionSolid("geo_Lv1TaBwd_x_name", geo_Lv1TaBwd_d, geo_Lv1TaBwd_b, G4Translate3D(0, 0,
1126 -Lv1TaBwd_L1 / 2.0 + Lv1TaBwd_bL1 / 2.0));
1127 geo_Lv1TaBwd = new G4UnionSolid("geo_Lv1TaBwd_name", geo_Lv1TaBwd_x, geo_Flange,
1128 G4Translate3D(0, 0, -Flange_D - (-Lv1TaBwd_D1 - Lv1TaBwd_L1 / 2.0)));
1129 logi_Lv1TaBwd = new G4LogicalVolume(geo_Lv1TaBwd, mat_Lv1TaBwd, "logi_Lv1TaBwd_name");
1130
1131 // Put volume
1132 setColor(*logi_Lv1TaBwd, "#333333");
1133 new G4PVPlacement(0, G4ThreeVector(0, 0, -Lv1TaBwd_D1 - Lv1TaBwd_L1 / 2.0), logi_Lv1TaBwd, "phys_Lv1TaBwd_name", &topVolume, false,
1134 0);
1135 }
1136
1137
1138 //----------
1139 //- Lv2VacBwd
1140
1141 // Get parameters from .xml file
1142 prep = "Lv2VacBwd.";
1143
1144 double Lv2VacBwd_D1 = m_config.getParameter(prep + "D1") * unitFactor;
1145 double Lv2VacBwd_D2 = m_config.getParameter(prep + "D2") * unitFactor;
1146 double Lv2VacBwd_D3 = m_config.getParameter(prep + "D3") * unitFactor;
1147 double Lv2VacBwd_L1 = m_config.getParameter(prep + "L1") * unitFactor;
1148 double Lv2VacBwd_L2 = m_config.getParameter(prep + "L2") * unitFactor;
1149 double Lv2VacBwd_L3 = m_config.getParameter(prep + "L3") * unitFactor;
1150 double Lv2VacBwd_R1 = m_config.getParameter(prep + "R1") * unitFactor;
1151 double Lv2VacBwd_R2 = m_config.getParameter(prep + "R2") * unitFactor;
1152 double Lv2VacBwd_R3 = m_config.getParameter(prep + "R3") * unitFactor;
1153 double Lv2VacBwd_R4 = m_config.getParameter(prep + "R4") * unitFactor;
1154 double Lv2VacBwd_A1 = m_config.getParameter(prep + "A1");
1155 double Lv2VacBwd_A2 = m_config.getParameter(prep + "A2");
1156
1157 string strMat_Lv2VacBwd = m_config.getParameterStr(prep + "Material");
1158 G4Material* mat_Lv2VacBwd = Materials::get(strMat_Lv2VacBwd);
1159
1160 // Part 1
1161 double Lv2VacBwd1_Z1 = sqrt(Lv2VacBwd_D1 * Lv2VacBwd_D1 + Lv2VacBwd_D2 * Lv2VacBwd_D2 - 2.*Lv2VacBwd_D1 * Lv2VacBwd_D2 * cos(
1162 Lv2VacBwd_A1));
1163 double Lv2VacBwd1_rI1 = 0.0;
1164 double Lv2VacBwd1_rO1 = Lv2VacBwd_R1;
1165
1166 double Lv2VacBwd1_Z2 = (Lv2VacBwd1_Z1 / 2. * cos(Lv2VacBwd_A2)) + SafetyLength;
1167 double Lv2VacBwd1_rI2 = 0.0;
1168 double Lv2VacBwd1_rO2 = 2 * Lv2VacBwd_R1;
1169 // Part 2
1170 double Lv2VacBwd2_Z1 = Lv2VacBwd_L1;
1171 double Lv2VacBwd2_rI1 = 0.0;
1172 double Lv2VacBwd2_rO1 = Lv2VacBwd_R2;
1173
1174 double Lv2VacBwd2_Z2 = (Lv2VacBwd_L1 / 2. * cos(Lv2VacBwd_A2)) + SafetyLength;
1175 double Lv2VacBwd2_rI2 = 0.0;
1176 double Lv2VacBwd2_rO2 = 2 * Lv2VacBwd_R2;
1177 // Part 3
1178 const int Lv2VacBwd3_num1 = 2; // cylindrical part
1179 const int Lv2VacBwd3_num2 = 3; // policone part
1180 // ----------->Cylindrical part
1181 double Lv2VacBwd_Z1[Lv2VacBwd3_num1];
1182 Lv2VacBwd_Z1[0] = 0.0;
1183 Lv2VacBwd_Z1[1] = -Lv2VacBwd_D3 + Lv2VacBwd_L2 - 0.03 * SafetyLength;
1184 double Lv2VacBwd_rI1[Lv2VacBwd3_num1];
1185 for (int tmpn = 0; tmpn < Lv2VacBwd3_num1; ++tmpn) {
1186 Lv2VacBwd_rI1[tmpn] = 0.0;
1187 }
1188 double Lv2VacBwd_rO1[Lv2VacBwd3_num1];
1189 Lv2VacBwd_rO1[0] = Lv2VacBwd_R3;
1190 Lv2VacBwd_rO1[1] = Lv2VacBwd_R3;
1191 //<----------------
1192 //------------> Policone part
1193 double Lv2VacBwd_Z2[Lv2VacBwd3_num2];
1194 Lv2VacBwd_Z2[0] = -Lv2VacBwd_D3 + Lv2VacBwd_L2;
1195 Lv2VacBwd_Z2[1] = -Lv2VacBwd_D3;
1196 Lv2VacBwd_Z2[2] = -Lv2VacBwd_D3 - Lv2VacBwd_L3;
1197 double Lv2VacBwd_rI2[Lv2VacBwd3_num2];
1198 for (int tmpn = 0; tmpn < Lv2VacBwd3_num2; ++tmpn) {
1199 Lv2VacBwd_rI2[tmpn] = 0.0;
1200 }
1201 double Lv2VacBwd_rO2[Lv2VacBwd3_num2];
1202 Lv2VacBwd_rO2[0] = Lv2VacBwd_R3;
1203 Lv2VacBwd_rO2[1] = Lv2VacBwd_R4;
1204 Lv2VacBwd_rO2[2] = Lv2VacBwd_R4;
1205 //<--------------
1206
1207
1208 // Define geometry
1209 // Part 1
1210 G4Tubs* geo_Lv2VacBwdPart1_1 = new G4Tubs("geo_Lv2VacBwdPart1_1_name", Lv2VacBwd1_rI1, Lv2VacBwd1_rO1, Lv2VacBwd1_Z1, 0, 2 * M_PI);
1211 G4Tubs* geo_Lv2VacBwdPart1_2 = new G4Tubs("geo_Lv2VacBwdPart1_2_name", Lv2VacBwd1_rI2, Lv2VacBwd1_rO2, Lv2VacBwd1_Z2, 0, 2 * M_PI);
1212 G4Transform3D transform_Lv2VacBwdPart1_2 = G4Translate3D(0., 0., 0.);
1213 transform_Lv2VacBwdPart1_2 = transform_Lv2VacBwdPart1_2 * G4RotateY3D(Lv2VacBwd_A2 / 2.);
1214 G4IntersectionSolid* geo_Lv2VacBwdPart1 = new G4IntersectionSolid("geo_Lv2VacBwdPart1_name", geo_Lv2VacBwdPart1_1,
1215 geo_Lv2VacBwdPart1_2, transform_Lv2VacBwdPart1_2);
1216 // Part 2
1217 G4Tubs* geo_Lv2VacBwdPart2_1 = new G4Tubs("geo_Lv2VacBwdPart2_1_name", Lv2VacBwd2_rI1, Lv2VacBwd2_rO1, Lv2VacBwd2_Z1, 0, 2 * M_PI);
1218 G4Tubs* geo_Lv2VacBwdPart2_2 = new G4Tubs("geo_Lv2VacBwdPart2_2_name", Lv2VacBwd2_rI2, Lv2VacBwd2_rO2, Lv2VacBwd2_Z2, 0, 2 * M_PI);
1219 G4Transform3D transform_Lv2VacBwdPart2_2 = G4Translate3D(0., 0., 0.);
1220 transform_Lv2VacBwdPart2_2 = transform_Lv2VacBwdPart2_2 * G4RotateY3D(-Lv2VacBwd_A2 / 2.);
1221 G4IntersectionSolid* geo_Lv2VacBwdPart2 = new G4IntersectionSolid("geo_Lv2VacBwdPart2_name", geo_Lv2VacBwdPart2_1,
1222 geo_Lv2VacBwdPart2_2, transform_Lv2VacBwdPart2_2);
1223 // Part 3
1224// G4Polycone* geo_Lv2VacBwdPart3 = new G4Polycone("geo_Lv2VacBwdPart3", 0, 2 * M_PI, Lv2VacBwd3_num, Lv2VacBwd_Z, Lv2VacBwd_rI, Lv2VacBwd_rO);
1225 G4Polycone* geo_Lv2VacBwdPart3_1 = new G4Polycone("geo_Lv2VacBwdPart3_1", 0, 2 * M_PI, Lv2VacBwd3_num1, Lv2VacBwd_Z1, Lv2VacBwd_rI1,
1226 Lv2VacBwd_rO1);
1227 G4Polycone* geo_Lv2VacBwdPart3_2 = new G4Polycone("geo_Lv2VacBwdPart3_2", 0, 2 * M_PI, Lv2VacBwd3_num2, Lv2VacBwd_Z2, Lv2VacBwd_rI2,
1228 Lv2VacBwd_rO2);
1229 G4Transform3D transform_Lv2VacBwdPart3_1 = G4Translate3D(-0.5, 0., 0.);
1230 transform_Lv2VacBwdPart3_1 = transform_Lv2VacBwdPart3_1 * G4RotateY3D(-Lv2VacBwd_A1 + A11);
1231 G4UnionSolid* geo_Lv2VacBwdPart3 = new G4UnionSolid("geo_Lv2VacBwdPart3_name", geo_Lv2VacBwdPart3_2, geo_Lv2VacBwdPart3_1,
1232 transform_Lv2VacBwdPart3_1);
1233 // Part1+2+3
1234 //tmp begin
1235 G4Transform3D transform_Lv2VacBwdPart1 = G4Translate3D((Lv2VacBwd_D1 * sin(Lv2VacBwd_A1) + Lv2VacBwd_D2 * sin(
1236 2.*Lv2VacBwd_A1)) / 2., 0.,
1237 -(Lv2VacBwd_D1 * cos(Lv2VacBwd_A1) + Lv2VacBwd_D2 * cos(2.*Lv2VacBwd_A1)) / 2.);
1238 //G4Transform3D transform_Lv2VacBwdPart1 = G4Translate3D((Lv2VacBwd_D1 * sin(Lv2VacBwd_A1) + Lv2VacBwd_D2 * sin(2.*Lv2VacBwd_A1)) / 2.05,
1239 // 0.,
1240 // -(Lv2VacBwd_D1 * cos(Lv2VacBwd_A1) + Lv2VacBwd_D2 * cos(2.*Lv2VacBwd_A1)) / 2.05);
1241 transform_Lv2VacBwdPart1 = transform_Lv2VacBwdPart1 * G4RotateY3D(-Lv2VacBwd_A1 - Lv2VacBwd_A2);
1242 //tmp end
1243
1244 G4Transform3D transform_Lv2VacBwdPart2 = G4Translate3D((Lv2VacBwd_D2 + Lv2VacBwd_L1 / 2.0) * sin(2.*Lv2VacBwd_A1), 0.,
1245 -(Lv2VacBwd_D2 + Lv2VacBwd_L1 / 2.0) * cos(2.*Lv2VacBwd_A1));
1246 transform_Lv2VacBwdPart2 = transform_Lv2VacBwdPart2 * G4RotateY3D(-2.*Lv2VacBwd_A1);
1247
1248 G4UnionSolid* geo_Lv2VacBwdxx = new G4UnionSolid("geo_Lv2VacBwdxx_name", geo_Lv2VacBwdPart3, geo_Lv2VacBwdPart1,
1249 transform_Lv2VacBwdPart1);
1250 G4UnionSolid* geo_Lv2VacBwdx = new G4UnionSolid("geo_Lv2VacBwdx_name", geo_Lv2VacBwdxx, geo_Lv2VacBwdPart2,
1251 transform_Lv2VacBwdPart2);
1252 // Intersection
1253 G4Transform3D transform_Lv2VacBwd = G4Translate3D(0., 0., +Lv1TaBwd_D1 + Lv1TaBwd_L1 / 2.);
1254 transform_Lv2VacBwd = transform_Lv2VacBwd * G4RotateY3D(+Lv2VacBwd_A1);
1255
1256 G4IntersectionSolid* geo_Lv2VacBwd = new G4IntersectionSolid("geo_Lv2VacBwd_name", geo_Lv1TaBwd, geo_Lv2VacBwdx,
1257 transform_Lv2VacBwd);
1258 G4LogicalVolume* logi_Lv2VacBwd = new G4LogicalVolume(geo_Lv2VacBwd, mat_Lv2VacBwd, "logi_Lv2VacBwd_name");
1259 if (flag_limitStep) logi_Lv2VacBwd->SetUserLimits(new G4UserLimits(stepMax));
1260
1261 // Put volume
1262 setColor(*logi_Lv2VacBwd, "#CCCCCC");
1263 //you must set this invisible, otherwise encounter segV.
1264 setVisibility(*logi_Lv2VacBwd, false);
1265 new G4PVPlacement(0, G4ThreeVector(0., 0., 0.), logi_Lv2VacBwd, "phys_Lv2VacBwd_name", logi_Lv1TaBwd, false, 0);
1266
1267
1268 //----------
1269 //- Lv2VacLERUp
1270
1271 // Get parameters from .xml file
1272 prep = "Lv2VacLERUp.";
1273
1274 vector<double> Lv2VacLERUp_rO(Lv1TaLERUp_num);
1275 for (int i = 0; i < Lv1TaLERUp_num; ++i) {
1276 Lv2VacLERUp_rO[i] = m_config.getParameter(prep + "R1") * unitFactor;
1277 }
1278
1279 string strMat_Lv2VacLERUp = m_config.getParameterStr(prep + "Material");
1280 G4Material* mat_Lv2VacLERUp = Materials::get(strMat_Lv2VacLERUp);
1281
1282 // Define geometry
1283 G4Polycone* geo_Lv2VacLERUppcon = new G4Polycone("geo_Lv2VacLERUppcon_name", 0, 2 * M_PI, Lv1TaLERUp_num, &(Lv1TaLERUp_Z[0]),
1284 &(Lv1TaLERUp_rI[0]), &(Lv2VacLERUp_rO[0]));
1285 G4IntersectionSolid* geo_Lv2VacLERUp = new G4IntersectionSolid("geo_Lv2VacLERUp_name", geo_Lv2VacLERUppcon, geo_AreaTubeFwdpcon,
1286 transform_AreaTubeFwdForLER);
1287 G4LogicalVolume* logi_Lv2VacLERUp = new G4LogicalVolume(geo_Lv2VacLERUp, mat_Lv2VacLERUp, "logi_Lv2VacLERUp_name");
1288 if (flag_limitStep) logi_Lv2VacLERUp->SetUserLimits(new G4UserLimits(stepMax));
1289
1290
1291 // Put volume
1292 setColor(*logi_Lv2VacLERUp, "#CCCCCC");
1293 new G4PVPlacement(0, G4ThreeVector(0, 0, 0), logi_Lv2VacLERUp, "phys_Lv2VacLERUp_name", logi_Lv1TaLERUp, false, 0);
1294
1295
1296 //----------
1297 //- Lv2VacHERDwn
1298
1299 // Get parameters from .xml file
1300 prep = "Lv2VacHERDwn.";
1301
1302 vector<double> Lv2VacHERDwn_rO(Lv1TaHERDwn_num);
1303 for (int i = 0; i < Lv1TaHERDwn_num; ++i) {
1304 Lv2VacHERDwn_rO[i] = m_config.getParameter(prep + "R1") * unitFactor;
1305 }
1306
1307 string strMat_Lv2VacHERDwn = m_config.getParameterStr(prep + "Material");
1308 G4Material* mat_Lv2VacHERDwn = Materials::get(strMat_Lv2VacHERDwn);
1309
1310 // Define geometry
1311 G4Polycone* geo_Lv2VacHERDwnpcon = new G4Polycone("geo_Lv2VacHERDwnpcon_name", 0, 2 * M_PI, Lv1TaHERDwn_num, &(Lv1TaHERDwn_Z[0]),
1312 &(Lv1TaHERDwn_rI[0]), &(Lv2VacHERDwn_rO[0]));
1313 G4IntersectionSolid* geo_Lv2VacHERDwn = new G4IntersectionSolid("", geo_Lv2VacHERDwnpcon, geo_AreaTubeFwdpcon,
1314 transform_AreaTubeFwdForHER);
1315 G4LogicalVolume* logi_Lv2VacHERDwn = new G4LogicalVolume(geo_Lv2VacHERDwn, mat_Lv2VacHERDwn, "logi_Lv2VacHERDwn_name");
1316 if (flag_limitStep) logi_Lv2VacHERDwn->SetUserLimits(new G4UserLimits(stepMax));
1317
1318 // Put volume
1319 setColor(*logi_Lv2VacHERDwn, "#CCCCCC");
1320 new G4PVPlacement(0, G4ThreeVector(0, 0, 0), logi_Lv2VacHERDwn, "phys_Lv2VacHERDwn_name", logi_Lv1TaHERDwn, false, 0);
1321
1322
1323 //----------
1324 //- Lv2VacHERUp
1325
1326 // Get parameters from .xml file
1327 prep = "Lv2VacHERUp.";
1328
1329 vector<double> Lv2VacHERUp_rO(Lv1TaHERUp_num);
1330 for (int i = 0; i < Lv1TaHERUp_num; ++i) {
1331 Lv2VacHERUp_rO[i] = m_config.getParameter(prep + "R1") * unitFactor;
1332 }
1333
1334 string strMat_Lv2VacHERUp = m_config.getParameterStr(prep + "Material");
1335 G4Material* mat_Lv2VacHERUp = Materials::get(strMat_Lv2VacHERUp);
1336
1337 // Define geometry
1338 G4Polycone* geo_Lv2VacHERUppcon = new G4Polycone("geo_Lv2VacHERUppcon_name", 0, 2 * M_PI, Lv1TaHERUp_num, &(Lv1TaHERUp_Z[0]),
1339 &(Lv1TaHERUp_rI[0]), &(Lv2VacHERUp_rO[0]));
1340 G4IntersectionSolid* geo_Lv2VacHERUp = new G4IntersectionSolid("", geo_Lv2VacHERUppcon, geo_AreaTubeBwdpcon,
1341 transform_AreaTubeFwdForHER);
1342 G4LogicalVolume* logi_Lv2VacHERUp = new G4LogicalVolume(geo_Lv2VacHERUp, mat_Lv2VacHERUp, "logi_Lv2VacHERUp_name");
1343 if (flag_limitStep) logi_Lv2VacHERUp->SetUserLimits(new G4UserLimits(stepMax));
1344
1345 // Put volume
1346 setColor(*logi_Lv2VacHERUp, "#CCCCCC");
1347 new G4PVPlacement(0, G4ThreeVector(0, 0, 0), logi_Lv2VacHERUp, "phys_Lv2VacHERUp_name", logi_Lv1TaHERUp, false, 0);
1348
1349
1350 //----------
1351 //- Lv2VacLERDwn
1352
1353 // Get parameters from .xml file
1354 prep = "Lv2VacLERDwn.";
1355
1356 vector<double> Lv2VacLERDwn_rO(Lv1TaLERDwn_num);
1357 for (int i = 0; i < Lv1TaLERDwn_num; ++i) {
1358 Lv2VacLERDwn_rO[i] = m_config.getParameter(prep + "R1") * unitFactor;
1359 }
1360
1361 string strMat_Lv2VacLERDwn = m_config.getParameterStr(prep + "Material");
1362 G4Material* mat_Lv2VacLERDwn = Materials::get(strMat_Lv2VacLERDwn);
1363
1364 // Define geometry
1365 G4Polycone* geo_Lv2VacLERDwnpcon = new G4Polycone("geo_Lv2VacLERDwnpcon_name", 0, 2 * M_PI, Lv1TaLERDwn_num, &(Lv1TaLERDwn_Z[0]),
1366 &(Lv1TaLERDwn_rI[0]), &(Lv2VacLERDwn_rO[0]));
1367 G4IntersectionSolid* geo_Lv2VacLERDwn = new G4IntersectionSolid("", geo_Lv2VacLERDwnpcon, geo_AreaTubeBwdpcon,
1368 transform_AreaTubeBwdForLER);
1369 G4LogicalVolume* logi_Lv2VacLERDwn = new G4LogicalVolume(geo_Lv2VacLERDwn, mat_Lv2VacLERDwn, "logi_Lv2VacLERDwn_name");
1370 if (flag_limitStep) logi_Lv2VacLERDwn->SetUserLimits(new G4UserLimits(stepMax));
1371
1372 // Put volume
1373 setColor(*logi_Lv2VacLERDwn, "#CCCCCC");
1374 new G4PVPlacement(0, G4ThreeVector(0, 0, 0), logi_Lv2VacLERDwn, "phys_Lv2VacLERDwn_name", logi_Lv1TaLERDwn, false, 0);
1375
1376
1377 //----------
1378 // Cu flange
1379
1380 G4IntersectionSolid* geo_CuFlangeFwd_x2 = new G4IntersectionSolid("geo_CuFlangeFwd_x2_name", geo_AreaTubeFwdpcon, geo_Flange,
1381 G4Translate3D(0, 0, Flange_D + Flange_T * 2));
1382 G4SubtractionSolid* geo_CuFlangeFwd_x = new G4SubtractionSolid("geo_CuFlangeFwd_x_name", geo_CuFlangeFwd_x2, geo_Lv1TaLERUp,
1383 transform_Lv1TaLERUp);
1384 G4SubtractionSolid* geo_CuFlangeFwd = new G4SubtractionSolid("geo_CuFlangeFwd_name", geo_CuFlangeFwd_x, geo_Lv1TaHERDwn,
1385 transform_Lv1TaHERDwn);
1386
1387 G4LogicalVolume* logi_CuFlangeFwd = new G4LogicalVolume(geo_CuFlangeFwd, mat_Lv1TaLERUp, "logi_CuFlangeFwd_name");
1388
1389 // Put volume
1390 setColor(*logi_CuFlangeFwd, "#CCCCCC");
1391 new G4PVPlacement(0, G4ThreeVector(0, 0, 0), logi_CuFlangeFwd, "phys_CuFlangeFwd_name", &topVolume, false, 0);
1392
1393
1394
1395
1396 G4IntersectionSolid* geo_CuFlangeBwd_x2 = new G4IntersectionSolid("geo_CuFlangeBwd_x2_name", geo_AreaTubeBwdpcon, geo_Flange,
1397 G4Translate3D(0, 0, -Flange_D - Flange_T * 2));
1398 G4SubtractionSolid* geo_CuFlangeBwd_x = new G4SubtractionSolid("geo_CuFlangeBwd_x_name", geo_CuFlangeBwd_x2, geo_Lv1TaHERUp,
1399 transform_Lv1TaHERUp);
1400 G4SubtractionSolid* geo_CuFlangeBwd = new G4SubtractionSolid("geo_CuFlangeBwd_name", geo_CuFlangeBwd_x, geo_Lv1TaLERDwn,
1401 transform_Lv1TaLERDwn);
1402
1403 G4LogicalVolume* logi_CuFlangeBwd = new G4LogicalVolume(geo_CuFlangeBwd, mat_Lv1TaLERUp, "logi_CuFlangeBwd_name");
1404
1405 // Put volume
1406 setColor(*logi_CuFlangeBwd, "#CCCCCC");
1407 new G4PVPlacement(0, G4ThreeVector(0, 0, 0), logi_CuFlangeBwd, "phys_CuFlangeBwd_name", &topVolume, false, 0);
1408
1409
1410 // Components installed after Phase 2
1411 if (!phase2) {
1412 //- Lv2OutTi
1413 // Get parameters from .xml file
1414 prep = "Lv2OutTi.";
1415
1416 const int Lv2OutTi_num = 2;
1417
1418 double Lv2OutTi_Z[Lv2OutTi_num];
1419 Lv2OutTi_Z[0] = m_config.getParameter(prep + "L1") * unitFactor;
1420 Lv2OutTi_Z[1] = m_config.getParameter(prep + "L2") * unitFactor;
1421
1422 double Lv2OutTi_rI[Lv2OutTi_num];
1423 Lv2OutTi_rI[0] = m_config.getParameter(prep + "R1") * unitFactor;
1424 Lv2OutTi_rI[1] = Lv2OutTi_rI[0];
1425
1426 double Lv2OutTi_rO[Lv2OutTi_num];
1427 Lv2OutTi_rO[0] = m_config.getParameter(prep + "R2") * unitFactor;
1428 Lv2OutTi_rO[1] = Lv2OutTi_rO[0];
1429
1430 string strMat_Lv2OutTi = m_config.getParameterStr(prep + "Material");
1431 G4Material* mat_Lv2OutTi = Materials::get(strMat_Lv2OutTi);
1432
1433 // Define geometry
1434 G4Polycone* geo_Lv2OutTi = new G4Polycone("geo_Lv2OutTi_name", 0, 2 * M_PI, Lv2OutTi_num, Lv2OutTi_Z, Lv2OutTi_rI, Lv2OutTi_rO);
1435 G4LogicalVolume* logi_Lv2OutTi = new G4LogicalVolume(geo_Lv2OutTi, mat_Lv2OutTi, "logi_Lv2OutTi_name");
1436
1437 // Put volume
1438 setColor(*logi_Lv2OutTi, "#333300");
1439 new G4PVPlacement(0, G4ThreeVector(0, 0, 0), logi_Lv2OutTi, "phys_Lv2OutTi_name", logi_Lv1SUS, false, 0);
1440
1441
1442 //----------
1443 //-Lv1SUSLERUp
1444 prep = "Lv1SUSLERUp.";
1445 int Lv1SUSLERUp_num = int(m_config.getParameter(prep + "N"));
1446 vector<double> Lv1SUSLERUp_Z(Lv1SUSLERUp_num);
1447 vector<double> Lv1SUSLERUp_rI(Lv1SUSLERUp_num);
1448 vector<double> Lv1SUSLERUp_rO(Lv1SUSLERUp_num);
1449
1450 for (int i = 0; i < Lv1SUSLERUp_num; ++i) {
1451 ostringstream ossZ_Lv1SUSLERUp;
1452 ossZ_Lv1SUSLERUp << "Z" << i;
1453 ostringstream ossRI_Lv1SUSLERUp;
1454 ossRI_Lv1SUSLERUp << "RI" << i;
1455 ostringstream ossRO_Lv1SUSLERUp;
1456 ossRO_Lv1SUSLERUp << "RO" << i;
1457
1458 Lv1SUSLERUp_Z[i] = m_config.getParameter(prep + ossZ_Lv1SUSLERUp.str()) * unitFactor;
1459 Lv1SUSLERUp_rI[i] = m_config.getParameter(prep + ossRI_Lv1SUSLERUp.str()) * unitFactor;
1460 Lv1SUSLERUp_rO[i] = m_config.getParameter(prep + ossRO_Lv1SUSLERUp.str()) * unitFactor;
1461 }
1462
1463 string strMat_Lv1SUSLERUp = m_config.getParameterStr(prep + "Material");
1464 G4Material* mat_Lv1SUSLERUp = Materials::get(strMat_Lv1SUSLERUp);
1465
1466 G4Polycone* geo_Lv1SUSLERUppcon = new G4Polycone("geo_Lv1SUSLERUppcon_name", 0, 2 * M_PI, Lv1SUSLERUp_num, &(Lv1SUSLERUp_Z[0]),
1467 &(Lv1SUSLERUp_rI[0]), &(Lv1SUSLERUp_rO[0]));
1468 G4IntersectionSolid* geo_Lv1SUSLERUp = new G4IntersectionSolid("", geo_Lv1SUSLERUppcon, geo_AreaTubeFwdpcon,
1469 transform_AreaTubeFwdForLER);
1470 G4LogicalVolume* logi_Lv1SUSLERUp = new G4LogicalVolume(geo_Lv1SUSLERUp, mat_Lv1SUSLERUp, "logi_Lv1SUSLERUp_name");
1471
1472 //-put volume
1473 setColor(*logi_Lv1SUSLERUp, "#666666");
1474 new G4PVPlacement(transform_Lv1TaLERUp, logi_Lv1SUSLERUp, "phys_Lv1SUSLERUp_name", &topVolume, false, 0);
1475
1476
1477 //----------
1478 //-Lv1SUSHERDwn
1479 prep = "Lv1SUSHERDwn.";
1480 int Lv1SUSHERDwn_num = int(m_config.getParameter(prep + "N"));
1481 vector<double> Lv1SUSHERDwn_Z(Lv1SUSHERDwn_num);
1482 vector<double> Lv1SUSHERDwn_rI(Lv1SUSHERDwn_num);
1483 vector<double> Lv1SUSHERDwn_rO(Lv1SUSHERDwn_num);
1484
1485 for (int i = 0; i < Lv1SUSHERDwn_num; ++i) {
1486 ostringstream ossZ_Lv1SUSHERDwn;
1487 ossZ_Lv1SUSHERDwn << "Z" << i;
1488 ostringstream ossRI_Lv1SUSHERDwn;
1489 ossRI_Lv1SUSHERDwn << "RI" << i;
1490 ostringstream ossRO_Lv1SUSHERDwn;
1491 ossRO_Lv1SUSHERDwn << "RO" << i;
1492
1493 Lv1SUSHERDwn_Z[i] = m_config.getParameter(prep + ossZ_Lv1SUSHERDwn.str()) * unitFactor;
1494 Lv1SUSHERDwn_rI[i] = m_config.getParameter(prep + ossRI_Lv1SUSHERDwn.str()) * unitFactor;
1495 Lv1SUSHERDwn_rO[i] = m_config.getParameter(prep + ossRO_Lv1SUSHERDwn.str()) * unitFactor;
1496 }
1497
1498 string strMat_Lv1SUSHERDwn = m_config.getParameterStr(prep + "Material");
1499 G4Material* mat_Lv1SUSHERDwn = Materials::get(strMat_Lv1SUSHERDwn);
1500 //G4Material* mat_Lv1SUSHERDwn = mat_Lv1SUS;
1501
1502 G4Polycone* geo_Lv1SUSHERDwnpcon = new G4Polycone("geo_Lv1SUSHERDwnpcon_name", 0, 2 * M_PI, Lv1SUSHERDwn_num, &(Lv1SUSHERDwn_Z[0]),
1503 &(Lv1SUSHERDwn_rI[0]), &(Lv1SUSHERDwn_rO[0]));
1504 G4IntersectionSolid* geo_Lv1SUSHERDwn = new G4IntersectionSolid("", geo_Lv1SUSHERDwnpcon, geo_AreaTubeFwdpcon,
1505 transform_AreaTubeFwdForHER);
1506 G4LogicalVolume* logi_Lv1SUSHERDwn = new G4LogicalVolume(geo_Lv1SUSHERDwn, mat_Lv1SUSHERDwn, "logi_Lv1SUSHERDwn_name");
1507
1508 //-put volume
1509 setColor(*logi_Lv1SUSHERDwn, "#666666");
1510 new G4PVPlacement(transform_Lv1TaHERDwn, logi_Lv1SUSHERDwn, "phys_Lv1SUSHERDwn_name", &topVolume, false, 0);
1511
1512
1513 //----------
1514 //-Lv1SUSHERUp
1515 prep = "Lv1SUSHERUp.";
1516 int Lv1SUSHERUp_num = int(m_config.getParameter(prep + "N"));
1517 vector<double> Lv1SUSHERUp_Z(Lv1SUSHERUp_num);
1518 vector<double> Lv1SUSHERUp_rI(Lv1SUSHERUp_num);
1519 vector<double> Lv1SUSHERUp_rO(Lv1SUSHERUp_num);
1520
1521 for (int i = 0; i < Lv1SUSHERUp_num; ++i) {
1522 ostringstream ossZ_Lv1SUSHERUp;
1523 ossZ_Lv1SUSHERUp << "Z" << i;
1524 ostringstream ossRI_Lv1SUSHERUp;
1525 ossRI_Lv1SUSHERUp << "RI" << i;
1526 ostringstream ossRO_Lv1SUSHERUp;
1527 ossRO_Lv1SUSHERUp << "RO" << i;
1528
1529 Lv1SUSHERUp_Z[i] = m_config.getParameter(prep + ossZ_Lv1SUSHERUp.str()) * unitFactor;
1530 Lv1SUSHERUp_rI[i] = m_config.getParameter(prep + ossRI_Lv1SUSHERUp.str()) * unitFactor;
1531 Lv1SUSHERUp_rO[i] = m_config.getParameter(prep + ossRO_Lv1SUSHERUp.str()) * unitFactor;
1532 }
1533
1534 string strMat_Lv1SUSHERUp = m_config.getParameterStr(prep + "Material");
1535 G4Material* mat_Lv1SUSHERUp = Materials::get(strMat_Lv1SUSHERUp);
1536
1537 G4Polycone* geo_Lv1SUSHERUppcon = new G4Polycone("geo_Lv1SUSHERUppcon_name", 0, 2 * M_PI, Lv1SUSHERUp_num, &(Lv1SUSHERUp_Z[0]),
1538 &(Lv1SUSHERUp_rI[0]), &(Lv1SUSHERUp_rO[0]));
1539 G4IntersectionSolid* geo_Lv1SUSHERUp = new G4IntersectionSolid("", geo_Lv1SUSHERUppcon, geo_AreaTubeBwdpcon,
1540 transform_AreaTubeFwdForHER);
1541 G4LogicalVolume* logi_Lv1SUSHERUp = new G4LogicalVolume(geo_Lv1SUSHERUp, mat_Lv1SUSHERUp, "logi_Lv1SUSHERUp_name");
1542
1543 //-put volume
1544 setColor(*logi_Lv1SUSHERUp, "#666666");
1545 new G4PVPlacement(transform_Lv1TaHERUp, logi_Lv1SUSHERUp, "phys_Lv1SUSHERUp_name", &topVolume, false, 0);
1546
1547
1548 //----------
1549 //-Lv1SUSLERDwn
1550 prep = "Lv1SUSLERDwn.";
1551 int Lv1SUSLERDwn_num = int(m_config.getParameter(prep + "N"));
1552 vector<double> Lv1SUSLERDwn_Z(Lv1SUSLERDwn_num);
1553 vector<double> Lv1SUSLERDwn_rI(Lv1SUSLERDwn_num);
1554 vector<double> Lv1SUSLERDwn_rO(Lv1SUSLERDwn_num);
1555
1556 for (int i = 0; i < Lv1SUSLERDwn_num; ++i) {
1557 ostringstream ossZ_Lv1SUSLERDwn;
1558 ossZ_Lv1SUSLERDwn << "Z" << i;
1559 ostringstream ossRI_Lv1SUSLERDwn;
1560 ossRI_Lv1SUSLERDwn << "RI" << i;
1561 ostringstream ossRO_Lv1SUSLERDwn;
1562 ossRO_Lv1SUSLERDwn << "RO" << i;
1563
1564 Lv1SUSLERDwn_Z[i] = m_config.getParameter(prep + ossZ_Lv1SUSLERDwn.str()) * unitFactor;
1565 Lv1SUSLERDwn_rI[i] = m_config.getParameter(prep + ossRI_Lv1SUSLERDwn.str()) * unitFactor;
1566 Lv1SUSLERDwn_rO[i] = m_config.getParameter(prep + ossRO_Lv1SUSLERDwn.str()) * unitFactor;
1567 }
1568
1569 string strMat_Lv1SUSLERDwn = m_config.getParameterStr(prep + "Material");
1570 G4Material* mat_Lv1SUSLERDwn = Materials::get(strMat_Lv1SUSLERDwn);
1571
1572 G4Polycone* geo_Lv1SUSLERDwnpcon = new G4Polycone("geo_Lv1SUSLERDwnpcon_name", 0, 2 * M_PI, Lv1SUSLERDwn_num, &(Lv1SUSLERDwn_Z[0]),
1573 &(Lv1SUSLERDwn_rI[0]), &(Lv1SUSLERDwn_rO[0]));
1574 G4IntersectionSolid* geo_Lv1SUSLERDwn = new G4IntersectionSolid("", geo_Lv1SUSLERDwnpcon, geo_AreaTubeBwdpcon,
1575 transform_AreaTubeFwdForHER);
1576 G4LogicalVolume* logi_Lv1SUSLERDwn = new G4LogicalVolume(geo_Lv1SUSLERDwn, mat_Lv1SUSLERDwn, "logi_Lv1SUSLERDwn_name");
1577
1578 //-put volume
1579 setColor(*logi_Lv1SUSLERDwn, "#666666");
1580 new G4PVPlacement(transform_Lv1TaLERDwn, logi_Lv1SUSLERDwn, "phys_Lv1SUSLERDwn_name", &topVolume, false, 0);
1581
1582
1585
1586 //----------
1587 //- PXDMountFwd
1588
1589 // Get parameters from .xml file
1590 prep = "PXDMountFwd.";
1591
1592 double PXDMountFwd_Z1 = m_config.getParameter(prep + "Z1") * unitFactor;
1593 double PXDMountFwd_R1 = m_config.getParameter(prep + "R1") * unitFactor;
1594 double PXDMountFwd_D1 = m_config.getParameter(prep + "D1") * unitFactor;
1595 double PXDMountFwd_R2 = m_config.getParameter(prep + "R2") * unitFactor;
1596 double PXDMountFwd_L1 = m_config.getParameter(prep + "L1") * unitFactor;
1597 double PXDMountFwd_L2 = m_config.getParameter(prep + "L2") * unitFactor;
1598
1599 string strMat_PXDMountFwd = m_config.getParameterStr(prep + "Material");
1600 G4Material* mat_PXDMountFwd = Materials::get(strMat_PXDMountFwd);
1601
1602 // Define geometry
1603 G4VSolid* geo_PXDMountFwd_a = new G4Tubs("geo_PXDMountFwd_a", 0, PXDMountFwd_R1, PXDMountFwd_D1 / 2, 0, 2 * M_PI);
1604 G4VSolid* geo_PXDMountFwd_b = new G4SubtractionSolid("geo_PXDMountFwd_b", geo_PXDMountFwd_a, geo_Lv1TaFwd_d, G4Translate3D(0., 0.,
1605 -(-Lv1TaFwd_L1 / 2.0 + Lv1TaFwd_aL1 + Lv1TaFwd_aL2 + Lv1TaFwd_aL3) + PXDMountFwd_D1 / 2));
1606 G4VSolid* geo_PXDMountFwd_c = new G4Tubs("geo_PXDMountFwd_c", 0, PXDMountFwd_R2, 100, 0, 2 * M_PI);
1607 G4VSolid* geo_PXDMountFwd_d = new G4Box("geo_PXDMountFwd_d", PXDMountFwd_R1 - PXDMountFwd_L1, 100, PXDMountFwd_R2);
1608
1609 G4VSolid* geo_PXDMountFwd_p1 = new G4SubtractionSolid("geo_PXDMountFwd_p1", geo_PXDMountFwd_b, geo_PXDMountFwd_c,
1610 G4Translate3D(+PXDMountFwd_L1, 0., +(PXDMountFwd_D1 / 2 - PXDMountFwd_L2))*G4RotateX3D(M_PI / 2));
1611 G4VSolid* geo_PXDMountFwd_p2 = new G4SubtractionSolid("geo_PXDMountFwd_p2", geo_PXDMountFwd_p1, geo_PXDMountFwd_c,
1612 G4Translate3D(+PXDMountFwd_L1, 0., -(PXDMountFwd_D1 / 2 - PXDMountFwd_L2))*G4RotateX3D(M_PI / 2));
1613 G4VSolid* geo_PXDMountFwd_p3 = new G4SubtractionSolid("geo_PXDMountFwd_p3", geo_PXDMountFwd_p2, geo_PXDMountFwd_c,
1614 G4Translate3D(-PXDMountFwd_L1, 0., +(PXDMountFwd_D1 / 2 - PXDMountFwd_L2))*G4RotateX3D(M_PI / 2));
1615 G4VSolid* geo_PXDMountFwd_p4 = new G4SubtractionSolid("geo_PXDMountFwd_p4", geo_PXDMountFwd_p3, geo_PXDMountFwd_c,
1616 G4Translate3D(-PXDMountFwd_L1, 0., -(PXDMountFwd_D1 / 2 - PXDMountFwd_L2))*G4RotateX3D(M_PI / 2));
1617
1618 G4VSolid* geo_PXDMountFwd_q1 = new G4SubtractionSolid("geo_PXDMountFwd_q1", geo_PXDMountFwd_p4, geo_PXDMountFwd_d,
1619 G4Translate3D(+PXDMountFwd_R1, 0., +(PXDMountFwd_D1 / 2 - PXDMountFwd_L2)));
1620 G4VSolid* geo_PXDMountFwd_q2 = new G4SubtractionSolid("geo_PXDMountFwd_q2", geo_PXDMountFwd_q1, geo_PXDMountFwd_d,
1621 G4Translate3D(+PXDMountFwd_R1, 0., -(PXDMountFwd_D1 / 2 - PXDMountFwd_L2)));
1622 G4VSolid* geo_PXDMountFwd_q3 = new G4SubtractionSolid("geo_PXDMountFwd_q3", geo_PXDMountFwd_q2, geo_PXDMountFwd_d,
1623 G4Translate3D(-PXDMountFwd_R1, 0., +(PXDMountFwd_D1 / 2 - PXDMountFwd_L2)));
1624 G4VSolid* geo_PXDMountFwd_q4 = new G4SubtractionSolid("geo_PXDMountFwd_q4", geo_PXDMountFwd_q3, geo_PXDMountFwd_d,
1625 G4Translate3D(-PXDMountFwd_R1, 0., -(PXDMountFwd_D1 / 2 - PXDMountFwd_L2)));
1626
1627 G4VSolid* geo_PXDMountFwd = geo_PXDMountFwd_q4;
1628
1629 G4LogicalVolume* logi_PXDMountFwd = new G4LogicalVolume(geo_PXDMountFwd, mat_PXDMountFwd, "logi_PXDMountFwd_name");
1630 setColor(*logi_PXDMountFwd, "#333333");
1631
1632 new G4PVPlacement(0, G4ThreeVector(0, 0, +PXDMountFwd_D1 / 2 + PXDMountFwd_Z1), logi_PXDMountFwd, "phys_PXDMountFwd_name",
1633 &topVolume, false, 0);
1634
1635
1636 //adding the screws
1637 double PXDMountFixture_screw_radius = 0.2 * unitFactor;
1638 double PXDMountFixture_screw_length = 0.5 * unitFactor; //half z
1639 G4VSolid* geo_PXDMountFwd_s1 = new G4Tubs("geo_PXDMountFwd_s1", 0, PXDMountFixture_screw_radius, PXDMountFixture_screw_length, 0,
1640 2 * M_PI);
1641 G4VSolid* geo_PXDMountFwd_s2 = new G4Tubs("geo_PXDMountFwd_s2", 0, PXDMountFixture_screw_radius, PXDMountFixture_screw_length, 0,
1642 2 * M_PI);
1643 G4VSolid* geo_PXDMountFwd_s3 = new G4Tubs("geo_PXDMountFwd_s3", 0, PXDMountFixture_screw_radius, PXDMountFixture_screw_length, 0,
1644 2 * M_PI);
1645 G4VSolid* geo_PXDMountFwd_s4 = new G4Tubs("geo_PXDMountFwd_s4", 0, PXDMountFixture_screw_radius, PXDMountFixture_screw_length, 0,
1646 2 * M_PI);
1647
1648 G4Material* mat_PXDMountFwd_s = Materials::get("Cu");
1649
1650 G4Rotate3D rotate_PXDMountFwd = G4RotateX3D(-M_PI / 2.0 / Unit::rad);
1651 G4Transform3D transform_PXDMountFwd_s1 = G4Translate3D(+PXDMountFwd_L1, 0,
1652 PXDMountFwd_Z1 + PXDMountFwd_D1 - PXDMountFwd_L2) * rotate_PXDMountFwd;
1653 G4Transform3D transform_PXDMountFwd_s2 = G4Translate3D(+PXDMountFwd_L1, 0, PXDMountFwd_Z1 + PXDMountFwd_L2) * rotate_PXDMountFwd;
1654 G4Transform3D transform_PXDMountFwd_s3 = G4Translate3D(-PXDMountFwd_L1, 0,
1655 PXDMountFwd_Z1 + PXDMountFwd_D1 - PXDMountFwd_L2) * rotate_PXDMountFwd;
1656 G4Transform3D transform_PXDMountFwd_s4 = G4Translate3D(-PXDMountFwd_L1, 0, PXDMountFwd_Z1 + PXDMountFwd_L2) * rotate_PXDMountFwd;
1657
1658 G4LogicalVolume* logi_PXDMountFwd_s1 = new G4LogicalVolume(geo_PXDMountFwd_s1, mat_PXDMountFwd_s, "logi_PXDMountFwd_name_s1");
1659 G4LogicalVolume* logi_PXDMountFwd_s2 = new G4LogicalVolume(geo_PXDMountFwd_s2, mat_PXDMountFwd_s, "logi_PXDMountFwd_name_s2");
1660 G4LogicalVolume* logi_PXDMountFwd_s3 = new G4LogicalVolume(geo_PXDMountFwd_s3, mat_PXDMountFwd_s, "logi_PXDMountFwd_name_s3");
1661 G4LogicalVolume* logi_PXDMountFwd_s4 = new G4LogicalVolume(geo_PXDMountFwd_s4, mat_PXDMountFwd_s, "logi_PXDMountFwd_name_s4");
1662
1663 new G4PVPlacement(transform_PXDMountFwd_s1, logi_PXDMountFwd_s1, "phys_PXDMountFwd_name_s1", &topVolume, false, 0);
1664 new G4PVPlacement(transform_PXDMountFwd_s2, logi_PXDMountFwd_s2, "phys_PXDMountFwd_name_s2", &topVolume, false, 0);
1665 new G4PVPlacement(transform_PXDMountFwd_s3, logi_PXDMountFwd_s3, "phys_PXDMountFwd_name_s3", &topVolume, false, 0);
1666 new G4PVPlacement(transform_PXDMountFwd_s4, logi_PXDMountFwd_s4, "phys_PXDMountFwd_name_s4", &topVolume, false, 0);
1667
1668
1669 //----------
1670 //- PXDMountFixtureFwd
1671 prep = "PXDMountFixtureFwd.";
1672
1673 double PXDMountFixtureFwd_Z1 = m_config.getParameter(prep + "Z1") * unitFactor;
1674 double PXDMountFixtureFwd_R1 = m_config.getParameter(prep + "R1") * unitFactor;
1675 double PXDMountFixtureFwd_D1 = m_config.getParameter(prep + "D1") * unitFactor;
1676 double PXDMountFixtureFwd_T1 = m_config.getParameter(prep + "T1") * unitFactor;
1677 double PXDMountFixtureFwd_T2 = m_config.getParameter(prep + "T2") * unitFactor;
1678 double PXDMountFixtureFwd_FL = m_config.getParameter(prep + "I1") * unitFactor;
1679 double PXDMountFixtureFwd_inner_cut_phi = PXDMountFixtureFwd_FL / (PXDMountFwd_R1 + PXDMountFixtureFwd_T1);
1680 double PXDMountFixtureFwd_outter_uni_phi = (1 / 6.0) * M_PI - PXDMountFixtureFwd_FL / PXDMountFixtureFwd_R1;
1681
1682 string strMat_PXDMountFixtureFwd = m_config.getParameterStr(prep + "Material");
1683 G4Material* mat_PXDMountFixtureFwd = Materials::get(strMat_PXDMountFixtureFwd);
1684
1685 // Define geometry
1686 G4VSolid* geo_PXDMountFixtureFwd_a = new G4Tubs("geo_PXDMountFixtureFwd_a", 0, PXDMountFixtureFwd_R1 - PXDMountFixtureFwd_T2,
1687 PXDMountFixtureFwd_D1 / 2, 0,
1688 2 * M_PI);
1689 G4VSolid* geo_PXDMountFixtureFwd_b = new G4Box("geo_PXDMountFixtureFwd_b", PXDMountFixtureFwd_R1 * 0.5, 0.1 * unitFactor,
1690 100);
1691
1692 G4VSolid* geo_PXDMountFixtureFwd_b1 = new G4Box("geo_PXDMountFixtureFwd_b1", PXDMountFwd_R1 + PXDMountFixtureFwd_T1,
1693 PXDMountFixtureFwd_FL * 0.5, 100);
1694 G4VSolid* geo_PXDMountFixtureFwd_b2 = new G4Tubs("geo_PXDMountFixtureFwd_b2", PXDMountFwd_R1 + PXDMountFixtureFwd_T1,
1695 PXDMountFixtureFwd_R1, PXDMountFixtureFwd_D1 / 2,
1696 0, PXDMountFixtureFwd_outter_uni_phi);
1697 G4VSolid* geo_PXDMountFixtureFwd_b3 = new G4Box("geo_PXDMountFixtureFwd_b3", 0.2 * unitFactor, 0.35 * unitFactor,
1698 100 * unitFactor);
1699
1700 G4VSolid* geo_PXDMountFixtureFwd_a1 = new G4Tubs("geo_PXDMountFixtureFwd_a1", 0, PXDMountFwd_R1, 100, 0, 2 * M_PI);
1701
1702 G4VSolid* geo_PXDMountFixtureFwd_c1 = new G4SubtractionSolid("geo_PXDMountFixtureFwd_c1", geo_PXDMountFixtureFwd_a,
1703 geo_PXDMountFixtureFwd_a1);
1704
1705
1706 G4VSolid* geo_PXDMountFixtureFwd_d1 = geo_PXDMountFixtureFwd_c1;
1707 for (int i = 0; i < 4; ++i) {
1708
1709 geo_PXDMountFixtureFwd_d1 = new G4SubtractionSolid("geo_PXDMountFixtureFwd_d1", geo_PXDMountFixtureFwd_d1,
1710 geo_PXDMountFixtureFwd_b1, G4RotateZ3D(i * 0.25 * M_PI));
1711 }
1712 geo_PXDMountFixtureFwd_d1 = new G4SubtractionSolid("geo_PXDMountFixtureFwd_d1", geo_PXDMountFixtureFwd_d1,
1713 geo_PXDMountFixtureFwd_b, G4Translate3D(PXDMountFixtureFwd_R1, - PXDMountFixtureFwd_FL * 0.5, 0));
1714 geo_PXDMountFixtureFwd_d1 = new G4SubtractionSolid("geo_PXDMountFixtureFwd_d1", geo_PXDMountFixtureFwd_d1,
1715 geo_PXDMountFixtureFwd_b, G4Translate3D(-PXDMountFixtureFwd_R1, PXDMountFixtureFwd_FL * 0.5, 0));
1716
1717
1718 double PXDMountFixtureFwd_R1_temp = PXDMountFixtureFwd_R1 - PXDMountFixtureFwd_T2;
1719 for (int i = 2; i < 7; i += 4) {
1720
1721 geo_PXDMountFixtureFwd_d1 = new G4SubtractionSolid("geo_PXDMountFixtureFwd_d1", geo_PXDMountFixtureFwd_d1,
1722 geo_PXDMountFixtureFwd_b3,
1723 G4Translate3D(PXDMountFixtureFwd_R1_temp * cos(i * 0.25 * M_PI - 0.5 * PXDMountFixtureFwd_inner_cut_phi),
1724 PXDMountFixtureFwd_R1_temp * sin(i * 0.25 * M_PI - 0.5 * PXDMountFixtureFwd_inner_cut_phi),
1725 0)*G4RotateZ3D(i * 0.25 * M_PI - 0.5 * PXDMountFixtureFwd_inner_cut_phi));
1726
1727 geo_PXDMountFixtureFwd_d1 = new G4SubtractionSolid("geo_PXDMountFixtureFwd_d1", geo_PXDMountFixtureFwd_d1,
1728 geo_PXDMountFixtureFwd_b3,
1729 G4Translate3D(PXDMountFixtureFwd_R1_temp * cos(i * 0.25 * M_PI + 0.5 * PXDMountFixtureFwd_inner_cut_phi),
1730 PXDMountFixtureFwd_R1_temp * sin(i * 0.25 * M_PI + 0.5 * PXDMountFixtureFwd_inner_cut_phi),
1731 0)*G4RotateZ3D(i * 0.25 * M_PI + 0.5 * PXDMountFixtureFwd_inner_cut_phi));
1732
1733 }
1734 G4VSolid* geo_PXDMountFixtureFwd_d2 = geo_PXDMountFixtureFwd_d1;
1735 for (int i = 0; i < 12; ++i) {
1736 if (i == 2 || i == 3 || i == 8 || i == 9) continue;
1737 geo_PXDMountFixtureFwd_d2 = new G4UnionSolid("geo_PXDMountFixtureFwd_d1", geo_PXDMountFixtureFwd_d2,
1738 geo_PXDMountFixtureFwd_b2, G4RotateZ3D(i * (1 / 6.0) * M_PI + ((1 / 12.0)*M_PI - 0.5 * PXDMountFixtureFwd_outter_uni_phi)));
1739
1740 }
1741
1742 G4VSolid* geo_PXDMountFixtureFwd = geo_PXDMountFixtureFwd_d2;
1743 G4LogicalVolume* logi_PXDMountFixtureFwd = new G4LogicalVolume(geo_PXDMountFixtureFwd, mat_PXDMountFixtureFwd,
1744 "logi_PXDMountFixtureFwd_name");
1745 setColor(*logi_PXDMountFixtureFwd, "#333333");
1746
1747 new G4PVPlacement(0, G4ThreeVector(0, 0, +PXDMountFixtureFwd_D1 / 2 + PXDMountFixtureFwd_Z1), logi_PXDMountFixtureFwd,
1748 "phys_PXDMountFixtureFwd_name",
1749 &topVolume, false, 0);
1750
1751 //----------
1752 //- PXDMountBwd
1753
1754 // Get parameters from .xml file
1755 prep = "PXDMountBwd.";
1756
1757 double PXDMountBwd_Z1 = m_config.getParameter(prep + "Z1") * unitFactor;
1758 double PXDMountBwd_R1 = m_config.getParameter(prep + "R1") * unitFactor;
1759 double PXDMountBwd_D1 = m_config.getParameter(prep + "D1") * unitFactor;
1760 double PXDMountBwd_R2 = m_config.getParameter(prep + "R2") * unitFactor;
1761 double PXDMountBwd_L1 = m_config.getParameter(prep + "L1") * unitFactor;
1762 double PXDMountBwd_L2 = m_config.getParameter(prep + "L2") * unitFactor;
1763
1764 string strMat_PXDMountBwd = m_config.getParameterStr(prep + "Material");
1765 G4Material* mat_PXDMountBwd = Materials::get(strMat_PXDMountBwd);
1766
1767 // Define geometry
1768 G4VSolid* geo_PXDMountBwd_a = new G4Tubs("geo_PXDMountBwd_a", 0, PXDMountBwd_R1, PXDMountBwd_D1 / 2, 0, 2 * M_PI);
1769 G4VSolid* geo_PXDMountBwd_b = new G4SubtractionSolid("geo_PXDMountBwd_b", geo_PXDMountBwd_a, geo_Lv1TaBwd_d, G4Translate3D(0., 0.,
1770 -(+Lv1TaBwd_L1 / 2.0 - (Lv1TaBwd_aL1 + Lv1TaBwd_aL2 + Lv1TaBwd_aL3)) - PXDMountBwd_D1 / 2));
1771 G4VSolid* geo_PXDMountBwd_c = new G4Tubs("geo_PXDMountBwd_c", 0, PXDMountBwd_R2, 100, 0, 2 * M_PI);
1772 G4VSolid* geo_PXDMountBwd_d = new G4Box("geo_PXDMountBwd_d", PXDMountBwd_R1 - PXDMountBwd_L1, 100, PXDMountBwd_R2);
1773
1774 G4VSolid* geo_PXDMountBwd_p1 = new G4SubtractionSolid("geo_PXDMountBwd_p1", geo_PXDMountBwd_b, geo_PXDMountBwd_c,
1775 G4Translate3D(+PXDMountBwd_L1, 0., +(PXDMountBwd_D1 / 2 - PXDMountBwd_L2))*G4RotateX3D(M_PI / 2));
1776 G4VSolid* geo_PXDMountBwd_p2 = new G4SubtractionSolid("geo_PXDMountBwd_p2", geo_PXDMountBwd_p1, geo_PXDMountBwd_c,
1777 G4Translate3D(+PXDMountBwd_L1, 0., -(PXDMountBwd_D1 / 2 - PXDMountBwd_L2))*G4RotateX3D(M_PI / 2));
1778 G4VSolid* geo_PXDMountBwd_p3 = new G4SubtractionSolid("geo_PXDMountBwd_p3", geo_PXDMountBwd_p2, geo_PXDMountBwd_c,
1779 G4Translate3D(-PXDMountBwd_L1, 0., +(PXDMountBwd_D1 / 2 - PXDMountBwd_L2))*G4RotateX3D(M_PI / 2));
1780 G4VSolid* geo_PXDMountBwd_p4 = new G4SubtractionSolid("geo_PXDMountBwd_p4", geo_PXDMountBwd_p3, geo_PXDMountBwd_c,
1781 G4Translate3D(-PXDMountBwd_L1, 0., -(PXDMountBwd_D1 / 2 - PXDMountBwd_L2))*G4RotateX3D(M_PI / 2));
1782
1783 G4VSolid* geo_PXDMountBwd_q1 = new G4SubtractionSolid("geo_PXDMountBwd_q1", geo_PXDMountBwd_p4, geo_PXDMountBwd_d,
1784 G4Translate3D(+PXDMountBwd_R1, 0., +(PXDMountBwd_D1 / 2 - PXDMountBwd_L2)));
1785 G4VSolid* geo_PXDMountBwd_q2 = new G4SubtractionSolid("geo_PXDMountBwd_q2", geo_PXDMountBwd_q1, geo_PXDMountBwd_d,
1786 G4Translate3D(+PXDMountBwd_R1, 0., -(PXDMountBwd_D1 / 2 - PXDMountBwd_L2)));
1787 G4VSolid* geo_PXDMountBwd_q3 = new G4SubtractionSolid("geo_PXDMountBwd_q3", geo_PXDMountBwd_q2, geo_PXDMountBwd_d,
1788 G4Translate3D(-PXDMountBwd_R1, 0., +(PXDMountBwd_D1 / 2 - PXDMountBwd_L2)));
1789 G4VSolid* geo_PXDMountBwd_q4 = new G4SubtractionSolid("geo_PXDMountBwd_q4", geo_PXDMountBwd_q3, geo_PXDMountBwd_d,
1790 G4Translate3D(-PXDMountBwd_R1, 0., -(PXDMountBwd_D1 / 2 - PXDMountBwd_L2)));
1791
1792 G4VSolid* geo_PXDMountBwd = geo_PXDMountBwd_q4;
1793
1794 G4LogicalVolume* logi_PXDMountBwd = new G4LogicalVolume(geo_PXDMountBwd, mat_PXDMountBwd, "logi_PXDMountBwd_name");
1795 setColor(*logi_PXDMountBwd, "#333333");
1796
1797 new G4PVPlacement(0, G4ThreeVector(0, 0, -PXDMountBwd_D1 / 2 - PXDMountBwd_Z1), logi_PXDMountBwd, "phys_PXDMountBwd_name",
1798 &topVolume, false, 0);
1799
1800 // adding screws
1801
1802 G4VSolid* geo_PXDMountBwd_s1 = new G4Tubs("geo_PXDMountBwd_s1", 0, PXDMountFixture_screw_radius, PXDMountFixture_screw_length, 0,
1803 2 * M_PI);
1804 G4VSolid* geo_PXDMountBwd_s2 = new G4Tubs("geo_PXDMountBwd_s2", 0, PXDMountFixture_screw_radius, PXDMountFixture_screw_length, 0,
1805 2 * M_PI);
1806 G4VSolid* geo_PXDMountBwd_s3 = new G4Tubs("geo_PXDMountBwd_s3", 0, PXDMountFixture_screw_radius, PXDMountFixture_screw_length, 0,
1807 2 * M_PI);
1808 G4VSolid* geo_PXDMountBwd_s4 = new G4Tubs("geo_PXDMountBwd_s4", 0, PXDMountFixture_screw_radius, PXDMountFixture_screw_length, 0,
1809 2 * M_PI);
1810
1811 G4Material* mat_PXDMountBwd_s = Materials::get("Cu");
1812
1813 G4Rotate3D rotate_PXDMountBwd = G4RotateX3D(-M_PI / 2.0 / Unit::rad);
1814 G4Transform3D transform_PXDMountBwd_s1 = G4Translate3D(+PXDMountBwd_L1, 0,
1815 -PXDMountBwd_Z1 - PXDMountBwd_D1 + PXDMountBwd_L2) * rotate_PXDMountBwd;
1816 G4Transform3D transform_PXDMountBwd_s2 = G4Translate3D(+PXDMountBwd_L1, 0, -PXDMountBwd_Z1 - PXDMountBwd_L2) * rotate_PXDMountBwd;
1817 G4Transform3D transform_PXDMountBwd_s3 = G4Translate3D(-PXDMountBwd_L1, 0,
1818 -PXDMountBwd_Z1 - PXDMountBwd_D1 + PXDMountBwd_L2) * rotate_PXDMountBwd;
1819 G4Transform3D transform_PXDMountBwd_s4 = G4Translate3D(-PXDMountBwd_L1, 0, -PXDMountBwd_Z1 - PXDMountBwd_L2) * rotate_PXDMountBwd;
1820
1821 G4LogicalVolume* logi_PXDMountBwd_s1 = new G4LogicalVolume(geo_PXDMountBwd_s1, mat_PXDMountBwd_s, "logi_PXDMountBwd_name_s1");
1822 G4LogicalVolume* logi_PXDMountBwd_s2 = new G4LogicalVolume(geo_PXDMountBwd_s2, mat_PXDMountBwd_s, "logi_PXDMountBwd_name_s2");
1823 G4LogicalVolume* logi_PXDMountBwd_s3 = new G4LogicalVolume(geo_PXDMountBwd_s3, mat_PXDMountBwd_s, "logi_PXDMountBwd_name_s3");
1824 G4LogicalVolume* logi_PXDMountBwd_s4 = new G4LogicalVolume(geo_PXDMountBwd_s4, mat_PXDMountBwd_s, "logi_PXDMountBwd_name_s4");
1825
1826 new G4PVPlacement(transform_PXDMountBwd_s1, logi_PXDMountBwd_s1, "phys_PXDMountBwd_name_s1", &topVolume, false, 0);
1827 new G4PVPlacement(transform_PXDMountBwd_s2, logi_PXDMountBwd_s2, "phys_PXDMountBwd_name_s2", &topVolume, false, 0);
1828 new G4PVPlacement(transform_PXDMountBwd_s3, logi_PXDMountBwd_s3, "phys_PXDMountBwd_name_s3", &topVolume, false, 0);
1829 new G4PVPlacement(transform_PXDMountBwd_s4, logi_PXDMountBwd_s4, "phys_PXDMountBwd_name_s4", &topVolume, false, 0);
1830
1831
1832 //----------
1833 //- PXDMountFixtureBwd
1834 prep = "PXDMountFixtureBwd.";
1835
1836 double PXDMountFixtureBwd_Z1 = m_config.getParameter(prep + "Z1") * unitFactor;
1837 double PXDMountFixtureBwd_R1 = m_config.getParameter(prep + "R1") * unitFactor;
1838 double PXDMountFixtureBwd_D1 = m_config.getParameter(prep + "D1") * unitFactor;
1839 double PXDMountFixtureBwd_T1 = m_config.getParameter(prep + "T1") * unitFactor;
1840 double PXDMountFixtureBwd_T2 = m_config.getParameter(prep + "T2") * unitFactor;
1841 double PXDMountFixtureBwd_FL = m_config.getParameter(prep + "I1") * unitFactor;
1842 double PXDMountFixtureBwd_inner_cut_phi = PXDMountFixtureBwd_FL / (PXDMountBwd_R1 + PXDMountFixtureBwd_T1);
1843 double PXDMountFixtureBwd_outter_uni_phi = (1 / 6.0) * M_PI - PXDMountFixtureBwd_FL / PXDMountFixtureBwd_R1;
1844
1845 string strMat_PXDMountFixtureBwd = m_config.getParameterStr(prep + "Material");
1846 G4Material* mat_PXDMountFixtureBwd = Materials::get(strMat_PXDMountFixtureBwd);
1847
1848 // Define geometry
1849 G4VSolid* geo_PXDMountFixtureBwd_a = new G4Tubs("geo_PXDMountFixtureBwd_a", 0, PXDMountFixtureBwd_R1 - PXDMountFixtureBwd_T2,
1850 PXDMountFixtureBwd_D1 / 2, 0,
1851 2 * M_PI);
1852 G4VSolid* geo_PXDMountFixtureBwd_b = new G4Box("geo_PXDMountFixtureBwd_b", PXDMountFixtureBwd_R1 * 0.5, 0.1 * unitFactor,
1853 100);
1854
1855 G4VSolid* geo_PXDMountFixtureBwd_b1 = new G4Box("geo_PXDMountFixtureBwd_b1", PXDMountBwd_R1 + PXDMountFixtureBwd_T1,
1856 PXDMountFixtureBwd_FL * 0.5, 100);
1857 G4VSolid* geo_PXDMountFixtureBwd_b2 = new G4Tubs("geo_PXDMountFixtureBwd_b2", PXDMountBwd_R1 + PXDMountFixtureBwd_T1,
1858 PXDMountFixtureBwd_R1, PXDMountFixtureBwd_D1 / 2,
1859 0, PXDMountFixtureBwd_outter_uni_phi);
1860 G4VSolid* geo_PXDMountFixtureBwd_b3 = new G4Box("geo_PXDMountFixtureBwd_b3", 0.2 * unitFactor, 0.35 * unitFactor,
1861 100 * unitFactor);
1862
1863 G4VSolid* geo_PXDMountFixtureBwd_a1 = new G4Tubs("geo_PXDMountFixtureBwd_a1", 0, PXDMountBwd_R1, 100, 0, 2 * M_PI);
1864
1865 G4VSolid* geo_PXDMountFixtureBwd_c1 = new G4SubtractionSolid("geo_PXDMountFixtureBwd_c1", geo_PXDMountFixtureBwd_a,
1866 geo_PXDMountFixtureBwd_a1);
1867
1868
1869 G4VSolid* geo_PXDMountFixtureBwd_d1 = geo_PXDMountFixtureBwd_c1;
1870 for (int i = 0; i < 4; ++i) {
1871
1872 geo_PXDMountFixtureBwd_d1 = new G4SubtractionSolid("geo_PXDMountFixtureBwd_d1", geo_PXDMountFixtureBwd_d1,
1873 geo_PXDMountFixtureBwd_b1, G4RotateZ3D(i * 0.25 * M_PI));
1874 }
1875 geo_PXDMountFixtureBwd_d1 = new G4SubtractionSolid("geo_PXDMountFixtureBwd_d1", geo_PXDMountFixtureBwd_d1,
1876 geo_PXDMountFixtureBwd_b, G4Translate3D(PXDMountFixtureBwd_R1, - PXDMountFixtureBwd_FL * 0.5, 0));
1877 geo_PXDMountFixtureBwd_d1 = new G4SubtractionSolid("geo_PXDMountFixtureBwd_d1", geo_PXDMountFixtureBwd_d1,
1878 geo_PXDMountFixtureBwd_b, G4Translate3D(-PXDMountFixtureBwd_R1, PXDMountFixtureBwd_FL * 0.5, 0));
1879
1880
1881 double PXDMountFixtureBwd_R1_temp = PXDMountFixtureBwd_R1 - PXDMountFixtureBwd_T2;
1882 for (int i = 2; i < 7; i += 4) {
1883
1884 geo_PXDMountFixtureBwd_d1 = new G4SubtractionSolid("geo_PXDMountFixtureBwd_d1", geo_PXDMountFixtureBwd_d1,
1885 geo_PXDMountFixtureBwd_b3,
1886 G4Translate3D(PXDMountFixtureBwd_R1_temp * cos(i * 0.25 * M_PI - 0.5 * PXDMountFixtureBwd_inner_cut_phi),
1887 PXDMountFixtureBwd_R1_temp * sin(i * 0.25 * M_PI - 0.5 * PXDMountFixtureBwd_inner_cut_phi),
1888 0)*G4RotateZ3D(i * 0.25 * M_PI - 0.5 * PXDMountFixtureBwd_inner_cut_phi));
1889
1890 geo_PXDMountFixtureBwd_d1 = new G4SubtractionSolid("geo_PXDMountFixtureBwd_d1", geo_PXDMountFixtureBwd_d1,
1891 geo_PXDMountFixtureBwd_b3,
1892 G4Translate3D(PXDMountFixtureBwd_R1_temp * cos(i * 0.25 * M_PI + 0.5 * PXDMountFixtureBwd_inner_cut_phi),
1893 PXDMountFixtureBwd_R1_temp * sin(i * 0.25 * M_PI + 0.5 * PXDMountFixtureBwd_inner_cut_phi),
1894 0)*G4RotateZ3D(i * 0.25 * M_PI + 0.5 * PXDMountFixtureBwd_inner_cut_phi));
1895
1896 }
1897 G4VSolid* geo_PXDMountFixtureBwd_d2 = geo_PXDMountFixtureBwd_d1;
1898 for (int i = 0; i < 12; ++i) {
1899 if (i == 2 || i == 3 || i == 8 || i == 9) continue;
1900 geo_PXDMountFixtureBwd_d2 = new G4UnionSolid("geo_PXDMountFixtureBwd_d1", geo_PXDMountFixtureBwd_d2,
1901 geo_PXDMountFixtureBwd_b2, G4RotateZ3D(i * (1 / 6.0) * M_PI + ((1 / 12.0)*M_PI - 0.5 * PXDMountFixtureBwd_outter_uni_phi)));
1902
1903 }
1904
1905 G4VSolid* geo_PXDMountFixtureBwd = geo_PXDMountFixtureBwd_d2;
1906 G4LogicalVolume* logi_PXDMountFixtureBwd = new G4LogicalVolume(geo_PXDMountFixtureBwd, mat_PXDMountFixtureBwd,
1907 "logi_PXDMountFixtureBwd_name");
1908 setColor(*logi_PXDMountFixtureBwd, "#333333");
1909
1910 new G4PVPlacement(0, G4ThreeVector(0, 0, -PXDMountFixtureBwd_D1 / 2 - PXDMountFixtureBwd_Z1), logi_PXDMountFixtureBwd,
1911 "phys_PXDMountFixtureBwd_name",
1912 &topVolume, false, 0);
1913
1914 //---------------------------
1915 // for dose simulation
1916 //---------------------------
1917
1918 m_sensitive.push_back((SensitiveDetector*)(new BkgSensitiveDetector("IR", Index_sensi++)));
1919 logi_Lv1SUSLERUp->SetSensitiveDetector(m_sensitive.back());
1920
1921 m_sensitive.push_back((SensitiveDetector*)(new BkgSensitiveDetector("IR", Index_sensi++)));
1922 logi_Lv1SUSHERDwn->SetSensitiveDetector(m_sensitive.back());
1923
1924 m_sensitive.push_back((SensitiveDetector*)(new BkgSensitiveDetector("IR", Index_sensi++)));
1925 logi_Lv1SUSHERUp->SetSensitiveDetector(m_sensitive.back());
1926
1927 m_sensitive.push_back((SensitiveDetector*)(new BkgSensitiveDetector("IR", Index_sensi++)));
1928 logi_Lv1SUSLERDwn->SetSensitiveDetector(m_sensitive.back());
1929 }
1930
1931
1932 // Components installed after LS1
1933 if (!(phase2 || Run1)) {
1934 //- Lv2AuCoat
1935 prep = "Lv2AuCoat.";
1936
1937 const int Lv2AuCoat_num = 2;
1938
1939 // Part1
1940
1941 double Lv2AuCoat1_Z[Lv2AuCoat_num];
1942 Lv2AuCoat1_Z[0] = m_config.getParameter(prep + "L1") * unitFactor;
1943 Lv2AuCoat1_Z[1] = m_config.getParameter(prep + "L2") * unitFactor;
1944 double Lv2AuCoat1_rI[Lv2AuCoat_num];
1945 Lv2AuCoat1_rI[0] = m_config.getParameter(prep + "R1") * unitFactor;
1946 Lv2AuCoat1_rI[1] = Lv2AuCoat1_rI[0];
1947 double Lv2AuCoat1_rO[Lv2AuCoat_num];
1948 Lv2AuCoat1_rO[0] = m_config.getParameter(prep + "R2") * unitFactor;
1949 Lv2AuCoat1_rO[1] = Lv2AuCoat1_rO[0];
1950
1951 // Part2
1952
1953 double Lv2AuCoat2_Z[Lv2AuCoat_num];
1954 Lv2AuCoat2_Z[0] = m_config.getParameter(prep + "L3") * unitFactor;
1955 Lv2AuCoat2_Z[1] = m_config.getParameter(prep + "L4") * unitFactor;
1956 double Lv2AuCoat2_rI[Lv2AuCoat_num];
1957 Lv2AuCoat2_rI[0] = m_config.getParameter(prep + "R1") * unitFactor;
1958 Lv2AuCoat2_rI[1] = Lv2AuCoat2_rI[0];
1959 double Lv2AuCoat2_rO[Lv2AuCoat_num];
1960 Lv2AuCoat2_rO[0] = m_config.getParameter(prep + "R2") * unitFactor;
1961 Lv2AuCoat2_rO[1] = Lv2AuCoat2_rO[0];
1962
1963 string strMat_Lv2AuCoat = m_config.getParameterStr(prep + "Material");
1964 G4Material* mat_Lv2AuCoat = Materials::get(strMat_Lv2AuCoat);
1965
1966 // Define geometry
1967 G4Polycone* geo_Lv2AuCoat1 = new G4Polycone("geo_Lv2AuCoat1_name", 0, 2 * M_PI, Lv2AuCoat_num, Lv2AuCoat1_Z, Lv2AuCoat1_rI,
1968 Lv2AuCoat1_rO);
1969 G4Polycone* geo_Lv2AuCoat2 = new G4Polycone("geo_Lv2AuCoat2_name", 0, 2 * M_PI, Lv2AuCoat_num, Lv2AuCoat2_Z, Lv2AuCoat2_rI,
1970 Lv2AuCoat2_rO);
1971 //G4UnionSolid* geo_Lv2AuCoat = new G4UnionSolid("geo_Lv2AuCoat_name", geo_Lv2AuCoat1, geo_Lv2AuCoat2);
1972
1973 G4LogicalVolume* logi_Lv2AuCoat1 = new G4LogicalVolume(geo_Lv2AuCoat1, mat_Lv2AuCoat, "logi_Lv2AuCoat1_name");
1974 G4LogicalVolume* logi_Lv2AuCoat2 = new G4LogicalVolume(geo_Lv2AuCoat2, mat_Lv2AuCoat, "logi_Lv2AuCoat2_name");
1975
1976 // Put volume
1977 setColor(*logi_Lv2AuCoat1, "#CCCC00");
1978 setColor(*logi_Lv2AuCoat1, "#CCCC00");
1979 new G4PVPlacement(0, G4ThreeVector(0, 0, 0), logi_Lv2AuCoat1, "phys_Lv2AuCoat1_name", logi_Lv2Paraf, false, 0);
1980 new G4PVPlacement(0, G4ThreeVector(0, 0, 0), logi_Lv2AuCoat2, "phys_Lv2AuCoat2_name", logi_Lv2Paraf, false, 0);
1981 }
1982
1983
1984 //---------------------------
1985 // for dose simulation
1986 //---------------------------
1987
1988 m_sensitive.push_back((SensitiveDetector*)(new BkgSensitiveDetector("IR", Index_sensi++)));
1989 logi_Lv3AuCoat->SetSensitiveDetector(m_sensitive.back());
1990
1991 m_sensitive.push_back((SensitiveDetector*)(new BkgSensitiveDetector("IR", Index_sensi++)));
1992 logi_Lv1TaFwd->SetSensitiveDetector(m_sensitive.back());
1993
1994 m_sensitive.push_back((SensitiveDetector*)(new BkgSensitiveDetector("IR", Index_sensi++)));
1995 logi_Lv1TaBwd->SetSensitiveDetector(m_sensitive.back());
1996
1997 m_sensitive.push_back((SensitiveDetector*)(new BkgSensitiveDetector("IR", Index_sensi++)));
1998 logi_Lv1TaLERUp->SetSensitiveDetector(m_sensitive.back());
1999
2000 m_sensitive.push_back((SensitiveDetector*)(new BkgSensitiveDetector("IR", Index_sensi++)));
2001 logi_Lv1TaHERDwn->SetSensitiveDetector(m_sensitive.back());
2002
2003 m_sensitive.push_back((SensitiveDetector*)(new BkgSensitiveDetector("IR", Index_sensi++)));
2004 logi_Lv1TaHERUp->SetSensitiveDetector(m_sensitive.back());
2005
2006 m_sensitive.push_back((SensitiveDetector*)(new BkgSensitiveDetector("IR", Index_sensi++)));
2007 logi_Lv1TaLERDwn->SetSensitiveDetector(m_sensitive.back());
2008
2009 m_sensitive.push_back((SensitiveDetector*)(new BkgSensitiveDetector("IR", Index_sensi++)));
2010 logi_CuFlangeFwd->SetSensitiveDetector(m_sensitive.back());
2011
2012 m_sensitive.push_back((SensitiveDetector*)(new BkgSensitiveDetector("IR", Index_sensi++)));
2013 logi_CuFlangeBwd->SetSensitiveDetector(m_sensitive.back());
2014
2015 }
Belle2::sqrt
double sqrt(double a)
sqrt for double
Definition beamHelpers.h:28
Belle2::geometry::setVisibility
void setVisibility(G4LogicalVolume &volume, bool visible)
Helper function to quickly set the visibility of a given volume.
Definition utilities.cc:108
Belle2::geometry::setColor
void setColor(G4LogicalVolume &volume, const std::string &color)
Set the color of a logical volume.
Definition utilities.cc:100

◆ createPayloads()

virtual void createPayloads ( const GearDir & content,
const IntervalOfValidity & iov )
inlineoverridevirtual

creates DB payload for BeamPipeGeo class

Reimplemented from CreatorBase.

Definition at line 78 of file GeoBeamPipeCreator.h.

79 {
80 DBImportObjPtr<BeamPipeGeo> importObj;
81 importObj.construct(createConfiguration(content));
82 importObj.import(iov);
83 }

Member Data Documentation

◆ m_config

BeamPipeGeo m_config
protected

geometry parameters object

Definition at line 101 of file GeoBeamPipeCreator.h.

◆ m_sensitive

std::vector<SensitiveDetector*> m_sensitive
protected

Sensitive detector.

Definition at line 99 of file GeoBeamPipeCreator.h.

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