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

#include <GeoPXDCreator.h>

Inheritance 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.

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.

virtual VXD::GeoVXDAssembly	createLadderSupport ()
	Create support structure for a PXD Ladder.

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.

virtual VXD::SensorInfoBase *	createSensorInfo (const VXDGeoSensorPar &sensor) override
	Read the sensor definitions from the database.

PXDSensorInfoPar *	readSensorInfo (const GearDir &sensor)
	Read the sensor definitions from the gearbox.

virtual VXD::SensitiveDetectorBase *	createSensitiveDetector (VxdID sensorID, const VXDGeoSensor &sensor, const VXDGeoSensorPlacement &placement) override
	Return a SensitiveDetector implementation for a given sensor.

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.

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.

G4Transform3D	getAlignment (const VXDAlignmentPar &params)
	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.

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

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.

void	readSubComponents (const std::vector< VXDGeoPlacementPar > &placements, const GearDir &componentsDir, VXDGeometryPar &vxdGeometryPar)
	Read parameters for all components in placement container from Gearbox into payload.

	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.

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 consistently handle it in hierarchy.

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.

Constructor & Destructor Documentation

◆ GeoPXDCreator()

GeoPXDCreator ( )

inline

Constructor of the GeoPXDCreator class.

Definition at line 36 of file GeoPXDCreator.h.

36: VXD::GeoVXDCreator("PXD") {};

◆ ~GeoPXDCreator()

~GeoPXDCreator ( )

virtual

The destructor of the GeoPXDCreator class.

Definition at line 50 of file GeoPXDCreator.cc.

    {
      for (SensorInfo* sensorInfo : m_SensorInfo) delete sensorInfo;
      m_SensorInfo.clear();
    }

Member Function Documentation

◆ create()

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

inlineoverridevirtual

The old create member: create the configuration object(s) on the fly and call the geometry creation routine.

Implements CreatorBase.

Definition at line 43 of file GeoPXDCreator.h.

      {
        PXDGeometryPar config = createConfiguration(content);
        createGeometry(config, topVolume, type);
      }

◆ createConfiguration()

PXDGeometryPar createConfiguration ( const GearDir & param )

private

Create a parameter object from the Gearbox XML parameters.

Definition at line 131 of file GeoPXDCreator.cc.

    {
      // Create an empty payload
      PXDGeometryPar pxdGeometryPar;
 
      //Read prefix ('SVD' or 'PXD')
      pxdGeometryPar.setPrefix(m_prefix);
 
      //Read some global parameters
      VXDGlobalPar globals((float)content.getDouble("ElectronTolerance", 100),
                           (float)content.getDouble("MinimumElectrons", 10),
                           content.getLength("ActiveStepSize", 0.005),
                           content.getBool("ActiveChips", false),
                           content.getBool("SeeNeutrons", false),
                           content.getBool("OnlyPrimaryTrueHits", false),
                           content.getBool("OnlyActiveMaterial", false),
                           (float)content.getLength("DistanceTolerance", 0.005),
                           content.getString("DefaultMaterial", "Air")
                          );
      pxdGeometryPar.setGlobalParams(globals);
 
      //Read envelope parameters
      GearDir envelopeParams(content, "Envelope/");
      VXDEnvelopePar envelope(envelopeParams.getString("Name", ""),
                              envelopeParams.getString("Material", "Air"),
                              envelopeParams.getString("Color", ""),
                              envelopeParams.getAngle("minPhi", 0),
                              envelopeParams.getAngle("maxPhi", 2 * M_PI),
                              (envelopeParams.getNodes("InnerPoints/point").size() > 0)
                             );
 
      for (const GearDir& point : envelopeParams.getNodes("InnerPoints/point")) {
        pair<double, double> ZXPoint(point.getLength("z"), point.getLength("x"));
        envelope.getInnerPoints().push_back(ZXPoint);
      }
      for (const GearDir& point : envelopeParams.getNodes("OuterPoints/point")) {
        pair<double, double> ZXPoint(point.getLength("z"), point.getLength("x"));
        envelope.getOuterPoints().push_back(ZXPoint);
      }
      pxdGeometryPar.setEnvelope(envelope);
 
      // Read alignment for detector m_prefix ('PXD' or 'SVD')
      string pathAlign = (boost::format("Align[@component='%1%']/") % m_prefix).str();
      GearDir paramsAlign(GearDir(content, "Alignment/"), pathAlign);
      if (!paramsAlign) {
        B2WARNING("Could not find alignment parameters for component " << m_prefix);
        return pxdGeometryPar;
      }
      pxdGeometryPar.getAlignmentMap()[m_prefix] = VXDAlignmentPar(paramsAlign.getLength("du"),
                                                   paramsAlign.getLength("dv"),
                                                   paramsAlign.getLength("dw"),
                                                   paramsAlign.getAngle("alpha"),
                                                   paramsAlign.getAngle("beta"),
                                                   paramsAlign.getAngle("gamma")
                                                                  );
 
      //Read the definition of all sensor types
      GearDir components(content, "Components/");
      for (const GearDir& paramsSensor : components.getNodes("Sensor")) {
        string sensorTypeID = paramsSensor.getString("@type");
 
        VXDGeoSensorPar sensor(paramsSensor.getString("Material"),
                               paramsSensor.getString("Color", ""),
                               paramsSensor.getLength("width"),
                               paramsSensor.getLength("width2", 0),
                               paramsSensor.getLength("length"),
                               paramsSensor.getLength("height"),
                               paramsSensor.getAngle("angle", 0),
                               paramsSensor.getBool("@slanted", false)
                              );
        sensor.setActive(VXDGeoComponentPar(
                           paramsSensor.getString("Material"),
                           paramsSensor.getString("Active/Color", "#f00"),
                           paramsSensor.getLength("Active/width"),
                           paramsSensor.getLength("Active/width2", 0),
                           paramsSensor.getLength("Active/length"),
                           paramsSensor.getLength("Active/height")
                         ), VXDGeoPlacementPar(
                           "Active",
                           paramsSensor.getLength("Active/u"),
                           paramsSensor.getLength("Active/v"),
                           paramsSensor.getString("Active/w", "center"),
                           paramsSensor.getLength("Active/woffset", 0)
                         ));
 
        PXDSensorInfoPar* pxdInfo = readSensorInfo(GearDir(paramsSensor, "Active"));
        sensor.setSensorInfo(pxdInfo);
        sensor.setComponents(getSubComponents(paramsSensor));
        pxdGeometryPar.getSensorMap()[sensorTypeID] = sensor;
        pxdGeometryPar.getSensorInfos().push_back(pxdInfo);
      }
 
      //Build all ladders including Sensors
      GearDir support(content, "Support/");
      readHalfShellSupport(support, pxdGeometryPar);
 
      for (const GearDir& shell : content.getNodes("HalfShell")) {
 
        string shellName = m_prefix + "." + shell.getString("@name");
        string pathShell = (boost::format("Align[@component='%1%']/") % shellName).str();
        GearDir paramsShell(GearDir(content, "Alignment/"), pathShell);
        if (!paramsShell) {
          B2WARNING("Could not find alignment parameters for component " << shellName);
          return pxdGeometryPar;
        }
        pxdGeometryPar.getAlignmentMap()[shellName] = VXDAlignmentPar(paramsShell.getLength("du"),
                                                      paramsShell.getLength("dv"),
                                                      paramsShell.getLength("dw"),
                                                      paramsShell.getAngle("alpha"),
                                                      paramsShell.getAngle("beta"),
                                                      paramsShell.getAngle("gamma")
                                                                     );
 
        VXDHalfShellPar halfShell(shell.getString("@name"), shell.getAngle("shellAngle", 0));
 
        for (const GearDir& layer : shell.getNodes("Layer")) {
          int layerID = layer.getInt("@id");
 
          readLadder(layerID, components, pxdGeometryPar);
 
          //Loop over defined ladders
          for (const GearDir& ladder : layer.getNodes("Ladder")) {
            int ladderID = ladder.getInt("@id");
            double phi = ladder.getAngle("phi", 0);
            readLadderComponents(layerID, ladderID, content, pxdGeometryPar);
            halfShell.addLadder(layerID, ladderID,  phi);
          }
        }
        pxdGeometryPar.getHalfShells().push_back(halfShell);
      }
 
      //Create diamond radiation sensors if defined and in background mode
      GearDir radiationDir(content, "RadiationSensors");
      if (pxdGeometryPar.getGlobalParams().getActiveChips() &&  radiationDir) {
        VXDGeoRadiationSensorsPar radiationSensors(
          m_prefix,
          radiationDir.getBool("insideEnvelope"),
          radiationDir.getLength("width"),
          radiationDir.getLength("length"),
          radiationDir.getLength("height"),
          radiationDir.getString("material")
        );
 
        //Add radiation sensor positions
        for (GearDir& position : radiationDir.getNodes("position")) {
          VXDGeoRadiationSensorsPositionPar diamonds(position.getLength("z"),
                                                     position.getLength("radius"),
                                                     position.getAngle("theta")
                                                    );
 
          //Loop over all phi positions
          for (GearDir& sensor : position.getNodes("phi")) {
            //Add sensor with angle and id
            diamonds.addSensor(sensor.getInt("@id"), sensor.getAngle());
          }
          radiationSensors.addPosition(diamonds);
        }
        pxdGeometryPar.setRadiationSensors(radiationSensors);
      }
 
      return pxdGeometryPar;
    }

