9#include <pxd/geometry/GeoPXDCreator.h>
10#include <vxd/geometry/GeoCache.h>
11#include <pxd/geometry/SensorInfo.h>
12#include <pxd/simulation/SensitiveDetector.h>
14#include <simulation/background/BkgSensitiveDetector.h>
16#include <geometry/Materials.h>
17#include <geometry/CreatorFactory.h>
18#include <geometry/utilities.h>
19#include <framework/gearbox/GearDir.h>
20#include <framework/gearbox/Unit.h>
21#include <framework/logging/Logger.h>
24#include <boost/format.hpp>
26#include <G4LogicalVolume.hh>
27#include <G4PVPlacement.hh>
32#include <G4Polycone.hh>
33#include <G4SubtractionSolid.hh>
43 using namespace geometry;
71 info->setDEPFETParams(
86 info->setIntegrationWindow(
99 sensor.getLength(
"width"),
100 sensor.getLength(
"length"),
101 sensor.getLength(
"height"),
102 sensor.getInt(
"pixelsU"),
103 sensor.getInt(
"pixelsV[1]"),
104 sensor.getLength(
"splitLength", 0),
105 sensor.getInt(
"pixelsV[2]", 0)
108 info->setDEPFETParams(
109 sensor.getDouble(
"BulkDoping"),
110 sensor.getWithUnit(
"BackVoltage"),
111 sensor.getWithUnit(
"TopVoltage"),
112 sensor.getLength(
"SourceBorderSmallPixel"),
113 sensor.getLength(
"ClearBorderSmallPixel"),
114 sensor.getLength(
"DrainBorderSmallPixel"),
115 sensor.getLength(
"SourceBorderLargePixel"),
116 sensor.getLength(
"ClearBorderLargePixel"),
117 sensor.getLength(
"DrainBorderLargePixel"),
118 sensor.getLength(
"GateDepth"),
119 sensor.getBool(
"DoublePixel"),
120 sensor.getDouble(
"ChargeThreshold"),
121 sensor.getDouble(
"NoiseFraction")
123 info->setIntegrationWindow(
124 sensor.getTime(
"IntegrationStart"),
125 sensor.getTime(
"IntegrationEnd")
140 VXDGlobalPar globals((
float)content.getDouble(
"ElectronTolerance", 100),
141 (
float)content.getDouble(
"MinimumElectrons", 10),
142 content.getLength(
"ActiveStepSize", 0.005),
143 content.getBool(
"ActiveChips",
false),
144 content.getBool(
"SeeNeutrons",
false),
145 content.getBool(
"OnlyPrimaryTrueHits",
false),
146 content.getBool(
"OnlyActiveMaterial",
false),
147 (
float)content.getLength(
"DistanceTolerance", 0.005),
148 content.getString(
"DefaultMaterial",
"Air")
153 GearDir envelopeParams(content,
"Envelope/");
155 envelopeParams.
getString(
"Material",
"Air"),
157 envelopeParams.
getAngle(
"minPhi", 0),
158 envelopeParams.
getAngle(
"maxPhi", 2 * M_PI),
159 (envelopeParams.
getNodes(
"InnerPoints/point").size() > 0)
162 for (
const GearDir& point : envelopeParams.
getNodes(
"InnerPoints/point")) {
163 pair<double, double> ZXPoint(point.getLength(
"z"), point.getLength(
"x"));
166 for (
const GearDir& point : envelopeParams.
getNodes(
"OuterPoints/point")) {
167 pair<double, double> ZXPoint(point.getLength(
"z"), point.getLength(
"x"));
173 string pathAlign = (boost::format(
"Align[@component='%1%']/") %
m_prefix).str();
176 B2WARNING(
"Could not find alignment parameters for component " <<
m_prefix);
177 return pxdGeometryPar;
188 GearDir components(content,
"Components/");
189 for (
const GearDir& paramsSensor : components.getNodes(
"Sensor")) {
190 string sensorTypeID = paramsSensor.getString(
"@type");
193 paramsSensor.getString(
"Color",
""),
194 paramsSensor.getLength(
"width"),
195 paramsSensor.getLength(
"width2", 0),
196 paramsSensor.getLength(
"length"),
197 paramsSensor.getLength(
"height"),
198 paramsSensor.getAngle(
"angle", 0),
199 paramsSensor.getBool(
"@slanted",
false)
202 paramsSensor.getString(
"Material"),
203 paramsSensor.getString(
"Active/Color",
"#f00"),
204 paramsSensor.getLength(
"Active/width"),
205 paramsSensor.getLength(
"Active/width2", 0),
206 paramsSensor.getLength(
"Active/length"),
207 paramsSensor.getLength(
"Active/height")
210 paramsSensor.getLength(
"Active/u"),
211 paramsSensor.getLength(
"Active/v"),
212 paramsSensor.getString(
"Active/w",
"center"),
213 paramsSensor.getLength(
"Active/woffset", 0)
217 sensor.setSensorInfo(pxdInfo);
224 GearDir support(content,
"Support/");
227 for (
const GearDir& shell : content.getNodes(
"HalfShell")) {
229 string shellName =
m_prefix +
"." + shell.getString(
"@name");
230 string pathShell = (boost::format(
"Align[@component='%1%']/") % shellName).str();
233 B2WARNING(
"Could not find alignment parameters for component " << shellName);
234 return pxdGeometryPar;
244 VXDHalfShellPar halfShell(shell.getString(
"@name"), shell.getAngle(
"shellAngle", 0));
246 for (
const GearDir& layer : shell.getNodes(
"Layer")) {
247 int layerID = layer.getInt(
"@id");
249 readLadder(layerID, components, pxdGeometryPar);
252 for (
const GearDir& ladder : layer.getNodes(
"Ladder")) {
253 int ladderID = ladder.getInt(
"@id");
254 double phi = ladder.getAngle(
"phi", 0);
256 halfShell.
addLadder(layerID, ladderID, phi);
263 GearDir radiationDir(content,
"RadiationSensors");
267 radiationDir.
getBool(
"insideEnvelope"),
277 position.getLength(
"radius"),
278 position.getAngle(
"theta")
282 for (
GearDir& sensor : position.getNodes(
"phi")) {
284 diamonds.
addSensor(sensor.getInt(
"@id"), sensor.getAngle());
291 return pxdGeometryPar;
298 endflange.getString(
"@name"),
299 endflange.getString(
"Material",
"Air"),
300 endflange.getAngle(
"minPhi", 0),
301 endflange.getAngle(
"maxPhi", 2 * M_PI),
302 (endflange.getNodes(
"Cutout").size() > 0),
303 endflange.getLength(
"Cutout/width1", 0.),
304 endflange.getLength(
"Cutout/width2", 0.),
305 endflange.getLength(
"Cutout/height", 0.),
306 endflange.getLength(
"Cutout/depth", 0.)
309 for (
const GearDir& plane : endflange.getNodes(
"Plane")) {
311 plane.getLength(
"posZ"),
312 plane.getLength(
"innerRadius"),
313 plane.getLength(
"outerRadius")
315 endflangePar.
getPlanes().push_back(planePar);
347 m_activeChips = parameters.getGlobalParams().getActiveChips();
348 m_seeNeutrons = parameters.getGlobalParams().getSeeNeutrons();
357 if (!material) B2FATAL(
"Default Material of VXD, '" <<
m_defaultMaterial <<
"', could not be found");
361 G4LogicalVolume* envelope(0);
362 G4VPhysicalVolume* physEnvelope{
nullptr};
363 if (!parameters.getEnvelope().getExists()) {
364 B2INFO(
"Could not find definition for " +
m_prefix +
" Envelope, placing directly in top volume");
365 envelope = &topVolume;
367 double minZ(0), maxZ(0);
369 parameters.getEnvelope().getInnerPoints(),
370 parameters.getEnvelope().getOuterPoints(),
371 parameters.getEnvelope().getMinPhi(),
372 parameters.getEnvelope().getMaxPhi(),
375 envelope =
new G4LogicalVolume(envelopeCone, material,
m_prefix +
".Envelope");
378 &topVolume,
false, 1);
381 G4Region* aRegion =
new G4Region(
"PXDEnvelope");
382 envelope->SetRegion(aRegion);
383 aRegion->AddRootLogicalVolume(envelope);
387 for (
const pair<const string, VXDGeoSensorPar>& typeAndSensor : parameters.getSensorMap()) {
388 const string& sensorTypeID = typeAndSensor.first;
415 vector<VXDGeoPlacement> subcomponents;
417 subcomponents.reserve(components.size());
418 std::transform(components.begin(), components.end(), std::back_inserter(subcomponents),
419 [](
auto const & component) {
420 return VXDGeoPlacement(component.getName(),
421 component.getU() / Unit::mm,
422 component.getV() / Unit::mm,
424 component.getWOffset() / Unit::mm
427 sensor.setComponents(subcomponents);
432 for (
const string& name : parameters.getComponentInsertOder()) {
438 B2WARNING(
"Component " << name <<
" already created from previous subcomponents, should not be here");
450 double angle = paramsComponent.
getAngle();
453 if (c.getWidth() <= 0 || c.getLength() <= 0 || c.getHeight() <= 0) {
454 B2DEBUG(100,
"One dimension empty, using auto resize for component");
456 G4VSolid* solid =
createTrapezoidal(
m_prefix +
"." + name, c.getWidth(), c.getWidth2(), c.getLength(), c.getHeight(), angle);
460 vector<VXDGeoPlacement> subComponents;
462 subComponents.reserve(paramsSubComponents.size());
463 std::transform(paramsSubComponents.begin(), paramsSubComponents.end(), std::back_inserter(subComponents),
464 [](
auto const & paramsSubComponent) {
465 return VXDGeoPlacement(paramsSubComponent.getName(),
466 paramsSubComponent.getU() / Unit::mm,
467 paramsSubComponent.getV() / Unit::mm,
468 paramsSubComponent.getW(),
469 paramsSubComponent.getWOffset() / Unit::mm
473 if (
m_activeChips && parameters.getSensitiveChipID(name) >= 0) {
474 int chipID = parameters.getSensitiveChipID(name);
475 B2DEBUG(50,
"Creating BkgSensitiveDetector for component " << name <<
" with chipID " << chipID);
477 c.getVolume()->SetSensitiveDetector(sensitive);
489 string shellName = shell.getName();
497 double shellAngle = shell.getShellAngle();
501 for (
const std::pair<
const int, std::vector<std::pair<int, double>> >& layer : shell.getLayers()) {
502 int layerID = layer.first;
503 const std::vector<std::pair<int, double>>& Ladders = layer.second;
514 for (
const std::pair<int, double>& ladder : Ladders) {
515 int ladderID = ladder.first;
516 double phi = ladder.second;
518 G4Transform3D ladderPlacement =
placeLadder(ladderID, phi, envelope, shellAlignment, parameters);
530 G4PVPlacement topPlacement(
nullptr, G4ThreeVector(0, 0, 0), &topVolume,
531 "temp_Top",
nullptr,
false, 1,
false);
538 if (parameters.getRadiationSensors().getSubDetector() ==
"") {
539 B2DEBUG(10,
"Apparently no radiation sensors defined, skipping");
541 createDiamonds(parameters.getRadiationSensors(), topVolume, *envelope);
550 sensorInfo->
setID(sensorID);
564 if (!parameters.getBuildSupport())
return supportAssembly;
568 const std::vector<VXDPolyConePar> Endflanges = parameters.getEndflanges();
571 double minZ(0), maxZ(0);
572 string name = endflange.getName();
575 double minPhi = endflange.getMinPhi();
576 double dPhi = endflange.getMaxPhi() - minPhi;
577 int nPlanes = endflange.getPlanes().size();
579 B2ERROR(
"Polycone needs at least two planes");
580 return supportAssembly;
582 std::vector<double> z(nPlanes, 0);
583 std::vector<double> rMin(nPlanes, 0);
584 std::vector<double> rMax(nPlanes, 0);
586 minZ = numeric_limits<double>::infinity();
587 maxZ = -numeric_limits<double>::infinity();
589 const std::vector<VXDPolyConePlanePar> Planes = endflange.getPlanes();
591 z[index] = plane.getPosZ() /
Unit::mm;
592 minZ = min(minZ, z[index]);
593 maxZ = max(maxZ, z[index]);
594 rMin[index] = plane.getInnerRadius() /
Unit::mm;
595 rMax[index] = plane.getOuterRadius() /
Unit::mm;
599 G4VSolid* supportCone =
new G4Polycone(name, minPhi, dPhi, nPlanes, z.data(), rMin.data(), rMax.data());
612 int nCutouts = parameters.getNCutOuts();
613 double sizeX = parameters.getCutOutWidth() /
Unit::mm / 2.;
614 double sizeY = parameters.getCutOutHeight() /
Unit::mm / 2.;
615 double sizeZ = (maxZ - minZ) / 2.;
616 G4ThreeVector origin(
617 parameters.getCutOutShift() /
Unit::mm,
618 parameters.getCutOutRPhi() /
Unit::mm,
622 double phi0 = parameters.getCutOutStartPhi();
623 double dphi = parameters.getCutOutDeltaPhi();
624 for (
int i = 0; i < nCutouts; ++i) {
625 G4Box* box =
new G4Box(
"Cutout", sizeX, sizeY, sizeZ);
626 G4Transform3D placement = G4RotateZ3D(phi0 + i * dphi) * G4Translate3D(origin);
627 G4VSolid* supportConeOld = supportCone;
628 supportCone =
new G4SubtractionSolid(
"PXD Support endflange", supportConeOld, box, placement);
632 string materialName = endflange.getMaterial();
634 if (!material) B2FATAL(
"Material '" << materialName <<
"', required by PXD component " << name <<
", could not be found");
636 G4LogicalVolume* volume =
new G4LogicalVolume(supportCone, material, name);
638 supportAssembly.
add(volume);
645 int nTubes = parameters.getNTubes();
646 double minZ = parameters.getTubesMinZ() /
Unit::mm;
647 double maxZ = parameters.getTubesMaxZ() /
Unit::mm;
648 double minR = parameters.getTubesMinR() /
Unit::mm;
649 double maxR = parameters.getTubesMaxR() /
Unit::mm;
650 double sizeZ = (maxZ - minZ) / 2.;
651 double shiftX = parameters.getTubesRPhi() /
Unit::mm;
653 double shiftZ = minZ + sizeZ;
654 double phi0 = parameters.getTubesStartPhi();
655 double dphi = parameters.getTubesDeltaPhi();
656 string material = parameters.getTubesMaterial();
658 G4Tubs* tube =
new G4Tubs(
"CarbonTube", minR, maxR, sizeZ, 0, 2 * M_PI);
661 for (
int i = 0; i < nTubes; ++i) {
662 G4Transform3D placement = G4RotateZ3D(phi0 + i * dphi) * G4Translate3D(shiftX, shiftY, shiftZ);
663 supportAssembly.
add(tubeVol, placement);
667 return supportAssembly;
The Class for BeamBackground Sensitive Detector.
GearDir is the basic class used for accessing the parameter store.
virtual std::string getString(const std::string &path="") const noexcept(false) override
Get the parameter path as a string.
The Class for VXD geometry.
void setNTubes(int nTubes)
set number of tubes
void setTubesRPhi(double rphi)
set tubes tubes RPhi
void setTubesMaxR(double maxR)
set tubes maxR
const std::vector< VXDPolyConePar > & getEndflanges() const
get Endflanges
void setNCutOuts(int nCutouts)
set number of cutouts
void setCutOutShift(double shift)
set shift of cutouts
std::vector< PXDSensorInfoPar * > & getSensorInfos()
get sensorInfos
void setCutOutWidth(double width)
set width of cutouts
void setTubesMinZ(double minZ)
set tubes minZ
void setCutOutHeight(double height)
set height of cutouts
void setCutOutDeltaPhi(double delta)
set deltaphi of cutouts
void setTubesDeltaPhi(double delta)
set tubes tubes DeltaPhi
void setTubesMaxZ(double maxZ)
set tubes maxZ
void setTubesMinR(double minR)
set tubes minR
void setCutOutStartPhi(double start)
set start phi of cutouts
void setCutOutRPhi(double rphi)
set rphi of cutouts
void setTubesStartPhi(double start)
set tubes tubes StartPhi
void setTubesMaterial(const std::string &material)
set tubes tubes material
The Class for VXD geometry.
double getTopVoltage() const
Return the voltage at the top of the sensor.
double getClearBorderSmallPitch() const
Return the distance along u between the clear side of a small pixel and the start of the internal gat...
double getChargeThreshold() const
Get the charge threshold in ADU for the sensor.
double getGateDepth() const
Return the gate depth for the sensor.
double getDrainBorderLargePitch() const
Return the distance along v between the drain side of a large pixel and the start of the internal gat...
double getClearBorderLargePitch() const
Return the distance along u between the clear side of a large pixel and the start of the internal gat...
double getNoiseFraction() const
Get the noise fraction for the sensor.
double getBulkDoping() const
Return the bulk doping of the Silicon sensor.
bool getDoublePixel() const
Return true if the Sensor is a double pixel structure: every other pixel is mirrored along v.
double getSourceBorderSmallPitch() const
Return the distance along v between the source side of a small pixel and the start of the internal ga...
double getSourceBorderLargePitch() const
Return the distance along v between the source side of a large pixel and the start of the internal ga...
double getIntegrationEnd() const
Return the end of the integration window, the timeframe the PXD is sensitive.
double getBackVoltage() const
Return the voltage at the backside of the sensor.
double getIntegrationStart() const
Return the start of the integration window, the timeframe the PXD is sensitive.
double getDrainBorderSmallPitch() const
Return the distance along v between the drain side of a small pixel and the start of the internal gat...
virtual VXD::GeoVXDAssembly createLayerSupport()
Create support structure for a PXD Layer.
void createGeometry(const PXDGeometryPar ¶meters, G4LogicalVolume &topVolume, geometry::GeometryTypes type)
Create the geometry from a parameter object.
virtual VXD::SensitiveDetectorBase * createSensitiveDetector(VxdID sensorID, const VXDGeoSensor &sensor, const VXDGeoSensorPlacement &placement) override
Return a SensitiveDetector implementation for a given sensor.
std::vector< SensorInfo * > m_SensorInfo
Vector of points to SensorInfo objects.
void readHalfShellSupport(const GearDir &support, PXDGeometryPar &pxdGeometryPar)
Create support structure for VXD Half Shell, that means everything that does not depend on layer or s...
PXDGeometryPar createConfiguration(const GearDir ¶m)
Create a parameter object from the Gearbox XML parameters.
PXDSensorInfoPar * readSensorInfo(const GearDir &sensor)
Read the sensor definitions from the gearbox.
virtual ~GeoPXDCreator()
The destructor of the GeoPXDCreator class.
virtual VXD::GeoVXDAssembly createLadderSupport()
Create support structure for a PXD Ladder.
virtual VXD::GeoVXDAssembly createHalfShellSupport(const PXDGeometryPar ¶meters)
Create support structure for PXD Half Shell, that means everything that does not depend on layer or s...
virtual VXD::SensorInfoBase * createSensorInfo(const VXDGeoSensorPar &sensor) override
Read the sensor definitions from the database.
Specific implementation of SensorInfo for PXD Sensors which provides additional pixel specific inform...
void flipVSegmentation()
Flip the Pitch segmentation along v.
void setID(VxdID id)
Change the SensorID, useful to copy the SensorInfo from one sensor and use it for another.
static const double mm
[millimeters]
static const double um
[micrometers]
The Class for VXD Alignment payload.
The Class for VXD Envelope parameters.
The Class for VXD geometry component.
double getWidth() const
get the width of the component
double getHeight() const
get the height of the component
const std::vector< VXDGeoPlacementPar > & getSubComponents() const
get sub components
const std::string & getColor() const
get the name of the color for the component
double getAngle() const
get the angle of the component
double getWidth2() const
get the forward width of the component, 0 for rectangular
const std::string & getMaterial() const
get the name of the Material for the component
double getLength() const
get the length of the component
Class holding all parameters for an VXD geometry component.
The Class for VXD placement payload.
double getU() const
get local u coordinate where to place the component
double getV() const
get local v coordinate where to place the component
const std::string & getW() const
get local w position where to place the component
double getWOffset() const
get offset to local w position where to place the component
Class holding all parameters to place a VXD geometry subcomponent.
The Class for VXD Radiation Sensor parameters.
void addPosition(const VXDGeoRadiationSensorsPositionPar &position)
add radiation sensor position
The Class for VXD Radiation Sensor Position parameters.
void addSensor(int id, double phi)
add sensor with individual id
The Class for VXD Sensor payload.
const VXDGeoPlacementPar & getActivePlacement() const
get the placement description for the active area
const std::vector< VXDGeoPlacementPar > & getComponents() const
get the list of sub components
const VXDGeoComponentPar & getActiveArea() const
get the component description for the active area
bool getSlanted() const
return wether or not the sensor is slanted (usually only the first sensor in layers 4-6)
Struct holding the information where a sensor should be placed inside the ladder.
bool getFlipV() const
check whether or not the sensor should be flipped around the V coordinate
Struct holding all parameters for a completeVXD Sensor.
const std::vector< VXDHalfShellPar > & getHalfShells() const
get half-shell
void setGlobalParams(const VXDGlobalPar &globals)
set global parameters
void setRadiationSensors(const VXDGeoRadiationSensorsPar &diamonds)
set radiation sensor parameters
const std::map< std::string, VXDGeoSensorPar > & getSensorMap() const
get sensor map
void setEnvelope(const VXDEnvelopePar &envelope)
set envelope parameters
const VXDGlobalPar & getGlobalParams() const
get global parameters
void setPrefix(const std::string &prefix)
set prefix
std::map< std::string, VXDAlignmentPar > & getAlignmentMap()
get alignmant map
The Class for VXD global paramter payload.
bool getActiveChips() const
Get whether chips are sensitive
The Class for VXD half shell payload.
void addLadder(int layerID, int ladderID, double phi)
add ladder
The Class for VXD PolyCone, possibly with coutouts.
std::vector< VXDPolyConePlanePar > & getPlanes(void)
Get planes.
The Class for VXD Polycone Plane.
const std::list< std::pair< double, double > > & getInnerPoints() const
get inner XZ points
const std::list< std::pair< double, double > > & getOuterPoints() const
get outer XZ points
double getWidth() const
Return the (backward) width of the sensor.
int getUCells() const
Return number of pixel/strips in u direction.
double getThickness() const
Return the thickness of the sensor.
int getVCells2() const
Return number of pixel/strips in v direction for second segment.
double getSplitLength() const
Return the splitLength of the sensor.
int getVCells1() const
Return number of pixel/strips in v direction for first segment.
double getLength() const
Return the length of the sensor.
void findVolumes(G4VPhysicalVolume *envelope)
Search a given Geometry for Sensors.
static GeoCache & getInstance()
Return a reference to the singleton instance.
void addHalfShellPlacement(VxdID halfShell, const G4Transform3D &placement)
Remember how half-shell is placed into world volume.
Class to group some Geant4 volumes and place them all at once with a given transformation matrix.
void place(G4LogicalVolume *mother, const G4Transform3D &transform)
Place all the volumes already added to the assembly in the given mother.
void add(G4LogicalVolume *volume, const G4Transform3D &transform=G4Transform3D())
Add a volume to the assembly.
std::map< std::string, VXDGeoSensor > m_sensorMap
Map containing Information about all defined sensor types.
float m_minimumElectrons
minimum number of electrons to be deposited by a particle to be saved
G4VSolid * createTrapezoidal(const std::string &name, double width, double width2, double length, double &height, double angle=0)
Create a trapezoidal solid.
virtual void readLadderComponents(int layerID, int ladderID, GearDir content, VXDGeometryPar &vxdGeometryPar)
Read parameters for ladder components and their alignment corresponding to the given ladder id.
void createDiamonds(const VXDGeoRadiationSensorsPar ¶ms, G4LogicalVolume &topVolume, G4LogicalVolume &envelopeVolume)
Create diamond radiation sensors.
std::vector< Simulation::SensitiveDetectorBase * > m_sensitive
List to all created sensitive detector instances.
std::string m_prefix
Prefix to prepend to all volume names.
bool m_onlyActiveMaterial
If this is true, only active Materials will be placed for tracking studies.
double m_activeStepSize
Stepsize to be used inside active volumes.
float m_distanceTolerance
tolerance for Geant4 steps to be merged to a single step
virtual void readLadder(int layer, GearDir components, VXDGeometryPar &geoparameters)
Read parameters for a ladder in layer with given ID from gearbox and layer store them in payload.
std::map< std::string, Belle2::VxdID > m_halfShellVxdIDs
Used for translation of half-shell name into a VxdID to consitently handle it in hierarchy.
bool m_onlyPrimaryTrueHits
If true only create TrueHits from primary particles and ignore secondaries.
float m_electronTolerance
tolerance for the energy deposition in electrons to be merged in a single step
G4Transform3D getAlignment(const VXDAlignmentPar ¶ms)
Get Alignment from paylead object.
GeoVXDAssembly createSubComponents(const std::string &name, VXDGeoComponent &component, std::vector< VXDGeoPlacement > placements, bool originCenter=true, bool allowOutside=false)
Place a list of subcomponents into an component.
std::map< std::string, VXDGeoComponent > m_componentCache
Cache of all previously created components.
G4Transform3D placeLadder(int ladderID, double phi, G4LogicalVolume *volume, const G4Transform3D &placement, const VXDGeometryPar ¶meters)
Place ladder corresponding to the given ladder id into volume setLayer has to be called first to set ...
virtual void setCurrentLayer(int layer, const VXDGeometryPar ¶meters)
Read parameters for given layer and store in m_ladder.
std::vector< VXDGeoPlacementPar > getSubComponents(const GearDir &path)
Return vector of VXDGeoPlacements with all the components defined inside a given path.
bool m_seeNeutrons
Make sensitive detectors also see neutrons.
std::string m_defaultMaterial
Name of the Material to be used for Air.
bool m_activeChips
Make also chips sensitive.
std::string m_currentHalfShell
Current half-shell being processed (need to know ladder parent for hierarchy)
Base class for Sensitive Detector implementation of PXD and SVD.
Sensitive Detector implementation of PXD and SVD.
Base class to provide Sensor Information for PXD and SVD.
Class to uniquely identify a any structure of the PXD and SVD.
double getAngle(const std::string &path="") const noexcept(false)
Get the parameter path as a double converted to the standard angle unit.
double getLength(const std::string &path="") const noexcept(false)
Get the parameter path as a double converted to the standard length unit.
std::vector< GearDir > getNodes(const std::string &path="") const
Get vector of GearDirs which point to all the nodes the given path evaluates to.
bool getBool(const std::string &path="") const noexcept(false)
Get the parameter path as a bool.
int getInt(const std::string &path="") const noexcept(false)
Get the parameter path as a int.
static G4Material * get(const std::string &name)
Find given material.
VXD::SensitiveDetector< PXDSimHit, PXDTrueHit > SensitiveDetector
The PXD Sensitive Detector class.
geometry::CreatorFactory< GeoPXDCreator > GeoPXDFactory("PXDCreator")
Register the creator.
G4Polycone * createRotationSolid(const std::string &name, const GearDir ¶ms, double &minZ, double &maxZ)
Create a solid by roating two polylines around the Z-Axis.
void setVisibility(G4LogicalVolume &volume, bool visible)
Helper function to quickly set the visibility of a given volume.
void setColor(G4LogicalVolume &volume, const std::string &color)
Set the color of a logical volume.
GeometryTypes
Flag indiciating the type of geometry to be used.
Abstract base class for different kinds of events.
Very simple class to provide an easy way to register creators with the CreatorManager.