GeoPXDCreator Class Reference

The creator for the PXD geometry of the Belle II detector. More...

#include <GeoPXDCreator.h>

Inheritance diagram for GeoPXDCreator:

Collaboration diagram for GeoPXDCreator:

Public Member Functions
	GeoPXDCreator ()
	Constructor of the GeoPXDCreator class.
virtual	~GeoPXDCreator ()
	The destructor of the GeoPXDCreator class.
virtual void	create (const GearDir &content, G4LogicalVolume &topVolume, geometry::GeometryTypes type) override
	The old create member: create the configuration object(s) on the fly and call the geometry creation routine.
virtual void	createPayloads (const GearDir &content, const IntervalOfValidity &iov) override
	Create the configuration objects and save them in the Database. More...
virtual void	createFromDB (const std::string &name, G4LogicalVolume &topVolume, geometry::GeometryTypes type) override
	Create the geometry from the Database.
virtual VXD::GeoVXDAssembly	createLayerSupport ()
	Create support structure for a PXD Layer. More...
virtual VXD::GeoVXDAssembly	createLadderSupport ()
	Create support structure for a PXD Ladder. More...
virtual VXD::GeoVXDAssembly	createHalfShellSupport (const PXDGeometryPar &parameters)
	Create support structure for PXD Half Shell, that means everything that does not depend on layer or sensor alignment. More...
virtual VXD::SensorInfoBase *	createSensorInfo (const VXDGeoSensorPar &sensor) override
	Read the sensor definitions from the database. More...
PXDSensorInfoPar *	readSensorInfo (const GearDir &sensor)
	Read the sensor definitions from the gearbox. More...
virtual VXD::SensitiveDetectorBase *	createSensitiveDetector (VxdID sensorID, const VXDGeoSensor &sensor, const VXDGeoSensorPlacement &placement) override
	Return a SensitiveDetector implementation for a given sensor. More...
void	readHalfShellSupport (const GearDir &support, PXDGeometryPar &pxdGeometryPar)
	Create support structure for VXD Half Shell, that means everything that does not depend on layer or sensor alignment. More...
virtual void	setCurrentLayer (int layer, const VXDGeometryPar &parameters)
	Read parameters for given layer and store in m_ladder.
G4Transform3D	placeLadder (int ladderID, double phi, G4LogicalVolume *volume, const G4Transform3D &placement, const VXDGeometryPar &parameters)
	Place ladder corresponding to the given ladder id into volume setLayer has to be called first to set the correct layer id.
G4Transform3D	getPosition (const VXDGeoComponent &mother, const VXDGeoComponent &daughter, const VXDGeoPlacement &placement, bool originCenter)
	Return the position where a daughter component is to be placed. More...
G4Transform3D	getAlignment (const VXDAlignmentPar &params)
	Get Alignment from paylead object. More...
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. More...
G4VSolid *	createTrapezoidal (const std::string &name, double width, double width2, double length, double &height, double angle=0)
	Create a trapezoidal solid. More...
void	createDiamonds (const VXDGeoRadiationSensorsPar &params, G4LogicalVolume &topVolume, G4LogicalVolume &envelopeVolume)
	Create diamond radiation sensors.
std::vector< VXDGeoPlacementPar >	getSubComponents (const GearDir &path)
	Return vector of VXDGeoPlacements with all the components defined inside a given path.
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.
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	readComponent (const std::string &name, GearDir components, VXDGeometryPar &vxdGeometryPar)
	Read parameters for component name from Gearbox into geometry payload. More...
void	readSubComponents (const std::vector< VXDGeoPlacementPar > &placements, const GearDir &componentsDir, VXDGeometryPar &vxdGeometryPar)
	Read parameters for all components in placement container from Gearbox into payload. More...
	BELLE2_DEFINE_EXCEPTION (DBNotImplemented, "Cannot create geometry from Database.")
	Exception that will be thrown in createFromDB if member is not yet implemented by creator.

