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

The GeoCDCCreatorReducedCDCNoSL0SL1 class. More...

#include <GeoCDCCreatorReducedCDCNoSL0SL1.h>

Inheritance diagram for GeoCDCCreatorReducedCDCNoSL0SL1:
GeoCDCCreator CreatorBase

Public Member Functions

 GeoCDCCreatorReducedCDCNoSL0SL1 ()
 Constructor of the GeoCDCCreatorReducedCDCNoSL0SL1 class.
 
 ~GeoCDCCreatorReducedCDCNoSL0SL1 ()
 The destructor of the GeoCDCCreatorReducedCDCNoSL0SL1 class.
 
virtual void create (const GearDir &content, G4LogicalVolume &topVolume, geometry::GeometryTypes type) override
 Creates the ROOT Objects for the CDC geometry.
 
virtual void createFromDB (const std::string &name, G4LogicalVolume &topVolume, geometry::GeometryTypes type) override
 Create geometry from DB.
 
virtual void createPayloads (const GearDir &content, const IntervalOfValidity &iov) override
 Create payloads.
 
void createCovers (const GearDir &content)
 Create CDC covers from gear box.
 
void createCovers (const CDCGeometry &geom)
 Create CDC covers from DB.
 
void createNeutronShields (const GearDir &content)
 Create neutron shield from gearbox.
 
void createNeutronShields (const CDCGeometry &geom)
 Create neutron shield from DB.
 
void createCover2s (const GearDir &content)
 Create CDC cover2s from gear box.
 
void createCover2s (const CDCGeometry &geom)
 Create CDC cover2s from DB.
 
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 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.
 
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.
 
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 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.
 
 BELLE2_DEFINE_EXCEPTION (DBNotImplemented, "Cannot create geometry from Database.")
 Exception that will be thrown in createFromDB if member is not yet implemented by creator.
 

Private Member Functions

virtual bool getEndplateInformation (const CDCGeometry &geo, const uint iSLayer, double &rMinLeft, double &rMaxLeft, double &zBackLeft, double &zForLeft, double &rMinMiddle, double &rMaxMiddle, double &zBackMiddle, double &zForMiddle, double &rMinRight, double &rMaxRight, double &zBackRight, double &zForRight) const override
 Get endplate information.
 
CDCGeometry createConfiguration (const GearDir &param)
 Create DB object of CDC geometry from gearbox.
 
void createGeometry (const CDCGeometry &parameters, G4LogicalVolume &topVolume, geometry::GeometryTypes type)
 Create G4 geometry of CDC.
 
void createMapper (G4LogicalVolume &topVolume)
 Create the B-field mapper geometry (tentative function)
 

Private Attributes

G4LogicalVolume * m_logicalCDC
 CDC G4 logical volume.
 
G4VPhysicalVolume * m_physicalCDC
 CDC G4 physical volume.
 
CDCSensitiveDetector * m_sensitive = nullptr
 Sensitive detector.
 
BkgSensitiveDetector * m_bkgsensitive = nullptr
 Sensitive detector for background studies.
 
std::vector< BkgSensitiveDetector * > m_BkgSensitiveRib4 = {}
 Sensitive detectors for background studies (rib4).
 
std::vector< G4VisAttributes * > m_VisAttributes
 Vector of pointers to G4VisAttributes.
 
std::vector< G4UserLimits * > m_userLimits
 Vector of pointers to G4UserLimits.
 

Detailed Description

The GeoCDCCreatorReducedCDCNoSL0SL1 class.

The creator for the CDC geometry of the Belle II detector where the SuperLayers 0 and 1 are removed.

Definition at line 28 of file GeoCDCCreatorReducedCDCNoSL0SL1.h.

Constructor & Destructor Documentation

◆ GeoCDCCreatorReducedCDCNoSL0SL1()

GeoCDCCreatorReducedCDCNoSL0SL1 ( )
inline

Constructor of the GeoCDCCreatorReducedCDCNoSL0SL1 class.

Definition at line 33 of file GeoCDCCreatorReducedCDCNoSL0SL1.h.

33 : GeoCDCCreator()
34 {
35 B2WARNING("Using CDC without SL0 and SL1!");
36 }

◆ ~GeoCDCCreatorReducedCDCNoSL0SL1()

~GeoCDCCreatorReducedCDCNoSL0SL1 ( )
inline

The destructor of the GeoCDCCreatorReducedCDCNoSL0SL1 class.

Definition at line 39 of file GeoCDCCreatorReducedCDCNoSL0SL1.h.

39{};

Member Function Documentation

◆ create()

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

Creates the ROOT Objects for the CDC geometry.

Parameters
contentA reference to the content part of the parameter description, which should to be used to create the ROOT objects.
topVolumeGeant4 top logical volume.
typeGeometry type.

Implements CreatorBase.

Definition at line 57 of file GeoCDCCreator.h.

58 {
59 CDCGeometry config = createConfiguration(content);
60 createGeometry(config, topVolume, type);
61 }

◆ createBox()

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 )
inherited

Create G4Box.

Definition at line 1635 of file GeoCDCCreator.cc.

1640 {
1641 const string solidName = (boost::format("solid%1%%2%") % name % id).str();
1642 const string logicalName = (boost::format("logical%1%%2%") % name % id).str();
1643 const string physicalName = (boost::format("physical%1%%2%") % name % id).str();
1644 G4Box* boxShape = new G4Box(solidName.c_str(), 0.5 * length * CLHEP::cm,
1645 0.5 * height * CLHEP::cm,
1646 0.5 * thick * CLHEP::cm);
1647 G4LogicalVolume* logicalV = new G4LogicalVolume(boxShape, med,
1648 logicalName.c_str(), 0, 0, 0);
1649 logicalV->SetVisAttributes(m_VisAttributes.back());
1650 new G4PVPlacement(0, G4ThreeVector(x * CLHEP::cm, y * CLHEP::cm, z * CLHEP::cm - thick * CLHEP::cm / 2.0), logicalV,
1651 physicalName.c_str(), m_logicalCDC, false, id);
1652
1653 }

◆ createCone()

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 )
inherited

Create G4Cone.

Definition at line 1594 of file GeoCDCCreator.cc.

1599 {
1600 const string solidName = "solid" + name;
1601 const string logicalName = "logical" + name;
1602 const string physicalName = "physical" + name;
1603 G4Cons* coverConeShape = new G4Cons(solidName.c_str(), rmin1 * CLHEP::cm, rmax1 * CLHEP::cm,
1604 rmin2 * CLHEP::cm, rmax2 * CLHEP::cm, thick * CLHEP::cm / 2.0, 0.*CLHEP::deg, 360.*CLHEP::deg);
1605 G4LogicalVolume* coverCone = new G4LogicalVolume(coverConeShape, med,
1606 logicalName.c_str(), 0, 0, 0);
1607 coverCone->SetVisAttributes(m_VisAttributes.back());
1608 new G4PVPlacement(0, G4ThreeVector(0.0, 0.0, posZ * CLHEP::cm - thick * CLHEP::cm / 2.0), coverCone,
1609 physicalName.c_str(), m_logicalCDC, false, id);
1610
1611 }

◆ createConfiguration()

CDCGeometry createConfiguration ( const GearDir & param)
inlineprivateinherited

Create DB object of CDC geometry from gearbox.

Definition at line 161 of file GeoCDCCreator.h.

162 {
163 CDCGeometry cdcGeometry;
164 cdcGeometry.read(param);
165 return cdcGeometry;
166 }

◆ createCover2s()

void createCover2s ( const CDCGeometry & geom)
inherited

Create CDC cover2s from DB.

Definition at line 1565 of file GeoCDCCreator.cc.

1566 {
1567 G4Material* medHV = geometry::Materials::get("CDCHVCable");
1568 G4Material* medFiber = geometry::Materials::get("CDCOpticalFiber");
1569 G4Material* medCAT7 = geometry::Materials::get("CDCCAT7");
1570 G4Material* medTRG = geometry::Materials::get("CDCOpticalFiberTRG");
1571
1572 m_VisAttributes.push_back(new G4VisAttributes(true, G4Colour(0., 1., 0.)));
1573 for (const auto& cover2 : geom.getCover2s()) {
1574 const int cover2ID = cover2.getId();
1575 const string cover2Name = "cover2" + to_string(cover2ID);
1576 const double rmin = cover2.getRmin();
1577 const double rmax = cover2.getRmax();
1578 const double phis = cover2.getPhis();
1579 const double dphi = cover2.getDphi();
1580 const double thick = cover2.getThick();
1581 const double posZ = cover2.getZ();
1582
1583 if (cover2ID < 11)
1584 createTube2(rmin, rmax, phis, dphi, thick, posZ, cover2ID, medHV, cover2Name);
1585 if (cover2ID > 10 && cover2ID < 14)
1586 createTube2(rmin, rmax, phis, dphi, thick, posZ, cover2ID, medFiber, cover2Name);
1587 if (cover2ID > 13 && cover2ID < 23)
1588 createTube2(rmin, rmax, phis, dphi, thick, posZ, cover2ID, medCAT7, cover2Name);
1589 if (cover2ID > 22 && cover2ID < 29)
1590 createTube2(rmin, rmax, phis, dphi, thick, posZ, cover2ID, medTRG, cover2Name);
1591 }
1592 }

◆ createCovers() [1/2]

void createCovers ( const CDCGeometry & geom)
inherited

Create CDC covers from DB.

Definition at line 1504 of file GeoCDCCreator.cc.

1505 {
1506 G4Material* medAl = geometry::Materials::get("Al");
1507 G4double density = 1.000 * CLHEP::g / CLHEP::cm3;
1508 G4double a = 1.01 * CLHEP::g / CLHEP::mole;
1509 G4Element* elH = new G4Element("Hydrogen", "H", 1., a);
1510 a = 16.00 * CLHEP::g / CLHEP::mole;
1511 G4Element* elO = new G4Element("Oxygen", "O", 8., a);
1512 G4Material* medH2O = new G4Material("water", density, 2);
1513 medH2O->AddElement(elH, 2);
1514 medH2O->AddElement(elO, 1);
1515 G4Material* medCu = geometry::Materials::get("Cu");
1516 G4Material* medLV = geometry::Materials::get("CDCLVCable");
1517 G4Material* medFiber = geometry::Materials::get("CDCOpticalFiber");
1518 G4Material* medCAT7 = geometry::Materials::get("CDCCAT7");
1519 G4Material* medTRG = geometry::Materials::get("CDCOpticalFiberTRG");
1520 G4Material* medHV = geometry::Materials::get("CDCHVCable");
1521
1522 m_VisAttributes.push_back(new G4VisAttributes(true, G4Colour(0., 1., 0.)));
1523 for (const auto& cover : geom.getCovers()) {
1524 const int coverID = cover.getId();
1525 const string coverName = "cover" + to_string(coverID);
1526 const double rmin1 = cover.getRmin1();
1527 const double rmin2 = cover.getRmin2();
1528 const double rmax1 = cover.getRmax1();
1529 const double rmax2 = cover.getRmax2();
1530 const double thick = cover.getThick();
1531 const double posZ = cover.getZ();
1532
1533 /*if (coverID == 7 || coverID == 10) {
1534 createCone(rmin1, rmax1, rmin2, rmax2, thick, posZ, coverID, medAl, coverName);
1535 } else {
1536 createTube(rmin1, rmax1, thick, posZ, coverID, medAl, coverName);
1537 }*/
1538 // ID dependent material definition
1539 if (coverID < 23) {
1540 if (coverID == 7 || coverID == 10) {
1541 createCone(rmin1, rmax1, rmin2, rmax2, thick, posZ, coverID, medAl, coverName);
1542 } else {
1543 createTube(rmin1, rmax1, thick, posZ, coverID, medAl, coverName);
1544 }
1545 }
1546 if (coverID > 22 && coverID < 29)
1547 createTube(rmin1, rmax1, thick, posZ, coverID, medCu, coverName);
1548 if (coverID > 28 && coverID < 35)
1549 createTorus(rmin1, rmax1, thick, posZ, coverID, medCu, coverName);
1550 if (coverID > 34 && coverID < 41)
1551 createTorus(rmin1, rmax1, thick, posZ, coverID, medH2O, coverName);
1552 if (coverID == 45 || coverID == 46)
1553 createTube(rmin1, rmax1, thick, posZ, coverID, medLV, coverName);
1554 if (coverID == 47 || coverID == 48)
1555 createTube(rmin1, rmax1, thick, posZ, coverID, medFiber, coverName);
1556 if (coverID == 49 || coverID == 50)
1557 createTube(rmin1, rmax1, thick, posZ, coverID, medCAT7, coverName);
1558 if (coverID == 51 || coverID == 52)
1559 createTube(rmin1, rmax1, thick, posZ, coverID, medTRG, coverName);
1560 if (coverID == 53)
1561 createTube(rmin1, rmax1, thick, posZ, coverID, medHV, coverName);
1562 }
1563 }

◆ createCovers() [2/2]

void createCovers ( const GearDir & content)
inherited

Create CDC covers from gear box.

Definition at line 1074 of file GeoCDCCreator.cc.

1075 {
1076 string Aluminum = content.getString("Aluminum");
1077 G4Material* medAluminum = geometry::Materials::get(Aluminum);
1078 G4Material* medNEMA_G10_Plate = geometry::Materials::get("NEMA_G10_Plate");
1079 G4double density = 1.000 * CLHEP::g / CLHEP::cm3;
1080 G4double a = 1.01 * CLHEP::g / CLHEP::mole;
1081 G4Element* elH = new G4Element("Hydrogen", "H", 1., a);
1082 a = 16.00 * CLHEP::g / CLHEP::mole;
1083 G4Element* elO = new G4Element("Oxygen", "O", 8., a);
1084 G4Material* medH2O = new G4Material("Water", density, 2);
1085 medH2O->AddElement(elH, 2);
1086 medH2O->AddElement(elO, 1);
1087 G4Material* medCopper = geometry::Materials::get("Cu");
1088 G4Material* medLV = geometry::Materials::get("CDCLVCable");
1089 G4Material* medFiber = geometry::Materials::get("CDCOpticalFiber");
1090 G4Material* medCAT7 = geometry::Materials::get("CDCCAT7");
1091 G4Material* medTRG = geometry::Materials::get("CDCOpticalFiberTRG");
1092 G4Material* medHV = geometry::Materials::get("CDCHVCable");
1093
1094 m_VisAttributes.push_back(new G4VisAttributes(true, G4Colour(0., 1., 0.)));
1095 const int nCover = content.getNumberNodes("Covers/Cover");
1096 for (int iCover = 0; iCover < nCover; ++iCover) {
1097 GearDir coverContent(content);
1098 coverContent.append((boost::format("/Covers/Cover[%1%]/") % (iCover + 1)).str());
1099 const string scoverID = coverContent.getString("@id");
1100 const int coverID = atoi(scoverID.c_str());
1101 const string coverName = coverContent.getString("Name");
1102 const double coverInnerR1 = coverContent.getLength("InnerR1");
1103 const double coverInnerR2 = coverContent.getLength("InnerR2");
1104 const double coverOuterR1 = coverContent.getLength("OuterR1");
1105 const double coverOuterR2 = coverContent.getLength("OuterR2");
1106 const double coverThick = coverContent.getLength("Thickness");
1107 const double coverPosZ = coverContent.getLength("PosZ");
1108
1109 const double rmin1 = coverInnerR1;
1110 const double rmax1 = coverOuterR1;
1111 const double rmin2 = coverInnerR2;
1112 const double rmax2 = coverOuterR2;
1113
1114 /*
1115 if (coverID == 7 || coverID == 10) {
1116 createCone(rmin1, rmax1, rmin2, rmax2, coverThick, coverPosZ, coverID, medAluminum, coverName);
1117 } else {
1118 createTube(rmin1, rmax1, coverThick, coverPosZ, coverID, medAluminum, coverName);
1119
1120 }*/
1121 // ID dependent material definition
1122 if (coverID < 23) {
1123 if (coverID == 7 || coverID == 10) {// cones
1124 createCone(rmin1, rmax1, rmin2, rmax2, coverThick, coverPosZ, coverID, medAluminum, coverName);
1125 } else {// covers
1126 createTube(rmin1, rmax1, coverThick, coverPosZ, coverID, medAluminum, coverName);
1127 }
1128 }
1129 if (coverID > 22 && coverID < 29)// cooling plate
1130 createTube(rmin1, rmax1, coverThick, coverPosZ, coverID, medCopper, coverName);
1131 if (coverID > 28 && coverID < 35)// cooling Pipe
1132 createTorus(rmin1, rmax1, coverThick, coverPosZ, coverID, medCopper, coverName);
1133 if (coverID > 34 && coverID < 41)// cooling water
1134 createTorus(rmin1, rmax1, coverThick, coverPosZ, coverID, medH2O, coverName);
1135 if (coverID == 45 || coverID == 46)
1136 createTube(rmin1, rmax1, coverThick, coverPosZ, coverID, medLV, coverName);
1137 if (coverID == 47 || coverID == 48)
1138 createTube(rmin1, rmax1, coverThick, coverPosZ, coverID, medFiber, coverName);
1139 if (coverID == 49 || coverID == 50)
1140 createTube(rmin1, rmax1, coverThick, coverPosZ, coverID, medCAT7, coverName);
1141 if (coverID == 51 || coverID == 52)
1142 createTube(rmin1, rmax1, coverThick, coverPosZ, coverID, medTRG, coverName);
1143 if (coverID == 53)
1144 createTube(rmin1, rmax1, coverThick, coverPosZ, coverID, medHV, coverName);
1145 }
1146
1147 const int nCover2 = content.getNumberNodes("Covers/Cover2");
1148 for (int iCover2 = 0; iCover2 < nCover2; ++iCover2) {
1149 GearDir cover2Content(content);
1150 cover2Content.append((boost::format("/Cover2s/Cover2[%1%]/") % (iCover2 + 1)).str());
1151 const string scover2ID = cover2Content.getString("@id");
1152 const int cover2ID = atoi(scover2ID.c_str());
1153 const string cover2Name = cover2Content.getString("Name");
1154 const double cover2InnerR = cover2Content.getLength("InnerR");
1155 const double cover2OuterR = cover2Content.getLength("OuterR");
1156 const double cover2StartPhi = cover2Content.getLength("StartPhi");
1157 const double cover2DeltaPhi = cover2Content.getLength("DeltaPhi");
1158 const double cover2Thick = cover2Content.getLength("Thickness");
1159 const double cover2PosZ = cover2Content.getLength("PosZ");
1160
1161 if (cover2ID < 11)
1162 createTube2(cover2InnerR, cover2OuterR, cover2StartPhi, cover2DeltaPhi, cover2Thick, cover2PosZ, cover2ID, medHV, cover2Name);
1163 if (cover2ID > 10 && cover2ID < 14)
1164 createTube2(cover2InnerR, cover2OuterR, cover2StartPhi, cover2DeltaPhi, cover2Thick, cover2PosZ, cover2ID, medFiber, cover2Name);
1165 if (cover2ID > 13 && cover2ID < 23)
1166 createTube2(cover2InnerR, cover2OuterR, cover2StartPhi, cover2DeltaPhi, cover2Thick, cover2PosZ, cover2ID, medCAT7, cover2Name);
1167 if (cover2ID > 22 && cover2ID < 29)
1168 createTube2(cover2InnerR, cover2OuterR, cover2StartPhi, cover2DeltaPhi, cover2Thick, cover2PosZ, cover2ID, medTRG, cover2Name);
1169 }
1170
1171 const int nRibs = content.getNumberNodes("Covers/Rib");
1172 for (int iRib = 0; iRib < nRibs; ++iRib) {
1173 GearDir ribContent(content);
1174 ribContent.append((boost::format("/Covers/Rib[%1%]/") % (iRib + 1)).str());
1175 const string sribID = ribContent.getString("@id");
1176 const int ribID = atoi(sribID.c_str());
1177 // const string ribName = ribContent.getString("Name");
1178 const double length = ribContent.getLength("Length");
1179 const double width = ribContent.getLength("Width");
1180 const double thick = ribContent.getLength("Thickness");
1181 const double rotX = ribContent.getLength("RotX");
1182 const double rotY = ribContent.getLength("RotY");
1183 const double rotZ = ribContent.getLength("RotZ");
1184 const double cX = ribContent.getLength("PosX");
1185 const double cY = ribContent.getLength("PosY");
1186 const double cZ = ribContent.getLength("PosZ");
1187 const int offset = atoi((ribContent.getString("Offset")).c_str());
1188 const int number = atoi((ribContent.getString("NDiv")).c_str());
1189
1190 const string solidName = "solidRib" + to_string(ribID);
1191 const string logicalName = "logicalRib" + to_string(ribID);
1192 G4Box* boxShape = new G4Box(solidName, 0.5 * length * CLHEP::cm,
1193 0.5 * width * CLHEP::cm,
1194 0.5 * thick * CLHEP::cm);
1195 const double rmax = 0.5 * length;
1196 const double rmin = max((rmax - thick), 0.);
1197 G4Tubs* tubeShape = new G4Tubs(solidName,
1198 rmin * CLHEP::cm,
1199 rmax * CLHEP::cm,
1200 0.5 * width * CLHEP::cm,
1201 0.,
1202 360. * CLHEP::deg);
1203
1204 //G4LogicalVolume* logicalV = new G4LogicalVolume(boxShape, medAluminum,
1205 // logicalName, 0, 0, 0);
1206 // ID dependent material definition Aluminum is default
1207 G4LogicalVolume* logicalV = new G4LogicalVolume(boxShape, medAluminum, logicalName, 0, 0, 0);
1208 if (ribID > 39 && ribID < 78) // Cu box
1209 logicalV = new G4LogicalVolume(boxShape, medCopper, logicalName, 0, 0, 0);
1210 if ((ribID > 77 && ribID < 94) || (ribID > 131 && ribID < 146)) // G10 box
1211 logicalV = new G4LogicalVolume(boxShape, medNEMA_G10_Plate, logicalName, 0, 0, 0);
1212 if (ribID > 93 && ribID < 110) // Cu tube
1213 logicalV = new G4LogicalVolume(tubeShape, medCopper, logicalName, 0, 0, 0);
1214 if (ribID > 109 && ribID < 126) // H2O tube (rmin = 0)
1215 logicalV = new G4LogicalVolume(tubeShape, medH2O, logicalName, 0, 0, 0);
1216 [[clang::suppress]]
1217 if (ribID > 127 && ribID < 132) // cppcheck-suppress syntaxError // HV bundle
1218 logicalV = new G4LogicalVolume(boxShape, medHV, logicalName, 0, 0, 0);
1219 /*if( ribID > 145 && ribID < 149 )// Fiber box
1220 logicalV = new G4LogicalVolume(boxShape, medFiber, logicalName, 0, 0, 0);
1221 if( ribID > 148 && ribID < 158 )// Fiber box
1222 logicalV = new G4LogicalVolume(boxShape, medCAT7, logicalName, 0, 0, 0);
1223 if( ribID > 157 && ribID < 164 )// Fiber box
1224 logicalV = new G4LogicalVolume(boxShape, medTRG, logicalName, 0, 0, 0);*/
1225
1226 logicalV->SetVisAttributes(m_VisAttributes.back());
1227
1228 const double phi = 360.0 / number;
1229
1230 G4RotationMatrix rot = G4RotationMatrix();
1231
1232 double dz = thick;
1233 if (ribID > 93 && ribID < 126) dz = 0;
1234 G4ThreeVector arm(cX * CLHEP::cm, cY * CLHEP::cm, cZ * CLHEP::cm - dz * CLHEP::cm / 2.0);
1235
1236 rot.rotateX(rotX);
1237 rot.rotateY(rotY);
1238 rot.rotateZ(rotZ);
1239 if (offset) {
1240 rot.rotateZ(0.5 * phi * CLHEP::deg);
1241 arm.rotateZ(0.5 * phi * CLHEP::deg);
1242 }
1243 for (int i = 0; i < number; ++i) {
1244 const string physicalName = "physicalRib_" + to_string(ribID) + " " + to_string(i);
1245 new G4PVPlacement(G4Transform3D(rot, arm), logicalV,
1246 physicalName.c_str(), m_logicalCDC, false, ribID);
1247 rot.rotateZ(phi * CLHEP::deg);
1248 arm.rotateZ(phi * CLHEP::deg);
1249 }
1250
1251 }// rib
1252
1253 const int nRib2s = content.getNumberNodes("Covers/Rib2");
1254 for (int iRib2 = 0; iRib2 < nRib2s; ++iRib2) {
1255 GearDir rib2Content(content);
1256 rib2Content.append((boost::format("/Covers/Rib2[%1%]/") % (iRib2 + 1)).str());
1257 const string srib2ID = rib2Content.getString("@id");
1258 const int rib2ID = atoi(srib2ID.c_str());
1259 // const string rib2Name = rib2Content.getString("Name");
1260 const double length = rib2Content.getLength("Length");
1261 const double width = rib2Content.getLength("Width");
1262 const double thick = rib2Content.getLength("Thickness");
1263 const double width2 = rib2Content.getLength("Width2");
1264 const double thick2 = rib2Content.getLength("Thickness2");
1265 const double rotX = rib2Content.getLength("RotX");
1266 const double rotY = rib2Content.getLength("RotY");
1267 const double rotZ = rib2Content.getLength("RotZ");
1268 const double cX = rib2Content.getLength("PosX");
1269 const double cY = rib2Content.getLength("PosY");
1270 const double cZ = rib2Content.getLength("PosZ");
1271 const int number = atoi((rib2Content.getString("NDiv")).c_str());
1272
1273 const string solidName = "solidRib2" + to_string(rib2ID);
1274 const string logicalName = "logicalRib2" + to_string(rib2ID);
1275 G4Trd* trdShape = new G4Trd(solidName,
1276 0.5 * thick * CLHEP::cm,
1277 0.5 * thick2 * CLHEP::cm,
1278 0.5 * width * CLHEP::cm,
1279 0.5 * width2 * CLHEP::cm,
1280 0.5 * length * CLHEP::cm);
1281
1282 G4LogicalVolume* logicalV = new G4LogicalVolume(trdShape, medAluminum, logicalName, 0, 0, 0);
1283 if (rib2ID > 0)
1284 logicalV = new G4LogicalVolume(trdShape, medCopper, logicalName, 0, 0, 0);
1285
1286 [[clang::suppress]]
1287 logicalV->SetVisAttributes(m_VisAttributes.back());
1288
1289 const double phi = 360.0 / number;
1290
1291 G4RotationMatrix rot = G4RotationMatrix();
1292 G4ThreeVector arm(cX * CLHEP::cm, cY * CLHEP::cm, cZ * CLHEP::cm - thick * CLHEP::cm / 2.0);
1293
1294 rot.rotateX(rotX);
1295 rot.rotateY(rotY);
1296 rot.rotateZ(rotZ);
1297 for (int i = 0; i < number; ++i) {
1298 const string physicalName = "physicalRib2_" + to_string(rib2ID) + " " + to_string(i);
1299 new G4PVPlacement(G4Transform3D(rot, arm), logicalV,
1300 physicalName.c_str(), m_logicalCDC, false, rib2ID);
1301 rot.rotateZ(phi * CLHEP::deg);
1302 arm.rotateZ(phi * CLHEP::deg);
1303 }
1304
1305 }// rib2
1306
1307 const int nRib3s = content.getNumberNodes("Covers/Rib3");
1308 for (int iRib3 = 0; iRib3 < nRib3s; ++iRib3) {
1309 GearDir rib3Content(content);
1310 rib3Content.append((boost::format("/Covers/Rib3[%1%]/") % (iRib3 + 1)).str());
1311 const string srib3ID = rib3Content.getString("@id");
1312 const int rib3ID = atoi(srib3ID.c_str());
1313 // const string rib3Name = rib3Content.getString("Name");
1314 const double length = rib3Content.getLength("Length");
1315 const double width = rib3Content.getLength("Width");
1316 const double thick = rib3Content.getLength("Thickness");
1317 const double r = rib3Content.getLength("HoleR");
1318 const double cX = rib3Content.getLength("PosX");
1319 const double cY = rib3Content.getLength("PosY");
1320 const double cZ = rib3Content.getLength("PosZ");
1321 const double hX = rib3Content.getLength("HoleX");
1322 const double hY = rib3Content.getLength("HoleY");
1323 const double hZ = rib3Content.getLength("HoleZ");
1324 const int offset = atoi((rib3Content.getString("Offset")).c_str());
1325 const int number = atoi((rib3Content.getString("NDiv")).c_str());
1326
1327 const string logicalName = "logicalRib3" + to_string(rib3ID);
1328 G4VSolid* boxShape = new G4Box("Block",
1329 0.5 * length * CLHEP::cm,
1330 0.5 * width * CLHEP::cm,
1331 0.5 * thick * CLHEP::cm);
1332 G4VSolid* tubeShape = new G4Tubs("Hole",
1333 0.,
1334 r * CLHEP::cm,
1335 length * CLHEP::cm,
1336 0.,
1337 360. * CLHEP::deg);
1338 G4RotationMatrix rotsub = G4RotationMatrix();
1339 G4ThreeVector trnsub(cX * CLHEP::cm - hX * CLHEP::cm, cY * CLHEP::cm - hY * CLHEP::cm,
1340 cZ * CLHEP::cm - hZ * CLHEP::cm + 0.5 * thick * CLHEP::cm);
1341 G4VSolid* coolingBlock = new G4SubtractionSolid("Block-Hole",
1342 boxShape,
1343 tubeShape,
1344 G4Transform3D(rotsub,
1345 trnsub));
1346
1347 G4LogicalVolume* logicalV = new G4LogicalVolume(coolingBlock, medCopper, logicalName, 0, 0, 0);
1348
1349 logicalV->SetVisAttributes(m_VisAttributes.back());
1350
1351 const double phi = 360.0 / number;
1352
1353 G4RotationMatrix rot = G4RotationMatrix();
1354 G4ThreeVector arm(cX * CLHEP::cm, cY * CLHEP::cm, cZ * CLHEP::cm - thick * CLHEP::cm / 2.0);
1355
1356 if (offset) {
1357 rot.rotateZ(0.5 * phi * CLHEP::deg);
1358 arm.rotateZ(0.5 * phi * CLHEP::deg);
1359 }
1360 for (int i = 0; i < number; ++i) {
1361 const string physicalName = "physicalRib3_" + to_string(rib3ID) + " " + to_string(i);
1362 new G4PVPlacement(G4Transform3D(rot, arm), logicalV,
1363 physicalName.c_str(), m_logicalCDC, false, rib3ID);
1364 rot.rotateZ(phi * CLHEP::deg);
1365 arm.rotateZ(phi * CLHEP::deg);
1366 }
1367
1368 }// rib3
1369
1370 const int nRib4s = content.getNumberNodes("Covers/Rib4");
1371 for (int iRib4 = 0; iRib4 < nRib4s; ++iRib4) {
1372 GearDir rib4Content(content);
1373 rib4Content.append((boost::format("/Covers/Rib4[%1%]/") % (iRib4 + 1)).str());
1374 const string srib4ID = rib4Content.getString("@id");
1375 const int rib4ID = atoi(srib4ID.c_str());
1376 // const string rib4Name = rib4Content.getString("Name");
1377 const double length = rib4Content.getLength("Length");
1378 const double width = rib4Content.getLength("Width");
1379 const double thick = rib4Content.getLength("Thickness");
1380 const double length2 = rib4Content.getLength("Length2");
1381 const double width2 = rib4Content.getLength("Width2");
1382 const double thick2 = rib4Content.getLength("Thickness2");
1383 const double cX = rib4Content.getLength("PosX");
1384 const double cY = rib4Content.getLength("PosY");
1385 const double cZ = rib4Content.getLength("PosZ");
1386 const double hX = rib4Content.getLength("HoleX");
1387 const double hY = rib4Content.getLength("HoleY");
1388 const double hZ = rib4Content.getLength("HoleZ");
1389 const int offset = atoi((rib4Content.getString("Offset")).c_str());
1390 const int number = atoi((rib4Content.getString("NDiv")).c_str());
1391
1392 const string logicalName = "logicalRib4" + to_string(rib4ID);
1393 G4VSolid* baseShape = new G4Box("Base",
1394 0.5 * length * CLHEP::cm,
1395 0.5 * width * CLHEP::cm,
1396 0.5 * thick * CLHEP::cm);
1397 G4VSolid* sqShape = new G4Box("Sq",
1398 0.5 * length2 * CLHEP::cm,
1399 0.5 * width2 * CLHEP::cm,
1400 0.5 * thick2 * CLHEP::cm);
1401 G4RotationMatrix rotsub = G4RotationMatrix();
1402 double dzc = (hZ - thick2 / 2.) - (cZ - thick / 2.);
1403 G4ThreeVector trnsub(hX * CLHEP::cm - cX * CLHEP::cm,
1404 hY * CLHEP::cm - cY * CLHEP::cm,
1405 dzc * CLHEP::cm);
1406 G4VSolid* sqHoleBase = new G4SubtractionSolid("Base-Sq",
1407 baseShape,
1408 sqShape,
1409 G4Transform3D(rotsub,
1410 trnsub)
1411 );
1412
1413 G4LogicalVolume* logicalV = new G4LogicalVolume(sqHoleBase, medCopper, logicalName, 0, 0, 0);
1414 if (rib4ID < 19)
1415 logicalV = new G4LogicalVolume(sqHoleBase, medNEMA_G10_Plate, logicalName, 0, 0, 0);
1416
1417 logicalV->SetVisAttributes(m_VisAttributes.back());
1418
1419 const double phi = 360.0 / number;
1420
1421 G4RotationMatrix rot = G4RotationMatrix();
1422 G4ThreeVector arm(cX * CLHEP::cm, cY * CLHEP::cm, cZ * CLHEP::cm - thick * CLHEP::cm / 2.0);
1423
1424 if (offset) {
1425 rot.rotateZ(0.5 * phi * CLHEP::deg);
1426 arm.rotateZ(0.5 * phi * CLHEP::deg);
1427 }
1428 for (int i = 0; i < number; ++i) {
1429 const string physicalName = "physicalRib4_" + to_string(rib4ID) + " " + to_string(i);
1430 new G4PVPlacement(G4Transform3D(rot, arm), logicalV,
1431 physicalName.c_str(), m_logicalCDC, false, rib4ID);
1432 rot.rotateZ(phi * CLHEP::deg);
1433 arm.rotateZ(phi * CLHEP::deg);
1434 }
1435
1436 }// rib4
1437
1438 const int nRib5s = content.getNumberNodes("Covers/Rib5");
1439 for (int iRib5 = 0; iRib5 < nRib5s; ++iRib5) {
1440 GearDir rib5Content(content);
1441 rib5Content.append((boost::format("/Covers/Rib5[%1%]/") % (iRib5 + 1)).str());
1442 const string srib5ID = rib5Content.getString("@id");
1443 const int rib5ID = atoi(srib5ID.c_str());
1444 // const string rib5Name = rib5Content.getString("Name");
1445 const double dr = rib5Content.getLength("DeltaR");
1446 const double dz = rib5Content.getLength("DeltaZ");
1447 const double width = rib5Content.getLength("Width");
1448 const double thick = rib5Content.getLength("Thickness");
1449 const double rin = rib5Content.getLength("Rin");
1450 const double rotX = rib5Content.getLength("RotX");
1451 const double rotY = rib5Content.getLength("RotY");
1452 const double rotZ = rib5Content.getLength("RotZ");
1453 const double cX = rib5Content.getLength("PosX");
1454 const double cY = rib5Content.getLength("PosY");
1455 const double cZ = rib5Content.getLength("PosZ");
1456 const int offset = atoi((rib5Content.getString("Offset")).c_str());
1457 const int number = atoi((rib5Content.getString("NDiv")).c_str());
1458
1459 const string solidName = "solidRib5" + to_string(rib5ID);
1460 const string logicalName = "logicalRib5" + to_string(rib5ID);
1461 const double rmax = rin + thick;
1462 const double rmin = rin;
1463 const double dphi = 2. * atan2(dz, dr);
1464 const double ddphi = thick * tan(dphi) / rin;
1465 const double ddphi2 = width / 2. * width / 2. / (cX + dr) / rin;
1466 const double cphi = dphi - ddphi - ddphi2;
1467 G4Tubs* tubeShape = new G4Tubs(solidName,
1468 rmin * CLHEP::cm,
1469 rmax * CLHEP::cm,
1470 0.5 * width * CLHEP::cm,
1471 0.,
1472 cphi);
1473
1474 G4LogicalVolume* logicalV = new G4LogicalVolume(tubeShape, medAluminum, logicalName, 0, 0, 0);
1475
1476 logicalV->SetVisAttributes(m_VisAttributes.back());
1477
1478 const double phi = 360.0 / number;
1479
1480 G4RotationMatrix rot = G4RotationMatrix();
1481
1482 //G4ThreeVector arm(cX * CLHEP::cm, cY * CLHEP::cm, cZ * CLHEP::cm - thick * CLHEP::cm / 2.0);
1483 G4ThreeVector arm(cX * CLHEP::cm, cY * CLHEP::cm, cZ * CLHEP::cm - rin * CLHEP::cm - thick * CLHEP::cm);
1484
1485 rot.rotateX(rotX);
1486 rot.rotateY(rotY);
1487 rot.rotateZ(rotZ);
1488 if (offset) {
1489 rot.rotateZ(0.5 * phi * CLHEP::deg);
1490 arm.rotateZ(0.5 * phi * CLHEP::deg);
1491 }
1492 for (int i = 0; i < number; ++i) {
1493 const string physicalName = "physicalRib5_" + to_string(rib5ID) + " " + to_string(i);
1494 new G4PVPlacement(G4Transform3D(rot, arm), logicalV,
1495 physicalName.c_str(), m_logicalCDC, false, rib5ID);
1496 rot.rotateZ(phi * CLHEP::deg);
1497 arm.rotateZ(phi * CLHEP::deg);
1498 }
1499 }//rib5
1500
1501 }

◆ createFromDB()

virtual void createFromDB ( const std::string & name,
G4LogicalVolume & topVolume,
geometry::GeometryTypes type )
inlineoverridevirtualinherited

Create geometry from DB.

Reimplemented from CreatorBase.

Definition at line 66 of file GeoCDCCreator.h.

67 {
68 DBObjPtr<CDCGeometry> geo;
69 if (!geo) {
70 B2FATAL("No configuration for " << name << " found.");
71 }
72 createGeometry(*geo, topVolume, type);
73 }

◆ createGeometry()

void createGeometry ( const CDCGeometry & parameters,
G4LogicalVolume & topVolume,
geometry::GeometryTypes type )
privateinherited

Create G4 geometry of CDC.

Definition at line 90 of file GeoCDCCreator.cc.

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
148 CDCGeometryPar& cdcgp = CDCGeometryPar::Instance(&geo);
149 const CDCGeoControlPar& gcp = CDCGeoControlPar::getInstance();
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 // Get parameters for sensitive layer: left, middle and right.
248 double rmin_sensitive_left, rmax_sensitive_left;
249 double rmin_sensitive_middle, rmax_sensitive_middle;
250 double rmin_sensitive_right, rmax_sensitive_right;
251 double zback_sensitive_left, zfor_sensitive_left;
252 double zback_sensitive_middle, zfor_sensitive_middle;
253 double zback_sensitive_right, zfor_sensitive_right;
254
255 if (not getEndplateInformation(geo, iSLayer,
256 rmin_sensitive_left, rmax_sensitive_left, zback_sensitive_left, zfor_sensitive_left,
257 rmin_sensitive_middle, rmax_sensitive_middle, zback_sensitive_middle, zfor_sensitive_middle,
258 rmin_sensitive_right, rmax_sensitive_right, zback_sensitive_right, zfor_sensitive_right)) {
259 continue;
260 }
261
262 // Check if build left sensitive tube
263 if ((zfor_sensitive_left - zback_sensitive_left) > length_feedthrough) {
264 // std::cout <<"left doif " << iSLayer <<" "<< zfor_sensitive_left - zback_sensitive_left << std::endl;
265 //==========================================================
266 // zback_sensitive_left
267 // |
268 // \|/
269 // _____________________
270 // | |// 1 // | |
271 // | |==ft====|2 | (ft = feedthrouth)
272 // |_______|____1___|__|
273 // |_______|___________|
274 // |
275 // \|/
276 // zfor_sensitive_left
277 //==========================================================
278
279 // Build a tube with metarial cdcMed for area 1
280 G4Tubs* leftTubeShape = new G4Tubs((boost::format("solidCDCLayer_%1%_leftTube") % iSLayer).str().c_str(),
281 rmin_sensitive_left * CLHEP::cm,
282 rmax_sensitive_left * CLHEP::cm, length_feedthrough * CLHEP::cm / 2.0, 0 * CLHEP::deg, 360.*CLHEP::deg);
283 G4LogicalVolume* leftTube = new G4LogicalVolume(leftTubeShape, cdcMed,
284 (boost::format("logicalCDCLayer_%1%_leftTube") % iSLayer).str().c_str(), 0, 0, 0);
285 new G4PVPlacement(0, G4ThreeVector(0.0, 0.0, (zback_sensitive_left + length_feedthrough / 2.0)*CLHEP::cm), leftTube,
286 (boost::format("physicalCDCLayer_%1%_leftTube") % iSLayer).str().c_str(), m_logicalCDC, false, iSLayer);
287 // Build left sensitive tube (area 2)
288 G4Tubs* leftSensitiveTubeShape = new G4Tubs((boost::format("solidSD_CDCLayer_%1%_left") % iSLayer).str().c_str(),
289 rmin_sensitive_left * CLHEP::cm, rmax_sensitive_left * CLHEP::cm,
290 (zfor_sensitive_left - zback_sensitive_left - length_feedthrough)*CLHEP::cm / 2.0, 0 * CLHEP::deg, 360.*CLHEP::deg);
291 G4LogicalVolume* leftSensitiveTube = new G4LogicalVolume(leftSensitiveTubeShape, cdcMed,
292 (boost::format("logicalSD_CDCLayer_%1%_left") % iSLayer).str().c_str(), 0, 0, 0);
293 leftSensitiveTube->SetSensitiveDetector(m_sensitive);
294 new G4PVPlacement(0, G4ThreeVector(0.0, 0.0, (zfor_sensitive_left + zback_sensitive_left + length_feedthrough)*CLHEP::cm / 2.0),
295 leftSensitiveTube, (boost::format("physicalSD_CDCLayer_%1%_left") % iSLayer).str().c_str(), m_logicalCDC, false, iSLayer);
296 } else {
297 // std::cout <<"left doelse " << iSLayer << std::endl;
298 //==========================================================
299 // zback_sensitive_left
300 // |
301 // \|/
302 // _________________________
303 // | |//// 1 ////| 2 |
304 // | |======ft======== (ft = feedthrouth)
305 // |_______|____1______| 2 |
306 // |_______|___________|___|
307 // |
308 // \|/
309 // zfor_sensitive_left
310 //==========================================================
311
312 // Build a tube with metarial cdcMed for area 1
313 G4Tubs* leftTubeShape = new G4Tubs((boost::format("solidCDCLayer_%1%_leftTube") % iSLayer).str().c_str(),
314 rmin_sensitive_left * CLHEP::cm,
315 rmax_sensitive_left * CLHEP::cm, (zfor_sensitive_left - zback_sensitive_left)*CLHEP::cm / 2.0, 0 * CLHEP::deg, 360.*CLHEP::deg);
316 G4LogicalVolume* leftTube = new G4LogicalVolume(leftTubeShape, cdcMed,
317 (boost::format("logicalCDCLayer_%1%_leftTube") % iSLayer).str().c_str(), 0, 0, 0);
318 new G4PVPlacement(0, G4ThreeVector(0.0, 0.0, (zfor_sensitive_left + zback_sensitive_left)*CLHEP::cm / 2.0), leftTube,
319 (boost::format("physicalCDCLayer_%1%_leftTube") % iSLayer).str().c_str(), m_logicalCDC, false, iSLayer);
320
321
322 // Build a tube with metarial cdcMed for area 2
323 G4Tubs* leftMidTubeShape = new G4Tubs((boost::format("solidCDCLayer_%1%_leftMidTube") % iSLayer).str().c_str(),
324 rmin_sensitive_middle * CLHEP::cm, rmax_sensitive_middle * CLHEP::cm,
325 (length_feedthrough - zfor_sensitive_left + zback_sensitive_left)*CLHEP::cm / 2.0, 0 * CLHEP::deg, 360.*CLHEP::deg);
326 G4LogicalVolume* leftMidTube = new G4LogicalVolume(leftMidTubeShape, cdcMed,
327 (boost::format("logicalCDCLayer_%1%_leftMidTube") % iSLayer).str().c_str(), 0, 0, 0);
328
329 new G4PVPlacement(0, G4ThreeVector(0.0, 0.0, (length_feedthrough + zfor_sensitive_left + zback_sensitive_left)*CLHEP::cm / 2.0),
330 leftMidTube, (boost::format("physicalCDCLayer_%1%_leftMidTube") % iSLayer).str().c_str(), m_logicalCDC, false, iSLayer);
331
332 // Reset zback_sensitive_middle
333 zback_sensitive_middle = length_feedthrough + zback_sensitive_left;
334 }
335
336 // Check if build right sensitive tube
337 if ((zfor_sensitive_right - zback_sensitive_right) > length_feedthrough) {
338 // std::cout <<"right doif" << iSLayer <<" "<< zfor_sensitive_right - zback_sensitive_right << std::endl;
339 //==========================================================
340 // zfor_sensitive_right
341 // |
342 // \|/
343 // _____________________________
344 // | | 1 |///////|
345 // | 2 |====ft=====|///////| (ft = feedthrouth)
346 // |_______|____1______|_______|
347 // |_______|___________|_______|
348 // |
349 // \|/
350 // zback_sensitive_right
351 //==========================================================
352
353 // Build a tube with metarial cdcMed for area 1
354 G4Tubs* rightTubeShape = new G4Tubs((boost::format("solidCDCLayer_%1%_rightTube") % iSLayer).str().c_str(),
355 rmin_sensitive_right * CLHEP::cm, rmax_sensitive_right * CLHEP::cm, length_feedthrough * CLHEP::cm / 2.0, 0 * CLHEP::deg,
356 360.*CLHEP::deg);
357 G4LogicalVolume* rightTube = new G4LogicalVolume(rightTubeShape, cdcMed,
358 (boost::format("logicalCDCLayer_%1%_rightTube") % iSLayer).str().c_str(), 0, 0, 0);
359
360 new G4PVPlacement(0, G4ThreeVector(0.0, 0.0, (zfor_sensitive_right - length_feedthrough / 2.0)*CLHEP::cm), rightTube,
361 (boost::format("physicalCDCLayer_%1%_rightTube") % iSLayer).str().c_str(), m_logicalCDC, false, iSLayer);
362
363
364 // Build right sensitive tube (area 2)
365 G4Tubs* rightSensitiveTubeShape = new G4Tubs((boost::format("solidSD_CDCLayer_%1%_right") % iSLayer).str().c_str(),
366 rmin_sensitive_right * CLHEP::cm, rmax_sensitive_right * CLHEP::cm,
367 (zfor_sensitive_right - zback_sensitive_right - length_feedthrough)*CLHEP::cm / 2.0, 0 * CLHEP::deg, 360.*CLHEP::deg);
368 G4LogicalVolume* rightSensitiveTube = new G4LogicalVolume(rightSensitiveTubeShape, cdcMed,
369 (boost::format("logicalSD_CDCLayer_%1%_right") % iSLayer).str().c_str(), 0, 0, 0);
370 rightSensitiveTube->SetSensitiveDetector(m_sensitive);
371
372 new G4PVPlacement(0, G4ThreeVector(0.0, 0.0, (zfor_sensitive_right + zback_sensitive_right - length_feedthrough)*CLHEP::cm / 2.0),
373 rightSensitiveTube, (boost::format("physicalSD_CDCLayer_%1%_right") % iSLayer).str().c_str(), m_logicalCDC, false, iSLayer);
374
375 } else {
376 // std::cout <<"right doelse" << iSLayer << std::endl;
377 //==========================================================
378 // zfor_sensitive_right
379 // |
380 // \|/
381 // _____________________________
382 // | | 1 |///////|
383 // |============ft=====|///////| (ft = feedthrouth)
384 // | |____1______|_______|
385 // |_______|___________|_______|
386 // |
387 // \|/
388 // zback_sensitive_right
389 //==========================================================
390
391 // Build a tube with metarial cdcMed for area 1
392 G4Tubs* rightTubeShape = new G4Tubs((boost::format("solidCDCLayer_%1%_rightTube") % iSLayer).str().c_str(),
393 rmin_sensitive_right * CLHEP::cm, rmax_sensitive_right * CLHEP::cm, (zfor_sensitive_right - zback_sensitive_right)*CLHEP::cm / 2.0,
394 0 * CLHEP::deg, 360.*CLHEP::deg);
395 G4LogicalVolume* rightTube = new G4LogicalVolume(rightTubeShape, cdcMed,
396 (boost::format("logicalCDCLayer_%1%_rightTube") % iSLayer).str().c_str(), 0, 0, 0);
397
398 new G4PVPlacement(0, G4ThreeVector(0.0, 0.0, (zfor_sensitive_right + zback_sensitive_right)*CLHEP::cm / 2.0), rightTube,
399 (boost::format("physicalCDCLayer_%1%_rightTube") % iSLayer).str().c_str(), m_logicalCDC, false, iSLayer);
400
401
402 // Build a tube with metarial cdcMed for area 2
403 G4Tubs* rightMidTubeShape = new G4Tubs((boost::format("solidCDCLayer_%1%_rightMidTube") % iSLayer).str().c_str(),
404 rmin_sensitive_middle * CLHEP::cm, rmax_sensitive_middle * CLHEP::cm,
405 (length_feedthrough - zfor_sensitive_right + zback_sensitive_right)*CLHEP::cm / 2.0, 0 * CLHEP::deg, 360.*CLHEP::deg);
406 G4LogicalVolume* rightMidTube = new G4LogicalVolume(rightMidTubeShape, cdcMed,
407 (boost::format("logicalCDCLayer_%1%_rightMidTube") % iSLayer).str().c_str(), 0, 0, 0);
408 new G4PVPlacement(0, G4ThreeVector(0.0, 0.0, (zback_sensitive_right - length_feedthrough + zfor_sensitive_right)*CLHEP::cm / 2.0),
409 rightMidTube, (boost::format("physicalCDCLayer_%1%_rightMidTube") % iSLayer).str().c_str(), m_logicalCDC, false, iSLayer);
410
411 // Reset zback_sensitive_middle
412 zfor_sensitive_middle = zfor_sensitive_right - length_feedthrough;
413 }
414
415
416 // Middle sensitive tube
417 G4Tubs* middleSensitiveTubeShape = new G4Tubs((boost::format("solidSD_CDCLayer_%1%_middle") % iSLayer).str().c_str(),
418 rmin_sensitive_middle * CLHEP::cm, rmax_sensitive_middle * CLHEP::cm,
419 (zfor_sensitive_middle - zback_sensitive_middle)*CLHEP::cm / 2.0, 0 * CLHEP::deg, 360.*CLHEP::deg);
420 G4LogicalVolume* middleSensitiveTube = new G4LogicalVolume(middleSensitiveTubeShape, cdcMedGas,
421 (boost::format("logicalSD_CDCLayer_%1%_middle") % iSLayer).str().c_str(), 0, 0, 0);
422 //hard-coded temporarily
423 //need to create an object per layer ??? to be checked later
424 G4UserLimits* uLimits = new G4UserLimits(8.5 * CLHEP::cm);
425 m_userLimits.push_back(uLimits);
426 middleSensitiveTube->SetUserLimits(uLimits);
427 middleSensitiveTube->SetSensitiveDetector(m_sensitive);
428
429 new G4PVPlacement(0, G4ThreeVector(0.0, 0.0, (zfor_sensitive_middle + zback_sensitive_middle)*CLHEP::cm / 2.0), middleSensitiveTube,
430 (boost::format("physicalSD_CDCLayer_%1%_middle") % iSLayer).str().c_str(), m_logicalCDC, false, iSLayer);
431
432 // if (cdcgp.getMaterialDefinitionMode() == 2) {
433 if (gcp.getMaterialDefinitionMode() == 2) {
434 G4String sName = "sWire";
435 const G4int jc = 0;
436 B2Vector3D wb0 = cdcgp.wireBackwardPosition(iSLayer, jc);
437 // G4double rsense0 = wb0.Perp();
438 B2Vector3D wf0 = cdcgp.wireForwardPosition(iSLayer, jc);
439 G4double tAtZ0 = -wb0.Z() / (wf0.Z() - wb0.Z()); //t: param. along the wire
440 B2Vector3D wAtZ0 = wb0 + tAtZ0 * (wf0 - wb0);
441 //additional chop of wire; must be larger than 126um*(1/10), where 126um is the field wire diameter; 1/10: approx. stereo angle
442 const G4double epsl = 25.e-4; // (in cm);
443 G4double reductionBwd = (zback_sensitive_middle + epsl) / wb0.Z();
444 //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
445 wb0 = reductionBwd * (wb0 - wAtZ0) + wAtZ0;
446 //chop wire at zfor_sensitive_middle for avoiding overlap
447 G4double reductionFwd = (zfor_sensitive_middle - epsl) / wf0.Z();
448 wf0 = reductionFwd * (wf0 - wAtZ0) + wAtZ0;
449
450 const G4double wireHalfLength = 0.5 * (wf0 - wb0).Mag() * CLHEP::cm;
451 const G4double sWireRadius = 0.5 * cdcgp.senseWireDiameter() * CLHEP::cm;
452 // const G4double sWireRadius = 15.e-4 * CLHEP::cm;
453 G4Tubs* middleSensitiveSwireShape = new G4Tubs(sName, 0., sWireRadius, wireHalfLength, 0., 360. * CLHEP::deg);
454 G4LogicalVolume* middleSensitiveSwire = new G4LogicalVolume(middleSensitiveSwireShape, medTungsten, sName);
455 // middleSensitiveSwire->SetSensitiveDetector(m_sensitive);
456 middleSensitiveSwire->SetVisAttributes(m_VisAttributes.front()); // <- to speed up visualization
457
458 G4String fName = "fWire";
459 const G4double fWireRadius = 0.5 * cdcgp.fieldWireDiameter() * CLHEP::cm;
460 G4Tubs* middleSensitiveFwireShape = new G4Tubs(fName, 0., fWireRadius, wireHalfLength, 0., 360. * CLHEP::deg);
461 G4LogicalVolume* middleSensitiveFwire = new G4LogicalVolume(middleSensitiveFwireShape, medAluminum, fName);
462 // middleSensitiveFwire->SetSensitiveDetector(m_sensitive);
463 middleSensitiveFwire->SetVisAttributes(m_VisAttributes.front()); // <- to speed up visualization
464
465 const G4double diameter = cdcgp.fieldWireDiameter();
466
467 const G4int nCells = cdcgp.nWiresInLayer(iSLayer);
468 const G4double dphi = M_PI / nCells;
469 const B2Vector3D unitZ(0., 0., 1.);
470
471 for (int ic = 0; ic < nCells; ++ic) {
472 //define sense wire
473 B2Vector3D wb = cdcgp.wireBackwardPosition(iSLayer, ic);
474 B2Vector3D wf = cdcgp.wireForwardPosition(iSLayer, ic);
475 G4double tAtZ02 = -wb.Z() / (wf.Z() - wb.Z());
476 B2Vector3D wAtZ02 = wb + tAtZ02 * (wf - wb);
477 G4double reductionBwd2 = (zback_sensitive_middle + epsl) / wb.Z();
478 wb = reductionBwd2 * (wb - wAtZ02) + wAtZ02;
479 G4double reductionFwd2 = (zfor_sensitive_middle - epsl) / wf.Z();
480 wf = reductionFwd2 * (wf - wAtZ02) + wAtZ02;
481
482 G4double thetaYZ = -asin((wf - wb).Y() / (wf - wb).Mag());
483
484 B2Vector3D fMinusBInZX((wf - wb).X(), 0., (wf - wb).Z());
485 G4double thetaZX = asin((unitZ.Cross(fMinusBInZX)).Y() / fMinusBInZX.Mag());
486 G4RotationMatrix rotM;
487 // std::cout <<"deg,rad= " << CLHEP::deg <<" "<< CLHEP::rad << std::endl;
488 rotM.rotateX(thetaYZ * CLHEP::rad);
489 rotM.rotateY(thetaZX * CLHEP::rad);
490
491 G4ThreeVector xyz(0.5 * (wb.X() + wf.X()) * CLHEP::cm,
492 0.5 * (wb.Y() + wf.Y()) * CLHEP::cm, 0.);
493
494 // std::cout <<"0 x,y= " << xyz.getX() <<" "<< xyz.getY() << std::endl;
495 //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.
496 new G4PVPlacement(G4Transform3D(rotM, xyz), middleSensitiveSwire, sName, middleSensitiveTube, false, ic);
497
498 //define field wire #1 (placed at the same phi but at the outer r boundary)
499 B2Vector3D wbF = wb;
500 G4double rF = rmax_sensitive_middle - 0.5 * diameter;
501 // std::cout <<"iSLayer,rF= " << iSLayer <<" "<< rF <<" "<< std::endl;
502 G4double phi = atan2(wbF.Y(), wbF.X());
503 wbF.SetX(rF * cos(phi));
504 wbF.SetY(rF * sin(phi));
505
506 B2Vector3D wfF = wf;
507 rF = rmax_sensitive_middle - 0.5 * diameter;
508 phi = atan2(wfF.Y(), wfF.X());
509 wfF.SetX(rF * cos(phi));
510 wfF.SetY(rF * sin(phi));
511
512 thetaYZ = -asin((wfF - wbF).Y() / (wfF - wbF).Mag());
513
514 fMinusBInZX = wfF - wbF;
515 fMinusBInZX.SetY(0.);
516 thetaZX = asin((unitZ.Cross(fMinusBInZX)).Y() / fMinusBInZX.Mag());
517
518 G4RotationMatrix rotM1;
519 rotM1.rotateX(thetaYZ * CLHEP::rad);
520 rotM1.rotateY(thetaZX * CLHEP::rad);
521
522 xyz.setX(0.5 * (wbF.X() + wfF.X()) * CLHEP::cm);
523 xyz.setY(0.5 * (wbF.Y() + wfF.Y()) * CLHEP::cm);
524
525 if (iSLayer != nSLayer - 1) {
526 // std::cout <<"1 x,y= " << xyz.getX() <<" "<< xyz.getY() << std::endl;
527 new G4PVPlacement(G4Transform3D(rotM1, xyz), middleSensitiveFwire, fName, middleSensitiveTube, false, ic);
528 }
529
530 //define field wire #2 (placed at the same radius but shifted by dphi)
531 wbF = wb;
532 rF = wbF.Perp();
533 phi = atan2(wbF.Y(), wbF.X());
534 wbF.SetX(rF * cos(phi + dphi));
535 wbF.SetY(rF * sin(phi + dphi));
536
537 wfF = wf;
538 rF = wfF.Perp();
539 phi = atan2(wfF.Y(), wfF.X());
540 wfF.SetX(rF * cos(phi + dphi));
541 wfF.SetY(rF * sin(phi + dphi));
542
543 thetaYZ = -asin((wfF - wbF).Y() / (wfF - wbF).Mag());
544
545 fMinusBInZX = wfF - wbF;
546 fMinusBInZX.SetY(0.);
547 thetaZX = asin((unitZ.Cross(fMinusBInZX)).Y() / fMinusBInZX.Mag());
548
549 G4RotationMatrix rotM2;
550 rotM2.rotateX(thetaYZ * CLHEP::rad);
551 rotM2.rotateY(thetaZX * CLHEP::rad);
552
553 xyz.setX(0.5 * (wbF.X() + wfF.X()) * CLHEP::cm);
554 xyz.setY(0.5 * (wbF.Y() + wfF.Y()) * CLHEP::cm);
555
556 // std::cout <<"2 x,y= " << xyz.getX() <<" "<< xyz.getY() << std::endl;
557 new G4PVPlacement(G4Transform3D(rotM2, xyz), middleSensitiveFwire, fName, middleSensitiveTube, false, ic + nCells);
558
559 //define field wire #3 (placed at the cell corner)
560 wbF = wb;
561 rF = rmax_sensitive_middle - 0.5 * diameter;
562 phi = atan2(wbF.Y(), wbF.X());
563 wbF.SetX(rF * cos(phi + dphi));
564 wbF.SetY(rF * sin(phi + dphi));
565
566 wfF = wf;
567 rF = rmax_sensitive_middle - 0.5 * diameter;
568 phi = atan2(wfF.Y(), wfF.X());
569 wfF.SetX(rF * cos(phi + dphi));
570 wfF.SetY(rF * sin(phi + dphi));
571
572 thetaYZ = -asin((wfF - wbF).Y() / (wfF - wbF).Mag());
573
574 fMinusBInZX = wfF - wbF;
575 fMinusBInZX.SetY(0.);
576 thetaZX = asin((unitZ.Cross(fMinusBInZX)).Y() / fMinusBInZX.Mag());
577
578 G4RotationMatrix rotM3;
579 rotM3.rotateX(thetaYZ * CLHEP::rad);
580 rotM3.rotateY(thetaZX * CLHEP::rad);
581
582 xyz.setX(0.5 * (wbF.X() + wfF.X()) * CLHEP::cm);
583 xyz.setY(0.5 * (wbF.Y() + wfF.Y()) * CLHEP::cm);
584
585 if (iSLayer != nSLayer - 1) {
586 new G4PVPlacement(G4Transform3D(rotM3, xyz), middleSensitiveFwire, fName, middleSensitiveTube, false, ic + 2 * nCells);
587 }
588 } // end of wire loop
589 } // end of wire definitions
590
591 }
592 //
593 // Endplates.
594 //
595
596 m_VisAttributes.push_back(new G4VisAttributes(true, G4Colour(1., 1., 0.)));
597 for (const auto& endplate : geo.getEndPlates()) {
598 for (const auto& epLayer : endplate.getEndPlateLayers()) {
599 const int iEPLayer = epLayer.getILayer();
600 const string name = epLayer.getName();
601 const double rmin = epLayer.getRmin();
602 const double rmax = epLayer.getRmax();
603 const double zbwd = epLayer.getZbwd();
604 const double zfwd = epLayer.getZfwd();
605 const double length = (zfwd - zbwd) / 2.0;
606
607 G4Tubs* tube = new G4Tubs("solidCDCEndplate" + name, rmin * CLHEP::cm,
608 rmax * CLHEP::cm, length * CLHEP::cm, 0 * CLHEP::deg, 360.*CLHEP::deg);
609 G4LogicalVolume* logical = new G4LogicalVolume(tube, Materials::get("G4_Al"),
610 "logicalCDCEndplate" + name, 0, 0);
611 logical->SetVisAttributes(m_VisAttributes.back());
612 new G4PVPlacement(0, G4ThreeVector(0.0, 0.0, (zfwd + zbwd)*CLHEP::cm / 2.0), logical,
613 "physicalCDCEndplate" + name, m_logicalCDC, false, iEPLayer);
614
615 }
616 }
617
618
619 // Construct electronics boards
620 for (const auto& frontend : geo.getFrontends()) {
621
622 const int iEB = frontend.getId();
623 const double ebInnerR = frontend.getRmin();
624 const double ebOuterR = frontend.getRmax();
625 const double ebBZ = frontend.getZbwd();
626 const double ebFZ = frontend.getZfwd();
627
628 G4Tubs* ebTubeShape = new G4Tubs((boost::format("solidSD_ElectronicsBoard_Layer%1%") % iEB).str().c_str(), ebInnerR * CLHEP::cm,
629 ebOuterR * CLHEP::cm, (ebFZ - ebBZ)*CLHEP::cm / 2.0, 0 * CLHEP::deg, 360.*CLHEP::deg);
630
631 G4LogicalVolume* ebTube = new G4LogicalVolume(ebTubeShape, medNEMA_G10_Plate,
632 (boost::format("logicalSD_ElectronicsBoard_Layer%1%") % iEB).str().c_str(), 0, 0, 0);
633 if (!m_bkgsensitive) m_bkgsensitive = new BkgSensitiveDetector("CDC", iEB);
634 ebTube->SetSensitiveDetector(m_bkgsensitive);
635 ebTube->SetVisAttributes(m_VisAttributes.back());
636 new G4PVPlacement(0, G4ThreeVector(0.0, 0.0, (ebFZ + ebBZ)*CLHEP::cm / 2.0), ebTube,
637 (boost::format("physicalSD_ElectronicsBoard_Layer%1%") % iEB).str().c_str(), m_logicalCDC, false, iEB);
638 }
639
640 //
641 // Construct neutron shield.
642 //
643 createNeutronShields(geo);
644
645 //
646 // construct covers.
647 //
648 createCovers(geo);
649
650 //
651 // construct covers.
652 //
653 createCover2s(geo);
654
655 //
656 // Construct ribs.
657 //
658 for (const auto& rib : geo.getRibs()) {
659
660 const int id = rib.getId();
661 const double length = rib.getLength();
662 const double width = rib.getWidth();
663 const double thick = rib.getThick();
664 const double rotx = rib.getRotX();
665 const double roty = rib.getRotY();
666 const double rotz = rib.getRotZ();
667 const double x = rib.getX();
668 const double y = rib.getY();
669 const double z = rib.getZ();
670 const int offset = rib.getOffset();
671 const int ndiv = rib.getNDiv();
672
673 const string solidName = "solidRib" + to_string(id);
674 const string logicalName = "logicalRib" + to_string(id);
675 G4Box* boxShape = new G4Box(solidName, 0.5 * length * CLHEP::cm,
676 0.5 * width * CLHEP::cm,
677 0.5 * thick * CLHEP::cm);
678
679 const double rmax = 0.5 * length;
680 const double rmin = max((rmax - thick), 0.);
681 G4Tubs* tubeShape = new G4Tubs(solidName,
682 rmin * CLHEP::cm,
683 rmax * CLHEP::cm,
684 0.5 * width * CLHEP::cm,
685 0.,
686 360. * CLHEP::deg);
687
688 //G4LogicalVolume* logicalV = new G4LogicalVolume(boxShape, medAluminum,
689 // logicalName, 0, 0, 0);
690 // ID dependent material definition, Aluminum is default
691 G4LogicalVolume* logicalV = new G4LogicalVolume(boxShape, medAluminum, logicalName, 0, 0, 0);
692 if (id > 39 && id < 78) // Cu
693 logicalV = new G4LogicalVolume(boxShape, medCopper, logicalName, 0, 0, 0);
694 if ((id > 77 && id < 94) || (id > 131 && id < 146)) // G10
695 logicalV = new G4LogicalVolume(boxShape, medNEMA_G10_Plate, logicalName, 0, 0, 0);
696 if (id > 93 && id < 110) // Cu
697 logicalV = new G4LogicalVolume(tubeShape, medCopper, logicalName, 0, 0, 0);
698 if (id > 109 && id < 126) // H2O
699 logicalV = new G4LogicalVolume(tubeShape, medH2O, logicalName, 0, 0, 0);
700 if (id > 127 && id < 132) // HV
701 logicalV = new G4LogicalVolume(boxShape, medHV, logicalName, 0, 0, 0);
702 /*if( id > 145 && id < 149 )// Fiber
703 logicalV = new G4LogicalVolume(boxShape, medFiber, logicalName, 0, 0, 0);
704 if( id > 148 && id < 158 )// Fiber
705 logicalV = new G4LogicalVolume(boxShape, medCAT7, logicalName, 0, 0, 0);
706 if( id > 157 && id < 164 )// Fiber
707 logicalV = new G4LogicalVolume(boxShape, medTRG, logicalName, 0, 0, 0);*/
708
709 logicalV->SetVisAttributes(m_VisAttributes.back());
710
711 const double phi = 360.0 / ndiv;
712
713 G4RotationMatrix rot = G4RotationMatrix();
714 double dz = thick;
715 if (id > 93 && id < 126) dz = 0;
716
717 G4ThreeVector arm(x * CLHEP::cm, y * CLHEP::cm, z * CLHEP::cm - dz * CLHEP::cm / 2.0);
718 rot.rotateX(rotx);
719 rot.rotateY(roty);
720 rot.rotateZ(rotz);
721 if (offset) {
722 rot.rotateZ(0.5 * phi * CLHEP::deg);
723 arm.rotateZ(0.5 * phi * CLHEP::deg);
724 }
725 for (int i = 0; i < ndiv; ++i) {
726 const string physicalName = "physicalRib_" + to_string(id) + " " + to_string(i);
727 new G4PVPlacement(G4Transform3D(rot, arm), logicalV,
728 physicalName.c_str(), m_logicalCDC, false, id);
729 rot.rotateZ(phi * CLHEP::deg);
730 arm.rotateZ(phi * CLHEP::deg);
731 }
732
733 }
734
735 //
736 // Construct rib2s.
737 //
738 for (const auto& rib2 : geo.getRib2s()) {
739
740 const int id = rib2.getId();
741 const double length = rib2.getLength();
742 const double width = rib2.getWidth();
743 const double thick = rib2.getThick();
744 const double width2 = rib2.getWidth2();
745 const double thick2 = rib2.getThick2();
746 const double rotx = rib2.getRotX();
747 const double roty = rib2.getRotY();
748 const double rotz = rib2.getRotZ();
749 const double x = rib2.getX();
750 const double y = rib2.getY();
751 const double z = rib2.getZ();
752 const int ndiv = rib2.getNDiv();
753
754 const string solidName = "solidRib2" + to_string(id);
755 const string logicalName = "logicalRib2" + to_string(id);
756 G4Trd* trdShape = new G4Trd(solidName,
757 0.5 * thick * CLHEP::cm,
758 0.5 * thick2 * CLHEP::cm,
759 0.5 * width * CLHEP::cm,
760 0.5 * width2 * CLHEP::cm,
761 0.5 * length * CLHEP::cm);
762
763 G4LogicalVolume* logicalV = new G4LogicalVolume(trdShape, medAluminum, logicalName, 0, 0, 0);
764
765 if (id > 0)
766 logicalV = new G4LogicalVolume(trdShape, medCopper, logicalName, 0, 0, 0);
767
768 logicalV->SetVisAttributes(m_VisAttributes.back());
769
770 const double phi = 360.0 / ndiv;
771
772 G4RotationMatrix rot = G4RotationMatrix();
773 G4ThreeVector arm(x * CLHEP::cm, y * CLHEP::cm, z * CLHEP::cm - thick * CLHEP::cm / 2.0);
774
775 rot.rotateX(rotx);
776 rot.rotateY(roty);
777 rot.rotateZ(rotz);
778 for (int i = 0; i < ndiv; ++i) {
779 const string physicalName = "physicalRib2_" + to_string(id) + " " + to_string(i);
780 new G4PVPlacement(G4Transform3D(rot, arm), logicalV,
781 physicalName.c_str(), m_logicalCDC, false, id);
782 rot.rotateZ(phi * CLHEP::deg);
783 arm.rotateZ(phi * CLHEP::deg);
784 }
785
786 }
787
788 //
789 // Construct rib3s.
790 //
791 for (const auto& rib3 : geo.getRib3s()) {
792
793 const int id = rib3.getId();
794 const double length = rib3.getLength();
795 const double width = rib3.getWidth();
796 const double thick = rib3.getThick();
797 const double r = rib3.getR();
798 const double x = rib3.getX();
799 const double y = rib3.getY();
800 const double z = rib3.getZ();
801 const double rx = rib3.getRx();
802 const double ry = rib3.getRy();
803 const double rz = rib3.getRz();
804 const int offset = rib3.getOffset();
805 const int ndiv = rib3.getNDiv();
806
807 const string logicalName = "logicalRib3" + to_string(id);
808 G4VSolid* boxShape = new G4Box("Block",
809 0.5 * length * CLHEP::cm,
810 0.5 * width * CLHEP::cm,
811 0.5 * thick * CLHEP::cm);
812 G4VSolid* tubeShape = new G4Tubs("Hole",
813 0.,
814 r * CLHEP::cm,
815 width * CLHEP::cm,
816 0. * CLHEP::deg,
817 360. * CLHEP::deg);
818
819 G4RotationMatrix rotsub = G4RotationMatrix();
820 rotsub.rotateX(90. * CLHEP::deg);
821 G4ThreeVector trnsub(rx * CLHEP::cm - x * CLHEP::cm, ry * CLHEP::cm - y * CLHEP::cm,
822 rz * CLHEP::cm - z * CLHEP::cm + 0.5 * thick * CLHEP::cm);
823 G4VSolid* coolingBlock = new G4SubtractionSolid("Block-Hole",
824 boxShape,
825 tubeShape,
826 G4Transform3D(rotsub,
827 trnsub));
828
829 G4LogicalVolume* logicalV = new G4LogicalVolume(coolingBlock, medCopper, logicalName, 0, 0, 0);
830
831 logicalV->SetVisAttributes(m_VisAttributes.back());
832
833 const double phi = 360.0 / ndiv;
834
835 G4RotationMatrix rot = G4RotationMatrix();
836 G4ThreeVector arm(x * CLHEP::cm, y * CLHEP::cm, z * CLHEP::cm - thick * CLHEP::cm / 2.0);
837
838 if (offset) {
839 rot.rotateZ(0.5 * phi * CLHEP::deg);
840 arm.rotateZ(0.5 * phi * CLHEP::deg);
841 }
842 for (int i = 0; i < ndiv; ++i) {
843 const string physicalName = "physicalRib3_" + to_string(id) + " " + to_string(i);
844 new G4PVPlacement(G4Transform3D(rot, arm), logicalV,
845 physicalName.c_str(), m_logicalCDC, false, id);
846 rot.rotateZ(phi * CLHEP::deg);
847 arm.rotateZ(phi * CLHEP::deg);
848 }
849
850 }
851
852 //
853 // Construct rib4s.
854 //
855 for (const auto& rib4 : geo.getRib4s()) {
856
857 const int id = rib4.getId();
858 const double length = rib4.getLength();
859 const double width = rib4.getWidth();
860 const double thick = rib4.getThick();
861 const double length2 = rib4.getLength2();
862 const double width2 = rib4.getWidth2();
863 const double thick2 = rib4.getThick2();
864 const double x = rib4.getX();
865 const double y = rib4.getY();
866 const double z = rib4.getZ();
867 const double x2 = rib4.getX2();
868 const double y2 = rib4.getY2();
869 const double z2 = rib4.getZ2();
870 const int offset = rib4.getOffset();
871 const int ndiv = rib4.getNDiv();
872
873 const string logicalName = "logicalRib4" + to_string(id);
874 G4VSolid* baseShape = new G4Box("Base",
875 0.5 * length * CLHEP::cm,
876 0.5 * width * CLHEP::cm,
877 0.5 * thick * CLHEP::cm);
878 G4VSolid* sqShape = new G4Box("Sq",
879 0.5 * length2 * CLHEP::cm,
880 0.5 * width2 * CLHEP::cm,
881 0.5 * thick2 * CLHEP::cm);
882
883 G4RotationMatrix rotsub = G4RotationMatrix();
884 double dzc = (z2 - thick2 / 2.) - (z - thick / 2.);
885 G4ThreeVector trnsub(x2 * CLHEP::cm - x * CLHEP::cm,
886 y2 * CLHEP::cm - y * CLHEP::cm,
887 dzc * CLHEP::cm);
888 G4VSolid* sqHoleBase = new G4SubtractionSolid("Box-Sq",
889 baseShape,
890 sqShape,
891 G4Transform3D(rotsub,
892 trnsub)
893 );
894
895 G4LogicalVolume* logicalV = new G4LogicalVolume(sqHoleBase, medCopper, logicalName, 0, 0, 0);
896 if (id < 19) {
897 logicalV = new G4LogicalVolume(sqHoleBase, medNEMA_G10_Plate, logicalName, 0, 0, 0);
898 BkgSensitiveDetector* sensitiveDetector =
899 new BkgSensitiveDetector("CDC", 2000 + id);
900 logicalV->SetSensitiveDetector(sensitiveDetector);
901 m_BkgSensitiveRib4.push_back(sensitiveDetector);
902 }
903
904 logicalV->SetVisAttributes(m_VisAttributes.back());
905
906 const double phi = 360.0 / ndiv;
907
908 G4RotationMatrix rot = G4RotationMatrix();
909 G4ThreeVector arm(x * CLHEP::cm, y * CLHEP::cm, z * CLHEP::cm - thick * CLHEP::cm / 2.0);
910
911 if (offset) {
912 rot.rotateZ(0.5 * phi * CLHEP::deg);
913 arm.rotateZ(0.5 * phi * CLHEP::deg);
914 }
915 for (int i = 0; i < ndiv; ++i) {
916 const string physicalName = "physicalRib4_" + to_string(id) + " " + to_string(i);
917 new G4PVPlacement(G4Transform3D(rot, arm), logicalV,
918 physicalName.c_str(), m_logicalCDC, false, id);
919 rot.rotateZ(phi * CLHEP::deg);
920 arm.rotateZ(phi * CLHEP::deg);
921 }
922
923 }
924 //
925 // Construct rib5s.
926 //
927 for (const auto& rib5 : geo.getRib5s()) {
928
929 const int id = rib5.getId();
930 const double dr = rib5.getDr();
931 const double dz = rib5.getDz();
932 const double width = rib5.getWidth();
933 const double thick = rib5.getThick();
934 const double rin = rib5.getRin();
935 const double x = rib5.getX();
936 const double y = rib5.getY();
937 const double z = rib5.getZ();
938 const double rotx = rib5.getRotx();
939 const double roty = rib5.getRoty();
940 const double rotz = rib5.getRotz();
941 const int offset = rib5.getOffset();
942 const int ndiv = rib5.getNDiv();
943
944 const string solidName = "solidRib5" + to_string(id);
945 const string logicalName = "logicalRib5" + to_string(id);
946
947 const double rmax = rin + thick;
948 const double rmin = rin;
949 const double dphi = 2. * atan2(dz, dr);
950 const double ddphi = thick * tan(dphi) / rin;
951 const double ddphi2 = width / 2. * width / 2. / (x + dr) / rin;
952 const double cphi = dphi - ddphi - ddphi2;
953 G4Tubs* tubeShape = new G4Tubs(solidName,
954 rmin * CLHEP::cm,
955 rmax * CLHEP::cm,
956 0.5 * width * CLHEP::cm,
957 0.,
958 cphi);
959
960 G4LogicalVolume* logicalV = new G4LogicalVolume(tubeShape, medAluminum, logicalName, 0, 0, 0);
961
962 logicalV->SetVisAttributes(m_VisAttributes.back());
963
964 const double phi = 360.0 / ndiv;
965
966 G4RotationMatrix rot = G4RotationMatrix();
967
968 //G4ThreeVector arm(x * CLHEP::cm, y * CLHEP::cm, z * CLHEP::cm - thick * CLHEP::cm / 2.0);
969 G4ThreeVector arm(x * CLHEP::cm, y * CLHEP::cm, z * CLHEP::cm - rin * CLHEP::cm - thick * CLHEP::cm);
970 rot.rotateX(rotx);
971 rot.rotateY(roty);
972 rot.rotateZ(rotz);
973 if (offset) {
974 rot.rotateZ(0.5 * phi * CLHEP::deg);
975 arm.rotateZ(0.5 * phi * CLHEP::deg);
976 }
977 for (int i = 0; i < ndiv; ++i) {
978 const string physicalName = "physicalRib5_" + to_string(id) + " " + to_string(i);
979 new G4PVPlacement(G4Transform3D(rot, arm), logicalV,
980 physicalName.c_str(), m_logicalCDC, false, id);
981 rot.rotateZ(phi * CLHEP::deg);
982 arm.rotateZ(phi * CLHEP::deg);
983 }
984
985 }
986
987 //Create B-field mapper (here tentatively)
988 createMapper(topVolume);
989 }
Belle2::B2Vector3::Z
DataType Z() const
access variable Z (= .at(2) without boundary check)
Definition B2Vector3.h:435
Belle2::B2Vector3D
B2Vector3< double > B2Vector3D
typedef for common usage with double
Definition B2Vector3.h:516

◆ createMapper()

void createMapper ( G4LogicalVolume & topVolume)
privateinherited

Create the B-field mapper geometry (tentative function)

Definition at line 1704 of file GeoCDCCreator.cc.

1705 {
1706 CDCGeoControlPar& gcp = CDCGeoControlPar::getInstance();
1707 if (!gcp.getMapperGeometry()) return;
1708
1709 const double xc = 0.5 * (-0.0002769 + 0.0370499) * CLHEP::cm;
1710 const double yc = 0.5 * (-0.0615404 + -0.108948) * CLHEP::cm;
1711 const double zc = 0.5 * (-35.3 + 48.5) * CLHEP::cm;
1712 //3 plates
1713 // const double plateWidth = 13.756 * CLHEP::cm;
1714 // const double plateThick = 1.203 * CLHEP::cm;
1715 // const double plateLength = 83.706 * CLHEP::cm;
1716 const double plateWidth = 13.8 * CLHEP::cm;
1717 const double plateThick = 1.2 * CLHEP::cm;
1718 const double plateLength = 83.8 * CLHEP::cm;
1719 const double phi = gcp.getMapperPhiAngle() * CLHEP::deg; //phi-angle in lab.
1720 // std::cout << "phi= " << phi << std::endl;
1721 // const double endRingRmin = 4.1135 * CLHEP::cm;
1722 // const double endRingRmax = 15.353 * CLHEP::cm;
1723 // const double endRingThick = 2.057 * CLHEP::cm;
1724 const double endPlateRmin = 4.0 * CLHEP::cm;
1725 const double endPlateRmax = 15.5 * CLHEP::cm;
1726 const double bwdEndPlateThick = 1.7 * CLHEP::cm;
1727 const double fwdEndPlateThick = 2.0 * CLHEP::cm;
1728
1729 G4Material* medAluminum = geometry::Materials::get("Al");
1730
1731 string name = "Plate";
1732 int pID = 0;
1733 G4Box* plateShape = new G4Box("solid" + name, .5 * plateWidth, .5 * plateThick, .5 * plateLength);
1734 G4LogicalVolume* logical0 = new G4LogicalVolume(plateShape, medAluminum, "logical" + name, 0, 0, 0);
1735 logical0->SetVisAttributes(m_VisAttributes.back());
1736 // const double x = .5 * plateWidth;
1737 const double x = xc + 0.5 * plateWidth;
1738 // const double y = endRingRmin;
1739 const double y = yc + endPlateRmin + 0.1 * CLHEP::cm;
1740 // double z = 2.871 * CLHEP::cm;
1741 G4ThreeVector xyz(x, y, zc);
1742 G4RotationMatrix rotM3 = G4RotationMatrix();
1743 xyz.rotateZ(phi);
1744 rotM3.rotateZ(phi);
1745 new G4PVPlacement(G4Transform3D(rotM3, xyz), logical0, "physical" + name, &topVolume, false, pID);
1746
1747 const double alf = 120. * CLHEP::deg;
1748 xyz.rotateZ(alf);
1749 rotM3.rotateZ(alf);
1750 new G4PVPlacement(G4Transform3D(rotM3, xyz), logical0, "physical" + name, &topVolume, false, pID + 1);
1751
1752 xyz.rotateZ(alf);
1753 rotM3.rotateZ(alf);
1754 new G4PVPlacement(G4Transform3D(rotM3, xyz), logical0, "physical" + name, &topVolume, false, pID + 2);
1755
1756 //Define 2 end-plates
1757 //bwd
1758 name = "BwdEndPlate";
1759 G4Tubs* BwdEndPlateShape = new G4Tubs("solid" + name, endPlateRmin, endPlateRmax, 0.5 * bwdEndPlateThick, 0., 360.*CLHEP::deg);
1760 G4LogicalVolume* logical1 = new G4LogicalVolume(BwdEndPlateShape, medAluminum, "logical" + name, 0, 0, 0);
1761 logical1->SetVisAttributes(m_VisAttributes.back());
1762 // z = -40.0105 * CLHEP::cm;
1763 double z = -35.3 * CLHEP::cm - 0.5 * bwdEndPlateThick;
1764 pID = 0;
1765 new G4PVPlacement(0, G4ThreeVector(xc, yc, z), logical1, "physical" + name, &topVolume, false, pID);
1766
1767 //fwd
1768 // z = 45.7525 * CLHEP::cm;
1769 // new G4PVPlacement(0, G4ThreeVector(0., 0., z), logical1, "physical" + name, &topVolume, false, pID + 1);
1770 name = "FwdEndPlate";
1771 G4Tubs* FwdEndPlateShape = new G4Tubs("solid" + name, endPlateRmin, endPlateRmax, 0.5 * fwdEndPlateThick, 0., 360.*CLHEP::deg);
1772 G4LogicalVolume* logical2 = new G4LogicalVolume(FwdEndPlateShape, medAluminum, "logical" + name, 0, 0, 0);
1773 logical2->SetVisAttributes(m_VisAttributes.back());
1774 z = 48.5 * CLHEP::cm + 0.5 * fwdEndPlateThick;
1775 new G4PVPlacement(0, G4ThreeVector(xc, yc, z), logical2, "physical" + name, &topVolume, false, pID);
1776 }

◆ createNeutronShields() [1/2]

void createNeutronShields ( const CDCGeometry & geom)
inherited

Create neutron shield from DB.

Definition at line 1043 of file GeoCDCCreator.cc.

1044 {
1045
1046 G4Material* C2H4 = geometry::Materials::get("G4_POLYETHYLENE");
1047 G4Material* shieldMat = C2H4;
1048
1049 for (const auto& shield : geom.getNeutronShields()) {
1050 const int shieldID = shield.getId();
1051 const double shieldInnerR1 = shield.getRmin1();
1052 const double shieldInnerR2 = shield.getRmin2();
1053 const double shieldOuterR1 = shield.getRmax1();
1054 const double shieldOuterR2 = shield.getRmax2();
1055 const double shieldThick = shield.getThick();
1056 const double shieldPosZ = shield.getZ();
1057
1058 G4Cons* shieldConsShape = new G4Cons("solidShield" + to_string(shieldID),
1059 shieldInnerR1 * CLHEP::cm, shieldOuterR1 * CLHEP::cm,
1060 shieldInnerR2 * CLHEP::cm, shieldOuterR2 * CLHEP::cm,
1061 shieldThick * CLHEP::cm / 2.0,
1062 0.*CLHEP::deg, 360.*CLHEP::deg);
1063
1064 G4LogicalVolume* shieldCons = new G4LogicalVolume(shieldConsShape, shieldMat, "logicalShield" + to_string(shieldID),
1065 0, 0, 0);
1066 shieldCons->SetVisAttributes(m_VisAttributes.back());
1067 new G4PVPlacement(0, G4ThreeVector(0.0, 0.0, (shieldPosZ - shieldThick / 2.0) * CLHEP::cm), shieldCons,
1068 "physicalShield" + to_string(shieldID), m_logicalCDC, false, 0);
1069
1070 }
1071
1072 }