◆ createDiamonds()

void createDiamonds	(	const VXDGeoRadiationSensorsPar &	params,
		G4LogicalVolume &	topVolume,
		G4LogicalVolume &	envelopeVolume )

inherited

Create diamond radiation sensors.

Definition at line 210 of file GeoVXDCreator.cc.

    {
      //Set the correct top volume to either global top or detector envelope
      G4LogicalVolume* top = &topVolume;
      if (params.getInsideEnvelope()) {
        top = &envelopeVolume;
      }
 
      //shape and material are the same for all sensors so create them now
      const double width = params.getWidth();
      const double length = params.getLength();
      const double height = params.getHeight();
      G4Box* shape = 0;
      G4Material* material = geometry::Materials::get(params.getMaterial());
 
      //Now loop over all positions
      const std::vector<VXDGeoRadiationSensorsPositionPar>& Positions = params.getPositions();
      for (const VXDGeoRadiationSensorsPositionPar& position : Positions) {
        //get the radial and z position
        const double r = position.getRadius();
        const double z = position.getZ();
        const double theta = position.getTheta();
        //and loop over all phi positions
        const std::map<int, double>& Sensors = position.getSensors();
        for (const std::pair<const int, double>& sensor : Sensors) {
          //for (GearDir& sensor : position.getNodes("phi")) {
          //we need angle and Id
          const double phi = sensor.second;
          const int id = sensor.first;
          //then we create a nice name
          const std::string name = params.getSubDetector() + ".DiamondSensor." + std::to_string(id);
          //and create the sensor volume
          if (not shape) shape = new G4Box("radiationSensorDiamond", width / 2 * CLHEP::cm, length / 2 * CLHEP::cm, height / 2 * CLHEP::cm);
          G4LogicalVolume* volume = new G4LogicalVolume(shape, material, name);
          //add a sensitive detector implementation
          BkgSensitiveDetector* sensitive = new BkgSensitiveDetector(params.getSubDetector().c_str(), id);
          volume->SetSensitiveDetector(sensitive);
          //and place it at the correct position
          G4Transform3D transform = G4RotateZ3D(phi - M_PI / 2) * G4Translate3D(0, r * CLHEP::cm,
                                    z * CLHEP::cm) * G4RotateX3D(-M_PI / 2 - theta);
          new G4PVPlacement(transform, volume, name, top, false, 1);
        }
      }
    }

◆ createFromDB()

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

inlineoverridevirtual

Create the geometry from the Database.

Reimplemented from CreatorBase.

Definition at line 60 of file GeoPXDCreator.h.

      {
        DBObjPtr<PXDGeometryPar> dbObj;
        if (!dbObj) {
          // Check that we found the object and if not report the problem
          B2FATAL("No configuration for " << name << " found.");
        }
        createGeometry(*dbObj, topVolume, type);
      }

◆ createGeometry()

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

private

Create the geometry from a parameter object.