Protected Attributes
std::string	m_prefix
	Prefix to prepend to all volume names.
GearDir	m_alignment
	GearDir pointing to the alignment parameters.
GearDir	m_components
	GearDir pointing to the toplevel of the components.
std::map< std::string, VXDGeoComponent >	m_componentCache
	Cache of all previously created components.
std::map< std::string, VXDGeoSensor >	m_sensorMap
	Map containing Information about all defined sensor types.
VXDGeoLadder	m_ladder
	Parameters of the currently active ladder.
std::vector< Simulation::SensitiveDetectorBase * >	m_sensitive
	List to all created sensitive detector instances.
GeoVXDRadiationSensors	m_radiationsensors
	Diamond radiation sensor "sub creator".
std::string	m_defaultMaterial
	Name of the Material to be used for Air.
float	m_distanceTolerance {(float)(5 * Unit::um)}
	tolerance for Geant4 steps to be merged to a single step
float	m_electronTolerance {100}
	tolerance for the energy deposition in electrons to be merged in a single step
float	m_minimumElectrons {10}
	minimum number of electrons to be deposited by a particle to be saved
double	m_activeStepSize {5 * Unit::um}
	Stepsize to be used inside active volumes.
bool	m_activeChips {false}
	Make also chips sensitive.
bool	m_seeNeutrons {false}
	Make sensitive detectors also see neutrons.
bool	m_onlyPrimaryTrueHits {false}
	If true only create TrueHits from primary particles and ignore secondaries.
bool	m_onlyActiveMaterial {false}
	If this is true, only active Materials will be placed for tracking studies. More...
std::vector< G4UserLimits * >	m_UserLimits
	Vector of G4UserLimit pointers.
std::string	m_currentHalfShell {""}
	Current half-shell being processed (need to know ladder parent for hierarchy)
std::map< std::string, Belle2::VxdID >	m_halfShellVxdIDs
	Used for translation of half-shell name into a VxdID to consitently handle it in hierarchy. More...

Private Member Functions
PXDGeometryPar	createConfiguration (const GearDir &param)
	Create a parameter object from the Gearbox XML parameters.
void	createGeometry (const PXDGeometryPar &parameters, G4LogicalVolume &topVolume, geometry::GeometryTypes type)
	Create the geometry from a parameter object.

Private Attributes
std::vector< SensorInfo * >	m_SensorInfo
	Vector of points to SensorInfo objects.

Detailed Description

The creator for the PXD geometry of the Belle II detector.

Definition at line 27 of file GeoPXDCreator.h.

Member Function Documentation

createHalfShellSupport()

VXD::GeoVXDAssembly createHalfShellSupport ( const PXDGeometryPar &  parameters )

virtual

Create support structure for PXD Half Shell, that means everything that does not depend on layer or sensor alignment.

Parameters

parameters

Reference to the database containing the parameters