◆ createNeutronShields() [2/2]

void createNeutronShields ( const GearDir & content)
inherited

Create neutron shield from gearbox.

Definition at line 992 of file GeoCDCCreator.cc.

993 {
994
995 G4Material* C2H4 = geometry::Materials::get("G4_POLYETHYLENE");
996 G4Material* elB = geometry::Materials::get("G4_B");
997
998 // 5% borated polyethylene = SWX201
999 // http://www.deqtech.com/Shieldwerx/Products/swx201hd.htm
1000 G4Material* boratedpoly05 = new G4Material("BoratedPoly05", 1.06 * CLHEP::g / CLHEP::cm3, 2);
1001 boratedpoly05->AddMaterial(elB, 0.05);
1002 boratedpoly05->AddMaterial(C2H4, 0.95);
1003 // 30% borated polyethylene = SWX210
1004 G4Material* boratedpoly30 = new G4Material("BoratedPoly30", 1.19 * CLHEP::g / CLHEP::cm3, 2);
1005 boratedpoly30->AddMaterial(elB, 0.30);
1006 boratedpoly30->AddMaterial(C2H4, 0.70);
1007
1008 G4Material* shieldMat = C2H4;
1009
1010 const int nShields = content.getNumberNodes("Shields/Shield");
1011
1012 for (int iShield = 0; iShield < nShields; ++iShield) {
1013 GearDir shieldContent(content);
1014 shieldContent.append((boost::format("/Shields/Shield[%1%]/") % (iShield + 1)).str());
1015 const string sShieldID = shieldContent.getString("@id");
1016 const int shieldID = atoi(sShieldID.c_str());
1017 // const string shieldName = shieldContent.getString("Name");
1018 const double shieldInnerR1 = shieldContent.getLength("InnerR1");
1019 const double shieldInnerR2 = shieldContent.getLength("InnerR2");
1020 const double shieldOuterR1 = shieldContent.getLength("OuterR1");
1021 const double shieldOuterR2 = shieldContent.getLength("OuterR2");
1022 const double shieldThick = shieldContent.getLength("Thickness");
1023 const double shieldPosZ = shieldContent.getLength("PosZ");
1024
1025 G4Cons* shieldConsShape = new G4Cons((boost::format("solidShield%1%") % shieldID).str().c_str(),
1026 shieldInnerR1 * CLHEP::cm, shieldOuterR1 * CLHEP::cm,
1027 shieldInnerR2 * CLHEP::cm, shieldOuterR2 * CLHEP::cm,
1028 shieldThick * CLHEP::cm / 2.0,
1029 0.*CLHEP::deg, 360.*CLHEP::deg);
1030
1031 G4LogicalVolume* shieldCons = new G4LogicalVolume(shieldConsShape, shieldMat,
1032 (boost::format("logicalShield%1%") % shieldID).str().c_str(),
1033 0, 0, 0);
1034 shieldCons->SetVisAttributes(m_VisAttributes.back());
1035 new G4PVPlacement(0, G4ThreeVector(0.0, 0.0, (shieldPosZ - shieldThick / 2.0) * CLHEP::cm), shieldCons,
1036 (boost::format("physicalShield%1%") % shieldID).str().c_str(), m_logicalCDC, false, 0);
1037
1038 }
1039
1040 }

◆ createPayloads()

virtual void createPayloads ( const GearDir & content,
const IntervalOfValidity & iov )
inlineoverridevirtualinherited

Create payloads.

Reimplemented from CreatorBase.

Definition at line 78 of file GeoCDCCreator.h.

79 {
80 DBImportObjPtr<CDCGeometry> importObj;
81 importObj.construct(createConfiguration(content));
82 importObj.import(iov);
83 }

◆ createTorus()

void createTorus ( const double rmin1,
const double rmax1,
const double thick,
const double posZ,
const int id,
G4Material * med,
const std::string & name )
inherited

Create G4Torus.

Definition at line 1655 of file GeoCDCCreator.cc.

1659 {
1660 const string solidName = "solid" + name;
1661 const string logicalName = "logical" + name;
1662 const string physicalName = "physical" + name;
1663 const double rtor = (rmax1 + rmin1) / 2.;
1664 const double rmax = rmax1 - rtor;
1665 const double rmin = max((rmax - thick), 0.);
1666
1667 G4Torus* solidV = new G4Torus(solidName.c_str(),
1668 rmin * CLHEP::cm,
1669 rmax * CLHEP::cm,
1670 rtor * CLHEP::cm,
1671 0.*CLHEP::deg,
1672 360.*CLHEP::deg);
1673 G4LogicalVolume* logicalV = new G4LogicalVolume(solidV, med,
1674 logicalName.c_str(), 0, 0, 0);
1675 logicalV->SetVisAttributes(m_VisAttributes.back());
1676 new G4PVPlacement(0, G4ThreeVector(0.0, 0.0, posZ * CLHEP::cm), logicalV,
1677 physicalName.c_str(), m_logicalCDC, false, id);
1678
1679 }

