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 ()
 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 ( )
virtual

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 early phase 3 before LS1)
124 bool phase2 = false;
125 bool earlyPhase3 = false; // aka Run1
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 earlyPhase3 = 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 = 0;
483 if (phase2 || earlyPhase3) {
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 G4Transform3D transform_Lv2VacuumPart2_3 = G4Translate3D(0., 0., 0.);
654 G4IntersectionSolid* geo_Lv2VacuumPart3 = new G4IntersectionSolid("geo_Lv2VacuumPart3_name", geo_Lv2VacuumPart3x,
655 geo_Lv2VacuumPart3_3);
656 // Part1+2+3
657 // G4Transform3D transform_Lv2VacuumPart3 = G4Translate3D(0., 0., 0.);
658 G4Transform3D transform_Lv2VacuumPart3 = G4Translate3D(-(67.5 + 85) * sin(Lv2Vacuum_A1), 0., (67.5 + 85) * cos(Lv2Vacuum_A1));
659 transform_Lv2VacuumPart3 = transform_Lv2VacuumPart3 * G4RotateY3D(M_PI - Lv2Vacuum_A1);
660 G4UnionSolid* geo_Lv2Vacuumxx = new G4UnionSolid("geo_Lv2Vacuumxx_name", geo_Lv2VacuumPart1, geo_Lv2VacuumPart3,
661 transform_Lv2VacuumPart3);
662 G4Transform3D transform_Lv2VacuumPart2 = G4Translate3D(Lv2Vacuum_L3 * sin(Lv2Vacuum_A2), 0.,
663 Lv2Vacuum_L2 + Lv2Vacuum_L3 * cos(Lv2Vacuum_A2));
664 transform_Lv2VacuumPart2 = transform_Lv2VacuumPart2 * G4RotateY3D(Lv2Vacuum_A2);
665 geo_Lv2Vacuumx = new G4UnionSolid("geo_Lv2Vacuumx_name", geo_Lv2Vacuumxx, geo_Lv2VacuumPart2,
666 transform_Lv2VacuumPart2);
667 }
668
669 // Material
670 string strMat_Lv2Vacuum = m_config.getParameterStr(prep + "Material");
671 G4Material* mat_Lv2Vacuum = Materials::get(strMat_Lv2Vacuum);
672
673 // Intersection with mother
674 G4IntersectionSolid* geo_Lv2Vacuum = new G4IntersectionSolid("geo_Lv2Vacuum_name", geo_Lv2Vacuumx, geo_Lv1SUS);
675 G4LogicalVolume* logi_Lv2Vacuum = new G4LogicalVolume(geo_Lv2Vacuum, mat_Lv2Vacuum, "logi_Lv2Vacuum_name");
676 if (flag_limitStep) logi_Lv2Vacuum->SetUserLimits(new G4UserLimits(stepMax));
677
678 // Put volume
679 setColor(*logi_Lv2Vacuum, "#CCCCCC");
680 new G4PVPlacement(0, G4ThreeVector(0, 0, 0), logi_Lv2Vacuum, "phys_Lv2Vacuum_name", logi_Lv1SUS, false, 0);
681
682
683 //----------
684 //- Lv2Paraf
685
686 // Part 1
687 prep = "Lv2Paraf1.";
688
689 int Lv2Paraf1_num = int(m_config.getParameter(prep + "N"));
690 vector<double> Lv2Paraf1_Z(Lv2Paraf1_num);
691 vector<double> Lv2Paraf1_rI(Lv2Paraf1_num);
692 vector<double> Lv2Paraf1_rO(Lv2Paraf1_num);
693
694 for (int i = 0; i < Lv2Paraf1_num; ++i) {
695 ostringstream ossZID;
696 ossZID << "Z" << i;
697
698 ostringstream ossrOID;
699 ossrOID << "R" << i;
700
701 ostringstream ossrIID;
702 ossrIID << "r" << i;
703
704 Lv2Paraf1_Z[i] = m_config.getParameter(prep + ossZID.str()) * unitFactor;
705 Lv2Paraf1_rO[i] = m_config.getParameter(prep + ossrOID.str()) * unitFactor;
706 Lv2Paraf1_rI[i] = m_config.getParameter(prep + ossrIID.str(), 0.0) * unitFactor;
707 }
708
709 // Part 2
710 prep = "Lv2Paraf2.";
711
712 int Lv2Paraf2_num = int(m_config.getParameter(prep + "N"));
713 vector<double> Lv2Paraf2_Z(Lv2Paraf2_num);
714 vector<double> Lv2Paraf2_rI(Lv2Paraf2_num);
715 vector<double> Lv2Paraf2_rO(Lv2Paraf2_num);
716
717 for (int i = 0; i < Lv2Paraf2_num; ++i) {
718 ostringstream ossZID;
719 ossZID << "Z" << i;
720
721 ostringstream ossrOID;
722 ossrOID << "R" << i;
723
724 ostringstream ossrIID;
725 ossrIID << "r" << i;
726
727 Lv2Paraf2_Z[i] = m_config.getParameter(prep + ossZID.str()) * unitFactor;
728 Lv2Paraf2_rO[i] = m_config.getParameter(prep + ossrOID.str()) * unitFactor;
729 Lv2Paraf2_rI[i] = m_config.getParameter(prep + ossrIID.str(), 0.0) * unitFactor;
730 }
731
732 // Material
733 string strMat_Lv2Paraf = m_config.getParameterStr(prep + "Material");
734 G4Material* mat_Lv2Paraf = Materials::get(strMat_Lv2Paraf);
735
736 // Define geometry
737 G4Polycone* geo_Lv2Parafpcon1 = new G4Polycone("geo_Lv2Parafpcon1_name", 0, 2 * M_PI, Lv2Paraf1_num, &(Lv2Paraf1_Z[0]),
738 &(Lv2Paraf1_rI[0]),
739 &(Lv2Paraf1_rO[0]));
740 G4Polycone* geo_Lv2Parafpcon2 = new G4Polycone("geo_Lv2Parafpcon2_name", 0, 2 * M_PI, Lv2Paraf2_num, &(Lv2Paraf2_Z[0]),
741 &(Lv2Paraf2_rI[0]),
742 &(Lv2Paraf2_rO[0]));
743 G4SubtractionSolid* geo_Lv2Paraf = new G4SubtractionSolid("geo_Lv2Paraf_name", geo_Lv2Parafpcon1, geo_Lv2Parafpcon2);
744 G4LogicalVolume* logi_Lv2Paraf = new G4LogicalVolume(geo_Lv2Paraf, mat_Lv2Paraf, "logi_Lv2Paraf_name");
745
746 // Put volume
747 setColor(*logi_Lv2Paraf, "#00CCCC");
748 new G4PVPlacement(0, G4ThreeVector(0, 0, 0), logi_Lv2Paraf, "phys_Lv2Paraf_name", logi_Lv1SUS, false, 0);
749
750
751 //----------
752 //- Lv3AuCoat
753
754 // Get parameters from .xml file
755 prep = "Lv3AuCoat.";
756
757 const int Lv3AuCoat_num = 2;
758
759 double Lv3AuCoat_Z[Lv3AuCoat_num];
760 Lv3AuCoat_Z[0] = m_config.getParameter(prep + "L1") * unitFactor;
761 Lv3AuCoat_Z[1] = m_config.getParameter(prep + "L2") * unitFactor;
762
763 double Lv3AuCoat_rI[Lv3AuCoat_num];
764 Lv3AuCoat_rI[0] = m_config.getParameter(prep + "R1") * unitFactor;
765 Lv3AuCoat_rI[1] = Lv3AuCoat_rI[0];
766
767 double Lv3AuCoat_rO[Lv3AuCoat_num];
768 Lv3AuCoat_rO[0] = m_config.getParameter(prep + "R2") * unitFactor;
769 Lv3AuCoat_rO[1] = Lv3AuCoat_rO[0];
770
771 string strMat_Lv3AuCoat = m_config.getParameterStr(prep + "Material");
772 G4Material* mat_Lv3AuCoat = Materials::get(strMat_Lv3AuCoat);
773
774 // Define geometry
775 G4Polycone* geo_Lv3AuCoat = new G4Polycone("geo_Lv3AuCoat_name", 0, 2 * M_PI, Lv3AuCoat_num, Lv3AuCoat_Z, Lv3AuCoat_rI,
776 Lv3AuCoat_rO);
777 G4LogicalVolume* logi_Lv3AuCoat = new G4LogicalVolume(geo_Lv3AuCoat, mat_Lv3AuCoat, "logi_Lv3AuCoat_name");
778
779 // Put volume
780 setColor(*logi_Lv3AuCoat, "#CCCC00");
781 new G4PVPlacement(0, G4ThreeVector(0, 0, 0), logi_Lv3AuCoat, "phys_Lv3AuCoat_name", logi_Lv2Vacuum, false, 0);
782
783
786
787 // Get parameters from .xml file
788 prep = "Flange.";
789
790 double Flange_R = m_config.getParameter(prep + "R") * unitFactor;
791 double Flange_L1 = m_config.getParameter(prep + "L1") * unitFactor;
792 double Flange_L2 = m_config.getParameter(prep + "L2") * unitFactor;
793 double Flange_D = m_config.getParameter(prep + "D") * unitFactor;
794 double Flange_T = m_config.getParameter(prep + "T") * unitFactor;
795
796 // Define geometry
797 //G4Box* geo_Flange0 = new G4Box("geo_Flange0_name", Flange_L2, Flange_R, Flange_T);
798 G4Tubs* geo_Flange0 = new G4Tubs("geo_Flange0_name", 0, Flange_L2, Flange_T, 0, 2 * M_PI);
799 G4Tubs* geo_Flange1 = new G4Tubs("geo_Flange1_name", 0, Flange_R, Flange_T, 0, 2 * M_PI);
800 G4Tubs* geo_Flange2 = new G4Tubs("geo_Flange2_name", 0, Flange_R, Flange_T, 0, 2 * M_PI);
801
802 G4UnionSolid* geo_Flange_x = new G4UnionSolid("geo_Flange_x_name", geo_Flange1, geo_Flange2, G4Translate3D(-Flange_L1 * 2, 0, 0));
803 G4IntersectionSolid* geo_Flange = new G4IntersectionSolid("geo_Flange_name", geo_Flange0, geo_Flange_x, G4Translate3D(Flange_L1, 0,
804 0));
805
806
809
810
811 // Avoid overlap with HeavyMetalShield
812 prep = "HMS.";
813 int HMS_num = int(m_config.getParameter(prep + "N"));
814 vector<double> HMS_Z(HMS_num);
815 vector<double> HMS_rI(HMS_num);
816 vector<double> HMS_rO(HMS_num);
817
818 for (int i = 0; i < HMS_num; ++i) {
819 ostringstream ossZID;
820 ossZID << "Z" << i;
821
822 ostringstream ossrIID;
823 ossrIID << "rI" << i;
824
825 ostringstream ossrOID;
826 ossrOID << "rO" << i;
827
828 HMS_Z[i] = m_config.getParameter(prep + ossZID.str()) * unitFactor;
829 HMS_rI[i] = m_config.getParameter(prep + ossrIID.str()) * unitFactor;
830 HMS_rO[i] = m_config.getParameter(prep + ossrOID.str()) * unitFactor;
831 }
832
833 G4Polycone* geo_HMS = new G4Polycone("geo_HMS_name", 0, 2 * M_PI, HMS_num, &(HMS_Z[0]), &(HMS_rI[0]), &(HMS_rO[0]));
834
835
836 //----------
837 //- Lv1TaFwd
838
839 prep = "Lv1TaFwd.";
840 // The following variables are used in creation of other components below
841 double Lv1TaFwd_D1 = m_config.getParameter(prep + "D1") * unitFactor;
842 double Lv1TaFwd_L1 = m_config.getParameter(prep + "L1") * unitFactor;
843 double Lv1TaFwd_aL1 = m_config.getParameter(prep + "aL1", 0.0) * unitFactor;
844 double Lv1TaFwd_aL2 = m_config.getParameter(prep + "aL2", 0.0) * unitFactor;
845 double Lv1TaFwd_aL3 = m_config.getParameter(prep + "aL3", 0.0) * unitFactor;
846 G4SubtractionSolid* geo_Lv1TaFwd;
847 G4VSolid* geo_Lv1TaFwd_d;
848 G4LogicalVolume* logi_Lv1TaFwd;
849 if (phase2) {
850 // Get parameters from .xml file
851 double Lv1TaFwd_L2 = m_config.getParameter(prep + "L2") * unitFactor;
852 double Lv1TaFwd_L3 = m_config.getParameter(prep + "L3") * unitFactor;
853 double Lv1TaFwd_T1 = m_config.getParameter(prep + "T1") * unitFactor;
854
855 string strMat_Lv1TaFwd = m_config.getParameterStr(prep + "Material");
856 G4Material* mat_Lv1TaFwd = Materials::get(strMat_Lv1TaFwd);
857
858 //define geometry
859 G4Trd* geo_Lv1TaFwd_xx = new G4Trd("geo_Lv1TaFwd_xx_name", Lv1TaFwd_L2, Lv1TaFwd_L3, Lv1TaFwd_T1, Lv1TaFwd_T1, Lv1TaFwd_L1 / 2.0);
860 G4UnionSolid* geo_Lv1TaFwd_x
861 = new G4UnionSolid("geo_Lv1TaFwd_x_name", geo_Lv1TaFwd_xx, geo_Flange,
862 G4Translate3D(0, 0, Flange_D - (Lv1TaFwd_D1 + Lv1TaFwd_L1 / 2.0)));
863
864 geo_Lv1TaFwd = new G4SubtractionSolid("geo_Lv1TaFwd_name", geo_Lv1TaFwd_x, geo_HMS,
865 G4Translate3D(0, 0, -(Lv1TaFwd_D1 + Lv1TaFwd_L1 / 2.0)));
866
867 logi_Lv1TaFwd = new G4LogicalVolume(geo_Lv1TaFwd, mat_Lv1TaFwd, "logi_Lv1TaFwd_name");
868
869 // Put volume at (0.,0.,D1 + L1/2)
870 setColor(*logi_Lv1TaFwd, "#333333");
871 new G4PVPlacement(0, G4ThreeVector(0, 0, Lv1TaFwd_D1 + Lv1TaFwd_L1 / 2.0), logi_Lv1TaFwd, "phys_Lv1TaFwd_name", &topVolume, false,
872 0);
873 } else {
874 // Get parameters from .xml file
875 //double Lv1TaFwd_L2 = m_config.getParameter(prep + "L2") * unitFactor;
876 //double Lv1TaFwd_L3 = m_config.getParameter(prep + "L3") * unitFactor;
877 double Lv1TaFwd_T1 = m_config.getParameter(prep + "T1") * unitFactor;
878 double Lv1TaFwd_aR1 = m_config.getParameter(prep + "aR1") * unitFactor;
879 double Lv1TaFwd_aR2 = m_config.getParameter(prep + "aR2") * unitFactor;
880 double Lv1TaFwd_bL1 = Lv1TaFwd_L1 - Lv1TaFwd_aL1 - Lv1TaFwd_aL2 - Lv1TaFwd_aL3;
881 double Lv1TaFwd_bL2 = m_config.getParameter(prep + "bL2") * unitFactor;
882 double Lv1TaFwd_bL3 = m_config.getParameter(prep + "bL3") * unitFactor;
883
884 string strMat_Lv1TaFwd = m_config.getParameterStr(prep + "Material");
885 G4Material* mat_Lv1TaFwd = Materials::get(strMat_Lv1TaFwd);
886
887 // Define geometry
888 //G4Trd* geo_Lv1TaFwd_xx = new G4Trd("geo_Lv1TaFwd_xx_name", Lv1TaFwd_L2, Lv1TaFwd_L3, Lv1TaFwd_T1, Lv1TaFwd_T1, Lv1TaFwd_L1 / 2.0);
889 double Lv1TaFwd_aR[4] = {Lv1TaFwd_aR1, Lv1TaFwd_aR1, Lv1TaFwd_aR2, Lv1TaFwd_aR2};
890 double Lv1TaFwd_ar[4] = {0, 0, 0, 0};
891 double Lv1TaFwd_aL[4] = { -Lv1TaFwd_L1 / 2.0 + 0,
892 -Lv1TaFwd_L1 / 2.0 + Lv1TaFwd_aL1,
893 -Lv1TaFwd_L1 / 2.0 + Lv1TaFwd_aL1 + Lv1TaFwd_aL2,
894 -Lv1TaFwd_L1 / 2.0 + Lv1TaFwd_aL1 + Lv1TaFwd_aL2 + Lv1TaFwd_aL3
895 };
896
897 G4VSolid* geo_Lv1TaFwd_a = new G4Polycone("geo_Lv1TaFwd_a_name", 0, 2 * M_PI, 4, Lv1TaFwd_aL, Lv1TaFwd_ar, Lv1TaFwd_aR);
898 G4VSolid* geo_Lv1TaFwd_b = new G4Trd("geo_Lv1TaFwd_b_name", Lv1TaFwd_bL2, Lv1TaFwd_bL3, Lv1TaFwd_T1, Lv1TaFwd_T1,
899 Lv1TaFwd_bL1 / 2.0);
900 G4VSolid* geo_Lv1TaFwd_c = new G4Box("geo_Lv1TaFwd_c_name", 200, Lv1TaFwd_T1, (Lv1TaFwd_aL1 + Lv1TaFwd_aL2 + Lv1TaFwd_aL3) / 2.0);
901 geo_Lv1TaFwd_d = new G4IntersectionSolid("geo_Lv1TaFwd_d_name", geo_Lv1TaFwd_a, geo_Lv1TaFwd_c, G4Translate3D(0, 0,
902 -Lv1TaFwd_L1 / 2.0 + (Lv1TaFwd_aL1 + Lv1TaFwd_aL2 + Lv1TaFwd_aL3) / 2.0));
903 G4VSolid* geo_Lv1TaFwd_xx = new G4UnionSolid("geo_Lv1TaFwd_xx_name", geo_Lv1TaFwd_d, geo_Lv1TaFwd_b, G4Translate3D(0, 0,
904 Lv1TaFwd_L1 / 2.0 - Lv1TaFwd_bL1 / 2.0));
905 G4UnionSolid* geo_Lv1TaFwd_x
906 = new G4UnionSolid("geo_Lv1TaFwd_x_name", geo_Lv1TaFwd_xx, geo_Flange,
907 G4Translate3D(0, 0, Flange_D - (Lv1TaFwd_D1 + Lv1TaFwd_L1 / 2.0)));
908
909 geo_Lv1TaFwd = new G4SubtractionSolid("geo_Lv1TaFwd_name", geo_Lv1TaFwd_x, geo_HMS,
910 G4Translate3D(0, 0, -(Lv1TaFwd_D1 + Lv1TaFwd_L1 / 2.0)));
911
912 logi_Lv1TaFwd = new G4LogicalVolume(geo_Lv1TaFwd, mat_Lv1TaFwd, "logi_Lv1TaFwd_name");
913
914 // Put volume at (0.,0.,D1 + L1/2)
915 setColor(*logi_Lv1TaFwd, "#333333");
916 new G4PVPlacement(0, G4ThreeVector(0, 0, Lv1TaFwd_D1 + Lv1TaFwd_L1 / 2.0), logi_Lv1TaFwd, "phys_Lv1TaFwd_name", &topVolume, false,
917 0);
918 }
919
920
921 //----------
922 //- Lv2VacFwd
923
924 // Get parameters from .xml file
925 prep = "Lv2VacFwd.";
926
927 double Lv2VacFwd_D1 = m_config.getParameter(prep + "D1") * unitFactor;
928 double Lv2VacFwd_D2 = m_config.getParameter(prep + "D2") * unitFactor;
929 double Lv2VacFwd_D3 = m_config.getParameter(prep + "D3") * unitFactor;
930 double Lv2VacFwd_L1 = m_config.getParameter(prep + "L1") * unitFactor;
931 double Lv2VacFwd_L2 = m_config.getParameter(prep + "L2") * unitFactor;
932 double Lv2VacFwd_L3 = m_config.getParameter(prep + "L3") * unitFactor;
933 double Lv2VacFwd_R1 = m_config.getParameter(prep + "R1") * unitFactor;
934 double Lv2VacFwd_R2 = m_config.getParameter(prep + "R2") * unitFactor;
935 double Lv2VacFwd_R3 = m_config.getParameter(prep + "R3") * unitFactor;
936 double Lv2VacFwd_R4 = m_config.getParameter(prep + "R4") * unitFactor;
937 double Lv2VacFwd_A1 = m_config.getParameter(prep + "A1");
938 double Lv2VacFwd_A2 = m_config.getParameter(prep + "A2");
939
940 string strMat_Lv2VacFwd = m_config.getParameterStr(prep + "Material");
941 G4Material* mat_Lv2VacFwd = Materials::get(strMat_Lv2VacFwd);
942
943 // Part 1
944 double Lv2VacFwd1_Z1 = sqrt(Lv2VacFwd_D1 * Lv2VacFwd_D1 + Lv2VacFwd_D2 * Lv2VacFwd_D2 - 2.*Lv2VacFwd_D1 * Lv2VacFwd_D2 * cos(
945 Lv2VacFwd_A1));
946 double Lv2VacFwd1_rI1 = 0.0;
947 double Lv2VacFwd1_rO1 = Lv2VacFwd_R1;
948
949 double Lv2VacFwd1_Z2 = (Lv2VacFwd1_Z1 / 2. * cos(Lv2VacFwd_A2)) + SafetyLength;
950 double Lv2VacFwd1_rI2 = 0.0;
951 double Lv2VacFwd1_rO2 = 2 * Lv2VacFwd_R1;
952 // Part 2
953 double Lv2VacFwd2_Z1 = Lv2VacFwd_L1;
954 double Lv2VacFwd2_rI1 = 0.0;
955 double Lv2VacFwd2_rO1 = Lv2VacFwd_R2;
956
957 double Lv2VacFwd2_Z2 = (Lv2VacFwd_L1 / 2. * cos(Lv2VacFwd_A2)) + SafetyLength;
958 double Lv2VacFwd2_rI2 = 0.0;
959 double Lv2VacFwd2_rO2 = 2 * Lv2VacFwd_R2;
960 // Part 3
961 const int Lv2VacFwd3_num1 = 2; // Cylindrical part
962 const int Lv2VacFwd3_num2 = 3; // Policone part
963 //-----------> Cylindrical part
964 double Lv2VacFwd_Z1[Lv2VacFwd3_num1];
965 Lv2VacFwd_Z1[0] = 0.0;
966// Lv2VacFwd_Z1[1] = Lv2VacFwd_D3 - Lv2VacFwd_L2;
967 Lv2VacFwd_Z1[1] = Lv2VacFwd_D3 - Lv2VacFwd_L2 + 0.03 * SafetyLength;
968 double Lv2VacFwd_rI1[Lv2VacFwd3_num1];
969 for (int tmpn = 0; tmpn < Lv2VacFwd3_num1; tmpn++) {
970 Lv2VacFwd_rI1[tmpn] = 0.0;
971 }
972 double Lv2VacFwd_rO1[Lv2VacFwd3_num1];
973 Lv2VacFwd_rO1[0] = Lv2VacFwd_R3;
974 Lv2VacFwd_rO1[1] = Lv2VacFwd_R3;
975 //<---------------
976 //----------->Policone part
977 double Lv2VacFwd_Z2[Lv2VacFwd3_num2];
978 Lv2VacFwd_Z2[0] = Lv2VacFwd_D3 - Lv2VacFwd_L2;
979 Lv2VacFwd_Z2[1] = Lv2VacFwd_D3;
980 Lv2VacFwd_Z2[2] = Lv2VacFwd_D3 + Lv2VacFwd_L3;
981 double Lv2VacFwd_rI2[Lv2VacFwd3_num2];
982 for (int tmpn = 0; tmpn < Lv2VacFwd3_num2; tmpn++) {
983 Lv2VacFwd_rI2[tmpn] = 0.0;
984 }
985 double Lv2VacFwd_rO2[Lv2VacFwd3_num2];
986 Lv2VacFwd_rO2[0] = Lv2VacFwd_R3;
987 Lv2VacFwd_rO2[1] = Lv2VacFwd_R4;
988 Lv2VacFwd_rO2[2] = Lv2VacFwd_R4;
989 //<-------------------
990
991
992 // Define geometry
993 // Part 1
994 G4Tubs* geo_Lv2VacFwdPart1_1 = new G4Tubs("geo_Lv2VacFwdPart1_1_name", Lv2VacFwd1_rI1, Lv2VacFwd1_rO1, Lv2VacFwd1_Z1, 0, 2 * M_PI);
995 G4Tubs* geo_Lv2VacFwdPart1_2 = new G4Tubs("geo_Lv2VacFwdPart1_2_name", Lv2VacFwd1_rI2, Lv2VacFwd1_rO2, Lv2VacFwd1_Z2, 0, 2 * M_PI);
996 //Slanted tube of Part 1
997 G4Transform3D transform_Lv2VacFwdPart1_2 = G4Translate3D(0., 0., 0.);
998 transform_Lv2VacFwdPart1_2 = transform_Lv2VacFwdPart1_2 * G4RotateY3D(-Lv2VacFwd_A2 / 2.);
999 G4IntersectionSolid* geo_Lv2VacFwdPart1 = new G4IntersectionSolid("geo_Lv2VacFwdPart1_name", geo_Lv2VacFwdPart1_1,
1000 geo_Lv2VacFwdPart1_2, transform_Lv2VacFwdPart1_2);
1001 // Part 2
1002 G4Tubs* geo_Lv2VacFwdPart2_1 = new G4Tubs("geo_Lv2VacFwdPart2_1_name", Lv2VacFwd2_rI1, Lv2VacFwd2_rO1, Lv2VacFwd2_Z1, 0, 2 * M_PI);
1003 G4Tubs* geo_Lv2VacFwdPart2_2 = new G4Tubs("geo_Lv2VacFwdPart2_2_name", Lv2VacFwd2_rI2, Lv2VacFwd2_rO2, Lv2VacFwd2_Z2, 0, 2 * M_PI);
1004 //Slanted tube of Part 2
1005 G4Transform3D transform_Lv2VacFwdPart2_2 = G4Translate3D(0., 0., 0.);
1006 transform_Lv2VacFwdPart2_2 = transform_Lv2VacFwdPart2_2 * G4RotateY3D(Lv2VacFwd_A2 / 2.);
1007 G4IntersectionSolid* geo_Lv2VacFwdPart2 = new G4IntersectionSolid("geo_Lv2VacFwdPart2_name", geo_Lv2VacFwdPart2_1,
1008 geo_Lv2VacFwdPart2_2, transform_Lv2VacFwdPart2_2);
1009 // Part 3
1010// G4Polycone* geo_Lv2VacFwdPart3 = new G4Polycone("geo_Lv2VacFwdPart3", 0, 2 * M_PI, Lv2VacFwd3_num, Lv2VacFwd_Z, Lv2VacFwd_rI, Lv2VacFwd_rO);
1011 G4Polycone* geo_Lv2VacFwdPart3_1 = new G4Polycone("geo_Lv2VacFwdPart3_1", 0, 2 * M_PI, Lv2VacFwd3_num1, Lv2VacFwd_Z1, Lv2VacFwd_rI1,
1012 Lv2VacFwd_rO1);
1013 G4Polycone* geo_Lv2VacFwdPart3_2 = new G4Polycone("geo_Lv2VacFwdPart3_2", 0, 2 * M_PI, Lv2VacFwd3_num2, Lv2VacFwd_Z2, Lv2VacFwd_rI2,
1014 Lv2VacFwd_rO2);
1015 G4Transform3D transform_Lv2VacFwdPart3_1 = G4Translate3D(-0.5, 0., 0.);
1016 transform_Lv2VacFwdPart3_1 = transform_Lv2VacFwdPart3_1 * G4RotateY3D(Lv2VacFwd_A1 - A11);
1017 G4UnionSolid* geo_Lv2VacFwdPart3 = new G4UnionSolid("geo_Lv2VacFwdPart3_name", geo_Lv2VacFwdPart3_2, geo_Lv2VacFwdPart3_1,
1018 transform_Lv2VacFwdPart3_1);
1019 // Part1+2+3
1020 //tmp begin
1021 G4Transform3D transform_Lv2VacFwdPart1 = G4Translate3D((Lv2VacFwd_D1 * sin(Lv2VacFwd_A1) + Lv2VacFwd_D2 * sin(
1022 2.*Lv2VacFwd_A1)) / 2.,
1023 0.,
1024 (Lv2VacFwd_D1 * cos(Lv2VacFwd_A1) + Lv2VacFwd_D2 * cos(2.*Lv2VacFwd_A1)) / 2.);
1025 //G4Transform3D transform_Lv2VacFwdPart1 = G4Translate3D((Lv2VacFwd_D1 * sin(Lv2VacFwd_A1) + Lv2VacFwd_D2 * sin(2.*Lv2VacFwd_A1)) / 1.9 ,
1026 // 0.,
1027 // (Lv2VacFwd_D1 * cos(Lv2VacFwd_A1) + Lv2VacFwd_D2 * cos(2.*Lv2VacFwd_A1)) / 1.9);
1028 transform_Lv2VacFwdPart1 = transform_Lv2VacFwdPart1 * G4RotateY3D(Lv2VacFwd_A1 + Lv2VacFwd_A2);
1029
1030 G4Transform3D transform_Lv2VacFwdPart2 = G4Translate3D(Lv2VacFwd_D2 * sin(2.*Lv2VacFwd_A1) + Lv2VacFwd_L1 * sin(
1031 2.*Lv2VacFwd_A1) / 2.0,
1032 0.,
1033 Lv2VacFwd_D2 * cos(2.*Lv2VacFwd_A1) + Lv2VacFwd_L1 * cos(2.*Lv2VacFwd_A1) / 2.0);
1034 //G4Transform3D transform_Lv2VacFwdPart2 = G4Translate3D(Lv2VacFwd_D2 * sin(2.*Lv2VacFwd_A1) + Lv2VacFwd_L1 * sin(2.*Lv2VacFwd_A1) / 2.05,
1035 // 0.,
1036 // Lv2VacFwd_D2 * cos(2.*Lv2VacFwd_A1) + Lv2VacFwd_L1 * cos(2.*Lv2VacFwd_A1) / 2.05);
1037 //tmp end
1038 transform_Lv2VacFwdPart2 = transform_Lv2VacFwdPart2 * G4RotateY3D(2.*Lv2VacFwd_A1);
1039
1040 G4UnionSolid* geo_Lv2VacFwdxx = new G4UnionSolid("geo_Lv2VacFwdxx_name", geo_Lv2VacFwdPart3, geo_Lv2VacFwdPart1,
1041 transform_Lv2VacFwdPart1);
1042 G4UnionSolid* geo_Lv2VacFwdx = new G4UnionSolid("geo_Lv2VacFwdx_name", geo_Lv2VacFwdxx, geo_Lv2VacFwdPart2,
1043 transform_Lv2VacFwdPart2);
1044 // Intersection
1045 G4Transform3D transform_Lv2VacFwd = G4Translate3D(0., 0., -Lv1TaFwd_D1 - Lv1TaFwd_L1 / 2.);
1046 transform_Lv2VacFwd = transform_Lv2VacFwd * G4RotateY3D(-Lv2VacFwd_A1);
1047
1048 G4IntersectionSolid* geo_Lv2VacFwd = new G4IntersectionSolid("geo_Lv2VacFwd_name", geo_Lv1TaFwd, geo_Lv2VacFwdx,
1049 transform_Lv2VacFwd);
1050 G4LogicalVolume* logi_Lv2VacFwd = new G4LogicalVolume(geo_Lv2VacFwd, mat_Lv2VacFwd, "logi_Lv2VacFwd_name");
1051 if (flag_limitStep) logi_Lv2VacFwd->SetUserLimits(new G4UserLimits(stepMax));
1052
1053 // Put volume
1054 setColor(*logi_Lv2VacFwd, "#CCCCCC");
1055 //you must set this invisible, otherwise encounter segV.
1056 setVisibility(*logi_Lv2VacFwd, false);
1057 new G4PVPlacement(0, G4ThreeVector(0., 0., 0.), logi_Lv2VacFwd, "phys_Lv2VacFwd_name", logi_Lv1TaFwd, false, 0);
1058
1059
1062
1063 //----------
1064 //- Lv1TaBwd
1065
1066 prep = "Lv1TaBwd.";
1067 // The following variables are used in creation of other components below
1068 double Lv1TaBwd_D1 = m_config.getParameter(prep + "D1") * unitFactor;
1069 double Lv1TaBwd_L1 = m_config.getParameter(prep + "L1") * unitFactor;
1070 double Lv1TaBwd_aL1 = m_config.getParameter(prep + "aL1", 0.0) * unitFactor;
1071 double Lv1TaBwd_aL2 = m_config.getParameter(prep + "aL2", 0.0) * unitFactor;
1072 double Lv1TaBwd_aL3 = m_config.getParameter(prep + "aL3", 0.0) * unitFactor;
1073 G4UnionSolid* geo_Lv1TaBwd;
1074 G4VSolid* geo_Lv1TaBwd_d;
1075 G4LogicalVolume* logi_Lv1TaBwd;
1076 if (phase2) {
1077 // Get parameters from .xml file
1078 double Lv1TaBwd_L2 = m_config.getParameter(prep + "L2") * unitFactor;
1079 double Lv1TaBwd_L3 = m_config.getParameter(prep + "L3") * unitFactor;
1080 double Lv1TaBwd_T1 = m_config.getParameter(prep + "T1") * unitFactor;
1081 //
1082 string strMat_Lv1TaBwd = m_config.getParameterStr(prep + "Material");
1083 G4Material* mat_Lv1TaBwd = Materials::get(strMat_Lv1TaBwd);
1084
1085 //define geometry
1086 G4Trd* geo_Lv1TaBwd_x = new G4Trd("geo_Lv1TaBwd_x_name", Lv1TaBwd_L2, Lv1TaBwd_L3, Lv1TaBwd_T1, Lv1TaBwd_T1, Lv1TaBwd_L1 / 2.0);
1087 geo_Lv1TaBwd = new G4UnionSolid("geo_Lv1TaBwd_name", geo_Lv1TaBwd_x, geo_Flange,
1088 G4Translate3D(0, 0, -Flange_D - (-Lv1TaBwd_D1 - Lv1TaBwd_L1 / 2.0)));
1089 logi_Lv1TaBwd = new G4LogicalVolume(geo_Lv1TaBwd, mat_Lv1TaBwd, "logi_Lv1TaBwd_name");
1090
1091 //- put volume
1092 setColor(*logi_Lv1TaBwd, "#333333");
1093 new G4PVPlacement(0, G4ThreeVector(0, 0, -Lv1TaBwd_D1 - Lv1TaBwd_L1 / 2.0), logi_Lv1TaBwd, "phys_Lv1TaBwd_name", &topVolume, false,
1094 0);
1095 } else {
1096 // Get parameters from .xml file
1097 //double Lv1TaBwd_L2 = m_config.getParameter(prep + "L2") * unitFactor;
1098 //double Lv1TaBwd_L3 = m_config.getParameter(prep + "L3") * unitFactor;
1099 double Lv1TaBwd_T1 = m_config.getParameter(prep + "T1") * unitFactor;
1100 double Lv1TaBwd_aR1 = m_config.getParameter(prep + "aR1") * unitFactor;
1101 double Lv1TaBwd_aR2 = m_config.getParameter(prep + "aR2") * unitFactor;
1102 double Lv1TaBwd_bL1 = Lv1TaBwd_L1 - Lv1TaBwd_aL1 - Lv1TaBwd_aL2 - Lv1TaBwd_aL3;
1103 double Lv1TaBwd_bL2 = m_config.getParameter(prep + "bL2") * unitFactor;
1104 double Lv1TaBwd_bL3 = m_config.getParameter(prep + "bL3") * unitFactor;
1105
1106 string strMat_Lv1TaBwd = m_config.getParameterStr(prep + "Material");
1107 G4Material* mat_Lv1TaBwd = Materials::get(strMat_Lv1TaBwd);
1108
1109 // Define geometry
1110 //G4Trd* geo_Lv1TaBwd_x = new G4Trd("geo_Lv1TaBwd_x_name", Lv1TaBwd_L2, Lv1TaBwd_L3, Lv1TaBwd_T1, Lv1TaBwd_T1, Lv1TaBwd_L1 / 2.0);
1111 double Lv1TaBwd_aR[4] = {Lv1TaBwd_aR2, Lv1TaBwd_aR2, Lv1TaBwd_aR1, Lv1TaBwd_aR1};
1112 double Lv1TaBwd_ar[4] = {0, 0, 0, 0};
1113 double Lv1TaBwd_aL[4] = { +Lv1TaBwd_L1 / 2.0 - (Lv1TaBwd_aL1 + Lv1TaBwd_aL2 + Lv1TaBwd_aL3),
1114 +Lv1TaBwd_L1 / 2.0 - (Lv1TaBwd_aL1 + Lv1TaBwd_aL2),
1115 +Lv1TaBwd_L1 / 2.0 - (Lv1TaBwd_aL1),
1116 +Lv1TaBwd_L1 / 2.0 - 0
1117 };
1118 G4VSolid* geo_Lv1TaBwd_a = new G4Polycone("geo_Lv1TaBwd_a_name", 0, 2 * M_PI, 4, Lv1TaBwd_aL, Lv1TaBwd_ar, Lv1TaBwd_aR);
1119 G4VSolid* geo_Lv1TaBwd_b = new G4Trd("geo_Lv1TaBwd_b_name", Lv1TaBwd_bL2, Lv1TaBwd_bL3, Lv1TaBwd_T1, Lv1TaBwd_T1,
1120 Lv1TaBwd_bL1 / 2.0);
1121 G4VSolid* geo_Lv1TaBwd_c = new G4Box("geo_Lv1TaBwd_c_name", 200, Lv1TaBwd_T1, (Lv1TaBwd_aL1 + Lv1TaBwd_aL2 + Lv1TaBwd_aL3) / 2.0);
1122 geo_Lv1TaBwd_d = new G4IntersectionSolid("geo_Lv1TaBwd_d_name", geo_Lv1TaBwd_a, geo_Lv1TaBwd_c, G4Translate3D(0, 0,
1123 +Lv1TaBwd_L1 / 2.0 - (Lv1TaBwd_aL1 + Lv1TaBwd_aL2 + Lv1TaBwd_aL3) / 2.0));
1124 G4VSolid* geo_Lv1TaBwd_x = new G4UnionSolid("geo_Lv1TaBwd_x_name", geo_Lv1TaBwd_d, geo_Lv1TaBwd_b, G4Translate3D(0, 0,
1125 -Lv1TaBwd_L1 / 2.0 + Lv1TaBwd_bL1 / 2.0));
1126 geo_Lv1TaBwd = new G4UnionSolid("geo_Lv1TaBwd_name", geo_Lv1TaBwd_x, geo_Flange,
1127 G4Translate3D(0, 0, -Flange_D - (-Lv1TaBwd_D1 - Lv1TaBwd_L1 / 2.0)));
1128 logi_Lv1TaBwd = new G4LogicalVolume(geo_Lv1TaBwd, mat_Lv1TaBwd, "logi_Lv1TaBwd_name");
1129
1130 // Put volume
1131 setColor(*logi_Lv1TaBwd, "#333333");
1132 new G4PVPlacement(0, G4ThreeVector(0, 0, -Lv1TaBwd_D1 - Lv1TaBwd_L1 / 2.0), logi_Lv1TaBwd, "phys_Lv1TaBwd_name", &topVolume, false,
1133 0);
1134 }
1135
1136
1137 //----------
1138 //- Lv2VacBwd
1139
1140 // Get parameters from .xml file
1141 prep = "Lv2VacBwd.";
1142
1143 double Lv2VacBwd_D1 = m_config.getParameter(prep + "D1") * unitFactor;
1144 double Lv2VacBwd_D2 = m_config.getParameter(prep + "D2") * unitFactor;
1145 double Lv2VacBwd_D3 = m_config.getParameter(prep + "D3") * unitFactor;
1146 double Lv2VacBwd_L1 = m_config.getParameter(prep + "L1") * unitFactor;
1147 double Lv2VacBwd_L2 = m_config.getParameter(prep + "L2") * unitFactor;
1148 double Lv2VacBwd_L3 = m_config.getParameter(prep + "L3") * unitFactor;
1149 double Lv2VacBwd_R1 = m_config.getParameter(prep + "R1") * unitFactor;
1150 double Lv2VacBwd_R2 = m_config.getParameter(prep + "R2") * unitFactor;
1151 double Lv2VacBwd_R3 = m_config.getParameter(prep + "R3") * unitFactor;
1152 double Lv2VacBwd_R4 = m_config.getParameter(prep + "R4") * unitFactor;
1153 double Lv2VacBwd_A1 = m_config.getParameter(prep + "A1");
1154 double Lv2VacBwd_A2 = m_config.getParameter(prep + "A2");
1155
1156 string strMat_Lv2VacBwd = m_config.getParameterStr(prep + "Material");
1157 G4Material* mat_Lv2VacBwd = Materials::get(strMat_Lv2VacBwd);
1158
1159 // Part 1
1160 double Lv2VacBwd1_Z1 = sqrt(Lv2VacBwd_D1 * Lv2VacBwd_D1 + Lv2VacBwd_D2 * Lv2VacBwd_D2 - 2.*Lv2VacBwd_D1 * Lv2VacBwd_D2 * cos(
1161 Lv2VacBwd_A1));
1162 double Lv2VacBwd1_rI1 = 0.0;
1163 double Lv2VacBwd1_rO1 = Lv2VacBwd_R1;
1164
1165 double Lv2VacBwd1_Z2 = (Lv2VacBwd1_Z1 / 2. * cos(Lv2VacBwd_A2)) + SafetyLength;
1166 double Lv2VacBwd1_rI2 = 0.0;
1167 double Lv2VacBwd1_rO2 = 2 * Lv2VacBwd_R1;
1168 // Part 2
1169 double Lv2VacBwd2_Z1 = Lv2VacBwd_L1;
1170 double Lv2VacBwd2_rI1 = 0.0;
1171 double Lv2VacBwd2_rO1 = Lv2VacBwd_R2;
1172
1173 double Lv2VacBwd2_Z2 = (Lv2VacBwd_L1 / 2. * cos(Lv2VacBwd_A2)) + SafetyLength;
1174 double Lv2VacBwd2_rI2 = 0.0;
1175 double Lv2VacBwd2_rO2 = 2 * Lv2VacBwd_R2;
1176 // Part 3
1177 const int Lv2VacBwd3_num1 = 2; // cylindrical part
1178 const int Lv2VacBwd3_num2 = 3; // policone part
1179 // ----------->Cylindrical part
1180 double Lv2VacBwd_Z1[Lv2VacBwd3_num1];
1181 Lv2VacBwd_Z1[0] = 0.0;
1182 Lv2VacBwd_Z1[1] = -Lv2VacBwd_D3 + Lv2VacBwd_L2 - 0.03 * SafetyLength;
1183 double Lv2VacBwd_rI1[Lv2VacBwd3_num1];
1184 for (int tmpn = 0; tmpn < Lv2VacBwd3_num1; tmpn++) {
1185 Lv2VacBwd_rI1[tmpn] = 0.0;
1186 }
1187 double Lv2VacBwd_rO1[Lv2VacBwd3_num1];
1188 Lv2VacBwd_rO1[0] = Lv2VacBwd_R3;
1189 Lv2VacBwd_rO1[1] = Lv2VacBwd_R3;
1190 //<----------------
1191 //------------> Policone part
1192 double Lv2VacBwd_Z2[Lv2VacBwd3_num2];
1193 Lv2VacBwd_Z2[0] = -Lv2VacBwd_D3 + Lv2VacBwd_L2;
1194 Lv2VacBwd_Z2[1] = -Lv2VacBwd_D3;
1195 Lv2VacBwd_Z2[2] = -Lv2VacBwd_D3 - Lv2VacBwd_L3;
1196 double Lv2VacBwd_rI2[Lv2VacBwd3_num2];
1197 for (int tmpn = 0; tmpn < Lv2VacBwd3_num2; tmpn++) {
1198 Lv2VacBwd_rI2[tmpn] = 0.0;
1199 }
1200 double Lv2VacBwd_rO2[Lv2VacBwd3_num2];
1201 Lv2VacBwd_rO2[0] = Lv2VacBwd_R3;
1202 Lv2VacBwd_rO2[1] = Lv2VacBwd_R4;
1203 Lv2VacBwd_rO2[2] = Lv2VacBwd_R4;
1204 //<--------------
1205
1206
1207 // Define geometry
1208 // Part 1
1209 G4Tubs* geo_Lv2VacBwdPart1_1 = new G4Tubs("geo_Lv2VacBwdPart1_1_name", Lv2VacBwd1_rI1, Lv2VacBwd1_rO1, Lv2VacBwd1_Z1, 0, 2 * M_PI);
1210 G4Tubs* geo_Lv2VacBwdPart1_2 = new G4Tubs("geo_Lv2VacBwdPart1_2_name", Lv2VacBwd1_rI2, Lv2VacBwd1_rO2, Lv2VacBwd1_Z2, 0, 2 * M_PI);
1211 G4Transform3D transform_Lv2VacBwdPart1_2 = G4Translate3D(0., 0., 0.);
1212 transform_Lv2VacBwdPart1_2 = transform_Lv2VacBwdPart1_2 * G4RotateY3D(Lv2VacBwd_A2 / 2.);
1213 G4IntersectionSolid* geo_Lv2VacBwdPart1 = new G4IntersectionSolid("geo_Lv2VacBwdPart1_name", geo_Lv2VacBwdPart1_1,
1214 geo_Lv2VacBwdPart1_2, transform_Lv2VacBwdPart1_2);
1215 // Part 2
1216 G4Tubs* geo_Lv2VacBwdPart2_1 = new G4Tubs("geo_Lv2VacBwdPart2_1_name", Lv2VacBwd2_rI1, Lv2VacBwd2_rO1, Lv2VacBwd2_Z1, 0, 2 * M_PI);
1217 G4Tubs* geo_Lv2VacBwdPart2_2 = new G4Tubs("geo_Lv2VacBwdPart2_2_name", Lv2VacBwd2_rI2, Lv2VacBwd2_rO2, Lv2VacBwd2_Z2, 0, 2 * M_PI);
1218 G4Transform3D transform_Lv2VacBwdPart2_2 = G4Translate3D(0., 0., 0.);
1219 transform_Lv2VacBwdPart2_2 = transform_Lv2VacBwdPart2_2 * G4RotateY3D(-Lv2VacBwd_A2 / 2.);
1220 G4IntersectionSolid* geo_Lv2VacBwdPart2 = new G4IntersectionSolid("geo_Lv2VacBwdPart2_name", geo_Lv2VacBwdPart2_1,
1221 geo_Lv2VacBwdPart2_2, transform_Lv2VacBwdPart2_2);
1222 // Part 3
1223// G4Polycone* geo_Lv2VacBwdPart3 = new G4Polycone("geo_Lv2VacBwdPart3", 0, 2 * M_PI, Lv2VacBwd3_num, Lv2VacBwd_Z, Lv2VacBwd_rI, Lv2VacBwd_rO);
1224 G4Polycone* geo_Lv2VacBwdPart3_1 = new G4Polycone("geo_Lv2VacBwdPart3_1", 0, 2 * M_PI, Lv2VacBwd3_num1, Lv2VacBwd_Z1, Lv2VacBwd_rI1,
1225 Lv2VacBwd_rO1);
1226 G4Polycone* geo_Lv2VacBwdPart3_2 = new G4Polycone("geo_Lv2VacBwdPart3_2", 0, 2 * M_PI, Lv2VacBwd3_num2, Lv2VacBwd_Z2, Lv2VacBwd_rI2,
1227 Lv2VacBwd_rO2);
1228 G4Transform3D transform_Lv2VacBwdPart3_1 = G4Translate3D(-0.5, 0., 0.);
1229 transform_Lv2VacBwdPart3_1 = transform_Lv2VacBwdPart3_1 * G4RotateY3D(-Lv2VacBwd_A1 + A11);
1230 G4UnionSolid* geo_Lv2VacBwdPart3 = new G4UnionSolid("geo_Lv2VacBwdPart3_name", geo_Lv2VacBwdPart3_2, geo_Lv2VacBwdPart3_1,
1231 transform_Lv2VacBwdPart3_1);
1232 // Part1+2+3
1233 //tmp begin
1234 G4Transform3D transform_Lv2VacBwdPart1 = G4Translate3D((Lv2VacBwd_D1 * sin(Lv2VacBwd_A1) + Lv2VacBwd_D2 * sin(
1235 2.*Lv2VacBwd_A1)) / 2., 0.,
1236 -(Lv2VacBwd_D1 * cos(Lv2VacBwd_A1) + Lv2VacBwd_D2 * cos(2.*Lv2VacBwd_A1)) / 2.);
1237 //G4Transform3D transform_Lv2VacBwdPart1 = G4Translate3D((Lv2VacBwd_D1 * sin(Lv2VacBwd_A1) + Lv2VacBwd_D2 * sin(2.*Lv2VacBwd_A1)) / 2.05,
1238 // 0.,
1239 // -(Lv2VacBwd_D1 * cos(Lv2VacBwd_A1) + Lv2VacBwd_D2 * cos(2.*Lv2VacBwd_A1)) / 2.05);
1240 transform_Lv2VacBwdPart1 = transform_Lv2VacBwdPart1 * G4RotateY3D(-Lv2VacBwd_A1 - Lv2VacBwd_A2);
1241 //tmp end
1242
1243 G4Transform3D transform_Lv2VacBwdPart2 = G4Translate3D((Lv2VacBwd_D2 + Lv2VacBwd_L1 / 2.0) * sin(2.*Lv2VacBwd_A1), 0.,
1244 -(Lv2VacBwd_D2 + Lv2VacBwd_L1 / 2.0) * cos(2.*Lv2VacBwd_A1));
1245 transform_Lv2VacBwdPart2 = transform_Lv2VacBwdPart2 * G4RotateY3D(-2.*Lv2VacBwd_A1);
1246
1247 G4UnionSolid* geo_Lv2VacBwdxx = new G4UnionSolid("geo_Lv2VacBwdxx_name", geo_Lv2VacBwdPart3, geo_Lv2VacBwdPart1,
1248 transform_Lv2VacBwdPart1);
1249 G4UnionSolid* geo_Lv2VacBwdx = new G4UnionSolid("geo_Lv2VacBwdx_name", geo_Lv2VacBwdxx, geo_Lv2VacBwdPart2,
1250 transform_Lv2VacBwdPart2);
1251 // Intersection
1252 G4Transform3D transform_Lv2VacBwd = G4Translate3D(0., 0., +Lv1TaBwd_D1 + Lv1TaBwd_L1 / 2.);
1253 transform_Lv2VacBwd = transform_Lv2VacBwd * G4RotateY3D(+Lv2VacBwd_A1);
1254
1255 G4IntersectionSolid* geo_Lv2VacBwd = new G4IntersectionSolid("geo_Lv2VacBwd_name", geo_Lv1TaBwd, geo_Lv2VacBwdx,
1256 transform_Lv2VacBwd);
1257 G4LogicalVolume* logi_Lv2VacBwd = new G4LogicalVolume(geo_Lv2VacBwd, mat_Lv2VacBwd, "logi_Lv2VacBwd_name");
1258 if (flag_limitStep) logi_Lv2VacBwd->SetUserLimits(new G4UserLimits(stepMax));
1259
1260 // Put volume
1261 setColor(*logi_Lv2VacBwd, "#CCCCCC");
1262 //you must set this invisible, otherwise encounter segV.
1263 setVisibility(*logi_Lv2VacBwd, false);
1264 new G4PVPlacement(0, G4ThreeVector(0., 0., 0.), logi_Lv2VacBwd, "phys_Lv2VacBwd_name", logi_Lv1TaBwd, false, 0);
1265
1266
1267 //----------
1268 //- Lv2VacLERUp
1269
1270 // Get parameters from .xml file
1271 prep = "Lv2VacLERUp.";
1272
1273 double Lv2VacLERUp_rO[Lv1TaLERUp_num];
1274 for (int i = 0; i < Lv1TaLERUp_num; i++) {
1275 Lv2VacLERUp_rO[i] = m_config.getParameter(prep + "R1") * unitFactor;
1276 }
1277
1278 string strMat_Lv2VacLERUp = m_config.getParameterStr(prep + "Material");
1279 G4Material* mat_Lv2VacLERUp = Materials::get(strMat_Lv2VacLERUp);
1280
1281 // Define geometry
1282 G4Polycone* geo_Lv2VacLERUppcon = new G4Polycone("geo_Lv2VacLERUppcon_name", 0, 2 * M_PI, Lv1TaLERUp_num, &(Lv1TaLERUp_Z[0]),
1283 &(Lv1TaLERUp_rI[0]), &(Lv2VacLERUp_rO[0]));
1284 G4IntersectionSolid* geo_Lv2VacLERUp = new G4IntersectionSolid("geo_Lv2VacLERUp_name", geo_Lv2VacLERUppcon, geo_AreaTubeFwdpcon,
1285 transform_AreaTubeFwdForLER);
1286 G4LogicalVolume* logi_Lv2VacLERUp = new G4LogicalVolume(geo_Lv2VacLERUp, mat_Lv2VacLERUp, "logi_Lv2VacLERUp_name");
1287 if (flag_limitStep) logi_Lv2VacLERUp->SetUserLimits(new G4UserLimits(stepMax));
1288
1289
1290 // Put volume
1291 setColor(*logi_Lv2VacLERUp, "#CCCCCC");
1292 new G4PVPlacement(0, G4ThreeVector(0, 0, 0), logi_Lv2VacLERUp, "phys_Lv2VacLERUp_name", logi_Lv1TaLERUp, false, 0);
1293
1294
1295 //----------
1296 //- Lv2VacHERDwn
1297
1298 // Get parameters from .xml file
1299 prep = "Lv2VacHERDwn.";
1300
1301 double Lv2VacHERDwn_rO[Lv1TaHERDwn_num];
1302 for (int i = 0; i < Lv1TaHERDwn_num; i++) {
1303 Lv2VacHERDwn_rO[i] = m_config.getParameter(prep + "R1") * unitFactor;
1304 }
1305
1306 string strMat_Lv2VacHERDwn = m_config.getParameterStr(prep + "Material");
1307 G4Material* mat_Lv2VacHERDwn = Materials::get(strMat_Lv2VacHERDwn);
1308
1309 // Define geometry
1310 G4Polycone* geo_Lv2VacHERDwnpcon = new G4Polycone("geo_Lv2VacHERDwnpcon_name", 0, 2 * M_PI, Lv1TaHERDwn_num, &(Lv1TaHERDwn_Z[0]),
1311 &(Lv1TaHERDwn_rI[0]), &(Lv2VacHERDwn_rO[0]));
1312 G4IntersectionSolid* geo_Lv2VacHERDwn = new G4IntersectionSolid("", geo_Lv2VacHERDwnpcon, geo_AreaTubeFwdpcon,
1313 transform_AreaTubeFwdForHER);
1314 G4LogicalVolume* logi_Lv2VacHERDwn = new G4LogicalVolume(geo_Lv2VacHERDwn, mat_Lv2VacHERDwn, "logi_Lv2VacHERDwn_name");
1315 if (flag_limitStep) logi_Lv2VacHERDwn->SetUserLimits(new G4UserLimits(stepMax));
1316
1317 // Put volume
1318 setColor(*logi_Lv2VacHERDwn, "#CCCCCC");
1319 new G4PVPlacement(0, G4ThreeVector(0, 0, 0), logi_Lv2VacHERDwn, "phys_Lv2VacHERDwn_name", logi_Lv1TaHERDwn, false, 0);
1320
1321
1322 //----------
1323 //- Lv2VacHERUp
1324
1325 // Get parameters from .xml file
1326 prep = "Lv2VacHERUp.";
1327
1328 double Lv2VacHERUp_rO[Lv1TaHERUp_num];
1329 for (int i = 0; i < Lv1TaHERUp_num; i++) {
1330 Lv2VacHERUp_rO[i] = m_config.getParameter(prep + "R1") * unitFactor;
1331 }
1332
1333 string strMat_Lv2VacHERUp = m_config.getParameterStr(prep + "Material");
1334 G4Material* mat_Lv2VacHERUp = Materials::get(strMat_Lv2VacHERUp);
1335
1336 // Define geometry
1337 G4Polycone* geo_Lv2VacHERUppcon = new G4Polycone("geo_Lv2VacHERUppcon_name", 0, 2 * M_PI, Lv1TaHERUp_num, &(Lv1TaHERUp_Z[0]),
1338 &(Lv1TaHERUp_rI[0]), &(Lv2VacHERUp_rO[0]));
1339 G4IntersectionSolid* geo_Lv2VacHERUp = new G4IntersectionSolid("", geo_Lv2VacHERUppcon, geo_AreaTubeBwdpcon,
1340 transform_AreaTubeFwdForHER);
1341 G4LogicalVolume* logi_Lv2VacHERUp = new G4LogicalVolume(geo_Lv2VacHERUp, mat_Lv2VacHERUp, "logi_Lv2VacHERUp_name");
1342 if (flag_limitStep) logi_Lv2VacHERUp->SetUserLimits(new G4UserLimits(stepMax));
1343
1344 // Put volume
1345 setColor(*logi_Lv2VacHERUp, "#CCCCCC");
1346 new G4PVPlacement(0, G4ThreeVector(0, 0, 0), logi_Lv2VacHERUp, "phys_Lv2VacHERUp_name", logi_Lv1TaHERUp, false, 0);
1347
1348
1349 //----------
1350 //- Lv2VacLERDwn
1351
1352 // Get parameters from .xml file
1353 prep = "Lv2VacLERDwn.";
1354
1355 double Lv2VacLERDwn_rO[Lv1TaLERDwn_num];
1356 for (int i = 0; i < Lv1TaLERDwn_num; i++) {
1357 Lv2VacLERDwn_rO[i] = m_config.getParameter(prep + "R1") * unitFactor;
1358 }
1359
1360 string strMat_Lv2VacLERDwn = m_config.getParameterStr(prep + "Material");
1361 G4Material* mat_Lv2VacLERDwn = Materials::get(strMat_Lv2VacLERDwn);
1362
1363 // Define geometry
1364 G4Polycone* geo_Lv2VacLERDwnpcon = new G4Polycone("geo_Lv2VacLERDwnpcon_name", 0, 2 * M_PI, Lv1TaLERDwn_num, &(Lv1TaLERDwn_Z[0]),
1365 &(Lv1TaLERDwn_rI[0]), &(Lv2VacLERDwn_rO[0]));
1366 G4IntersectionSolid* geo_Lv2VacLERDwn = new G4IntersectionSolid("", geo_Lv2VacLERDwnpcon, geo_AreaTubeBwdpcon,
1367 transform_AreaTubeBwdForLER);
1368 G4LogicalVolume* logi_Lv2VacLERDwn = new G4LogicalVolume(geo_Lv2VacLERDwn, mat_Lv2VacLERDwn, "logi_Lv2VacLERDwn_name");
1369 if (flag_limitStep) logi_Lv2VacLERDwn->SetUserLimits(new G4UserLimits(stepMax));
1370
1371 // Put volume
1372 setColor(*logi_Lv2VacLERDwn, "#CCCCCC");
1373 new G4PVPlacement(0, G4ThreeVector(0, 0, 0), logi_Lv2VacLERDwn, "phys_Lv2VacLERDwn_name", logi_Lv1TaLERDwn, false, 0);
1374
1375
1376 //----------
1377 // Cu flange
1378
1379 G4IntersectionSolid* geo_CuFlangeFwd_x2 = new G4IntersectionSolid("geo_CuFlangeFwd_x2_name", geo_AreaTubeFwdpcon, geo_Flange,
1380 G4Translate3D(0, 0, Flange_D + Flange_T * 2));
1381 G4SubtractionSolid* geo_CuFlangeFwd_x = new G4SubtractionSolid("geo_CuFlangeFwd_x_name", geo_CuFlangeFwd_x2, geo_Lv1TaLERUp,
1382 transform_Lv1TaLERUp);
1383 G4SubtractionSolid* geo_CuFlangeFwd = new G4SubtractionSolid("geo_CuFlangeFwd_name", geo_CuFlangeFwd_x, geo_Lv1TaHERDwn,
1384 transform_Lv1TaHERDwn);
1385
1386 G4LogicalVolume* logi_CuFlangeFwd = new G4LogicalVolume(geo_CuFlangeFwd, mat_Lv1TaLERUp, "logi_CuFlangeFwd_name");
1387
1388 // Put volume
1389 setColor(*logi_CuFlangeFwd, "#CCCCCC");
1390 new G4PVPlacement(0, G4ThreeVector(0, 0, 0), logi_CuFlangeFwd, "phys_CuFlangeFwd_name", &topVolume, false, 0);
1391
1392
1393
1394
1395 G4IntersectionSolid* geo_CuFlangeBwd_x2 = new G4IntersectionSolid("geo_CuFlangeBwd_x2_name", geo_AreaTubeBwdpcon, geo_Flange,
1396 G4Translate3D(0, 0, -Flange_D - Flange_T * 2));
1397 G4SubtractionSolid* geo_CuFlangeBwd_x = new G4SubtractionSolid("geo_CuFlangeBwd_x_name", geo_CuFlangeBwd_x2, geo_Lv1TaHERUp,
1398 transform_Lv1TaHERUp);
1399 G4SubtractionSolid* geo_CuFlangeBwd = new G4SubtractionSolid("geo_CuFlangeBwd_name", geo_CuFlangeBwd_x, geo_Lv1TaLERDwn,
1400 transform_Lv1TaLERDwn);
1401
1402 G4LogicalVolume* logi_CuFlangeBwd = new G4LogicalVolume(geo_CuFlangeBwd, mat_Lv1TaLERUp, "logi_CuFlangeBwd_name");
1403
1404 // Put volume
1405 setColor(*logi_CuFlangeBwd, "#CCCCCC");
1406 new G4PVPlacement(0, G4ThreeVector(0, 0, 0), logi_CuFlangeBwd, "phys_CuFlangeBwd_name", &topVolume, false, 0);
1407
1408
1409 // Components installed after Phase 2
1410 if (!phase2) {
1411 //- Lv2OutTi
1412 // Get parameters from .xml file
1413 prep = "Lv2OutTi.";
1414
1415 const int Lv2OutTi_num = 2;
1416
1417 double Lv2OutTi_Z[Lv2OutTi_num];
1418 Lv2OutTi_Z[0] = m_config.getParameter(prep + "L1") * unitFactor;
1419 Lv2OutTi_Z[1] = m_config.getParameter(prep + "L2") * unitFactor;
1420
1421 double Lv2OutTi_rI[Lv2OutTi_num];
1422 Lv2OutTi_rI[0] = m_config.getParameter(prep + "R1") * unitFactor;
1423 Lv2OutTi_rI[1] = Lv2OutTi_rI[0];
1424
1425 double Lv2OutTi_rO[Lv2OutTi_num];
1426 Lv2OutTi_rO[0] = m_config.getParameter(prep + "R2") * unitFactor;
1427 Lv2OutTi_rO[1] = Lv2OutTi_rO[0];
1428
1429 string strMat_Lv2OutTi = m_config.getParameterStr(prep + "Material");
1430 G4Material* mat_Lv2OutTi = Materials::get(strMat_Lv2OutTi);
1431
1432 // Define geometry
1433 G4Polycone* geo_Lv2OutTi = new G4Polycone("geo_Lv2OutTi_name", 0, 2 * M_PI, Lv2OutTi_num, Lv2OutTi_Z, Lv2OutTi_rI, Lv2OutTi_rO);
1434 G4LogicalVolume* logi_Lv2OutTi = new G4LogicalVolume(geo_Lv2OutTi, mat_Lv2OutTi, "logi_Lv2OutTi_name");
1435
1436 // Put volume
1437 setColor(*logi_Lv2OutTi, "#333300");
1438 new G4PVPlacement(0, G4ThreeVector(0, 0, 0), logi_Lv2OutTi, "phys_Lv2OutTi_name", logi_Lv1SUS, false, 0);
1439
1440
1441 //----------
1442 //-Lv1SUSLERUp
1443 prep = "Lv1SUSLERUp.";
1444 int Lv1SUSLERUp_num = int(m_config.getParameter(prep + "N"));
1445 vector<double> Lv1SUSLERUp_Z(Lv1SUSLERUp_num);
1446 vector<double> Lv1SUSLERUp_rI(Lv1SUSLERUp_num);
1447 vector<double> Lv1SUSLERUp_rO(Lv1SUSLERUp_num);
1448
1449 for (int i = 0; i < Lv1SUSLERUp_num; i++) {
1450 ostringstream ossZ_Lv1SUSLERUp;
1451 ossZ_Lv1SUSLERUp << "Z" << i;
1452 ostringstream ossRI_Lv1SUSLERUp;
1453 ossRI_Lv1SUSLERUp << "RI" << i;
1454 ostringstream ossRO_Lv1SUSLERUp;
1455 ossRO_Lv1SUSLERUp << "RO" << i;
1456
1457 Lv1SUSLERUp_Z[i] = m_config.getParameter(prep + ossZ_Lv1SUSLERUp.str()) * unitFactor;
1458 Lv1SUSLERUp_rI[i] = m_config.getParameter(prep + ossRI_Lv1SUSLERUp.str()) * unitFactor;
1459 Lv1SUSLERUp_rO[i] = m_config.getParameter(prep + ossRO_Lv1SUSLERUp.str()) * unitFactor;
1460 }
1461
1462 string strMat_Lv1SUSLERUp = m_config.getParameterStr(prep + "Material");
1463 G4Material* mat_Lv1SUSLERUp = Materials::get(strMat_Lv1SUSLERUp);
1464
1465 G4Polycone* geo_Lv1SUSLERUppcon = new G4Polycone("geo_Lv1SUSLERUppcon_name", 0, 2 * M_PI, Lv1SUSLERUp_num, &(Lv1SUSLERUp_Z[0]),
1466 &(Lv1SUSLERUp_rI[0]), &(Lv1SUSLERUp_rO[0]));
1467 G4IntersectionSolid* geo_Lv1SUSLERUp = new G4IntersectionSolid("", geo_Lv1SUSLERUppcon, geo_AreaTubeFwdpcon,
1468 transform_AreaTubeFwdForLER);
1469 G4LogicalVolume* logi_Lv1SUSLERUp = new G4LogicalVolume(geo_Lv1SUSLERUp, mat_Lv1SUSLERUp, "logi_Lv1SUSLERUp_name");
1470
1471 //-put volume
1472 setColor(*logi_Lv1SUSLERUp, "#666666");
1473 new G4PVPlacement(transform_Lv1TaLERUp, logi_Lv1SUSLERUp, "phys_Lv1SUSLERUp_name", &topVolume, false, 0);
1474
1475
1476 //----------
1477 //-Lv1SUSHERDwn
1478 prep = "Lv1SUSHERDwn.";
1479 int Lv1SUSHERDwn_num = int(m_config.getParameter(prep + "N"));
1480 vector<double> Lv1SUSHERDwn_Z(Lv1SUSHERDwn_num);
1481 vector<double> Lv1SUSHERDwn_rI(Lv1SUSHERDwn_num);
1482 vector<double> Lv1SUSHERDwn_rO(Lv1SUSHERDwn_num);
1483
1484 for (int i = 0; i < Lv1SUSHERDwn_num; i++) {
1485 ostringstream ossZ_Lv1SUSHERDwn;
1486 ossZ_Lv1SUSHERDwn << "Z" << i;
1487 ostringstream ossRI_Lv1SUSHERDwn;
1488 ossRI_Lv1SUSHERDwn << "RI" << i;
1489 ostringstream ossRO_Lv1SUSHERDwn;
1490 ossRO_Lv1SUSHERDwn << "RO" << i;
1491
1492 Lv1SUSHERDwn_Z[i] = m_config.getParameter(prep + ossZ_Lv1SUSHERDwn.str()) * unitFactor;
1493 Lv1SUSHERDwn_rI[i] = m_config.getParameter(prep + ossRI_Lv1SUSHERDwn.str()) * unitFactor;
1494 Lv1SUSHERDwn_rO[i] = m_config.getParameter(prep + ossRO_Lv1SUSHERDwn.str()) * unitFactor;
1495 }
1496
1497 string strMat_Lv1SUSHERDwn = m_config.getParameterStr(prep + "Material");
1498 G4Material* mat_Lv1SUSHERDwn = Materials::get(strMat_Lv1SUSHERDwn);
1499 //G4Material* mat_Lv1SUSHERDwn = mat_Lv1SUS;
1500
1501 G4Polycone* geo_Lv1SUSHERDwnpcon = new G4Polycone("geo_Lv1SUSHERDwnpcon_name", 0, 2 * M_PI, Lv1SUSHERDwn_num, &(Lv1SUSHERDwn_Z[0]),
1502 &(Lv1SUSHERDwn_rI[0]), &(Lv1SUSHERDwn_rO[0]));
1503 G4IntersectionSolid* geo_Lv1SUSHERDwn = new G4IntersectionSolid("", geo_Lv1SUSHERDwnpcon, geo_AreaTubeFwdpcon,
1504 transform_AreaTubeFwdForHER);
1505 G4LogicalVolume* logi_Lv1SUSHERDwn = new G4LogicalVolume(geo_Lv1SUSHERDwn, mat_Lv1SUSHERDwn, "logi_Lv1SUSHERDwn_name");
1506
1507 //-put volume
1508 setColor(*logi_Lv1SUSHERDwn, "#666666");
1509 new G4PVPlacement(transform_Lv1TaHERDwn, logi_Lv1SUSHERDwn, "phys_Lv1SUSHERDwn_name", &topVolume, false, 0);
1510
1511
1512 //----------
1513 //-Lv1SUSHERUp
1514 prep = "Lv1SUSHERUp.";
1515 int Lv1SUSHERUp_num = int(m_config.getParameter(prep + "N"));
1516 vector<double> Lv1SUSHERUp_Z(Lv1SUSHERUp_num);
1517 vector<double> Lv1SUSHERUp_rI(Lv1SUSHERUp_num);
1518 vector<double> Lv1SUSHERUp_rO(Lv1SUSHERUp_num);
1519
1520 for (int i = 0; i < Lv1SUSHERUp_num; i++) {
1521 ostringstream ossZ_Lv1SUSHERUp;
1522 ossZ_Lv1SUSHERUp << "Z" << i;
1523 ostringstream ossRI_Lv1SUSHERUp;
1524 ossRI_Lv1SUSHERUp << "RI" << i;
1525 ostringstream ossRO_Lv1SUSHERUp;
1526 ossRO_Lv1SUSHERUp << "RO" << i;
1527
1528 Lv1SUSHERUp_Z[i] = m_config.getParameter(prep + ossZ_Lv1SUSHERUp.str()) * unitFactor;
1529 Lv1SUSHERUp_rI[i] = m_config.getParameter(prep + ossRI_Lv1SUSHERUp.str()) * unitFactor;
1530 Lv1SUSHERUp_rO[i] = m_config.getParameter(prep + ossRO_Lv1SUSHERUp.str()) * unitFactor;
1531 }
1532
1533 string strMat_Lv1SUSHERUp = m_config.getParameterStr(prep + "Material");
1534 G4Material* mat_Lv1SUSHERUp = Materials::get(strMat_Lv1SUSHERUp);
1535
1536 G4Polycone* geo_Lv1SUSHERUppcon = new G4Polycone("geo_Lv1SUSHERUppcon_name", 0, 2 * M_PI, Lv1SUSHERUp_num, &(Lv1SUSHERUp_Z[0]),
1537 &(Lv1SUSHERUp_rI[0]), &(Lv1SUSHERUp_rO[0]));
1538 G4IntersectionSolid* geo_Lv1SUSHERUp = new G4IntersectionSolid("", geo_Lv1SUSHERUppcon, geo_AreaTubeBwdpcon,
1539 transform_AreaTubeFwdForHER);
1540 G4LogicalVolume* logi_Lv1SUSHERUp = new G4LogicalVolume(geo_Lv1SUSHERUp, mat_Lv1SUSHERUp, "logi_Lv1SUSHERUp_name");
1541
1542 //-put volume
1543 setColor(*logi_Lv1SUSHERUp, "#666666");
1544 new G4PVPlacement(transform_Lv1TaHERUp, logi_Lv1SUSHERUp, "phys_Lv1SUSHERUp_name", &topVolume, false, 0);
1545
1546
1547 //----------
1548 //-Lv1SUSLERDwn
1549 prep = "Lv1SUSLERDwn.";
1550 int Lv1SUSLERDwn_num = int(m_config.getParameter(prep + "N"));
1551 vector<double> Lv1SUSLERDwn_Z(Lv1SUSLERDwn_num);
1552 vector<double> Lv1SUSLERDwn_rI(Lv1SUSLERDwn_num);
1553 vector<double> Lv1SUSLERDwn_rO(Lv1SUSLERDwn_num);
1554
1555 for (int i = 0; i < Lv1SUSLERDwn_num; i++) {
1556 ostringstream ossZ_Lv1SUSLERDwn;
1557 ossZ_Lv1SUSLERDwn << "Z" << i;
1558 ostringstream ossRI_Lv1SUSLERDwn;
1559 ossRI_Lv1SUSLERDwn << "RI" << i;
1560 ostringstream ossRO_Lv1SUSLERDwn;
1561 ossRO_Lv1SUSLERDwn << "RO" << i;
1562
1563 Lv1SUSLERDwn_Z[i] = m_config.getParameter(prep + ossZ_Lv1SUSLERDwn.str()) * unitFactor;
1564 Lv1SUSLERDwn_rI[i] = m_config.getParameter(prep + ossRI_Lv1SUSLERDwn.str()) * unitFactor;
1565 Lv1SUSLERDwn_rO[i] = m_config.getParameter(prep + ossRO_Lv1SUSLERDwn.str()) * unitFactor;
1566 }
1567
1568 string strMat_Lv1SUSLERDwn = m_config.getParameterStr(prep + "Material");
1569 G4Material* mat_Lv1SUSLERDwn = Materials::get(strMat_Lv1SUSLERDwn);
1570
1571 G4Polycone* geo_Lv1SUSLERDwnpcon = new G4Polycone("geo_Lv1SUSLERDwnpcon_name", 0, 2 * M_PI, Lv1SUSLERDwn_num, &(Lv1SUSLERDwn_Z[0]),
1572 &(Lv1SUSLERDwn_rI[0]), &(Lv1SUSLERDwn_rO[0]));
1573 G4IntersectionSolid* geo_Lv1SUSLERDwn = new G4IntersectionSolid("", geo_Lv1SUSLERDwnpcon, geo_AreaTubeBwdpcon,
1574 transform_AreaTubeFwdForHER);
1575 G4LogicalVolume* logi_Lv1SUSLERDwn = new G4LogicalVolume(geo_Lv1SUSLERDwn, mat_Lv1SUSLERDwn, "logi_Lv1SUSLERDwn_name");
1576
1577 //-put volume
1578 setColor(*logi_Lv1SUSLERDwn, "#666666");
1579 new G4PVPlacement(transform_Lv1TaLERDwn, logi_Lv1SUSLERDwn, "phys_Lv1SUSLERDwn_name", &topVolume, false, 0);
1580
1581
1584
1585 //----------
1586 //- PXDMountFwd
1587
1588 // Get parameters from .xml file
1589 prep = "PXDMountFwd.";
1590
1591 double PXDMountFwd_Z1 = m_config.getParameter(prep + "Z1") * unitFactor;
1592 double PXDMountFwd_R1 = m_config.getParameter(prep + "R1") * unitFactor;
1593 double PXDMountFwd_D1 = m_config.getParameter(prep + "D1") * unitFactor;
1594 double PXDMountFwd_R2 = m_config.getParameter(prep + "R2") * unitFactor;
1595 double PXDMountFwd_L1 = m_config.getParameter(prep + "L1") * unitFactor;
1596 double PXDMountFwd_L2 = m_config.getParameter(prep + "L2") * unitFactor;
1597
1598 string strMat_PXDMountFwd = m_config.getParameterStr(prep + "Material");
1599 G4Material* mat_PXDMountFwd = Materials::get(strMat_PXDMountFwd);
1600
1601 // Define geometry
1602 G4VSolid* geo_PXDMountFwd_a = new G4Tubs("geo_PXDMountFwd_a", 0, PXDMountFwd_R1, PXDMountFwd_D1 / 2, 0, 2 * M_PI);
1603 G4VSolid* geo_PXDMountFwd_b = new G4SubtractionSolid("geo_PXDMountFwd_b", geo_PXDMountFwd_a, geo_Lv1TaFwd_d, G4Translate3D(0., 0.,
1604 -(-Lv1TaFwd_L1 / 2.0 + Lv1TaFwd_aL1 + Lv1TaFwd_aL2 + Lv1TaFwd_aL3) + PXDMountFwd_D1 / 2));
1605 G4VSolid* geo_PXDMountFwd_c = new G4Tubs("geo_PXDMountFwd_c", 0, PXDMountFwd_R2, 100, 0, 2 * M_PI);
1606 G4VSolid* geo_PXDMountFwd_d = new G4Box("geo_PXDMountFwd_d", PXDMountFwd_R1 - PXDMountFwd_L1, 100, PXDMountFwd_R2);
1607
1608 G4VSolid* geo_PXDMountFwd_p1 = new G4SubtractionSolid("geo_PXDMountFwd_p1", geo_PXDMountFwd_b, geo_PXDMountFwd_c,
1609 G4Translate3D(+PXDMountFwd_L1, 0., +(PXDMountFwd_D1 / 2 - PXDMountFwd_L2))*G4RotateX3D(M_PI / 2));
1610 G4VSolid* geo_PXDMountFwd_p2 = new G4SubtractionSolid("geo_PXDMountFwd_p2", geo_PXDMountFwd_p1, geo_PXDMountFwd_c,
1611 G4Translate3D(+PXDMountFwd_L1, 0., -(PXDMountFwd_D1 / 2 - PXDMountFwd_L2))*G4RotateX3D(M_PI / 2));
1612 G4VSolid* geo_PXDMountFwd_p3 = new G4SubtractionSolid("geo_PXDMountFwd_p3", geo_PXDMountFwd_p2, geo_PXDMountFwd_c,
1613 G4Translate3D(-PXDMountFwd_L1, 0., +(PXDMountFwd_D1 / 2 - PXDMountFwd_L2))*G4RotateX3D(M_PI / 2));
1614 G4VSolid* geo_PXDMountFwd_p4 = new G4SubtractionSolid("geo_PXDMountFwd_p4", geo_PXDMountFwd_p3, geo_PXDMountFwd_c,
1615 G4Translate3D(-PXDMountFwd_L1, 0., -(PXDMountFwd_D1 / 2 - PXDMountFwd_L2))*G4RotateX3D(M_PI / 2));
1616
1617 G4VSolid* geo_PXDMountFwd_q1 = new G4SubtractionSolid("geo_PXDMountFwd_q1", geo_PXDMountFwd_p4, geo_PXDMountFwd_d,
1618 G4Translate3D(+PXDMountFwd_R1, 0., +(PXDMountFwd_D1 / 2 - PXDMountFwd_L2)));
1619 G4VSolid* geo_PXDMountFwd_q2 = new G4SubtractionSolid("geo_PXDMountFwd_q2", geo_PXDMountFwd_q1, geo_PXDMountFwd_d,
1620 G4Translate3D(+PXDMountFwd_R1, 0., -(PXDMountFwd_D1 / 2 - PXDMountFwd_L2)));
1621 G4VSolid* geo_PXDMountFwd_q3 = new G4SubtractionSolid("geo_PXDMountFwd_q3", geo_PXDMountFwd_q2, geo_PXDMountFwd_d,
1622 G4Translate3D(-PXDMountFwd_R1, 0., +(PXDMountFwd_D1 / 2 - PXDMountFwd_L2)));
1623 G4VSolid* geo_PXDMountFwd_q4 = new G4SubtractionSolid("geo_PXDMountFwd_q4", geo_PXDMountFwd_q3, geo_PXDMountFwd_d,
1624 G4Translate3D(-PXDMountFwd_R1, 0., -(PXDMountFwd_D1 / 2 - PXDMountFwd_L2)));
1625
1626 G4VSolid* geo_PXDMountFwd = geo_PXDMountFwd_q4;
1627
1628 G4LogicalVolume* logi_PXDMountFwd = new G4LogicalVolume(geo_PXDMountFwd, mat_PXDMountFwd, "logi_PXDMountFwd_name");
1629 setColor(*logi_PXDMountFwd, "#333333");
1630
1631 new G4PVPlacement(0, G4ThreeVector(0, 0, +PXDMountFwd_D1 / 2 + PXDMountFwd_Z1), logi_PXDMountFwd, "phys_PXDMountFwd_name",
1632 &topVolume, false, 0);
1633
1634
1635 //adding the screws
1636 double PXDMountFixture_screw_radius = 0.2 * unitFactor;
1637 double PXDMountFixture_screw_length = 0.5 * unitFactor; //half z
1638 G4VSolid* geo_PXDMountFwd_s1 = new G4Tubs("geo_PXDMountFwd_s1", 0, PXDMountFixture_screw_radius, PXDMountFixture_screw_length, 0,
1639 2 * M_PI);
1640 G4VSolid* geo_PXDMountFwd_s2 = new G4Tubs("geo_PXDMountFwd_s2", 0, PXDMountFixture_screw_radius, PXDMountFixture_screw_length, 0,
1641 2 * M_PI);
1642 G4VSolid* geo_PXDMountFwd_s3 = new G4Tubs("geo_PXDMountFwd_s3", 0, PXDMountFixture_screw_radius, PXDMountFixture_screw_length, 0,
1643 2 * M_PI);
1644 G4VSolid* geo_PXDMountFwd_s4 = new G4Tubs("geo_PXDMountFwd_s4", 0, PXDMountFixture_screw_radius, PXDMountFixture_screw_length, 0,
1645 2 * M_PI);
1646
1647 G4Material* mat_PXDMountFwd_s = Materials::get("Cu");
1648
1649 G4Rotate3D rotate_PXDMountFwd = G4RotateX3D(-M_PI / 2.0 / Unit::rad);
1650 G4Transform3D transform_PXDMountFwd_s1 = G4Translate3D(+PXDMountFwd_L1, 0,
1651 PXDMountFwd_Z1 + PXDMountFwd_D1 - PXDMountFwd_L2) * rotate_PXDMountFwd;
1652 G4Transform3D transform_PXDMountFwd_s2 = G4Translate3D(+PXDMountFwd_L1, 0, PXDMountFwd_Z1 + PXDMountFwd_L2) * rotate_PXDMountFwd;
1653 G4Transform3D transform_PXDMountFwd_s3 = G4Translate3D(-PXDMountFwd_L1, 0,
1654 PXDMountFwd_Z1 + PXDMountFwd_D1 - PXDMountFwd_L2) * rotate_PXDMountFwd;
1655 G4Transform3D transform_PXDMountFwd_s4 = G4Translate3D(-PXDMountFwd_L1, 0, PXDMountFwd_Z1 + PXDMountFwd_L2) * rotate_PXDMountFwd;
1656
1657 G4LogicalVolume* logi_PXDMountFwd_s1 = new G4LogicalVolume(geo_PXDMountFwd_s1, mat_PXDMountFwd_s, "logi_PXDMountFwd_name_s1");
1658 G4LogicalVolume* logi_PXDMountFwd_s2 = new G4LogicalVolume(geo_PXDMountFwd_s2, mat_PXDMountFwd_s, "logi_PXDMountFwd_name_s2");
1659 G4LogicalVolume* logi_PXDMountFwd_s3 = new G4LogicalVolume(geo_PXDMountFwd_s3, mat_PXDMountFwd_s, "logi_PXDMountFwd_name_s3");
1660 G4LogicalVolume* logi_PXDMountFwd_s4 = new G4LogicalVolume(geo_PXDMountFwd_s4, mat_PXDMountFwd_s, "logi_PXDMountFwd_name_s4");
1661
1662 new G4PVPlacement(transform_PXDMountFwd_s1, logi_PXDMountFwd_s1, "phys_PXDMountFwd_name_s1", &topVolume, false, 0);
1663 new G4PVPlacement(transform_PXDMountFwd_s2, logi_PXDMountFwd_s2, "phys_PXDMountFwd_name_s2", &topVolume, false, 0);
1664 new G4PVPlacement(transform_PXDMountFwd_s3, logi_PXDMountFwd_s3, "phys_PXDMountFwd_name_s3", &topVolume, false, 0);
1665 new G4PVPlacement(transform_PXDMountFwd_s4, logi_PXDMountFwd_s4, "phys_PXDMountFwd_name_s4", &topVolume, false, 0);
1666
1667
1668 //----------
1669 //- PXDMountFixtureFwd
1670 prep = "PXDMountFixtureFwd.";
1671
1672 double PXDMountFixtureFwd_Z1 = m_config.getParameter(prep + "Z1") * unitFactor;
1673 double PXDMountFixtureFwd_R1 = m_config.getParameter(prep + "R1") * unitFactor;
1674 double PXDMountFixtureFwd_D1 = m_config.getParameter(prep + "D1") * unitFactor;
1675 double PXDMountFixtureFwd_T1 = m_config.getParameter(prep + "T1") * unitFactor;
1676 double PXDMountFixtureFwd_T2 = m_config.getParameter(prep + "T2") * unitFactor;
1677 double PXDMountFixtureFwd_FL = m_config.getParameter(prep + "I1") * unitFactor;
1678 double PXDMountFixtureFwd_inner_cut_phi = PXDMountFixtureFwd_FL / (PXDMountFwd_R1 + PXDMountFixtureFwd_T1);
1679 double PXDMountFixtureFwd_outter_uni_phi = (1 / 6.0) * M_PI - PXDMountFixtureFwd_FL / PXDMountFixtureFwd_R1;
1680
1681 string strMat_PXDMountFixtureFwd = m_config.getParameterStr(prep + "Material");
1682 G4Material* mat_PXDMountFixtureFwd = Materials::get(strMat_PXDMountFixtureFwd);
1683
1684 // Define geometry
1685 G4VSolid* geo_PXDMountFixtureFwd_a = new G4Tubs("geo_PXDMountFixtureFwd_a", 0, PXDMountFixtureFwd_R1 - PXDMountFixtureFwd_T2,
1686 PXDMountFixtureFwd_D1 / 2, 0,
1687 2 * M_PI);
1688 G4VSolid* geo_PXDMountFixtureFwd_b = new G4Box("geo_PXDMountFixtureFwd_b", PXDMountFixtureFwd_R1 * 0.5, 0.1 * unitFactor,
1689 100);
1690
1691 G4VSolid* geo_PXDMountFixtureFwd_b1 = new G4Box("geo_PXDMountFixtureFwd_b1", PXDMountFwd_R1 + PXDMountFixtureFwd_T1,
1692 PXDMountFixtureFwd_FL * 0.5, 100);
1693 G4VSolid* geo_PXDMountFixtureFwd_b2 = new G4Tubs("geo_PXDMountFixtureFwd_b2", PXDMountFwd_R1 + PXDMountFixtureFwd_T1,
1694 PXDMountFixtureFwd_R1, PXDMountFixtureFwd_D1 / 2,
1695 0, PXDMountFixtureFwd_outter_uni_phi);
1696 G4VSolid* geo_PXDMountFixtureFwd_b3 = new G4Box("geo_PXDMountFixtureFwd_b3", 0.2 * unitFactor, 0.35 * unitFactor,
1697 100 * unitFactor);
1698
1699 G4VSolid* geo_PXDMountFixtureFwd_a1 = new G4Tubs("geo_PXDMountFixtureFwd_a1", 0, PXDMountFwd_R1, 100, 0, 2 * M_PI);
1700
1701 G4VSolid* geo_PXDMountFixtureFwd_c1 = new G4SubtractionSolid("geo_PXDMountFixtureFwd_c1", geo_PXDMountFixtureFwd_a,
1702 geo_PXDMountFixtureFwd_a1);
1703
1704
1705 G4VSolid* geo_PXDMountFixtureFwd_d1 = geo_PXDMountFixtureFwd_c1;
1706 for (int i = 0; i < 4; ++i) {
1707
1708 geo_PXDMountFixtureFwd_d1 = new G4SubtractionSolid("geo_PXDMountFixtureFwd_d1", geo_PXDMountFixtureFwd_d1,
1709 geo_PXDMountFixtureFwd_b1, G4RotateZ3D(i * 0.25 * M_PI));
1710 }
1711 geo_PXDMountFixtureFwd_d1 = new G4SubtractionSolid("geo_PXDMountFixtureFwd_d1", geo_PXDMountFixtureFwd_d1,
1712 geo_PXDMountFixtureFwd_b, G4Translate3D(PXDMountFixtureFwd_R1, - PXDMountFixtureFwd_FL * 0.5, 0));
1713 geo_PXDMountFixtureFwd_d1 = new G4SubtractionSolid("geo_PXDMountFixtureFwd_d1", geo_PXDMountFixtureFwd_d1,
1714 geo_PXDMountFixtureFwd_b, G4Translate3D(-PXDMountFixtureFwd_R1, PXDMountFixtureFwd_FL * 0.5, 0));
1715
1716
1717 double PXDMountFixtureFwd_R1_temp = PXDMountFixtureFwd_R1 - PXDMountFixtureFwd_T2;
1718 for (int i = 2; i < 7; i += 4) {
1719
1720 geo_PXDMountFixtureFwd_d1 = new G4SubtractionSolid("geo_PXDMountFixtureFwd_d1", geo_PXDMountFixtureFwd_d1,
1721 geo_PXDMountFixtureFwd_b3,
1722 G4Translate3D(PXDMountFixtureFwd_R1_temp * cos(i * 0.25 * M_PI - 0.5 * PXDMountFixtureFwd_inner_cut_phi),
1723 PXDMountFixtureFwd_R1_temp * sin(i * 0.25 * M_PI - 0.5 * PXDMountFixtureFwd_inner_cut_phi),
1724 0)*G4RotateZ3D(i * 0.25 * M_PI - 0.5 * PXDMountFixtureFwd_inner_cut_phi));
1725
1726 geo_PXDMountFixtureFwd_d1 = new G4SubtractionSolid("geo_PXDMountFixtureFwd_d1", geo_PXDMountFixtureFwd_d1,
1727 geo_PXDMountFixtureFwd_b3,
1728 G4Translate3D(PXDMountFixtureFwd_R1_temp * cos(i * 0.25 * M_PI + 0.5 * PXDMountFixtureFwd_inner_cut_phi),
1729 PXDMountFixtureFwd_R1_temp * sin(i * 0.25 * M_PI + 0.5 * PXDMountFixtureFwd_inner_cut_phi),
1730 0)*G4RotateZ3D(i * 0.25 * M_PI + 0.5 * PXDMountFixtureFwd_inner_cut_phi));
1731
1732 }
1733 G4VSolid* geo_PXDMountFixtureFwd_d2 = geo_PXDMountFixtureFwd_d1;
1734 for (int i = 0; i < 12; ++i) {
1735 if (i == 2 || i == 3 || i == 8 || i == 9) continue;
1736 geo_PXDMountFixtureFwd_d2 = new G4UnionSolid("geo_PXDMountFixtureFwd_d1", geo_PXDMountFixtureFwd_d2,
1737 geo_PXDMountFixtureFwd_b2, G4RotateZ3D(i * (1 / 6.0) * M_PI + ((1 / 12.0)*M_PI - 0.5 * PXDMountFixtureFwd_outter_uni_phi)));
1738
1739 }
1740
1741 G4VSolid* geo_PXDMountFixtureFwd = geo_PXDMountFixtureFwd_d2;
1742 G4LogicalVolume* logi_PXDMountFixtureFwd = new G4LogicalVolume(geo_PXDMountFixtureFwd, mat_PXDMountFixtureFwd,
1743 "logi_PXDMountFixtureFwd_name");
1744 setColor(*logi_PXDMountFixtureFwd, "#333333");
1745
1746 new G4PVPlacement(0, G4ThreeVector(0, 0, +PXDMountFixtureFwd_D1 / 2 + PXDMountFixtureFwd_Z1), logi_PXDMountFixtureFwd,
1747 "phys_PXDMountFixtureFwd_name",
1748 &topVolume, false, 0);
1749
1750 //----------
1751 //- PXDMountBwd
1752
1753 // Get parameters from .xml file
1754 prep = "PXDMountBwd.";
1755
1756 double PXDMountBwd_Z1 = m_config.getParameter(prep + "Z1") * unitFactor;
1757 double PXDMountBwd_R1 = m_config.getParameter(prep + "R1") * unitFactor;
1758 double PXDMountBwd_D1 = m_config.getParameter(prep + "D1") * unitFactor;
1759 double PXDMountBwd_R2 = m_config.getParameter(prep + "R2") * unitFactor;
1760 double PXDMountBwd_L1 = m_config.getParameter(prep + "L1") * unitFactor;
1761 double PXDMountBwd_L2 = m_config.getParameter(prep + "L2") * unitFactor;
1762
1763 string strMat_PXDMountBwd = m_config.getParameterStr(prep + "Material");
1764 G4Material* mat_PXDMountBwd = Materials::get(strMat_PXDMountBwd);
1765
1766 // Define geometry
1767 G4VSolid* geo_PXDMountBwd_a = new G4Tubs("geo_PXDMountBwd_a", 0, PXDMountBwd_R1, PXDMountBwd_D1 / 2, 0, 2 * M_PI);
1768 G4VSolid* geo_PXDMountBwd_b = new G4SubtractionSolid("geo_PXDMountBwd_b", geo_PXDMountBwd_a, geo_Lv1TaBwd_d, G4Translate3D(0., 0.,
1769 -(+Lv1TaBwd_L1 / 2.0 - (Lv1TaBwd_aL1 + Lv1TaBwd_aL2 + Lv1TaBwd_aL3)) - PXDMountBwd_D1 / 2));
1770 G4VSolid* geo_PXDMountBwd_c = new G4Tubs("geo_PXDMountBwd_c", 0, PXDMountBwd_R2, 100, 0, 2 * M_PI);
1771 G4VSolid* geo_PXDMountBwd_d = new G4Box("geo_PXDMountBwd_d", PXDMountBwd_R1 - PXDMountBwd_L1, 100, PXDMountBwd_R2);
1772
1773 G4VSolid* geo_PXDMountBwd_p1 = new G4SubtractionSolid("geo_PXDMountBwd_p1", geo_PXDMountBwd_b, geo_PXDMountBwd_c,
1774 G4Translate3D(+PXDMountBwd_L1, 0., +(PXDMountBwd_D1 / 2 - PXDMountBwd_L2))*G4RotateX3D(M_PI / 2));
1775 G4VSolid* geo_PXDMountBwd_p2 = new G4SubtractionSolid("geo_PXDMountBwd_p2", geo_PXDMountBwd_p1, geo_PXDMountBwd_c,
1776 G4Translate3D(+PXDMountBwd_L1, 0., -(PXDMountBwd_D1 / 2 - PXDMountBwd_L2))*G4RotateX3D(M_PI / 2));
1777 G4VSolid* geo_PXDMountBwd_p3 = new G4SubtractionSolid("geo_PXDMountBwd_p3", geo_PXDMountBwd_p2, geo_PXDMountBwd_c,
1778 G4Translate3D(-PXDMountBwd_L1, 0., +(PXDMountBwd_D1 / 2 - PXDMountBwd_L2))*G4RotateX3D(M_PI / 2));
1779 G4VSolid* geo_PXDMountBwd_p4 = new G4SubtractionSolid("geo_PXDMountBwd_p4", geo_PXDMountBwd_p3, geo_PXDMountBwd_c,
1780 G4Translate3D(-PXDMountBwd_L1, 0., -(PXDMountBwd_D1 / 2 - PXDMountBwd_L2))*G4RotateX3D(M_PI / 2));
1781
1782 G4VSolid* geo_PXDMountBwd_q1 = new G4SubtractionSolid("geo_PXDMountBwd_q1", geo_PXDMountBwd_p4, geo_PXDMountBwd_d,
1783 G4Translate3D(+PXDMountBwd_R1, 0., +(PXDMountBwd_D1 / 2 - PXDMountBwd_L2)));
1784 G4VSolid* geo_PXDMountBwd_q2 = new G4SubtractionSolid("geo_PXDMountBwd_q2", geo_PXDMountBwd_q1, geo_PXDMountBwd_d,
1785 G4Translate3D(+PXDMountBwd_R1, 0., -(PXDMountBwd_D1 / 2 - PXDMountBwd_L2)));
1786 G4VSolid* geo_PXDMountBwd_q3 = new G4SubtractionSolid("geo_PXDMountBwd_q3", geo_PXDMountBwd_q2, geo_PXDMountBwd_d,
1787 G4Translate3D(-PXDMountBwd_R1, 0., +(PXDMountBwd_D1 / 2 - PXDMountBwd_L2)));
1788 G4VSolid* geo_PXDMountBwd_q4 = new G4SubtractionSolid("geo_PXDMountBwd_q4", geo_PXDMountBwd_q3, geo_PXDMountBwd_d,
1789 G4Translate3D(-PXDMountBwd_R1, 0., -(PXDMountBwd_D1 / 2 - PXDMountBwd_L2)));
1790
1791 G4VSolid* geo_PXDMountBwd = geo_PXDMountBwd_q4;
1792
1793 G4LogicalVolume* logi_PXDMountBwd = new G4LogicalVolume(geo_PXDMountBwd, mat_PXDMountBwd, "logi_PXDMountBwd_name");
1794 setColor(*logi_PXDMountBwd, "#333333");
1795
1796 new G4PVPlacement(0, G4ThreeVector(0, 0, -PXDMountBwd_D1 / 2 - PXDMountBwd_Z1), logi_PXDMountBwd, "phys_PXDMountBwd_name",
1797 &topVolume, false, 0);
1798
1799 // adding screws
1800
1801 G4VSolid* geo_PXDMountBwd_s1 = new G4Tubs("geo_PXDMountBwd_s1", 0, PXDMountFixture_screw_radius, PXDMountFixture_screw_length, 0,
1802 2 * M_PI);
1803 G4VSolid* geo_PXDMountBwd_s2 = new G4Tubs("geo_PXDMountBwd_s2", 0, PXDMountFixture_screw_radius, PXDMountFixture_screw_length, 0,
1804 2 * M_PI);
1805 G4VSolid* geo_PXDMountBwd_s3 = new G4Tubs("geo_PXDMountBwd_s3", 0, PXDMountFixture_screw_radius, PXDMountFixture_screw_length, 0,
1806 2 * M_PI);
1807 G4VSolid* geo_PXDMountBwd_s4 = new G4Tubs("geo_PXDMountBwd_s4", 0, PXDMountFixture_screw_radius, PXDMountFixture_screw_length, 0,
1808 2 * M_PI);
1809
1810 G4Material* mat_PXDMountBwd_s = Materials::get("Cu");
1811
1812 G4Rotate3D rotate_PXDMountBwd = G4RotateX3D(-M_PI / 2.0 / Unit::rad);
1813 G4Transform3D transform_PXDMountBwd_s1 = G4Translate3D(+PXDMountBwd_L1, 0,
1814 -PXDMountBwd_Z1 - PXDMountBwd_D1 + PXDMountBwd_L2) * rotate_PXDMountBwd;
1815 G4Transform3D transform_PXDMountBwd_s2 = G4Translate3D(+PXDMountBwd_L1, 0, -PXDMountBwd_Z1 - PXDMountBwd_L2) * rotate_PXDMountBwd;
1816 G4Transform3D transform_PXDMountBwd_s3 = G4Translate3D(-PXDMountBwd_L1, 0,
1817 -PXDMountBwd_Z1 - PXDMountBwd_D1 + PXDMountBwd_L2) * rotate_PXDMountBwd;
1818 G4Transform3D transform_PXDMountBwd_s4 = G4Translate3D(-PXDMountBwd_L1, 0, -PXDMountBwd_Z1 - PXDMountBwd_L2) * rotate_PXDMountBwd;
1819
1820 G4LogicalVolume* logi_PXDMountBwd_s1 = new G4LogicalVolume(geo_PXDMountBwd_s1, mat_PXDMountBwd_s, "logi_PXDMountBwd_name_s1");
1821 G4LogicalVolume* logi_PXDMountBwd_s2 = new G4LogicalVolume(geo_PXDMountBwd_s2, mat_PXDMountBwd_s, "logi_PXDMountBwd_name_s2");
1822 G4LogicalVolume* logi_PXDMountBwd_s3 = new G4LogicalVolume(geo_PXDMountBwd_s3, mat_PXDMountBwd_s, "logi_PXDMountBwd_name_s3");
1823 G4LogicalVolume* logi_PXDMountBwd_s4 = new G4LogicalVolume(geo_PXDMountBwd_s4, mat_PXDMountBwd_s, "logi_PXDMountBwd_name_s4");
1824
1825 new G4PVPlacement(transform_PXDMountBwd_s1, logi_PXDMountBwd_s1, "phys_PXDMountBwd_name_s1", &topVolume, false, 0);
1826 new G4PVPlacement(transform_PXDMountBwd_s2, logi_PXDMountBwd_s2, "phys_PXDMountBwd_name_s2", &topVolume, false, 0);
1827 new G4PVPlacement(transform_PXDMountBwd_s3, logi_PXDMountBwd_s3, "phys_PXDMountBwd_name_s3", &topVolume, false, 0);
1828 new G4PVPlacement(transform_PXDMountBwd_s4, logi_PXDMountBwd_s4, "phys_PXDMountBwd_name_s4", &topVolume, false, 0);
1829
1830
1831 //----------
1832 //- PXDMountFixtureBwd
1833 prep = "PXDMountFixtureBwd.";
1834
1835 double PXDMountFixtureBwd_Z1 = m_config.getParameter(prep + "Z1") * unitFactor;
1836 double PXDMountFixtureBwd_R1 = m_config.getParameter(prep + "R1") * unitFactor;
1837 double PXDMountFixtureBwd_D1 = m_config.getParameter(prep + "D1") * unitFactor;
1838 double PXDMountFixtureBwd_T1 = m_config.getParameter(prep + "T1") * unitFactor;
1839 double PXDMountFixtureBwd_T2 = m_config.getParameter(prep + "T2") * unitFactor;
1840 double PXDMountFixtureBwd_FL = m_config.getParameter(prep + "I1") * unitFactor;
1841 double PXDMountFixtureBwd_inner_cut_phi = PXDMountFixtureBwd_FL / (PXDMountBwd_R1 + PXDMountFixtureBwd_T1);
1842 double PXDMountFixtureBwd_outter_uni_phi = (1 / 6.0) * M_PI - PXDMountFixtureBwd_FL / PXDMountFixtureBwd_R1;
1843
1844 string strMat_PXDMountFixtureBwd = m_config.getParameterStr(prep + "Material");
1845 G4Material* mat_PXDMountFixtureBwd = Materials::get(strMat_PXDMountFixtureBwd);
1846
1847 // Define geometry
1848 G4VSolid* geo_PXDMountFixtureBwd_a = new G4Tubs("geo_PXDMountFixtureBwd_a", 0, PXDMountFixtureBwd_R1 - PXDMountFixtureBwd_T2,
1849 PXDMountFixtureBwd_D1 / 2, 0,
1850 2 * M_PI);
1851 G4VSolid* geo_PXDMountFixtureBwd_b = new G4Box("geo_PXDMountFixtureBwd_b", PXDMountFixtureBwd_R1 * 0.5, 0.1 * unitFactor,
1852 100);
1853
1854 G4VSolid* geo_PXDMountFixtureBwd_b1 = new G4Box("geo_PXDMountFixtureBwd_b1", PXDMountBwd_R1 + PXDMountFixtureBwd_T1,
1855 PXDMountFixtureBwd_FL * 0.5, 100);
1856 G4VSolid* geo_PXDMountFixtureBwd_b2 = new G4Tubs("geo_PXDMountFixtureBwd_b2", PXDMountBwd_R1 + PXDMountFixtureBwd_T1,
1857 PXDMountFixtureBwd_R1, PXDMountFixtureBwd_D1 / 2,
1858 0, PXDMountFixtureBwd_outter_uni_phi);
1859 G4VSolid* geo_PXDMountFixtureBwd_b3 = new G4Box("geo_PXDMountFixtureBwd_b3", 0.2 * unitFactor, 0.35 * unitFactor,
1860 100 * unitFactor);
1861
1862 G4VSolid* geo_PXDMountFixtureBwd_a1 = new G4Tubs("geo_PXDMountFixtureBwd_a1", 0, PXDMountBwd_R1, 100, 0, 2 * M_PI);
1863
1864 G4VSolid* geo_PXDMountFixtureBwd_c1 = new G4SubtractionSolid("geo_PXDMountFixtureBwd_c1", geo_PXDMountFixtureBwd_a,
1865 geo_PXDMountFixtureBwd_a1);
1866
1867
1868 G4VSolid* geo_PXDMountFixtureBwd_d1 = geo_PXDMountFixtureBwd_c1;
1869 for (int i = 0; i < 4; ++i) {
1870
1871 geo_PXDMountFixtureBwd_d1 = new G4SubtractionSolid("geo_PXDMountFixtureBwd_d1", geo_PXDMountFixtureBwd_d1,
1872 geo_PXDMountFixtureBwd_b1, G4RotateZ3D(i * 0.25 * M_PI));
1873 }
1874 geo_PXDMountFixtureBwd_d1 = new G4SubtractionSolid("geo_PXDMountFixtureBwd_d1", geo_PXDMountFixtureBwd_d1,
1875 geo_PXDMountFixtureBwd_b, G4Translate3D(PXDMountFixtureBwd_R1, - PXDMountFixtureBwd_FL * 0.5, 0));
1876 geo_PXDMountFixtureBwd_d1 = new G4SubtractionSolid("geo_PXDMountFixtureBwd_d1", geo_PXDMountFixtureBwd_d1,
1877 geo_PXDMountFixtureBwd_b, G4Translate3D(-PXDMountFixtureBwd_R1, PXDMountFixtureBwd_FL * 0.5, 0));
1878
1879
1880 double PXDMountFixtureBwd_R1_temp = PXDMountFixtureBwd_R1 - PXDMountFixtureBwd_T2;
1881 for (int i = 2; i < 7; i += 4) {
1882
1883 geo_PXDMountFixtureBwd_d1 = new G4SubtractionSolid("geo_PXDMountFixtureBwd_d1", geo_PXDMountFixtureBwd_d1,
1884 geo_PXDMountFixtureBwd_b3,
1885 G4Translate3D(PXDMountFixtureBwd_R1_temp * cos(i * 0.25 * M_PI - 0.5 * PXDMountFixtureBwd_inner_cut_phi),
1886 PXDMountFixtureBwd_R1_temp * sin(i * 0.25 * M_PI - 0.5 * PXDMountFixtureBwd_inner_cut_phi),
1887 0)*G4RotateZ3D(i * 0.25 * M_PI - 0.5 * PXDMountFixtureBwd_inner_cut_phi));
1888
1889 geo_PXDMountFixtureBwd_d1 = new G4SubtractionSolid("geo_PXDMountFixtureBwd_d1", geo_PXDMountFixtureBwd_d1,
1890 geo_PXDMountFixtureBwd_b3,
1891 G4Translate3D(PXDMountFixtureBwd_R1_temp * cos(i * 0.25 * M_PI + 0.5 * PXDMountFixtureBwd_inner_cut_phi),
1892 PXDMountFixtureBwd_R1_temp * sin(i * 0.25 * M_PI + 0.5 * PXDMountFixtureBwd_inner_cut_phi),
1893 0)*G4RotateZ3D(i * 0.25 * M_PI + 0.5 * PXDMountFixtureBwd_inner_cut_phi));
1894
1895 }
1896 G4VSolid* geo_PXDMountFixtureBwd_d2 = geo_PXDMountFixtureBwd_d1;
1897 for (int i = 0; i < 12; ++i) {
1898 if (i == 2 || i == 3 || i == 8 || i == 9) continue;
1899 geo_PXDMountFixtureBwd_d2 = new G4UnionSolid("geo_PXDMountFixtureBwd_d1", geo_PXDMountFixtureBwd_d2,
1900 geo_PXDMountFixtureBwd_b2, G4RotateZ3D(i * (1 / 6.0) * M_PI + ((1 / 12.0)*M_PI - 0.5 * PXDMountFixtureBwd_outter_uni_phi)));
1901
1902 }
1903
1904 G4VSolid* geo_PXDMountFixtureBwd = geo_PXDMountFixtureBwd_d2;
1905 G4LogicalVolume* logi_PXDMountFixtureBwd = new G4LogicalVolume(geo_PXDMountFixtureBwd, mat_PXDMountFixtureBwd,
1906 "logi_PXDMountFixtureBwd_name");
1907 setColor(*logi_PXDMountFixtureBwd, "#333333");
1908
1909 new G4PVPlacement(0, G4ThreeVector(0, 0, -PXDMountFixtureBwd_D1 / 2 - PXDMountFixtureBwd_Z1), logi_PXDMountFixtureBwd,
1910 "phys_PXDMountFixtureBwd_name",
1911 &topVolume, false, 0);
1912
1913 //---------------------------
1914 // for dose simulation
1915 //---------------------------
1916
1917 m_sensitive.push_back((SensitiveDetector*)(new BkgSensitiveDetector("IR", Index_sensi++)));
1918 logi_Lv1SUSLERUp->SetSensitiveDetector(m_sensitive.back());
1919
1920 m_sensitive.push_back((SensitiveDetector*)(new BkgSensitiveDetector("IR", Index_sensi++)));
1921 logi_Lv1SUSHERDwn->SetSensitiveDetector(m_sensitive.back());
1922
1923 m_sensitive.push_back((SensitiveDetector*)(new BkgSensitiveDetector("IR", Index_sensi++)));
1924 logi_Lv1SUSHERUp->SetSensitiveDetector(m_sensitive.back());
1925
1926 m_sensitive.push_back((SensitiveDetector*)(new BkgSensitiveDetector("IR", Index_sensi++)));
1927 logi_Lv1SUSLERDwn->SetSensitiveDetector(m_sensitive.back());
1928 }
1929
1930
1931 // Components installed after LS1
1932 if (!(phase2 || earlyPhase3)) {
1933 //- Lv2AuCoat
1934 prep = "Lv2AuCoat.";
1935
1936 const int Lv2AuCoat_num = 2;
1937
1938 // Part1
1939
1940 double Lv2AuCoat1_Z[Lv2AuCoat_num];
1941 Lv2AuCoat1_Z[0] = m_config.getParameter(prep + "L1") * unitFactor;
1942 Lv2AuCoat1_Z[1] = m_config.getParameter(prep + "L2") * unitFactor;
1943 double Lv2AuCoat1_rI[Lv2AuCoat_num];
1944 Lv2AuCoat1_rI[0] = m_config.getParameter(prep + "R1") * unitFactor;
1945 Lv2AuCoat1_rI[1] = Lv2AuCoat1_rI[0];
1946 double Lv2AuCoat1_rO[Lv2AuCoat_num];
1947 Lv2AuCoat1_rO[0] = m_config.getParameter(prep + "R2") * unitFactor;
1948 Lv2AuCoat1_rO[1] = Lv2AuCoat1_rO[0];
1949
1950 // Part2
1951
1952 double Lv2AuCoat2_Z[Lv2AuCoat_num];
1953 Lv2AuCoat2_Z[0] = m_config.getParameter(prep + "L3") * unitFactor;
1954 Lv2AuCoat2_Z[1] = m_config.getParameter(prep + "L4") * unitFactor;
1955 double Lv2AuCoat2_rI[Lv2AuCoat_num];
1956 Lv2AuCoat2_rI[0] = m_config.getParameter(prep + "R1") * unitFactor;
1957 Lv2AuCoat2_rI[1] = Lv2AuCoat2_rI[0];
1958 double Lv2AuCoat2_rO[Lv2AuCoat_num];
1959 Lv2AuCoat2_rO[0] = m_config.getParameter(prep + "R2") * unitFactor;
1960 Lv2AuCoat2_rO[1] = Lv2AuCoat2_rO[0];
1961
1962 string strMat_Lv2AuCoat = m_config.getParameterStr(prep + "Material");
1963 G4Material* mat_Lv2AuCoat = Materials::get(strMat_Lv2AuCoat);
1964
1965 // Define geometry
1966 G4Polycone* geo_Lv2AuCoat1 = new G4Polycone("geo_Lv2AuCoat1_name", 0, 2 * M_PI, Lv2AuCoat_num, Lv2AuCoat1_Z, Lv2AuCoat1_rI,
1967 Lv2AuCoat1_rO);
1968 G4Polycone* geo_Lv2AuCoat2 = new G4Polycone("geo_Lv2AuCoat2_name", 0, 2 * M_PI, Lv2AuCoat_num, Lv2AuCoat2_Z, Lv2AuCoat2_rI,
1969 Lv2AuCoat2_rO);
1970 //G4UnionSolid* geo_Lv2AuCoat = new G4UnionSolid("geo_Lv2AuCoat_name", geo_Lv2AuCoat1, geo_Lv2AuCoat2);
1971
1972 G4LogicalVolume* logi_Lv2AuCoat1 = new G4LogicalVolume(geo_Lv2AuCoat1, mat_Lv2AuCoat, "logi_Lv2AuCoat1_name");
1973 G4LogicalVolume* logi_Lv2AuCoat2 = new G4LogicalVolume(geo_Lv2AuCoat2, mat_Lv2AuCoat, "logi_Lv2AuCoat2_name");
1974
1975 // Put volume
1976 setColor(*logi_Lv2AuCoat1, "#CCCC00");
1977 setColor(*logi_Lv2AuCoat1, "#CCCC00");
1978 new G4PVPlacement(0, G4ThreeVector(0, 0, 0), logi_Lv2AuCoat1, "phys_Lv2AuCoat1_name", logi_Lv2Paraf, false, 0);
1979 new G4PVPlacement(0, G4ThreeVector(0, 0, 0), logi_Lv2AuCoat2, "phys_Lv2AuCoat2_name", logi_Lv2Paraf, false, 0);
1980 }
1981
1982
1983 //---------------------------
1984 // for dose simulation
1985 //---------------------------
1986
1987 m_sensitive.push_back((SensitiveDetector*)(new BkgSensitiveDetector("IR", Index_sensi++)));
1988 logi_Lv3AuCoat->SetSensitiveDetector(m_sensitive.back());
1989
1990 m_sensitive.push_back((SensitiveDetector*)(new BkgSensitiveDetector("IR", Index_sensi++)));
1991 logi_Lv1TaFwd->SetSensitiveDetector(m_sensitive.back());
1992
1993 m_sensitive.push_back((SensitiveDetector*)(new BkgSensitiveDetector("IR", Index_sensi++)));
1994 logi_Lv1TaBwd->SetSensitiveDetector(m_sensitive.back());
1995
1996 m_sensitive.push_back((SensitiveDetector*)(new BkgSensitiveDetector("IR", Index_sensi++)));
1997 logi_Lv1TaLERUp->SetSensitiveDetector(m_sensitive.back());
1998
1999 m_sensitive.push_back((SensitiveDetector*)(new BkgSensitiveDetector("IR", Index_sensi++)));
2000 logi_Lv1TaHERDwn->SetSensitiveDetector(m_sensitive.back());
2001
2002 m_sensitive.push_back((SensitiveDetector*)(new BkgSensitiveDetector("IR", Index_sensi++)));
2003 logi_Lv1TaHERUp->SetSensitiveDetector(m_sensitive.back());
2004
2005 m_sensitive.push_back((SensitiveDetector*)(new BkgSensitiveDetector("IR", Index_sensi++)));
2006 logi_Lv1TaLERDwn->SetSensitiveDetector(m_sensitive.back());
2007
2008 m_sensitive.push_back((SensitiveDetector*)(new BkgSensitiveDetector("IR", Index_sensi++)));
2009 logi_CuFlangeFwd->SetSensitiveDetector(m_sensitive.back());
2010
2011 m_sensitive.push_back((SensitiveDetector*)(new BkgSensitiveDetector("IR", Index_sensi++)));
2012 logi_CuFlangeBwd->SetSensitiveDetector(m_sensitive.back());
2013
2014 }
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: