Belle II Software development
GeoCDCCreatorReducedCDC.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 <cdc/geometry/GeoCDCCreatorReducedCDC.h>
10#include <cdc/geometry/CDCGeometryPar.h>
11#include <cdc/geometry/CDCGeoControlPar.h>
12#include <cdc/simulation/CDCSimControlPar.h>
13#include <cdc/simulation/CDCSensitiveDetector.h>
14#include <simulation/background/BkgSensitiveDetector.h>
15
16#include <geometry/CreatorFactory.h>
17#include <geometry/Materials.h>
18
19#include <cmath>
20#include <boost/format.hpp>
21
22#include <G4Material.hh>
23#include <G4Box.hh>
24#include <G4Tubs.hh>
25#include <G4Torus.hh>
26#include <G4Trd.hh>
27#include <G4SubtractionSolid.hh>
28#include <G4Region.hh>
29#include <G4VSolid.hh>
30
31#include <G4Polycone.hh>
32#include <G4Cons.hh>
33#include <G4Colour.hh>
34#include <G4LogicalVolume.hh>
35#include <G4PVPlacement.hh>
36#include <G4Transform3D.hh>
37#include <G4VisAttributes.hh>
38#include <G4RotationMatrix.hh>
39#include <G4UserLimits.hh>
40#include <iostream>
41
42using namespace std;
43
44namespace Belle2 {
49
50 using namespace geometry;
51
52 namespace CDC {
53
57
59
60 //-----------------------------------------------------------------
61 // Implementation
62 //-----------------------------------------------------------------
63
65 {
66 // Set job control params. before sensitivedetector and geometry construction
69
70 m_logicalCDC = 0;
71 m_physicalCDC = 0;
72 m_VisAttributes.clear();
73 m_VisAttributes.push_back(new G4VisAttributes(false)); // for "invisible"
74 m_userLimits.clear();
75
76 B2WARNING("Using CDC without SL0!");
77 }
78
79
81 {
82 delete m_sensitive;
84 for (G4VisAttributes* visAttr : m_VisAttributes) delete visAttr;
85 m_VisAttributes.clear();
86 for (G4UserLimits* userLimits : m_userLimits) delete userLimits;
87 m_userLimits.clear();
88 }
89
91 {
92
93 m_sensitive = new CDCSensitiveDetector("CDCSensitiveDetector", (2 * 24)* CLHEP::eV, 10 * CLHEP::MeV);
94
95 const G4double realTemperture = (273.15 + 23.) * CLHEP::kelvin;
96 G4Material* medHelium = geometry::Materials::get("CDCHeGas");
97 G4Material* medEthane = geometry::Materials::get("CDCEthaneGas");
98 G4Material* medAluminum = geometry::Materials::get("Al");
99 G4Material* medTungsten = geometry::Materials::get("W");
100 G4Material* medCFRP = geometry::Materials::get("CFRP");
101 G4Material* medNEMA_G10_Plate = geometry::Materials::get("NEMA_G10_Plate");
102 G4Material* medGlue = geometry::Materials::get("CDCGlue");
103 G4Material* medAir = geometry::Materials::get("Air");
104
105 G4double h2odensity = 1.000 * CLHEP::g / CLHEP::cm3;
106 G4double a = 1.01 * CLHEP::g / CLHEP::mole;
107 G4Element* elH = new G4Element("Hydrogen", "H", 1., a);
108 a = 16.00 * CLHEP::g / CLHEP::mole;
109 G4Element* elO = new G4Element("Oxygen", "O", 8., a);
110 G4Material* medH2O = new G4Material("Water", h2odensity, 2);
111 medH2O->AddElement(elH, 2);
112 medH2O->AddElement(elO, 1);
113 G4Material* medCopper = geometry::Materials::get("Cu");
114 G4Material* medHV = geometry::Materials::get("CDCHVCable");
115 //G4Material* medFiber = geometry::Materials::get("CDCOpticalFiber");
116 //G4Material* medCAT7 = geometry::Materials::get("CDCCAT7");
117 //G4Material* medTRG = geometry::Materials::get("CDCOpticalFiberTRG");
118
119 // Total cross section
120 const double rmax_innerWall = geo.getFiducialRmin();
121 const double rmin_outerWall = geo.getFiducialRmax();
122 const double diameter_senseWire = geo.getSenseDiameter();
123 const double diameter_fieldWire = geo.getFieldDiameter();
124 const double num_senseWire = static_cast<double>(geo.getNSenseWires());
125 const double num_fieldWire = static_cast<double>(geo.getNFieldWires());
126 double totalCS = M_PI * (rmin_outerWall * rmin_outerWall - rmax_innerWall * rmax_innerWall);
127
128 // Sense wire cross section
129 double senseCS = M_PI * (diameter_senseWire / 2) * (diameter_senseWire / 2) * num_senseWire;
130
131 // Field wire cross section
132 double fieldCS = M_PI * (diameter_fieldWire / 2) * (diameter_fieldWire / 2) * num_fieldWire;
133
134 // Density
135 const double denHelium = medHelium->GetDensity() / 2.0;
136 const double denEthane = medEthane->GetDensity() / 2.0;
137 const double denAluminum = medAluminum->GetDensity() * (fieldCS / totalCS);
138 const double denTungsten = medTungsten->GetDensity() * (senseCS / totalCS);
139 const double density = denHelium + denEthane + denAluminum + denTungsten;
140 G4Material* cdcMed = new G4Material("CDCGasWire", density, 4, kStateGas, realTemperture);
141 cdcMed->AddMaterial(medHelium, denHelium / density);
142 cdcMed->AddMaterial(medEthane, denEthane / density);
143 cdcMed->AddMaterial(medTungsten, denTungsten / density);
144 cdcMed->AddMaterial(medAluminum, denAluminum / density);
145
146 G4Material* cdcMedGas = cdcMed;
147
150 // std::cout << gcp.getMaterialDefinitionMode() << std::endl;
151
152 // if (cdcgp.getMaterialDefinitionMode() == 2) {
153 if (gcp.getMaterialDefinitionMode() == 2) {
154 const double density2 = denHelium + denEthane;
155 cdcMedGas = new G4Material("CDCRealGas", density2, 2, kStateGas, realTemperture);
156 cdcMedGas->AddMaterial(medHelium, denHelium / density2);
157 cdcMedGas->AddMaterial(medEthane, denEthane / density2);
158 }
159
160 if (gcp.getPrintMaterialTable()) {
161 G4cout << *(G4Material::GetMaterialTable());
162 }
163
164 const auto& mother = geo.getMotherVolume();
165 const auto& motherRmin = mother.getRmin();
166 const auto& motherRmax = mother.getRmax();
167 const auto& motherZ = mother.getZ();
168 G4Polycone* solid_cdc =
169 new G4Polycone("solidCDC", 0 * CLHEP::deg, 360.* CLHEP::deg,
170 mother.getNNodes(), motherZ.data(),
171 motherRmin.data(), motherRmax.data());
172 m_logicalCDC = new G4LogicalVolume(solid_cdc, medAir, "logicalCDC", 0, 0, 0);
173 m_physicalCDC = new G4PVPlacement(0, G4ThreeVector(geo.getGlobalOffsetX() * CLHEP::cm,
174 geo.getGlobalOffsetY() * CLHEP::cm,
175 geo.getGlobalOffsetZ() * CLHEP::cm), m_logicalCDC,
176 "physicalCDC", &topVolume, false, 0);
177
178 // Set up region for production cuts
179 G4Region* aRegion = new G4Region("CDCEnvelope");
180 m_logicalCDC->SetRegion(aRegion);
181 aRegion->AddRootLogicalVolume(m_logicalCDC);
182
183 m_VisAttributes.push_back(new G4VisAttributes(true, G4Colour(0., 1., 0.)));
184 for (const auto& wall : geo.getOuterWalls()) {
185 const int iOuterWall = wall.getId();
186 const string wallName = wall.getName();
187 const double wallRmin = wall.getRmin();
188 const double wallRmax = wall.getRmax();
189 const double wallZfwd = wall.getZfwd();
190 const double wallZbwd = wall.getZbwd();
191 const double length = (wallZfwd - wallZbwd) / 2.0;
192
193
194 G4Material* medWall;
195 if (strstr((wallName).c_str(), "MiddleWall") != nullptr) {
196 medWall = medCFRP;
197 } else {
198 medWall = medAluminum;
199 }
200 G4Tubs* outerWallTubeShape = new G4Tubs("solid" + wallName, wallRmin * CLHEP::cm,
201 wallRmax * CLHEP::cm, length * CLHEP::cm, 0 * CLHEP::deg, 360.*CLHEP::deg);
202
203 G4LogicalVolume* outerWallTube = new G4LogicalVolume(outerWallTubeShape, medWall, "solid" + wallName, 0, 0, 0);
204 outerWallTube->SetVisAttributes(m_VisAttributes.back());
205 new G4PVPlacement(0, G4ThreeVector(0.0, 0.0, (length + wallZbwd)*CLHEP::cm), outerWallTube, "logical" + wallName,
206 m_logicalCDC, false, iOuterWall);
207 }
208
209
210 m_VisAttributes.push_back(new G4VisAttributes(true, G4Colour(0., 1., 0.)));
211 for (const auto& wall : geo.getInnerWalls()) {
212 const string wallName = wall.getName();
213 const double wallRmin = wall.getRmin();
214 const double wallRmax = wall.getRmax();
215 const double wallZfwd = wall.getZfwd();
216 const double wallZbwd = wall.getZbwd();
217 const double length = (wallZfwd - wallZbwd) / 2.0;
218 const int iInnerWall = wall.getId();
219
220 G4Material* medWall;
221 if (strstr(wallName.c_str(), "MiddleWall") != nullptr) {
222 medWall = medCFRP;
223 } else if (strstr(wallName.c_str(), "MiddleGlue") != nullptr) { // Glue layer 0.005 mmt
224 medWall = medGlue;
225 } else { // Al layer 0.1 mmt
226 medWall = medAluminum;
227 }
228
229 G4Tubs* innerWallTubeShape = new G4Tubs("solid" + wallName, wallRmin * CLHEP::cm,
230 wallRmax * CLHEP::cm, length * CLHEP::cm, 0 * CLHEP::deg, 360.*CLHEP::deg);
231 G4LogicalVolume* innerWallTube = new G4LogicalVolume(innerWallTubeShape, medWall, "logical" + wallName, 0, 0, 0);
232 innerWallTube->SetVisAttributes(m_VisAttributes.back());
233 new G4PVPlacement(0, G4ThreeVector(0.0, 0.0, (length + wallZbwd)*CLHEP::cm), innerWallTube, "physical" + wallName,
234 m_logicalCDC, false, iInnerWall);
235
236
237 }
238
239
240
241 //
242 // Construct sensitive layers.
243 //
244 const uint nSLayer = geo.getNSenseLayers();
245 const double length_feedthrough = geo.getFeedthroughLength();
246 for (uint iSLayer = 0; iSLayer < nSLayer; ++iSLayer) {
247 const auto& endplate = geo.getEndPlate(iSLayer);
248 const int nEPLayer = endplate.getNEndPlateLayers();
249 // Get parameters for sensitive layer: left, middle and right.
250 double rmin_sensitive_left, rmax_sensitive_left;
251 double rmin_sensitive_middle, rmax_sensitive_middle;
252 double rmin_sensitive_right, rmax_sensitive_right;
253 double zback_sensitive_left, zfor_sensitive_left;
254 double zback_sensitive_middle, zfor_sensitive_middle;
255 double zback_sensitive_right, zfor_sensitive_right;
256
257 if (iSLayer == 0) {
258 const auto& epLayerBwd = endplate.getEndPlateLayer(1);
259 const auto& epLayerFwd = endplate.getEndPlateLayer((nEPLayer / 2) + 1);
260 const auto& senseLayer = geo.getSenseLayer(iSLayer);
261 const auto& fieldLayer = geo.getFieldLayer(iSLayer);
262
263 rmin_sensitive_left = epLayerBwd.getRmax();
264 rmax_sensitive_left = fieldLayer.getR();
265 zback_sensitive_left = senseLayer.getZbwd();
266 zfor_sensitive_left = epLayerBwd.getZfwd();
267
268 rmin_sensitive_middle = (geo.getInnerWall(0)).getRmax();
269 rmax_sensitive_middle = fieldLayer.getR();
270 zback_sensitive_middle = epLayerBwd.getZfwd();
271 zfor_sensitive_middle = epLayerFwd.getZbwd();
272
273 rmin_sensitive_right = epLayerFwd.getRmax();
274 rmax_sensitive_right = fieldLayer.getR();
275 zback_sensitive_right = epLayerFwd.getZbwd();
276 zfor_sensitive_right = senseLayer.getZfwd();
277 } else if (iSLayer >= 1 && iSLayer <= 6) {
278 const auto& epLayerBwd = endplate.getEndPlateLayer(1);
279 const auto& epLayerFwd = endplate.getEndPlateLayer((nEPLayer / 2) + 1);
280 const auto& senseLayer = geo.getSenseLayer(iSLayer);
281 const auto& fieldLayerIn = geo.getFieldLayer(iSLayer - 1);
282 const auto& fieldLayerOut = geo.getFieldLayer(iSLayer);
283
284 rmin_sensitive_left = epLayerBwd.getRmax();
285 rmax_sensitive_left = fieldLayerOut.getR();
286 zback_sensitive_left = senseLayer.getZbwd();
287 zfor_sensitive_left = epLayerBwd.getZfwd();
288
289 rmin_sensitive_middle = fieldLayerIn.getR();
290 rmax_sensitive_middle = fieldLayerOut.getR();
291 zback_sensitive_middle = epLayerBwd.getZfwd();
292 zfor_sensitive_middle = epLayerFwd.getZbwd();
293
294 rmin_sensitive_right = epLayerFwd.getRmax();
295 rmax_sensitive_right = fieldLayerOut.getR();
296 zback_sensitive_right = epLayerFwd.getZbwd();
297 zfor_sensitive_right = senseLayer.getZfwd();
298 } else if (iSLayer >= 7 && iSLayer <= 10) {
299 const auto& epLayerBwd = endplate.getEndPlateLayer(1);
300 const auto& epLayerFwd = endplate.getEndPlateLayer(nEPLayer / 2);
301 const auto& senseLayer = geo.getSenseLayer(iSLayer);
302 const auto& fieldLayerIn = geo.getFieldLayer(iSLayer - 1);
303 const auto& fieldLayerOut = geo.getFieldLayer(iSLayer);
304
305 rmin_sensitive_left = epLayerBwd.getRmax();
306 rmax_sensitive_left = fieldLayerOut.getR();
307 zback_sensitive_left = senseLayer.getZbwd();
308 zfor_sensitive_left = epLayerBwd.getZfwd();
309
310 rmin_sensitive_middle = fieldLayerIn.getR();
311 rmax_sensitive_middle = fieldLayerOut.getR();
312 zback_sensitive_middle = epLayerBwd.getZfwd();
313 zfor_sensitive_middle = epLayerFwd.getZbwd();
314
315 rmin_sensitive_right = epLayerFwd.getRmax();
316 rmax_sensitive_right = fieldLayerOut.getR();
317 zback_sensitive_right = epLayerFwd.getZbwd();
318 zfor_sensitive_right = senseLayer.getZfwd();
319 } else if (iSLayer >= 11 && iSLayer < 47) {
320 const auto& epLayerBwd = endplate.getEndPlateLayer(0);
321 const auto& epLayerFwd = endplate.getEndPlateLayer(nEPLayer / 2);
322 const auto& senseLayer = geo.getSenseLayer(iSLayer);
323 const auto& fieldLayerIn = geo.getFieldLayer(iSLayer - 1);
324 const auto& fieldLayerOut = geo.getFieldLayer(iSLayer);
325
326 rmin_sensitive_left = epLayerBwd.getRmax();
327 rmax_sensitive_left = fieldLayerOut.getR();
328 zback_sensitive_left = senseLayer.getZbwd();
329 zfor_sensitive_left = epLayerBwd.getZfwd();
330
331 rmin_sensitive_middle = fieldLayerIn.getR();
332 rmax_sensitive_middle = fieldLayerOut.getR();
333 zback_sensitive_middle = epLayerBwd.getZfwd();
334 zfor_sensitive_middle = epLayerFwd.getZbwd();
335
336 rmin_sensitive_right = epLayerFwd.getRmax();
337 rmax_sensitive_right = fieldLayerOut.getR();
338 zback_sensitive_right = epLayerFwd.getZbwd();
339 zfor_sensitive_right = senseLayer.getZfwd();
340
341 } else if (iSLayer == 47) {
342
343 const auto& epLayerBwdIn = endplate.getEndPlateLayer(0);
344 const auto& epLayerBwdOut = endplate.getEndPlateLayer((nEPLayer / 2) - 1);
345 const auto& epLayerFwdIn = endplate.getEndPlateLayer(nEPLayer / 2);
346 const auto& epLayerFwdOut = endplate.getEndPlateLayer(nEPLayer - 1);
347 const auto& senseLayer = geo.getSenseLayer(iSLayer);
348 // const auto& fieldLayerIn = geo.getFieldLayer(iSLayer - 1);
349 int iSLayerMinus1 = iSLayer - 1; //avoid cpp-check warning
350 const auto& fieldLayerIn = geo.getFieldLayer(iSLayerMinus1); //avoid cpp-check warning
351 rmin_sensitive_left = epLayerBwdIn.getRmax();
352 rmax_sensitive_left = epLayerBwdOut.getRmax();
353 zback_sensitive_left = senseLayer.getZbwd();
354 zfor_sensitive_left = epLayerBwdIn.getZfwd();
355
356 rmin_sensitive_middle = fieldLayerIn.getR();
357 rmax_sensitive_middle = (geo.getOuterWall(0)).getRmin();
358 zback_sensitive_middle = epLayerBwdIn.getZfwd();
359 zfor_sensitive_middle = epLayerFwdIn.getZbwd();
360
361 rmin_sensitive_right = epLayerFwdIn.getRmax();
362 rmax_sensitive_right = epLayerFwdOut.getRmax();
363 zback_sensitive_right = epLayerFwdIn.getZbwd();
364 zfor_sensitive_right = senseLayer.getZfwd();
365
366 } else {
367 B2ERROR("Undefined sensitive layer : " << iSLayer);
368 continue;
369 }
370
371
372 // Check if build left sensitive tube
373 if ((zfor_sensitive_left - zback_sensitive_left) > length_feedthrough) {
374 // std::cout <<"left doif " << iSLayer <<" "<< zfor_sensitive_left - zback_sensitive_left << std::endl;
375 //==========================================================
376 // zback_sensitive_left
377 // |
378 // \|/
379 // _____________________
380 // | |// 1 // | |
381 // | |==ft====|2 | (ft = feedthrouth)
382 // |_______|____1___|__|
383 // |_______|___________|
384 // |
385 // \|/
386 // zfor_sensitive_left
387 //==========================================================
388
389 // Build a tube with metarial cdcMed for area 1
390 G4Tubs* leftTubeShape = new G4Tubs((boost::format("solidCDCLayer_%1%_leftTube") % iSLayer).str().c_str(),
391 rmin_sensitive_left * CLHEP::cm,
392 rmax_sensitive_left * CLHEP::cm, length_feedthrough * CLHEP::cm / 2.0, 0 * CLHEP::deg, 360.*CLHEP::deg);
393 G4LogicalVolume* leftTube = new G4LogicalVolume(leftTubeShape, cdcMed,
394 (boost::format("logicalCDCLayer_%1%_leftTube") % iSLayer).str().c_str(), 0, 0, 0);
395 new G4PVPlacement(0, G4ThreeVector(0.0, 0.0, (zback_sensitive_left + length_feedthrough / 2.0)*CLHEP::cm), leftTube,
396 (boost::format("physicalCDCLayer_%1%_leftTube") % iSLayer).str().c_str(), m_logicalCDC, false, iSLayer);
397 // Build left sensitive tube (area 2)
398 G4Tubs* leftSensitiveTubeShape = new G4Tubs((boost::format("solidSD_CDCLayer_%1%_left") % iSLayer).str().c_str(),
399 rmin_sensitive_left * CLHEP::cm, rmax_sensitive_left * CLHEP::cm,
400 (zfor_sensitive_left - zback_sensitive_left - length_feedthrough)*CLHEP::cm / 2.0, 0 * CLHEP::deg, 360.*CLHEP::deg);
401 G4LogicalVolume* leftSensitiveTube = new G4LogicalVolume(leftSensitiveTubeShape, cdcMed,
402 (boost::format("logicalSD_CDCLayer_%1%_left") % iSLayer).str().c_str(), 0, 0, 0);
403 leftSensitiveTube->SetSensitiveDetector(m_sensitive);
404 new G4PVPlacement(0, G4ThreeVector(0.0, 0.0, (zfor_sensitive_left + zback_sensitive_left + length_feedthrough)*CLHEP::cm / 2.0),
405 leftSensitiveTube, (boost::format("physicalSD_CDCLayer_%1%_left") % iSLayer).str().c_str(), m_logicalCDC, false, iSLayer);
406 } else {
407 // std::cout <<"left doelse " << iSLayer << std::endl;
408 //==========================================================
409 // zback_sensitive_left
410 // |
411 // \|/
412 // _________________________
413 // | |//// 1 ////| 2 |
414 // | |======ft======== (ft = feedthrouth)
415 // |_______|____1______| 2 |
416 // |_______|___________|___|
417 // |
418 // \|/
419 // zfor_sensitive_left
420 //==========================================================
421
422 // Build a tube with metarial cdcMed for area 1
423 G4Tubs* leftTubeShape = new G4Tubs((boost::format("solidCDCLayer_%1%_leftTube") % iSLayer).str().c_str(),
424 rmin_sensitive_left * CLHEP::cm,
425 rmax_sensitive_left * CLHEP::cm, (zfor_sensitive_left - zback_sensitive_left)*CLHEP::cm / 2.0, 0 * CLHEP::deg, 360.*CLHEP::deg);
426 G4LogicalVolume* leftTube = new G4LogicalVolume(leftTubeShape, cdcMed,
427 (boost::format("logicalCDCLayer_%1%_leftTube") % iSLayer).str().c_str(), 0, 0, 0);
428 new G4PVPlacement(0, G4ThreeVector(0.0, 0.0, (zfor_sensitive_left + zback_sensitive_left)*CLHEP::cm / 2.0), leftTube,
429 (boost::format("physicalCDCLayer_%1%_leftTube") % iSLayer).str().c_str(), m_logicalCDC, false, iSLayer);
430
431
432 // Build a tube with metarial cdcMed for area 2
433 G4Tubs* leftMidTubeShape = new G4Tubs((boost::format("solidCDCLayer_%1%_leftMidTube") % iSLayer).str().c_str(),
434 rmin_sensitive_middle * CLHEP::cm, rmax_sensitive_middle * CLHEP::cm,
435 (length_feedthrough - zfor_sensitive_left + zback_sensitive_left)*CLHEP::cm / 2.0, 0 * CLHEP::deg, 360.*CLHEP::deg);
436 G4LogicalVolume* leftMidTube = new G4LogicalVolume(leftMidTubeShape, cdcMed,
437 (boost::format("logicalCDCLayer_%1%_leftMidTube") % iSLayer).str().c_str(), 0, 0, 0);
438
439 new G4PVPlacement(0, G4ThreeVector(0.0, 0.0, (length_feedthrough + zfor_sensitive_left + zback_sensitive_left)*CLHEP::cm / 2.0),
440 leftMidTube, (boost::format("physicalCDCLayer_%1%_leftMidTube") % iSLayer).str().c_str(), m_logicalCDC, false, iSLayer);
441
442 // Reset zback_sensitive_middle
443 zback_sensitive_middle = length_feedthrough + zback_sensitive_left;
444 }
445
446 // Check if build right sensitive tube
447 if ((zfor_sensitive_right - zback_sensitive_right) > length_feedthrough) {
448 // std::cout <<"right doif" << iSLayer <<" "<< zfor_sensitive_right - zback_sensitive_right << std::endl;
449 //==========================================================
450 // zfor_sensitive_right
451 // |
452 // \|/
453 // _____________________________
454 // | | 1 |///////|
455 // | 2 |====ft=====|///////| (ft = feedthrouth)
456 // |_______|____1______|_______|
457 // |_______|___________|_______|
458 // |
459 // \|/
460 // zback_sensitive_right
461 //==========================================================
462
463 // Build a tube with metarial cdcMed for area 1
464 G4Tubs* rightTubeShape = new G4Tubs((boost::format("solidCDCLayer_%1%_rightTube") % iSLayer).str().c_str(),
465 rmin_sensitive_right * CLHEP::cm, rmax_sensitive_right * CLHEP::cm, length_feedthrough * CLHEP::cm / 2.0, 0 * CLHEP::deg,
466 360.*CLHEP::deg);
467 G4LogicalVolume* rightTube = new G4LogicalVolume(rightTubeShape, cdcMed,
468 (boost::format("logicalCDCLayer_%1%_rightTube") % iSLayer).str().c_str(), 0, 0, 0);
469
470 new G4PVPlacement(0, G4ThreeVector(0.0, 0.0, (zfor_sensitive_right - length_feedthrough / 2.0)*CLHEP::cm), rightTube,
471 (boost::format("physicalCDCLayer_%1%_rightTube") % iSLayer).str().c_str(), m_logicalCDC, false, iSLayer);
472
473
474 // Build right sensitive tube (area 2)
475 G4Tubs* rightSensitiveTubeShape = new G4Tubs((boost::format("solidSD_CDCLayer_%1%_right") % iSLayer).str().c_str(),
476 rmin_sensitive_right * CLHEP::cm, rmax_sensitive_right * CLHEP::cm,
477 (zfor_sensitive_right - zback_sensitive_right - length_feedthrough)*CLHEP::cm / 2.0, 0 * CLHEP::deg, 360.*CLHEP::deg);
478 G4LogicalVolume* rightSensitiveTube = new G4LogicalVolume(rightSensitiveTubeShape, cdcMed,
479 (boost::format("logicalSD_CDCLayer_%1%_right") % iSLayer).str().c_str(), 0, 0, 0);
480 rightSensitiveTube->SetSensitiveDetector(m_sensitive);
481
482 new G4PVPlacement(0, G4ThreeVector(0.0, 0.0, (zfor_sensitive_right + zback_sensitive_right - length_feedthrough)*CLHEP::cm / 2.0),
483 rightSensitiveTube, (boost::format("physicalSD_CDCLayer_%1%_right") % iSLayer).str().c_str(), m_logicalCDC, false, iSLayer);
484
485 } else {
486 // std::cout <<"right doelse" << iSLayer << std::endl;
487 //==========================================================
488 // zfor_sensitive_right
489 // |
490 // \|/
491 // _____________________________
492 // | | 1 |///////|
493 // |============ft=====|///////| (ft = feedthrouth)
494 // | |____1______|_______|
495 // |_______|___________|_______|
496 // |
497 // \|/
498 // zback_sensitive_right
499 //==========================================================
500
501 // Build a tube with metarial cdcMed for area 1
502 G4Tubs* rightTubeShape = new G4Tubs((boost::format("solidCDCLayer_%1%_rightTube") % iSLayer).str().c_str(),
503 rmin_sensitive_right * CLHEP::cm, rmax_sensitive_right * CLHEP::cm, (zfor_sensitive_right - zback_sensitive_right)*CLHEP::cm / 2.0,
504 0 * CLHEP::deg, 360.*CLHEP::deg);
505 G4LogicalVolume* rightTube = new G4LogicalVolume(rightTubeShape, cdcMed,
506 (boost::format("logicalCDCLayer_%1%_rightTube") % iSLayer).str().c_str(), 0, 0, 0);
507
508 new G4PVPlacement(0, G4ThreeVector(0.0, 0.0, (zfor_sensitive_right + zback_sensitive_right)*CLHEP::cm / 2.0), rightTube,
509 (boost::format("physicalCDCLayer_%1%_rightTube") % iSLayer).str().c_str(), m_logicalCDC, false, iSLayer);
510
511
512 // Build a tube with metarial cdcMed for area 2
513 G4Tubs* rightMidTubeShape = new G4Tubs((boost::format("solidCDCLayer_%1%_rightMidTube") % iSLayer).str().c_str(),
514 rmin_sensitive_middle * CLHEP::cm, rmax_sensitive_middle * CLHEP::cm,
515 (length_feedthrough - zfor_sensitive_right + zback_sensitive_right)*CLHEP::cm / 2.0, 0 * CLHEP::deg, 360.*CLHEP::deg);
516 G4LogicalVolume* rightMidTube = new G4LogicalVolume(rightMidTubeShape, cdcMed,
517 (boost::format("logicalCDCLayer_%1%_rightMidTube") % iSLayer).str().c_str(), 0, 0, 0);
518 new G4PVPlacement(0, G4ThreeVector(0.0, 0.0, (zback_sensitive_right - length_feedthrough + zfor_sensitive_right)*CLHEP::cm / 2.0),
519 rightMidTube, (boost::format("physicalCDCLayer_%1%_rightMidTube") % iSLayer).str().c_str(), m_logicalCDC, false, iSLayer);
520
521 // Reset zback_sensitive_middle
522 zfor_sensitive_middle = zfor_sensitive_right - length_feedthrough;
523 }
524
525
526 // Middle sensitive tube
527 G4Tubs* middleSensitiveTubeShape = new G4Tubs((boost::format("solidSD_CDCLayer_%1%_middle") % iSLayer).str().c_str(),
528 rmin_sensitive_middle * CLHEP::cm, rmax_sensitive_middle * CLHEP::cm,
529 (zfor_sensitive_middle - zback_sensitive_middle)*CLHEP::cm / 2.0, 0 * CLHEP::deg, 360.*CLHEP::deg);
530 G4LogicalVolume* middleSensitiveTube = new G4LogicalVolume(middleSensitiveTubeShape, cdcMedGas,
531 (boost::format("logicalSD_CDCLayer_%1%_middle") % iSLayer).str().c_str(), 0, 0, 0);
532 //hard-coded temporarily
533 //need to create an object per layer ??? to be checked later
534 G4UserLimits* uLimits = new G4UserLimits(8.5 * CLHEP::cm);
535 m_userLimits.push_back(uLimits);
536 middleSensitiveTube->SetUserLimits(uLimits);
537 middleSensitiveTube->SetSensitiveDetector(m_sensitive);
538
539 new G4PVPlacement(0, G4ThreeVector(0.0, 0.0, (zfor_sensitive_middle + zback_sensitive_middle)*CLHEP::cm / 2.0), middleSensitiveTube,
540 (boost::format("physicalSD_CDCLayer_%1%_middle") % iSLayer).str().c_str(), m_logicalCDC, false, iSLayer);
541
542 // if (cdcgp.getMaterialDefinitionMode() == 2) {
543 if (gcp.getMaterialDefinitionMode() == 2) {
544 G4String sName = "sWire";
545 const G4int jc = 0;
546 B2Vector3D wb0 = cdcgp.wireBackwardPosition(iSLayer, jc);
547 // G4double rsense0 = wb0.Perp();
548 B2Vector3D wf0 = cdcgp.wireForwardPosition(iSLayer, jc);
549 G4double tAtZ0 = -wb0.Z() / (wf0.Z() - wb0.Z()); //t: param. along the wire
550 B2Vector3D wAtZ0 = wb0 + tAtZ0 * (wf0 - wb0);
551 //additional chop of wire; must be larger than 126um*(1/10), where 126um is the field wire diameter; 1/10: approx. stereo angle
552 const G4double epsl = 25.e-4; // (in cm);
553 G4double reductionBwd = (zback_sensitive_middle + epsl) / wb0.Z();
554 //chop the wire at zback_sensitive_middle for avoiding overlap; this is because the wire length defined by wb0 and wf0 is larger than the length of middle sensitive tube
555 wb0 = reductionBwd * (wb0 - wAtZ0) + wAtZ0;
556 //chop wire at zfor_sensitive_middle for avoiding overlap
557 G4double reductionFwd = (zfor_sensitive_middle - epsl) / wf0.Z();
558 wf0 = reductionFwd * (wf0 - wAtZ0) + wAtZ0;
559
560 const G4double wireHalfLength = 0.5 * (wf0 - wb0).Mag() * CLHEP::cm;
561 const G4double sWireRadius = 0.5 * cdcgp.senseWireDiameter() * CLHEP::cm;
562 // const G4double sWireRadius = 15.e-4 * CLHEP::cm;
563 G4Tubs* middleSensitiveSwireShape = new G4Tubs(sName, 0., sWireRadius, wireHalfLength, 0., 360. * CLHEP::deg);
564 G4LogicalVolume* middleSensitiveSwire = new G4LogicalVolume(middleSensitiveSwireShape, medTungsten, sName);
565 // middleSensitiveSwire->SetSensitiveDetector(m_sensitive);
566 middleSensitiveSwire->SetVisAttributes(m_VisAttributes.front()); // <- to speed up visualization
567
568 G4String fName = "fWire";
569 const G4double fWireRadius = 0.5 * cdcgp.fieldWireDiameter() * CLHEP::cm;
570 G4Tubs* middleSensitiveFwireShape = new G4Tubs(fName, 0., fWireRadius, wireHalfLength, 0., 360. * CLHEP::deg);
571 G4LogicalVolume* middleSensitiveFwire = new G4LogicalVolume(middleSensitiveFwireShape, medAluminum, fName);
572 // middleSensitiveFwire->SetSensitiveDetector(m_sensitive);
573 middleSensitiveFwire->SetVisAttributes(m_VisAttributes.front()); // <- to speed up visualization
574
575 const G4double diameter = cdcgp.fieldWireDiameter();
576
577 const G4int nCells = cdcgp.nWiresInLayer(iSLayer);
578 const G4double dphi = M_PI / nCells;
579 const B2Vector3D unitZ(0., 0., 1.);
580
581 for (int ic = 0; ic < nCells; ++ic) {
582 //define sense wire
583 B2Vector3D wb = cdcgp.wireBackwardPosition(iSLayer, ic);
584 B2Vector3D wf = cdcgp.wireForwardPosition(iSLayer, ic);
585 G4double tAtZ02 = -wb.Z() / (wf.Z() - wb.Z());
586 B2Vector3D wAtZ02 = wb + tAtZ02 * (wf - wb);
587 G4double reductionBwd2 = (zback_sensitive_middle + epsl) / wb.Z();
588 wb = reductionBwd2 * (wb - wAtZ02) + wAtZ02;
589 G4double reductionFwd2 = (zfor_sensitive_middle - epsl) / wf.Z();
590 wf = reductionFwd2 * (wf - wAtZ02) + wAtZ02;
591
592 G4double thetaYZ = -asin((wf - wb).Y() / (wf - wb).Mag());
593
594 B2Vector3D fMinusBInZX((wf - wb).X(), 0., (wf - wb).Z());
595 G4double thetaZX = asin((unitZ.Cross(fMinusBInZX)).Y() / fMinusBInZX.Mag());
596 G4RotationMatrix rotM;
597 // std::cout <<"deg,rad= " << CLHEP::deg <<" "<< CLHEP::rad << std::endl;
598 rotM.rotateX(thetaYZ * CLHEP::rad);
599 rotM.rotateY(thetaZX * CLHEP::rad);
600
601 G4ThreeVector xyz(0.5 * (wb.X() + wf.X()) * CLHEP::cm,
602 0.5 * (wb.Y() + wf.Y()) * CLHEP::cm, 0.);
603
604 // std::cout <<"0 x,y= " << xyz.getX() <<" "<< xyz.getY() << std::endl;
605 //Calling G4PVPlacement with G4Transform3D is convenient because it rotates the object instead of rotating the coordinate-frame; rotM is copied so it does not have to be created on heep by new.
606 new G4PVPlacement(G4Transform3D(rotM, xyz), middleSensitiveSwire, sName, middleSensitiveTube, false, ic);
607
608 //define field wire #1 (placed at the same phi but at the outer r boundary)
609 B2Vector3D wbF = wb;
610 G4double rF = rmax_sensitive_middle - 0.5 * diameter;
611 // std::cout <<"iSLayer,rF= " << iSLayer <<" "<< rF <<" "<< std::endl;
612 G4double phi = atan2(wbF.Y(), wbF.X());
613 wbF.SetX(rF * cos(phi));
614 wbF.SetY(rF * sin(phi));
615
616 B2Vector3D wfF = wf;
617 rF = rmax_sensitive_middle - 0.5 * diameter;
618 phi = atan2(wfF.Y(), wfF.X());
619 wfF.SetX(rF * cos(phi));
620 wfF.SetY(rF * sin(phi));
621
622 thetaYZ = -asin((wfF - wbF).Y() / (wfF - wbF).Mag());
623
624 fMinusBInZX = wfF - wbF;
625 fMinusBInZX.SetY(0.);
626 thetaZX = asin((unitZ.Cross(fMinusBInZX)).Y() / fMinusBInZX.Mag());
627
628 G4RotationMatrix rotM1;
629 rotM1.rotateX(thetaYZ * CLHEP::rad);
630 rotM1.rotateY(thetaZX * CLHEP::rad);
631
632 xyz.setX(0.5 * (wbF.X() + wfF.X()) * CLHEP::cm);
633 xyz.setY(0.5 * (wbF.Y() + wfF.Y()) * CLHEP::cm);
634
635 if (iSLayer != nSLayer - 1) {
636 // std::cout <<"1 x,y= " << xyz.getX() <<" "<< xyz.getY() << std::endl;
637 new G4PVPlacement(G4Transform3D(rotM1, xyz), middleSensitiveFwire, fName, middleSensitiveTube, false, ic);
638 }
639
640 //define field wire #2 (placed at the same radius but shifted by dphi)
641 wbF = wb;
642 rF = wbF.Perp();
643 phi = atan2(wbF.Y(), wbF.X());
644 wbF.SetX(rF * cos(phi + dphi));
645 wbF.SetY(rF * sin(phi + dphi));
646
647 wfF = wf;
648 rF = wfF.Perp();
649 phi = atan2(wfF.Y(), wfF.X());
650 wfF.SetX(rF * cos(phi + dphi));
651 wfF.SetY(rF * sin(phi + dphi));
652
653 thetaYZ = -asin((wfF - wbF).Y() / (wfF - wbF).Mag());
654
655 fMinusBInZX = wfF - wbF;
656 fMinusBInZX.SetY(0.);
657 thetaZX = asin((unitZ.Cross(fMinusBInZX)).Y() / fMinusBInZX.Mag());
658
659 G4RotationMatrix rotM2;
660 rotM2.rotateX(thetaYZ * CLHEP::rad);
661 rotM2.rotateY(thetaZX * CLHEP::rad);
662
663 xyz.setX(0.5 * (wbF.X() + wfF.X()) * CLHEP::cm);
664 xyz.setY(0.5 * (wbF.Y() + wfF.Y()) * CLHEP::cm);
665
666 // std::cout <<"2 x,y= " << xyz.getX() <<" "<< xyz.getY() << std::endl;
667 new G4PVPlacement(G4Transform3D(rotM2, xyz), middleSensitiveFwire, fName, middleSensitiveTube, false, ic + nCells);
668
669 //define field wire #3 (placed at the cell corner)
670 wbF = wb;
671 rF = rmax_sensitive_middle - 0.5 * diameter;
672 phi = atan2(wbF.Y(), wbF.X());
673 wbF.SetX(rF * cos(phi + dphi));
674 wbF.SetY(rF * sin(phi + dphi));
675
676 wfF = wf;
677 rF = rmax_sensitive_middle - 0.5 * diameter;
678 phi = atan2(wfF.Y(), wfF.X());
679 wfF.SetX(rF * cos(phi + dphi));
680 wfF.SetY(rF * sin(phi + dphi));
681
682 thetaYZ = -asin((wfF - wbF).Y() / (wfF - wbF).Mag());
683
684 fMinusBInZX = wfF - wbF;
685 fMinusBInZX.SetY(0.);
686 thetaZX = asin((unitZ.Cross(fMinusBInZX)).Y() / fMinusBInZX.Mag());
687
688 G4RotationMatrix rotM3;
689 rotM3.rotateX(thetaYZ * CLHEP::rad);
690 rotM3.rotateY(thetaZX * CLHEP::rad);
691
692 xyz.setX(0.5 * (wbF.X() + wfF.X()) * CLHEP::cm);
693 xyz.setY(0.5 * (wbF.Y() + wfF.Y()) * CLHEP::cm);
694
695 if (iSLayer != nSLayer - 1) {
696 new G4PVPlacement(G4Transform3D(rotM3, xyz), middleSensitiveFwire, fName, middleSensitiveTube, false, ic + 2 * nCells);
697 }
698 } // end of wire loop
699 } // end of wire definitions
700
701 }
702 //
703 // Endplates.
704 //
705
706 m_VisAttributes.push_back(new G4VisAttributes(true, G4Colour(1., 1., 0.)));
707 for (const auto& endplate : geo.getEndPlates()) {
708 for (const auto& epLayer : endplate.getEndPlateLayers()) {
709 const int iEPLayer = epLayer.getILayer();
710 const string name = epLayer.getName();
711 const double rmin = epLayer.getRmin();
712 const double rmax = epLayer.getRmax();
713 const double zbwd = epLayer.getZbwd();
714 const double zfwd = epLayer.getZfwd();
715 const double length = (zfwd - zbwd) / 2.0;
716
717 G4Tubs* tube = new G4Tubs("solidCDCEndplate" + name, rmin * CLHEP::cm,
718 rmax * CLHEP::cm, length * CLHEP::cm, 0 * CLHEP::deg, 360.*CLHEP::deg);
719 G4LogicalVolume* logical = new G4LogicalVolume(tube, Materials::get("G4_Al"),
720 "logicalCDCEndplate" + name, 0, 0);
721 logical->SetVisAttributes(m_VisAttributes.back());
722 new G4PVPlacement(0, G4ThreeVector(0.0, 0.0, (zfwd + zbwd)*CLHEP::cm / 2.0), logical,
723 "physicalCDCEndplate" + name, m_logicalCDC, false, iEPLayer);
724
725 }
726 }
727
728
729 // Construct electronics boards
730 for (const auto& frontend : geo.getFrontends()) {
731
732 const int iEB = frontend.getId();
733 const double ebInnerR = frontend.getRmin();
734 const double ebOuterR = frontend.getRmax();
735 const double ebBZ = frontend.getZbwd();
736 const double ebFZ = frontend.getZfwd();
737
738 G4Tubs* ebTubeShape = new G4Tubs((boost::format("solidSD_ElectronicsBoard_Layer%1%") % iEB).str().c_str(), ebInnerR * CLHEP::cm,
739 ebOuterR * CLHEP::cm, (ebFZ - ebBZ)*CLHEP::cm / 2.0, 0 * CLHEP::deg, 360.*CLHEP::deg);
740
741 G4LogicalVolume* ebTube = new G4LogicalVolume(ebTubeShape, medNEMA_G10_Plate,
742 (boost::format("logicalSD_ElectronicsBoard_Layer%1%") % iEB).str().c_str(), 0, 0, 0);
743 if (!m_bkgsensitive) m_bkgsensitive = new BkgSensitiveDetector("CDC", iEB);
744 ebTube->SetSensitiveDetector(m_bkgsensitive);
745 ebTube->SetVisAttributes(m_VisAttributes.back());
746 new G4PVPlacement(0, G4ThreeVector(0.0, 0.0, (ebFZ + ebBZ)*CLHEP::cm / 2.0), ebTube,
747 (boost::format("physicalSD_ElectronicsBoard_Layer%1%") % iEB).str().c_str(), m_logicalCDC, false, iEB);
748 }
749
750 //
751 // Construct neutron shield.
752 //
754
755 //
756 // construct covers.
757 //
758 createCovers(geo);
759
760 //
761 // construct covers.
762 //
763 createCover2s(geo);
764
765 //
766 // Construct ribs.
767 //
768 for (const auto& rib : geo.getRibs()) {
769
770 const int id = rib.getId();
771 const double length = rib.getLength();
772 const double width = rib.getWidth();
773 const double thick = rib.getThick();
774 const double rotx = rib.getRotX();
775 const double roty = rib.getRotY();
776 const double rotz = rib.getRotZ();
777 const double x = rib.getX();
778 const double y = rib.getY();
779 const double z = rib.getZ();
780 const int offset = rib.getOffset();
781 const int ndiv = rib.getNDiv();
782
783 const string solidName = "solidRib" + to_string(id);
784 const string logicalName = "logicalRib" + to_string(id);
785 G4Box* boxShape = new G4Box(solidName, 0.5 * length * CLHEP::cm,
786 0.5 * width * CLHEP::cm,
787 0.5 * thick * CLHEP::cm);
788
789 const double rmax = 0.5 * length;
790 const double rmin = max((rmax - thick), 0.);
791 G4Tubs* tubeShape = new G4Tubs(solidName,
792 rmin * CLHEP::cm,
793 rmax * CLHEP::cm,
794 0.5 * width * CLHEP::cm,
795 0.,
796 360. * CLHEP::deg);
797
798 //G4LogicalVolume* logicalV = new G4LogicalVolume(boxShape, medAluminum,
799 // logicalName, 0, 0, 0);
800 // ID dependent material definition, Aluminum is default
801 G4LogicalVolume* logicalV = new G4LogicalVolume(boxShape, medAluminum, logicalName, 0, 0, 0);
802 if (id > 39 && id < 78) // Cu
803 logicalV = new G4LogicalVolume(boxShape, medCopper, logicalName, 0, 0, 0);
804 if ((id > 77 && id < 94) || (id > 131 && id < 146)) // G10
805 logicalV = new G4LogicalVolume(boxShape, medNEMA_G10_Plate, logicalName, 0, 0, 0);
806 if (id > 93 && id < 110) // Cu
807 logicalV = new G4LogicalVolume(tubeShape, medCopper, logicalName, 0, 0, 0);
808 if (id > 109 && id < 126) // H2O
809 logicalV = new G4LogicalVolume(tubeShape, medH2O, logicalName, 0, 0, 0);
810 if (id > 127 && id < 132) // HV
811 logicalV = new G4LogicalVolume(boxShape, medHV, logicalName, 0, 0, 0);
812 /*if( id > 145 && id < 149 )// Fiber
813 logicalV = new G4LogicalVolume(boxShape, medFiber, logicalName, 0, 0, 0);
814 if( id > 148 && id < 158 )// Fiber
815 logicalV = new G4LogicalVolume(boxShape, medCAT7, logicalName, 0, 0, 0);
816 if( id > 157 && id < 164 )// Fiber
817 logicalV = new G4LogicalVolume(boxShape, medTRG, logicalName, 0, 0, 0);*/
818
819 logicalV->SetVisAttributes(m_VisAttributes.back());
820
821 const double phi = 360.0 / ndiv;
822
823 G4RotationMatrix rot = G4RotationMatrix();
824 double dz = thick;
825 if (id > 93 && id < 126) dz = 0;
826
827 G4ThreeVector arm(x * CLHEP::cm, y * CLHEP::cm, z * CLHEP::cm - dz * CLHEP::cm / 2.0);
828 rot.rotateX(rotx);
829 rot.rotateY(roty);
830 rot.rotateZ(rotz);
831 if (offset) {
832 rot.rotateZ(0.5 * phi * CLHEP::deg);
833 arm.rotateZ(0.5 * phi * CLHEP::deg);
834 }
835 for (int i = 0; i < ndiv; ++i) {
836 const string physicalName = "physicalRib_" + to_string(id) + " " + to_string(i);
837 new G4PVPlacement(G4Transform3D(rot, arm), logicalV,
838 physicalName.c_str(), m_logicalCDC, false, id);
839 rot.rotateZ(phi * CLHEP::deg);
840 arm.rotateZ(phi * CLHEP::deg);
841 }
842
843 }
844
845 //
846 // Construct rib2s.
847 //
848 for (const auto& rib2 : geo.getRib2s()) {
849
850 const int id = rib2.getId();
851 const double length = rib2.getLength();
852 const double width = rib2.getWidth();
853 const double thick = rib2.getThick();
854 const double width2 = rib2.getWidth2();
855 const double thick2 = rib2.getThick2();
856 const double rotx = rib2.getRotX();
857 const double roty = rib2.getRotY();
858 const double rotz = rib2.getRotZ();
859 const double x = rib2.getX();
860 const double y = rib2.getY();
861 const double z = rib2.getZ();
862 const int ndiv = rib2.getNDiv();
863
864 const string solidName = "solidRib2" + to_string(id);
865 const string logicalName = "logicalRib2" + to_string(id);
866 G4Trd* trdShape = new G4Trd(solidName,
867 0.5 * thick * CLHEP::cm,
868 0.5 * thick2 * CLHEP::cm,
869 0.5 * width * CLHEP::cm,
870 0.5 * width2 * CLHEP::cm,
871 0.5 * length * CLHEP::cm);
872
873 G4LogicalVolume* logicalV = new G4LogicalVolume(trdShape, medAluminum, logicalName, 0, 0, 0);
874
875 if (id > 0)
876 logicalV = new G4LogicalVolume(trdShape, medCopper, logicalName, 0, 0, 0);
877
878 logicalV->SetVisAttributes(m_VisAttributes.back());
879
880 const double phi = 360.0 / ndiv;
881
882 G4RotationMatrix rot = G4RotationMatrix();
883 G4ThreeVector arm(x * CLHEP::cm, y * CLHEP::cm, z * CLHEP::cm - thick * CLHEP::cm / 2.0);
884
885 rot.rotateX(rotx);
886 rot.rotateY(roty);
887 rot.rotateZ(rotz);
888 for (int i = 0; i < ndiv; ++i) {
889 const string physicalName = "physicalRib2_" + to_string(id) + " " + to_string(i);
890 new G4PVPlacement(G4Transform3D(rot, arm), logicalV,
891 physicalName.c_str(), m_logicalCDC, false, id);
892 rot.rotateZ(phi * CLHEP::deg);
893 arm.rotateZ(phi * CLHEP::deg);
894 }
895
896 }
897
898 //
899 // Construct rib3s.
900 //
901 for (const auto& rib3 : geo.getRib3s()) {
902
903 const int id = rib3.getId();
904 const double length = rib3.getLength();
905 const double width = rib3.getWidth();
906 const double thick = rib3.getThick();
907 const double r = rib3.getR();
908 const double x = rib3.getX();
909 const double y = rib3.getY();
910 const double z = rib3.getZ();
911 const double rx = rib3.getRx();
912 const double ry = rib3.getRy();
913 const double rz = rib3.getRz();
914 const int offset = rib3.getOffset();
915 const int ndiv = rib3.getNDiv();
916
917 const string logicalName = "logicalRib3" + to_string(id);
918 G4VSolid* boxShape = new G4Box("Block",
919 0.5 * length * CLHEP::cm,
920 0.5 * width * CLHEP::cm,
921 0.5 * thick * CLHEP::cm);
922 G4VSolid* tubeShape = new G4Tubs("Hole",
923 0.,
924 r * CLHEP::cm,
925 width * CLHEP::cm,
926 0. * CLHEP::deg,
927 360. * CLHEP::deg);
928
929 G4RotationMatrix rotsub = G4RotationMatrix();
930 rotsub.rotateX(90. * CLHEP::deg);
931 G4ThreeVector trnsub(rx * CLHEP::cm - x * CLHEP::cm, ry * CLHEP::cm - y * CLHEP::cm,
932 rz * CLHEP::cm - z * CLHEP::cm + 0.5 * thick * CLHEP::cm);
933 G4VSolid* coolingBlock = new G4SubtractionSolid("Block-Hole",
934 boxShape,
935 tubeShape,
936 G4Transform3D(rotsub,
937 trnsub));
938
939 G4LogicalVolume* logicalV = new G4LogicalVolume(coolingBlock, medCopper, logicalName, 0, 0, 0);
940
941 logicalV->SetVisAttributes(m_VisAttributes.back());
942
943 const double phi = 360.0 / ndiv;
944
945 G4RotationMatrix rot = G4RotationMatrix();
946 G4ThreeVector arm(x * CLHEP::cm, y * CLHEP::cm, z * CLHEP::cm - thick * CLHEP::cm / 2.0);
947
948 if (offset) {
949 rot.rotateZ(0.5 * phi * CLHEP::deg);
950 arm.rotateZ(0.5 * phi * CLHEP::deg);
951 }
952 for (int i = 0; i < ndiv; ++i) {
953 const string physicalName = "physicalRib3_" + to_string(id) + " " + to_string(i);
954 new G4PVPlacement(G4Transform3D(rot, arm), logicalV,
955 physicalName.c_str(), m_logicalCDC, false, id);
956 rot.rotateZ(phi * CLHEP::deg);
957 arm.rotateZ(phi * CLHEP::deg);
958 }
959
960 }
961
962 //
963 // Construct rib4s.
964 //
965 for (const auto& rib4 : geo.getRib4s()) {
966
967 const int id = rib4.getId();
968 const double length = rib4.getLength();
969 const double width = rib4.getWidth();
970 const double thick = rib4.getThick();
971 const double length2 = rib4.getLength2();
972 const double width2 = rib4.getWidth2();
973 const double thick2 = rib4.getThick2();
974 const double x = rib4.getX();
975 const double y = rib4.getY();
976 const double z = rib4.getZ();
977 const double x2 = rib4.getX2();
978 const double y2 = rib4.getY2();
979 const double z2 = rib4.getZ2();
980 const int offset = rib4.getOffset();
981 const int ndiv = rib4.getNDiv();
982
983 const string logicalName = "logicalRib4" + to_string(id);
984 G4VSolid* baseShape = new G4Box("Base",
985 0.5 * length * CLHEP::cm,
986 0.5 * width * CLHEP::cm,
987 0.5 * thick * CLHEP::cm);
988 G4VSolid* sqShape = new G4Box("Sq",
989 0.5 * length2 * CLHEP::cm,
990 0.5 * width2 * CLHEP::cm,
991 0.5 * thick2 * CLHEP::cm);
992
993 G4RotationMatrix rotsub = G4RotationMatrix();
994 double dzc = (z2 - thick2 / 2.) - (z - thick / 2.);
995 G4ThreeVector trnsub(x2 * CLHEP::cm - x * CLHEP::cm,
996 y2 * CLHEP::cm - y * CLHEP::cm,
997 dzc * CLHEP::cm);
998 G4VSolid* sqHoleBase = new G4SubtractionSolid("Box-Sq",
999 baseShape,
1000 sqShape,
1001 G4Transform3D(rotsub,
1002 trnsub)
1003 );
1004
1005 G4LogicalVolume* logicalV = new G4LogicalVolume(sqHoleBase, medCopper, logicalName, 0, 0, 0);
1006 if (id < 19) {
1007 logicalV = new G4LogicalVolume(sqHoleBase, medNEMA_G10_Plate, logicalName, 0, 0, 0);
1008 logicalV->SetSensitiveDetector(new BkgSensitiveDetector("CDC", 2000 + id));
1009 }
1010
1011 logicalV->SetVisAttributes(m_VisAttributes.back());
1012
1013 const double phi = 360.0 / ndiv;
1014
1015 G4RotationMatrix rot = G4RotationMatrix();
1016 G4ThreeVector arm(x * CLHEP::cm, y * CLHEP::cm, z * CLHEP::cm - thick * CLHEP::cm / 2.0);
1017
1018 if (offset) {
1019 rot.rotateZ(0.5 * phi * CLHEP::deg);
1020 arm.rotateZ(0.5 * phi * CLHEP::deg);
1021 }
1022 for (int i = 0; i < ndiv; ++i) {
1023 const string physicalName = "physicalRib4_" + to_string(id) + " " + to_string(i);
1024 new G4PVPlacement(G4Transform3D(rot, arm), logicalV,
1025 physicalName.c_str(), m_logicalCDC, false, id);
1026 rot.rotateZ(phi * CLHEP::deg);
1027 arm.rotateZ(phi * CLHEP::deg);
1028 }
1029
1030 }
1031 //
1032 // Construct rib5s.
1033 //
1034 for (const auto& rib5 : geo.getRib5s()) {
1035
1036 const int id = rib5.getId();
1037 const double dr = rib5.getDr();
1038 const double dz = rib5.getDz();
1039 const double width = rib5.getWidth();
1040 const double thick = rib5.getThick();
1041 const double rin = rib5.getRin();
1042 const double x = rib5.getX();
1043 const double y = rib5.getY();
1044 const double z = rib5.getZ();
1045 const double rotx = rib5.getRotx();
1046 const double roty = rib5.getRoty();
1047 const double rotz = rib5.getRotz();
1048 const int offset = rib5.getOffset();
1049 const int ndiv = rib5.getNDiv();
1050
1051 const string solidName = "solidRib5" + to_string(id);
1052 const string logicalName = "logicalRib5" + to_string(id);
1053
1054 const double rmax = rin + thick;
1055 const double rmin = rin;
1056 const double dphi = 2. * atan2(dz, dr);
1057 const double ddphi = thick * tan(dphi) / rin;
1058 const double ddphi2 = width / 2. * width / 2. / (x + dr) / rin;
1059 const double cphi = dphi - ddphi - ddphi2;
1060 G4Tubs* tubeShape = new G4Tubs(solidName,
1061 rmin * CLHEP::cm,
1062 rmax * CLHEP::cm,
1063 0.5 * width * CLHEP::cm,
1064 0.,
1065 cphi);
1066
1067 G4LogicalVolume* logicalV = new G4LogicalVolume(tubeShape, medAluminum, logicalName, 0, 0, 0);
1068
1069 logicalV->SetVisAttributes(m_VisAttributes.back());
1070
1071 const double phi = 360.0 / ndiv;
1072
1073 G4RotationMatrix rot = G4RotationMatrix();
1074
1075 //G4ThreeVector arm(x * CLHEP::cm, y * CLHEP::cm, z * CLHEP::cm - thick * CLHEP::cm / 2.0);
1076 G4ThreeVector arm(x * CLHEP::cm, y * CLHEP::cm, z * CLHEP::cm - rin * CLHEP::cm - thick * CLHEP::cm);
1077 rot.rotateX(rotx);
1078 rot.rotateY(roty);
1079 rot.rotateZ(rotz);
1080 if (offset) {
1081 rot.rotateZ(0.5 * phi * CLHEP::deg);
1082 arm.rotateZ(0.5 * phi * CLHEP::deg);
1083 }
1084 for (int i = 0; i < ndiv; ++i) {
1085 const string physicalName = "physicalRib5_" + to_string(id) + " " + to_string(i);
1086 new G4PVPlacement(G4Transform3D(rot, arm), logicalV,
1087 physicalName.c_str(), m_logicalCDC, false, id);
1088 rot.rotateZ(phi * CLHEP::deg);
1089 arm.rotateZ(phi * CLHEP::deg);
1090 }
1091
1092 }
1093
1094 //Create B-field mapper (here tentatively)
1095 createMapper(topVolume);
1096 }
1097
1098
1100 {
1101
1102 G4Material* C2H4 = geometry::Materials::get("G4_POLYETHYLENE");
1103 G4Material* elB = geometry::Materials::get("G4_B");
1104
1105 // 5% borated polyethylene = SWX201
1106 // http://www.deqtech.com/Shieldwerx/Products/swx201hd.htm
1107 G4Material* boratedpoly05 = new G4Material("BoratedPoly05", 1.06 * CLHEP::g / CLHEP::cm3, 2);
1108 boratedpoly05->AddMaterial(elB, 0.05);
1109 boratedpoly05->AddMaterial(C2H4, 0.95);
1110 // 30% borated polyethylene = SWX210
1111 G4Material* boratedpoly30 = new G4Material("BoratedPoly30", 1.19 * CLHEP::g / CLHEP::cm3, 2);
1112 boratedpoly30->AddMaterial(elB, 0.30);
1113 boratedpoly30->AddMaterial(C2H4, 0.70);
1114
1115 G4Material* shieldMat = C2H4;
1116
1117 const int nShields = content.getNumberNodes("Shields/Shield");
1118
1119 for (int iShield = 0; iShield < nShields; ++iShield) {
1120 GearDir shieldContent(content);
1121 shieldContent.append((boost::format("/Shields/Shield[%1%]/") % (iShield + 1)).str());
1122 const string sShieldID = shieldContent.getString("@id");
1123 const int shieldID = atoi(sShieldID.c_str());
1124 // const string shieldName = shieldContent.getString("Name");
1125 const double shieldInnerR1 = shieldContent.getLength("InnerR1");
1126 const double shieldInnerR2 = shieldContent.getLength("InnerR2");
1127 const double shieldOuterR1 = shieldContent.getLength("OuterR1");
1128 const double shieldOuterR2 = shieldContent.getLength("OuterR2");
1129 const double shieldThick = shieldContent.getLength("Thickness");
1130 const double shieldPosZ = shieldContent.getLength("PosZ");
1131
1132 G4Cons* shieldConsShape = new G4Cons((boost::format("solidShield%1%") % shieldID).str().c_str(),
1133 shieldInnerR1 * CLHEP::cm, shieldOuterR1 * CLHEP::cm,
1134 shieldInnerR2 * CLHEP::cm, shieldOuterR2 * CLHEP::cm,
1135 shieldThick * CLHEP::cm / 2.0,
1136 0.*CLHEP::deg, 360.*CLHEP::deg);
1137
1138 G4LogicalVolume* shieldCons = new G4LogicalVolume(shieldConsShape, shieldMat,
1139 (boost::format("logicalShield%1%") % shieldID).str().c_str(),
1140 0, 0, 0);
1141 shieldCons->SetVisAttributes(m_VisAttributes.back());
1142 new G4PVPlacement(0, G4ThreeVector(0.0, 0.0, (shieldPosZ - shieldThick / 2.0) * CLHEP::cm), shieldCons,
1143 (boost::format("physicalShield%1%") % shieldID).str().c_str(), m_logicalCDC, false, 0);
1144
1145 }
1146
1147 }
1148
1149
1151 {
1152
1153 G4Material* C2H4 = geometry::Materials::get("G4_POLYETHYLENE");
1154 G4Material* shieldMat = C2H4;
1155
1156 for (const auto& shield : geom.getNeutronShields()) {
1157 const int shieldID = shield.getId();
1158 const double shieldInnerR1 = shield.getRmin1();
1159 const double shieldInnerR2 = shield.getRmin2();
1160 const double shieldOuterR1 = shield.getRmax1();
1161 const double shieldOuterR2 = shield.getRmax2();
1162 const double shieldThick = shield.getThick();
1163 const double shieldPosZ = shield.getZ();
1164
1165 G4Cons* shieldConsShape = new G4Cons("solidShield" + to_string(shieldID),
1166 shieldInnerR1 * CLHEP::cm, shieldOuterR1 * CLHEP::cm,
1167 shieldInnerR2 * CLHEP::cm, shieldOuterR2 * CLHEP::cm,
1168 shieldThick * CLHEP::cm / 2.0,
1169 0.*CLHEP::deg, 360.*CLHEP::deg);
1170
1171 G4LogicalVolume* shieldCons = new G4LogicalVolume(shieldConsShape, shieldMat, "logicalShield" + to_string(shieldID),
1172 0, 0, 0);
1173 shieldCons->SetVisAttributes(m_VisAttributes.back());
1174 new G4PVPlacement(0, G4ThreeVector(0.0, 0.0, (shieldPosZ - shieldThick / 2.0) * CLHEP::cm), shieldCons,
1175 "physicalShield" + to_string(shieldID), m_logicalCDC, false, 0);
1176
1177 }
1178
1179 }
1180
1182 {
1183 string Aluminum = content.getString("Aluminum");
1184 G4Material* medAluminum = geometry::Materials::get(Aluminum);
1185 G4Material* medNEMA_G10_Plate = geometry::Materials::get("NEMA_G10_Plate");
1186 G4double density = 1.000 * CLHEP::g / CLHEP::cm3;
1187 G4double a = 1.01 * CLHEP::g / CLHEP::mole;
1188 G4Element* elH = new G4Element("Hydrogen", "H", 1., a);
1189 a = 16.00 * CLHEP::g / CLHEP::mole;
1190 G4Element* elO = new G4Element("Oxygen", "O", 8., a);
1191 G4Material* medH2O = new G4Material("Water", density, 2);
1192 medH2O->AddElement(elH, 2);
1193 medH2O->AddElement(elO, 1);
1194 G4Material* medCopper = geometry::Materials::get("Cu");
1195 G4Material* medLV = geometry::Materials::get("CDCLVCable");
1196 G4Material* medFiber = geometry::Materials::get("CDCOpticalFiber");
1197 G4Material* medCAT7 = geometry::Materials::get("CDCCAT7");
1198 G4Material* medTRG = geometry::Materials::get("CDCOpticalFiberTRG");
1199 G4Material* medHV = geometry::Materials::get("CDCHVCable");
1200
1201 m_VisAttributes.push_back(new G4VisAttributes(true, G4Colour(0., 1., 0.)));
1202 const int nCover = content.getNumberNodes("Covers/Cover");
1203 for (int iCover = 0; iCover < nCover; ++iCover) {
1204 GearDir coverContent(content);
1205 coverContent.append((boost::format("/Covers/Cover[%1%]/") % (iCover + 1)).str());
1206 const string scoverID = coverContent.getString("@id");
1207 const int coverID = atoi(scoverID.c_str());
1208 const string coverName = coverContent.getString("Name");
1209 const double coverInnerR1 = coverContent.getLength("InnerR1");
1210 const double coverInnerR2 = coverContent.getLength("InnerR2");
1211 const double coverOuterR1 = coverContent.getLength("OuterR1");
1212 const double coverOuterR2 = coverContent.getLength("OuterR2");
1213 const double coverThick = coverContent.getLength("Thickness");
1214 const double coverPosZ = coverContent.getLength("PosZ");
1215
1216 const double rmin1 = coverInnerR1;
1217 const double rmax1 = coverOuterR1;
1218 const double rmin2 = coverInnerR2;
1219 const double rmax2 = coverOuterR2;
1220
1221 /*
1222 if (coverID == 7 || coverID == 10) {
1223 createCone(rmin1, rmax1, rmin2, rmax2, coverThick, coverPosZ, coverID, medAluminum, coverName);
1224 } else {
1225 createTube(rmin1, rmax1, coverThick, coverPosZ, coverID, medAluminum, coverName);
1226
1227 }*/
1228 // ID dependent material definition
1229 if (coverID < 23) {
1230 if (coverID == 7 || coverID == 10) {// cones
1231 createCone(rmin1, rmax1, rmin2, rmax2, coverThick, coverPosZ, coverID, medAluminum, coverName);
1232 } else {// covers
1233 createTube(rmin1, rmax1, coverThick, coverPosZ, coverID, medAluminum, coverName);
1234 }
1235 }
1236 if (coverID > 22 && coverID < 29)// cooling plate
1237 createTube(rmin1, rmax1, coverThick, coverPosZ, coverID, medCopper, coverName);
1238 if (coverID > 28 && coverID < 35)// cooling Pipe
1239 createTorus(rmin1, rmax1, coverThick, coverPosZ, coverID, medCopper, coverName);
1240 if (coverID > 34 && coverID < 41)// cooling water
1241 createTorus(rmin1, rmax1, coverThick, coverPosZ, coverID, medH2O, coverName);
1242 if (coverID == 45 || coverID == 46)
1243 createTube(rmin1, rmax1, coverThick, coverPosZ, coverID, medLV, coverName);
1244 if (coverID == 47 || coverID == 48)
1245 createTube(rmin1, rmax1, coverThick, coverPosZ, coverID, medFiber, coverName);
1246 if (coverID == 49 || coverID == 50)
1247 createTube(rmin1, rmax1, coverThick, coverPosZ, coverID, medCAT7, coverName);
1248 if (coverID == 51 || coverID == 52)
1249 createTube(rmin1, rmax1, coverThick, coverPosZ, coverID, medTRG, coverName);
1250 if (coverID == 53)
1251 createTube(rmin1, rmax1, coverThick, coverPosZ, coverID, medHV, coverName);
1252 }
1253
1254 const int nCover2 = content.getNumberNodes("Covers/Cover2");
1255 for (int iCover2 = 0; iCover2 < nCover2; ++iCover2) {
1256 GearDir cover2Content(content);
1257 cover2Content.append((boost::format("/Cover2s/Cover2[%1%]/") % (iCover2 + 1)).str());
1258 const string scover2ID = cover2Content.getString("@id");
1259 const int cover2ID = atoi(scover2ID.c_str());
1260 const string cover2Name = cover2Content.getString("Name");
1261 const double cover2InnerR = cover2Content.getLength("InnerR");
1262 const double cover2OuterR = cover2Content.getLength("OuterR");
1263 const double cover2StartPhi = cover2Content.getLength("StartPhi");
1264 const double cover2DeltaPhi = cover2Content.getLength("DeltaPhi");
1265 const double cover2Thick = cover2Content.getLength("Thickness");
1266 const double cover2PosZ = cover2Content.getLength("PosZ");
1267
1268 if (cover2ID < 11)
1269 createTube2(cover2InnerR, cover2OuterR, cover2StartPhi, cover2DeltaPhi, cover2Thick, cover2PosZ, cover2ID, medHV, cover2Name);
1270 if (cover2ID > 10 && cover2ID < 14)
1271 createTube2(cover2InnerR, cover2OuterR, cover2StartPhi, cover2DeltaPhi, cover2Thick, cover2PosZ, cover2ID, medFiber, cover2Name);
1272 if (cover2ID > 13 && cover2ID < 23)
1273 createTube2(cover2InnerR, cover2OuterR, cover2StartPhi, cover2DeltaPhi, cover2Thick, cover2PosZ, cover2ID, medCAT7, cover2Name);
1274 if (cover2ID > 22 && cover2ID < 29)
1275 createTube2(cover2InnerR, cover2OuterR, cover2StartPhi, cover2DeltaPhi, cover2Thick, cover2PosZ, cover2ID, medTRG, cover2Name);
1276 }
1277
1278 const int nRibs = content.getNumberNodes("Covers/Rib");
1279 for (int iRib = 0; iRib < nRibs; ++iRib) {
1280 GearDir ribContent(content);
1281 ribContent.append((boost::format("/Covers/Rib[%1%]/") % (iRib + 1)).str());
1282 const string sribID = ribContent.getString("@id");
1283 const int ribID = atoi(sribID.c_str());
1284 // const string ribName = ribContent.getString("Name");
1285 const double length = ribContent.getLength("Length");
1286 const double width = ribContent.getLength("Width");
1287 const double thick = ribContent.getLength("Thickness");
1288 const double rotX = ribContent.getLength("RotX");
1289 const double rotY = ribContent.getLength("RotY");
1290 const double rotZ = ribContent.getLength("RotZ");
1291 const double cX = ribContent.getLength("PosX");
1292 const double cY = ribContent.getLength("PosY");
1293 const double cZ = ribContent.getLength("PosZ");
1294 const int offset = atoi((ribContent.getString("Offset")).c_str());
1295 const int number = atoi((ribContent.getString("NDiv")).c_str());
1296
1297 const string solidName = "solidRib" + to_string(ribID);
1298 const string logicalName = "logicalRib" + to_string(ribID);
1299 G4Box* boxShape = new G4Box(solidName, 0.5 * length * CLHEP::cm,
1300 0.5 * width * CLHEP::cm,
1301 0.5 * thick * CLHEP::cm);
1302 const double rmax = 0.5 * length;
1303 const double rmin = max((rmax - thick), 0.);
1304 G4Tubs* tubeShape = new G4Tubs(solidName,
1305 rmin * CLHEP::cm,
1306 rmax * CLHEP::cm,
1307 0.5 * width * CLHEP::cm,
1308 0.,
1309 360. * CLHEP::deg);
1310
1311 //G4LogicalVolume* logicalV = new G4LogicalVolume(boxShape, medAluminum,
1312 // logicalName, 0, 0, 0);
1313 // ID dependent material definition Aluminum is default
1314 G4LogicalVolume* logicalV = new G4LogicalVolume(boxShape, medAluminum, logicalName, 0, 0, 0);
1315 if (ribID > 39 && ribID < 78) // Cu box
1316 logicalV = new G4LogicalVolume(boxShape, medCopper, logicalName, 0, 0, 0);
1317 if ((ribID > 77 && ribID < 94) || (ribID > 131 && ribID < 146)) // G10 box
1318 logicalV = new G4LogicalVolume(boxShape, medNEMA_G10_Plate, logicalName, 0, 0, 0);
1319 if (ribID > 93 && ribID < 110) // Cu tube
1320 logicalV = new G4LogicalVolume(tubeShape, medCopper, logicalName, 0, 0, 0);
1321 if (ribID > 109 && ribID < 126) // H2O tube (rmin = 0)
1322 logicalV = new G4LogicalVolume(tubeShape, medH2O, logicalName, 0, 0, 0);
1323 if (ribID > 127 && ribID < 132) // HV bundle
1324 logicalV = new G4LogicalVolume(boxShape, medHV, logicalName, 0, 0, 0);
1325 /*if( ribID > 145 && ribID < 149 )// Fiber box
1326 logicalV = new G4LogicalVolume(boxShape, medFiber, logicalName, 0, 0, 0);
1327 if( ribID > 148 && ribID < 158 )// Fiber box
1328 logicalV = new G4LogicalVolume(boxShape, medCAT7, logicalName, 0, 0, 0);
1329 if( ribID > 157 && ribID < 164 )// Fiber box
1330 logicalV = new G4LogicalVolume(boxShape, medTRG, logicalName, 0, 0, 0);*/
1331
1332 logicalV->SetVisAttributes(m_VisAttributes.back());
1333
1334 const double phi = 360.0 / number;
1335
1336 G4RotationMatrix rot = G4RotationMatrix();
1337
1338 double dz = thick;
1339 if (ribID > 93 && ribID < 126) dz = 0;
1340 G4ThreeVector arm(cX * CLHEP::cm, cY * CLHEP::cm, cZ * CLHEP::cm - dz * CLHEP::cm / 2.0);
1341
1342 rot.rotateX(rotX);
1343 rot.rotateY(rotY);
1344 rot.rotateZ(rotZ);
1345 if (offset) {
1346 rot.rotateZ(0.5 * phi * CLHEP::deg);
1347 arm.rotateZ(0.5 * phi * CLHEP::deg);
1348 }
1349 for (int i = 0; i < number; ++i) {
1350 const string physicalName = "physicalRib_" + to_string(ribID) + " " + to_string(i);
1351 new G4PVPlacement(G4Transform3D(rot, arm), logicalV,
1352 physicalName.c_str(), m_logicalCDC, false, ribID);
1353 rot.rotateZ(phi * CLHEP::deg);
1354 arm.rotateZ(phi * CLHEP::deg);
1355 }
1356
1357 }// rib
1358
1359 const int nRib2s = content.getNumberNodes("Covers/Rib2");
1360 for (int iRib2 = 0; iRib2 < nRib2s; ++iRib2) {
1361 GearDir rib2Content(content);
1362 rib2Content.append((boost::format("/Covers/Rib2[%1%]/") % (iRib2 + 1)).str());
1363 const string srib2ID = rib2Content.getString("@id");
1364 const int rib2ID = atoi(srib2ID.c_str());
1365 // const string rib2Name = rib2Content.getString("Name");
1366 const double length = rib2Content.getLength("Length");
1367 const double width = rib2Content.getLength("Width");
1368 const double thick = rib2Content.getLength("Thickness");
1369 const double width2 = rib2Content.getLength("Width2");
1370 const double thick2 = rib2Content.getLength("Thickness2");
1371 const double rotX = rib2Content.getLength("RotX");
1372 const double rotY = rib2Content.getLength("RotY");
1373 const double rotZ = rib2Content.getLength("RotZ");
1374 const double cX = rib2Content.getLength("PosX");
1375 const double cY = rib2Content.getLength("PosY");
1376 const double cZ = rib2Content.getLength("PosZ");
1377 const int number = atoi((rib2Content.getString("NDiv")).c_str());
1378
1379 const string solidName = "solidRib2" + to_string(rib2ID);
1380 const string logicalName = "logicalRib2" + to_string(rib2ID);
1381 G4Trd* trdShape = new G4Trd(solidName,
1382 0.5 * thick * CLHEP::cm,
1383 0.5 * thick2 * CLHEP::cm,
1384 0.5 * width * CLHEP::cm,
1385 0.5 * width2 * CLHEP::cm,
1386 0.5 * length * CLHEP::cm);
1387
1388 G4LogicalVolume* logicalV = new G4LogicalVolume(trdShape, medAluminum, logicalName, 0, 0, 0);
1389 if (rib2ID > 0)
1390 logicalV = new G4LogicalVolume(trdShape, medCopper, logicalName, 0, 0, 0);
1391
1392 logicalV->SetVisAttributes(m_VisAttributes.back());
1393
1394 const double phi = 360.0 / number;
1395
1396 G4RotationMatrix rot = G4RotationMatrix();
1397 G4ThreeVector arm(cX * CLHEP::cm, cY * CLHEP::cm, cZ * CLHEP::cm - thick * CLHEP::cm / 2.0);
1398
1399 rot.rotateX(rotX);
1400 rot.rotateY(rotY);
1401 rot.rotateZ(rotZ);
1402 for (int i = 0; i < number; ++i) {
1403 const string physicalName = "physicalRib2_" + to_string(rib2ID) + " " + to_string(i);
1404 new G4PVPlacement(G4Transform3D(rot, arm), logicalV,
1405 physicalName.c_str(), m_logicalCDC, false, rib2ID);
1406 rot.rotateZ(phi * CLHEP::deg);
1407 arm.rotateZ(phi * CLHEP::deg);
1408 }
1409
1410 }// rib2
1411
1412 const int nRib3s = content.getNumberNodes("Covers/Rib3");
1413 for (int iRib3 = 0; iRib3 < nRib3s; ++iRib3) {
1414 GearDir rib3Content(content);
1415 rib3Content.append((boost::format("/Covers/Rib3[%1%]/") % (iRib3 + 1)).str());
1416 const string srib3ID = rib3Content.getString("@id");
1417 const int rib3ID = atoi(srib3ID.c_str());
1418 // const string rib3Name = rib3Content.getString("Name");
1419 const double length = rib3Content.getLength("Length");
1420 const double width = rib3Content.getLength("Width");
1421 const double thick = rib3Content.getLength("Thickness");
1422 const double r = rib3Content.getLength("HoleR");
1423 const double cX = rib3Content.getLength("PosX");
1424 const double cY = rib3Content.getLength("PosY");
1425 const double cZ = rib3Content.getLength("PosZ");
1426 const double hX = rib3Content.getLength("HoleX");
1427 const double hY = rib3Content.getLength("HoleY");
1428 const double hZ = rib3Content.getLength("HoleZ");
1429 const int offset = atoi((rib3Content.getString("Offset")).c_str());
1430 const int number = atoi((rib3Content.getString("NDiv")).c_str());
1431
1432 const string logicalName = "logicalRib3" + to_string(rib3ID);
1433 G4VSolid* boxShape = new G4Box("Block",
1434 0.5 * length * CLHEP::cm,
1435 0.5 * width * CLHEP::cm,
1436 0.5 * thick * CLHEP::cm);
1437 G4VSolid* tubeShape = new G4Tubs("Hole",
1438 0.,
1439 r * CLHEP::cm,
1440 length * CLHEP::cm,
1441 0.,
1442 360. * CLHEP::deg);
1443 G4RotationMatrix rotsub = G4RotationMatrix();
1444 G4ThreeVector trnsub(cX * CLHEP::cm - hX * CLHEP::cm, cY * CLHEP::cm - hY * CLHEP::cm,
1445 cZ * CLHEP::cm - hZ * CLHEP::cm + 0.5 * thick * CLHEP::cm);
1446 G4VSolid* coolingBlock = new G4SubtractionSolid("Block-Hole",
1447 boxShape,
1448 tubeShape,
1449 G4Transform3D(rotsub,
1450 trnsub));
1451
1452 G4LogicalVolume* logicalV = new G4LogicalVolume(coolingBlock, medCopper, logicalName, 0, 0, 0);
1453
1454 logicalV->SetVisAttributes(m_VisAttributes.back());
1455
1456 const double phi = 360.0 / number;
1457
1458 G4RotationMatrix rot = G4RotationMatrix();
1459 G4ThreeVector arm(cX * CLHEP::cm, cY * CLHEP::cm, cZ * CLHEP::cm - thick * CLHEP::cm / 2.0);
1460
1461 if (offset) {
1462 rot.rotateZ(0.5 * phi * CLHEP::deg);
1463 arm.rotateZ(0.5 * phi * CLHEP::deg);
1464 }
1465 for (int i = 0; i < number; ++i) {
1466 const string physicalName = "physicalRib3_" + to_string(rib3ID) + " " + to_string(i);
1467 new G4PVPlacement(G4Transform3D(rot, arm), logicalV,
1468 physicalName.c_str(), m_logicalCDC, false, rib3ID);
1469 rot.rotateZ(phi * CLHEP::deg);
1470 arm.rotateZ(phi * CLHEP::deg);
1471 }
1472
1473 }// rib3
1474
1475 const int nRib4s = content.getNumberNodes("Covers/Rib4");
1476 for (int iRib4 = 0; iRib4 < nRib4s; ++iRib4) {
1477 GearDir rib4Content(content);
1478 rib4Content.append((boost::format("/Covers/Rib4[%1%]/") % (iRib4 + 1)).str());
1479 const string srib4ID = rib4Content.getString("@id");
1480 const int rib4ID = atoi(srib4ID.c_str());
1481 // const string rib4Name = rib4Content.getString("Name");
1482 const double length = rib4Content.getLength("Length");
1483 const double width = rib4Content.getLength("Width");
1484 const double thick = rib4Content.getLength("Thickness");
1485 const double length2 = rib4Content.getLength("Length2");
1486 const double width2 = rib4Content.getLength("Width2");
1487 const double thick2 = rib4Content.getLength("Thickness2");
1488 const double cX = rib4Content.getLength("PosX");
1489 const double cY = rib4Content.getLength("PosY");
1490 const double cZ = rib4Content.getLength("PosZ");
1491 const double hX = rib4Content.getLength("HoleX");
1492 const double hY = rib4Content.getLength("HoleY");
1493 const double hZ = rib4Content.getLength("HoleZ");
1494 const int offset = atoi((rib4Content.getString("Offset")).c_str());
1495 const int number = atoi((rib4Content.getString("NDiv")).c_str());
1496
1497 const string logicalName = "logicalRib4" + to_string(rib4ID);
1498 G4VSolid* baseShape = new G4Box("Base",
1499 0.5 * length * CLHEP::cm,
1500 0.5 * width * CLHEP::cm,
1501 0.5 * thick * CLHEP::cm);
1502 G4VSolid* sqShape = new G4Box("Sq",
1503 0.5 * length2 * CLHEP::cm,
1504 0.5 * width2 * CLHEP::cm,
1505 0.5 * thick2 * CLHEP::cm);
1506 G4RotationMatrix rotsub = G4RotationMatrix();
1507 double dzc = (hZ - thick2 / 2.) - (cZ - thick / 2.);
1508 G4ThreeVector trnsub(hX * CLHEP::cm - cX * CLHEP::cm,
1509 hY * CLHEP::cm - cY * CLHEP::cm,
1510 dzc * CLHEP::cm);
1511 G4VSolid* sqHoleBase = new G4SubtractionSolid("Base-Sq",
1512 baseShape,
1513 sqShape,
1514 G4Transform3D(rotsub,
1515 trnsub)
1516 );
1517
1518 G4LogicalVolume* logicalV = new G4LogicalVolume(sqHoleBase, medCopper, logicalName, 0, 0, 0);
1519 if (rib4ID < 19)
1520 logicalV = new G4LogicalVolume(sqHoleBase, medNEMA_G10_Plate, logicalName, 0, 0, 0);
1521
1522 logicalV->SetVisAttributes(m_VisAttributes.back());
1523
1524 const double phi = 360.0 / number;
1525
1526 G4RotationMatrix rot = G4RotationMatrix();
1527 G4ThreeVector arm(cX * CLHEP::cm, cY * CLHEP::cm, cZ * CLHEP::cm - thick * CLHEP::cm / 2.0);
1528
1529 if (offset) {
1530 rot.rotateZ(0.5 * phi * CLHEP::deg);
1531 arm.rotateZ(0.5 * phi * CLHEP::deg);
1532 }
1533 for (int i = 0; i < number; ++i) {
1534 const string physicalName = "physicalRib4_" + to_string(rib4ID) + " " + to_string(i);
1535 new G4PVPlacement(G4Transform3D(rot, arm), logicalV,
1536 physicalName.c_str(), m_logicalCDC, false, rib4ID);
1537 rot.rotateZ(phi * CLHEP::deg);
1538 arm.rotateZ(phi * CLHEP::deg);
1539 }
1540
1541 }// rib4
1542
1543 const int nRib5s = content.getNumberNodes("Covers/Rib5");
1544 for (int iRib5 = 0; iRib5 < nRib5s; ++iRib5) {
1545 GearDir rib5Content(content);
1546 rib5Content.append((boost::format("/Covers/Rib5[%1%]/") % (iRib5 + 1)).str());
1547 const string srib5ID = rib5Content.getString("@id");
1548 const int rib5ID = atoi(srib5ID.c_str());
1549 // const string rib5Name = rib5Content.getString("Name");
1550 const double dr = rib5Content.getLength("DeltaR");
1551 const double dz = rib5Content.getLength("DeltaZ");
1552 const double width = rib5Content.getLength("Width");
1553 const double thick = rib5Content.getLength("Thickness");
1554 const double rin = rib5Content.getLength("Rin");
1555 const double rotX = rib5Content.getLength("RotX");
1556 const double rotY = rib5Content.getLength("RotY");
1557 const double rotZ = rib5Content.getLength("RotZ");
1558 const double cX = rib5Content.getLength("PosX");
1559 const double cY = rib5Content.getLength("PosY");
1560 const double cZ = rib5Content.getLength("PosZ");
1561 const int offset = atoi((rib5Content.getString("Offset")).c_str());
1562 const int number = atoi((rib5Content.getString("NDiv")).c_str());
1563
1564 const string solidName = "solidRib5" + to_string(rib5ID);
1565 const string logicalName = "logicalRib5" + to_string(rib5ID);
1566 const double rmax = rin + thick;
1567 const double rmin = rin;
1568 const double dphi = 2. * atan2(dz, dr);
1569 const double ddphi = thick * tan(dphi) / rin;
1570 const double ddphi2 = width / 2. * width / 2. / (cX + dr) / rin;
1571 const double cphi = dphi - ddphi - ddphi2;
1572 G4Tubs* tubeShape = new G4Tubs(solidName,
1573 rmin * CLHEP::cm,
1574 rmax * CLHEP::cm,
1575 0.5 * width * CLHEP::cm,
1576 0.,
1577 cphi);
1578
1579 G4LogicalVolume* logicalV = new G4LogicalVolume(tubeShape, medAluminum, logicalName, 0, 0, 0);
1580
1581 logicalV->SetVisAttributes(m_VisAttributes.back());
1582
1583 const double phi = 360.0 / number;
1584
1585 G4RotationMatrix rot = G4RotationMatrix();
1586
1587 //G4ThreeVector arm(cX * CLHEP::cm, cY * CLHEP::cm, cZ * CLHEP::cm - thick * CLHEP::cm / 2.0);
1588 G4ThreeVector arm(cX * CLHEP::cm, cY * CLHEP::cm, cZ * CLHEP::cm - rin * CLHEP::cm - thick * CLHEP::cm);
1589
1590 rot.rotateX(rotX);
1591 rot.rotateY(rotY);
1592 rot.rotateZ(rotZ);
1593 if (offset) {
1594 rot.rotateZ(0.5 * phi * CLHEP::deg);
1595 arm.rotateZ(0.5 * phi * CLHEP::deg);
1596 }
1597 for (int i = 0; i < number; ++i) {
1598 const string physicalName = "physicalRib5_" + to_string(rib5ID) + " " + to_string(i);
1599 new G4PVPlacement(G4Transform3D(rot, arm), logicalV,
1600 physicalName.c_str(), m_logicalCDC, false, rib5ID);
1601 rot.rotateZ(phi * CLHEP::deg);
1602 arm.rotateZ(phi * CLHEP::deg);
1603 }
1604 }//rib5
1605
1606 }
1607
1608
1610 {
1611 G4Material* medAl = geometry::Materials::get("Al");
1612 G4double density = 1.000 * CLHEP::g / CLHEP::cm3;
1613 G4double a = 1.01 * CLHEP::g / CLHEP::mole;
1614 G4Element* elH = new G4Element("Hydrogen", "H", 1., a);
1615 a = 16.00 * CLHEP::g / CLHEP::mole;
1616 G4Element* elO = new G4Element("Oxygen", "O", 8., a);
1617 G4Material* medH2O = new G4Material("water", density, 2);
1618 medH2O->AddElement(elH, 2);
1619 medH2O->AddElement(elO, 1);
1620 G4Material* medCu = geometry::Materials::get("Cu");
1621 G4Material* medLV = geometry::Materials::get("CDCLVCable");
1622 G4Material* medFiber = geometry::Materials::get("CDCOpticalFiber");
1623 G4Material* medCAT7 = geometry::Materials::get("CDCCAT7");
1624 G4Material* medTRG = geometry::Materials::get("CDCOpticalFiberTRG");
1625 G4Material* medHV = geometry::Materials::get("CDCHVCable");
1626
1627 m_VisAttributes.push_back(new G4VisAttributes(true, G4Colour(0., 1., 0.)));
1628 for (const auto& cover : geom.getCovers()) {
1629 const int coverID = cover.getId();
1630 const string coverName = "cover" + to_string(coverID);
1631 const double rmin1 = cover.getRmin1();
1632 const double rmin2 = cover.getRmin2();
1633 const double rmax1 = cover.getRmax1();
1634 const double rmax2 = cover.getRmax2();
1635 const double thick = cover.getThick();
1636 const double posZ = cover.getZ();
1637
1638 /*if (coverID == 7 || coverID == 10) {
1639 createCone(rmin1, rmax1, rmin2, rmax2, thick, posZ, coverID, medAl, coverName);
1640 } else {
1641 createTube(rmin1, rmax1, thick, posZ, coverID, medAl, coverName);
1642 }*/
1643 // ID dependent material definition
1644 if (coverID < 23) {
1645 if (coverID == 7 || coverID == 10) {
1646 createCone(rmin1, rmax1, rmin2, rmax2, thick, posZ, coverID, medAl, coverName);
1647 } else {
1648 createTube(rmin1, rmax1, thick, posZ, coverID, medAl, coverName);
1649 }
1650 }
1651 if (coverID > 22 && coverID < 29)
1652 createTube(rmin1, rmax1, thick, posZ, coverID, medCu, coverName);
1653 if (coverID > 28 && coverID < 35)
1654 createTorus(rmin1, rmax1, thick, posZ, coverID, medCu, coverName);
1655 if (coverID > 34 && coverID < 41)
1656 createTorus(rmin1, rmax1, thick, posZ, coverID, medH2O, coverName);
1657 if (coverID == 45 || coverID == 46)
1658 createTube(rmin1, rmax1, thick, posZ, coverID, medLV, coverName);
1659 if (coverID == 47 || coverID == 48)
1660 createTube(rmin1, rmax1, thick, posZ, coverID, medFiber, coverName);
1661 if (coverID == 49 || coverID == 50)
1662 createTube(rmin1, rmax1, thick, posZ, coverID, medCAT7, coverName);
1663 if (coverID == 51 || coverID == 52)
1664 createTube(rmin1, rmax1, thick, posZ, coverID, medTRG, coverName);
1665 if (coverID == 53)
1666 createTube(rmin1, rmax1, thick, posZ, coverID, medHV, coverName);
1667 }
1668 }
1669
1671 {
1672 G4Material* medHV = geometry::Materials::get("CDCHVCable");
1673 G4Material* medFiber = geometry::Materials::get("CDCOpticalFiber");
1674 G4Material* medCAT7 = geometry::Materials::get("CDCCAT7");
1675 G4Material* medTRG = geometry::Materials::get("CDCOpticalFiberTRG");
1676
1677 m_VisAttributes.push_back(new G4VisAttributes(true, G4Colour(0., 1., 0.)));
1678 for (const auto& cover2 : geom.getCover2s()) {
1679 const int cover2ID = cover2.getId();
1680 const string cover2Name = "cover2" + to_string(cover2ID);
1681 const double rmin = cover2.getRmin();
1682 const double rmax = cover2.getRmax();
1683 const double phis = cover2.getPhis();
1684 const double dphi = cover2.getDphi();
1685 const double thick = cover2.getThick();
1686 const double posZ = cover2.getZ();
1687
1688 if (cover2ID < 11)
1689 createTube2(rmin, rmax, phis, dphi, thick, posZ, cover2ID, medHV, cover2Name);
1690 if (cover2ID > 10 && cover2ID < 14)
1691 createTube2(rmin, rmax, phis, dphi, thick, posZ, cover2ID, medFiber, cover2Name);
1692 if (cover2ID > 13 && cover2ID < 23)
1693 createTube2(rmin, rmax, phis, dphi, thick, posZ, cover2ID, medCAT7, cover2Name);
1694 if (cover2ID > 22 && cover2ID < 29)
1695 createTube2(rmin, rmax, phis, dphi, thick, posZ, cover2ID, medTRG, cover2Name);
1696 }
1697 }
1698
1699 void GeoCDCCreatorReducedCDC::createCone(const double rmin1, const double rmax1,
1700 const double rmin2, const double rmax2,
1701 const double thick, const double posZ,
1702 const int id, G4Material* med,
1703 const string& name)
1704 {
1705 const string solidName = "solid" + name;
1706 const string logicalName = "logical" + name;
1707 const string physicalName = "physical" + name;
1708 G4Cons* coverConeShape = new G4Cons(solidName.c_str(), rmin1 * CLHEP::cm, rmax1 * CLHEP::cm,
1709 rmin2 * CLHEP::cm, rmax2 * CLHEP::cm, thick * CLHEP::cm / 2.0, 0.*CLHEP::deg, 360.*CLHEP::deg);
1710 G4LogicalVolume* coverCone = new G4LogicalVolume(coverConeShape, med,
1711 logicalName.c_str(), 0, 0, 0);
1712 coverCone->SetVisAttributes(m_VisAttributes.back());
1713 new G4PVPlacement(0, G4ThreeVector(0.0, 0.0, posZ * CLHEP::cm - thick * CLHEP::cm / 2.0), coverCone,
1714 physicalName.c_str(), m_logicalCDC, false, id);
1715
1716 }
1717
1718 void GeoCDCCreatorReducedCDC::createTube(const double rmin, const double rmax,
1719 const double thick, const double posZ,
1720 const int id, G4Material* med,
1721 const string& name)
1722 {
1723 const string solidName = "solid" + name;
1724 const string logicalName = "logical" + name;
1725 const string physicalName = "physical" + name;
1726 G4Tubs* solidV = new G4Tubs(solidName.c_str(),
1727 rmin * CLHEP::cm,
1728 rmax * CLHEP::cm,
1729 thick * CLHEP::cm / 2.0,
1730 0.*CLHEP::deg,
1731 360.*CLHEP::deg);
1732 G4LogicalVolume* logicalV = new G4LogicalVolume(solidV, med,
1733 logicalName.c_str(), 0, 0, 0);
1734 logicalV->SetVisAttributes(m_VisAttributes.back());
1735 new G4PVPlacement(0, G4ThreeVector(0.0, 0.0, posZ * CLHEP::cm - thick * CLHEP::cm / 2.0), logicalV,
1736 physicalName.c_str(), m_logicalCDC, false, id);
1737
1738 }
1739
1740 void GeoCDCCreatorReducedCDC::createBox(const double length, const double height,
1741 const double thick, const double x,
1742 const double y, const double z,
1743 const int id, G4Material* med,
1744 const string& name)
1745 {
1746 const string solidName = (boost::format("solid%1%%2%") % name % id).str();
1747 const string logicalName = (boost::format("logical%1%%2%") % name % id).str();
1748 const string physicalName = (boost::format("physical%1%%2%") % name % id).str();
1749 G4Box* boxShape = new G4Box(solidName.c_str(), 0.5 * length * CLHEP::cm,
1750 0.5 * height * CLHEP::cm,
1751 0.5 * thick * CLHEP::cm);
1752 G4LogicalVolume* logicalV = new G4LogicalVolume(boxShape, med,
1753 logicalName.c_str(), 0, 0, 0);
1754 logicalV->SetVisAttributes(m_VisAttributes.back());
1755 new G4PVPlacement(0, G4ThreeVector(x * CLHEP::cm, y * CLHEP::cm, z * CLHEP::cm - thick * CLHEP::cm / 2.0), logicalV,
1756 physicalName.c_str(), m_logicalCDC, false, id);
1757
1758 }
1759
1760 void GeoCDCCreatorReducedCDC::createTorus(const double rmin1, const double rmax1,
1761 const double thick, const double posZ,
1762 const int id, G4Material* med,
1763 const string& name)
1764 {
1765 const string solidName = "solid" + name;
1766 const string logicalName = "logical" + name;
1767 const string physicalName = "physical" + name;
1768 const double rtor = (rmax1 + rmin1) / 2.;
1769 const double rmax = rmax1 - rtor;
1770 const double rmin = max((rmax - thick), 0.);
1771
1772 G4Torus* solidV = new G4Torus(solidName.c_str(),
1773 rmin * CLHEP::cm,
1774 rmax * CLHEP::cm,
1775 rtor * CLHEP::cm,
1776 0.*CLHEP::deg,
1777 360.*CLHEP::deg);
1778 G4LogicalVolume* logicalV = new G4LogicalVolume(solidV, med,
1779 logicalName.c_str(), 0, 0, 0);
1780 logicalV->SetVisAttributes(m_VisAttributes.back());
1781 new G4PVPlacement(0, G4ThreeVector(0.0, 0.0, posZ * CLHEP::cm), logicalV,
1782 physicalName.c_str(), m_logicalCDC, false, id);
1783
1784 }
1785
1786 void GeoCDCCreatorReducedCDC::createTube2(const double rmin, const double rmax,
1787 const double phis, const double phie,
1788 const double thick, const double posZ,
1789 const int id, G4Material* med,
1790 const string& name)
1791 {
1792 const string solidName = "solid" + name;
1793 const string logicalName = "logical" + name;
1794 const string physicalName = "physical" + name;
1795 G4Tubs* solidV = new G4Tubs(solidName.c_str(),
1796 rmin * CLHEP::cm,
1797 rmax * CLHEP::cm,
1798 thick * CLHEP::cm / 2.0,
1799 phis,
1800 phie);
1801 G4LogicalVolume* logicalV = new G4LogicalVolume(solidV, med,
1802 logicalName.c_str(), 0, 0, 0);
1803 logicalV->SetVisAttributes(m_VisAttributes.back());
1804 new G4PVPlacement(0, G4ThreeVector(0.0, 0.0, posZ * CLHEP::cm - thick * CLHEP::cm / 2.0), logicalV,
1805 physicalName.c_str(), m_logicalCDC, false, id);
1806
1807 }
1808
1809 void GeoCDCCreatorReducedCDC::createMapper(G4LogicalVolume& topVolume)
1810 {
1812 if (!gcp.getMapperGeometry()) return;
1813
1814 const double xc = 0.5 * (-0.0002769 + 0.0370499) * CLHEP::cm;
1815 const double yc = 0.5 * (-0.0615404 + -0.108948) * CLHEP::cm;
1816 const double zc = 0.5 * (-35.3 + 48.5) * CLHEP::cm;
1817 //3 plates
1818 // const double plateWidth = 13.756 * CLHEP::cm;
1819 // const double plateThick = 1.203 * CLHEP::cm;
1820 // const double plateLength = 83.706 * CLHEP::cm;
1821 const double plateWidth = 13.8 * CLHEP::cm;
1822 const double plateThick = 1.2 * CLHEP::cm;
1823 const double plateLength = 83.8 * CLHEP::cm;
1824 const double phi = gcp.getMapperPhiAngle() * CLHEP::deg; //phi-angle in lab.
1825 // std::cout << "phi= " << phi << std::endl;
1826 // const double endRingRmin = 4.1135 * CLHEP::cm;
1827 // const double endRingRmax = 15.353 * CLHEP::cm;
1828 // const double endRingThick = 2.057 * CLHEP::cm;
1829 const double endPlateRmin = 4.0 * CLHEP::cm;
1830 const double endPlateRmax = 15.5 * CLHEP::cm;
1831 const double bwdEndPlateThick = 1.7 * CLHEP::cm;
1832 const double fwdEndPlateThick = 2.0 * CLHEP::cm;
1833
1834 G4Material* medAluminum = geometry::Materials::get("Al");
1835
1836 string name = "Plate";
1837 int pID = 0;
1838 G4Box* plateShape = new G4Box("solid" + name, .5 * plateWidth, .5 * plateThick, .5 * plateLength);
1839 G4LogicalVolume* logical0 = new G4LogicalVolume(plateShape, medAluminum, "logical" + name, 0, 0, 0);
1840 logical0->SetVisAttributes(m_VisAttributes.back());
1841 // const double x = .5 * plateWidth;
1842 const double x = xc + 0.5 * plateWidth;
1843 // const double y = endRingRmin;
1844 const double y = yc + endPlateRmin + 0.1 * CLHEP::cm;
1845 // double z = 2.871 * CLHEP::cm;
1846 G4ThreeVector xyz(x, y, zc);
1847 G4RotationMatrix rotM3 = G4RotationMatrix();
1848 xyz.rotateZ(phi);
1849 rotM3.rotateZ(phi);
1850 new G4PVPlacement(G4Transform3D(rotM3, xyz), logical0, "physical" + name, &topVolume, false, pID);
1851
1852 const double alf = 120. * CLHEP::deg;
1853 xyz.rotateZ(alf);
1854 rotM3.rotateZ(alf);
1855 new G4PVPlacement(G4Transform3D(rotM3, xyz), logical0, "physical" + name, &topVolume, false, pID + 1);
1856
1857 xyz.rotateZ(alf);
1858 rotM3.rotateZ(alf);
1859 new G4PVPlacement(G4Transform3D(rotM3, xyz), logical0, "physical" + name, &topVolume, false, pID + 2);
1860
1861 //Define 2 end-plates
1862 //bwd
1863 name = "BwdEndPlate";
1864 G4Tubs* BwdEndPlateShape = new G4Tubs("solid" + name, endPlateRmin, endPlateRmax, 0.5 * bwdEndPlateThick, 0., 360.*CLHEP::deg);
1865 G4LogicalVolume* logical1 = new G4LogicalVolume(BwdEndPlateShape, medAluminum, "logical" + name, 0, 0, 0);
1866 logical1->SetVisAttributes(m_VisAttributes.back());
1867 // z = -40.0105 * CLHEP::cm;
1868 double z = -35.3 * CLHEP::cm - 0.5 * bwdEndPlateThick;
1869 pID = 0;
1870 new G4PVPlacement(0, G4ThreeVector(xc, yc, z), logical1, "physical" + name, &topVolume, false, pID);
1871
1872 //fwd
1873 // z = 45.7525 * CLHEP::cm;
1874 // new G4PVPlacement(0, G4ThreeVector(0., 0., z), logical1, "physical" + name, &topVolume, false, pID + 1);
1875 name = "FwdEndPlate";
1876 G4Tubs* FwdEndPlateShape = new G4Tubs("solid" + name, endPlateRmin, endPlateRmax, 0.5 * fwdEndPlateThick, 0., 360.*CLHEP::deg);
1877 G4LogicalVolume* logical2 = new G4LogicalVolume(FwdEndPlateShape, medAluminum, "logical" + name, 0, 0, 0);
1878 logical2->SetVisAttributes(m_VisAttributes.back());
1879 z = 48.5 * CLHEP::cm + 0.5 * fwdEndPlateThick;
1880 new G4PVPlacement(0, G4ThreeVector(xc, yc, z), logical2, "physical" + name, &topVolume, false, pID);
1881 }
1882 }
1884}
DataType Z() const
access variable Z (= .at(2) without boundary check)
Definition B2Vector3.h:435
void SetX(DataType x)
set X/1st-coordinate
Definition B2Vector3.h:457
B2Vector3< DataType > Cross(const B2Vector3< DataType > &p) const
Cross product.
Definition B2Vector3.h:296
DataType X() const
access variable X (= .at(0) without boundary check)
Definition B2Vector3.h:431
DataType Y() const
access variable Y (= .at(1) without boundary check)
Definition B2Vector3.h:433
DataType Mag() const
The magnitude (rho in spherical coordinate system).
Definition B2Vector3.h:159
void SetY(DataType y)
set Y/2nd-coordinate
Definition B2Vector3.h:459
DataType Perp() const
The transverse component (R in cylindrical coordinate system).
Definition B2Vector3.h:200
The Class for BeamBackground Sensitive Detector.
int getNEndPlateLayers() const
Get the number of endplate layers.
double getR() const
Get Radius.
double getZbwd() const
Get bwd z-position.
std::vector< double > getRmin() const
Get the list of the Rmin coordinates.
The Class for CDC geometry.
Definition CDCGeometry.h:27
double getGlobalOffsetY() const
Get the global y offset of CDC wrt Belle2 coord.
FieldLayer getFieldLayer(int i) const
Get the i-th field layer.
OuterWall getOuterWall(int i) const
Get the i-th outer wall.
std::vector< Rib2 > getRib2s() const
Get the list of rib2s.
double getFiducialRmin() const
Get the fiducial Rmin of CDC sensitive volume.
std::vector< Rib > getRibs() const
Get the list of ribs.
double getGlobalOffsetX() const
Get the global x offset of CDC wrt Belle2 coord.
std::vector< InnerWall > getInnerWalls() const
Get the list of inner walls.
std::vector< Rib5 > getRib5s() const
Get the list of rib5s.
double getFiducialRmax() const
Get the fiducial Rmax of CDC sensitive volume.
int getNFieldWires() const
Get the number of field wires.
std::vector< Rib3 > getRib3s() const
Get the list of rib3s.
MotherVolume getMotherVolume() const
Get the mother volume geometry of CDC.
int getNSenseWires() const
Get the number of sense wires.
double getSenseDiameter() const
Get the diameter of sense wire.
std::vector< Frontend > getFrontends() const
Get the list of frontend layers.
InnerWall getInnerWall(int i) const
Get the i-th inner wall.
double getFieldDiameter() const
Get the diameter of field wire.
EndPlate getEndPlate(int i) const
Get the i-th endplate.
std::vector< Rib4 > getRib4s() const
Get the list of rib4s.
int getNSenseLayers() const
Get the number of sense layers.
std::vector< EndPlate > getEndPlates() const
Get the list of endplates.
double getFeedthroughLength() const
Get the length of feedthrough.
double getGlobalOffsetZ() const
Get the global z offset of CDC wrt Belle2 coord.
std::vector< OuterWall > getOuterWalls() const
Get the list of outer walls.
SenseLayer getSenseLayer(int i) const
Get i-th sense layer.
The Class for CDC Geometry Control Parameters.
bool getPrintMaterialTable() const
Get printMaterialTable flag.
double getMaterialDefinitionMode() const
Get material definition mode.
bool getMapperGeometry()
Get mapper geometry flag.
double getMapperPhiAngle()
Get mapper phi-angle.
static CDCGeoControlPar & getInstance()
Static method to get a reference to the CDCGeoControlPar instance.
The Class for CDC Geometry Parameters.
double fieldWireDiameter() const
Returns diameter of the field wire.
const B2Vector3D wireForwardPosition(uint layerId, int cellId, EWirePosition set=c_Base) const
Returns the forward position of the input sense wire.
double senseWireDiameter() const
Returns diameter of the sense wire.
const B2Vector3D wireBackwardPosition(uint layerId, int cellId, EWirePosition set=c_Base) const
Returns the backward position of the input sense wire.
unsigned nWiresInLayer(int layerId) const
Returns wire numbers in a layer.
static CDCGeometryPar & Instance(const CDCGeometry *=nullptr)
Static method to get a reference to the CDCGeometryPar instance.
The Class for CDC Sensitive Detector.
static CDCSimControlPar & getInstance()
Static method to get a reference to the CDCSimControlPar instance.
void createBox(const double length, const double height, const double thick, const double x, const double y, const double z, const int id, G4Material *med, const std::string &name)
Create G4Box.
GeoCDCCreatorReducedCDC()
Constructor of the GeoCDCCreatorReducedCDC class.
std::vector< G4VisAttributes * > m_VisAttributes
Vector of pointers to G4VisAttributes.
std::vector< G4UserLimits * > m_userLimits
Vector of pointers to G4UserLimits.
BkgSensitiveDetector * m_bkgsensitive
Sensitive detector for background studies.
void createGeometry(const CDCGeometry &parameters, G4LogicalVolume &topVolume, geometry::GeometryTypes type)
Create G4 geometry of CDC.
void createTube2(const double rmin, const double rmax, const double phis, const double phie, const double thick, const double posZ, const int id, G4Material *med, const std::string &name)
Create G4Tube2.
void createTube(const double rmin, const double rmax, const double thick, const double posZ, const int id, G4Material *med, const std::string &name)
Create G4Tube.
~GeoCDCCreatorReducedCDC()
The destructor of the GeoCDCCreatorReducedCDC class.
void createNeutronShields(const GearDir &content)
Create neutron shield from gearbox.
G4VPhysicalVolume * m_physicalCDC
CDC G4 physical volume.
void createTorus(const double rmin1, const double rmax1, const double thick, const double posZ, const int id, G4Material *med, const std::string &name)
Create G4Torus.
void createCone(const double rmin1, const double rmax1, const double rmin2, const double rmax2, const double thick, const double posz, const int id, G4Material *med, const std::string &name)
Create G4Cone.
void createCover2s(const GearDir &content)
Create CDC cover2s from gear box.
void createMapper(G4LogicalVolume &topVolume)
Create the B-field mapper geometry (tentative function)
G4LogicalVolume * m_logicalCDC
CDC G4 logical volume.
void createCovers(const GearDir &content)
Create CDC covers from gear box.
CDCSensitiveDetector * m_sensitive
Sensitive detector.
GearDir is the basic class used for accessing the parameter store.
Definition GearDir.h:31
void append(const std::string &path)
Append something to the current path, modifying the GearDir in place.
Definition GearDir.h:52
virtual std::string getString(const std::string &path="") const noexcept(false) override
Get the parameter path as a string.
Definition GearDir.h:69
double getLength(const std::string &path="") const noexcept(false)
Get the parameter path as a double converted to the standard length unit.
Definition Interface.h:259
static G4Material * get(const std::string &name)
Find given material.
Definition Materials.h:63
B2Vector3< double > B2Vector3D
typedef for common usage with double
Definition B2Vector3.h:516
double tan(double a)
tan for double
Definition beamHelpers.h:31
geometry::CreatorFactory< GeoCDCCreatorReducedCDC > GeoCDCFactoryReducedCDC("CDCCreatorReducedCDC")
Register the GeoCreator.
Common code concerning the geometry representation of the detector.
Definition CreatorBase.h:25
GeometryTypes
Flag indicating the type of geometry to be used.
Abstract base class for different kinds of events.
STL namespace.
Very simple class to provide an easy way to register creators with the CreatorManager.