◆ createTube()

void createTube ( const double rmin,
const double rmax,
const double thick,
const double posZ,
const int id,
G4Material * med,
const std::string & name )
inherited

Create G4Tube.

Definition at line 1613 of file GeoCDCCreator.cc.

1617 {
1618 const string solidName = "solid" + name;
1619 const string logicalName = "logical" + name;
1620 const string physicalName = "physical" + name;
1621 G4Tubs* solidV = new G4Tubs(solidName.c_str(),
1622 rmin * CLHEP::cm,
1623 rmax * CLHEP::cm,
1624 thick * CLHEP::cm / 2.0,
1625 0.*CLHEP::deg,
1626 360.*CLHEP::deg);
1627 G4LogicalVolume* logicalV = new G4LogicalVolume(solidV, med,
1628 logicalName.c_str(), 0, 0, 0);
1629 logicalV->SetVisAttributes(m_VisAttributes.back());
1630 new G4PVPlacement(0, G4ThreeVector(0.0, 0.0, posZ * CLHEP::cm - thick * CLHEP::cm / 2.0), logicalV,
1631 physicalName.c_str(), m_logicalCDC, false, id);
1632
1633 }

◆ createTube2()

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 )
inherited

Create G4Tube2.

Definition at line 1681 of file GeoCDCCreator.cc.

1686 {
1687 const string solidName = "solid" + name;
1688 const string logicalName = "logical" + name;
1689 const string physicalName = "physical" + name;
1690 G4Tubs* solidV = new G4Tubs(solidName.c_str(),
1691 rmin * CLHEP::cm,
1692 rmax * CLHEP::cm,
1693 thick * CLHEP::cm / 2.0,
1694 phis,
1695 phie);
1696 G4LogicalVolume* logicalV = new G4LogicalVolume(solidV, med,
1697 logicalName.c_str(), 0, 0, 0);
1698 logicalV->SetVisAttributes(m_VisAttributes.back());
1699 new G4PVPlacement(0, G4ThreeVector(0.0, 0.0, posZ * CLHEP::cm - thick * CLHEP::cm / 2.0), logicalV,
1700 physicalName.c_str(), m_logicalCDC, false, id);
1701
1702 }

◆ getEndplateInformation()

bool getEndplateInformation ( const CDCGeometry & geo,
const uint iSLayer,
double & rMinLeft,
double & rMaxLeft,
double & zBackLeft,
double & zForLeft,
double & rMinMiddle,
double & rMaxMiddle,
double & zBackMiddle,
double & zForMiddle,
double & rMinRight,
double & rMaxRight,
double & zBackRight,
double & zForRight ) const
overrideprivatevirtual

Get endplate information.

Parameters
[in]geothe CDCGeometry
[in]iSLayernumber of the sense layer
[in,out]rMinLeftminimum radius of sensitive layer left
[in,out]rMaxLeftmaximum radius of sensitive layer left
[in,out]zBackLeftbackward z value of sensitive layer left
[in,out]zForLeftforward z value of sensitive layer left
[in,out]rMinMiddleminimum radius of sensitive layer middle
[in,out]rMaxMiddlemaximum radius of sensitive layer middle
[in,out]zBackMiddlebackward z value of sensitive layer middle
[in,out]zForMiddleforward z value of sensitive layer middle
[in,out]rMinRightminimum radius of sensitive layer right
[in,out]rMaxRightmaximum radius of sensitive layer right
[in,out]zBackRightbackward z value of sensitive layer right
[in,out]zForRightforward z value of sensitive layer right
Returns
: true on success, false otherwise (only for unknown value of iSLayer)

Reimplemented from GeoCDCCreator.

Definition at line 30 of file GeoCDCCreatorReducedCDCNoSL0SL1.cc.

34 {
35 const auto& endplate = geo.getEndPlate(iSLayer);
36 const int nEPLayer = endplate.getNEndPlateLayers();
37
38 if (iSLayer == 0) {
39 const auto& epLayerBwd = endplate.getEndPlateLayer(1);
40 const auto& epLayerFwd = endplate.getEndPlateLayer((nEPLayer / 2) + 1);
41 const auto& senseLayer = geo.getSenseLayer(iSLayer);
42 const auto& fieldLayer = geo.getFieldLayer(iSLayer);
43
44 rMinLeft = epLayerBwd.getRmax();
45 rMaxLeft = fieldLayer.getR();
46 zBackLeft = senseLayer.getZbwd();
47 zForLeft = epLayerBwd.getZfwd();
48
49 rMinMiddle = (geo.getInnerWall(0)).getRmax();
50 rMaxMiddle = fieldLayer.getR();
51 zBackMiddle = epLayerBwd.getZfwd();
52 zForMiddle = epLayerFwd.getZbwd();
53
54 rMinRight = epLayerFwd.getRmax();
55 rMaxRight = fieldLayer.getR();
56 zBackRight = epLayerFwd.getZbwd();
57 zForRight = senseLayer.getZfwd();
58 } else if (iSLayer >= 1 && iSLayer <= 4) {
59 const auto& epLayerBwd = endplate.getEndPlateLayer(1);
60 const auto& epLayerFwd = endplate.getEndPlateLayer(nEPLayer / 2);
61 const auto& senseLayer = geo.getSenseLayer(iSLayer);
62 const auto& fieldLayerIn = geo.getFieldLayer(iSLayer - 1);
63 const auto& fieldLayerOut = geo.getFieldLayer(iSLayer);
64
65 rMinLeft = epLayerBwd.getRmax();
66 rMaxLeft = fieldLayerOut.getR();
67 zBackLeft = senseLayer.getZbwd();
68 zForLeft = epLayerBwd.getZfwd();
69
70 rMinMiddle = fieldLayerIn.getR();
71 rMaxMiddle = fieldLayerOut.getR();
72 zBackMiddle = epLayerBwd.getZfwd();
73 zForMiddle = epLayerFwd.getZbwd();
74
75 rMinRight = epLayerFwd.getRmax();
76 rMaxRight = fieldLayerOut.getR();
77 zBackRight = epLayerFwd.getZbwd();
78 zForRight = senseLayer.getZfwd();
79 } else if (iSLayer >= 5 && iSLayer < 41) {
80 const auto& epLayerBwd = endplate.getEndPlateLayer(0);
81 const auto& epLayerFwd = endplate.getEndPlateLayer(nEPLayer / 2);
82 const auto& senseLayer = geo.getSenseLayer(iSLayer);
83 const auto& fieldLayerIn = geo.getFieldLayer(iSLayer - 1);
84 const auto& fieldLayerOut = geo.getFieldLayer(iSLayer);
85
86 rMinLeft = epLayerBwd.getRmax();
87 rMaxLeft = fieldLayerOut.getR();
88 zBackLeft = senseLayer.getZbwd();
89 zForLeft = epLayerBwd.getZfwd();
90
91 rMinMiddle = fieldLayerIn.getR();
92 rMaxMiddle = fieldLayerOut.getR();
93 zBackMiddle = epLayerBwd.getZfwd();
94 zForMiddle = epLayerFwd.getZbwd();
95
96 rMinRight = epLayerFwd.getRmax();
97 rMaxRight = fieldLayerOut.getR();
98 zBackRight = epLayerFwd.getZbwd();
99 zForRight = senseLayer.getZfwd();
100
101 } else if (iSLayer == 41) {
102
103 const auto& epLayerBwdIn = endplate.getEndPlateLayer(0);
104 const auto& epLayerBwdOut = endplate.getEndPlateLayer((nEPLayer / 2) - 1);
105 const auto& epLayerFwdIn = endplate.getEndPlateLayer(nEPLayer / 2);
106 const auto& epLayerFwdOut = endplate.getEndPlateLayer(nEPLayer - 1);
107 const auto& senseLayer = geo.getSenseLayer(iSLayer);
108
109 int iSLayerMinus1 = iSLayer - 1; //avoid cpp-check warning
110 const auto& fieldLayerIn = geo.getFieldLayer(iSLayerMinus1); //avoid cpp-check warning
111
112 rMinLeft = epLayerBwdIn.getRmax();
113 rMaxLeft = epLayerBwdOut.getRmax();
114 zBackLeft = senseLayer.getZbwd();
115 zForLeft = epLayerBwdIn.getZfwd();
116
117 rMinMiddle = fieldLayerIn.getR();
118 rMaxMiddle = (geo.getOuterWall(0)).getRmin();
119 zBackMiddle = epLayerBwdIn.getZfwd();
120 zForMiddle = epLayerFwdIn.getZbwd();
121
122 rMinRight = epLayerFwdIn.getRmax();
123 rMaxRight = epLayerFwdOut.getRmax();
124 zBackRight = epLayerFwdIn.getZbwd();
125 zForRight = senseLayer.getZfwd();
126
127 } else {
128 B2ERROR("Undefined sensitive layer : " << iSLayer);
129 return false;
130 }
131 return true;
132 }

Member Data Documentation

◆ m_bkgsensitive

BkgSensitiveDetector* m_bkgsensitive = nullptr
privateinherited

Sensitive detector for background studies.

Definition at line 213 of file GeoCDCCreator.h.

◆ m_BkgSensitiveRib4

std::vector<BkgSensitiveDetector*> m_BkgSensitiveRib4 = {}
privateinherited

Sensitive detectors for background studies (rib4).

Definition at line 216 of file GeoCDCCreator.h.

216{};

◆ m_logicalCDC

G4LogicalVolume* m_logicalCDC
privateinherited

CDC G4 logical volume.

Definition at line 204 of file GeoCDCCreator.h.

◆ m_physicalCDC

G4VPhysicalVolume* m_physicalCDC
privateinherited

CDC G4 physical volume.

Definition at line 207 of file GeoCDCCreator.h.

◆ m_sensitive

CDCSensitiveDetector* m_sensitive = nullptr
privateinherited

Sensitive detector.

Definition at line 210 of file GeoCDCCreator.h.

◆ m_userLimits

std::vector<G4UserLimits*> m_userLimits
privateinherited

Vector of pointers to G4UserLimits.

Definition at line 222 of file GeoCDCCreator.h.

◆ m_VisAttributes

std::vector<G4VisAttributes*> m_VisAttributes
privateinherited

Vector of pointers to G4VisAttributes.

Definition at line 219 of file GeoCDCCreator.h.

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