Definition at line 561 of file GeoPXDCreator.cc.

    {
      VXD::GeoVXDAssembly supportAssembly;
 
      if (!parameters.getBuildSupport()) return supportAssembly;
 
 
      // Create the Endlanges
      const std::vector<VXDPolyConePar> Endflanges = parameters.getEndflanges();
      for (const VXDPolyConePar& endflange : Endflanges) {
 
        double minZ(0), maxZ(0);
        string name = endflange.getName();
 
        // Create a polycone
        double minPhi = endflange.getMinPhi();
        double dPhi   = endflange.getMaxPhi() - minPhi;
        int nPlanes = endflange.getPlanes().size();
        if (nPlanes < 2) {
          B2ERROR("Polycone needs at least two planes");
          return supportAssembly;
        }
        std::vector<double> z(nPlanes, 0);
        std::vector<double> rMin(nPlanes, 0);
        std::vector<double> rMax(nPlanes, 0);
        int index(0);
        minZ = numeric_limits<double>::infinity();
        maxZ = -numeric_limits<double>::infinity();
 
        const std::vector<VXDPolyConePlanePar> Planes = endflange.getPlanes();
        for (const VXDPolyConePlanePar& plane : Planes) {
          z[index]    = plane.getPosZ() / Unit::mm;
          minZ = min(minZ, z[index]);
          maxZ = max(maxZ, z[index]);
          rMin[index] = plane.getInnerRadius() / Unit::mm;
          rMax[index] = plane.getOuterRadius() / Unit::mm;
          ++index;
        }
 
        G4VSolid* supportCone = new G4Polycone(name, minPhi, dPhi, nPlanes, z.data(), rMin.data(), rMax.data());
 
 
        //Cutout boxes to make place for modules
 
        //We have the z dimensions of the polycon. Let's
        //add 1mm on each side to make sure we don't run into problems when the
        //surfaces match
        minZ -= 1. / Unit::mm;
        maxZ += 1. / Unit::mm;
 
 
        //Now get the number of cutouts and their size/position/angle
        int nCutouts  = parameters.getNCutOuts();
        double sizeX  = parameters.getCutOutWidth() / Unit::mm / 2.;
        double sizeY  = parameters.getCutOutHeight() / Unit::mm / 2.;
        double sizeZ  = (maxZ - minZ) / 2.;
        G4ThreeVector origin(
          parameters.getCutOutShift() / Unit::mm,
          parameters.getCutOutRPhi() / Unit::mm,
          minZ + sizeZ
        );
 
        double phi0   = parameters.getCutOutStartPhi();
        double dphi   = parameters.getCutOutDeltaPhi();
        for (int i = 0; i < nCutouts; ++i) {
          G4Box* box = new G4Box("Cutout", sizeX, sizeY, sizeZ);
          G4Transform3D placement = G4RotateZ3D(phi0 + i * dphi) * G4Translate3D(origin);
          G4VSolid* supportConeOld = supportCone;
          supportCone = new G4SubtractionSolid("PXD Support endflange", supportConeOld, box, placement);
        }
 
 
        string materialName = endflange.getMaterial();
        G4Material* material = geometry::Materials::get(materialName);
        if (!material) B2FATAL("Material '" << materialName << "', required by PXD component " << name << ", could not be found");
 
        G4LogicalVolume* volume = new G4LogicalVolume(supportCone, material, name);
        geometry::setColor(*volume, "#ccc4");
        supportAssembly.add(volume);
 
      }
 
 
      //Create Carbon cooling tubes
      {
        int nTubes    = parameters.getNTubes();
        double minZ   = parameters.getTubesMinZ() / Unit::mm;
        double maxZ   = parameters.getTubesMaxZ() / Unit::mm;
        double minR   = parameters.getTubesMinR() / Unit::mm;
        double maxR   = parameters.getTubesMaxR() / Unit::mm;
        double sizeZ  = (maxZ - minZ) / 2.;
        double shiftX = parameters.getTubesRPhi() / Unit::mm;
        double shiftY = 0;
        double shiftZ = minZ + sizeZ;
        double phi0   = parameters.getTubesStartPhi();
        double dphi   = parameters.getTubesDeltaPhi();
        string material = parameters.getTubesMaterial();
 
        G4Tubs* tube = new G4Tubs("CarbonTube", minR, maxR, sizeZ, 0, 2 * M_PI);
        G4LogicalVolume* tubeVol = new G4LogicalVolume(tube, geometry::Materials::get(material), "CarbonTube");
        geometry::setColor(*tubeVol, "#000");
        for (int i = 0; i < nTubes; ++i) {
          G4Transform3D placement = G4RotateZ3D(phi0 + i * dphi) * G4Translate3D(shiftX, shiftY, shiftZ);
          supportAssembly.add(tubeVol, placement);
        }
      }
 
      return supportAssembly;
    }

createLadderSupport()