Definition at line 343 of file GeoPXDCreator.cc.

    {
 
      m_activeStepSize = parameters.getGlobalParams().getActiveStepSize() / Unit::mm;
      m_activeChips = parameters.getGlobalParams().getActiveChips();
      m_seeNeutrons = parameters.getGlobalParams().getSeeNeutrons();
      m_onlyPrimaryTrueHits = parameters.getGlobalParams().getOnlyPrimaryTrueHits();
      m_distanceTolerance = parameters.getGlobalParams().getDistanceTolerance();
      m_electronTolerance = parameters.getGlobalParams().getElectronTolerance();
      m_minimumElectrons = parameters.getGlobalParams().getMinimumElectrons();
      m_onlyActiveMaterial = parameters.getGlobalParams().getOnlyActiveMaterial();
      m_defaultMaterial = parameters.getGlobalParams().getDefaultMaterial();
 
      G4Material* material = Materials::get(m_defaultMaterial);
      if (!material) B2FATAL("Default Material of VXD, '" << m_defaultMaterial << "', could not be found");
 
 
      //Build envelope
      G4LogicalVolume* envelope(0);
      G4VPhysicalVolume* physEnvelope{nullptr};
      if (!parameters.getEnvelope().getExists()) {
        B2INFO("Could not find definition for " + m_prefix + " Envelope, placing directly in top volume");
        envelope = &topVolume;
      } else {
        double minZ(0), maxZ(0);
        G4Polycone* envelopeCone = geometry::createRotationSolid("Envelope",
                                                                 parameters.getEnvelope().getInnerPoints(),
                                                                 parameters.getEnvelope().getOuterPoints(),
                                                                 parameters.getEnvelope().getMinPhi(),
                                                                 parameters.getEnvelope().getMaxPhi(),
                                                                 minZ, maxZ
                                                                );
        envelope = new G4LogicalVolume(envelopeCone, material, m_prefix + ".Envelope");
        setVisibility(*envelope, false);
        physEnvelope = new G4PVPlacement(getAlignment(parameters.getAlignment(m_prefix)), envelope, m_prefix + ".Envelope",
                                         &topVolume, false, 1);
 
        // Set up region for production cuts
        G4Region* aRegion = new G4Region("PXDEnvelope");
        envelope->SetRegion(aRegion);
        aRegion->AddRootLogicalVolume(envelope);
      }
 
      //Read the definition of all sensor types
      for (const pair<const string, VXDGeoSensorPar>& typeAndSensor : parameters.getSensorMap()) {
        const string& sensorTypeID = typeAndSensor.first;
        const VXDGeoSensorPar& paramsSensor = typeAndSensor.second;
        VXDGeoSensor sensor(
          paramsSensor.getMaterial(),
          paramsSensor.getColor(),
          paramsSensor.getWidth() / Unit::mm,
          paramsSensor.getWidth2() / Unit::mm,
          paramsSensor.getLength() / Unit::mm,
          paramsSensor.getHeight() / Unit::mm,
          paramsSensor.getSlanted()
        );
        sensor.setActive(VXDGeoComponent(
                           paramsSensor.getMaterial(),
                           paramsSensor.getActiveArea().getColor(),
                           paramsSensor.getActiveArea().getWidth() / Unit::mm,
                           paramsSensor.getActiveArea().getWidth2() / Unit::mm,
                           paramsSensor.getActiveArea().getLength() / Unit::mm,
                           paramsSensor.getActiveArea().getHeight() / Unit::mm
                         ), VXDGeoPlacement(
                           "Active",
                           paramsSensor.getActivePlacement().getU() / Unit::mm,
                           paramsSensor.getActivePlacement().getV() / Unit::mm,
                           paramsSensor.getActivePlacement().getW(),
                           paramsSensor.getActivePlacement().getWOffset() / Unit::mm
                         ));
        sensor.setSensorInfo(createSensorInfo(paramsSensor));
 
        vector<VXDGeoPlacement> subcomponents;
        const auto& components = paramsSensor.getComponents();
        subcomponents.reserve(components.size());
        std::transform(components.begin(), components.end(), std::back_inserter(subcomponents),
        [](auto const & component) {
          return VXDGeoPlacement(component.getName(),
                                 component.getU() / Unit::mm,
                                 component.getV() / Unit::mm,
                                 component.getW(),
                                 component.getWOffset() / Unit::mm
                                );
        });
        sensor.setComponents(subcomponents);
        m_sensorMap[sensorTypeID] = sensor;
      }
 
      //Read the component cache from DB
      for (const string& name : parameters.getComponentInsertOder()) {
        if (m_componentCache.find(name) != m_componentCache.end()) {
          // already created due to being a sub component of a previous
          // component. Seems fishy since the information of this component
          // is in the db at least twice so we could run into
          // inconsistencies.
          B2WARNING("Component " << name << " already created from previous subcomponents, should not be here");
          continue;
        }
        const VXDGeoComponentPar& paramsComponent = parameters.getComponent(name);
        VXDGeoComponent  c(
          paramsComponent.getMaterial(),
          paramsComponent.getColor(),
          paramsComponent.getWidth() / Unit::mm,
          paramsComponent.getWidth2() / Unit::mm,
          paramsComponent.getLength() / Unit::mm,
          paramsComponent.getHeight() / Unit::mm
        );
        double angle  = paramsComponent.getAngle();
 
 
        if (c.getWidth() <= 0 || c.getLength() <= 0 || c.getHeight() <= 0) {
          B2DEBUG(100, "One dimension empty, using auto resize for component");
        } else {
          G4VSolid* solid = createTrapezoidal(m_prefix + "." + name, c.getWidth(), c.getWidth2(), c.getLength(), c.getHeight(), angle);
          c.setVolume(new G4LogicalVolume(solid, Materials::get(c.getMaterial()), m_prefix + "." + name));
        }
 
        vector<VXDGeoPlacement> subComponents;
        const auto& paramsSubComponents = paramsComponent.getSubComponents();
        subComponents.reserve(paramsSubComponents.size());
        std::transform(paramsSubComponents.begin(), paramsSubComponents.end(), std::back_inserter(subComponents),
        [](auto const & paramsSubComponent) {
          return VXDGeoPlacement(paramsSubComponent.getName(),
                                 paramsSubComponent.getU() / Unit::mm,
                                 paramsSubComponent.getV() / Unit::mm,
                                 paramsSubComponent.getW(),
                                 paramsSubComponent.getWOffset() / Unit::mm
                                );
        });
        createSubComponents(m_prefix + "." + name, c, subComponents);
        if (m_activeChips &&  parameters.getSensitiveChipID(name) >= 0) {
          int chipID = parameters.getSensitiveChipID(name);
          B2DEBUG(50, "Creating BkgSensitiveDetector for component " << name << " with chipID " <<  chipID);
          BkgSensitiveDetector* sensitive = new BkgSensitiveDetector(m_prefix.c_str(), chipID);
          c.getVolume()->SetSensitiveDetector(sensitive);
          m_sensitive.push_back(sensitive);
        }
 
        m_componentCache[name] = c;
      }
 
      //Build all ladders including Sensors
      VXD::GeoVXDAssembly shellSupport = createHalfShellSupport(parameters);
 
      //const std::vector<VXDHalfShellPar>& HalfShells = parameters.getHalfShells();
      for (const VXDHalfShellPar& shell : parameters.getHalfShells()) {
        string shellName =  shell.getName();
        m_currentHalfShell = m_prefix + "." + shellName;
        G4Transform3D shellAlignment = getAlignment(parameters.getAlignment(m_currentHalfShell));
 
        // Remember shell coordinate system (into which ladders are inserted)
        VXD::GeoCache::getInstance().addHalfShellPlacement(m_halfShellVxdIDs[m_currentHalfShell], shellAlignment);
 
        //Place shell support
        double shellAngle = shell.getShellAngle(); // Only used to move support, not active volumes!
        if (!m_onlyActiveMaterial) shellSupport.place(envelope, shellAlignment * G4RotateZ3D(shellAngle));
 
        //const std::map< int, std::vector<std::pair<int, double>> >& Layers = shell.getLayers();
        for (const std::pair<const int, std::vector<std::pair<int, double>> >& layer : shell.getLayers()) {
          int layerID = layer.first;
          const std::vector<std::pair<int, double>>& Ladders = layer.second;
 
 
          setCurrentLayer(layerID, parameters);
 
          //Place Layer support
          VXD::GeoVXDAssembly layerSupport = createLayerSupport();
          if (!m_onlyActiveMaterial) layerSupport.place(envelope, shellAlignment * G4RotateZ3D(shellAngle));
          VXD::GeoVXDAssembly ladderSupport = createLadderSupport();
 
          //Loop over defined ladders
          for (const std::pair<int, double>& ladder : Ladders) {
            int ladderID = ladder.first;
            double phi = ladder.second;
 
            G4Transform3D ladderPlacement = placeLadder(ladderID, phi, envelope, shellAlignment, parameters);
            if (!m_onlyActiveMaterial) ladderSupport.place(envelope, ladderPlacement);
          }
 
        }
      }
 
      //Now build cache with all transformations
      if (physEnvelope) {
        VXD::GeoCache::getInstance().findVolumes(physEnvelope);
      } else {
        //create a temporary placement of the top volume.
        G4PVPlacement topPlacement(nullptr, G4ThreeVector(0, 0, 0), &topVolume,
                                   "temp_Top", nullptr, false, 1, false);
        //and search for all VXD sensitive sensors within
        VXD::GeoCache::getInstance().findVolumes(&topPlacement);
      }
 
      //Create diamond radiation sensors if defined and in background mode
      if (m_activeChips) {
        if (parameters.getRadiationSensors().getSubDetector() == "") {
          B2DEBUG(10, "Apparently no radiation sensors defined, skipping");
        } else {
          createDiamonds(parameters.getRadiationSensors(), topVolume, *envelope);
        }
      }
    }

