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

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

#include <GeoCryostatCreator.h>

Inheritance diagram for GeoCryostatCreator:
CreatorBase

Public Member Functions

 GeoCryostatCreator ()
 Constructor of the GeoCryostatCreator class.
 
virtual ~GeoCryostatCreator ()
 The destructor of the GeoCryostatCreator class.
 
 GeoCryostatCreator (const GeoCryostatCreator &)=delete
 Do not want a copy constructor.
 
GeoCryostatCreator & operator= (const GeoCryostatCreator &)=delete
 Do not want an assignment operator.
 
virtual void create (const GearDir &content, G4LogicalVolume &topVolume, geometry::GeometryTypes type) override
 Creates the ROOT Objects for the Cryostat geometry.
 
virtual void createPayloads (const GearDir &content, const IntervalOfValidity &iov) override
 creates DB payload for CryostatGeo 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

SensitiveDetector * m_sensitive
 Sensitive detector.
 
CryostatGeo m_config
 geometry parameters object
 

Private Member Functions

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

Detailed Description

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


Definition at line 43 of file GeoCryostatCreator.h.

Constructor & Destructor Documentation

◆ GeoCryostatCreator()

GeoCryostatCreator ( )

Constructor of the GeoCryostatCreator class.

Definition at line 57 of file GeoCryostatCreator.cc.

58 {
59 m_sensitive = new SensitiveDetector();
60 }
Belle2::ir::GeoCryostatCreator::m_sensitive
SensitiveDetector * m_sensitive
Sensitive detector.
Definition: GeoCryostatCreator.h:117
Belle2::PXD::SensitiveDetector
VXD::SensitiveDetector< PXDSimHit, PXDTrueHit > SensitiveDetector
The PXD Sensitive Detector class.
Definition: SensitiveDetector.h:23

◆ ~GeoCryostatCreator()

~GeoCryostatCreator ( )
virtual

The destructor of the GeoCryostatCreator class.

Definition at line 62 of file GeoCryostatCreator.cc.

63 {
64 delete m_sensitive;
65 }

Member Function Documentation

◆ create()

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

Creates the ROOT Objects for the Cryostat 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 84 of file GeoCryostatCreator.h.

85 {
86 m_config = createConfiguration(content);
87
88 // override geometry configuration from the DB
89 DBStore::Instance().addConstantOverride("CryostatGeo", new CryostatGeo(m_config));
90
91 createGeometry(topVolume, type);
92 }
Belle2::ir::GeoCryostatCreator::m_config
CryostatGeo m_config
geometry parameters object
Definition: GeoCryostatCreator.h:118
Belle2::ir::GeoCryostatCreator::createGeometry
void createGeometry(G4LogicalVolume &topVolume, geometry::GeometryTypes type)
Create detector geometry.
Definition: GeoCryostatCreator.cc:67
Belle2::ir::GeoCryostatCreator::createConfiguration
CryostatGeo createConfiguration(const GearDir &param)
Reads IR geometry parameters from the xml files and createst DB class CryostatGeo.
Definition: GeoCryostatCreator.h:47
Belle2::DBStore::Instance
static DBStore & Instance()
Instance of a singleton DBStore.
Definition: DBStore.cc:26
Belle2::DBStore::addConstantOverride
void addConstantOverride(const std::string &name, TObject *obj, bool oneRun=false)
Add constant override payload.
Definition: DBStore.cc:202

◆ createConfiguration()

CryostatGeo createConfiguration ( const GearDir &  param)
inlineprivate

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

Definition at line 47 of file GeoCryostatCreator.h.

48 {
49 CryostatGeo CryostatGeoConfig;
50 CryostatGeoConfig.initialize(param);
51 return CryostatGeoConfig;
52 }

◆ 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 103 of file GeoCryostatCreator.h.

104 {
105 DBObjPtr<CryostatGeo> dbObj;
106 if (!dbObj) {
107 // Check that we found the object and if not report the problem
108 B2FATAL("No configuration for " << name << " found.");
109 }
110 m_config = *dbObj;
111 createGeometry(topVolume, type);
112 }

◆ createGeometry()

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

Create detector geometry.

Parameters
topVolumeGeant4 logical top volume.
typeGeometry type.

Definition at line 67 of file GeoCryostatCreator.cc.