VXD::GeoVXDAssembly createLadderSupport ( )

virtual

Create support structure for a PXD Ladder.

Parameters

layer	Layer ID to create the support
support	Reference to the database containing the parameters

Definition at line 559 of file GeoPXDCreator.cc.

createLayerSupport()

VXD::GeoVXDAssembly createLayerSupport ( )

virtual

Create support structure for a PXD Layer.

Parameters

layer	Layer ID to create the support
support	Reference to the database containing the parameters

Definition at line 557 of file GeoPXDCreator.cc.

createPayloads()

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

inlineoverridevirtual

Create the configuration objects and save them in the Database.

If more than one object is needed adjust accordingly

Reimplemented from CreatorBase.

Definition at line 51 of file GeoPXDCreator.h.

      {
        DBImportObjPtr<PXDGeometryPar> importObj;
        PXDGeometryPar config = createConfiguration(content);
        importObj.construct(config);
        importObj.import(iov);
      }

createSensitiveDetector()

VXD::SensitiveDetectorBase * createSensitiveDetector ( VxdID  sensorID, const VXDGeoSensor &  sensor, const VXDGeoSensorPlacement &  placement  )

overridevirtual

Return a SensitiveDetector implementation for a given sensor.

Parameters

sensorID	SensorID for the sensor
sensor	Information about the sensor to create the Sensitive Detector for
placement	Information on how to place the sensor

Implements GeoVXDCreator.

Definition at line 547 of file GeoPXDCreator.cc.

createSensorInfo()

VXD::SensorInfoBase * createSensorInfo ( const VXDGeoSensorPar &  sensor )

overridevirtual

Read the sensor definitions from the database.

Parameters

sensor

Reference to the database containing the parameters

Implements GeoVXDCreator.

Definition at line 57 of file GeoPXDCreator.cc.

createSubComponents()

GeoVXDAssembly createSubComponents ( const std::string &  name, VXDGeoComponent &  component, std::vector< VXDGeoPlacement >  placements, bool  originCenter = true, bool  allowOutside = false  )

inherited

Place a list of subcomponents into an component.

If the volume of the given component is NULL, a new container will be created to fit all subcomponents. It will have air as medium. If at least one subcomponent with this placement is found the whole component is wrapped in a container volume with Air medium which extends above and below to fit the subcomponents

Parameters

name	Name for the potential new volume or as prefix for the container to extend the component
component	Component to fit the subcomponents into
placements	Placement information for all subcomponents
originCenter	bool
allowOutside	bool

Returns

offset in w which was applied to the component when extending it