◆ 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 560 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.

Definition at line 558 of file GeoPXDCreator.cc.

558{ return VXD::GeoVXDAssembly(); }

◆ createLayerSupport()

VXD::GeoVXDAssembly createLayerSupport ( )

virtual

Create support structure for a PXD Layer.

Definition at line 556 of file GeoPXDCreator.cc.

556{ return VXD::GeoVXDAssembly(); }

◆ 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 546 of file GeoPXDCreator.cc.

    {
      SensorInfo* sensorInfo = new SensorInfo(dynamic_cast<const SensorInfo&>(*sensor.getSensorInfo()));
      sensorInfo->setID(sensorID);
      if (placement.getFlipV()) sensorInfo->flipVSegmentation();
      SensitiveDetector* sensitive = new SensitiveDetector(sensorInfo);
      return sensitive;
    }

◆ 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 56 of file GeoPXDCreator.cc.

    {
 
      const PXDSensorInfoPar& infoPar = dynamic_cast<const PXDSensorInfoPar&>(*sensor.getSensorInfo());
 
      SensorInfo* info = new SensorInfo(
        VxdID(0, 0, 0),
        infoPar.getWidth(),
        infoPar.getLength(),
        infoPar.getThickness(),
        infoPar.getUCells(),
        infoPar.getVCells1(),
        infoPar.getSplitLength(),
        infoPar.getVCells2()
      );
      info->setDEPFETParams(
        infoPar.getBulkDoping() / (Unit::um * Unit::um * Unit::um),
        infoPar.getBackVoltage(),
        infoPar.getTopVoltage(),
        infoPar.getSourceBorderSmallPitch(),
        infoPar.getClearBorderSmallPitch(),
        infoPar.getDrainBorderSmallPitch(),
        infoPar.getSourceBorderLargePitch(),
        infoPar.getClearBorderLargePitch(),
        infoPar.getDrainBorderLargePitch(),
        infoPar.getGateDepth(),
        infoPar.getDoublePixel(),
        infoPar.getChargeThreshold(),
        infoPar.getNoiseFraction()
      );
      info->setIntegrationWindow(
        infoPar.getIntegrationStart(),
        infoPar.getIntegrationEnd()
      );
 
      m_SensorInfo.push_back(info);
      return info;
    }

◆ 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 75 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 component 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
[height]	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 256 of file GeoVXDCreator.cc.

    {
      double offset(0);
      if (angle > 0) {
        const double tana = tan(angle);
        height = min(tana * length, min(tana * width, height));
        offset = height / tana;
      }
      const double hwidth  = width / 2.0;
      const double hwidth2 = width2 / 2.0;
      const double hlength = length / 2.0;
      const double hheight = height / 2.0;
 
      if (width2 <= 0 || width == width2) {
        if (angle <= 0) {
          return new G4Box(name, hwidth, hlength, hheight);
        } else {
          return new G4Trd(name, hwidth, hwidth - offset, hlength, hlength - offset, hheight);
        }
      }
      //FIXME: offset not working, g4 complains about nonplanarity of face -X. But we do not need that shape at the moment
      //so lets ignore it for now
      return  new G4Trap(name, hheight, 0, 0, hlength, hwidth, hwidth2, 0, hlength - offset, hwidth - offset, hwidth2 - offset, 0);
    }

◆ getAlignment()

G4Transform3D getAlignment ( const VXDAlignmentPar & params )

inherited

Get Alignment from paylead object.

Parameters

params Payload object

Returns: Transformation matrix for component

Definition at line 173 of file GeoVXDCreator.cc.

    {
      G4RotationMatrix rotation(params.getAlpha(), params.getBeta(), params.getGamma());
      G4ThreeVector translation(params.getDU() / Unit::mm, params.getDV() / Unit::mm, params.getDW() / Unit::mm);
      return G4Transform3D(rotation, translation);
    }

◆ 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 180 of file GeoVXDCreator.cc.

    {
      double u(placement.getU()), v(placement.getV()), w(0);
      switch (placement.getW()) {
        case VXDGeoPlacement::c_below:  //Place below component
          w = - mother.getHeight() / 2.0 - daughter.getHeight() / 2.0;
          break;
        case VXDGeoPlacement::c_bottom: //Place inside, at bottom of component
          w = - mother.getHeight() / 2.0 + daughter.getHeight() / 2.0;
          break;
        case VXDGeoPlacement::c_center: //Place inside, centered
          w = 0;
          break;
        case VXDGeoPlacement::c_top:    //Place inside, at top of mother
          w = mother.getHeight() / 2.0 - daughter.getHeight() / 2.0;
          break;
        case VXDGeoPlacement::c_above:  //Place above mother
          w = mother.getHeight() / 2.0 + daughter.getHeight() / 2.0;
          break;
      }
      if (!originCenter) { //Sensor has coordinate origin in the corner, all submothers at their center
        u -= mother.getWidth() / 2.0;
        v -= mother.getLength() / 2.0;
      }
      return G4Translate3D(u, v, w + placement.getWOffset());
    }

◆ getSubComponents()

std::vector< VXDGeoPlacementPar > getSubComponents ( const GearDir & path )

inherited

Return vector of VXDGeoPlacements with all the components defined inside a given path.

