Belle II Software development
GeoARICHCreator.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 <arich/geometry/GeoARICHCreator.h>
10#include <arich/dbobjects/tessellatedSolidStr.h>
11
12#include <geometry/Materials.h>
13#include <geometry/CreatorFactory.h>
14#include <geometry/utilities.h>
15#include <framework/gearbox/Unit.h>
16#include <framework/logging/Logger.h>
17#include <arich/simulation/SensitiveDetector.h>
18#include <arich/simulation/SensitiveAero.h>
19#include <simulation/background/BkgSensitiveDetector.h>
20#include <arich/dbobjects/ARICHPositionElement.h>
21
22#include <cmath>
23
24// Geant4
25#include <G4LogicalVolume.hh>
26#include <G4PVPlacement.hh>
27#include <G4AssemblyVolume.hh>
28#include <G4UnionSolid.hh>
29#include <G4LogicalSkinSurface.hh>
30#include <G4OpticalSurface.hh>
31
32// Geant4 Shapes
33#include <G4Box.hh>
34#include <G4Tubs.hh>
35#include <G4Trap.hh>
36#include <G4Torus.hh>
37#include <G4TessellatedSolid.hh>
38#include <G4TriangularFacet.hh>
39
40#include <G4SubtractionSolid.hh>
41#include <G4Region.hh>
42#include <G4Material.hh>
43
44using namespace std;
45using namespace CLHEP;
46
47namespace Belle2 {
52
53 using namespace geometry;
54
55 namespace arich {
56
57 //-----------------------------------------------------------------
58 // Register the Creator
59 //-----------------------------------------------------------------
60
61 geometry::CreatorFactory<GeoARICHCreator> GeoARICHFactory("ARICHCreator");
62
63 //-----------------------------------------------------------------
64 // Implementation
65 //-----------------------------------------------------------------
66
72
73 GeoARICHCreator::~GeoARICHCreator()
74 {
75 delete m_sensitive;
76 delete m_sensitiveAero;
77 G4LogicalSkinSurface::CleanSurfaceTable();
78
79 }
80
81
82 void GeoARICHCreator::createGeometry(G4LogicalVolume& topVolume, GeometryTypes)
83 {
84
85 m_config.useGeantUnits();
86 m_sensitive = new SensitiveDetector();
87 m_sensitiveAero = new SensitiveAero();
88
89 // print geometry configuration
90 // m_config.print();
91
92 //Build envelope
93 G4Tubs* envelopeTube = new G4Tubs("Envelope", m_config.getMasterVolume().getInnerRadius(),
94 m_config.getMasterVolume().getOuterRadius(), m_config.getMasterVolume().getLength() / 2., 0, 2 * M_PI);
95 G4Material* material = Materials::get(m_config.getMasterVolume().getMaterial());
96
97 // check of material and its refractive index
98 if (!material) { B2FATAL("Material ARICH_Air required for ARICH master volume could not be found");}
99 if (!getAvgRINDEX(material))
100 B2WARNING("Material ARICH_Air required by ARICH master volume has no specified refractive index. Continuing, but no photons in ARICH will be propagated.");
101
102 // create and place
103 G4LogicalVolume* masterLV = new G4LogicalVolume(envelopeTube, material, "ARICH.masterVolume");
104 setVisibility(*masterLV, false);
105
106 // Set up region for production cuts
107 G4Region* aRegion = new G4Region("ARICHEnvelope");
108 masterLV->SetRegion(aRegion);
109 aRegion->AddRootLogicalVolume(masterLV);
110
111 G4RotationMatrix rotMaster;
112 double rot_x = m_config.getMasterVolume().getRotationX();
113 double rot_y = m_config.getMasterVolume().getRotationY();
114 double rot_z = m_config.getMasterVolume().getRotationZ();
115 double tr_x = m_config.getMasterVolume().getPosition().X();
116 double tr_y = m_config.getMasterVolume().getPosition().Y();
117 double tr_z = m_config.getMasterVolume().getPosition().Z();
118
119 if (m_config.useGlobalDisplacement()) {
120 rot_x += m_config.getGlobalDisplacement().getAlpha();
121 rot_y += m_config.getGlobalDisplacement().getBeta();
122 rot_z += m_config.getGlobalDisplacement().getGamma();
123 tr_x += m_config.getGlobalDisplacement().getX();
124 tr_y += m_config.getGlobalDisplacement().getY();
125 tr_z += m_config.getGlobalDisplacement().getZ();
126 B2WARNING("ARICH global displacement parameters from DB will be taken into account.");
127 }
128 rotMaster.rotateX(rot_x);
129 rotMaster.rotateY(rot_y);
130 rotMaster.rotateZ(rot_z);
131
132 G4ThreeVector transMaster(tr_x, tr_y, tr_z);
133
134 new G4PVPlacement(G4Transform3D(rotMaster, transMaster), masterLV, "ARICH.MasterVolume", &topVolume, false, 1);
135
136 m_isBeamBkgStudy = m_config.doBeamBackgroundStudy();
137
138 // Z shift for placing volumes in ARICH master volume
139 double zShift = 0;
140
141 // build photon detector logical volume
142 G4LogicalVolume* detPlaneLV = buildDetectorPlane(m_config);
143 G4LogicalVolume* detSupportPlateLV = buildDetectorSupportPlate(m_config);
144
145 // Build merger PCB logical volume
146 G4LogicalVolume* mergerLV = buildMergerPCBEnvelopePlane(m_config);
147
148 // Build the cables envelop with effective material describing cables
149 G4LogicalVolume* cablesLV = buildCables(m_config.getCablesEnvelope());
150
151 // Build cooling system assembly envelope plane
152 //G4LogicalVolume* coolingLV = buildCoolingEnvelopePlane(m_config.getCoolingGeometry());
153
154 // Build aerogel logical volume
155 G4LogicalVolume* aeroPlaneLV;
156 if (!m_config.getAerogelPlane().isSimple()) {
157 aeroPlaneLV = buildAerogelPlane(m_config);
158 } else {
159 B2INFO("GeoARICHCreator: using simple cosmic test geometry.");
160 aeroPlaneLV = buildSimpleAerogelPlane(m_config);
161 }
162
163 G4RotationMatrix rotDetPlane;
164 rotDetPlane.rotateX(m_config.getDetectorPlane().getRotationX());
165 rotDetPlane.rotateY(m_config.getDetectorPlane().getRotationY());
166 rotDetPlane.rotateZ(m_config.getDetectorPlane().getRotationZ());
167
168 //
169 // For the moment rotation of merger PCB board envelope is not foreseen.
170 //
171 G4RotationMatrix rotMergerPlane;
172 rotMergerPlane.rotateX(0.0);
173 rotMergerPlane.rotateY(0.0);
174 rotMergerPlane.rotateZ(0.0);
175
176 //
177 // For the moment rotation of cables envelope is not foreseen.
178 //
179 G4RotationMatrix rotCablesPlane;
180 rotCablesPlane.rotateX(0.0);
181 rotCablesPlane.rotateY(0.0);
182 rotCablesPlane.rotateZ(0.0);
183
184 G4RotationMatrix rotCoolingPlane;
185 rotCoolingPlane.rotateX(0.0);
186 rotCoolingPlane.rotateY(0.0);
187 rotCoolingPlane.rotateZ(0.0);
188
189 G4RotationMatrix rotAeroPlane;
190 rotAeroPlane.rotateX(m_config.getAerogelPlane().getRotationX());
191 rotAeroPlane.rotateY(m_config.getAerogelPlane().getRotationY());
192 rotAeroPlane.rotateZ(m_config.getAerogelPlane().getRotationZ());
193
194 G4ThreeVector transDetPlane(m_config.getDetectorPlane().getPosition().X(), m_config.getDetectorPlane().getPosition().Y(),
195 m_config.getDetectorPlane().getPosition().Z() + zShift);
196
197 G4ThreeVector transDetSupportPlate(m_config.getDetectorPlane().getPosition().X(), m_config.getDetectorPlane().getPosition().Y(),
198 m_config.getDetectorPlane().getSupportZPosition() + zShift);
199
200 G4ThreeVector transMergerPlate(m_config.getMergerGeometry().getEnvelopeCenterPosition().X() * mm,
201 m_config.getMergerGeometry().getEnvelopeCenterPosition().Y() * mm,
202 m_config.getMergerGeometry().getEnvelopeCenterPosition().Z() * mm + zShift);
203
204 G4ThreeVector transCablesPlate(m_config.getCablesEnvelope().getEnvelopeCenterPosition().X(),
205 m_config.getCablesEnvelope().getEnvelopeCenterPosition().Y(),
206 m_config.getCablesEnvelope().getEnvelopeCenterPosition().Z() + zShift);
207
208 G4ThreeVector transCoolingPlate(m_config.getCoolingGeometry().getEnvelopeCenterPosition().X() * mm,
209 m_config.getCoolingGeometry().getEnvelopeCenterPosition().Y() * mm,
210 m_config.getCoolingGeometry().getEnvelopeCenterPosition().Z() * mm + zShift);
211
212 G4ThreeVector transAeroPlane(m_config.getAerogelPlane().getPosition().X(),
213 m_config.getAerogelPlane().getPosition().Y(),
214 m_config.getAerogelPlane().getPosition().Z() + zShift);
215
216
217 new G4PVPlacement(G4Transform3D(rotDetPlane, transDetPlane), detPlaneLV, "ARICH.detPlane", masterLV, false, 1);
218 new G4PVPlacement(G4Transform3D(rotDetPlane, transDetSupportPlate), detSupportPlateLV, "ARICH.detSupportPlane", masterLV, false, 1);
219 if (mergerLV) new G4PVPlacement(G4Transform3D(rotMergerPlane, transMergerPlate), mergerLV, "ARICH.mergerPlane", masterLV, false, 1);
220 new G4PVPlacement(G4Transform3D(rotCablesPlane, transCablesPlate), cablesLV, "ARICH.cablesPlane", masterLV, false, 1);
221 //new G4PVPlacement(G4Transform3D(rotCoolingPlane, transCoolingPlate), coolingLV, "ARICH.coolingPlane", masterLV, false, 1);
222 new G4PVPlacement(G4Transform3D(rotAeroPlane, transAeroPlane), aeroPlaneLV, "ARICH.aeroPlane", masterLV, false, 1);
223
224 /*
225 // build and place cooling test plates
226 G4LogicalVolume* coolingTestPlatesLV = buildCoolingTestPlate(m_config.getCoolingGeometry());
227 double coolingTestPlateAngle = 0.0;
228 double coolingTestPlateR = 0.0;
229 for (unsigned i = 0; i < m_config.getCoolingGeometry().getCoolingTestPlatePosR().size(); i++) {
230 coolingTestPlateAngle = m_config.getCoolingGeometry().getCoolingTestPlatePosPhi().at(i) * deg;
231 coolingTestPlateR = m_config.getCoolingGeometry().getCoolingTestPlatePosR().at(i) * mm;
232 G4RotationMatrix rotCoolingTestPlate;
233 rotCoolingTestPlate.rotateZ(coolingTestPlateAngle);
234 G4ThreeVector transCoolingTestPlate(coolingTestPlateR * cos(coolingTestPlateAngle),
235 coolingTestPlateR * sin(coolingTestPlateAngle),
236 m_config.getCoolingGeometry().getCoolingTestPlatePosZ0().at(i) * mm + zShift);
237 new G4PVPlacement(G4Transform3D(rotCoolingTestPlate, transCoolingTestPlate), coolingTestPlatesLV, "ARICH.coolingTestPlates",
238 masterLV, false, i);
239 }
240 */
241
242 // build and place mirrors
243 G4LogicalVolume* mirrorLV = buildMirror(m_config);
244 int nMirrors = m_config.getMirrors().getNMirrors();
245 int mirStart = m_config.getMirrors().getStartAngle();
246 int mirZPos = m_config.getMirrors().getZPosition();
247 int mirRad = m_config.getMirrors().getRadius();
248
249 double angl = mirStart;
250 double dphi = 2 * M_PI / nMirrors;
251 if (m_config.useMirrorDisplacement()) B2WARNING("ARICH mirrors displacement parameters from DB will be used.");
252 for (int i = 1; i < nMirrors + 1; i++) {
253 double mrot_x = 0;
254 double mrot_y = 0;
255 double mrot_z = angl;
256 double mtr_x = mirRad * cos(angl);
257 double mtr_y = mirRad * sin(angl);
258 double mtr_z = mirZPos + zShift;
259 if (m_config.useMirrorDisplacement()) {
260 const ARICHPositionElement& displ = m_config.getMirrorDisplacement().getDisplacementElement(i);
261 mrot_x += displ.getAlpha();
262 mrot_y += displ.getBeta();
263 mrot_z += displ.getGamma();
264 mtr_x += displ.getX();
265 mtr_y += displ.getY();
266 mtr_z += displ.getZ();
267 }
268 G4RotationMatrix rotMirror;
269 rotMirror.rotateX(mrot_x);
270 rotMirror.rotateY(mrot_y);
271 rotMirror.rotateZ(mrot_z);
272 G4ThreeVector transMirror(mtr_x, mtr_y, mtr_z);
273 new G4PVPlacement(G4Transform3D(rotMirror, transMirror), mirrorLV, "ARICH.mirrorPlate", masterLV, false, i);
274 angl += dphi;
275 }
276
277 // build additional components of support structure
278
279 const ARICHGeoSupport& supportPar = m_config.getSupportStructure();
280 std::vector<G4LogicalVolume*> shieldLV(2);
281 std::vector<double> shieldZ(2);
282 int nTubes = supportPar.getNTubes();
283 for (int i = 0; i < nTubes; i++) {
284 G4Tubs* tube = new G4Tubs(supportPar.getTubeName(i), supportPar.getTubeInnerR(i), supportPar.getTubeOuterR(i),
285 supportPar.getTubeLength(i) / 2., 0, 2.*M_PI);
286 G4Material* tubeMaterial = Materials::get(supportPar.getTubeMaterial(i));
287
288 if (supportPar.getTubeName(i) == "ARICH.NeutronShield1") {
289 shieldLV[0] = new G4LogicalVolume(tube, tubeMaterial, supportPar.getTubeName(i));
290 shieldZ[0] = supportPar.getTubeZPosition(i) + supportPar.getTubeLength(i) / 2.;
291 continue;
292 } else if (supportPar.getTubeName(i) == "ARICH.NeutronShield2") {
293 shieldLV[1] = new G4LogicalVolume(tube, tubeMaterial, supportPar.getTubeName(i));
294 shieldZ[1] = supportPar.getTubeZPosition(i) + supportPar.getTubeLength(i) / 2.;
295 continue;
296 }
297
298 G4LogicalVolume* tubeLV = new G4LogicalVolume(tube, tubeMaterial, supportPar.getTubeName(i));
299
300 new G4PVPlacement(G4Transform3D(G4RotationMatrix(), G4ThreeVector(0, 0,
301 supportPar.getTubeZPosition(i) + supportPar.getTubeLength(i) / 2. + zShift)), tubeLV, supportPar.getTubeName(i), masterLV, false,
302 1);
303 }
304
305 const std::vector<double> wedge1 = supportPar.getWedge(1);
306 const std::vector<double> wedge2 = supportPar.getWedge(2);
307 G4Material* wedge1Material = Materials::get(supportPar.getWedgeMaterial(1));
308 G4Material* wedge2Material = Materials::get(supportPar.getWedgeMaterial(2));
309 G4AssemblyVolume* assemblyWedge1 = new G4AssemblyVolume();
310 G4AssemblyVolume* assemblyWedge2 = new G4AssemblyVolume();
311 makeJoint(wedge1Material, wedge1, assemblyWedge1);
312 makeJoint(wedge2Material, wedge2, assemblyWedge2);
313
314 G4Transform3D Tr;
315 int nWedge = supportPar.getNWedges();
316 for (int i = 0; i < nWedge; i++) {
317 G4RotationMatrix Rx;
318 int wgtype = supportPar.getWedgeType(i);
319 double phi = supportPar.getWedgePhi(i);
320 Rx.rotateZ(phi);
321 double r = supportPar.getWedgeR(i);
322 double z = supportPar.getWedgeZ(i);
323 G4ThreeVector Tb(r * cos(phi), r * sin(phi), z);
324
325 if (shieldLV[0]) {
326 z -= shieldZ[0];
327 Tb.setZ(z);
328 Tr = G4Transform3D(Rx, Tb);
329 if (wgtype == 1) assemblyWedge1->MakeImprint(shieldLV[0], Tr);
330 else if (wgtype == 2) assemblyWedge2->MakeImprint(shieldLV[0], Tr);
331 continue;
332 }
333
334 Tr = G4Transform3D(Rx, Tb);
335 if (wgtype == 1) assemblyWedge1->MakeImprint(masterLV, Tr);
336 else if (wgtype == 2) assemblyWedge2->MakeImprint(masterLV, Tr);
337 else B2ERROR("GeoARICHCreator: invalid support wedge type!");
338 }
339
340 // place neutron shield volumes
341 if (shieldLV[0])
342 new G4PVPlacement(G4Transform3D(G4RotationMatrix(), G4ThreeVector(0, 0, shieldZ[0])), shieldLV[0], "ARICH.NeutronShield1", masterLV,
343 false, 1);
344 if (shieldLV[1])
345 new G4PVPlacement(G4Transform3D(G4RotationMatrix(), G4ThreeVector(0, 0, shieldZ[1])), shieldLV[1], "ARICH.NeutronShield2", masterLV,
346 false, 1);
347
348 // place mirror holders, for now skip
349 /*
350 double mirSupX = 17.;
351 double mirSupY = 14.;
352 double mirSupLen = 131;
353 double mirSupLen1 = 201;
354
355 std::vector<G4TwoVector> polygon;
356 polygon.assign(12, G4TwoVector());
357 polygon[11] = G4TwoVector(-mirSupX / 2., -mirSupY / 2.);
358 polygon[10] = G4TwoVector(-mirSupX / 2., 2.);
359 polygon[9] = G4TwoVector(-mirSupX / 4., 2. - 0.75);
360 polygon[8] = G4TwoVector(-mirSupX / 4., 5. - 0.75);
361 polygon[7] = G4TwoVector(-mirSupX / 2., 5);
362 polygon[6] = G4TwoVector(-mirSupX / 2., mirSupY / 2.);
363 polygon[5] = G4TwoVector(mirSupX / 2., mirSupY / 2.);
364 polygon[4] = G4TwoVector(mirSupX / 2., 6);
365 polygon[3] = G4TwoVector(mirSupX / 4., 6. - 0.75);
366 polygon[2] = G4TwoVector(mirSupX / 4., 2. - 0.75);
367 polygon[1] = G4TwoVector(mirSupX / 2., 2.);
368 polygon[0] = G4TwoVector(mirSupX / 2., -mirSupY / 2.);
369
370 std::vector<G4ExtrudedSolid::ZSection> zsections;
371 zsections.push_back(G4ExtrudedSolid::ZSection(-mirSupLen / 2., G4TwoVector(0, 0), 1));
372 zsections.push_back(G4ExtrudedSolid::ZSection(mirSupLen / 2., G4TwoVector(0, 0), 1));
373
374 G4ExtrudedSolid* shape = new G4ExtrudedSolid("bla", polygon, zsections);
375 G4LogicalVolume* shapeLV = new G4LogicalVolume(shape, wedge1Material, "mirrorsupport");
376
377 G4Box* shape1 = new G4Box("shape1", mirSupX / 2., 2. / 2., mirSupLen1 / 2.);
378 G4LogicalVolume* shape1LV = new G4LogicalVolume(shape1, wedge1Material, "mirrorholder");
379
380 G4AssemblyVolume* mirroHolder = new G4AssemblyVolume();
381 G4RotationMatrix Rh;
382 G4ThreeVector Th(0, 0, 0);
383 Tr = G4Transform3D(Rh, Th);
384 mirroHolder->AddPlacedVolume(shapeLV, Tr);
385
386 Th.setZ(-35.0);
387 Th.setY(-mirSupY / 2. - 1.);
388 Tr = G4Transform3D(Rh, Th);
389 mirroHolder->AddPlacedVolume(shape1LV, Tr);
390
391 double rholder = m_config.getDetectorPlane().getSupportOuterR() - mirSupY / 2.;
392
393 angl = dphi / 2.;
394 for (int i = 1; i < nMirrors + 1; i++) {
395 G4RotationMatrix rotMirror;
396 rotMirror.rotateX(M_PI);
397 rotMirror.rotateZ(-M_PI / 2. + angl);
398 G4ThreeVector transMirror(rholder * cos(angl), rholder * sin(angl), mirZPos + zShift);
399 Tr = G4Transform3D(rotMirror, transMirror);
400 mirroHolder->MakeImprint(masterLV, Tr);
401 angl += dphi;
402 }
403 */
404
405 // temporary for simple cosmic test
406 // if using simple configuration, place scinitilators
407 if (m_config.getAerogelPlane().isSimple()) {
408 int nBoxes = supportPar.getNBoxes();
409 for (int i = 0; i < nBoxes; i++) {
410 ARICHGeoSupport::box box = supportPar.getBox(i);
411 G4Box* scintBox = new G4Box("scintBox", box.size[0] * 10. / 2., box.size[1] * 10. / 2., box.size[2] * 10. / 2.);
412 G4Material* scintMaterial = Materials::get(box.material);
413 G4LogicalVolume* scintLV = new G4LogicalVolume(scintBox, scintMaterial, box.name);
414 scintLV->SetSensitiveDetector(m_sensitiveAero);
415 G4RotationMatrix rotScint;
416 rotScint.rotateX(box.rotation[0]);
417 rotScint.rotateY(box.rotation[1]);
418 rotScint.rotateZ(box.rotation[2]);
419 ROOT::Math::XYZVector transScintTV(box.position[0], box.position[1], box.position[2]);
420 transScintTV = m_config.getMasterVolume().pointToGlobal(transScintTV);
421 B2INFO("GeoARICHCreator: Scintilator " << box.name << " placed at global: " << transScintTV.X() << " " << transScintTV.Y() << " " <<
422 transScintTV.Z());
423 G4ThreeVector transScint(box.position[0] * 10., box.position[1] * 10., box.position[2] * 10.);
424 new G4PVPlacement(G4Transform3D(rotScint, transScint), scintLV, "scintilator", masterLV, false, 1);
425 }
426 }
427
428 m_config.useBasf2Units();
429
430 delete assemblyWedge1;
431 delete assemblyWedge2;
432
433 return;
434
435 }
436
437
438 G4LogicalVolume* GeoARICHCreator::buildSimpleAerogelPlane(const ARICHGeometryConfig& detectorGeo)
439 {
440
441 const ARICHGeoAerogelPlane& aeroGeo = detectorGeo.getAerogelPlane();
442
443 const std::vector<double>& params = aeroGeo.getSimpleParams();
444
445 // support plane
446 double rin = aeroGeo.getSupportInnerR();
447 double rout = aeroGeo.getSupportOuterR();
448 double thick = aeroGeo.getSupportThickness();
449 string supportMat = aeroGeo.getSupportMaterial();
450 double wallHeight = aeroGeo.getWallHeight();
451 G4Material* supportMaterial = Materials::get(supportMat);
452 G4Material* gapMaterial = Materials::get("Air"); // Air without refractive index (to kill photons, to mimic black paper around tile)
453
454 // master volume
455 G4Tubs* aerogelTube = new G4Tubs("aerogelTube", rin, rout, (thick + wallHeight) / 2., 0, 2 * M_PI);
456 G4LogicalVolume* aerogelPlaneLV = new G4LogicalVolume(aerogelTube, gapMaterial, "ARICH.AaerogelPlane");
457
458 // support plate
459 G4Tubs* supportTube = new G4Tubs("aeroSupportTube", rin, rout, thick / 2., 0, 2 * M_PI);
460 G4LogicalVolume* supportTubeLV = new G4LogicalVolume(supportTube, supportMaterial, "ARICH.AerogelSupportPlate");
461 //supportTubeLV->SetSensitiveDetector(m_sensitiveAero);
462
463 unsigned nLayer = aeroGeo.getNLayers();
464
465 // loop over layers
466 double zLayer = 0;
467 for (unsigned iLayer = 1; iLayer < nLayer + 1; iLayer++) {
468 double layerThick = aeroGeo.getLayerThickness(iLayer);
469 std::stringstream tileName;
470 tileName << "aerogelTile_" << iLayer;
471
472 G4Box* tileShape = new G4Box(tileName.str(), params[0] * 10. / 2., params[1] * 10. / 2., layerThick / 2.);
473
474 G4Material* aeroMaterial = Materials::get(aeroGeo.getLayerMaterial(iLayer));
475
476 G4LogicalVolume* tileLV = new G4LogicalVolume(tileShape, aeroMaterial, string("ARICH.") + tileName.str());
477
478 G4ThreeVector transTile(params[2] * 10., params[3] * 10., (thick + layerThick - wallHeight) / 2. + zLayer);
479 G4RotationMatrix Ra;
480 Ra.rotateZ(params[4]);
481 new G4PVPlacement(G4Transform3D(Ra, transTile), tileLV, string("ARICH.") + tileName.str(), aerogelPlaneLV, false, iLayer);
482
483 zLayer += layerThick;
484 }
485
486 new G4PVPlacement(G4Translate3D(0., 0., -wallHeight / 2.), supportTubeLV, "ARICH.AerogelSupportPlate", aerogelPlaneLV, false, 1);
487
488 return aerogelPlaneLV;
489 }
490
491 G4LogicalVolume* GeoARICHCreator::buildAerogelPlane(const ARICHGeometryConfig& detectorGeo)
492 {
493 if (detectorGeo.getAerogelPlane().getFullAerogelMaterialDescriptionKey() == 0)
494 return buildAerogelPlaneAveragedOverLayers(detectorGeo);
495 else if (detectorGeo.getAerogelPlane().getFullAerogelMaterialDescriptionKey() == 1)
496 return buildAerogelPlaneWithIndividualTilesProp(detectorGeo);
497 else
498 B2ERROR("GeoARICHCreator::buildAerogelPlane --> getFullAerogelMaterialDescriptionKey() is wrong");
499 return NULL;
500 }
501
502 G4LogicalVolume* GeoARICHCreator::buildAerogelPlaneAveragedOverLayers(const ARICHGeometryConfig& detectorGeo)
503 {
504
505 //cout<<"GeoARICHCreator::buildAerogelPlaneAveragedOverLayers(const ARICHGeometryConfig& detectorGeo)"<<endl;
506
507 const ARICHGeoAerogelPlane& aeroGeo = detectorGeo.getAerogelPlane();
508
509 // support plane
510 double rin = aeroGeo.getSupportInnerR();
511 double rout = aeroGeo.getSupportOuterR();
512 double thick = aeroGeo.getSupportThickness();
513 double wallThick = aeroGeo.getWallThickness();
514 double wallHeight = aeroGeo.getWallHeight();
515 string supportMat = aeroGeo.getSupportMaterial();
516 G4Material* supportMaterial = Materials::get(supportMat);
517 G4Material* gapMaterial = Materials::get("Air"); // Air without refractive index (to kill photons, to mimic black paper around tile)
518 G4Material* imgMaterial = Materials::get("ARICH_Air");
519 // master volume
520
521 //double imgTubeLen = 0.5; // if changed, change position of aerogel plane also in main function!!
522 double imgTubeLen = aeroGeo.getImgTubeThickness();
523 G4Tubs* aerogelTube = new G4Tubs("aerogelTube", rin, rout, (thick + wallHeight + imgTubeLen) / 2., 0, 2 * M_PI);
524 G4LogicalVolume* aerogelPlaneLV = new G4LogicalVolume(aerogelTube, gapMaterial, "ARICH.AaerogelPlane");
525
526 // support plate
527 G4Tubs* supportTube = new G4Tubs("aeroSupportTube", rin, rout, thick / 2., 0, 2 * M_PI);
528 G4LogicalVolume* supportTubeLV = new G4LogicalVolume(supportTube, supportMaterial, "ARICH.AerogelSupportPlate");
529 //supportTubeLV->SetSensitiveDetector(m_sensitiveAero);
530
531 // imaginary tube after aerogel layers (used as volume to which tracks are extrapolated by ext module)
532 G4Tubs* imgTube = new G4Tubs("imgTube", rin, rout, imgTubeLen / 2., 0, 2 * M_PI);
533 G4LogicalVolume* imgTubeLV = new G4LogicalVolume(imgTube, imgMaterial, "ARICH.AerogelImgPlate");
534 imgTubeLV->SetSensitiveDetector(m_sensitiveAero);
535
536
537 // read radiuses of aerogel slot aluminum walls
538 std::vector<double> wallR;
539 unsigned nRing = aeroGeo.getNRings();
540 for (unsigned iRing = 1; iRing < nRing + 1; iRing++) {
541 wallR.push_back(aeroGeo.getRingRadius(iRing));
542 }
543
544 unsigned nLayer = aeroGeo.getNLayers();
545 double tileGap = aeroGeo.getTileGap();
546 G4Transform3D transform = G4Translate3D(0., 0., (thick - imgTubeLen) / 2.);
547
548 for (unsigned iRing = 0; iRing < nRing; iRing++) {
549
550 // aluminum walls between tile rings (r wall)
551 std::stringstream wallName;
552 wallName << "supportWallR_" << iRing + 1;
553 G4Tubs* supportWall = new G4Tubs(wallName.str().c_str(), wallR[iRing], wallR[iRing] + wallThick, wallHeight / 2., 0, 2 * M_PI);
554 G4LogicalVolume* supportWallLV = new G4LogicalVolume(supportWall, supportMaterial, string("ARICH.") + wallName.str().c_str());
555
556 new G4PVPlacement(transform, supportWallLV, string("ARICH.") + wallName.str().c_str(), aerogelPlaneLV, false, 0);
557
558 if (iRing == 0) continue;
559
560 // place phi aluminum walls
561 double dphi = aeroGeo.getRingDPhi(iRing);
562
563 wallName.str("");
564 wallName << "supportWallPhi_" << iRing + 1;
565 G4Box* wall = new G4Box(wallName.str(), (wallR[iRing] - wallR[iRing - 1] - wallThick) / 2. - 1., thick / 2., wallHeight / 2.);
566 [[clang::suppress]]
567 G4LogicalVolume* wallLV = new G4LogicalVolume(wall, supportMaterial, string("ARICH.") + wallName.str());
568 double r = (wallR[iRing - 1] + wallThick + wallR[iRing]) / 2.;
569 double zLayer = 0;
570
571 // loop over layers
572 int iSlot = 1;
573 for (unsigned iLayer = 1; iLayer < nLayer + 1; iLayer++) {
574 double iphi = 0;
575 double layerThick = aeroGeo.getLayerThickness(iLayer);
576
577 std::stringstream tileName;
578 tileName << "aerogelTile_" << iRing << "_" << iLayer;
579
580 G4Tubs* tileShape = new G4Tubs(tileName.str(), wallR[iRing - 1] + wallThick + tileGap, wallR[iRing] - tileGap, layerThick / 2.,
581 (tileGap + wallThick / 2.) / wallR[iRing], dphi - (2.*tileGap + wallThick) / wallR[iRing]);
582
583 G4Material* aeroMaterial = Materials::get(aeroGeo.getLayerMaterial(iLayer));
584 [[clang::suppress]]
585 G4LogicalVolume* tileLV = new G4LogicalVolume(tileShape, aeroMaterial, string("ARICH.") + tileName.str());
586
587 while (iphi < 2 * M_PI - 0.0001) {
588 G4ThreeVector trans(r * cos(iphi), r * sin(iphi), (thick - imgTubeLen) / 2.);
589 G4RotationMatrix Ra;
590 Ra.rotateZ(iphi);
591
592 if (iLayer == 1) new G4PVPlacement(G4Transform3D(Ra, trans), wallLV, string("ARICH.") + wallName.str(), aerogelPlaneLV, false,
593 iSlot);
594
595 G4ThreeVector transTile(0, 0, (thick + layerThick - wallHeight - imgTubeLen) / 2. + zLayer);
596 new G4PVPlacement(G4Transform3D(Ra, transTile), tileLV, string("ARICH.") + tileName.str(), aerogelPlaneLV, false, iSlot);
597 iphi += dphi;
598 iSlot++;
599 }
600 zLayer += layerThick;
601 }
602 }
603
604 new G4PVPlacement(G4Translate3D(0., 0., -(wallHeight + imgTubeLen) / 2.), supportTubeLV, "ARICH.AerogelSupportPlate",
605 aerogelPlaneLV,
606 false, 1);
607
608 new G4PVPlacement(G4Translate3D(0., 0., (wallHeight + thick) / 2.), imgTubeLV, "ARICH.AerogelImgPlate", aerogelPlaneLV, false, 1);
609
610 return aerogelPlaneLV;
611
612 }
613
614 G4LogicalVolume* GeoARICHCreator::buildAerogelPlaneWithIndividualTilesProp(const ARICHGeometryConfig& detectorGeo)
615 {
616
617 //cout << "GeoARICHCreator::buildAerogelPlaneWithIndividualTilesProp(const ARICHGeometryConfig& detectorGeo)" << endl;
618
619 const ARICHGeoAerogelPlane& aeroGeo = detectorGeo.getAerogelPlane();
620
621 // support plane
622 double rin = aeroGeo.getSupportInnerR();
623 double rout = aeroGeo.getSupportOuterR();
624 double thick = aeroGeo.getSupportThickness();
625 double wallThick = aeroGeo.getWallThickness();
626 // Maximum total (up and down) thickness of the aerogel tiles
627 double maxTotalAerogelThick = aeroGeo.getMaximumTotalTileThickness();
628 //cout<<"maxTotalAerogelThick "<<maxTotalAerogelThick<<endl
629 // <<"wallHeight "<<wallHeight<<endl;
630 // In case of individual thickness of the tiles we need to define compensation
631 // volume with ARICH air. This volume situated between aerogel tile and image plane (imgTube).
632 // Minimum thickness of the compensation volume with ARICH air
633 double compensationARICHairVolumeThick_min = aeroGeo.getCompensationARICHairVolumeThick_min(); // mm
634 // Please note redefinition of wallHeight value
635 double wallHeight = maxTotalAerogelThick + compensationARICHairVolumeThick_min;
636
637 string supportMat = aeroGeo.getSupportMaterial();
638 G4Material* supportMaterial = Materials::get(supportMat);
639
640 G4Material* gapMaterial =
641 Materials::get("Air"); // Air without refractive index (to kill photons, to mimic black paper around tile)
642 G4Material* imgMaterial = Materials::get("ARICH_Air"); // Air with defined optical properties to propagate cherenkov photons
643
644 // master volume
645 double imgTubeLen = aeroGeo.getImgTubeThickness(); // if changed, change position of aerogel plane also in main function!!
646 G4Tubs* aerogelTube = new G4Tubs("aerogelTube", rin, rout, (thick + wallHeight + imgTubeLen) / 2., 0, 2 * M_PI);
647 G4LogicalVolume* aerogelPlaneLV = new G4LogicalVolume(aerogelTube, gapMaterial, "ARICH.AaerogelPlane");
648
649 // support plate
650 G4Tubs* supportTube = new G4Tubs("aeroSupportTube", rin, rout, thick / 2., 0, 2 * M_PI);
651 G4LogicalVolume* supportTubeLV = new G4LogicalVolume(supportTube, supportMaterial, "ARICH.AerogelSupportPlate");
652 //supportTubeLV->SetSensitiveDetector(m_sensitiveAero);
653
654 // imaginary tube after aerogel layers (used as volume to which tracks are extrapolated by ext module)
655 G4Tubs* imgTube = new G4Tubs("imgTube", rin, rout, imgTubeLen / 2., 0, 2 * M_PI);
656 G4LogicalVolume* imgTubeLV = new G4LogicalVolume(imgTube, imgMaterial, "ARICH.AerogelImgPlate");
657 imgTubeLV->SetSensitiveDetector(m_sensitiveAero);
658
659 // read radiuses of aerogel slot aluminum walls
660 std::vector<double> wallR;
661 unsigned nRing = aeroGeo.getNRings();
662 for (unsigned iRing = 1; iRing < nRing + 1; iRing++) {
663 wallR.push_back(aeroGeo.getRingRadius(iRing));
664 }
665
666 unsigned nLayer = aeroGeo.getNLayers();
667 double tileGap = aeroGeo.getTileGap();
668 G4Transform3D transform = G4Translate3D(0., 0., (thick - imgTubeLen) / 2.);
669
670 for (unsigned iRing = 0; iRing < nRing; iRing++) {
671
672 // Aluminum walls between tile rings (r wall)
673 std::stringstream wallName;
674 wallName << "supportWallR_" << iRing + 1;
675 //cout<<"wallName = "<<wallName.str().c_str()<<endl;
676 G4Tubs* supportWall = new G4Tubs(wallName.str().c_str(), wallR[iRing], wallR[iRing] + wallThick, wallHeight / 2., 0, 2 * M_PI);
677 G4LogicalVolume* supportWallLV = new G4LogicalVolume(supportWall, supportMaterial, string("ARICH.") + wallName.str().c_str());
678 new G4PVPlacement(transform, supportWallLV, string("ARICH.") + wallName.str().c_str(), aerogelPlaneLV, false, 0);
680
681 // There are only 4 rings of aerogel - the first one is only for mechanical support
682 if (iRing == 0) continue;
683
684 // dphi - distance between centers of two consecutive aluminum walls (diaphragm) in one ring
685 double dphi = aeroGeo.getRingDPhi(iRing);
686
687 // Aluminum walls (diaphragm) between two neighboring tile in one ring (phi wall)
688 wallName.str("");
689 wallName << "supportWallPhi_" << iRing + 1;
690 G4Box* wall = new G4Box(wallName.str(), (wallR[iRing] - wallR[iRing - 1] - wallThick) / 2. - 1., thick / 2., wallHeight / 2.);
691 [[clang::suppress]]
692 G4LogicalVolume* wallLV = new G4LogicalVolume(wall, supportMaterial, string("ARICH.") + wallName.str());
693 double r = (wallR[iRing - 1] + wallThick + wallR[iRing]) / 2.;
695
696 // loop over layers
697 int icopyNumber = 0;
698 for (unsigned iLayer = 1; iLayer < nLayer + 1; iLayer++) {
699 //int iSlot = 1;
700 double iphi = 0;
701
702 int iicolumn = 0;
703 // loop over phi (over tile slots from same ring)
704 while (iphi < 2 * M_PI - 0.0001) {
705
706 // Define layer thickness as -1 in case it will not be defined
707 // below in the code with a appropriate value - Geant4 will trigger error
708 double layerThick = -1.0;
709 double tileUpThick = -1.0;
710 double tileDownThick = -1.0;
711 //cout<<" double layerThick = aeroGeo.getLayerThickness(iLayer) = "<<layerThick<<endl;
712
713 // Define material and thickness
714 G4Material* aeroMaterial = NULL;
715 int ati_ring = iRing;
716 int ati_column = iicolumn + 1;
717 int ati_layerN = iLayer - 1;
718
719 //cout<<setw(5)<<ati_layerN<<setw(5)<<ati_ring<<setw(5)<<ati_column<<endl;
720 if (detectorGeo.getAerogelPlane().getFullAerogelMaterialDescriptionKey() == 1) {
721 aeroMaterial = Materials::get(aeroGeo.getTileMaterialName(ati_ring, ati_column, ati_layerN).c_str());
722 } else {
723 B2ERROR("GeoARICHCreator::buildAerogelPlaneWithIndividualTilesProp --> getFullAerogelMaterialDescriptionKey() is wrong");
724 }
725 //cout<<"-----------------"<<endl
726 // <<"iLayer = "<<iLayer<<endl
727 // <<aeroMaterial->GetName()<<endl;
728 //cout<<setw(5)<<ati_layerN<<setw(5)<<ati_ring<<setw(5)<<ati_column<<endl;
729 //aeroMaterial->GetMaterialPropertiesTable()->DumpTable();
730 //zcout<<"ooooooooooooooooo"<<endl;
731 layerThick = aeroGeo.getTileThickness(ati_ring, ati_column, ati_layerN);
732 tileUpThick = aeroGeo.getTileThickness(ati_ring, ati_column, 0);
733 tileDownThick = aeroGeo.getTileThickness(ati_ring, ati_column, 1);
734
735 // Placement of the aluminum walls (diaphragm) between two neighboring tile in one ring (phi wall)
736 // please note that we place single wall for two aerogel layers
737 G4ThreeVector trans(r * cos(iphi), r * sin(iphi), (thick - imgTubeLen) / 2.);
738 G4RotationMatrix Ra;
739 Ra.rotateZ(iphi);
740 if (iLayer == 1) {
741 new G4PVPlacement(G4Transform3D(Ra, trans), //transformation
742 wallLV, //its logical
743 string("ARICH.") + wallName.str(), //name
744 aerogelPlaneLV, //mother logical
745 false, //always false
746 icopyNumber); //should be set to 0 for the first volume of a given type.
748
749 // In case of individual thickness
750 // (if aeroGeo.getFullAerogelMaterialDescriptionKey() == 1) or
751 // (if aeroGeo.getFullAerogelMaterialDescriptionKey() == 2)
752 // of the tiles we need to define compensation volume with ARICH air.
753 // This volume situated between aerogel tile and image plane (imgTube).
754 // This volume have same shape as earogel tile but different thickness.
755 // Build Compensation tiles only one time
756 // Compensation tile shape
757 double compTileUpThick = wallHeight - tileUpThick - tileDownThick;
758 std::stringstream compTileName;
759 //compTileName << "aerogelCompTile_" << ati_layerN << "_" << ati_ring << "_" << ati_column;
760 // In the end of the name we have Layer(L), Ring(R), Slot/Column(S) id's
761 // L : 1-2
762 // R : 1-4
763 // S : 1-22 @ R = 1
764 // S : 1-28 @ R = 2
765 // S : 1-34 @ R = 3
766 // S : 1-40 @ R = 4
767 compTileName << "aerogelCompTile_" << iLayer << "_" << ati_ring << "_" << ati_column;
768 //cout<<compTileName.str()<<endl;
769 G4Tubs* compTileShape = new G4Tubs(compTileName.str(), //name
770 wallR[iRing - 1] + wallThick + tileGap, //Rmin
771 wallR[iRing] - tileGap, //Rmax
772 compTileUpThick / 2.0, //Thickness
773 (tileGap + wallThick / 2.0) / wallR[iRing], //phi start
774 dphi - (2.0 * tileGap + wallThick) / wallR[iRing]); //delta phi
775
776 // Logical volume of the compensation tiles
777 G4LogicalVolume* compTileLV = new G4LogicalVolume(compTileShape, //Its solid
778 imgMaterial, //G4 material
779 string("ARICH.") + compTileName.str()); //name
780
781 // Placement of the compensation tiles
782 G4ThreeVector transCompTile(0, 0, (thick + wallHeight - compTileUpThick - imgTubeLen) / 2.0);
783 G4RotationMatrix compRa;
784 compRa.rotateZ(iphi);
785 new G4PVPlacement(G4Transform3D(compRa, transCompTile), //transformation
786 compTileLV, //its logical
787 string("ARICH.") + compTileName.str(), //name
788 aerogelPlaneLV, //mother logical
789 false, //always false
790 0); //should be set to 0 for the first volume of a given type.
791 }
792
793 // Tile shape
794 std::stringstream tileName;
795 tileName << "aerogelTile_" << iLayer << "_" << ati_ring << "_" << ati_column;
796 //cout<<tileName.str()<<endl;
797 G4Tubs* tileShape = new G4Tubs(tileName.str(), //name
798 wallR[iRing - 1] + wallThick + tileGap, //Rmin
799 wallR[iRing] - tileGap, //Rmax
800 layerThick / 2.0, //Thickness
801 (tileGap + wallThick / 2.0) / wallR[iRing], //phi start
802 dphi - (2.0 * tileGap + wallThick) / wallR[iRing]); //delta phi
803
804 // Logical volume of the aerogel tiles
805 G4LogicalVolume* tileLV = new G4LogicalVolume(tileShape, //Its solid
806 aeroMaterial, //G4 material
807 string("ARICH.") + tileName.str()); //name
808
809 // Placement of the aerogel tiles
810 double zLayer = 0.0;
811 if (iLayer == 2)
812 zLayer = tileUpThick;
813 G4ThreeVector transTile(0, 0, (thick + layerThick - wallHeight - imgTubeLen) / 2.0 + zLayer);
814 new G4PVPlacement(G4Transform3D(Ra, transTile), //transformation
815 tileLV, //its logical
816 string("ARICH.") + tileName.str(), //name
817 aerogelPlaneLV, //mother logical
818 false, //always false
819 0); //should be set to 0 for the first volume of a given type.
821
822 iphi += dphi;
823 //iSlot++;
824 icopyNumber++;
825 iicolumn++;
826 }
827 }
828 }
829
830 // Placement of the support tube
831 new G4PVPlacement(G4Translate3D(0., 0., -(wallHeight + imgTubeLen) / 2.), //transformation
832 supportTubeLV, //its logical
833 "ARICH.AerogelSupportPlate", //name
834 aerogelPlaneLV, //mother logical
835 false, //always false
836 0); //should be set to 0 for the first volume of a given type.
837
838 // Placement of the imaginary tube after aerogel layers (used as volume to which tracks are extrapolated by ext module)
839 new G4PVPlacement(G4Translate3D(0., 0., (wallHeight + thick) / 2.), //transformation
840 imgTubeLV, //its logical
841 "ARICH.AerogelImgPlate", //name
842 aerogelPlaneLV, //mother logical
843 false, //always false
844 0); //should be set to 0 for the first volume of a given type.
845
846 return aerogelPlaneLV;
847
848 }
849
850 G4LogicalVolume* GeoARICHCreator::buildHAPD(const ARICHGeoHAPD& hapdGeo)
851 {
852
853 // get module materials
854 string wallMat = hapdGeo.getWallMaterial();
855 string winMat = hapdGeo.getWinMaterial();
856 string apdMat = hapdGeo.getAPDMaterial();
857 string fillMat = hapdGeo.getFillMaterial();
858 string febMat = hapdGeo.getFEBMaterial();
859 G4Material* wallMaterial = Materials::get(wallMat);
860 G4Material* windowMaterial = Materials::get(winMat);
861 G4Material* apdMaterial = Materials::get(apdMat);
862 G4Material* fillMaterial = Materials::get(fillMat);
863 G4Material* febMaterial = Materials::get(febMat);
864 G4Material* moduleFill = Materials::get("ARICH_Air");
865
866 // check that module window material has specified refractive index
867 double wref = getAvgRINDEX(windowMaterial);
868 if (!wref) B2WARNING("Material '" << winMat <<
869 "', required for ARICH photon detector window as no specified refractive index. Continuing, but no photons in ARICH will be detected.");
870
871 // get module dimensions
872 const double hapdSizeX = hapdGeo.getSizeX();
873 const double hapdSizeY = hapdGeo.getSizeY();
874 const double hapdSizeZ = hapdGeo.getSizeZ();
875 const double wallThick = hapdGeo.getWallThickness();
876 const double winThick = hapdGeo.getWinThickness();
877 const double apdSizeX = hapdGeo.getAPDSizeX();
878 const double apdSizeY = hapdGeo.getAPDSizeY();
879 const double apdSizeZ = hapdGeo.getAPDSizeZ();
880 const double botThick = wallThick;
881 const double modHeight = hapdGeo.getModuleSizeZ();
882
883 // module master volume
884 G4Box* moduleBox = new G4Box("moduleBox", hapdSizeX / 2., hapdSizeY / 2., modHeight / 2.);
885 G4LogicalVolume* lmoduleBox = new G4LogicalVolume(moduleBox, moduleFill, "ARICH.HAPDModule");
886
887 // build HAPD box
888 G4Box* hapdBox = new G4Box("hapdBox", hapdSizeX / 2., hapdSizeY / 2., hapdSizeZ / 2.);
889 G4LogicalVolume* lhapdBox = new G4LogicalVolume(hapdBox, fillMaterial, "ARICH.HAPD");
890
891 // build HAPD walls
892 G4Box* tempBox2 = new G4Box("tempBox2", hapdSizeX / 2. - wallThick, hapdSizeY / 2. - wallThick,
893 hapdSizeZ / 2. + 0.1); // Don't care about "+0.1", needs to be there.
894 G4SubtractionSolid* moduleWall = new G4SubtractionSolid("Box-tempBox", hapdBox, tempBox2);
895 G4LogicalVolume* lmoduleWall = new G4LogicalVolume(moduleWall, wallMaterial, "ARICH.HAPDWall");
896 setColor(*lmoduleWall, "rgb(1.0,0.0,0.0,1.0)");
897 new G4PVPlacement(G4Transform3D(), lmoduleWall, "ARICH.HAPDWall", lhapdBox, false, 1);
898
899 // build HAPD window
900 G4Box* winBox = new G4Box("winBox", hapdSizeX / 2. - wallThick, hapdSizeY / 2. - wallThick, winThick / 2.);
901 G4LogicalVolume* lmoduleWin = new G4LogicalVolume(winBox, windowMaterial, "ARICH.HAPDWindow");
902 setColor(*lmoduleWin, "rgb(0.7,0.7,0.7,1.0)");
903 lmoduleWin->SetSensitiveDetector(m_sensitive);
904 G4Transform3D transform = G4Translate3D(0., 0., (-hapdSizeZ + winThick) / 2.);
905 new G4PVPlacement(transform, lmoduleWin, "ARICH.HAPDWindow", lhapdBox, false, 1);
906
907 // build module bottom
908 G4Box* botBox = new G4Box("botBox", hapdSizeX / 2. - wallThick, hapdSizeY / 2. - wallThick, botThick / 2.);
909 G4LogicalVolume* lmoduleBot = new G4LogicalVolume(botBox, wallMaterial, "ARICH.HAPDBottom");
910 setColor(*lmoduleBot, "rgb(0.0,1.0,0.0,1.0)");
911 G4Transform3D transform1 = G4Translate3D(0., 0., (hapdSizeZ - botThick) / 2.);
912 new G4PVPlacement(transform1, lmoduleBot, "ARICH.HAPDBottom", lhapdBox, false, 1);
913
914 // build apd
915 G4Box* apdBox = new G4Box("apdBox", apdSizeX / 2., apdSizeY / 2., apdSizeZ / 2.);
916 G4LogicalVolume* lApd = new G4LogicalVolume(apdBox, apdMaterial, "ARICH.HAPDApd");
917 if (m_isBeamBkgStudy) lApd->SetSensitiveDetector(new BkgSensitiveDetector("ARICH", 1));
918
919 // add APD surface optical properties
920 Materials& materials = Materials::getInstance();
921
922 G4OpticalSurface* optSurf = materials.createOpticalSurface(hapdGeo.getAPDSurface());
923
924 new G4LogicalSkinSurface("apdSurface", lApd, optSurf);
925 G4Transform3D transform2 = G4Translate3D(0., 0., (hapdSizeZ - apdSizeZ) / 2. - botThick);
926 new G4PVPlacement(transform2, lApd, "ARICH.HAPDApd", lhapdBox, false, 1);
927
928 // build FEB
929 double febSizeX = hapdGeo.getFEBSizeX();
930 double febSizeY = hapdGeo.getFEBSizeY();
931 double febSizeZ = hapdGeo.getFEBSizeZ();
932 G4Box* febBox = new G4Box("febBox", febSizeX / 2., febSizeY / 2., febSizeZ / 2.);
933 G4LogicalVolume* lfeb = new G4LogicalVolume(febBox, febMaterial, "ARICH.HAPDFeb");
934 if (m_isBeamBkgStudy) lfeb->SetSensitiveDetector(new BkgSensitiveDetector("ARICH"));
935 setColor(*lfeb, "rgb(0.0,0.6,0.0,1.0)");
936 G4Transform3D transform3 = G4Translate3D(0., 0., (modHeight - febSizeZ) / 2.);
937 new G4PVPlacement(transform3, lfeb, "ARICH.HAPDFeb", lmoduleBox, false, 1);
938 G4Transform3D transform4 = G4Translate3D(0., 0., - (modHeight - hapdSizeZ) / 2.);
939 new G4PVPlacement(transform4, lhapdBox, "ARICH.HAPD", lmoduleBox, false, 1);
940
941 return lmoduleBox;
942
943 }
944
945 G4LogicalVolume* GeoARICHCreator::buildDetectorPlane(const ARICHGeometryConfig& detectorGeo)
946 {
947
948 const ARICHGeoHAPD& hapdGeo = detectorGeo.getHAPDGeometry();
949 G4LogicalVolume* hapdLV = buildHAPD(hapdGeo);
950
951 const ARICHGeoDetectorPlane& detGeo = detectorGeo.getDetectorPlane();
952
953 G4Tubs* detTube = new G4Tubs("detTube", detGeo.getRingR(1) - hapdGeo.getSizeX() * 1.4 / 2.,
954 detGeo.getRingR(detGeo.getNRings()) + hapdGeo.getSizeX() * 1.4 / 2., hapdGeo.getModuleSizeZ() / 2., 0, 2 * M_PI);
955 G4LogicalVolume* detPlaneLV = new G4LogicalVolume(detTube, Materials::get("ARICH_Air"), "ARICH.detectorPlane");
956
957 unsigned nSlots = detGeo.getNSlots();
958
959 for (unsigned iSlot = 1; iSlot < nSlots + 1; iSlot++) {
960 if (!m_modInfo->isInstalled(iSlot)) continue;
961 double r = detGeo.getSlotR(iSlot);
962 double phi = detGeo.getSlotPhi(iSlot);
963 G4ThreeVector trans(r * cos(phi), r * sin(phi), 0);
964 G4RotationMatrix Ra;
965 Ra.rotateZ(phi);
966 G4ThreeVector trans1(r * cos(phi), r * sin(phi), 0.0);
967 new G4PVPlacement(G4Transform3D(Ra, trans1), hapdLV, "ARICH.HAPDModule", detPlaneLV, false, iSlot);
968 }
969
970 return detPlaneLV;
971
972 }
973
974 G4LogicalVolume* GeoARICHCreator::buildMerger(const ARICHGeoMerger& mergerGeo)
975 {
976
977 // This is a screw hole on the merger board.
978 // This high precision of the geometry description is needed
979 // only for the correct placement of the merger cooling bodies.
980 // Volume to subtract (screw hole on the merger board)
981 double screwholeR = mergerGeo.getMergerPCBscrewholeR() * mm;
982 double screwholedY = mergerGeo.getMergerPCBscrewholePosdY() * mm;
983 double screwholedX1 = mergerGeo.getMergerPCBscrewholePosdX1() * mm;
984 double screwholedX2 = mergerGeo.getMergerPCBscrewholePosdX2() * mm;
985
986 G4VSolid* screwHoleTubeSubtracted_solid = new G4Tubs("screwHoleTubeSubtracted_solid",
987 0.0,
988 screwholeR,
989 mergerGeo.getThickness() * mm / 2.0,
990 0, 360.0 * deg);
991
992 // Volume to add (merger box)
993 G4Box* merger_solid = new G4Box("merger_solid",
994 mergerGeo.getSizeW() * mm / 2.0,
995 mergerGeo.getSizeL() * mm / 2.0,
996 mergerGeo.getThickness() * mm / 2.0);
997
998 G4RotationMatrix Ra_sub;
999 G4ThreeVector Ta_sub;
1000 G4Transform3D Tr_sub;
1001 Ta_sub.setX(-mergerGeo.getSizeW() * mm / 2.0 + screwholedX1);
1002 Ta_sub.setY(mergerGeo.getSizeL() * mm / 2.0 - screwholedY);
1003 Ta_sub.setZ(0.0);
1004 Tr_sub = G4Transform3D(Ra_sub, Ta_sub);
1005 G4SubtractionSolid* substraction_solid = new G4SubtractionSolid("substraction_solid", merger_solid, screwHoleTubeSubtracted_solid,
1006 Tr_sub);
1007 Ta_sub.setX(mergerGeo.getSizeW() * mm / 2.0 - screwholedX2);
1008 Ta_sub.setY(mergerGeo.getSizeL() * mm / 2.0 - screwholedY);
1009 Ta_sub.setZ(0.0);
1010 Tr_sub = G4Transform3D(Ra_sub, Ta_sub);
1011 substraction_solid = new G4SubtractionSolid("substraction_solid", substraction_solid, screwHoleTubeSubtracted_solid, Tr_sub);
1012 Ta_sub.setX(mergerGeo.getSizeW() * mm / 2.0 - screwholedX2);
1013 Ta_sub.setY(-mergerGeo.getSizeL() * mm / 2.0 + screwholedY);
1014 Ta_sub.setZ(0.0);
1015 Tr_sub = G4Transform3D(Ra_sub, Ta_sub);
1016 substraction_solid = new G4SubtractionSolid("substraction_solid", substraction_solid, screwHoleTubeSubtracted_solid, Tr_sub);
1017 Ta_sub.setX(-mergerGeo.getSizeW() * mm / 2.0 + screwholedX1);
1018 Ta_sub.setY(-mergerGeo.getSizeL() * mm / 2.0 + screwholedY);
1019 Ta_sub.setZ(0.0);
1020 Tr_sub = G4Transform3D(Ra_sub, Ta_sub);
1021 substraction_solid = new G4SubtractionSolid("substraction_solid", substraction_solid, screwHoleTubeSubtracted_solid, Tr_sub);
1022
1023 return new G4LogicalVolume(substraction_solid, Materials::get(mergerGeo.getMergerPCBMaterialName()), "ARICH.mergerPCB");
1024 }
1025
1026
1027 G4LogicalVolume* GeoARICHCreator::buildMergerCooling(unsigned iType)
1028 {
1029
1030 if (!m_mergerCooling) {
1031 B2WARNING("ARICH geometry: no data available for merger " << iType << " cooling body geometry. Cooling body will not be placed.");
1032 return NULL;
1033 }
1034
1035 std::stringstream shpName;
1036 shpName << "TessellatedSolid_" << + iType;
1037
1038 G4TessellatedSolid* volume_solid = new G4TessellatedSolid(shpName.str().c_str());
1039
1040 G4ThreeVector point_1;
1041 G4ThreeVector point_2;
1042 G4ThreeVector point_3;
1043
1044 tessellatedSolidStr mergerCoolingStr = m_mergerCooling->getMergerCoolingBodiesInfo(iType);
1045
1046 if (mergerCoolingStr.nCells == 0) {
1047 B2WARNING("ARICH geometry: no data available for merger " << iType << " cooling body geometry. Cooling body will not be placed.");
1048 return NULL;
1049 }
1050
1051 for (unsigned int i = 0; i < mergerCoolingStr.nCells; i++) {
1052 //
1053 point_1.setX(mergerCoolingStr.posV1[0][i]);
1054 point_1.setY(mergerCoolingStr.posV1[1][i]);
1055 point_1.setZ(mergerCoolingStr.posV1[2][i]);
1056 //
1057 point_2.setX(mergerCoolingStr.posV2[0][i]);
1058 point_2.setY(mergerCoolingStr.posV2[1][i]);
1059 point_2.setZ(mergerCoolingStr.posV2[2][i]);
1060 //
1061 point_3.setX(mergerCoolingStr.posV3[0][i]);
1062 point_3.setY(mergerCoolingStr.posV3[1][i]);
1063 point_3.setZ(mergerCoolingStr.posV3[2][i]);
1064 //
1065 G4TriangularFacet* facet = new G4TriangularFacet(point_1, point_2, point_3, ABSOLUTE);
1066 volume_solid->AddFacet((G4VFacet*) facet);
1067 delete facet;
1068 }
1069
1070 volume_solid->SetSolidClosed(true);
1071 std::stringstream volName;
1072 volName << "ARICH.mergerCooling_" << + iType;
1073 G4LogicalVolume* volume_logical = new G4LogicalVolume(volume_solid,
1074 Materials::get(m_mergerCooling->getMergerCoolingBodiesMaterialName()), volName.str().c_str());
1075
1076 setColor(*volume_logical, "rgb(0.6,0.0,0.2,1.0)"); //From the top (farther from IP, downstream)
1077
1078 return volume_logical;
1079 }
1080
1081 G4LogicalVolume* GeoARICHCreator::buildMergerEnvelope(const ARICHGeoMerger& mergerGeo, int iType)
1082 {
1083 // Volume to add single merger and merger cooling body envelope box
1084 G4Box* singlemergerenvelope_solid = new G4Box("singlemergerenvelope_solid",
1085 mergerGeo.getSingleMergerEnvelopeSizeW() * mm / 2.0,
1086 mergerGeo.getSingleMergerEnvelopeSizeL() * mm / 2.0,
1087 mergerGeo.getSingleMergerEnvelopeThickness() * mm / 2.0);
1088 std::stringstream volName;
1089 volName << "ARICH.singleMergerEnvelope_" << + iType;
1090 return new G4LogicalVolume(singlemergerenvelope_solid, Materials::get("ARICH_Air"), volName.str().c_str());
1091 }
1092
1093 G4LogicalVolume* GeoARICHCreator::buildMergerPCBEnvelopePlane(const ARICHGeometryConfig& detectorGeo)
1094 {
1095
1096 const ARICHGeoMerger& mergerGeo = detectorGeo.getMergerGeometry();
1097
1098 if (mergerGeo.getSingleMergerEnvelopeSizeW() < 1e-9) {
1099 B2WARNING("GeoARICHCreator: Merger and merger cooling geometry will not be build as it is not available in geometry configuration (ARICHGeometryConfig with ClasDef>4 is needed).");
1100 return NULL;
1101 }
1102
1103 G4Tubs* envelope_solid = new G4Tubs("envelope_solid", mergerGeo.getEnvelopeInnerRadius() * mm,
1104 mergerGeo.getEnvelopeOuterRadius() * mm, mergerGeo.getEnvelopeThickness() * mm / 2.0, 0.0, 2.0 * M_PI);
1105
1106 G4LogicalVolume* envelope_logical = new G4LogicalVolume(envelope_solid, Materials::get("ARICH_Air"), "ARICH.mergerEnvelope");
1107
1108
1109 G4LogicalVolume* merger_logical = buildMerger(mergerGeo);
1110 G4LogicalVolume* mergerCooling_logical[12] = {NULL};
1111 G4LogicalVolume* mergerEnvelope_logical[12] = {NULL};
1112 G4ThreeVector TaPCB(mergerGeo.getSingleMergeEnvelopePosition().X() * mm, mergerGeo.getSingleMergeEnvelopePosition().Y() * mm,
1113 mergerGeo.getSingleMergeEnvelopePosition().Z() * mm);
1114 G4RotationMatrix RaPCB;
1115 G4ThreeVector TaMergerCooling(mergerGeo.getSingleMergeEnvelopePosition().X() * mm,
1116 mergerGeo.getSingleMergeEnvelopePosition().Y() * mm, -mergerGeo.getSingleMergeEnvelopePosition().Z() * mm);
1117 G4RotationMatrix RaMergerCooling;
1118 RaMergerCooling.rotateY(180 * deg);
1119 RaMergerCooling.rotateZ(-90 * deg);
1120
1121 // build 12 different merger+cooling body volumes
1122 for (int iType = 1; iType < 13; iType++) {
1123 mergerCooling_logical[iType - 1] = buildMergerCooling(iType);
1124 mergerEnvelope_logical[iType - 1 ] = buildMergerEnvelope(mergerGeo, iType); //Single merger and merger cooling body envelope box
1125 setColor(*mergerEnvelope_logical[iType - 1], "rgb(0.0,0.0,1.0,1.0)");
1126
1127 new G4PVPlacement(G4Transform3D(RaPCB, TaPCB), //Transformation
1128 merger_logical, //its logical volume
1129 "ARICH.mergerPCB", //its name
1130 mergerEnvelope_logical[iType - 1], //its mother volume
1131 false, //no boolean operation
1132 iType); //copy number
1133
1134 if (mergerCooling_logical[iType - 1] == NULL) continue;
1135
1136 new G4PVPlacement(G4Transform3D(RaMergerCooling, TaMergerCooling), //Transformation
1137 mergerCooling_logical[iType - 1], //its logical volume
1138 "ARICH.mergerCooling", //its name
1139 mergerEnvelope_logical[iType - 1], //its mother volume
1140 false, //no boolean operation
1141 iType); //copy number
1142 }
1143
1144 // place all 72 merger+cooling body packages
1145 for (unsigned iSlot = 0; iSlot < mergerGeo.getMergerSlotID().size(); iSlot++) {
1146
1147 int type = 1; // if no merger cooling is available...
1148 if (m_mergerCooling) type = (int)m_mergerCooling->getMergerCoolingPositionID().at(iSlot);
1149
1150 //Placement of the single volume envelope
1151 G4ThreeVector Ta(mergerGeo.getMergerPosR().at(iSlot) * mm * cos(mergerGeo.getMergerAngle().at(iSlot) * deg),
1152 mergerGeo.getMergerPosR().at(iSlot) * mm * sin(mergerGeo.getMergerAngle().at(iSlot) * deg),
1153 mergerGeo.getSingleMergerenvelopeDeltaZ().at(iSlot) * mm);
1154 G4RotationMatrix Ra;
1155 Ra.rotateZ(mergerGeo.getMergerAngle().at(iSlot) * deg + mergerGeo.getMergerOrientation().at(iSlot) * deg);
1156 new G4PVPlacement(G4Transform3D(Ra, Ta), //Transformation
1157 mergerEnvelope_logical[type - 1], //its logical volume
1158 "ARICH.singleMergerEnvelope", //its name
1159 envelope_logical, //its mother volume
1160 false, //no boolean operation
1161 iSlot); //copy number
1162 }
1163
1164 return envelope_logical;
1165
1166 }
1167
1168 G4LogicalVolume* GeoARICHCreator::buildCables(const ARICHGeoCablesEnvelope& cablesGeo)
1169 {
1170
1171 G4Tubs* cablesEnvelope_solid = new G4Tubs("cablesEnvelope_solid",
1172 cablesGeo.getEnvelopeInnerRadius(),
1173 cablesGeo.getEnvelopeOuterRadius(),
1174 cablesGeo.getEnvelopeThickness() / 2.0,
1175 0.0,
1176 2.0 * M_PI);
1177 G4LogicalVolume* cablesEnvelope_logical = new G4LogicalVolume(cablesEnvelope_solid,
1178 Materials::get(cablesGeo.getCablesEffectiveMaterialName()),
1179 "ARICH.cablesEnvelope");
1180
1181 return cablesEnvelope_logical;
1182
1183 }
1184
1185 G4LogicalVolume* GeoARICHCreator::buildFEBCoolingBody(const ARICHGeoFEBCooling& coolingv2Geo)
1186 {
1187
1188 //FEB aluminum cooling envelope for single object
1189 double feb_alcooling_singleObjectEnvelope_sizeX = (2 * coolingv2Geo.getSmallSquareSize() + coolingv2Geo.getBigSquareSize() + 2.0) *
1190 mm;
1191 double feb_alcooling_singleObjectEnvelope_sizeY = feb_alcooling_singleObjectEnvelope_sizeX * mm;
1192 double feb_alcooling_singleObjectEnvelope_sizeZ = (coolingv2Geo.getSmallSquareThickness() + coolingv2Geo.getRectangleThickness()) *
1193 mm;
1194
1195 double feb_alcooling_box1_sizeX = coolingv2Geo.getSmallSquareSize() * mm;
1196 double feb_alcooling_box1_sizeY = feb_alcooling_box1_sizeX;
1197 double feb_alcooling_box1_sizeZ = coolingv2Geo.getSmallSquareThickness() * mm;
1198
1199 double feb_alcooling_box2_sizeX = coolingv2Geo.getBigSquareSize() * mm;
1200 double feb_alcooling_box2_sizeY = feb_alcooling_box2_sizeX;
1201 double feb_alcooling_box2_sizeZ = coolingv2Geo.getBigSquareThickness() * mm;
1202
1203 double feb_alcooling_box3_sizeX = coolingv2Geo.getRectangleW() * mm;
1204 double feb_alcooling_box3_sizeY = coolingv2Geo.getRectangleL() * mm;
1205 double feb_alcooling_box3_sizeZ = coolingv2Geo.getRectangleThickness() * mm;
1206
1207 double feb_alcooling_box1_X0 = feb_alcooling_box2_sizeX / 2.0 + feb_alcooling_box1_sizeX / 2.0;
1208 double feb_alcooling_box1_Y0 = feb_alcooling_box2_sizeY / 2.0 + feb_alcooling_box1_sizeY / 2.0;
1209 double feb_alcooling_box1_Z0 = 0.0 * mm;
1210
1211 //double feb_alcooling_box2_X0 = 0.0*mm;
1212 //double feb_alcooling_box2_Y0 = 0.0*mm;
1213 //double feb_alcooling_box2_Z0 = 0.0*mm;
1214
1215 double feb_alcooling_box3_X0 = coolingv2Geo.getRectangleDistanceFromCenter() / sqrt(2.0) * mm;
1216 double feb_alcooling_box3_Y0 = feb_alcooling_box3_X0;
1217 double feb_alcooling_box3_Z0 = feb_alcooling_box1_sizeZ / 2.0 + feb_alcooling_box3_sizeZ / 2.0;
1218 double feb_alcooling_box3_angle = 45.0 * deg;
1219
1220 G4RotationMatrix Ra;
1221 G4ThreeVector Ta;
1222 G4Transform3D Tr;
1223
1224 //
1225 // Define single FEB aluminum cooling envelope
1226 //
1227 G4VSolid* feb_alcoolingEnvelope_solid = new G4Box("feb_alcoolingEnvelope_solid",
1228 feb_alcooling_singleObjectEnvelope_sizeX / 2.0,
1229 feb_alcooling_singleObjectEnvelope_sizeY / 2.0,
1230 feb_alcooling_singleObjectEnvelope_sizeZ / 2.0);
1231 G4LogicalVolume* feb_alcoolingEnvelope_logical = new G4LogicalVolume(feb_alcoolingEnvelope_solid, Materials::get("Air"),
1232 "feb_alcoolingEnvelope_logical");
1233
1234 G4VSolid* feb_alcooling_box1_solid = new G4Box("feb_alcooling_box1_solid", feb_alcooling_box1_sizeX / 2.0,
1235 feb_alcooling_box1_sizeY / 2.0, feb_alcooling_box1_sizeZ / 2.0);
1236 G4VSolid* feb_alcooling_box2_solid = new G4Box("feb_alcooling_box2_solid", feb_alcooling_box2_sizeX / 2.0,
1237 feb_alcooling_box2_sizeY / 2.0, feb_alcooling_box2_sizeZ / 2.0);
1238 G4VSolid* feb_alcooling_box3_solid = new G4Box("feb_alcooling_box3_solid", feb_alcooling_box3_sizeX / 2.0,
1239 feb_alcooling_box3_sizeY / 2.0, feb_alcooling_box3_sizeZ / 2.0);
1240
1241 //
1242 //Box 1 A
1243 //
1244 Ta.setX(feb_alcooling_box1_X0);
1245 Ta.setY(feb_alcooling_box1_Y0);
1246 Ta.setZ(feb_alcooling_box1_Z0);
1247 Tr = G4Transform3D(Ra, Ta);
1248 G4UnionSolid* feb_alcooling_assembly01_solid = new G4UnionSolid("feb_alcooling_assembly01_solid", feb_alcooling_box2_solid,
1249 feb_alcooling_box1_solid, Tr);
1250 //
1251 //Box 1 B
1252 //
1253 Ta.setX(-feb_alcooling_box1_X0);
1254 Ta.setY(-feb_alcooling_box1_Y0);
1255 Ta.setZ(feb_alcooling_box1_Z0);
1256 Tr = G4Transform3D(Ra, Ta);
1257 G4UnionSolid* feb_alcooling_assembly02_solid = new G4UnionSolid("feb_alcooling_assembly02_solid", feb_alcooling_assembly01_solid,
1258 feb_alcooling_box1_solid, Tr);
1259 //
1260 //Box 3 A
1261 //
1262 Ta.setX(feb_alcooling_box3_X0);
1263 Ta.setY(feb_alcooling_box3_Y0);
1264 Ta.setZ(feb_alcooling_box3_Z0);
1265 Ra.rotateZ(-feb_alcooling_box3_angle);
1266 Tr = G4Transform3D(Ra, Ta);
1267 G4UnionSolid* feb_alcooling_assembly03_solid = new G4UnionSolid("feb_alcooling_assembly03_solid", feb_alcooling_assembly02_solid,
1268 feb_alcooling_box3_solid, Tr);
1269 Ra.rotateZ(feb_alcooling_box3_angle);
1270 //
1271 //Box 3 B
1272 //
1273 Ta.setX(-feb_alcooling_box3_X0);
1274 Ta.setY(-feb_alcooling_box3_Y0);
1275 Ta.setZ(feb_alcooling_box3_Z0);
1276 Ra.rotateZ(-feb_alcooling_box3_angle);
1277 Tr = G4Transform3D(Ra, Ta);
1278 G4UnionSolid* feb_alcooling_assembly_solid = new G4UnionSolid("feb_alcooling_assembly_solid", feb_alcooling_assembly03_solid,
1279 feb_alcooling_box3_solid, Tr);
1280 Ra.rotateZ(feb_alcooling_box3_angle);
1281
1282 G4LogicalVolume* feb_alcooling_assembly_logical = new G4LogicalVolume(feb_alcooling_assembly_solid, Materials::get("Al"),
1283 "feb_alcooling_assembly_logical");
1284 Ta.setX(0.0);
1285 Ta.setY(0.0);
1286 Ta.setZ(-feb_alcooling_box3_sizeZ / 2.0);
1287
1288 Tr = G4Transform3D(Ra, Ta);
1289 new G4PVPlacement(Tr, //Transformation
1290 feb_alcooling_assembly_logical, //its logical volume
1291 "feb_alcooling_assembly", //its name
1292 feb_alcoolingEnvelope_logical, //its mother volume
1293 false, //no boolean operation
1294 0); //copy number
1295
1296 return feb_alcoolingEnvelope_logical;
1297 }
1298
1299 G4LogicalVolume* GeoARICHCreator::buildCoolingTube(const unsigned i_volumeID, const ARICHGeoCooling& coolingGeo)
1300 {
1301
1302 B2ASSERT("ARICH cooling geometry ID (G4Tube) is wrong : coolingGeo.getCoolingGeometryID.at(i_volumeID) != 1",
1303 coolingGeo.getCoolingGeometryID().at(i_volumeID) == 1);
1304 G4Tubs* coolingTube_solid = new G4Tubs("coolingTube_solid",
1305 coolingGeo.getRmin() * mm,
1306 coolingGeo.getRmax() * mm,
1307 coolingGeo.getCoolingL().at(i_volumeID) * mm / 2.0,
1308 0.0,
1309 2.0 * M_PI);
1310 return new G4LogicalVolume(coolingTube_solid, Materials::get(coolingGeo.getCoolingPipeMaterialName()), "ARICH.coolingTube");
1311
1312 }
1313
1314 G4LogicalVolume* GeoARICHCreator::buildCoolingTorus(const unsigned i_volumeID, const ARICHGeoCooling& coolingGeo)
1315 {
1316
1317 B2ASSERT("ARICH cooling geometry ID (G4Torus) is wrong : coolingGeo.getCoolingGeometryID.at(i_volumeID) != 2",
1318 coolingGeo.getCoolingGeometryID().at(i_volumeID) == 2);
1319
1320 double pSPhi = coolingGeo.getCoolingPosPhi().at(i_volumeID) * deg - coolingGeo.getCoolingL().at(
1321 i_volumeID) / coolingGeo.getCoolingPosR().at(i_volumeID) / 2.0;
1322 //double pDPhi = coolingGeo.getCoolingPosPhi().at(i_volumeID)*deg + coolingGeo.getCoolingL().at(i_volumeID) / coolingGeo.getCoolingPosR().at(i_volumeID) / 2.0;
1323 double pDPhi = coolingGeo.getCoolingL().at(i_volumeID) / coolingGeo.getCoolingPosR().at(i_volumeID);
1324
1325 G4Torus* coolingTorus_solid = new G4Torus("coolingTorus_solid", // name
1326 coolingGeo.getRmin(), // pRmin
1327 coolingGeo.getRmax(), // pRmax
1328 coolingGeo.getCoolingPosR().at(i_volumeID), // pRtor
1329 pSPhi, // pSPhi
1330 pDPhi); // pDPhi
1331
1332 return new G4LogicalVolume(coolingTorus_solid, Materials::get(coolingGeo.getCoolingPipeMaterialName()), "ARICH.coolingTorus");
1333
1334 }
1335
1336 G4LogicalVolume* GeoARICHCreator::buildCoolingEnvelopePlane(const ARICHGeoCooling& coolingGeo)
1337 {
1338
1339 G4Tubs* coolingEnvelope_solid = new G4Tubs("coolingEnvelope_solid",
1340 coolingGeo.getEnvelopeInnerRadius(),
1341 coolingGeo.getEnvelopeOuterRadius(),
1342 coolingGeo.getEnvelopeThickness() / 2.0,
1343 0.0,
1344 2.0 * M_PI);
1345 G4LogicalVolume* coolingEnvelope_logical = new G4LogicalVolume(coolingEnvelope_solid,
1346 Materials::get("Air"),
1347 "ARICH.coolingEnvelope");
1348
1349 unsigned nComponents = coolingGeo.getCoolingGeometryID().size();
1350
1351 for (unsigned i = 0; i < nComponents; i++) {
1352 double r = coolingGeo.getCoolingPosR().at(i) * mm;
1353 double phi = coolingGeo.getCoolingPosPhi().at(i) * deg;
1354 G4ThreeVector Ta;
1355 G4RotationMatrix Ra;
1356 G4LogicalVolume* coolingComponentLV;
1357 if (coolingGeo.getCoolingGeometryID().at(i) == 1) {
1358 //<!-- 1 -> G4Tubs --> build a tube
1359 Ta.set(r * cos(phi), r * sin(phi), 0);
1360 //First need to rotate around y axis
1361 //to make the tube parallel with x axis
1362 Ra.rotateY(90.0 * deg);
1363 Ra.rotateZ(coolingGeo.getCoolinRotationAngle().at(i) * deg);
1364 coolingComponentLV = buildCoolingTube(i, coolingGeo);
1365 } else if (coolingGeo.getCoolingGeometryID().at(i) == 2) {
1366 //<!-- 2 -> G4Torus --> build a torus
1367 coolingComponentLV = buildCoolingTorus(i, coolingGeo);
1368 } else {
1369 B2FATAL("ARICH cooling geometry component ID is wrong");
1370 }
1371 new G4PVPlacement(G4Transform3D(Ra, Ta), //Transformation
1372 coolingComponentLV, //its logical volume
1373 "ARICH.cooling", //its name
1374 coolingEnvelope_logical, //its mother volume
1375 false, //no boolean operation
1376 i); //copy number
1377 }
1378
1379 return coolingEnvelope_logical;
1380
1381 }
1382
1383 G4LogicalVolume* GeoARICHCreator::buildCoolingTestPlate(const ARICHGeoCooling& coolingGeo)
1384 {
1385
1386 G4Box* coolingTestPlateEnvelop_solid = new G4Box("coolingTestPlateEnvelop_solid",
1387 coolingGeo.getCoolingTestPlateslengths().X() / 2.0 * mm,
1388 coolingGeo.getCoolingTestPlateslengths().Y() / 2.0 * mm,
1389 coolingGeo.getCoolingTestPlateslengths().Z() / 2.0 * mm);
1390 G4LogicalVolume* coolingTestPlateEnvelop_logical = new G4LogicalVolume(coolingTestPlateEnvelop_solid, Materials::get("Air"),
1391 "ARICH.coolingTestPlateEnvelop");
1392
1393 G4Box* coolingTestPlate_solid = new G4Box("coolingTestPlate_solid",
1394 coolingGeo.getCoolingTestPlateslengths().X() / 2.0 * mm,
1395 coolingGeo.getCoolingTestPlateslengths().Y() / 2.0 * mm,
1396 coolingGeo.getCoolingTestPlateslengths().Z() / 2.0 * mm);
1397
1398 // Volume to subtract
1399 G4VSolid* coldTubeSubtracted_solid = new G4Tubs("coldTubeSubtracted_solid",
1400 0.0,
1401 coolingGeo.getColdTubeSubtractedR() * mm,
1402 (coolingGeo.getCoolingTestPlateslengths().X() + 1) / 2.0 * mm,
1403 0, 360.0 * deg);
1404
1405 // Volume to add (cold tube)
1406 G4VSolid* coldTube_solid = new G4Tubs("coldTube_solid",
1407 (coolingGeo.getColdTubeR() - coolingGeo.getColdTubeWallThickness()) * mm,
1408 coolingGeo.getColdTubeR() * mm,
1409 coolingGeo.getCoolingTestPlateslengths().X() / 2.0 * mm,
1410 0, 360.0 * deg);
1411 [[clang::suppress]]
1412 G4LogicalVolume* coldTube_logical = new G4LogicalVolume(coldTube_solid, Materials::get(coolingGeo.getColdTubeMaterialName()),
1413 "ARICH.coldTube");
1414
1415 G4RotationMatrix Ra_sub;
1416 G4ThreeVector Ta_sub;
1417 G4Transform3D Tr_sub;
1418 Ta_sub.setX(0.0);
1419 Ta_sub.setY((coolingGeo.getCoolingTestPlateslengths().Y() / 2.0 - coolingGeo.getColdTubeSpacing()) * mm);
1420 Ta_sub.setZ((coolingGeo.getCoolingTestPlateslengths().Z() / 2.0 - coolingGeo.getDepthColdTubeInPlate()) * mm);
1421 Ra_sub.rotateY(90.0 * deg);
1422 Tr_sub = G4Transform3D(Ra_sub, Ta_sub);
1423 G4SubtractionSolid* substraction_solid = new G4SubtractionSolid("substraction_solid", coolingTestPlate_solid,
1424 coldTubeSubtracted_solid, Tr_sub);
1425 for (int i = 1; i < coolingGeo.getColdTubeNumber(); i++) {
1426 Ta_sub.setX(0.0);
1427 Ta_sub.setY((coolingGeo.getCoolingTestPlateslengths().Y() / 2.0 - coolingGeo.getColdTubeSpacing() - coolingGeo.getColdTubeSpacing()
1428 * 2 * i) * mm);
1429 Ta_sub.setZ((coolingGeo.getCoolingTestPlateslengths().Z() / 2.0 - coolingGeo.getDepthColdTubeInPlate()) * mm);
1430 Tr_sub = G4Transform3D(Ra_sub, Ta_sub);
1431 substraction_solid = new G4SubtractionSolid("substraction_solid", substraction_solid, coldTubeSubtracted_solid, Tr_sub);
1432 }
1433
1434 G4LogicalVolume* coolingTestPlate_logical = new G4LogicalVolume(substraction_solid,
1435 Materials::get(coolingGeo.getCoolingTestPlateMaterialName()), "ARICH.coolingTestPlate");
1436
1437 new G4PVPlacement(G4Transform3D(), //Transformation
1438 coolingTestPlate_logical, //its logical volume
1439 "ARICH.coolingTestPlate", //its name
1440 coolingTestPlateEnvelop_logical, //its mother volume
1441 false, //no boolean operation
1442 0); //copy number
1443 //Add cold tubes
1444 G4RotationMatrix Ra;
1445 G4ThreeVector Ta;
1446 G4Transform3D Tr;
1447 Ra.rotateY(90.0 * deg);
1448 for (int i = 0; i < coolingGeo.getColdTubeNumber(); i++) {
1449 Ta.setX(0.0);
1450 Ta.setY((coolingGeo.getCoolingTestPlateslengths().Y() / 2.0 - coolingGeo.getColdTubeSpacing() - coolingGeo.getColdTubeSpacing() *
1451 2 * i) * mm);
1452 Ta.setZ((coolingGeo.getCoolingTestPlateslengths().Z() / 2.0 - coolingGeo.getDepthColdTubeInPlate()) * mm);
1453 Tr = G4Transform3D(Ra, Ta);
1454 new G4PVPlacement(Tr, //Transformation
1455 coldTube_logical, //its logical volume
1456 "ARICH.coldTube", //its name
1457 coolingTestPlateEnvelop_logical, //its mother volume
1458 false, //no boolean operation
1459 0); //copy number
1460 }
1461
1462 return coolingTestPlateEnvelop_logical;
1463
1464 }
1465
1466 G4LogicalVolume* GeoARICHCreator::buildDetectorSupportPlate(const ARICHGeometryConfig& detectorGeo)
1467 {
1468
1469 const ARICHGeoDetectorPlane& detGeo = detectorGeo.getDetectorPlane();
1470
1471 G4Tubs* supportTube = new G4Tubs("supportTube", detGeo.getSupportInnerR(), detGeo.getSupportOuterR(),
1472 (detGeo.getSupportThickness() + detGeo.getSupportBackWallHeight()) / 2., 0, 2 * M_PI);
1473 G4Material* supportMaterial = Materials::get(detGeo.getSupportMaterial());
1474 G4LogicalVolume* detSupportLV = new G4LogicalVolume(supportTube, supportMaterial, "ARICH.detectorSupportPlate");
1475
1476 G4Tubs* supportPlate = new G4Tubs("supportPlate", detGeo.getSupportInnerR(), detGeo.getSupportOuterR(),
1477 detGeo.getSupportThickness() / 2., 0, 2 * M_PI);
1478
1479 G4Box* hole = new G4Box("hole", detGeo.getModuleHoleSize() / 2., detGeo.getModuleHoleSize() / 2.,
1480 detGeo.getSupportThickness() / 2.); // +1 for thickness for subtraction solid
1481 [[clang::suppress]]
1482 G4LogicalVolume* holeLV = new G4LogicalVolume(hole, Materials::get("Air"), "ARICH.detectorSupportHole");
1483
1484 int nRings = detGeo.getNRings();
1485 std::vector<G4LogicalVolume*> hapdBackRadialWallLV;
1486 double backWallThick = detGeo.getSupportBackWallThickness();
1487 double backWallHeight = detGeo.getSupportBackWallHeight();
1488
1489 [[clang::suppress]]
1490 G4LogicalVolume* hapdSupportPlateLV = new G4LogicalVolume(supportPlate, supportMaterial, "hapdSupport");
1491
1492 std::vector<double> wallR;
1493 wallR.assign(nRings + 1, 0);
1494 std::vector<double> thickR;
1495 thickR.assign(nRings + 1, 0);
1496
1497 for (int i = 1; i < nRings; i++) {
1498 double rm1 = detGeo.getRingR(i);
1499 double rp1 = detGeo.getRingR(i + 1);
1500 wallR[i] = (rp1 + rm1) / 2.;
1501 if (i == 1) {
1502 wallR[0] = rm1 - (rp1 - rm1) / 2.;
1503 }
1504 if (i == nRings - 1) {
1505 wallR[i + 1] = rp1 + (rp1 - rm1) / 2.;
1506 }
1507 }
1508
1509 for (int i = 0; i < nRings + 1; i++) {
1510 std::stringstream ringName1;
1511 ringName1 << "backWall_" << i;
1512 thickR[i] = backWallThick;
1513 if (i == nRings) {
1514 thickR[i] = 2.*backWallThick;
1515 wallR[i] = detGeo.getSupportOuterR() - thickR[i] / 2.;
1516 }
1517 G4Tubs* backTube = new G4Tubs("hapdBackRing", wallR[i] - thickR[i] / 2., wallR[i] + thickR[i] / 2., backWallHeight / 2., 0,
1518 2 * M_PI);
1519 G4LogicalVolume* hapdBackTubeLV = new G4LogicalVolume(backTube, supportMaterial, "backTube");
1520 G4Transform3D transform3 = G4Translate3D(0., 0., detGeo.getSupportThickness() / 2.);
1521 new G4PVPlacement(transform3, hapdBackTubeLV, "backTube", detSupportLV, false, 1);
1522 if (i == 0) continue;
1523
1524 G4Box* backRadial = new G4Box("backRadialBox", (wallR[i] - wallR[i - 1] - thickR[i] / 2. - thickR[i - 1] / 2.) / 2. - 1.,
1525 backWallThick / 2., backWallHeight / 2.);
1526 hapdBackRadialWallLV.push_back(new G4LogicalVolume(backRadial, supportMaterial, ringName1.str().c_str()));
1527 }
1528
1529 G4SubtractionSolid* substraction = NULL;
1530 unsigned nSlots = detGeo.getNSlots();
1531
1532 if (nSlots > detectorGeo.getFEBCoolingGeometry().getFebcoolingv2GeometryID().size()) {
1533 B2WARNING("GeoARICHCreator: No FEB colling body geometry available so they will not be placed (ARICHGeometryConfig with ClasDef>4 is needed).");
1534 return detSupportLV;
1535 }
1536
1537 // drill holes in support plate
1538 // add FEB cooling bodies
1539 for (unsigned iSlot = 1; iSlot < nSlots + 1; iSlot++) {
1540 unsigned iRing = detGeo.getSlotRing(iSlot);
1541 double r = (wallR[iRing] + wallR[iRing - 1]) / 2. - (thickR[iRing] - thickR[iRing - 1]) / 2.;
1542
1543 double phi = detGeo.getSlotPhi(iSlot);
1544 G4ThreeVector trans(r * cos(phi), r * sin(phi), 0);
1545 G4RotationMatrix Ra;
1546 Ra.rotateZ(phi);
1547
1548 new G4PVPlacement(G4Transform3D(Ra, trans), holeLV, "hole", hapdSupportPlateLV, false, iSlot);
1549 if (substraction) substraction = new G4SubtractionSolid("Box+CylinderMoved", substraction, hole, G4Transform3D(Ra, trans));
1550 else substraction = new G4SubtractionSolid("Box+CylinderMoved", supportPlate, hole, G4Transform3D(Ra, trans));
1551
1552 phi = phi + detGeo.getRingDPhi(iRing) / 2.;
1553 G4ThreeVector transBack(r * cos(phi), r * sin(phi), detGeo.getSupportThickness() / 2.);
1554 G4RotationMatrix RaBack;
1555 RaBack.rotateZ(phi);
1556 new G4PVPlacement(G4Transform3D(RaBack, transBack), hapdBackRadialWallLV[iRing - 1], "hapdBack", detSupportLV, false, iSlot);
1557
1558 // add FEB cooling bodies
1559 G4ThreeVector febCoolingTa;
1560 G4Transform3D febCoolingTr;
1561 febCoolingTa.setX(r * cos(detGeo.getSlotPhi(iSlot)));
1562 febCoolingTa.setY(r * sin(detGeo.getSlotPhi(iSlot)));
1563
1564 double supportTube_envelope_dZ = (detGeo.getSupportThickness() + detGeo.getSupportBackWallHeight());
1565 double febCooling_envelope_dZ = (detectorGeo.getFEBCoolingGeometry().getBigSquareThickness() +
1566 detectorGeo.getFEBCoolingGeometry().getRectangleThickness());
1567 double febCooling_envelope_Z0 = -supportTube_envelope_dZ / 2.0 + febCooling_envelope_dZ / 2.0 + detGeo.getSupportThickness();
1568 febCoolingTa.setZ(febCooling_envelope_Z0);
1569
1570 int febcoolingv2GeometryID = detectorGeo.getFEBCoolingGeometry().getFebcoolingv2GeometryID().at(iSlot - 1);
1571
1572 if (febcoolingv2GeometryID == 2) Ra.rotateZ(90.0 * deg);
1573
1574 febCoolingTr = G4Transform3D(Ra, febCoolingTa);
1575
1576 if (febcoolingv2GeometryID != 0) {
1577 G4LogicalVolume* febCoolingLV = buildFEBCoolingBody(detectorGeo.getFEBCoolingGeometry());
1578
1579 new G4PVPlacement(febCoolingTr, //Transformation
1580 febCoolingLV, //its logical volume
1581 "febCoolingLV", //its name
1582 detSupportLV, //its mother volume
1583 false, //no boolean operation
1584 iSlot); //copy number
1585 }
1586 }
1587
1588 // G4LogicalVolume* hapdSupportPlateLV = new G4LogicalVolume(substraction, supportMaterial, "hapdSupport");
1589
1590 G4Transform3D transform3 = G4Translate3D(0., 0., - backWallHeight / 2.);
1591 new G4PVPlacement(transform3, hapdSupportPlateLV, "supportPlate", detSupportLV, false, 1);
1592
1593 // place electronics side neutron shield - for now hardcoded here, pending for more proper implementation!
1594 G4Box* shieldBox1 = new G4Box("shieldBox1", 20. / 2., 75. / 2., backWallHeight / 2.);
1595 G4Box* shieldBox2 = new G4Box("shieldBox2", 55. / 2., 40. / 2., backWallHeight / 2.);
1596 G4LogicalVolume* shield1 = new G4LogicalVolume(shieldBox1, Materials::get("BoratedPoly"), "ARICH.FWDShield1");
1597 G4LogicalVolume* shield2 = new G4LogicalVolume(shieldBox2, Materials::get("BoratedPoly"), "ARICH.FWDShield2");
1598 double dphi = 2 * M_PI / 36.;
1599 double r1 = wallR[0] - 15.;
1600 double r2 = wallR[0] - 15. - 20. / 2. - 55. / 2.;
1601 for (int i = 0; i < 36; i++) {
1602 double phi = (i + 0.5) * dphi;
1603 G4RotationMatrix rot;
1604 rot.rotateZ(phi);
1605 G4ThreeVector trans(r1 * cos(phi), r1 * sin(phi), detGeo.getSupportThickness() / 2.);
1606 G4ThreeVector trans1(r2 * cos(phi), r2 * sin(phi), detGeo.getSupportThickness() / 2.);
1607 new G4PVPlacement(G4Transform3D(rot, trans), shield1, "ARICH.FWDShield1", detSupportLV, false, i);
1608 new G4PVPlacement(G4Transform3D(rot, trans1), shield2, "ARICH.FWDShield2", detSupportLV, false, i);
1609 }
1610
1611 return detSupportLV;
1612 }
1613
1614
1615 G4LogicalVolume* GeoARICHCreator::buildMirror(const ARICHGeometryConfig& detectorGeo)
1616 {
1617
1618 const ARICHGeoMirrors& mirrGeo = detectorGeo.getMirrors();
1619
1620 // read m_config
1621 string mirrMat = mirrGeo.getMaterial();
1622 G4Material* mirrorMaterial = Materials::get(mirrMat);
1623
1624 double mThick = mirrGeo.getPlateThickness();
1625 double mLength = mirrGeo.getPlateLength();
1626 double mWidth = mirrGeo.getPlateWidth();
1627
1628 G4Box* mirrPlate = new G4Box("mirrPlate", mThick / 2., mLength / 2., mWidth / 2.);
1629
1630 G4LogicalVolume* lmirror = new G4LogicalVolume(mirrPlate, mirrorMaterial, "ARICH.mirrorPlate");
1631
1632 Materials& materials = Materials::getInstance();
1633
1634 G4OpticalSurface* optSurf = materials.createOpticalSurface(mirrGeo.getMirrorSurface());
1635 new G4LogicalSkinSurface("mirrorSurface", lmirror, optSurf);
1636
1637 return lmirror;
1638
1639 }
1640
1641 double GeoARICHCreator::getAvgRINDEX(G4Material* material)
1642 {
1643 G4MaterialPropertiesTable* mTable = material->GetMaterialPropertiesTable();
1644 if (!mTable) return 0;
1645 G4MaterialPropertyVector* mVector = mTable->GetProperty("RINDEX");
1646 if (!mVector) return 0;
1647 G4bool b;
1648 return mVector->GetValue(2 * Unit::eV / Unit::MeV, b);
1649 }
1650
1651 void GeoARICHCreator::makeJoint(G4Material* supportMaterial, const std::vector<double>& par, G4AssemblyVolume* assemblyWedge)
1652 {
1653
1654 int size = par.size();
1655 if (size < 4 || size > 8) B2ERROR("GeoARICHCreator::makeJoint: invalid number of joint wedge parameters");
1656 double lenx = par.at(0);
1657 double leny = par.at(1);
1658 double lenz = par.at(2);
1659 double thick = par.at(3);
1660
1661 G4Box* wedgeBox1 = new G4Box("wedgeBox1", thick / 2., lenx / 2., leny / 2.);
1662 G4Box* wedgeBox2 = new G4Box("wedgeBox2", lenz / 2., lenx / 2., thick / 2.);
1663
1664 G4LogicalVolume* wedgeBox1LV = new G4LogicalVolume(wedgeBox1, supportMaterial, "ARICH.supportWedge");
1665 G4LogicalVolume* wedgeBox2LV = new G4LogicalVolume(wedgeBox2, supportMaterial, "ARICH.supportWedge");
1666
1667 G4RotationMatrix Rm;
1668 G4ThreeVector Ta(0, 0, 0);
1669 G4Transform3D Tr;
1670 Tr = G4Transform3D(Rm, Ta);
1671
1672 assemblyWedge->AddPlacedVolume(wedgeBox1LV, Tr);
1673
1674 Ta.setX(lenz / 2. + thick / 2.);
1675 Ta.setZ(leny / 2. - thick / 2.);
1676 Tr = G4Transform3D(Rm, Ta);
1677 assemblyWedge->AddPlacedVolume(wedgeBox2LV, Tr);
1678
1679 if (size == 4) return;
1680 double edge = par.at(4);
1681
1682 G4Box* wedgeBox3 = new G4Box("wedgeBox3", lenz / 2., edge / 2., thick / 2.);
1683 G4LogicalVolume* wedgeBox3LV = new G4LogicalVolume(wedgeBox3, supportMaterial, "ARICH.supportWedge");
1684
1685 Ta.setZ(leny / 2. - thick - thick / 2.);
1686 Tr = G4Transform3D(Rm, Ta);
1687 assemblyWedge->AddPlacedVolume(wedgeBox3LV, Tr);
1688
1689 G4Trap* wedgeBoxTmp = new G4Trap("wedgeBoxTmp", thick, leny - 2 * thick, lenz, edge);
1690 G4LogicalVolume* wedgeBox4LV;
1691 if (size == 8) {
1692 G4Tubs* wedgeBoxTmp1 = new G4Tubs("wedgeBoxTmp1", 0.0, par.at(5), thick, 0, 2.*M_PI);
1693 G4RotationMatrix rotHole;
1694 G4ThreeVector transHole(par.at(6), par.at(7), 0);
1695 G4SubtractionSolid* wedgeBox4 = new G4SubtractionSolid("wedgeBox4", wedgeBoxTmp, wedgeBoxTmp1, G4Transform3D(rotHole, transHole));
1696 wedgeBox4LV = new G4LogicalVolume(wedgeBox4, supportMaterial, "ARICH.supportWedge");
1697 } else wedgeBox4LV = new G4LogicalVolume(wedgeBoxTmp, supportMaterial, "ARICH.supportWedge");
1698
1699 Rm.rotateX(-M_PI / 2.);
1700 Ta.setX(thick / 2. + edge / 4. + lenz / 4.);
1701 Ta.setZ(-thick / 2. - edge / 2.);
1702 Tr = G4Transform3D(Rm, Ta);
1703 assemblyWedge->AddPlacedVolume(wedgeBox4LV, Tr);
1704
1705 }
1706
1707 // simple geometry for beamtest setup
1708 /* void GeoARICHCreator::createSimple(const GearDir& content, G4LogicalVolume& topVolume)
1709 {
1710
1711 B2INFO("ARICH simple (beamtest) geometry will be built.")
1712 GearDir envelopeParams(content, "Envelope");
1713 double xSize = envelopeParams.getLength("xSize") / Unit::mm;
1714 double ySize = envelopeParams.getLength("ySize") / Unit::mm;
1715 double zSize = envelopeParams.getLength("zSize") / Unit::mm;
1716 string envMat = envelopeParams.getString("material");
1717 G4Material* envMaterial = Materials::get(envMat);
1718
1719 G4Box* envBox = new G4Box("envBox", xSize / 2., ySize / 2., zSize / 2.);
1720 G4LogicalVolume* lenvBox = new G4LogicalVolume(envBox, envMaterial, "ARICH.envelope");
1721 new G4PVPlacement(G4Transform3D(), lenvBox, "ARICH.envelope", &topVolume, false, 1);
1722 setVisibility(*lenvBox, false);
1723 ARICHGeometryPar* m_arichgp = ARICHGeometryPar::Instance();
1724 m_arichgp->Initialize(content);
1725 GearDir moduleParam(content, "Detector/Module");
1726 G4LogicalVolume* detModule = buildModule(moduleParam);
1727
1728 double detZpos = content.getLength("Detector/Plane/zPosition") / Unit::mm;
1729 double detThick = content.getLength("Detector/Module/moduleZSize") / Unit::mm;
1730 int nModules = m_arichgp->getNMCopies();
1731 for (int i = 1; i <= nModules; i++) {
1732 G4ThreeVector origin = m_arichgp->getOriginG4(i); origin.setZ(detZpos + detThick / 2.);
1733 double angle = m_arichgp->getModAngle(i);
1734 G4RotationMatrix Ra;
1735 Ra.rotateZ(angle);
1736 G4Transform3D trans = G4Transform3D(Ra, origin);
1737 new G4PVPlacement(G4Transform3D(Ra, origin), detModule, "detModule", lenvBox, false, i);
1738 }
1739
1740 // place aerogel tiles
1741 GearDir aerogelParam(content, "Aerogel");
1742 double sizeX = aerogelParam.getLength("tileXSize") / Unit::mm;
1743 double sizeY = aerogelParam.getLength("tileYSize") / Unit::mm;
1744 double posX = aerogelParam.getLength("tileXPos") / Unit::mm;
1745 double posY = aerogelParam.getLength("tileYPos") / Unit::mm;
1746 int ilayer = 0;
1747 for (const GearDir& layer : aerogelParam.getNodes("Layers/Layer")) {
1748 double posZ = layer.getLength("zPosition");
1749 double sizeZ = layer.getLength("thickness");
1750 string tileMat = layer.getString("material");
1751 G4Material* tileMaterial = Materials::get(tileMat);
1752 double rInd = getAvgRINDEX(tileMaterial);
1753 m_arichgp->setAeroRefIndex(ilayer, rInd);
1754 m_arichgp->setAerogelZPosition(ilayer, posZ);
1755 m_arichgp->setAerogelThickness(ilayer, sizeZ);
1756
1757 G4MaterialPropertiesTable* mTable = tileMaterial->GetMaterialPropertiesTable();
1758 G4MaterialPropertyVector* mVector = mTable->GetProperty("RAYLEIGH");
1759 double lambda0 = 400;
1760 double e0 = 1240. / lambda0 * Unit::eV / Unit::MeV;
1761 G4bool b;
1762 m_arichgp->setAeroTransLength(ilayer, mVector->GetValue(e0, b)*Unit::mm);
1763 G4Box* tileBox = new G4Box("tileBox", sizeX / 2., sizeY / 2., sizeZ / 2. / Unit::mm);
1764 G4LogicalVolume* lTile = new G4LogicalVolume(tileBox, tileMaterial, "Tile", 0, m_sensitiveAero);
1765 setColor(*lTile, "rgb(0.0, 1.0, 1.0,1.0)");
1766 G4Transform3D trans = G4Translate3D(posX, posY, posZ / Unit::mm + sizeZ / 2. / Unit::mm);
1767 ilayer++;
1768 new G4PVPlacement(trans, lTile, "ARICH.tile", lenvBox, false, ilayer);
1769 }
1770
1771 // place mirrors
1772 GearDir mirrorsParam(content, "Mirrors");
1773 double height = mirrorsParam.getLength("height") / Unit::mm;
1774 double width = mirrorsParam.getLength("width") / Unit::mm;
1775 double thickness = mirrorsParam.getLength("thickness") / Unit::mm;
1776 string mirrMat = mirrorsParam.getString("material");
1777 G4Material* mirrMaterial = Materials::get(mirrMat);
1778 G4Box* mirrBox = new G4Box("mirrBox", thickness / 2., height / 2., width / 2.);
1779 G4LogicalVolume* lmirror = new G4LogicalVolume(mirrBox, mirrMaterial, "mirror");
1780
1781 Materials& materials = Materials::getInstance();
1782 GearDir surface(mirrorsParam, "Surface");
1783 G4OpticalSurface* optSurf = materials.createOpticalSurface(surface);
1784 new G4LogicalSkinSurface("mirrorsSurface", lmirror, optSurf);
1785 int iMirror = 0;
1786 for (const GearDir& mirror : mirrorsParam.getNodes("Mirror")) {
1787 double xpos = mirror.getLength("xPos") / Unit::mm;
1788 double ypos = mirror.getLength("yPos") / Unit::mm;
1789 double zpos = mirror.getLength("zPos") / Unit::mm;
1790 double angle = mirror.getAngle("angle") / Unit::rad;
1791 G4ThreeVector origin(xpos, ypos, zpos + width / 2.);
1792 G4RotationMatrix Ra;
1793 Ra.rotateZ(angle);
1794 G4Transform3D trans = G4Transform3D(Ra, origin);
1795 new G4PVPlacement(G4Transform3D(Ra, origin), lmirror, "ARICH.mirror", lenvBox, false, iMirror);
1796 iMirror++;
1797 }
1798 }
1799 */
1800
1801 } // namespace aricih
1803} // namespace belleII
Belle2::ARICHGeoAerogelPlane
Geometry parameters of HAPD.
Definition ARICHGeoAerogelPlane.h:29
Belle2::ARICHGeoAerogelPlane::getSimpleParams
const std::vector< double > & getSimpleParams() const
Get parameters of simple aerogel configuration.
Definition ARICHGeoAerogelPlane.h:397
Belle2::ARICHGeoAerogelPlane::getLayerThickness
double getLayerThickness(unsigned iLayer) const
Get thickness of tiles in i-th aerogel layer.
Definition ARICHGeoAerogelPlane.h:339
Belle2::ARICHGeoAerogelPlane::getSupportThickness
double getSupportThickness() const
Get support-plate thickness.
Definition ARICHGeoAerogelPlane.h:228
Belle2::ARICHGeoAerogelPlane::getNRings
unsigned getNRings() const
Get number of aluminum wall rings (should be number of tile rings + 1).
Definition ARICHGeoAerogelPlane.h:316
Belle2::ARICHGeoAerogelPlane::getSupportOuterR
double getSupportOuterR() const
Get support-plate outer radius.
Definition ARICHGeoAerogelPlane.h:222
Belle2::ARICHGeoAerogelPlane::getCompensationARICHairVolumeThick_min
double getCompensationARICHairVolumeThick_min() const
Get minimum thickness of the compensation volume with ARICH air.
Definition ARICHGeoAerogelPlane.h:559
Belle2::ARICHGeoAerogelPlane::getImgTubeThickness
double getImgTubeThickness() const
Get imaginary tube thickness just after aerogel layers used as volume to which tracks are extrapolate...
Definition ARICHGeoAerogelPlane.h:539
Belle2::ARICHGeoAerogelPlane::getWallHeight
double getWallHeight() const
Get height of aluminum walls between aerogel tiles.
Definition ARICHGeoAerogelPlane.h:240
Belle2::ARICHGeoAerogelPlane::getRingDPhi
double getRingDPhi(unsigned iRing) const
Get phi (angle) distance between "phi" aluminum wall between aerogel tiles in i-th tile ring.
Definition ARICHGeoAerogelPlane.h:332
Belle2::ARICHGeoAerogelPlane::getTileThickness
double getTileThickness(int ring, int column, int layerN) const
Get thickness of individual tile.
Definition ARICHGeoAerogelPlane.cc:174
Belle2::ARICHGeoAerogelPlane::getLayerMaterial
const std::string & getLayerMaterial(unsigned iLayer) const
Get material name of tiles in i-th aerogel layer.
Definition ARICHGeoAerogelPlane.h:360
Belle2::ARICHGeoAerogelPlane::getSupportMaterial
const std::string & getSupportMaterial() const
Get material of support plate.
Definition ARICHGeoAerogelPlane.h:252
Belle2::ARICHGeoAerogelPlane::getWallThickness
double getWallThickness() const
Get thickness of aluminum walls between aerogel tiles.
Definition ARICHGeoAerogelPlane.h:234
Belle2::ARICHGeoAerogelPlane::getRingRadius
double getRingRadius(unsigned iRing) const
Get radius of i-th aluminum ring between aerogel tiles (inner radius of ring).
Definition ARICHGeoAerogelPlane.h:324
Belle2::ARICHGeoAerogelPlane::getNLayers
unsigned getNLayers() const
Get number of aerogel layers.
Definition ARICHGeoAerogelPlane.h:310
Belle2::ARICHGeoAerogelPlane::getSupportInnerR
double getSupportInnerR() const
Get support-plate inner radius.
Definition ARICHGeoAerogelPlane.h:216
Belle2::ARICHGeoAerogelPlane::getFullAerogelMaterialDescriptionKey
int getFullAerogelMaterialDescriptionKey() const
Get full aerogel material description key.
Definition ARICHGeoAerogelPlane.h:441
Belle2::ARICHGeoAerogelPlane::getTileMaterialName
std::string getTileMaterialName(int ring, int column, int layerN) const
Get material name of individual tile.
Definition ARICHGeoAerogelPlane.cc:189
Belle2::ARICHGeoAerogelPlane::getMaximumTotalTileThickness
double getMaximumTotalTileThickness() const
Get maximum total thickness of the aerogel tiles tile_up + tile_down for all the slots.
Definition ARICHGeoAerogelPlane.cc:221
Belle2::ARICHGeoAerogelPlane::getTileGap
double getTileGap() const
Get gap between aerogel tile and aluminum wall.
Definition ARICHGeoAerogelPlane.h:246
Belle2::ARICHGeoCablesEnvelope
Geometry parameters of cable envelope.
Definition ARICHGeoCablesEnvelope.h:26
Belle2::ARICHGeoCablesEnvelope::getCablesEffectiveMaterialName
const std::string & getCablesEffectiveMaterialName() const
Returns Effective material name describing cables.
Definition ARICHGeoCablesEnvelope.h:72
Belle2::ARICHGeoCablesEnvelope::getEnvelopeOuterRadius
double getEnvelopeOuterRadius() const
Returns Outer radius of cables envelop.
Definition ARICHGeoCablesEnvelope.h:78
Belle2::ARICHGeoCablesEnvelope::getEnvelopeInnerRadius
double getEnvelopeInnerRadius() const
Returns Inner radius of cables envelop.
Definition ARICHGeoCablesEnvelope.h:84
Belle2::ARICHGeoCablesEnvelope::getEnvelopeThickness
double getEnvelopeThickness() const
Returns Thickness of cables envelop.
Definition ARICHGeoCablesEnvelope.h:90
Belle2::ARICHGeoCooling
Geometry parameters of cooling system.
Definition ARICHGeoCooling.h:26
Belle2::ARICHGeoCooling::getColdTubeWallThickness
double getColdTubeWallThickness() const
Get cold tube wall thickness.
Definition ARICHGeoCooling.h:342
Belle2::ARICHGeoCooling::getCoolinRotationAngle
const std::vector< double > & getCoolinRotationAngle() const
Get vector of azimuthal angle of rotation around Z - axis of the cooling system object in polar coord...
Definition ARICHGeoCooling.h:303
Belle2::ARICHGeoCooling::getCoolingPosPhi
const std::vector< double > & getCoolingPosPhi() const
Get vector of azimuthal angle of the cooling system object center in polar coordinate system in deg.
Definition ARICHGeoCooling.h:287
Belle2::ARICHGeoCooling::getEnvelopeOuterRadius
double getEnvelopeOuterRadius() const
Get outer radius of cooling system assembly envelope.
Definition ARICHGeoCooling.h:245
Belle2::ARICHGeoCooling::getCoolingGeometryID
const std::vector< double > & getCoolingGeometryID() const
Get vector of cooling system object geometry ID.
Definition ARICHGeoCooling.h:272
Belle2::ARICHGeoCooling::getColdTubeSpacing
double getColdTubeSpacing() const
Get distance from center of the cold tube to edge of cooling plate.
Definition ARICHGeoCooling.h:354
Belle2::ARICHGeoCooling::getCoolingPipeMaterialName
const std::string & getCoolingPipeMaterialName() const
Get material name of cooling pipe.
Definition ARICHGeoCooling.h:227
Belle2::ARICHGeoCooling::getColdTubeR
double getColdTubeR() const
Get radius of cold tubes.
Definition ARICHGeoCooling.h:330
Belle2::ARICHGeoCooling::getCoolingL
const std::vector< double > & getCoolingL() const
Get vector of lengs of the cooling system object with given geometry ID.
Definition ARICHGeoCooling.h:279
Belle2::ARICHGeoCooling::getCoolingPosR
const std::vector< double > & getCoolingPosR() const
Get vector of radial distance (r, pho) of the cooling system object center in polar coordinate system...
Definition ARICHGeoCooling.h:295
Belle2::ARICHGeoCooling::getColdTubeMaterialName
const std::string & getColdTubeMaterialName() const
Get material name of cold tube.
Definition ARICHGeoCooling.h:315
Belle2::ARICHGeoCooling::getCoolingTestPlateMaterialName
const std::string & getCoolingTestPlateMaterialName() const
Get material name of cooling test plates.
Definition ARICHGeoCooling.h:309
Belle2::ARICHGeoCooling::getRmax
double getRmax() const
Get size of cooling system pipe : outer radius in mm.
Definition ARICHGeoCooling.h:239
Belle2::ARICHGeoCooling::getEnvelopeInnerRadius
double getEnvelopeInnerRadius() const
Get inner radius of cooling system assembly envelope.
Definition ARICHGeoCooling.h:251
Belle2::ARICHGeoCooling::getCoolingTestPlateslengths
ROOT::Math::XYZVector getCoolingTestPlateslengths() const
Get sizes vector (ROOT::Math::XYZVector) of cooling test plates.
Definition ARICHGeoCooling.h:321
Belle2::ARICHGeoCooling::getRmin
double getRmin() const
Get size of cooling system pipe : inner radius in mm.
Definition ARICHGeoCooling.h:233
Belle2::ARICHGeoCooling::getDepthColdTubeInPlate
double getDepthColdTubeInPlate() const
Get depth of the cold tube in the cooling plate.
Definition ARICHGeoCooling.h:348
Belle2::ARICHGeoCooling::getEnvelopeThickness
double getEnvelopeThickness() const
Get thickness of cooling system assembly envelope.
Definition ARICHGeoCooling.h:257
Belle2::ARICHGeoCooling::getColdTubeSubtractedR
double getColdTubeSubtractedR() const
Get outer radius of subtracted tubes for cold tube.
Definition ARICHGeoCooling.h:336
Belle2::ARICHGeoCooling::getColdTubeNumber
int getColdTubeNumber() const
Get number of cold tubes in one plate.
Definition ARICHGeoCooling.h:360
Belle2::ARICHGeoDetectorPlane
Geometry parameters of ARICH photon detector plane.
Definition ARICHGeoDetectorPlane.h:30
Belle2::ARICHGeoDetectorPlane::getNSlots
unsigned getNSlots() const
Get total number of module slots.
Definition ARICHGeoDetectorPlane.h:235
Belle2::ARICHGeoDetectorPlane::getSlotRing
unsigned getSlotRing(unsigned slotID) const
Get ring number of slot with slot ID.
Definition ARICHGeoDetectorPlane.cc:33
Belle2::ARICHGeoDetectorPlane::getSupportBackWallHeight
double getSupportBackWallHeight() const
Get height of the aluminum walls between modules on the electronics side of aluminum support plate.
Definition ARICHGeoDetectorPlane.h:188
Belle2::ARICHGeoDetectorPlane::getSlotR
double getSlotR(unsigned modID) const
Get radial position of module with given module ID number.
Definition ARICHGeoDetectorPlane.h:222
Belle2::ARICHGeoDetectorPlane::getSupportBackWallThickness
double getSupportBackWallThickness() const
Get thickness of aluminum walls between modules on the electronics side of aluminum support plate.
Definition ARICHGeoDetectorPlane.h:195
Belle2::ARICHGeoDetectorPlane::getSupportThickness
double getSupportThickness() const
Get support plate thickness.
Definition ARICHGeoDetectorPlane.h:169
Belle2::ARICHGeoDetectorPlane::getNRings
unsigned getNRings() const
Get number of module slot rings.
Definition ARICHGeoDetectorPlane.h:241
Belle2::ARICHGeoDetectorPlane::getSupportOuterR
double getSupportOuterR() const
Get support plate outer radius.
Definition ARICHGeoDetectorPlane.h:163
Belle2::ARICHGeoDetectorPlane::getRingDPhi
double getRingDPhi(unsigned iRing) const
Get phi (angle) distance between module slots in i-th ring.
Definition ARICHGeoDetectorPlane.h:215
Belle2::ARICHGeoDetectorPlane::getSlotPhi
double getSlotPhi(unsigned modID) const
Get phi (angle) position of module with given module ID number.
Definition ARICHGeoDetectorPlane.h:229
Belle2::ARICHGeoDetectorPlane::getModuleHoleSize
double getModuleHoleSize() const
Get size of module hole in support plate.
Definition ARICHGeoDetectorPlane.h:181
Belle2::ARICHGeoDetectorPlane::getSupportMaterial
const std::string & getSupportMaterial() const
Get material of support plate.
Definition ARICHGeoDetectorPlane.h:201
Belle2::ARICHGeoDetectorPlane::getSupportInnerR
double getSupportInnerR() const
Get support plate inner radius.
Definition ARICHGeoDetectorPlane.h:157
Belle2::ARICHGeoDetectorPlane::getRingR
double getRingR(unsigned iRing) const
Get radius of i-th module slot ring (radius of center point).
Definition ARICHGeoDetectorPlane.h:208
Belle2::ARICHGeoFEBCooling
Geometry parameters of Cooling System - version2 (v2).
Definition ARICHGeoFEBCooling.h:28
Belle2::ARICHGeoFEBCooling::getBigSquareThickness
double getBigSquareThickness() const
Returns thickness of the big square in mm.
Definition ARICHGeoFEBCooling.h:117
Belle2::ARICHGeoFEBCooling::getBigSquareSize
double getBigSquareSize() const
Returns size of the big square in mm.
Definition ARICHGeoFEBCooling.h:111
Belle2::ARICHGeoFEBCooling::getSmallSquareSize
double getSmallSquareSize() const
Returns size of the small square in mm.
Definition ARICHGeoFEBCooling.h:99
Belle2::ARICHGeoFEBCooling::getRectangleThickness
double getRectangleThickness() const
Returns thickness of the rectangle in mm.
Definition ARICHGeoFEBCooling.h:135
Belle2::ARICHGeoFEBCooling::getSmallSquareThickness
double getSmallSquareThickness() const
Returns thickness of the small square in mm.
Definition ARICHGeoFEBCooling.h:105
Belle2::ARICHGeoFEBCooling::getFebcoolingv2GeometryID
const std::vector< double > & getFebcoolingv2GeometryID() const
Returns vector of feb cooling configuration/geometry ID.
Definition ARICHGeoFEBCooling.h:147
Belle2::ARICHGeoFEBCooling::getRectangleW
double getRectangleW() const
Returns width of the rectangle in mm.
Definition ARICHGeoFEBCooling.h:129
Belle2::ARICHGeoFEBCooling::getRectangleL
double getRectangleL() const
Returns length of the rectangle in mm.
Definition ARICHGeoFEBCooling.h:123
Belle2::ARICHGeoFEBCooling::getRectangleDistanceFromCenter
double getRectangleDistanceFromCenter() const
Returns distance from center of the rectangle in mm.
Definition ARICHGeoFEBCooling.h:141
Belle2::ARICHGeoHAPD
Geometry parameters of HAPD.
Definition ARICHGeoHAPD.h:24
Belle2::ARICHGeoHAPD::getSizeZ
double getSizeZ() const
Returns HAPD size in z.
Definition ARICHGeoHAPD.h:174
Belle2::ARICHGeoHAPD::getFEBMaterial
const std::string & getFEBMaterial() const
Returns FEB material name.
Definition ARICHGeoHAPD.h:289
Belle2::ARICHGeoHAPD::getAPDSizeZ
double getAPDSizeZ() const
Returns APD size in z.
Definition ARICHGeoHAPD.h:204
Belle2::ARICHGeoHAPD::getWinThickness
double getWinThickness() const
Returns window thickness.
Definition ARICHGeoHAPD.h:186
Belle2::ARICHGeoHAPD::getAPDMaterial
const std::string & getAPDMaterial() const
Returns APD material name.
Definition ARICHGeoHAPD.h:283
Belle2::ARICHGeoHAPD::getAPDSurface
const GeoOpticalSurface & getAPDSurface() const
Returns APD reflective optical surface.
Definition ARICHGeoHAPD.h:295
Belle2::ARICHGeoHAPD::getWallMaterial
const std::string & getWallMaterial() const
Returns wall (casing) material name.
Definition ARICHGeoHAPD.h:265
Belle2::ARICHGeoHAPD::getFillMaterial
const std::string & getFillMaterial() const
Returns fill (inside) material name.
Definition ARICHGeoHAPD.h:271
Belle2::ARICHGeoHAPD::getSizeX
double getSizeX() const
Returns HAPD size in x.
Definition ARICHGeoHAPD.h:162
Belle2::ARICHGeoHAPD::getSizeY
double getSizeY() const
Returns HAPD size in y.
Definition ARICHGeoHAPD.h:168
Belle2::ARICHGeoHAPD::getFEBSizeY
double getFEBSizeY() const
Returns FEB size in y.
Definition ARICHGeoHAPD.h:216
Belle2::ARICHGeoHAPD::getWallThickness
double getWallThickness() const
Returns wall thickness.
Definition ARICHGeoHAPD.h:180
Belle2::ARICHGeoHAPD::getFEBSizeZ
double getFEBSizeZ() const
Returns FEB size in z.
Definition ARICHGeoHAPD.h:222
Belle2::ARICHGeoHAPD::getWinMaterial
const std::string & getWinMaterial() const
Returns window material name.
Definition ARICHGeoHAPD.h:277
Belle2::ARICHGeoHAPD::getModuleSizeZ
double getModuleSizeZ() const
Returns module size in z (HAPD + FEB height)
Definition ARICHGeoHAPD.h:228
Belle2::ARICHGeoHAPD::getAPDSizeY
double getAPDSizeY() const
Returns APD size in y.
Definition ARICHGeoHAPD.h:198
Belle2::ARICHGeoHAPD::getFEBSizeX
double getFEBSizeX() const
Returns FEB size in x.
Definition ARICHGeoHAPD.h:210
Belle2::ARICHGeoHAPD::getAPDSizeX
double getAPDSizeX() const
Returns APD size in x.
Definition ARICHGeoHAPD.h:192
Belle2::ARICHGeoMerger
Geometry parameters of Merger PCB.
Definition ARICHGeoMerger.h:26
Belle2::ARICHGeoMerger::getSingleMergerenvelopeDeltaZ
const std::vector< double > & getSingleMergerenvelopeDeltaZ() const
Returns vector of Z position of the single merger and merger cooling body envelope inside global merg...
Definition ARICHGeoMerger.h:212
Belle2::ARICHGeoMerger::getMergerPCBscrewholeR
double getMergerPCBscrewholeR() const
Returns merger PCB screw hole radius.
Definition ARICHGeoMerger.h:218
Belle2::ARICHGeoMerger::getSingleMergerEnvelopeThickness
double getSingleMergerEnvelopeThickness() const
Returns single merger PCB and merger cooling envelop thickness.
Definition ARICHGeoMerger.h:206
Belle2::ARICHGeoMerger::getSizeW
double getSizeW() const
Returns merger PCB width.
Definition ARICHGeoMerger.h:182
Belle2::ARICHGeoMerger::getMergerPCBscrewholePosdX1
double getMergerPCBscrewholePosdX1() const
Returns merger PCB screw hole position from the bottom edge.
Definition ARICHGeoMerger.h:230
Belle2::ARICHGeoMerger::getEnvelopeOuterRadius
double getEnvelopeOuterRadius() const
Returns Outer radius of merger PCB assembly envelope.
Definition ARICHGeoMerger.h:242
Belle2::ARICHGeoMerger::getMergerSlotID
const std::vector< double > & getMergerSlotID() const
Returns vector of merger boards slot numbers.
Definition ARICHGeoMerger.h:272
Belle2::ARICHGeoMerger::getMergerPCBscrewholePosdX2
double getMergerPCBscrewholePosdX2() const
Returns merger PCB screw hole position from the top edge.
Definition ARICHGeoMerger.h:236
Belle2::ARICHGeoMerger::getMergerAngle
const std::vector< double > & getMergerAngle() const
Returns vector of merger boarts azimuthal angles in polar coordinate system in deg.
Definition ARICHGeoMerger.h:284
Belle2::ARICHGeoMerger::getThickness
double getThickness() const
Returns merger PCB thickness.
Definition ARICHGeoMerger.h:188
Belle2::ARICHGeoMerger::getSingleMergeEnvelopePosition
ROOT::Math::XYZVector getSingleMergeEnvelopePosition() const
Returns position vector (ROOT::Math::XYZVector) of merger PCB inside the single merger envelope.
Definition ARICHGeoMerger.h:266
Belle2::ARICHGeoMerger::getMergerOrientation
const std::vector< double > & getMergerOrientation() const
Returns vector of merger boarts orientations in deg.
Definition ARICHGeoMerger.h:290
Belle2::ARICHGeoMerger::getMergerPosR
const std::vector< double > & getMergerPosR() const
Returns vector of merger boards distances from the center in mm.
Definition ARICHGeoMerger.h:278
Belle2::ARICHGeoMerger::getMergerPCBMaterialName
const std::string & getMergerPCBMaterialName() const
Returns merger PCB material name.
Definition ARICHGeoMerger.h:170
Belle2::ARICHGeoMerger::getSingleMergerEnvelopeSizeW
double getSingleMergerEnvelopeSizeW() const
Returns single merger PCB and merger cooling envelop width.
Definition ARICHGeoMerger.h:200
Belle2::ARICHGeoMerger::getEnvelopeInnerRadius
double getEnvelopeInnerRadius() const
Returns Inner radius of merger PCB assembly envelope.
Definition ARICHGeoMerger.h:248
Belle2::ARICHGeoMerger::getSingleMergerEnvelopeSizeL
double getSingleMergerEnvelopeSizeL() const
Returns single merger PCB and merger cooling envelop length.
Definition ARICHGeoMerger.h:194
Belle2::ARICHGeoMerger::getSizeL
double getSizeL() const
Returns merger PCB length.
Definition ARICHGeoMerger.h:176
Belle2::ARICHGeoMerger::getEnvelopeThickness
double getEnvelopeThickness() const
Returns Thickness of merger PCB assembly envelope.
Definition ARICHGeoMerger.h:254
Belle2::ARICHGeoMerger::getMergerPCBscrewholePosdY
double getMergerPCBscrewholePosdY() const
Returns merger PCB screw hole position from the left and right sides.
Definition ARICHGeoMerger.h:224
Belle2::ARICHGeoMirrors
Geometry parameters of HAPD.
Definition ARICHGeoMirrors.h:29
Belle2::ARICHGeoMirrors::getMirrorSurface
const GeoOpticalSurface & getMirrorSurface() const
Returns mirror reflective optical surface.
Definition ARICHGeoMirrors.h:169
Belle2::ARICHGeoMirrors::getPlateWidth
double getPlateWidth() const
Get width of mirror plate.
Definition ARICHGeoMirrors.h:119
Belle2::ARICHGeoMirrors::getMaterial
const std::string & getMaterial() const
Get material name of mirror plates.
Definition ARICHGeoMirrors.h:163
Belle2::ARICHGeoMirrors::getPlateLength
double getPlateLength() const
Get length of mirror plate.
Definition ARICHGeoMirrors.h:125
Belle2::ARICHGeoMirrors::getPlateThickness
double getPlateThickness() const
Get thickness of mirror plate.
Definition ARICHGeoMirrors.h:113
Belle2::ARICHGeoSupport
Geometry parameters of ARICH support structures and neutron shield.
Definition ARICHGeoSupport.h:25
Belle2::ARICHGeoSupport::getWedgeR
double getWedgeR(unsigned i) const
Get radius at which i-th wedge is placed.
Definition ARICHGeoSupport.h:173
Belle2::ARICHGeoSupport::getWedgePhi
double getWedgePhi(unsigned i) const
Get phi angle at which i-th wedge is placed.
Definition ARICHGeoSupport.h:180
Belle2::ARICHGeoSupport::getWedge
const std::vector< double > getWedge(unsigned i) const
Get parameters of wedge.
Definition ARICHGeoSupport.h:221
Belle2::ARICHGeoSupport::getTubeInnerR
double getTubeInnerR(unsigned i) const
Get tube inner radius.
Definition ARICHGeoSupport.h:132
Belle2::ARICHGeoSupport::getTubeLength
double getTubeLength(unsigned i) const
Get tube length.
Definition ARICHGeoSupport.h:146
Belle2::ARICHGeoSupport::getTubeOuterR
double getTubeOuterR(unsigned i) const
Get tube outer radius.
Definition ARICHGeoSupport.h:139
Belle2::ARICHGeoSupport::getWedgeZ
double getWedgeZ(unsigned i) const
Get Z position of i-th wedge.
Definition ARICHGeoSupport.h:187
Belle2::ARICHGeoSupport::getNTubes
unsigned getNTubes() const
Get number of tube volumes to be placed.
Definition ARICHGeoSupport.h:125
Belle2::ARICHGeoSupport::getTubeMaterial
const std::string & getTubeMaterial(unsigned i) const
Get material of i-th tube.
Definition ARICHGeoSupport.h:194
Belle2::ARICHGeoSupport::getWedgeType
int getWedgeType(unsigned i) const
Get type of i-th wedge.
Definition ARICHGeoSupport.h:166
Belle2::ARICHGeoSupport::getNWedges
unsigned getNWedges() const
Get number of wedges to be placed.
Definition ARICHGeoSupport.h:159
Belle2::ARICHGeoSupport::getTubeZPosition
double getTubeZPosition(unsigned i) const
Get tube Z position.
Definition ARICHGeoSupport.h:153
Belle2::ARICHGeoSupport::getWedgeMaterial
const std::string & getWedgeMaterial(unsigned i) const
Get material of i-th wedge.
Definition ARICHGeoSupport.h:201
Belle2::ARICHGeoSupport::getBox
box getBox(unsigned i) const
Get box parameters.
Definition ARICHGeoSupport.h:264
Belle2::ARICHGeoSupport::getTubeName
const std::string & getTubeName(unsigned i) const
Get name of i-th tube.
Definition ARICHGeoSupport.h:208
Belle2::ARICHGeoSupport::getNBoxes
unsigned getNBoxes() const
Get number of box volumes.
Definition ARICHGeoSupport.h:254
Belle2::ARICHGeometryConfig
The Class for ARICH Geometry Parameters.
Definition ARICHGeometryConfig.h:41
Belle2::ARICHGeometryConfig::getAerogelPlane
const ARICHGeoAerogelPlane & getAerogelPlane() const
Get geometry configuration of aerogel plane.
Definition ARICHGeometryConfig.h:97
Belle2::ARICHGeometryConfig::getMergerGeometry
const ARICHGeoMerger & getMergerGeometry() const
Get Merger PCB geometry parameters.
Definition ARICHGeometryConfig.h:127
Belle2::ARICHGeometryConfig::getFEBCoolingGeometry
const ARICHGeoFEBCooling & getFEBCoolingGeometry() const
Get ARICH FEB cooling system (v2) geometry parameters.
Definition ARICHGeometryConfig.h:145
Belle2::ARICHGeometryConfig::getMirrors
const ARICHGeoMirrors & getMirrors() const
Get mirrors geometry configuration.
Definition ARICHGeometryConfig.h:103
Belle2::ARICHGeometryConfig::getHAPDGeometry
const ARICHGeoHAPD & getHAPDGeometry() const
Get HAPD geometry parameters.
Definition ARICHGeometryConfig.h:121
Belle2::ARICHGeometryConfig::getDetectorPlane
const ARICHGeoDetectorPlane & getDetectorPlane() const
Get geometry configuration of HAPD plane.
Definition ARICHGeometryConfig.h:91
Belle2::ARICHPositionElement
Position element for ARICH.
Definition ARICHPositionElement.h:29
Belle2::BkgSensitiveDetector
The Class for BeamBackground Sensitive Detector.
Definition BkgSensitiveDetector.h:25
Belle2::Unit::eV
static const double eV
[electronvolt]
Definition Unit.h:112
Belle2::Unit::MeV
static const double MeV
[megaelectronvolt]
Definition Unit.h:114
Belle2::arich::GeoARICHCreator::buildSimpleAerogelPlane
G4LogicalVolume * buildSimpleAerogelPlane(const ARICHGeometryConfig &detectorGeo)
build simple aerogel plane (for cosmic test)
Definition GeoARICHCreator.cc:438
Belle2::arich::GeoARICHCreator::buildHAPD
G4LogicalVolume * buildHAPD(const ARICHGeoHAPD &hapdPar)
build the HAPD modules
Definition GeoARICHCreator.cc:850
Belle2::arich::GeoARICHCreator::makeJoint
void makeJoint(G4Material *supportMaterial, const std::vector< double > &pars, G4AssemblyVolume *assemblyWedge)
build joints of the ARICH support structure
Definition GeoARICHCreator.cc:1651
Belle2::arich::GeoARICHCreator::~GeoARICHCreator
virtual ~GeoARICHCreator()
The destructor of the GeoARICHreator class.
Definition GeoARICHCreator.cc:73
Belle2::arich::GeoARICHCreator::m_mergerCooling
OptionalDBObjPtr< ARICHGeoMergerCooling > m_mergerCooling
merger cooling bodies geometry from the DB
Definition GeoARICHCreator.h:175
Belle2::arich::GeoARICHCreator::buildMergerPCBEnvelopePlane
G4LogicalVolume * buildMergerPCBEnvelopePlane(const ARICHGeometryConfig &detectorGeo)
build merger PCB assembly envelope plane
Definition GeoARICHCreator.cc:1093
Belle2::arich::GeoARICHCreator::buildFEBCoolingBody
G4LogicalVolume * buildFEBCoolingBody(const ARICHGeoFEBCooling &coolingv2Geo)
build FEB cooling bodies (cooling system update after phase 2)
Definition GeoARICHCreator.cc:1185
Belle2::arich::GeoARICHCreator::buildCoolingTorus
G4LogicalVolume * buildCoolingTorus(const unsigned i_volumeID, const ARICHGeoCooling &coolingGeo)
build cooling tube (G4Torus)
Definition GeoARICHCreator.cc:1314
Belle2::arich::GeoARICHCreator::buildAerogelPlaneAveragedOverLayers
G4LogicalVolume * buildAerogelPlaneAveragedOverLayers(const ARICHGeometryConfig &detectorGeo)
build aerogel plane with average properties of aerogel per layer
Definition GeoARICHCreator.cc:502
Belle2::arich::GeoARICHCreator::buildCables
G4LogicalVolume * buildCables(const ARICHGeoCablesEnvelope &cablesGeo)
build the cables envelop with effective material describing cables
Definition GeoARICHCreator.cc:1168
Belle2::arich::GeoARICHCreator::buildMergerCooling
G4LogicalVolume * buildMergerCooling(unsigned iType)
build merger cooling bodies (cooling system update after phase 2)
Definition GeoARICHCreator.cc:1027
Belle2::arich::GeoARICHCreator::getAvgRINDEX
double getAvgRINDEX(G4Material *material)
get refractive index of the material
Definition GeoARICHCreator.cc:1641
Belle2::arich::GeoARICHCreator::buildCoolingTube
G4LogicalVolume * buildCoolingTube(const unsigned i_volumeID, const ARICHGeoCooling &coolingGeo)
build cooling tube (G4Tubs)
Definition GeoARICHCreator.cc:1299
Belle2::arich::GeoARICHCreator::createGeometry
void createGeometry(G4LogicalVolume &topVolume, geometry::GeometryTypes type)
Create detector geometry.
Definition GeoARICHCreator.cc:82
Belle2::arich::GeoARICHCreator::buildDetectorSupportPlate
G4LogicalVolume * buildDetectorSupportPlate(const ARICHGeometryConfig &detectorGeo)
build detector support plate
Definition GeoARICHCreator.cc:1466
Belle2::arich::GeoARICHCreator::m_modInfo
DBObjPtr< ARICHModulesInfo > m_modInfo
information on installed modules from the DB
Definition GeoARICHCreator.h:174
Belle2::arich::GeoARICHCreator::buildAerogelPlane
G4LogicalVolume * buildAerogelPlane(const ARICHGeometryConfig &detectorGeo)
build aerogel plane
Definition GeoARICHCreator.cc:491
Belle2::arich::GeoARICHCreator::GeoARICHCreator
GeoARICHCreator()
Constructor of the GeoARICHCreator class.
Definition GeoARICHCreator.cc:67
Belle2::arich::GeoARICHCreator::m_sensitiveAero
SensitiveAero * m_sensitiveAero
pointer to sensitive aerogel - used instead of tracking
Definition GeoARICHCreator.h:169
Belle2::arich::GeoARICHCreator::buildDetectorPlane
G4LogicalVolume * buildDetectorPlane(const ARICHGeometryConfig &detectorGeo)
build detector plane
Definition GeoARICHCreator.cc:945
Belle2::arich::GeoARICHCreator::m_config
ARICHGeometryConfig m_config
geometry configuration
Definition GeoARICHCreator.h:163
Belle2::arich::GeoARICHCreator::buildCoolingEnvelopePlane
G4LogicalVolume * buildCoolingEnvelopePlane(const ARICHGeoCooling &coolingGeo)
build cooling system assembly envelope plane
Definition GeoARICHCreator.cc:1336
Belle2::arich::GeoARICHCreator::m_isBeamBkgStudy
int m_isBeamBkgStudy
flag the beam background study
Definition GeoARICHCreator.h:172
Belle2::arich::GeoARICHCreator::buildMergerEnvelope
G4LogicalVolume * buildMergerEnvelope(const ARICHGeoMerger &mergerGeo, int type)
build single merger and merger cooling body envelope logical volume
Definition GeoARICHCreator.cc:1081
Belle2::arich::GeoARICHCreator::buildMerger
G4LogicalVolume * buildMerger(const ARICHGeoMerger &mergerGeo)
build the merger PCB logical volume
Definition GeoARICHCreator.cc:974
Belle2::arich::GeoARICHCreator::m_sensitive
SensitiveDetector * m_sensitive
pointer to sensitive detector
Definition GeoARICHCreator.h:166
Belle2::arich::GeoARICHCreator::buildAerogelPlaneWithIndividualTilesProp
G4LogicalVolume * buildAerogelPlaneWithIndividualTilesProp(const ARICHGeometryConfig &detectorGeo)
with individual properties of aerogel tiles
Definition GeoARICHCreator.cc:614
Belle2::arich::GeoARICHCreator::buildMirror
G4LogicalVolume * buildMirror(const ARICHGeometryConfig &detectorGeo)
build mirrors
Definition GeoARICHCreator.cc:1615
Belle2::arich::GeoARICHCreator::buildCoolingTestPlate
G4LogicalVolume * buildCoolingTestPlate(const ARICHGeoCooling &coolingGeo)
build cooling test plates
Definition GeoARICHCreator.cc:1383
Belle2::arich::SensitiveAero
This is optional (temporary) class that provides information on track parameters on aerogel plane,...
Definition SensitiveAero.h:22
Belle2::arich::SensitiveDetector
The Class for ARICH Sensitive Detector.
Definition SensitiveDetector.h:26
Belle2::geometry::Materials
Thin wrapper around the Geant4 Material system.
Definition Materials.h:48
Belle2::geometry::Materials::get
static G4Material * get(const std::string &name)
Find given material.
Definition Materials.h:63
Belle2::geometry::Materials::getInstance
static Materials & getInstance()
Get a reference to the singleton instance.
Definition Materials.cc:85
Belle2::geometry::Materials::createOpticalSurface
G4OpticalSurface * createOpticalSurface(const gearbox::Interface &parameters)
Create an optical surface from parameters, will abort on error.
Definition Materials.cc:295
Belle2::sqrt
double sqrt(double a)
sqrt for double
Definition beamHelpers.h:28
Belle2::geometry
Common code concerning the geometry representation of the detector.
Definition CreatorBase.h:25
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
Belle2::geometry::GeometryTypes
GeometryTypes
Flag indicating the type of geometry to be used.
Definition GeometryManager.h:36
Belle2
Abstract base class for different kinds of events.
Definition MillepedeAlgorithm.h:17
std
STL namespace.
Belle2::ARICHGeoSupport::box
Struct to hold parameters of box volumes (examples, scintilators for cosmic test)
Definition ARICHGeoSupport.h:60
Belle2::ARICHGeoSupport::box::material
std::string material
material
Definition ARICHGeoSupport.h:65
Belle2::ARICHGeoSupport::box::rotation
double rotation[3]
rotation coordinates
Definition ARICHGeoSupport.h:63
Belle2::ARICHGeoSupport::box::position
double position[3]
position coordinates
Definition ARICHGeoSupport.h:62
Belle2::ARICHGeoSupport::box::size
double size[3]
size coordinates
Definition ARICHGeoSupport.h:61
Belle2::tessellatedSolidStr
Structure which holds apexes of the tessellation volumes.
Definition tessellatedSolidStr.h:26
Belle2::tessellatedSolidStr::posV1
std::vector< std::vector< double > > posV1
x, y, z of apex1.
Definition tessellatedSolidStr.h:34
Belle2::tessellatedSolidStr::posV3
std::vector< std::vector< double > > posV3
x, y, z of apex3.
Definition tessellatedSolidStr.h:40
Belle2::tessellatedSolidStr::posV2
std::vector< std::vector< double > > posV2
x, y, z of apex2.
Definition tessellatedSolidStr.h:37
Belle2::tessellatedSolidStr::nCells
unsigned int nCells
number of cells
Definition tessellatedSolidStr.h:28