Definition at line 74 of file GeoVXDCreator.cc.

    {
      GeoVXDAssembly assembly;
      B2DEBUG(100, "Creating component " << name);
      vector<VXDGeoComponent> subComponents;
      subComponents.reserve(placements.size());
      //Go over all subcomponents and check if they will fit inside.
      //If component.volume is zero we will create one so sum up needed space
      bool widthResize  = component.getWidth() <= 0;
      bool lengthResize = component.getLength() <= 0;
      bool heightResize = component.getHeight() <= 0;
 
      for (VXDGeoPlacement& p : placements) {
        //Test component already exists
        if (m_componentCache.find(p.getName()) == m_componentCache.end()) {
          B2FATAL("A component is requested that was not created before!");
        }
        VXDGeoComponent sub = m_componentCache[p.getName()];
 
        B2DEBUG(100, "SubComponent " << p.getName());
        B2DEBUG(100, boost::format("Placement: u:%1% cm, v:%2% cm, w:%3% + %4% cm") % p.getU() % p.getV() % p.getW() % p.getWOffset());
        B2DEBUG(100, boost::format("Dimensions: %1%x%2%x%3% cm") % sub.getWidth() % sub.getLength() % sub.getHeight());
 
        if (p.getW() == VXDGeoPlacement::c_above || p.getW() == VXDGeoPlacement::c_below) {
          //Below placement only valid if we are allowed to create a container around component
          if (!allowOutside) B2FATAL("Cannot place component " << p.getName() << " outside of component " << name);
        } else if (sub.getHeight() + p.getWOffset() > component.getHeight()) {
          //Component will not fit heightwise. If we resize the volume anyway than we don't have problems
          if (!heightResize) {
            B2FATAL("Subcomponent " << p.getName() << " does not fit into volume: "
                    << "height " << sub.getHeight() << " > " << component.getHeight());
          }
          component.getHeight() = sub.getHeight() + p.getWOffset();
        }
 
        //Check if compoent will fit inside width,length. If we can resize do it if needed, otherwise bail
        double minWidth =  max(abs(p.getU() + sub.getWidth() / 2.0), abs(p.getU() - sub.getWidth() / 2.0));
        double minLength = max(abs(p.getV() + sub.getLength() / 2.0), abs(p.getV() - sub.getLength() / 2.0));
        if (minWidth > component.getWidth() + component.getWidth() * numeric_limits<double>::epsilon()) {
          if (!widthResize) {
            B2FATAL("Subcomponent " << p.getName() << " does not fit into volume: "
                    << "minWidth " << minWidth << " > " << component.getWidth());
          }
          component.setWidth(minWidth * 2.0);
        }
        if (minLength > component.getLength() + component.getLength() * numeric_limits<double>::epsilon()) {
          if (!lengthResize) {
            B2FATAL("Subcomponent " << p.getName() << " does not fit into volume: "
                    << "minLength " << minLength << " > " << component.getLength());
          }
          component.setLength(minLength * 2.0);
        }
        subComponents.push_back(sub);
      }
 
      //zero dimensions are fine mathematically but we don't want them in the simulation
      if (component.getWidth() <= 0 || component.getLength() <= 0 || component.getHeight() <= 0) {
        B2FATAL("At least one dimension of component " << name << " is zero which does not make sense");
      }
 
      //No volume yet, create a new one automatically assuming air material
      if (!component.getVolume()) {
        G4VSolid* componentShape = createTrapezoidal(name, component.getWidth(), component.getWidth2(), component.getLength(),
                                                     component.getHeight());
        component.setVolume(new G4LogicalVolume(componentShape, Materials::get(component.getMaterial()), name));
      }
 
      B2DEBUG(100, boost::format("Component %1% dimensions: %2%x%3%x%4% cm") % name % component.getWidth() % component.getLength() %
              component.getHeight());
 
      //Ok, all volumes set up, now add them together
      for (size_t i = 0; i < placements.size(); ++i) {
        VXDGeoPlacement& p = placements[i];
        VXDGeoComponent& s = subComponents[i];
 
        G4Transform3D transform = getPosition(component, s, p, originCenter);
        if (p.getW() ==  VXDGeoPlacement::c_below || p.getW() == VXDGeoPlacement::c_above) {
          //Add to selected mother (either component or container around component
          assembly.add(s.getVolume(), transform);
        } else {
          new G4PVPlacement(transform, s.getVolume(), name + "." + p.getName(), component.getVolume(), false, i);
        }
      }
 
      //Set some visibility options for volume. Done here because all components including sensor go through here
      if (component.getColor().empty()) {
        B2DEBUG(200, "Component " << name << " is an Air volume, setting invisible");
        setVisibility(*component.getVolume(), false);
      } else {
        B2DEBUG(200, "Component " << name << " color: " << component.getColor());
        setColor(*component.getVolume(), component.getColor());
      }
      B2DEBUG(100, "--> Created component " << name);
      //Return the difference in W between the origin of the original component and the including container
      return assembly;
    }

createTrapezoidal()

G4VSolid * createTrapezoidal ( const std::string &  name, double  width, double  width2, double  length, double &  height, double  angle = 0  )

inherited

Create a trapezoidal solid.