Definition at line 607 of file GeoVXDCreator.cc.

    {
      vector<VXDGeoPlacementPar> result;
      for (const GearDir& component : path.getNodes("Component")) {
        string type;
        if (!component.exists("@type")) {
          type = component.getString("@name");
        } else {
          type = component.getString("@type");
        }
        int nPos = max(component.getNumberNodes("u"), component.getNumberNodes("v"));
        nPos = max(nPos, component.getNumberNodes("w"));
        nPos = max(nPos, component.getNumberNodes("woffset"));
        for (int iPos = 1; iPos <= nPos; ++iPos) {
          string index = (boost::format("[%1%]") % iPos).str();
          result.push_back(VXDGeoPlacementPar(
                             type,
                             component.getLength("u" + index, 0),
                             component.getLength("v" + index, 0),
                             component.getString("w" + index, "bottom"),
                             component.getLength("woffset" + index, 0)
                           ));
        }
      }
      return result;
    }

◆ placeLadder()

G4Transform3D placeLadder	(	int	ladderID,
		double	phi,
		G4LogicalVolume *	volume,
		const G4Transform3D &	placement,
		const VXDGeometryPar &	parameters )

inherited

Place ladder corresponding to the given ladder id into volume setLayer has to be called first to set the correct layer id.

Definition at line 282 of file GeoVXDCreator.cc.

    {
      VxdID ladder(m_ladder.getLayerID(), ladderID, 0);
 
      G4Translate3D ladderPos(m_ladder.getRadius(), m_ladder.getShift(), 0);
      G4Transform3D ladderPlacement = placement * G4RotateZ3D(phi) * ladderPos * getAlignment(parameters.getAlignment(ladder));
      // The actual coordinate system of ladder (w still points to Z, there is only phi rotation + move to correct radius + shift)
      VXD::GeoCache::getInstance().addLadderPlacement(m_halfShellVxdIDs[m_currentHalfShell], ladder, ladderPlacement);
 
 
      vector<G4Point3D> lastSensorEdge;
      for (const VXDGeoSensorPlacement& p : m_ladder.getSensors()) {
        VxdID sensorID(ladder);
        sensorID.setSensorNumber(p.getSensorID());
 
 
        std::map<string, VXDGeoSensor>::iterator it = m_sensorMap.find(p.getSensorTypeID());
        if (it == m_sensorMap.end()) {
          B2FATAL("Invalid SensorTypeID " << p.getSensorTypeID() << ", please check the definition of " << sensorID);
        }
        VXDGeoSensor& s = it->second;
        string name = m_prefix + "." + (string)sensorID;
 
        //Calculate the reflection transformation needed. Since we want the
        //active area to be non reflected we apply this transformation on the
        //sensor and on the active area
        G4Transform3D reflection;
        if (p.getFlipU()) reflection = reflection * G4ReflectX3D();
        if (p.getFlipV()) reflection = reflection * G4ReflectY3D();
        if (p.getFlipW()) reflection = reflection * G4ReflectZ3D();
 
        G4VSolid* sensorShape = createTrapezoidal(name, s.getWidth(), s.getWidth2(), s.getLength(),
                                                  s.getHeight());
        G4Material* sensorMaterial = Materials::get(s.getMaterial());
        if (m_onlyActiveMaterial) {
          s.setVolume(new G4LogicalVolume(sensorShape, Materials::get(m_defaultMaterial), name));
        } else {
          s.setVolume(new G4LogicalVolume(sensorShape, sensorMaterial, name));
        }
 
        // Create sensitive Area: this Part is created separately since we want full control over the coordinate system:
        // local x (called u) should point in RPhi direction
        // local y (called v) should point in global z
        // local z (called w) should away from the origin
        G4VSolid* activeShape = createTrapezoidal(name + ".Active", s.getActiveArea().getWidth(), s.getActiveArea().getWidth2(),
                                                  s.getActiveArea().getLength(), s.getActiveArea().getHeight());
 
        //Create appropriate sensitive detector instance
        SensitiveDetectorBase* sensitive = createSensitiveDetector(sensorID, s, p);
 
        sensitive->setOptions(m_seeNeutrons, m_onlyPrimaryTrueHits,
                              m_distanceTolerance, m_electronTolerance, m_minimumElectrons);
        m_sensitive.push_back(sensitive);
        G4LogicalVolume* active = new G4LogicalVolume(activeShape,  sensorMaterial, name + ".Active",
                                                      0, sensitive);
        m_UserLimits.push_back(new G4UserLimits(m_activeStepSize));
        active->SetUserLimits(m_UserLimits.back());
 
        setColor(*active, s.getActiveArea().getColor());
 
        //The coordinates of the active region are given as the distance between the corners, not to the center
        //Place the active area
        G4Transform3D activePosition = G4Translate3D(s.getActiveArea().getWidth() / 2.0, s.getActiveArea().getLength() / 2.0, 0) *
                                       getPosition(s, s.getActiveArea(), s.getActivePlacement(), false);
 
        G4ReflectionFactory::Instance()->Place(activePosition * reflection, name + ".Active", active, s.getVolume(),
                                               false, (int)sensorID, false);
 
        //Now create all the other components and place the Sensor
        GeoVXDAssembly assembly;
        if (!m_onlyActiveMaterial) assembly = createSubComponents(name, s, s.getComponents(), false, true);
 
        G4RotationMatrix rotation(0, -M_PI / 2.0, -M_PI / 2.0);
        G4Transform3D sensorAlign = getAlignment(parameters.getAlignment(sensorID));
        G4Transform3D sensorPlacement = G4Rotate3D(rotation) * sensorAlign * reflection;
 
        if (s.getSlanted()) {
          sensorPlacement = G4TranslateX3D(m_ladder.getSlantedRadius() - m_ladder.getRadius()) * G4RotateY3D(
                              -m_ladder.getSlantedAngle()) * sensorPlacement;
        }
        sensorPlacement = G4Translate3D(0.0, 0.0, p.getZ()) * sensorPlacement;
        // Remember the placement of sensor into ladder
        VXD::GeoCache::getInstance().addSensorPlacement(ladder, sensorID, sensorPlacement * activePosition * reflection);
        sensorPlacement = ladderPlacement * sensorPlacement;
 
        assembly.add(s.getVolume());
        assembly.place(volume, sensorPlacement);
 
        //See if we want to glue the modules together
        if (!m_ladder.getGlueMaterial().empty() && !m_onlyActiveMaterial) {
          double u = s.getWidth() / 2.0 + m_ladder.getGlueSize();
          double v = s.getLength() / 2.0;
          double w = s.getHeight() / 2.0 + m_ladder.getGlueSize();
          std::vector<G4Point3D> curSensorEdge(4);
          //Lets get the forward corners of the sensor by applying the unreflected placement matrix
          curSensorEdge[0] = sensorPlacement * reflection * G4Point3D(u, v, + w);
          curSensorEdge[1] = sensorPlacement * reflection * G4Point3D(u, v, - w);
          curSensorEdge[2] = sensorPlacement * reflection * G4Point3D(-u, v, - w);
          curSensorEdge[3] = sensorPlacement * reflection * G4Point3D(-u, v, + w);
          //If we already have backward edges this is not the first module so we can apply the glue
          if (lastSensorEdge.size()) {
            //Check that the modules don't overlap in z
            bool glueOK = true;
            for (int i = 0; i < 4; ++i) glueOK &= curSensorEdge[i].z() <= lastSensorEdge[i].z();
            if (!glueOK) {
              B2WARNING("Cannot place Glue at sensor " + (string)sensorID +
                        " since it overlaps with the last module in z");
            } else {
              //Create Glue which spans from last sensor to this sensor
              G4TessellatedSolid* solidTarget = new G4TessellatedSolid(m_prefix + ".Glue." + (string)sensorID);
 
              //Face at end of last Sensor
              solidTarget->AddFacet(new G4QuadrangularFacet(
                                      curSensorEdge[3], curSensorEdge[2], curSensorEdge[1], curSensorEdge[0], ABSOLUTE));
              //Face at begin of current Sensor
              solidTarget->AddFacet(new G4QuadrangularFacet(
                                      lastSensorEdge[0], lastSensorEdge[1], lastSensorEdge[2], lastSensorEdge[3], ABSOLUTE));
 
              //Top faces
              solidTarget->AddFacet(new G4TriangularFacet(
                                      curSensorEdge[3], curSensorEdge[0], lastSensorEdge[0], ABSOLUTE));
              solidTarget->AddFacet(new G4TriangularFacet(
                                      lastSensorEdge[0], lastSensorEdge[3], curSensorEdge[3], ABSOLUTE));
              //Bottom faces
              solidTarget->AddFacet(new G4TriangularFacet(
                                      curSensorEdge[1], curSensorEdge[2], lastSensorEdge[2], ABSOLUTE));
              solidTarget->AddFacet(new G4TriangularFacet(
                                      lastSensorEdge[2], lastSensorEdge[1], curSensorEdge[1], ABSOLUTE));
              //Right faces
              solidTarget->AddFacet(new G4TriangularFacet(
                                      curSensorEdge[0], curSensorEdge[1], lastSensorEdge[1], ABSOLUTE));
              solidTarget->AddFacet(new G4TriangularFacet(
                                      lastSensorEdge[1], lastSensorEdge[0], curSensorEdge[0], ABSOLUTE));
              //Left faces
              solidTarget->AddFacet(new G4TriangularFacet(
                                      curSensorEdge[2], curSensorEdge[3], lastSensorEdge[3], ABSOLUTE));
              solidTarget->AddFacet(new G4TriangularFacet(
                                      lastSensorEdge[3], lastSensorEdge[2], curSensorEdge[2], ABSOLUTE));
 
              solidTarget->SetSolidClosed(true);
 
              G4LogicalVolume* glue = new G4LogicalVolume(solidTarget,  Materials::get(m_ladder.getGlueMaterial()),
                                                          m_prefix + ".Glue." + (string)sensorID);
              setColor(*glue, "#097");
              new G4PVPlacement(G4Transform3D(), glue, m_prefix + ".Glue." + (string)sensorID, volume, false, 1);
            }
          }
          //Remember the backward edge of this sensor to be glued to.
          lastSensorEdge.resize(4);
          lastSensorEdge[0] = sensorPlacement * reflection * G4Point3D(u, -v, + w);
          lastSensorEdge[1] = sensorPlacement * reflection * G4Point3D(u, -v, - w);
          lastSensorEdge[2] = sensorPlacement * reflection * G4Point3D(-u, -v, - w);
          lastSensorEdge[3] = sensorPlacement * reflection * G4Point3D(-u, -v, + w);
        }
      }
 
      return ladderPlacement;
    }