68 {
69
70 //###### R side index ######
71 //
72 // +- A1spc1+A1spc2
73 // +- A2wal1
74 // +- A3wal1
75 // +- A3wal2
76 // +- A4mag1
77 // +- A4mag2
78 // +- A4mag3
79 // +- A4mag4
80 //
81 // +- B1spc1+B1spc2
82 // +- B2wal1
83 // +- B3wal1
84 // +- B3wal2
85 // +- B4mag1
86 // +- B4mag2
87 // +- B4mag3
88 // +- B4mag4
89 //
90 // +- C1wal1
91 // +- C2spc1
92 // +- C3wal1
93 // +- C4spc1
94 // +- C5wal1
95 // +- C6spc1
96 // +- C7lyr1
97 // +- C7lyr2
98 // +- C7lyr3
99 // +- C7lyr4
100 // +- C7lyr5
101 // +- C2spc2
102 // +- C3wal2
103 // +- C4spc2
104 // +- C5wal2
105 // +- C6spc2
106 // +- C7wal1
107 // +- C5wal3
108 // +- C5wal4
109 // +- C3wal3
110 // +- C2spc3
111 // +- C1wal2
112 //
113 //###### L side index ######
114 //
115 // +- D1spc1
116 // +- D2wal1
117 // +- D3wal1
118 // +- D3wal2
119 // +- D4mag1
120 // +- D4mag2
121 // +- D4mag3
122 //
123 // +- E1spc1
124 // +- E2wal1
125 // +- E3wal1
126 // +- E4mag1
127 // +- E4mag2
128 // +- E4mag3
129 //
130 // +- F1wal1
131 // +- F2spc1
132 // +- F3wal1
133 // +- F4spc1
134 // +- F5wal1
135 // +- F6spc1
136 // +- F7lyr1
137 // +- F7lyr2
138 // +- F7lyr3
139 // +- F7lyr4
140 // +- F7lyr5
141 // +- F3wal2
142 // +- F3wal3
143 // +- F3wal4
144 // +- F1wal2
145
146 double stepMax = 5.0 * Unit::mm;
147 int flag_limitStep = int(m_config.getParameter("LimitStepLength"));
148
149 const double unitFactor = Unit::cm / Unit::mm;
150
151 double crossingAngleHER = m_config.getParameter("CrossingAngle.HER", 0.0415);
152 double crossingAngleLER = m_config.getParameter("CrossingAngle.LER", -0.0415);
153
154 G4Transform3D transform_HER = G4Translate3D(0., 0., 0.);
155 transform_HER = transform_HER * G4RotateY3D(crossingAngleHER);
156
157 G4Transform3D transform_LER = G4Translate3D(0., 0., 0.);
158 transform_LER = transform_LER * G4RotateY3D(crossingAngleLER);
159
160 map<string, CryostatElement> elements;
161
162 //--------------
163 //- Bounding shapes
164
165 // right bounding shape 1
166 CryostatElement tubeR;
167 std::string prep = "TubeR.";
168
169 const int TubeR_N = int(m_config.getParameter(prep + "N"));
170
171 std::vector<double> TubeR_Z(TubeR_N);
172 std::vector<double> TubeR_R(TubeR_N);
173 std::vector<double> TubeR_r(TubeR_N);
174
175 for (int i = 0; i < TubeR_N; ++i) {
176 ostringstream ossZID;
177 ossZID << "Z" << i;
178
179 ostringstream ossRID;
180 ossRID << "R" << i;
181
182 ostringstream ossrID;
183 ossrID << "r" << i;
184
185 TubeR_Z[i] = m_config.getParameter(prep + ossZID.str()) * unitFactor;
186 TubeR_R[i] = m_config.getParameter(prep + ossRID.str()) * unitFactor;
187 TubeR_r[i] = m_config.getParameter(prep + ossrID.str(), 0.0) * unitFactor;
188 }
189
190 tubeR.transform = G4Translate3D(0., 0., 0.);
191 tubeR.geo = new G4Polycone("geo_TubeR_name", 0, 2 * M_PI, TubeR_N, &(TubeR_Z[0]), &(TubeR_r[0]), &(TubeR_R[0]));
192 tubeR.logi = NULL;
193 elements["TubeR"] = tubeR;
194
195 // right bounding shape 2
196 CryostatElement tubeR2;
197 prep = "TubeR2.";
198 const int TubeR2_N = int(m_config.getParameter(prep + "N"));
199
200 std::vector<double> TubeR2_Z(TubeR2_N);
201 std::vector<double> TubeR2_R(TubeR2_N);
202 std::vector<double> TubeR2_r(TubeR2_N);
203
204 for (int i = 0; i < TubeR2_N; ++i) {
205 ostringstream ossZID;
206 ossZID << "Z" << i;
207
208 ostringstream ossRID;
209 ossRID << "R" << i;
210
211 ostringstream ossrID;
212 ossrID << "r" << i;
213
214 TubeR2_Z[i] = m_config.getParameter(prep + ossZID.str()) * unitFactor;
215 TubeR2_R[i] = m_config.getParameter(prep + ossRID.str()) * unitFactor;
216 TubeR2_r[i] = m_config.getParameter(prep + ossrID.str(), 0.0) * unitFactor;
217 }
218
219 tubeR2.transform = G4Translate3D(0., 0., 0.);
220 tubeR2.geo = new G4Polycone("geo_TubeR2_name", 0, 2 * M_PI, TubeR2_N, &(TubeR2_Z[0]), &(TubeR2_r[0]), &(TubeR2_R[0]));
221 tubeR2.logi = NULL;
222 elements["TubeR2"] = tubeR2;
223
224 // left bounding shape
225 CryostatElement tubeL;
226 prep = "TubeL.";
227 const int TubeL_N = int(m_config.getParameter(prep + "N"));
228
229 std::vector<double> TubeL_Z(TubeL_N);
230 std::vector<double> TubeL_R(TubeL_N);
231 std::vector<double> TubeL_r(TubeL_N);
232
233 for (int i = 0; i < TubeL_N; ++i) {
234 ostringstream ossZID;
235 ossZID << "Z" << i;
236
237 ostringstream ossRID;
238 ossRID << "R" << i;
239
240 ostringstream ossrID;
241 ossrID << "r" << i;
242
243 TubeL_Z[i] = m_config.getParameter(prep + ossZID.str()) * unitFactor;
244 TubeL_R[i] = m_config.getParameter(prep + ossRID.str()) * unitFactor;
245 TubeL_r[i] = m_config.getParameter(prep + ossrID.str()) * unitFactor;
246 }
247
248 tubeL.transform = G4Translate3D(0., 0., 0.);
249 tubeL.geo = new G4Polycone("geo_TubeL_name", 0, 2 * M_PI, TubeL_N, &(TubeL_Z[0]), &(TubeL_r[0]), &(TubeL_R[0]));
250 tubeL.logi = NULL;
251 elements["TubeL"] = tubeL;
252
253 //--------------
254 // Special cases with complex geometry
255
256 //--------------
257 //- A1spc1 and B1spc1
258
259 // space containing all structures around right HER beam pipe, part 1
260 CryostatElement A1spc1;
261 prep = "A1spc1.";
262 const int A1spc1_N = int(m_config.getParameter(prep + "N"));
263
264 std::vector<double> A1spc1_Z(A1spc1_N);
265 std::vector<double> A1spc1_r(A1spc1_N);
266 std::vector<double> A1spc1_R(A1spc1_N);
267
268 for (int i = 0; i < A1spc1_N; ++i) {
269 ostringstream ossZID;
270 ossZID << "Z" << i;
271
272 ostringstream ossRID;
273 ossRID << "R" << i;
274
275 ostringstream ossrID;
276 ossrID << "r" << i;
277
278 A1spc1_Z[i] = m_config.getParameter(prep + ossZID.str()) * unitFactor;
279 A1spc1_R[i] = m_config.getParameter(prep + ossRID.str()) * unitFactor;
280 A1spc1_r[i] = m_config.getParameter(prep + ossrID.str(), 0.0) * unitFactor;
281 }
282
283 A1spc1.transform = transform_HER;
284 G4Polycone* geo_A1spc1xx = new G4Polycone("geo_A1spc1xx_name", 0, 2 * M_PI, A1spc1_N, &(A1spc1_Z[0]), &(A1spc1_r[0]),
285 &(A1spc1_R[0]));
286
287 // space containing all structures around right HER beam pipe, part 2
288 CryostatElement A1spc2;
289 prep = "A1spc2.";
290 const int A1spc2_N = int(m_config.getParameter(prep + "N"));
291
292 std::vector<double> A1spc2_Z(A1spc2_N);
293 std::vector<double> A1spc2_R(A1spc2_N);
294 std::vector<double> A1spc2_r(A1spc2_N);
295
296 for (int i = 0; i < A1spc2_N; ++i) {
297 ostringstream ossZID;
298 ossZID << "Z" << i;
299
300 ostringstream ossRID;
301 ossRID << "R" << i;
302
303 ostringstream ossrID;
304 ossrID << "r" << i;
305
306 A1spc2_Z[i] = m_config.getParameter(prep + ossZID.str()) * unitFactor;
307 A1spc2_R[i] = m_config.getParameter(prep + ossRID.str()) * unitFactor;
308 A1spc2_r[i] = m_config.getParameter(prep + ossrID.str(), 0.0) * unitFactor;
309 }
310
311 A1spc2.transform = transform_HER;
312 G4Polycone* geo_A1spc2xx = new G4Polycone("geo_A1spc2xx_name", 0, 2 * M_PI, A1spc2_N, &(A1spc2_Z[0]), &(A1spc2_r[0]),
313 &(A1spc2_R[0]));
314
315 // space containing all structures around right LER beam pipe, part 1
316 CryostatElement B1spc1;
317 prep = "B1spc1.";
318 const int B1spc1_N = int(m_config.getParameter(prep + "N"));
319
320 std::vector<double> B1spc1_Z(B1spc1_N);
321 std::vector<double> B1spc1_R(B1spc1_N);
322 std::vector<double> B1spc1_r(B1spc1_N);
323
324 for (int i = 0; i < B1spc1_N; ++i) {
325 ostringstream ossZID;
326 ossZID << "Z" << i;
327
328 ostringstream ossRID;
329 ossRID << "R" << i;
330
331 ostringstream ossrID;
332 ossrID << "r" << i;
333
334 B1spc1_Z[i] = m_config.getParameter(prep + ossZID.str()) * unitFactor;
335 B1spc1_R[i] = m_config.getParameter(prep + ossRID.str()) * unitFactor;
336 B1spc1_r[i] = m_config.getParameter(prep + ossrID.str(), 0.0) * unitFactor;
337 }
338
339 B1spc1.transform = transform_LER;
340 G4Polycone* geo_B1spc1xx = new G4Polycone("geo_B1spc1xx_name", 0, 2 * M_PI, B1spc1_N, &(B1spc1_Z[0]), &(B1spc1_r[0]),
341 &(B1spc1_R[0]));
342
343 // space containing all structures around right LER beam pipe, part 2
344 CryostatElement B1spc2;
345 prep = "B1spc2.";
346 const int B1spc2_N = int(m_config.getParameter(prep + "N"));
347
348 std::vector<double> B1spc2_Z(B1spc2_N);
349 std::vector<double> B1spc2_R(B1spc2_N);
350 std::vector<double> B1spc2_r(B1spc2_N);
351
352 for (int i = 0; i < B1spc2_N; ++i) {
353 ostringstream ossZID;
354 ossZID << "Z" << i;
355
356 ostringstream ossRID;
357 ossRID << "R" << i;
358
359 ostringstream ossrID;
360 ossrID << "r" << i;
361
362 B1spc2_Z[i] = m_config.getParameter(prep + ossZID.str()) * unitFactor;
363 B1spc2_R[i] = m_config.getParameter(prep + ossRID.str()) * unitFactor;
364 B1spc2_r[i] = m_config.getParameter(prep + ossrID.str(), 0.0) * unitFactor;
365 }
366
367 B1spc2.transform = transform_LER;
368 G4Polycone* geo_B1spc2xx = new G4Polycone("geo_B1spc2xx_name", 0, 2 * M_PI, B1spc2_N, &(B1spc2_Z[0]), &(B1spc2_r[0]),
369 &(B1spc2_R[0]));
370
371 // final cut
372 B1spc2.geo = new G4IntersectionSolid("geo_B1spc2_name", geo_B1spc2xx, elements["TubeR2"].geo, B1spc2.transform.inverse());
373 B1spc2.logi = NULL;
374
375 G4IntersectionSolid* geo_B1spc1x = new G4IntersectionSolid("geo_B1spc1x_name", geo_B1spc1xx, elements["TubeR"].geo,
376 B1spc1.transform.inverse());
377 B1spc1.geo = new G4UnionSolid("geo_B1spc1_name", geo_B1spc1x, B1spc2.geo);
378
379 A1spc2.geo = new G4IntersectionSolid("geo_A1spc2_name", geo_A1spc2xx, elements["TubeR2"].geo, A1spc2.transform.inverse());
380 A1spc2.logi = NULL;
381
382 G4IntersectionSolid* geo_A1spc1xy = new G4IntersectionSolid("geo_A1spc1xy_name", geo_A1spc1xx, elements["TubeR"].geo,
383 A1spc1.transform.inverse());
384 G4UnionSolid* geo_A1spc1x = new G4UnionSolid("geo_A1spc1x_name", geo_A1spc1xy, A1spc2.geo);
385 A1spc1.geo = new G4SubtractionSolid("geo_A1spc1_name", geo_A1spc1x, B1spc1.geo, A1spc1.transform.inverse()*B1spc1.transform);
386
387 string strMat_A1spc1 = m_config.getParameterStr("A1spc1.Material");
388 G4Material* mat_A1spc1 = Materials::get(strMat_A1spc1);
389 A1spc1.logi = new G4LogicalVolume(A1spc1.geo, mat_A1spc1, "logi_A1spc1_name");
390 if (flag_limitStep)
391 A1spc1.logi->SetUserLimits(new G4UserLimits(stepMax));
392
393 //put volume
394 setColor(*A1spc1.logi, "#CC0000");
395 //setVisibility(*A1spc1.logi, false);
396 new G4PVPlacement(A1spc1.transform, A1spc1.logi, "phys_A1spc1_name", &topVolume, false, 0);
397
398 string strMat_B1spc1 = m_config.getParameterStr("B1spc1.Material");
399 G4Material* mat_B1spc1 = Materials::get(strMat_B1spc1);
400 B1spc1.logi = new G4LogicalVolume(B1spc1.geo, mat_B1spc1, "logi_B1spc1_name");
401 if (flag_limitStep)
402 B1spc1.logi->SetUserLimits(new G4UserLimits(stepMax));
403
404 //put volume
405 setColor(*B1spc1.logi, "#CC0000");
406 //setVisibility(*B1spc1.logi, false);
407 new G4PVPlacement(B1spc1.transform, B1spc1.logi, "phys_B1spc1_name", &topVolume, false, 0);
408
409 elements["A1spc1"] = A1spc1;
410 elements["A1spc2"] = A1spc2;
411 elements["B1spc1"] = B1spc1;
412 elements["B1spc2"] = B1spc2;
413
414 //--------------
415 //- C1wal1
416
417 //get parameters from .xml file
418 CryostatElement C1wal1;
419 prep = "C1wal1.";
420 const int C1wal1_N = m_config.getParameter(prep + "N");
421
422 std::vector<double> C1wal1_Z(C1wal1_N);
423 std::vector<double> C1wal1_R(C1wal1_N);
424 std::vector<double> C1wal1_r(C1wal1_N);
425
426 for (int i = 0; i < C1wal1_N; ++i) {
427 ostringstream ossZID;
428 ossZID << "Z" << i;
429
430 ostringstream ossRID;
431 ossRID << "R" << i;
432
433 ostringstream ossrID;
434 ossrID << "r" << i;
435
436 C1wal1_Z[i] = m_config.getParameter(prep + ossZID.str()) * unitFactor;
437 C1wal1_R[i] = m_config.getParameter(prep + ossRID.str()) * unitFactor;
438 C1wal1_r[i] = m_config.getParameter(prep + ossrID.str(), 0.0) * unitFactor;
439 }
440
441 C1wal1.transform = G4Translate3D(0., 0., 0.);
442
443 //define geometry
444 G4Polycone* geo_C1wal1xxx = new G4Polycone("geo_C1wal1xxx_name", 0, 2 * M_PI, C1wal1_N, &(C1wal1_Z[0]), &(C1wal1_r[0]),
445 &(C1wal1_R[0]));
446 G4IntersectionSolid* geo_C1wal1xx = new G4IntersectionSolid("geo_C1wal1xx_name", geo_C1wal1xxx, elements["TubeR"].geo,
447 elements["TubeR"].transform);
448 G4SubtractionSolid* geo_C1wal1x = new G4SubtractionSolid("geo_C1wal1x_name", geo_C1wal1xx, elements["A1spc1"].geo,
449 elements["A1spc1"].transform);
450 C1wal1.geo = new G4SubtractionSolid("geo_C1wal1_name", geo_C1wal1x, elements["B1spc1"].geo, elements["B1spc1"].transform);
451
452 string strMat_C1wal1 = m_config.getParameterStr(prep + "Material");
453 G4Material* mat_C1wal1 = Materials::get(strMat_C1wal1);
454 C1wal1.logi = new G4LogicalVolume(C1wal1.geo, mat_C1wal1, "logi_C1wal1_name");
455
456 //put volume
457 setColor(*C1wal1.logi, "#CC0000");
458 setVisibility(*C1wal1.logi, false);
459 new G4PVPlacement(0, G4ThreeVector(0, 0, 0), C1wal1.logi, "phys_C1wal1_name", &topVolume, false, 0);
460
461 elements["C1wal1"] = C1wal1;
462
463 //--------------
464 //- D1spc1 and E1spc1
465
466 // space containing all structures around left HER beam pipe
467 CryostatElement D1spc1;
468 prep = "D1spc1.";
469 const int D1spc1_N = m_config.getParameter(prep + "N");
470
471 std::vector<double> D1spc1_Z(D1spc1_N);
472 std::vector<double> D1spc1_r(D1spc1_N);
473 std::vector<double> D1spc1_R(D1spc1_N);
474
475 for (int i = 0; i < D1spc1_N; ++i) {
476 ostringstream ossZID;
477 ossZID << "Z" << i;
478
479 ostringstream ossRID;
480 ossRID << "R" << i;
481
482 ostringstream ossrID;
483 ossrID << "r" << i;
484
485 D1spc1_Z[i] = m_config.getParameter(prep + ossZID.str()) * unitFactor;
486 D1spc1_R[i] = m_config.getParameter(prep + ossRID.str()) * unitFactor;
487 D1spc1_r[i] = m_config.getParameter(prep + ossrID.str(), 0.0) * unitFactor;
488 }
489
490 D1spc1.transform = transform_HER;
491 G4Polycone* geo_D1spc1xx = new G4Polycone("geo_D1spc1xx_name", 0, 2 * M_PI, D1spc1_N, &(D1spc1_Z[0]), &(D1spc1_r[0]),
492 &(D1spc1_R[0]));
493
494 // space containing all structures around left LER beam pipe
495 CryostatElement E1spc1;
496 prep = "E1spc1.";
497 const int E1spc1_N = int(m_config.getParameter(prep + "N"));
498
499 std::vector<double> E1spc1_Z(E1spc1_N);
500 std::vector<double> E1spc1_R(E1spc1_N);
501 std::vector<double> E1spc1_r(E1spc1_N);
502
503 for (int i = 0; i < E1spc1_N; ++i) {
504 ostringstream ossZID;
505 ossZID << "Z" << i;
506
507 ostringstream ossRID;
508 ossRID << "R" << i;
509
510 ostringstream ossrID;
511 ossrID << "r" << i;
512
513 E1spc1_Z[i] = m_config.getParameter(prep + ossZID.str()) * unitFactor;
514 E1spc1_R[i] = m_config.getParameter(prep + ossRID.str()) * unitFactor;
515 E1spc1_r[i] = m_config.getParameter(prep + ossrID.str(), 0.0) * unitFactor;
516 }
517
518 E1spc1.transform = transform_LER;
519 G4Polycone* geo_E1spc1xx = new G4Polycone("geo_E1spc1xx_name", 0, 2 * M_PI, E1spc1_N, &(E1spc1_Z[0]), &(E1spc1_r[0]),
520 &(E1spc1_R[0]));
521
522 // final cut
523 G4IntersectionSolid* geo_D1spc1x = new G4IntersectionSolid("geo_D1spc1x_name", geo_D1spc1xx, elements["TubeL"].geo,
524 D1spc1.transform.inverse());
525 E1spc1.geo = new G4IntersectionSolid("geo_E1spc1_name", geo_E1spc1xx, elements["TubeL"].geo, E1spc1.transform.inverse());
526 D1spc1.geo = new G4SubtractionSolid("geo_D1spc1_name", geo_D1spc1x, E1spc1.geo, D1spc1.transform.inverse()*E1spc1.transform);
527
528 string strMat_D1spc1 = m_config.getParameterStr("D1spc1.Material");
529 G4Material* mat_D1spc1 = Materials::get(strMat_D1spc1);
530 D1spc1.logi = new G4LogicalVolume(D1spc1.geo, mat_D1spc1, "logi_D1spc1_name");
531 if (flag_limitStep)
532 D1spc1.logi->SetUserLimits(new G4UserLimits(stepMax));
533
534 //put volume
535 setColor(*D1spc1.logi, "#CC0000");
536 //setVisibility(*D1spc1.logi, false);
537 new G4PVPlacement(D1spc1.transform, D1spc1.logi, "phys_D1spc1_name", &topVolume, false, 0);
538
539 string strMat_E1spc1 = m_config.getParameterStr(prep + "Material");
540 G4Material* mat_E1spc1 = Materials::get(strMat_E1spc1);
541 E1spc1.logi = new G4LogicalVolume(E1spc1.geo, mat_E1spc1, "logi_E1spc1_name");
542 if (flag_limitStep)
543 E1spc1.logi->SetUserLimits(new G4UserLimits(stepMax));
544
545 //put volume
546 setColor(*E1spc1.logi, "#CC0000");
547 //setVisibility(*E1spc1.logi, false);
548 new G4PVPlacement(E1spc1.transform, E1spc1.logi, "phys_E1spc1_name", &topVolume, false, 0);
549
550 elements["E1spc1"] = E1spc1;
551 elements["D1spc1"] = D1spc1;
552
553
554 //--------------
555 //- F1wal1
556
557 //get parameters from .xml file
558 CryostatElement F1wal1;
559 prep = "F1wal1.";
560 const int F1wal1_N = int(m_config.getParameter(prep + "N"));
561
562 std::vector<double> F1wal1_Z(F1wal1_N);
563 std::vector<double> F1wal1_R(F1wal1_N);
564 std::vector<double> F1wal1_r(F1wal1_N);
565
566 for (int i = 0; i < F1wal1_N; ++i) {
567 ostringstream ossZID;
568 ossZID << "Z" << i;
569
570 ostringstream ossRID;
571 ossRID << "R" << i;
572
573 ostringstream ossrID;
574 ossrID << "r" << i;
575
576 F1wal1_Z[i] = m_config.getParameter(prep + ossZID.str()) * unitFactor;
577 F1wal1_R[i] = m_config.getParameter(prep + ossRID.str()) * unitFactor;
578 F1wal1_r[i] = m_config.getParameter(prep + ossrID.str(), 0.0) * unitFactor;
579 }
580
581 F1wal1.transform = G4Translate3D(0., 0., 0.);
582
583 //define geometry
584 G4Polycone* geo_F1wal1xxx = new G4Polycone("geo_F1wal1xxx_name", 0, 2 * M_PI, F1wal1_N, &(F1wal1_Z[0]), &(F1wal1_r[0]),
585 &(F1wal1_R[0]));
586 G4IntersectionSolid* geo_F1wal1xx = new G4IntersectionSolid("geo_F1wal1xx_name", geo_F1wal1xxx, elements["TubeL"].geo,
587 elements["TubeL"].transform);
588 G4SubtractionSolid* geo_F1wal1x = new G4SubtractionSolid("geo_F1wal1x_name", geo_F1wal1xx, elements["D1spc1"].geo,
589 elements["D1spc1"].transform);
590 F1wal1.geo = new G4SubtractionSolid("geo_F1wal1_name", geo_F1wal1x, elements["E1spc1"].geo, elements["E1spc1"].transform);
591
592 string strMat_F1wal1 = m_config.getParameterStr(prep + "Material");
593 G4Material* mat_F1wal1 = Materials::get(strMat_F1wal1);
594 F1wal1.logi = new G4LogicalVolume(F1wal1.geo, mat_F1wal1, "logi_F1wal1_name");
595
596 //put volume
597 setColor(*F1wal1.logi, "#CC0000");
598 setVisibility(*F1wal1.logi, false);
599 new G4PVPlacement(F1wal1.transform, F1wal1.logi, "phys_F1wal1_name", &topVolume, false, 0);
600
601 elements["F1wal1"] = F1wal1;
602
603
604 //--------------
605 //- Cryostats' supports
606
607 std::vector<std::string> supports;
608 boost::split(supports, m_config.getParameterStr("Support"), boost::is_any_of(" "));
609 for (const auto& name : supports) {
610 // storable element
611 CryostatElement sup;
612 prep = name + ".";
613
614 double box_W = m_config.getParameter(prep + "W") * unitFactor;
615 double box_H = m_config.getParameter(prep + "H") * unitFactor;
616 double box_L = m_config.getParameter(prep + "L") * unitFactor;
617 double box_X0 = m_config.getParameter(prep + "X0") * unitFactor;
618 double box_Y0 = m_config.getParameter(prep + "Y0") * unitFactor;
619 double box_Z0 = m_config.getParameter(prep + "Z0") * unitFactor;
620
621 double trd_W1 = m_config.getParameter(prep + "trdW1") * unitFactor;
622 double trd_W2 = m_config.getParameter(prep + "trdW2") * unitFactor;
623 double trd_L = m_config.getParameter(prep + "trdL") * unitFactor;
624 double trd_H = m_config.getParameter(prep + "trdH") * unitFactor;
625 double trd_X0 = m_config.getParameter(prep + "trdX0") * unitFactor;
626 double trd_Y0 = m_config.getParameter(prep + "trdY0") * unitFactor;
627 double trd_Z0 = m_config.getParameter(prep + "trdZ0") * unitFactor;
628
629 double sup_PHI = m_config.getParameter(prep + "PHI");
630
631 int sup_cut_N = int(m_config.getParameter(prep + "N", 0));
632
633 // transformations
634 G4Transform3D transform_box = G4Translate3D(box_X0, box_Y0, box_Z0);
635 transform_box = transform_box * G4RotateY3D(sup_PHI / Unit::rad);
636
637 G4Transform3D transform_trd = G4Translate3D(trd_X0, trd_Y0, trd_Z0);
638 transform_trd = transform_trd * G4RotateY3D(sup_PHI / Unit::rad) * G4RotateX3D(M_PI / 2.0 / Unit::rad);
639
640 //define geometry
641 string geo_box_name = "geo_" + name + "_box_name";
642 string geo_trd_name = "geo_" + name + "_trd_name";
643
644 string geo_sup_name;
645 if (sup_cut_N == 0) {
646 geo_sup_name = "geo_" + name + "_name";
647 } else {
648 geo_sup_name = "geo_" + name + "_x_name";
649 }
650
651 G4Box* geo_box = new G4Box(geo_box_name, box_W / 2.0, box_H / 2.0, box_L / 2.0);
652 G4Trd* geo_trd = new G4Trd(geo_trd_name, trd_W1 / 2.0, trd_W2 / 2.0, trd_L / 2.0, trd_L / 2.0, trd_H / 2.0);
653
654 G4VSolid* geo_sup = new G4UnionSolid(geo_sup_name, geo_box, geo_trd, transform_box.inverse() * transform_trd);
655
656 // cuts
657 for (int i = 0; i < sup_cut_N; ++i) {
658 ostringstream oss_block_num;
659 oss_block_num << i;
660
661 double cut_type = m_config.getParameter(prep + "cutType" + oss_block_num.str());
662 string geo_supx_name;
663 if (i == sup_cut_N - 1) {
664 geo_supx_name = "geo_" + name + "_name";
665 } else {
666 geo_sup_name = "geo_" + name + "_x" + oss_block_num.str() + "_name";
667 }
668 string geo_cut_name = "geo_" + name + "_cut" + oss_block_num.str() + "_name";
669
670 G4VSolid* geo_cut;
671 //if(cut_type == "Box")
672 if (cut_type == 0.0) {
673 double cut_L = m_config.getParameter(prep + "cutL" + oss_block_num.str()) * unitFactor;
674 double cut_W = m_config.getParameter(prep + "cutW" + oss_block_num.str()) * unitFactor;
675 double cut_H = m_config.getParameter(prep + "cutH" + oss_block_num.str()) * unitFactor;
676
677 geo_cut = new G4Box(geo_cut_name, cut_W / 2.0, cut_H / 2.0, cut_L / 2.0);
678 // else if(cut_type == "Tubs")
679 } else { // if (cut_type != 0.0) {
680 double cut_L = m_config.getParameter(prep + "cutL" + oss_block_num.str()) * unitFactor;
681 double cut_R = m_config.getParameter(prep + "cutR" + oss_block_num.str()) * unitFactor;
682
683 geo_cut = new G4Tubs(geo_cut_name, 0.0, cut_R, cut_L / 2.0, 0.0, 2.0 * M_PI);
684 }
685 //} else
686 // continue;
687
688 double cut_X0 = m_config.getParameter(prep + "cutDX" + oss_block_num.str()) * unitFactor;
689 double cut_Y0 = m_config.getParameter(prep + "cutDY" + oss_block_num.str()) * unitFactor;
690 double cut_Z0 = m_config.getParameter(prep + "cutDZ" + oss_block_num.str()) * unitFactor;
691 double cut_PHI = m_config.getParameter(prep + "cutPHI" + oss_block_num.str(), 0.0);
692 double cut_TH = m_config.getParameter(prep + "cutTH" + oss_block_num.str(), 0.0);
693
694 G4Transform3D cut_transform = G4Translate3D(cut_X0, cut_Y0, cut_Z0);
695 cut_transform = cut_transform * G4RotateX3D(cut_PHI / Unit::rad);
696 cut_transform = cut_transform * G4RotateZ3D(cut_TH / Unit::rad);
697
698 geo_sup = new G4SubtractionSolid(geo_sup_name, geo_sup, geo_cut, cut_transform);
699 }
700
701 sup.geo = geo_sup;
702 sup.transform = transform_box;
703
704 string strMat_sup = m_config.getParameterStr(prep + "Material");
705 G4Material* mat_sup = Materials::get(strMat_sup);
706
707 string logi_sup_name = "logi_" + name + "_name";
708 G4LogicalVolume* logi_sup = new G4LogicalVolume(sup.geo, mat_sup, logi_sup_name);
709
710 sup.logi = logi_sup;
711
712 //put volume
713 setColor(*logi_sup, "#0000CC");
714 //setVisibility(*logi_sup, false);
715 string phys_sup_name = "phys_" + name + "_name";
716 new G4PVPlacement(sup.transform, sup.logi, phys_sup_name, &topVolume, false, 0);
717
718 elements[name] = sup;
719 }
720
721
722 //--------------
723 //- Rest of elements with typical geometry
724
725 std::vector<std::string> straightSections;
726 boost::split(straightSections, m_config.getParameterStr("Straight"), boost::is_any_of(" "));
727 for (const auto& name : straightSections) {
728 prep = name + ".";
729
730 CryostatElement polycone;
731
732 int N = int(m_config.getParameter(prep + "N"));
733
734 std::vector<double> Z(N);
735 std::vector<double> R(N);
736 std::vector<double> r(N);
737
738 for (int i = 0; i < N; ++i) {
739 ostringstream ossZID;
740 ossZID << "Z" << i;
741
742 ostringstream ossRID;
743 ossRID << "R" << i;
744
745 ostringstream ossrID;
746 ossrID << "r" << i;
747
748 Z[i] = m_config.getParameter(prep + ossZID.str()) * unitFactor;
749 R[i] = m_config.getParameter(prep + ossRID.str()) * unitFactor;
750 r[i] = m_config.getParameter(prep + ossrID.str(), 0.0) * unitFactor;
751 }
752
753 polycone.transform = G4Translate3D(0.0, 0.0, 0.0);
754
755 //define geometry
756 string motherVolume = m_config.getParameterStr(prep + "MotherVolume");
757 string subtract = m_config.getParameterStr(prep + "Subtract", "");
758 string intersect = m_config.getParameterStr(prep + "Intersect", "");
759
760 string geo_polyconexx_name = "geo_" + name + "xx_name";
761 string geo_polyconex_name = "geo_" + name + "x_name";
762 string geo_polycone_name = "geo_" + name + "_name";
763
764 G4VSolid* geo_polyconexx, *geo_polycone;
765
766 if (subtract != "" && intersect != "") {
767 geo_polyconexx = new G4Polycone(geo_polyconexx_name, 0.0, 2 * M_PI, N, &(Z[0]), &(r[0]), &(R[0]));
768 G4VSolid* geo_polyconex = new G4SubtractionSolid(geo_polyconex_name, geo_polyconexx, elements[subtract].geo,
769 elements[motherVolume].transform.inverse()*polycone.transform.inverse()*elements[subtract].transform);
770 geo_polycone = new G4IntersectionSolid(geo_polycone_name, geo_polyconex, elements[intersect].geo,
771 elements[motherVolume].transform.inverse()*polycone.transform.inverse()*elements[intersect].transform);
772 } else if (subtract != "") {
773 geo_polyconexx = new G4Polycone(geo_polyconexx_name, 0.0, 2 * M_PI, N, &(Z[0]), &(r[0]), &(R[0]));
774 geo_polycone = new G4SubtractionSolid(geo_polycone_name, geo_polyconexx, elements[subtract].geo,
775 elements[motherVolume].transform.inverse()*polycone.transform.inverse()*elements[subtract].transform);
776 } else if (intersect != "") {
777 geo_polyconexx = new G4Polycone(geo_polyconexx_name, 0.0, 2 * M_PI, N, &(Z[0]), &(r[0]), &(R[0]));
778 geo_polycone = new G4IntersectionSolid(geo_polycone_name, geo_polyconexx, elements[intersect].geo,
779 elements[motherVolume].transform.inverse()*polycone.transform.inverse()*elements[intersect].transform);
780 } else
781 geo_polycone = new G4Polycone(geo_polycone_name, 0.0, 2 * M_PI, N, &(Z[0]), &(r[0]), &(R[0]));
782
783 polycone.geo = geo_polycone;
784
785 // define logical volume
786 string strMat_polycone = m_config.getParameterStr(prep + "Material");
787 G4Material* mat_polycone = Materials::get(strMat_polycone);
788 string logi_polycone_name = "logi_" + name + "_name";
789 polycone.logi = new G4LogicalVolume(polycone.geo, mat_polycone, logi_polycone_name);
790 setColor(*polycone.logi, "#CC0000");
791 setVisibility(*polycone.logi, false);
792
793 //put volume
794 string phys_polycone_name = "phys_" + name + "_name";
795 new G4PVPlacement(polycone.transform, polycone.logi, phys_polycone_name, elements[motherVolume].logi, false, 0);
796
797 //to use it later in "intersect" and "subtract"
798 polycone.transform = polycone.transform * elements[motherVolume].transform;
799
800 elements[name] = polycone;
801 }
802
803
804 //--------------------------------------------------------------------------------------------
805 //- Shields
806
807 std::vector<std::string> shields;
808 boost::split(shields, m_config.getParameterStr("Shield"), boost::is_any_of(" "));
809 for (const auto& name : shields) {
810 prep = name + ".";
811
812 //- Shield made as box with optional subtracted box-shaped inner space (hole)
813
814 double shield_W = m_config.getParameter(prep + "W") * unitFactor;
815 double shield_H = m_config.getParameter(prep + "H") * unitFactor;
816 double shield_L = m_config.getParameter(prep + "L") * unitFactor;
817 double shield_X0 = m_config.getParameter(prep + "X0") * unitFactor;
818 double shield_Y0 = m_config.getParameter(prep + "Y0") * unitFactor;
819 double shield_Z0 = m_config.getParameter(prep + "Z0") * unitFactor;
820
821 double shield_hole_W = m_config.getParameter(prep + "holeW", 0) * unitFactor;
822 double shield_hole_H = m_config.getParameter(prep + "holeH", 0) * unitFactor;
823 double shield_hole_L = m_config.getParameter(prep + "holeL", 0) * unitFactor;
824 double shield_hole_dX = m_config.getParameter(prep + "holeDX", 0) * unitFactor;
825 double shield_hole_dY = m_config.getParameter(prep + "holeDY", 0) * unitFactor;
826 double shield_hole_dZ = m_config.getParameter(prep + "holeDZ", 0) * unitFactor;
827
828 double shield_PHI = m_config.getParameter(prep + "PHI");
829
830 // storable element
831 CryostatElement shield;
832
833 shield.transform = G4Translate3D(shield_X0, shield_Y0, shield_Z0);
834 shield.transform = shield.transform * G4RotateY3D(shield_PHI / Unit::rad);
835
836 G4Transform3D transform_shield_hole = G4Translate3D(shield_hole_dX, shield_hole_dY, shield_hole_dZ);
837
838 //define geometry
839 string geo_shieldx_name = "geo_" + name + "x_name";
840 string geo_shield_hole_name = "geo_" + name + "_hole_name";
841 string geo_shield_name = "geo_" + name + "_name";
842
843 if (shield_hole_W == 0 || shield_hole_H == 0 || shield_hole_L == 0) {
844 G4Box* geo_shield = new G4Box(geo_shield_name, shield_W / 2.0, shield_H / 2.0, shield_L / 2.0);
845
846 shield.geo = geo_shield;
847 } else {
848 G4Box* geo_shieldx = new G4Box(geo_shieldx_name, shield_W / 2.0, shield_H / 2.0, shield_L / 2.0);
849 G4Box* geo_shield_hole = new G4Box(geo_shield_hole_name, shield_hole_W / 2.0, shield_hole_H / 2.0, shield_hole_L / 2.0);
850 G4SubtractionSolid* geo_shield = new G4SubtractionSolid(geo_shield_name, geo_shieldx, geo_shield_hole,
851 transform_shield_hole);
852
853 shield.geo = geo_shield;
854 }
855
856 string strMat_shield = m_config.getParameterStr(prep + "Material");
857 G4Material* mat_shield = Materials::get(strMat_shield);
858
859 string logi_shield_name = "logi_" + name + "_name";
860 G4LogicalVolume* logi_shield = new G4LogicalVolume(shield.geo, mat_shield, logi_shield_name);
861
862 shield.logi = logi_shield;
863
864 //put volume
865 setColor(*logi_shield, "#0000CC");
866 //setVisibility(*logi_shield, false);
867 string phys_shield_name = "phys_" + name + "_name";
868 new G4PVPlacement(shield.transform, shield.logi, phys_shield_name, &topVolume, false, 0);
869
870 elements[name] = shield;
871 }
872
873
874 // RVC connection structure (simplified shape)
875 G4Tubs* geo_rvcR = new G4Tubs("geo_rvcR", 60, 60 + 60, (620 - 560) / 2., 0, 2 * M_PI);
876 G4LogicalVolume* logi_rvcR = new G4LogicalVolume(geo_rvcR, Materials::get("SUS316L"), "logi_rvcR_name");
877 new G4PVPlacement(0, G4ThreeVector(0, 0, (620 + 560) / 2.), logi_rvcR, "phys_rvcR_name", &topVolume, false, 0);
878
879 G4Tubs* geo_rvcL = new G4Tubs("geo_rvcL", 60, 60 + 60, (-560 - (-620)) / 2., 0, 2 * M_PI);
880 G4LogicalVolume* logi_rvcL = new G4LogicalVolume(geo_rvcL, Materials::get("SUS316L"), "logi_rvcL_name");
881 new G4PVPlacement(0, G4ThreeVector(0, 0, (-620 - 560) / 2.), logi_rvcL, "phys_rvcL_name", &topVolume, false, 0);
882
883 // Added 10 Nov 2018
884 // Elliptical inner surface around QC1LE
885 G4EllipticalTube* geo_elp_QC1LEx = new G4EllipticalTube("geo_elp_QC1LEx", 10.5, 13.5, (-675 - (-1225)) / 2.); //in mm
886 G4IntersectionSolid* geo_elp_QC1LE = new G4IntersectionSolid("geo_elp_QC1LE", elements["D2wal1"].geo, geo_elp_QC1LEx,
887 G4Translate3D(0, 0, (-675 - 1225) / 2.));
888 G4LogicalVolume* logi_elp_QC1LE = new G4LogicalVolume(geo_elp_QC1LE, Materials::get("Vacuum"), "logi_elp_QC1LE_name");
889 new G4PVPlacement(0, G4ThreeVector(0, 0, 0), logi_elp_QC1LE, "phys_elp_QC1LE_name", elements["D2wal1"].logi, false, 0);
890 // Elliptical inner surface around QC1LP
891 G4EllipticalTube* geo_elp_QC1LPx = new G4EllipticalTube("geo_elp_QC1LPx", 10.5, 13.5, (-675 - (-1225)) / 2.); //in mm
892 G4IntersectionSolid* geo_elp_QC1LP = new G4IntersectionSolid("geo_elp_QC1LP", elements["E2wal1"].geo, geo_elp_QC1LPx,
893 G4Translate3D(0, 0, (-675 - 1225) / 2.));
894 G4LogicalVolume* logi_elp_QC1LP = new G4LogicalVolume(geo_elp_QC1LP, Materials::get("Vacuum"), "logi_elp_QC1LP_name");
895 new G4PVPlacement(0, G4ThreeVector(0, 0, 0), logi_elp_QC1LP, "phys_elp_QC1LP_name", elements["E2wal1"].logi, false, 0);
896 // Elliptical inner surface around QC1RE
897 G4EllipticalTube* geo_elp_QC1REx = new G4EllipticalTube("geo_elp_QC1REx", 10.5, 13.5, (1225 - 675) / 2.); //in mm
898 G4IntersectionSolid* geo_elp_QC1RE = new G4IntersectionSolid("geo_elp_QC1RE", elements["A2wal1"].geo, geo_elp_QC1REx,
899 G4Translate3D(0, 0, (1225 + 675) / 2.));
900 G4LogicalVolume* logi_elp_QC1RE = new G4LogicalVolume(geo_elp_QC1RE, Materials::get("Vacuum"), "logi_elp_QC1RE_name");
901 new G4PVPlacement(0, G4ThreeVector(0, 0, 0), logi_elp_QC1RE, "phys_elp_QC1RE_name", elements["A2wal1"].logi, false, 0);
902 // Elliptical inner surface around QC1RP
903 G4EllipticalTube* geo_elp_QC1RPx = new G4EllipticalTube("geo_elp_QC1RPx", 10.5, 13.5, (1225 - 675) / 2.); //in mm
904 G4IntersectionSolid* geo_elp_QC1RP = new G4IntersectionSolid("geo_elp_QC1RP", elements["B2wal1"].geo, geo_elp_QC1RPx,
905 G4Translate3D(0, 0, (1225 + 675) / 2.));
906 G4LogicalVolume* logi_elp_QC1RP = new G4LogicalVolume(geo_elp_QC1RP, Materials::get("Vacuum"), "logi_elp_QC1RP_name");
907 new G4PVPlacement(0, G4ThreeVector(0, 0, 0), logi_elp_QC1RP, "phys_elp_QC1RP_name", elements["B2wal1"].logi, false, 0);
908
909
910 //---------------------------
911 // for dose simulation
912 //---------------------------
913
914 /*
915 logi_A1spc1 ->SetSensitiveDetector(new BkgSensitiveDetector("IR", 101));
916 logi_A1spc2 ->SetSensitiveDetector(new BkgSensitiveDetector("IR", 102));
917 logi_A2wal1 ->SetSensitiveDetector(new BkgSensitiveDetector("IR", 103));
918 logi_A3wal1 ->SetSensitiveDetector(new BkgSensitiveDetector("IR", 104));
919 logi_A3wal2 ->SetSensitiveDetector(new BkgSensitiveDetector("IR", 105));
920 logi_A4mag1 ->SetSensitiveDetector(new BkgSensitiveDetector("IR", 106));
921 logi_A4mag2p1 ->SetSensitiveDetector(new BkgSensitiveDetector("IR", 107));
922 logi_A4mag2p2 ->SetSensitiveDetector(new BkgSensitiveDetector("IR", 108));
923 logi_A4mag2p3 ->SetSensitiveDetector(new BkgSensitiveDetector("IR", 109));
924 logi_A4mag2p4 ->SetSensitiveDetector(new BkgSensitiveDetector("IR", 110));
925 logi_A4mag3p1 ->SetSensitiveDetector(new BkgSensitiveDetector("IR", 111));
926 logi_A4mag3p2 ->SetSensitiveDetector(new BkgSensitiveDetector("IR", 112));
927 logi_A4mag4p1 ->SetSensitiveDetector(new BkgSensitiveDetector("IR", 113));
928 logi_A4mag4p2 ->SetSensitiveDetector(new BkgSensitiveDetector("IR", 114));
929 logi_A4mag4p3 ->SetSensitiveDetector(new BkgSensitiveDetector("IR", 115));
930 logi_A4mag4p4 ->SetSensitiveDetector(new BkgSensitiveDetector("IR", 116));
931 logi_A4mag4p5 ->SetSensitiveDetector(new BkgSensitiveDetector("IR", 117));
932 logi_A4mag4p6 ->SetSensitiveDetector(new BkgSensitiveDetector("IR", 118));
933 logi_A4mag4p7 ->SetSensitiveDetector(new BkgSensitiveDetector("IR", 119));
934 logi_A4mag4p8 ->SetSensitiveDetector(new BkgSensitiveDetector("IR", 120));
935 logi_A4mag4p9 ->SetSensitiveDetector(new BkgSensitiveDetector("IR", 121));
936 logi_B1spc1 ->SetSensitiveDetector(new BkgSensitiveDetector("IR", 122));
937 logi_B1spc2 ->SetSensitiveDetector(new BkgSensitiveDetector("IR", 123));
938 logi_B2wal1 ->SetSensitiveDetector(new BkgSensitiveDetector("IR", 124));
939 logi_B3wal1 ->SetSensitiveDetector(new BkgSensitiveDetector("IR", 125));
940 logi_B3wal2 ->SetSensitiveDetector(new BkgSensitiveDetector("IR", 126));
941 logi_B4mag1p1 ->SetSensitiveDetector(new BkgSensitiveDetector("IR", 127));
942 logi_B4mag1p2 ->SetSensitiveDetector(new BkgSensitiveDetector("IR", 128));
943 logi_B4mag1p3 ->SetSensitiveDetector(new BkgSensitiveDetector("IR", 129));
944 logi_B4mag2 ->SetSensitiveDetector(new BkgSensitiveDetector("IR", 130));
945 logi_B4mag3p1 ->SetSensitiveDetector(new BkgSensitiveDetector("IR", 131));
946 logi_B4mag3p2 ->SetSensitiveDetector(new BkgSensitiveDetector("IR", 132));
947 logi_B4mag3p3 ->SetSensitiveDetector(new BkgSensitiveDetector("IR", 133));
948 logi_B4mag3p4 ->SetSensitiveDetector(new BkgSensitiveDetector("IR", 134));
949 logi_B4mag3p5 ->SetSensitiveDetector(new BkgSensitiveDetector("IR", 135));
950 logi_B4mag3p6 ->SetSensitiveDetector(new BkgSensitiveDetector("IR", 136));
951 logi_B4mag4p1 ->SetSensitiveDetector(new BkgSensitiveDetector("IR", 137));
952 logi_B4mag4p7 ->SetSensitiveDetector(new BkgSensitiveDetector("IR", 138));
953 logi_B4mag4p8 ->SetSensitiveDetector(new BkgSensitiveDetector("IR", 139));
954 logi_B4mag4p9 ->SetSensitiveDetector(new BkgSensitiveDetector("IR", 140));
955 logi_C1wal1 ->SetSensitiveDetector(new BkgSensitiveDetector("IR", 141));
956 logi_C1wal2 ->SetSensitiveDetector(new BkgSensitiveDetector("IR", 142));
957 logi_C2spc1 ->SetSensitiveDetector(new BkgSensitiveDetector("IR", 143));
958 logi_C2spc2 ->SetSensitiveDetector(new BkgSensitiveDetector("IR", 144));
959 logi_C2spc3 ->SetSensitiveDetector(new BkgSensitiveDetector("IR", 145));
960 logi_C3wal1 ->SetSensitiveDetector(new BkgSensitiveDetector("IR", 146));
961 logi_C3wal2 ->SetSensitiveDetector(new BkgSensitiveDetector("IR", 147));
962 logi_C4spc1 ->SetSensitiveDetector(new BkgSensitiveDetector("IR", 148));
963 logi_C4spc2 ->SetSensitiveDetector(new BkgSensitiveDetector("IR", 149));
964 logi_C5wal1 ->SetSensitiveDetector(new BkgSensitiveDetector("IR", 150));
965 logi_C5wal2 ->SetSensitiveDetector(new BkgSensitiveDetector("IR", 151));
966 logi_C5wal3 ->SetSensitiveDetector(new BkgSensitiveDetector("IR", 152));
967 logi_C6spc1 ->SetSensitiveDetector(new BkgSensitiveDetector("IR", 153));
968 logi_C6spc2 ->SetSensitiveDetector(new BkgSensitiveDetector("IR", 154));
969 logi_C7wal1 ->SetSensitiveDetector(new BkgSensitiveDetector("IR", 155));
970 logi_C7lyr1 ->SetSensitiveDetector(new BkgSensitiveDetector("IR", 156));
971 logi_C7lyr2 ->SetSensitiveDetector(new BkgSensitiveDetector("IR", 157));
972 logi_C7lyr3 ->SetSensitiveDetector(new BkgSensitiveDetector("IR", 158));
973 logi_C7lyr4 ->SetSensitiveDetector(new BkgSensitiveDetector("IR", 159));
974 logi_C7lyr5 ->SetSensitiveDetector(new BkgSensitiveDetector("IR", 160));
975 logi_D1spc1 ->SetSensitiveDetector(new BkgSensitiveDetector("IR", 161));
976 logi_D2wal1 ->SetSensitiveDetector(new BkgSensitiveDetector("IR", 162));
977 logi_D3wal1 ->SetSensitiveDetector(new BkgSensitiveDetector("IR", 163));
978 logi_D3wal2 ->SetSensitiveDetector(new BkgSensitiveDetector("IR", 164));
979 logi_D4mag1 ->SetSensitiveDetector(new BkgSensitiveDetector("IR", 165));
980 logi_D4mag2p1 ->SetSensitiveDetector(new BkgSensitiveDetector("IR", 166));
981 logi_D4mag2p2 ->SetSensitiveDetector(new BkgSensitiveDetector("IR", 167));
982 logi_D4mag2p3 ->SetSensitiveDetector(new BkgSensitiveDetector("IR", 168));
983 logi_D4mag2p4 ->SetSensitiveDetector(new BkgSensitiveDetector("IR", 169));
984 logi_D4mag3p1 ->SetSensitiveDetector(new BkgSensitiveDetector("IR", 170));
985 logi_D4mag3p2 ->SetSensitiveDetector(new BkgSensitiveDetector("IR", 171));
986 logi_D4mag3p3 ->SetSensitiveDetector(new BkgSensitiveDetector("IR", 172));
987 logi_D4mag3p4 ->SetSensitiveDetector(new BkgSensitiveDetector("IR", 173));
988 logi_D4mag3p5 ->SetSensitiveDetector(new BkgSensitiveDetector("IR", 174));
989 logi_D4mag3p6 ->SetSensitiveDetector(new BkgSensitiveDetector("IR", 175));
990 logi_E1spc1 ->SetSensitiveDetector(new BkgSensitiveDetector("IR", 176));
991 logi_E2wal1 ->SetSensitiveDetector(new BkgSensitiveDetector("IR", 177));
992 logi_E3wal1 ->SetSensitiveDetector(new BkgSensitiveDetector("IR", 178));
993 logi_E4mag1p1 ->SetSensitiveDetector(new BkgSensitiveDetector("IR", 179));
994 logi_E4mag1p2 ->SetSensitiveDetector(new BkgSensitiveDetector("IR", 180));
995 logi_E4mag1p3 ->SetSensitiveDetector(new BkgSensitiveDetector("IR", 181));
996 logi_E4mag2 ->SetSensitiveDetector(new BkgSensitiveDetector("IR", 182));
997 logi_E4mag3p1 ->SetSensitiveDetector(new BkgSensitiveDetector("IR", 183));
998 logi_E4mag3p2 ->SetSensitiveDetector(new BkgSensitiveDetector("IR", 184));
999 logi_E4mag3p3 ->SetSensitiveDetector(new BkgSensitiveDetector("IR", 185));
1000 logi_E4mag3p4 ->SetSensitiveDetector(new BkgSensitiveDetector("IR", 186));
1001 logi_E4mag3p5 ->SetSensitiveDetector(new BkgSensitiveDetector("IR", 187));
1002 logi_F1wal1 ->SetSensitiveDetector(new BkgSensitiveDetector("IR", 188));
1003 logi_F1wal2 ->SetSensitiveDetector(new BkgSensitiveDetector("IR", 189));
1004 logi_F2spc1 ->SetSensitiveDetector(new BkgSensitiveDetector("IR", 190));
1005 logi_F2spc2 ->SetSensitiveDetector(new BkgSensitiveDetector("IR", 191));
1006 logi_F2spc3 ->SetSensitiveDetector(new BkgSensitiveDetector("IR", 192));
1007 logi_F3wal1 ->SetSensitiveDetector(new BkgSensitiveDetector("IR", 193));
1008 logi_F3wal2 ->SetSensitiveDetector(new BkgSensitiveDetector("IR", 194));
1009 logi_F3wal3 ->SetSensitiveDetector(new BkgSensitiveDetector("IR", 195));
1010 logi_F4spc1 ->SetSensitiveDetector(new BkgSensitiveDetector("IR", 196));
1011 logi_F5wal1 ->SetSensitiveDetector(new BkgSensitiveDetector("IR", 197));
1012 logi_F6spc1 ->SetSensitiveDetector(new BkgSensitiveDetector("IR", 198));
1013 logi_F7lyr1 ->SetSensitiveDetector(new BkgSensitiveDetector("IR", 199));
1014 logi_F7lyr2 ->SetSensitiveDetector(new BkgSensitiveDetector("IR", 200));
1015 logi_F7lyr3 ->SetSensitiveDetector(new BkgSensitiveDetector("IR", 201));
1016 logi_F7lyr4 ->SetSensitiveDetector(new BkgSensitiveDetector("IR", 202));
1017 logi_F7lyr5 ->SetSensitiveDetector(new BkgSensitiveDetector("IR", 203));
1018 */
1019
1020 }
R
double R
typedef autogenerated by FFTW
Definition: DiscreteCosineTransform_31points.cc:35
Belle2::IRGeoBase::getParameterStr
const std::string & getParameterStr(const std::string &name) const
Get string parameter.
Definition: IRGeoBase.h:64
Belle2::IRGeoBase::getParameter
double getParameter(const std::string &name) const
Get parameter value.
Definition: IRGeoBase.h:41
Belle2::Unit::mm
static const double mm
[millimeters]
Definition: Unit.h:70
Belle2::Unit::rad
static const double rad
Standard of [angle].
Definition: Unit.h:50
Belle2::Unit::cm
static const double cm
Standard units with the value = 1.
Definition: Unit.h:47
Belle2::geometry::Materials::get
static G4Material * get(const std::string &name)
Find given material.
Definition: Materials.h:63
Belle2::intersect
int intersect(const TRGCDCLpar &lp1, const TRGCDCLpar &lp2, CLHEP::HepVector &v1, CLHEP::HepVector &v2)
intersection
Definition: Lpar.cc:249
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 CryostatGeo class

Reimplemented from CreatorBase.

Definition at line 95 of file GeoCryostatCreator.h.

96 {
97 DBImportObjPtr<CryostatGeo> importObj;
98 importObj.construct(createConfiguration(content));
99 importObj.import(iov);
100 }

Member Data Documentation

◆ m_config

CryostatGeo m_config
protected

geometry parameters object

Definition at line 118 of file GeoCryostatCreator.h.

◆ m_sensitive

SensitiveDetector* m_sensitive
protected

Sensitive detector.

Definition at line 117 of file GeoCryostatCreator.h.

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