Belle II Software development
GeoServiceMaterialCreator.cc
1/**************************************************************************
2 * basf2 (Belle II Analysis Software Framework) *
3 * Author: The Belle II Collaboration *
4 * *
5 * See git log for contributors and copyright holders. *
6 * This file is licensed under LGPL-3.0, see LICENSE.md. *
7 **************************************************************************/
8
9#include <structure/geometry/GeoServiceMaterialCreator.h>
10#include <geometry/CreatorFactory.h>
11#include <geometry/Materials.h>
12#include <simulation/background/BkgSensitiveDetector.h>
13#include <framework/gearbox/GearDir.h>
14#include <framework/logging/Logger.h>
15#include <G4Transform3D.hh>
16#include <G4LogicalVolume.hh>
17#include <G4PVPlacement.hh>
18#include "G4Polycone.hh"
19#include <G4Tubs.hh>
20#include <G4Cons.hh>
21#include <G4Box.hh>
22#include <string>
23#include <vector>
24#include <map>
25
26using namespace std;
27
28namespace Belle2 {
34 using namespace geometry;
35
36 namespace structure {
37
39 geometry::CreatorFactory<GeoServiceMaterialCreator> GeoServiceMaterialFactory("ServiceMaterialCreator");
40
42 ServiceGapsMaterialsPar GeoServiceMaterialCreator::createConfiguration(const GearDir& content)
43 {
44 ServiceGapsMaterialsPar ServiceMaterialGeometryPar(content.getBool("RecordBackground", false));
45
46 GearDir content0(content, "GapMomVolTopBack");
47 // Read parameters for Backward Gap Mom Volume
48 ServiceGapsMomVolPar MomVolTopBackPar;
49 for (const GearDir& GapVol : content0.getNodes("ZBound")) {
50 const double rmin = GapVol.getLength("Rmin") / Unit::mm;
51 const double rmax = GapVol.getLength("Rmax") / Unit::mm;
52 const double z = GapVol.getLength("Z") / Unit::mm;
53 MomVolTopBackPar.appendNode(rmin, rmax, z);
54 }
55 ServiceMaterialGeometryPar.getMomVolTopBack() = MomVolTopBackPar;
56
57 GearDir content1(content, "GapMomVolEclCoilBarrel");
58 // Read parameters for Backward Gap Mom Volume
59 ServiceGapsMomVolPar MomVolEclCoilBarrelPar;
60 for (const GearDir& GapVol : content1.getNodes("ZBound")) {
61 const double rmin = GapVol.getLength("Rmin") / Unit::mm;
62 const double rmax = GapVol.getLength("Rmax") / Unit::mm;
63 const double z = GapVol.getLength("Z") / Unit::mm;
64 MomVolEclCoilBarrelPar.appendNode(rmin, rmax, z);
65 }
66 ServiceMaterialGeometryPar.getMomVolEclCoilBarrel() = MomVolEclCoilBarrelPar;
67
68 GearDir content2(content, "GapMomVolBack");
69 // Read parameters for Backward Gap Mom Volume
70 ServiceGapsMomVolPar MomVolBackPar;
71 for (const GearDir& GapVol : content2.getNodes("ZBound")) {
72 const double rmin = GapVol.getLength("Rmin") / Unit::mm;
73 const double rmax = GapVol.getLength("Rmax") / Unit::mm;
74 const double z = GapVol.getLength("Z") / Unit::mm;
75 MomVolBackPar.appendNode(rmin, rmax, z);
76 }
77 ServiceMaterialGeometryPar.getMomVolBack() = MomVolBackPar;
78
79 GearDir content3(content, "GapMomVolFor");
80 // Read parameters for Forward Gap Mom Volume
81 ServiceGapsMomVolPar MomVolForPar;
82 for (const GearDir& GapVol : content3.getNodes("ZBound")) {
83 const double rmin = GapVol.getLength("Rmin") / Unit::mm;
84 const double rmax = GapVol.getLength("Rmax") / Unit::mm;
85 const double z = GapVol.getLength("Z") / Unit::mm;
86 MomVolForPar.appendNode(rmin, rmax, z);
87 }
88 ServiceMaterialGeometryPar.getMomVolFor() = MomVolForPar;
89
90 GearDir content4(content, "ServiceGapsMaterials");
91 // Read parameters to creates ServiceGaps Material in the gap between CDC and ECL, ARICH and TOP, TOP and ECL.
92 for (const GearDir& material : content4.getNodes("ServiceGapsMaterial")) {
93 ServiceGapsMaterialsCdcArichTopPar MaterialPar(
94 material.getString("Name"),
95 material.getString("material"),
96 material.getInt("@id", 0),
97 material.getLength("InnerR"),
98 material.getLength("OuterR"),
99 material.getLength("BackwardZ"),
100 material.getLength("ForwardZ")
101 );
102 ServiceMaterialGeometryPar.getServiceGapsMaterials().push_back(MaterialPar);
103 }
104
105 GearDir content5(content, "ServiceGapsEclMaterials");
106 // Read parameters to creates ServiceGaps Material in the gap between barrel and endcap of ECL.
107 for (const GearDir& material : content5.getNodes("ServiceGapsMaterial")) {
108 ServiceGapsMaterialsEclPar MaterialPar(
109 material.getString("Name"),
110 material.getString("material"),
111 material.getInt("@id", 0),
112 material.getLength("InnerR1"),
113 material.getLength("OuterR1"),
114 material.getLength("InnerR2"),
115 material.getLength("OuterR2"),
116 material.getLength("BackwardZ"),
117 material.getLength("ForwardZ")
118 );
119 ServiceMaterialGeometryPar.getServiceGapsEclMaterials().push_back(MaterialPar);
120 }
121
122 GearDir content6(content, "TicknessDensity");
123 // Read thickness and density for Gaps Volume
124 ThicknessDensityPar ThickPar(
125 content6.getInt("IRCDCBack"),
126 content6.getInt("IPhiCDCBack"),
127 content6.getInt("IRCDCFor"),
128 content6.getInt("IPhiCDCFor"),
129 content6.getInt("IRECLBack"),
130 content6.getInt("IZECLBack"),
131 content6.getInt("IPhiECLBack"),
132 content6.getInt("IRECLFor"),
133 content6.getInt("IZECLFor"),
134 content6.getInt("IPhiECLFor"),
135 content6.getInt("IZARICHFor"),
136 content6.getInt("IPhiARICHFor"),
137 content6.getInt("IPhiTOPBack"),
138 content6.getInt("IPhiTOPFor"),
139 content6.getInt("IZECLCOILBar"),
140 content6.getInt("IPhiECLCOILBar"),
141 content6.getArray("thicknesses")
142 );
143 ServiceMaterialGeometryPar.getthick() = ThickPar;
144
145
146 return ServiceMaterialGeometryPar;
147 }
148
149
150 void GeoServiceMaterialCreator::createGeometry(const ServiceGapsMaterialsPar& parameters, G4LogicalVolume& topVolume, GeometryTypes)
151 {
152 G4Material* medAir = geometry::Materials::get("Air");
153
154 const auto& MomVolFor = parameters.getMomVolFor();
155 std::vector<double> motherforRmin = MomVolFor.getRmin();
156 std::vector<double> motherforRmax = MomVolFor.getRmax();
157 std::vector<double> motherforZ = MomVolFor.getZ() ;
158
159 G4Polycone* solid_gap_for = new G4Polycone("ServiceMaterial.GAPFor", 0 * CLHEP::deg, 360.* CLHEP::deg, MomVolFor.getNNodes(),
160 motherforZ.data(), motherforRmin.data(), motherforRmax.data());
161 G4LogicalVolume* logical_gap_for = new G4LogicalVolume(solid_gap_for, medAir, "ServiceMaterial.GAPFor", 0, 0, 0);
162 new G4PVPlacement(0, G4ThreeVector(0.0, 0.0, 0.0), logical_gap_for, "ServiceMaterial.GAPFor", &topVolume, false, 1);
163
164 const auto& MomVolBack = parameters.getMomVolBack();
165 std::vector<double> motherbackRmin = MomVolBack.getRmin();
166 std::vector<double> motherbackRmax = MomVolBack.getRmax();
167 std::vector<double> motherbackZ = MomVolBack.getZ();
168
169 G4Polycone* solid_gap_back = new G4Polycone("ServiceMaterial.GAPBack", 0 * CLHEP::deg, 360.* CLHEP::deg, MomVolBack.getNNodes(),
170 motherbackZ.data(), motherbackRmin.data(), motherbackRmax.data());
171 G4LogicalVolume* logical_gap_back = new G4LogicalVolume(solid_gap_back, medAir, "ServiceMaterial.GAPBack", 0, 0, 0);
172 new G4PVPlacement(0, G4ThreeVector(0.0, 0.0, 0.0), logical_gap_back, "ServiceMaterial.GAPBack", &topVolume, false, 1);
173
174 const auto& MomVolTopBack = parameters.getMomVolTopBack();
175 std::vector<double> mothertopbackRmin = MomVolTopBack.getRmin();
176 std::vector<double> mothertopbackRmax = MomVolTopBack.getRmax();
177 std::vector<double> mothertopbackZ = MomVolTopBack.getZ();
178
179 G4Polycone* solid_gap_topback = new G4Polycone("ServiceMaterial.GAPTopBack", 0 * CLHEP::deg, 360.* CLHEP::deg,
180 MomVolTopBack.getNNodes(),
181 mothertopbackZ.data(), mothertopbackRmin.data(), mothertopbackRmax.data());
182 G4LogicalVolume* logical_gap_topback = new G4LogicalVolume(solid_gap_topback, medAir, "ServiceMaterial.GAPTopBack", 0, 0, 0);
183 new G4PVPlacement(0, G4ThreeVector(0.0, 0.0, 0.0), logical_gap_topback, "ServiceMaterial.GAPTopBack", &topVolume, false, 1);
184
185 const auto& MomVolEclCoilBarrel = parameters.getMomVolEclCoilBarrel();
186 std::vector<double> mothereclcoilbarrelRmin = MomVolEclCoilBarrel.getRmin();
187 std::vector<double> mothereclcoilbarrelRmax = MomVolEclCoilBarrel.getRmax();
188 std::vector<double> mothereclcoilbarrelZ = MomVolEclCoilBarrel.getZ();
189
190 G4Polycone* solid_gap_eclcoilbarrel = new G4Polycone("ServiceMaterial.GAPEclCoilBarrel", 0 * CLHEP::deg, 360.* CLHEP::deg,
191 MomVolEclCoilBarrel.getNNodes(),
192 mothereclcoilbarrelZ.data(), mothereclcoilbarrelRmin.data(), mothereclcoilbarrelRmax.data());
193 G4LogicalVolume* logical_gap_eclcoilbarrel = new G4LogicalVolume(solid_gap_eclcoilbarrel, medAir,
194 "ServiceMaterial.GAPEclCoilBarrel", 0, 0, 0);
195 new G4PVPlacement(0, G4ThreeVector(0.0, 0.0, 0.0), logical_gap_eclcoilbarrel, "ServiceMaterial.GAPEclCoilBarrel", &topVolume, false,
196 1);
197
198 const auto& Thick = parameters.getthick();
199 std::vector<double> Thickness = Thick.getthickness();
200 int IRCDCB = Thick.getIRCDCB();
201 int IPhiCDCB = Thick.getIPhiCDCB();
202 int IRCDCF = Thick.getIRCDCF();
203 int IPhiCDCF = Thick.getIPhiCDCF();
204 int IRECLB = Thick.getIRECLB();
205 int IZECLB = Thick.getIZECLB();
206 int IPhiECLB = Thick.getIPhiECLB();
207 int IRECLF = Thick.getIRECLF();
208 int IZECLF = Thick.getIZECLF();
209 int IPhiECLF = Thick.getIPhiECLF();
210 int IZARICHF = Thick.getIZARICHF();
211 int IPhiARICHF = Thick.getIPhiARICHF();
212 int IPhiTOPB = Thick.getIPhiTOPB();
213 int IPhiTOPF = Thick.getIPhiTOPF();
214 int IPhiECLCOILB = Thick.getIPhiECLCOILB();
215 int IZECLCOILB = Thick.getIZECLCOILB();
216
217 for (const ServiceGapsMaterialsCdcArichTopPar& material : parameters.getServiceGapsMaterials()) {
218 const int materialID = material.getIdentifier();
219 const double materialInnerR = material.getInnerR() / Unit::mm;
220 const double materialOuterR = material.getOuterR() / Unit::mm;
221 const double materialBackwardZ = material.getBackwardZ() / Unit::mm;
222 const double materialForwardZ = material.getForwardZ() / Unit::mm;
223 // Create Service Materials in the gap between CDC and ECL.
224 if (materialID < 2) {
225 int blockid = 0;
226 double IR = 0, IPhi = 0;
227 if (materialID < 1) {IR = IRCDCB; IPhi = IPhiCDCB;}
228 else {IR = IRCDCF; IPhi = IPhiCDCF;}
229 const double cellR = (materialOuterR - materialInnerR) / IRCDCB;
230 for (int iR = 0; iR < IR; iR++) {
231 const double rmin = materialInnerR + iR * cellR;
232 const double rmax = materialInnerR + (iR + 1) * cellR;
233 for (int iPhi = 0; iPhi < IPhi; iPhi++) {
234 const double SPhi = 360. / IPhi * iPhi;
235 const double DPhi = 360. / IPhi;
236 if (materialID < 1) {
237 const string storageName = "Service_CDC_ECL_Bwd_" + to_string(iR) + "_" + to_string(iPhi);
238 const double materialThick = Thickness[blockid] / Unit::mm;
239 const double materialPosZ = materialForwardZ - materialThick;
240 G4Material* mCDCGapback = geometry::Materials::get("CDCGapback");
241 createTube(rmin, rmax, SPhi, DPhi, materialThick, materialPosZ, mCDCGapback, storageName, logical_gap_back);
242 }
243 if (materialID >= 1) {
244 const string storageName = "Service_CDC_ARICH_Fwd_" + to_string(iR) + "_" + to_string(iPhi);
245 const double materialThick = Thickness[blockid + IRCDCB * IPhiCDCB] / Unit::mm;
246 const double materialPosZ = materialBackwardZ;
247 G4Material* mCDCGapfor = geometry::Materials::get("CDCGapfor");
248 createTube(rmin, rmax, SPhi, DPhi, materialThick, materialPosZ, mCDCGapfor, storageName, logical_gap_for);
249 }
250 blockid++;
251 }
252 }
253 }
254 // Create Service Materials in the gap between ARICH and TOP.
255 if (materialID == 2) {
256 int blockid = 0;
257 const double materialThick = fabs(materialForwardZ - materialBackwardZ) / IZARICHF;
258 for (int iZ = 0; iZ < IZARICHF; iZ++) {
259 const double rmax = materialOuterR;
260 const double materialPosZ = materialBackwardZ + iZ * materialThick;
261 for (int iPhi = 0; iPhi < IPhiARICHF; iPhi++) {
262 const double SPhi = 360. / IPhiARICHF * iPhi;
263 const double DPhi = 360. / IPhiARICHF;
264 const double materialRThick = Thickness[blockid + IRCDCB * IPhiCDCB + IRCDCF * IPhiCDCF] / Unit::mm;
265 const double rmin = rmax - materialRThick;
266 G4Material* ArichAir = geometry::Materials::get("Arich_TopGapfor");
267 const string storageName = "Service_ARICH_TOP_Fwd_" + to_string(iZ) + "_" + to_string(iPhi);
268 createTube(rmin, rmax, SPhi, DPhi, materialThick, materialPosZ, ArichAir, storageName, logical_gap_for);
269 blockid++;
270 }
271 }
272 }
273 // Create Service Materials in the gap between TOP and ECL.
274 if (materialID >= 3 && materialID < 5) {
275 int blockid = 0;
276 int IPhiTOP = 0;
277 if (materialID == 3) {IPhiTOP = IPhiTOPB;}
278 else {IPhiTOP = IPhiTOPF;}
279 const double rmin = materialInnerR;
280 const double rmax = materialOuterR;
281 for (int iPhi = 0; iPhi < IPhiTOP; iPhi++) {
282 const double SPhi = 360. / IPhiTOP * iPhi;
283 const double DPhi = 360. / IPhiTOP;
284 if (materialID == 3) {
285 const double materialThick = Thickness[blockid + IRCDCB * IPhiCDCB + IRCDCF * IPhiCDCF + IZARICHF * IPhiARICHF] / Unit::mm;
286 const double materialPosZ = materialForwardZ - materialThick;
287 G4Material* TopbackAir = geometry::Materials::get("Top_ECLGapback");
288 const string storageName = "Service_TOP_ECL_Bwd_" + to_string(iPhi);
289 createTube(rmin, rmax, SPhi, DPhi, materialThick, materialPosZ, TopbackAir, storageName, logical_gap_topback);
290 }
291 if (materialID == 4) {
292 const double materialThick = Thickness[blockid + IRCDCB * IPhiCDCB + IRCDCF * IPhiCDCF + IZARICHF * IPhiARICHF + IPhiTOPB] /
293 Unit::mm;
294 const double materialPosZ = materialBackwardZ;
295 G4Material* TopforAir = geometry::Materials::get("Top_ECLGapfor");
296 const string storageName = "Service_TOP_ECL_Fwd_" + to_string(iPhi);
297 createTube(rmin, rmax, SPhi, DPhi, materialThick, materialPosZ, TopforAir, storageName, logical_gap_for);
298 }
299 blockid++;
300 }
301 }
302 // Create Service Materials in the gap between barrel ECL and Coil.
303 if (materialID == 5) {
304 int blockid = 0;
305 const double materialThick = fabs(materialForwardZ - materialBackwardZ) / IZECLCOILB;
306 for (int iZ = 0; iZ < IZECLCOILB; iZ++) {
307 const double rmin = materialInnerR;
308 const double materialPosZ = materialBackwardZ + iZ * materialThick;
309 for (int iPhi = 0; iPhi < IPhiECLCOILB; iPhi++) {
310 const double SPhi = 360. / IPhiECLCOILB * iPhi;
311 const double DPhi = 360. / IPhiECLCOILB;
312 const double materialRThick = Thickness[blockid + IRCDCB * IPhiCDCB + IRCDCF * IPhiCDCF + IZARICHF * IPhiARICHF + IPhiTOPB +
313 IPhiTOPF] / Unit::mm;
314 const double rmax = rmin + materialRThick;
315 G4Material* EclCoilAir = geometry::Materials::get("ECL_COILbarrel");
316 const string storageName = "Service_ECL_COIL_Barrel_" + to_string(iZ) + "_" + to_string(iPhi);
317 createTube(rmin, rmax, SPhi, DPhi, materialThick, materialPosZ, EclCoilAir, storageName, logical_gap_eclcoilbarrel);
318 blockid++;
319 }
320 }
321 }
322 }
323
324 // Create Service Materials in the gap between barrel and endcap of ECL.
325 for (const ServiceGapsMaterialsEclPar& material : parameters.getServiceGapsEclMaterials()) {
326 int blockid = 0;
327 int IRECL = 0, IZECL = 0, IPhiECL = 0;
328 const int materialID = material.getIdentifier();
329 if (materialID < 1) {IRECL = IRECLB; IZECL = IZECLB; IPhiECL = IPhiECLB;}
330 else {IRECL = IRECLF; IZECL = IZECLF; IPhiECL = IPhiECLF;}
331 const double materialInnerR1 = material.getInnerR1() / Unit::mm;
332 const double materialOuterR1 = material.getOuterR1() / Unit::mm;
333 const double materialInnerR2 = material.getInnerR2() / Unit::mm;
334 const double materialOuterR2 = material.getOuterR2() / Unit::mm;
335 const double materialBackwardZ = material.getBackwardZ() / Unit::mm;
336 const double materialForwardZ = material.getForwardZ() / Unit::mm;
337 const double interval = (materialForwardZ - materialBackwardZ) / IZECL ;
338 const double Hf1 = (materialOuterR1 - materialInnerR1) / IRECL;
339 const double Hf2 = (materialOuterR2 - materialInnerR2) / IRECL;
340 for (int iR = 0; iR < IRECL; iR++) {
341 const double Rmin1 = materialInnerR1 + Hf1 * iR;
342 const double Rmax1 = materialInnerR1 + Hf1 * (iR + 1);
343 const double Rmin2 = materialInnerR2 + Hf2 * iR;
344 const double Rmax2 = materialInnerR2 + Hf2 * (iR + 1);
345 const double Hrmax = (Rmax2 - Rmax1) / IZECL;
346 const double Hrmin = (Rmin2 - Rmin1) / IZECL;
347 for (int iZ = 0; iZ < IZECL; iZ++) {
348 const double BackwardposZ = materialBackwardZ + interval * iZ;
349 const double ForwardposZ = materialBackwardZ + interval * (iZ + 1);
350 for (int iPhi = 0; iPhi < IPhiECL; iPhi++) {
351 const double SPhi = (360. / IPhiECL) * iPhi;
352 const double DPhi = 360. / IPhiECL;
353 if (materialID == 0) {
354 const double thick = Thickness[blockid + IRCDCB * IPhiCDCB + IRCDCF * IPhiCDCF + IZARICHF * IPhiARICHF + IPhiTOPB + IPhiTOPF +
355 IPhiECLCOILB * IZECLCOILB] / Unit::mm;
356 const double rmin2 = Rmin1 + Hrmin * (iZ + 1);
357 const double rmax2 = Rmax1 + Hrmax * (iZ + 1);
358 const double rmin1 = rmin2 - Hrmin * thick / interval ;
359 const double rmax1 = rmax2 - Hrmax * thick / interval ;
360 const double posZ = ForwardposZ - thick;
361 G4Material* ECLbackAir = geometry::Materials::get("ECLGapback");
362 const string storageName = "Service_ECLGAPS_Bwd_" + to_string(iR) + "_" + to_string(iZ) + "_" + to_string(iPhi);
363 createCone(rmin1, rmax1, rmin2, rmax2, thick, SPhi, DPhi, posZ, ECLbackAir, storageName, logical_gap_back);
364 }
365 if (materialID == 1) {
366 const double thick = Thickness[blockid + IRCDCB * IPhiCDCB + IRCDCF * IPhiCDCF + IZARICHF * IPhiARICHF + IPhiTOPB + IPhiTOPF +
367 IPhiECLCOILB * IZECLCOILB + IZECLB * IRECLB * IPhiECLB ] / Unit::mm;
368 const double rmin1 = Rmin1 + Hrmin * iZ;
369 const double rmax1 = Rmax1 + Hrmax * iZ;
370 const double rmin2 = rmin1 + Hrmin * thick / interval;
371 const double rmax2 = rmax1 + Hrmax * thick / interval;
372 const double posZ = BackwardposZ;
373 G4Material* ECLforAir = geometry::Materials::get("ECLGapfor");
374 const string storageName = "Service_ECLGAPS_Fwd_" + to_string(iR) + "_" + to_string(iZ) + "_" + to_string(iPhi);
375 createCone(rmin1, rmax1, rmin2, rmax2, thick, SPhi, DPhi, posZ, ECLforAir, storageName, logical_gap_for);
376 }
377 blockid++;
378 }
379 }
380 }
381 }
382 }
383
384 void GeoServiceMaterialCreator::createTube(const double rmin, const double rmax, const double SPhi, const double DPhi,
385 const double thick, const double posZ, G4Material* med, const string& name, G4LogicalVolume*& logical_gap)
386 {
387 const string solidName = "solid_" + name;
388 const string logicalName = "logical_" + name;
389 const string physicalName = "physical_" + name;
390 G4Tubs* solidV = new G4Tubs(solidName.c_str(), rmin * CLHEP::mm, rmax * CLHEP::mm,
391 thick * CLHEP::mm / 2.0, SPhi * CLHEP::deg, DPhi * CLHEP::deg);
392 G4LogicalVolume* logicalV = new G4LogicalVolume(solidV, med, logicalName.c_str(), 0, 0, 0);
393 new G4PVPlacement(0, G4ThreeVector(0.0, 0.0, posZ * CLHEP::mm + thick * CLHEP::mm / 2.0), logicalV,
394 physicalName.c_str(), logical_gap, false, 0);
395 }
396
397 void GeoServiceMaterialCreator::createCone(const double rmin1, const double rmax1, const double rmin2,
398 const double rmax2,
399 const double thick, const double SPhi, const double DPhi, const double posZ, G4Material* med,
400 const string& name, G4LogicalVolume*& top)
401 {
402 const string solidName = "solid" + name;
403 const string logicalName = "logical" + name;
404 const string physicalName = "physical" + name;
405 G4Cons* storageConeShape = new G4Cons(solidName.c_str(), rmin1 * CLHEP::mm, rmax1 * CLHEP::mm, rmin2 * CLHEP::mm,
406 rmax2 * CLHEP::mm, thick * CLHEP::mm / 2.0, SPhi * CLHEP::deg, DPhi * CLHEP::deg);
407 G4LogicalVolume* storageCone = new G4LogicalVolume(storageConeShape, med, logicalName.c_str(), 0, 0, 0);
408 new G4PVPlacement(0, G4ThreeVector(0.0, 0.0, posZ * CLHEP::mm + thick * CLHEP::mm / 2.0), storageCone, physicalName.c_str(), top,
409 false, 0);
410
411 }
412
413 } // structure namespace
415} // Belle2 namespace
Belle2::GearDir
GearDir is the basic class used for accessing the parameter store.
Definition: GearDir.h:31
Belle2::ServiceGapsMaterialsCdcArichTopPar
The Class for Service Materials between CDC and ECL, ARICH and TOP, TOP and ECL.
Definition: ServiceGapsMaterialsPar.h:24
Belle2::ServiceGapsMaterialsEclPar
The Class for Service Materials between barrel and endcap of ECL.
Definition: ServiceGapsMaterialsPar.h:68
Belle2::ServiceGapsMaterialsPar
The Class for services materials geometry.
Definition: ServiceGapsMaterialsPar.h:269
Belle2::ServiceGapsMaterialsPar::getServiceGapsEclMaterials
const std::vector< ServiceGapsMaterialsEclPar > & getServiceGapsEclMaterials(void) const
Get Service Materials at ECL.
Definition: ServiceGapsMaterialsPar.h:315
Belle2::ServiceGapsMaterialsPar::getMomVolBack
const ServiceGapsMomVolPar & getMomVolBack(void) const
Get Backward Gap MomVolume.
Definition: ServiceGapsMaterialsPar.h:299
Belle2::ServiceGapsMaterialsPar::getthick
const ThicknessDensityPar & getthick(void) const
Get Gap element cell Thickness.
Definition: ServiceGapsMaterialsPar.h:319
Belle2::ServiceGapsMaterialsPar::getMomVolFor
const ServiceGapsMomVolPar & getMomVolFor(void) const
Get Forward Gap MomVolume.
Definition: ServiceGapsMaterialsPar.h:303
Belle2::ServiceGapsMaterialsPar::getServiceGapsMaterials
const std::vector< ServiceGapsMaterialsCdcArichTopPar > & getServiceGapsMaterials(void) const
Get Service Materials.
Definition: ServiceGapsMaterialsPar.h:311
Belle2::ServiceGapsMaterialsPar::getMomVolEclCoilBarrel
const ServiceGapsMomVolPar & getMomVolEclCoilBarrel(void) const
Get Barrel ECL and Coil Gap MomVolume.
Definition: ServiceGapsMaterialsPar.h:307
Belle2::ServiceGapsMaterialsPar::getMomVolTopBack
const ServiceGapsMomVolPar & getMomVolTopBack(void) const
Get Backward Top Gap MomVolume.
Definition: ServiceGapsMaterialsPar.h:295
Belle2::ServiceGapsMomVolPar
The class for the mother volume of the Service Materials.
Definition: ServiceGapsMaterialsPar.h:122
Belle2::ServiceGapsMomVolPar::appendNode
void appendNode(double rmin, double rmax, double z)
Append a new node.
Definition: ServiceGapsMaterialsPar.h:132
Belle2::ThicknessDensityPar
The class for the thicknesses and the density of gap element cell.
Definition: ServiceGapsMaterialsPar.h:162
Belle2::Unit::mm
static const double mm
[millimeters]
Definition: Unit.h:70
Belle2::gearbox::Interface::getArray
std::vector< double > getArray(const std::string &path) const noexcept(false)
Get the parameter path as a list of double values converted to the standard unit.
Definition: Interface.cc:123
Belle2::gearbox::Interface::getNodes
std::vector< GearDir > getNodes(const std::string &path="") const
Get vector of GearDirs which point to all the nodes the given path evaluates to.
Definition: Interface.cc:21
Belle2::gearbox::Interface::getInt
int getInt(const std::string &path="") const noexcept(false)
Get the parameter path as a int.
Definition: Interface.cc:60
Belle2::geometry::Materials::get
static G4Material * get(const std::string &name)
Find given material.
Definition: Materials.h:63
Belle2::structure::GeoServiceMaterialCreator::createConfiguration
ServiceGapsMaterialsPar createConfiguration(const GearDir &param)
Create a parameter object from the Gearbox XML parameters.
Definition: GeoServiceMaterialCreator.cc:42
Belle2::structure::GeoServiceMaterialCreator::createTube
void createTube(const double rmin, const double rmax, const double SPhi, const double DPhi, const double thick, const double posZ, G4Material *med, const std::string &name, G4LogicalVolume *&top)
Create G4Tube.
Definition: GeoServiceMaterialCreator.cc:384
Belle2::structure::GeoServiceMaterialCreator::createGeometry
void createGeometry(const ServiceGapsMaterialsPar &parameters, G4LogicalVolume &topVolume, geometry::GeometryTypes type)
Create the geometry from a parameter object.
Definition: GeoServiceMaterialCreator.cc:150
Belle2::structure::GeoServiceMaterialCreator::createCone
void createCone(const double rmin1, const double rmax1, const double rmin2, const double rmax2, const double thick, const double SPhi, const double DPhi, const double posz, G4Material *med, const std::string &name, G4LogicalVolume *&top)
Create G4Cone.
Definition: GeoServiceMaterialCreator.cc:397
Belle2::geometry::GeometryTypes
GeometryTypes
Flag indiciating the type of geometry to be used.
Definition: GeometryManager.h:36
Belle2::structure::GeoServiceMaterialFactory
geometry::CreatorFactory< GeoServiceMaterialCreator > GeoServiceMaterialFactory("ServiceMaterialCreator")
Create factory instance so that the framework can instantiate the ServiceMaterialCreator.
Belle2
Abstract base class for different kinds of events.
Definition: MillepedeAlgorithm.h:17
std
STL namespace.
Belle2::geometry::CreatorFactory
Very simple class to provide an easy way to register creators with the CreatorManager.
Definition: CreatorFactory.h:31