◆ 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 534 of file GeoVXDCreator.cc.

    {
 
 
      //Check if component already exists
      if (vxdGeometryPar.getComponentMap().find(name) != vxdGeometryPar.getComponentMap().end()) {
        return; // nothing to do
      }
 
      //Component does not exist, so lets create a new one
      string path = (boost::format("descendant::Component[@name='%1%']/") % name).str();
      GearDir params(componentsDir, path);
      if (!params) {
        B2FATAL("Could not find definition for component " << name);
        return;
      }
 
      VXDGeoComponentPar c(
        params.getString("Material",  vxdGeometryPar.getGlobalParams().getDefaultMaterial()),
        params.getString("Color", ""),
        params.getLength("width", 0),
        params.getLength("width2", 0),
        params.getLength("length", 0),
        params.getLength("height", 0),
        params.getAngle("angle", 0)
      );
 
      if (c.getWidth() <= 0 || c.getLength() <= 0 || c.getHeight() <= 0) {
        B2DEBUG(100, "One dimension empty, using auto resize for component");
      }
 
      c.setSubComponents(getSubComponents(params));
      readSubComponents(c.getSubComponents(), componentsDir, vxdGeometryPar);
 
      if (vxdGeometryPar.getGlobalParams().getActiveChips() && params.exists("activeChipID")) {
        int chipID = params.getInt("activeChipID");
        vxdGeometryPar.getSensitiveChipIdMap()[name] = chipID;
      }
      vxdGeometryPar.getComponentMap()[name] = c;
      vxdGeometryPar.getComponentInsertOder().push_back(name);
    }

◆ 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 294 of file GeoPXDCreator.cc.

    {
      for (const GearDir& endflange : support.getNodes("Endflange")) {
        VXDPolyConePar endflangePar(
          endflange.getString("@name"),
          endflange.getString("Material", "Air"),
          endflange.getAngle("minPhi", 0),
          endflange.getAngle("maxPhi", 2 * M_PI),
          (endflange.getNodes("Cutout").size() > 0),
          endflange.getLength("Cutout/width1", 0.),
          endflange.getLength("Cutout/width2", 0.),
          endflange.getLength("Cutout/height", 0.),
          endflange.getLength("Cutout/depth", 0.)
        );
 
        for (const GearDir& plane : endflange.getNodes("Plane")) {
          VXDPolyConePlanePar planePar(
            plane.getLength("posZ"),
            plane.getLength("innerRadius"),
            plane.getLength("outerRadius")
          );
          endflangePar.getPlanes().push_back(planePar);
        }
        pxdGeometryPar.getEndflanges().push_back(endflangePar);
      }
 
      // Cout outs for endflanges
      pxdGeometryPar.setNCutOuts(support.getInt("Cutout/count"));
      pxdGeometryPar.setCutOutWidth(support.getLength("Cutout/width"));
      pxdGeometryPar.setCutOutHeight(support.getLength("Cutout/height"));
      pxdGeometryPar.setCutOutShift(support.getLength("Cutout/shift"));
      pxdGeometryPar.setCutOutRPhi(support.getLength("Cutout/rphi"));
      pxdGeometryPar.setCutOutStartPhi(support.getAngle("Cutout/startPhi"));
      pxdGeometryPar.setCutOutDeltaPhi(support.getAngle("Cutout/deltaPhi"));
 
      //Create Carbon cooling tubes
      pxdGeometryPar.setNTubes(support.getInt("CarbonTubes/count"));
      pxdGeometryPar.setTubesMinZ(support.getLength("CarbonTubes/minZ"));
      pxdGeometryPar.setTubesMaxZ(support.getLength("CarbonTubes/maxZ"));
      pxdGeometryPar.setTubesMinR(support.getLength("CarbonTubes/innerRadius"));
      pxdGeometryPar.setTubesMaxR(support.getLength("CarbonTubes/outerRadius"));
      pxdGeometryPar.setTubesRPhi(support.getLength("CarbonTubes/rphi"));
      pxdGeometryPar.setTubesStartPhi(support.getAngle("CarbonTubes/startPhi"));
      pxdGeometryPar.setTubesDeltaPhi(support.getAngle("CarbonTubes/deltaPhi"));
      pxdGeometryPar.setTubesMaterial(support.getString("CarbonTubes/Material", "Carbon"));
 
      return;
    }