Parameters

	name	name of the Geant4 solid
	width	full forward width of the shape in mm
	width2	full backward width of the shape in mm
	length	length of the shape in mm
[in,out]	height	of the shape in mm. If angle is not 0 this value might be changed if the actual height will be smaller due to the slanted edges
	angle	angle of the sides along w with respect to to the uv plane. 0 means normal box shaped, !=0 means the upper endcap of the solid will be smaller since all edges will be slanted by angle

Returns

A G4VShape which could be a G4Box, a G4Trd or a G4Trap depending on the parameters

Definition at line 254 of file GeoVXDCreator.cc.

getAlignment()

G4Transform3D getAlignment ( const VXDAlignmentPar &  params )

inherited

Get Alignment from paylead object.

Parameters

params

Payload object

Returns

Transformation matrix for component

Definition at line 172 of file GeoVXDCreator.cc.

getPosition()

G4Transform3D getPosition ( const VXDGeoComponent &  mother, const VXDGeoComponent &  daughter, const VXDGeoPlacement &  placement, bool  originCenter  )

inherited

Return the position where a daughter component is to be placed.

Parameters

mother	Mother component
daughter	Daughter component
placement	VXDGeoPlacement
originCenter	bool

Returns

Transformation matrix to place the daughter relative to the origin to the mother

Definition at line 179 of file GeoVXDCreator.cc.

readComponent()

void readComponent ( const std::string &  name, GearDir  components, VXDGeometryPar &  vxdGeometryPar  )

inherited

Read parameters for component name from Gearbox into geometry payload.

The name is assumed to be unique and Volumes are cached.

Parameters

name	Name of the component
components	Path to components
vxdGeometryPar	VXD geometry parameters

Definition at line 532 of file GeoVXDCreator.cc.

readHalfShellSupport()

void readHalfShellSupport	(	const GearDir &	support,
		PXDGeometryPar &	pxdGeometryPar
	)

Create support structure for VXD Half Shell, that means everything that does not depend on layer or sensor alignment.

Parameters

support	Reference to the database containing the parameters
pxdGeometryPar	PXD geometry

Definition at line 295 of file GeoPXDCreator.cc.

readSensorInfo()

PXDSensorInfoPar * readSensorInfo

(

const GearDir &

sensor

)

Read the sensor definitions from the gearbox.

Parameters

sensor

Reference to the database containing the parameters

Definition at line 96 of file GeoPXDCreator.cc.

readSubComponents()

void readSubComponents ( const std::vector< VXDGeoPlacementPar > &  placements, const GearDir &  componentsDir, VXDGeometryPar &  vxdGeometryPar  )

inherited

Read parameters for all components in placement container from Gearbox into payload.

Parameters

placements	container holding names of all components to be cached
componentsDir	Path to Gearbox where parameters are to be found
vxdGeometryPar

Definition at line 523 of file GeoVXDCreator.cc.

Member Data Documentation

m_halfShellVxdIDs

std::map<std::string, Belle2::VxdID> m_halfShellVxdIDs

protectedinherited

Initial value:

{
        {{"PXD.Ying"}, {Belle2::VxdID(1, 0, 0, 1)}},
        {{"PXD.Yang"}, {Belle2::VxdID(1, 0, 0, 2)}},
        {{"SVD.Pat"}, {Belle2::VxdID(3, 0, 0, 1)}},
        {{"SVD.Mat"}, {Belle2::VxdID(3, 0, 0, 2)}}
      }

Used for translation of half-shell name into a VxdID to consitently handle it in hierarchy.

Definition at line 222 of file GeoVXDCreator.h.

m_onlyActiveMaterial

bool m_onlyActiveMaterial {false}

protectedinherited

If this is true, only active Materials will be placed for tracking studies.

Dead Material will be ignored

Definition at line 216 of file GeoVXDCreator.h.

---

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

• pxd/geometry/include/GeoPXDCreator.h
• pxd/geometry/src/GeoPXDCreator.cc