◆ readLadder()

void readLadder	(	int	layer,
		GearDir	components,
		VXDGeometryPar &	geoparameters )

virtualinherited

Read parameters for a ladder in layer with given ID from gearbox and layer store them in payload.

Definition at line 576 of file GeoVXDCreator.cc.

    {
      string path = (boost::format("Ladder[@layer=%1%]/") % layer).str();
      GearDir paramsLadder(components, path);
      if (!paramsLadder) {
        B2FATAL("Could not find Ladder definition for layer " << layer);
      }
 
      geoparameters.getLadderMap()[layer] = VXDGeoLadderPar(
                                              layer,
                                              paramsLadder.getLength("shift"),
                                              paramsLadder.getLength("radius"),
                                              paramsLadder.getAngle("slantedAngle", 0),
                                              paramsLadder.getLength("slantedRadius", 0),
                                              paramsLadder.getLength("Glue/oversize", 0),
                                              paramsLadder.getString("Glue/Material", "")
                                            );
 
      for (const GearDir& sensorInfo : paramsLadder.getNodes("Sensor")) {
 
        geoparameters.getLadderMap()[layer].addSensor(VXDGeoSensorPlacementPar(
                                                        sensorInfo.getInt("@id"),
                                                        sensorInfo.getString("@type"),
                                                        sensorInfo.getLength("."),
                                                        sensorInfo.getBool("@flipU", false),
                                                        sensorInfo.getBool("@flipV", false),
                                                        sensorInfo.getBool("@flipW", false)
                                                      ));
      }
    }

◆ readLadderComponents()

void readLadderComponents	(	int	layerID,
		int	ladderID,
		GearDir	content,
		VXDGeometryPar &	vxdGeometryPar )

virtualinherited

Read parameters for ladder components and their alignment corresponding to the given ladder id.

Definition at line 472 of file GeoVXDCreator.cc.

    {
      VxdID ladder(layerID, ladderID, 0);
 
      // Read alignment for ladder
      string path = (boost::format("Align[@component='%1%']/") % ladder).str();
      GearDir params(GearDir(content, "Alignment/"), path);
      if (!params) {
        B2WARNING("Could not find alignment parameters for ladder " << ladder);
        return;
      }
      vxdGeometryPar.getAlignmentMap()[ladder] = VXDAlignmentPar(params.getLength("du"),
                                                                 params.getLength("dv"),
                                                                 params.getLength("dw"),
                                                                 params.getAngle("alpha"),
                                                                 params.getAngle("beta"),
                                                                 params.getAngle("gamma")
                                                                );
 
 
 
      for (const VXDGeoSensorPlacementPar& p : vxdGeometryPar.getLadderMap()[layerID].getSensors()) {
        VxdID sensorID(ladder);
        sensorID.setSensorNumber(p.getSensorID());
 
        std::map<string, VXDGeoSensorPar>::iterator it = vxdGeometryPar.getSensorMap().find(p.getSensorTypeID());
        if (it == vxdGeometryPar.getSensorMap().end()) {
          B2FATAL("Invalid SensorTypeID " << p.getSensorTypeID() << ", please check the definition of " << sensorID);
        }
 
        //Now create all the other components and place the Sensor
        if (!vxdGeometryPar.getGlobalParams().getOnlyActiveMaterial()) {
          VXDGeoSensorPar& s = it->second;
          readSubComponents(s.getComponents(), GearDir(content, "Components/"), vxdGeometryPar);
        }
        // Read alignment for sensor
        string pathSensor = (boost::format("Align[@component='%1%']/") % sensorID).str();
        GearDir paramsSensor(GearDir(content, "Alignment/"), pathSensor);
        if (!paramsSensor) {
          B2WARNING("Could not find alignment parameters for sensorID " << sensorID);
          return;
        }
        vxdGeometryPar.getAlignmentMap()[sensorID] = VXDAlignmentPar(paramsSensor.getLength("du"),
                                                     paramsSensor.getLength("dv"),
                                                     paramsSensor.getLength("dw"),
                                                     paramsSensor.getAngle("alpha"),
                                                     paramsSensor.getAngle("beta"),
                                                     paramsSensor.getAngle("gamma")
                                                                    );
      }
      return;
    }

◆ 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 95 of file GeoPXDCreator.cc.

    {
      PXDSensorInfoPar* info = new PXDSensorInfoPar(
        VxdID(0, 0, 0),
        sensor.getLength("width"),
        sensor.getLength("length"),
        sensor.getLength("height"),
        sensor.getInt("pixelsU"),
        sensor.getInt("pixelsV[1]"),
        sensor.getLength("splitLength", 0),
        sensor.getInt("pixelsV[2]", 0)
      );
 
      info->setDEPFETParams(
        sensor.getDouble("BulkDoping"),
        sensor.getWithUnit("BackVoltage"),
        sensor.getWithUnit("TopVoltage"),
        sensor.getLength("SourceBorderSmallPixel"),
        sensor.getLength("ClearBorderSmallPixel"),
        sensor.getLength("DrainBorderSmallPixel"),
        sensor.getLength("SourceBorderLargePixel"),
        sensor.getLength("ClearBorderLargePixel"),
        sensor.getLength("DrainBorderLargePixel"),
        sensor.getLength("GateDepth"),
        sensor.getBool("DoublePixel"),
        sensor.getDouble("ChargeThreshold"),
        sensor.getDouble("NoiseFraction")
      );
      info->setIntegrationWindow(
        sensor.getTime("IntegrationStart"),
        sensor.getTime("IntegrationEnd")
      );
      return info;
    }

◆ 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 525 of file GeoVXDCreator.cc.

    {
      for (const VXDGeoPlacementPar& p : placements) {
        readComponent(p.getName(), componentsDir, vxdGeometryPar);
      }
      return;
    }

◆ setCurrentLayer()

void setCurrentLayer	(	int	layer,
		const VXDGeometryPar &	parameters )

virtualinherited

Read parameters for given layer and store in m_ladder.

Definition at line 443 of file GeoVXDCreator.cc.

    {
      const VXDGeoLadderPar& paramsLadder = parameters.getLadder(layer);
 
      m_ladder = VXDGeoLadder(
                   layer,
                   paramsLadder.getShift() / Unit::mm,
                   paramsLadder.getRadius() / Unit::mm,
                   paramsLadder.getSlantedAngle(),
                   paramsLadder.getSlantedRadius() / Unit::mm,
                   paramsLadder.getGlueSize() / Unit::mm,
                   paramsLadder.getGlueMaterial()
                 );
 
 
      for (const VXDGeoSensorPlacementPar& sensorInfo : paramsLadder.getSensors()) {
        m_ladder.addSensor(VXDGeoSensorPlacement(
                             sensorInfo.getSensorID(),
                             sensorInfo.getSensorTypeID(),
                             sensorInfo.getZ() / Unit::mm,
                             sensorInfo.getFlipU(),
                             sensorInfo.getFlipV(),
                             sensorInfo.getFlipW()
                           ));
      }
    }

Member Data Documentation

◆ m_activeChips

bool m_activeChips {false}

protectedinherited

Make also chips sensitive.

Definition at line 211 of file GeoVXDCreator.h.

211{false};

◆ m_activeStepSize

double m_activeStepSize {5 * Unit::um}

protectedinherited

Stepsize to be used inside active volumes.

Definition at line 209 of file GeoVXDCreator.h.

209{5 * Unit::um};

◆ m_alignment

GearDir m_alignment

protectedinherited

GearDir pointing to the alignment parameters.

Definition at line 185 of file GeoVXDCreator.h.

◆ m_componentCache

std::map<std::string, VXDGeoComponent> m_componentCache

protectedinherited

Cache of all previously created components.

Definition at line 190 of file GeoVXDCreator.h.

◆ m_components

GearDir m_components

protectedinherited

GearDir pointing to the toplevel of the components.

Definition at line 187 of file GeoVXDCreator.h.

◆ m_currentHalfShell

std::string m_currentHalfShell {""}

protectedinherited

Current half-shell being processed (need to know ladder parent for hierarchy)

Definition at line 222 of file GeoVXDCreator.h.

222{""};

◆ m_defaultMaterial

std::string m_defaultMaterial

protectedinherited

Name of the Material to be used for Air.

Definition at line 201 of file GeoVXDCreator.h.

◆ m_distanceTolerance

float m_distanceTolerance {(float)(5 * Unit::um)}

protectedinherited

tolerance for Geant4 steps to be merged to a single step

Definition at line 203 of file GeoVXDCreator.h.

203{(float)(5 * Unit::um)};

◆ m_electronTolerance

float m_electronTolerance {100}

protectedinherited

tolerance for the energy deposition in electrons to be merged in a single step

Definition at line 205 of file GeoVXDCreator.h.

205{100};

◆ 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 consistently handle it in hierarchy.

Definition at line 224 of file GeoVXDCreator.h.

                                                       {
        {{"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)}}
      };

◆ m_ladder

VXDGeoLadder m_ladder

protectedinherited

Parameters of the currently active ladder.

Definition at line 194 of file GeoVXDCreator.h.

◆ m_minimumElectrons

float m_minimumElectrons {10}

protectedinherited

minimum number of electrons to be deposited by a particle to be saved

Definition at line 207 of file GeoVXDCreator.h.

207{10};

◆ 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 218 of file GeoVXDCreator.h.

218{false};

◆ m_onlyPrimaryTrueHits

bool m_onlyPrimaryTrueHits {false}

protectedinherited

If true only create TrueHits from primary particles and ignore secondaries.

Definition at line 215 of file GeoVXDCreator.h.

215{false};

◆ m_prefix

std::string m_prefix

protectedinherited

Prefix to prepend to all volume names.

Definition at line 183 of file GeoVXDCreator.h.

◆ m_radiationsensors

GeoVXDRadiationSensors m_radiationsensors

protectedinherited

Diamond radiation sensor "sub creator".

Definition at line 198 of file GeoVXDCreator.h.

◆ m_seeNeutrons

bool m_seeNeutrons {false}

protectedinherited

Make sensitive detectors also see neutrons.

Definition at line 213 of file GeoVXDCreator.h.

213{false};

◆ m_sensitive

std::vector<Simulation::SensitiveDetectorBase*> m_sensitive

protectedinherited

List to all created sensitive detector instances.

Definition at line 196 of file GeoVXDCreator.h.

◆ m_SensorInfo

std::vector<SensorInfo*> m_SensorInfo

private

Vector of points to SensorInfo objects.

Definition at line 119 of file GeoPXDCreator.h.

◆ m_sensorMap

std::map<std::string, VXDGeoSensor> m_sensorMap

protectedinherited

Map containing Information about all defined sensor types.

Definition at line 192 of file GeoVXDCreator.h.

◆ m_UserLimits

std::vector<G4UserLimits*> m_UserLimits

protectedinherited

Vector of G4UserLimit pointers.

Definition at line 220 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

Public Member Functions

Protected Attributes

Private Member Functions

Private Attributes

Detailed Description

Constructor & Destructor Documentation

◆ GeoPXDCreator()

◆ ~GeoPXDCreator()

Member Function Documentation

◆ create()

◆ createConfiguration()

◆ createDiamonds()

◆ createFromDB()

◆ createGeometry()

◆ createHalfShellSupport()

◆ createLadderSupport()

◆ createLayerSupport()

◆ createPayloads()

◆ createSensitiveDetector()

◆ createSensorInfo()

◆ createSubComponents()

◆ createTrapezoidal()

◆ getAlignment()

◆ getPosition()

◆ getSubComponents()

◆ placeLadder()

◆ readComponent()

◆ readHalfShellSupport()

◆ readLadder()

◆ readLadderComponents()

◆ readSensorInfo()

◆ readSubComponents()

◆ setCurrentLayer()

Member Data Documentation

◆ m_activeChips

◆ m_activeStepSize

◆ m_alignment

◆ m_componentCache

◆ m_components

◆ m_currentHalfShell

◆ m_defaultMaterial

◆ m_distanceTolerance

◆ m_electronTolerance

◆ m_halfShellVxdIDs

◆ m_ladder

◆ m_minimumElectrons

◆ m_onlyActiveMaterial

◆ m_onlyPrimaryTrueHits

◆ m_prefix

◆ m_radiationsensors

◆ m_seeNeutrons

◆ m_sensitive

◆ m_SensorInfo

◆ m_sensorMap

◆ m_UserLimits