GeoSVDCreator Class Reference

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

#include <GeoSVDCreator.h>

Inheritance diagram for GeoSVDCreator:

Public Member Functions
	GeoSVDCreator ()
	Constructor of the GeoSVDCreator class.
virtual	~GeoSVDCreator ()
	The destructor of the GeoSVDCreator 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 (int, const SVDGeometryPar &parameters)
	Create support structure for a SVD Layer.
virtual VXD::GeoVXDAssembly	createLadderSupport (int, const SVDGeometryPar &parameters)
	Create support structure for a SVD Ladder.
virtual VXD::GeoVXDAssembly	createHalfShellSupport (const SVDGeometryPar &parameters)
	Create support structure for SVD 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.
SVDSensorInfoPar *	readSensorInfo (const GearDir &sensor)
	Read the sensor definitions from 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, SVDGeometryPar &svdGeometryPar)
	Create support structure for SVD Half Shell, that means everything that does not depend on layer or sensor alignment.
void	readLayerSupport (int layer, const GearDir &support, SVDGeometryPar &svdGeometryPar)
	Create support structure for a SVD Layer.
void	readLadderSupport (int layer, const GearDir &support, SVDGeometryPar &svdGeometryPar)
	Create support structure for a SVD Ladder.
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 consitently handle it in hierarchy.

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

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

Detailed Description

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

Definition at line 28 of file GeoSVDCreator.h.

Constructor & Destructor Documentation

GeoSVDCreator()

GeoSVDCreator ( )

inline

Constructor of the GeoSVDCreator class.

Definition at line 37 of file GeoSVDCreator.h.

: VXD::GeoVXDCreator("SVD") {};

~GeoSVDCreator()

~GeoSVDCreator ( )

virtual

The destructor of the GeoSVDCreator class.

Definition at line 53 of file GeoSVDCreator.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 44 of file GeoSVDCreator.h.

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

createConfiguration()

SVDGeometryPar createConfiguration ( const GearDir &  param )

private

Create a parameter object from the Gearbox XML parameters.

Definition at line 145 of file GeoSVDCreator.cc.

    {
      SVDGeometryPar svdGeometryPar;
 
      //Read prefix ('SVD' or 'PXD')
      svdGeometryPar.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")
                          );
      svdGeometryPar.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);
      }
      svdGeometryPar.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 svdGeometryPar;
      }
      svdGeometryPar.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)
                         ));
 
        SVDSensorInfoPar* svdInfo = readSensorInfo(GearDir(paramsSensor, "Active"));
        sensor.setSensorInfo(svdInfo);
        sensor.setComponents(getSubComponents(paramsSensor));
        svdGeometryPar.getSensorMap()[sensorTypeID] = sensor;
        svdGeometryPar.getSensorInfos().push_back(svdInfo);
      }
 
      //Build all ladders including Sensors
      GearDir support(content, "Support/");
      readHalfShellSupport(support, svdGeometryPar);
 
      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 svdGeometryPar;
        }
        svdGeometryPar.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, svdGeometryPar);
          readLayerSupport(layerID, support, svdGeometryPar);
          readLadderSupport(layerID, support, svdGeometryPar);
 
          //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, svdGeometryPar);
            halfShell.addLadder(layerID, ladderID,  phi);
          }
        }
        svdGeometryPar.getHalfShells().push_back(halfShell);
      }
 
      //Create diamond radiation sensors if defined and in background mode
      GearDir radiationDir(content, "RadiationSensors");
      if (svdGeometryPar.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);
        }
        svdGeometryPar.setRadiationSensors(radiationSensors);
      }
      return svdGeometryPar;
    }

createDiamonds()

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

inherited

Create diamond radiation sensors.

Definition at line 209 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 GeoSVDCreator.h.

      {
        DBObjPtr<SVDGeometryPar> 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 SVDGeometryPar &  parameters, G4LogicalVolume &  topVolume, geometry::GeometryTypes  type  )

private

Create the geometry from a parameter object.

Definition at line 308 of file GeoSVDCreator.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("SVDEnvelope");
        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;
        for (const VXDGeoPlacementPar& component : paramsSensor.getComponents()) {
          subcomponents.push_back(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;
        for (const VXDGeoPlacementPar& paramsSubComponent : paramsComponent.getSubComponents()) {
          subComponents.push_back(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();
        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(layerID, parameters);
          if (!m_onlyActiveMaterial) layerSupport.place(envelope, shellAlignment * G4RotateZ3D(shellAngle));
          VXD::GeoVXDAssembly ladderSupport = createLadderSupport(layerID, parameters);
 
          //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 SVDGeometryPar &  parameters )

virtual

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

Parameters

parameters

Definition at line 635 of file GeoSVDCreator.cc.

    {
      VXD::GeoVXDAssembly supportAssembly;
 
      //Half shell support is easy as we just add all the defined RotationSolids
      double minZ(0), maxZ(0);
 
      const std::vector<VXDRotationSolidPar>& RotationSolids = parameters.getRotationSolids();
 
      for (const VXDRotationSolidPar& component : RotationSolids) {
 
        string name = component.getName();
        string material = component.getMaterial();
 
        G4Polycone* solid = geometry::createRotationSolid(name,
                                                          component.getInnerPoints(),
                                                          component.getOuterPoints(),
                                                          component.getMinPhi(),
                                                          component.getMaxPhi(),
                                                          minZ, maxZ
                                                         );
 
        G4LogicalVolume* volume = new G4LogicalVolume(
          solid, geometry::Materials::get(material), m_prefix + ". " + name);
        geometry::setColor(*volume, component.getColor());
        supportAssembly.add(volume);
      }
      return supportAssembly;
    }

createLadderSupport()

VXD::GeoVXDAssembly createLadderSupport ( int  layer, const SVDGeometryPar &  parameters  )

virtual

Create support structure for a SVD Ladder.

Parameters

layer	Layer ID to create the support
parameters

Definition at line 797 of file GeoSVDCreator.cc.

    {
      VXD::GeoVXDAssembly supportAssembly;
 
      if (!parameters.getSupportRibsExist(layer)) return supportAssembly;
      const SVDSupportRibsPar& support = parameters.getSupportRibs(layer);
 
      // Get the common values for all layers
      double spacing    = support.getSpacing() / Unit::mm / 2.0;
      double height     = support.getHeight() / Unit::mm / 2.0;
      double innerWidth = support.getInnerWidth() / Unit::mm / 2.0;
      double outerWidth = support.getOuterWidth() / Unit::mm / 2.0;
      double tabLength  = support.getTabLength() / Unit::mm / 2.0;
      G4VSolid* inner(0);
      G4VSolid* outer(0);
      G4Transform3D placement;
 
 
      // Now lets create the ribs by adding all boxes to form one union solid
      const std::vector<SVDSupportBoxPar>& Boxes = support.getBoxes();
      for (const SVDSupportBoxPar& box : Boxes) {
        double theta = box.getTheta();
        double zpos = box.getZ() / Unit::mm;
        double rpos = box.getR() / Unit::mm;
        double length = box.getLength() / Unit::mm / 2.0;
        G4Box* innerBox = new G4Box("innerBox", height, innerWidth, length);
        G4Box* outerBox = new G4Box("outerBox", height, outerWidth, length);
        if (!inner) {
          inner = innerBox;
          outer = outerBox;
          placement = G4Translate3D(rpos, 0, zpos) * G4RotateY3D(theta);
        } else {
          G4Transform3D relative = placement.inverse() * G4Translate3D(rpos, 0, zpos) * G4RotateY3D(theta);
          inner = new G4UnionSolid("innerBox", inner, innerBox, relative);
          outer = new G4UnionSolid("outerBox", outer, outerBox, relative);
        }
      }
 
      // Now lets add the tabs
      const std::vector<SVDSupportTabPar>& Tabs = support.getTabs();
      for (const SVDSupportTabPar& tab : Tabs) {
        double theta = tab.getTheta();
        double zpos = tab.getZ() / Unit::mm;
        double rpos = tab.getR() / Unit::mm;
        G4Box* innerBox = new G4Box("innerBox", height, innerWidth, tabLength);
        if (!inner) {
          inner = innerBox;
          placement = G4Translate3D(rpos, 0, zpos) * G4RotateY3D(theta);
        } else {
          G4Transform3D relative = placement.inverse() * G4Translate3D(rpos, 0, zpos) * G4RotateY3D(theta);
          inner = new G4UnionSolid("innerBox", inner, innerBox, relative);
        }
      }
 
      // Now lets create forward and backward endmounts for the ribs
      const std::vector<SVDEndmountPar>& Endmounts = support.getEndmounts();
      for (const SVDEndmountPar& endmount : Endmounts) {
        double endMountHeight = endmount.getHeight() / Unit::mm / 2.0;
        double endMountWidth = endmount.getWidth() / Unit::mm / 2.0;
        double endMountLength = endmount.getLength() / Unit::mm / 2.0;
        double zpos = endmount.getZ() / Unit::mm;
        double rpos = endmount.getR() / Unit::mm;
        G4VSolid* endmountBox = new G4Box("endmountBox", endMountHeight, endMountWidth, endMountLength);
        if (outer) { // holes for the ribs
          endmountBox = new G4SubtractionSolid("endmountBox", endmountBox, outer, G4TranslateY3D(-spacing)*placement * G4Translate3D(-rpos, 0,
                                               -zpos));
          endmountBox = new G4SubtractionSolid("endmountBox", endmountBox, outer, G4TranslateY3D(spacing)*placement * G4Translate3D(-rpos, 0,
                                               -zpos));
        }
        G4LogicalVolume* endmountVolume = new G4LogicalVolume(
          endmountBox, geometry::Materials::get(support.getEndmountMaterial()),
          (boost::format("%1%.Layer%2%.%3%Endmount") % m_prefix % layer % endmount.getName()).str());
        supportAssembly.add(endmountVolume, G4Translate3D(rpos, 0, zpos));
      }
 
      // If there has been at least one Box, create the volumes and add them to the assembly
      if (inner) {
        outer = new G4SubtractionSolid("outerBox", outer, inner);
        G4LogicalVolume* outerVolume = new G4LogicalVolume(
          outer, geometry::Materials::get(support.getOuterMaterial()),
          (boost::format("%1%.Layer%2%.SupportRib") % m_prefix % layer).str());
        G4LogicalVolume* innerVolume = new G4LogicalVolume(
          inner, geometry::Materials::get(support.getInnerMaterial()),
          (boost::format("%1%.Layer%2%.SupportRib.Airex") % m_prefix % layer).str());
        geometry::setColor(*outerVolume, support.getOuterColor());
        geometry::setColor(*innerVolume, support.getInnerColor());
        supportAssembly.add(innerVolume, G4TranslateY3D(-spacing)*placement);
        supportAssembly.add(innerVolume, G4TranslateY3D(spacing)*placement);
        supportAssembly.add(outerVolume, G4TranslateY3D(-spacing)*placement);
        supportAssembly.add(outerVolume, G4TranslateY3D(spacing)*placement);
      }
 
      // Done, return the finished assembly
      return supportAssembly;
    }

createLayerSupport()

VXD::GeoVXDAssembly createLayerSupport ( int  layer, const SVDGeometryPar &  parameters  )

virtual

Create support structure for a SVD Layer.

Parameters

layer	Layer ID to create the support
parameters

Definition at line 667 of file GeoSVDCreator.cc.

    {
      VXD::GeoVXDAssembly supportAssembly;
 
      //Check if there are any endrings defined for this layer. If not we don't create any
      if (parameters.getEndringsExist(layer)) {
        const SVDEndringsPar& support = parameters.getEndrings(layer);
 
        string material      = support.getMaterial();
        double length        = support.getLength() / Unit::mm / 2.0;
        double gapWidth      = support.getGapWidth() / Unit::mm;
        double baseThickness = support.getBaseThickness() / Unit::mm / 2.0;
 
        //Create  the endrings
        const std::vector<SVDEndringsTypePar>& Endrings = support.getTypes();
        for (const SVDEndringsTypePar& endring : Endrings) {
          double z             = endring.getZ() / Unit::mm;
          double baseRadius    = endring.getBaseRadius() / Unit::mm;
          double innerRadius   = endring.getInnerRadius() / Unit::mm;
          double outerRadius   = endring.getOuterRadius() / Unit::mm;
          double horiBarWidth  = endring.getHorizontalBarWidth() / Unit::mm / 2.0;
          double vertBarWidth  = endring.getVerticalBarWidth() / Unit::mm / 2.0;
 
          double angle = asin(gapWidth / innerRadius);
          G4VSolid* endringSolid = new G4Tubs("OuterEndring", innerRadius, outerRadius, length, -M_PI / 2 + angle, M_PI - 2 * angle);
          angle = asin(gapWidth / baseRadius);
          G4VSolid* endringBase  = new G4Tubs("InnerEndring", baseRadius, baseRadius + baseThickness, length, -M_PI / 2 + angle,
                                              M_PI - 2 * angle);
          endringSolid = new G4UnionSolid("Endring", endringSolid, endringBase);
 
          //Now we need the bars which connect the two rings
          double height = (innerRadius - baseRadius) / 2.0;
          double x = vertBarWidth + gapWidth;
          G4Box* verticalBar = new G4Box("VerticalBar", vertBarWidth, height, length);
          G4Box* horizontalBar = new G4Box("HorizontalBar", height, horiBarWidth, length);
          endringSolid = new G4UnionSolid("Endring", endringSolid, verticalBar, G4Translate3D(x,  baseRadius + height, 0));
          endringSolid = new G4UnionSolid("Endring", endringSolid, verticalBar, G4Translate3D(x, -(baseRadius + height), 0));
          endringSolid = new G4UnionSolid("Endring", endringSolid, horizontalBar, G4Translate3D((baseRadius + height), 0, 0));
 
          //Finally create the volume and add it to the assembly at the correct z position
          G4LogicalVolume* endringVolume = new G4LogicalVolume(
            endringSolid, geometry::Materials::get(material),
            (boost::format("%1%.Layer%2%.%3%") % m_prefix % layer % endring.getName()).str());
          supportAssembly.add(endringVolume, G4TranslateZ3D(z));
        }
      }
 
      //Check if there are any coling pipes defined for this layer. If not we don't create any
      if (parameters.getCoolingPipesExist(layer)) {
        const SVDCoolingPipesPar& pipes = parameters.getCoolingPipes(layer);
 
        string material    = pipes.getMaterial();
        double outerRadius = pipes.getOuterDiameter() / Unit::mm / 2.0;
        double innerRadius = outerRadius - pipes.getWallThickness() / Unit::mm;
        int    nPipes      = pipes.getNPipes();
        double startPhi    = pipes.getStartPhi();
        double deltaPhi    = pipes.getDeltaPhi();
        double radius      = pipes.getRadius() / Unit::mm;
        double zstart      = pipes.getZStart() / Unit::mm;
        double zend        = pipes.getZEnd() / Unit::mm;
        double zlength     = (zend - zstart) / 2.0;
 
 
        // There are two parts: the straight pipes and the bendings. So we only need two different volumes
        // which we place multiple times
        G4Tubs* pipeSolid = new G4Tubs("CoolingPipe", innerRadius, outerRadius, zlength, 0, 2 * M_PI);
        G4LogicalVolume* pipeVolume = new G4LogicalVolume(
          pipeSolid, geometry::Materials::get(material),
          (boost::format("%1%.Layer%2%.CoolingPipe") % m_prefix % layer).str());
        geometry::setColor(*pipeVolume, "#ccc");
 
        G4Torus* bendSolid = new G4Torus("CoolingBend", innerRadius, outerRadius, sin(deltaPhi / 2.0)*radius, -M_PI / 2, M_PI);
        G4LogicalVolume* bendVolume = new G4LogicalVolume(
          bendSolid, geometry::Materials::get(material),
          (boost::format("%1%.Layer%2%.CoolingBend") % m_prefix % layer).str());
 
        // Last pipe may be closer, thus we need additional bending
        if (pipes.getDeltaL() > 0) {
          double deltaL = pipes.getDeltaL() / Unit::mm;
          G4Torus* bendSolidLast = new G4Torus("CoolingBendLast", innerRadius, outerRadius, sin(deltaPhi / 2.0) * radius - deltaL / 2.0,
                                               -M_PI / 2, M_PI);
          G4LogicalVolume* bendVolumeLast = new G4LogicalVolume(bendSolidLast, geometry::Materials::get(material),
                                                                (boost::format("%1%.Layer%2%.CoolingBendLast") % m_prefix % layer).str());
          --nPipes;
 
          // Place the last straight pipe
          G4Transform3D placement_pipe = G4RotateZ3D(startPhi + (nPipes - 0.5) * deltaPhi) * G4Translate3D(cos(deltaPhi / 2.0) * radius,
                                         sin(deltaPhi / 2.0) * radius - deltaL, zstart + zlength);
          supportAssembly.add(pipeVolume, placement_pipe);
 
          // Place forward or backward bend
          double zpos = nPipes % 2 > 0 ? zend : zstart;
          // Calculate transformation
          G4Transform3D placement = G4RotateZ3D(startPhi + (nPipes - 0.5) * deltaPhi) * G4Translate3D(cos(deltaPhi / 2.0) * radius,
                                    -deltaL / 2.0, zpos) * G4RotateY3D(M_PI / 2);
          // If we are at the forward side we rotate the bend by 180 degree
          if (nPipes % 2 > 0) {
            placement = placement * G4RotateZ3D(M_PI);
          }
          // And place the bend
          supportAssembly.add(bendVolumeLast, placement);
        }
 
        for (int i = 0; i < nPipes; ++i) {
          // Place the straight pipes
          G4Transform3D placement_pipe = G4RotateZ3D(startPhi + i * deltaPhi) * G4Translate3D(radius, 0, zstart + zlength);
          supportAssembly.add(pipeVolume, placement_pipe);
 
          // This was the easy part, now lets add the connection between the pipes. We only need n-1 bendings
          if (i > 0) {
            // Place forward or backward bend
            double zpos = i % 2 > 0 ? zend : zstart;
            // Calculate transformation
            G4Transform3D placement = G4RotateZ3D(startPhi + (i - 0.5) * deltaPhi) * G4Translate3D(cos(deltaPhi / 2.0) * radius, 0,
                                      zpos) * G4RotateY3D(M_PI / 2);
            // If we are at the forward side we rotate the bend by 180 degree
            if (i % 2 > 0) {
              placement = placement * G4RotateZ3D(M_PI);
            }
            // And place the bend
            supportAssembly.add(bendVolume, placement);
          }
        }
      }
 
      return supportAssembly;
    }

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 52 of file GeoSVDCreator.h.

      {
        DBImportObjPtr<SVDGeometryPar> importObj;
        importObj.construct(createConfiguration(content));
        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 136 of file GeoSVDCreator.cc.

    {
      SensorInfo* sensorInfo = new SensorInfo(dynamic_cast<const SensorInfo&>(*sensor.getSensorInfo()));
      sensorInfo->setID(sensorID);
      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 59 of file GeoSVDCreator.cc.

    {
      const SVDSensorInfoPar& infoPar = dynamic_cast<const SVDSensorInfoPar&>(*sensor.getSensorInfo());
 
      SensorInfo* info = new SensorInfo(
        VxdID(0, 0, 0),
        infoPar.getWidth(),
        infoPar.getLength(),
        infoPar.getThickness(),
        infoPar.getUCells(),
        infoPar.getVCells(),
        infoPar.getWidth2()
      );
      info->setSensorParams(
        infoPar.getStripEdgeU(),
        infoPar.getStripEdgeV(),
        infoPar.getDepletionVoltage(),
        infoPar.getBiasVoltage(),
        infoPar.getBackplaneCapacitanceU(),
        infoPar.getInterstripCapacitanceU(),
        infoPar.getCouplingCapacitanceU(),
        infoPar.getBackplaneCapacitanceV(),
        infoPar.getInterstripCapacitanceV(),
        infoPar.getCouplingCapacitanceV(),
        infoPar.getAduEquivalentU(),
        infoPar.getAduEquivalentV(),
        infoPar.getElectronicNoiseU(),
        infoPar.getElectronicNoiseV(),
        infoPar.getAduEquivalentSbwU(),
        infoPar.getAduEquivalentSbwV(),
        infoPar.getElectronicNoiseSbwU(),
        infoPar.getElectronicNoiseSbwV()
      );
      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 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 255 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 172 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 179 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 606 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 281 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 actuall 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 533 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,
		SVDGeometryPar &	svdGeometryPar
	)

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

Parameters

support	Reference to the database containing the parameters
svdGeometryPar

Definition at line 509 of file GeoSVDCreator.cc.

    {
      if (!support) return;
 
      for (const GearDir& params : support.getNodes("HalfShell/RotationSolid")) {
 
        VXDRotationSolidPar rotationSolidPar(params.getString("Name", ""),
                                             params.getString("Material", "Air"),
                                             params.getString("Color", ""),
                                             params.getAngle("minPhi", 0),
                                             params.getAngle("maxPhi", 2 * M_PI),
                                             (params.getNodes("InnerPoints/point").size() > 0)
                                            );
 
        for (const GearDir& point : params.getNodes("InnerPoints/point")) {
          pair<double, double> ZXPoint(point.getLength("z"), point.getLength("x"));
          rotationSolidPar.getInnerPoints().push_back(ZXPoint);
        }
        for (const GearDir& point : params.getNodes("OuterPoints/point")) {
          pair<double, double> ZXPoint(point.getLength("z"), point.getLength("x"));
          rotationSolidPar.getOuterPoints().push_back(ZXPoint);
        }
        svdGeometryPar.getRotationSolids().push_back(rotationSolidPar);
      }
      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 575 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 471 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;
    }

readLadderSupport()

void readLadderSupport	(	int	layer,
		const GearDir &	support,
		SVDGeometryPar &	svdGeometryPar
	)

Create support structure for a SVD Ladder.

Parameters

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

Definition at line 581 of file GeoSVDCreator.cc.

    {
      if (!support) return;
 
      // Check if there are any support ribs defined for this layer. If not return empty assembly
      GearDir params(support, (boost::format("SupportRibs/Layer[@id='%1%']") % layer).str());
      if (params) {
        svdGeometryPar.getSupportRibs()[layer] = SVDSupportRibsPar(support.getLength("SupportRibs/spacing"),
                                                                   support.getLength("SupportRibs/height"),
                                                                   support.getLength("SupportRibs/inner/width"),
                                                                   support.getLength("SupportRibs/outer/width"),
                                                                   support.getLength("SupportRibs/inner/tabLength"),
                                                                   support.getString("SupportRibs/outer/Material"),
                                                                   support.getString("SupportRibs/inner/Material"),
                                                                   support.getString("SupportRibs/outer/Color"),
                                                                   support.getString("SupportRibs/inner/Color"),
                                                                   support.getString("SupportRibs/endmount/Material")
                                                                  );
 
        // Get values for the layer if available
        if (params.exists("spacing")) svdGeometryPar.getSupportRibs()[layer].setSpacing(params.getLength("spacing"));
        if (params.exists("height")) svdGeometryPar.getSupportRibs()[layer].setHeight(params.getLength("height"));
 
        for (const GearDir& box : params.getNodes("box")) {
          SVDSupportBoxPar boxPar(box.getAngle("theta"),
                                  box.getLength("z"),
                                  box.getLength("r"),
                                  box.getLength("length")
                                 );
          svdGeometryPar.getSupportRibs()[layer].getBoxes().push_back(boxPar);
        }
 
        for (const GearDir& tab : params.getNodes("tab")) {
          SVDSupportTabPar tabPar(tab.getAngle("theta"),
                                  tab.getLength("z"),
                                  tab.getLength("r")
                                 );
          svdGeometryPar.getSupportRibs()[layer].getTabs().push_back(tabPar);
        }
 
        for (const GearDir& endmount : params.getNodes("Endmount")) {
          SVDEndmountPar mountPar(endmount.getString("@name"),
                                  endmount.getLength("height"),
                                  endmount.getLength("width"),
                                  endmount.getLength("length"),
                                  endmount.getLength("z"),
                                  endmount.getLength("r")
                                 );
          svdGeometryPar.getSupportRibs()[layer].getEndmounts().push_back(mountPar);
        }
      }
      return;
    }

readLayerSupport()

void readLayerSupport	(	int	layer,
		const GearDir &	support,
		SVDGeometryPar &	svdGeometryPar
	)

Create support structure for a SVD Layer.

Parameters

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

Definition at line 536 of file GeoSVDCreator.cc.

    {
      if (!support) return;
 
      //Check if there are any endrings defined for this layer. If not we don't create any
      GearDir endrings(support, (boost::format("Endrings/Layer[@id='%1%']") % layer).str());
      if (endrings) {
        svdGeometryPar.getEndrings()[layer] = SVDEndringsPar(support.getString("Endrings/Material"),
                                                             support.getLength("Endrings/length"),
                                                             support.getLength("Endrings/gapWidth"),
                                                             support.getLength("Endrings/baseThickness")
                                                            );
 
        //Create  the endrings
        for (const GearDir& endring : endrings.getNodes("Endring")) {
          SVDEndringsTypePar endringPar(endring.getString("@name"),
                                        endring.getLength("z"),
                                        endring.getLength("baseRadius"),
                                        endring.getLength("innerRadius"),
                                        endring.getLength("outerRadius"),
                                        endring.getLength("horizontalBar"),
                                        endring.getLength("verticalBar")
                                       );
          svdGeometryPar.getEndrings()[layer].getTypes().push_back(endringPar);
        }
      }
 
      // Now let's add the cooling pipes to the Support
      GearDir pipes(support, (boost::format("CoolingPipes/Layer[@id='%1%']") % layer).str());
      if (pipes) {
        svdGeometryPar.getCoolingPipes()[layer] = SVDCoolingPipesPar(support.getString("CoolingPipes/Material"),
                                                  support.getLength("CoolingPipes/outerDiameter"),
                                                  support.getLength("CoolingPipes/wallThickness"),
                                                  pipes.getInt("nPipes"),
                                                  pipes.getAngle("startPhi"),
                                                  pipes.getAngle("deltaPhi"),
                                                  pipes.getLength("radius"),
                                                  pipes.getLength("zstart"),
                                                  pipes.getLength("zend")
                                                                    );
        if (pipes.exists("deltaL")) svdGeometryPar.getCoolingPipes()[layer].setDeltaL(pipes.getLength("deltaL"));
      }
      return;
    }

readSensorInfo()

SVDSensorInfoPar * readSensorInfo

(

const GearDir &

sensor

)

Read the sensor definitions from gearbox.

Parameters

sensor

Reference to the database containing the parameters

Definition at line 96 of file GeoSVDCreator.cc.

    {
 
      const double unit_pFcm = 1;
      // This was 1000 * Unit::fC / Unit::V / Unit::cm; // pF/cm.
      // We only use ratios of capacities, and this gives nicer numbers.
      SVDSensorInfoPar* info = new SVDSensorInfoPar(
        VxdID(0, 0, 0),
        sensor.getLength("width"),
        sensor.getLength("length"),
        sensor.getLength("height"),
        sensor.getInt("stripsU"),
        sensor.getInt("stripsV"),
        sensor.getLength("width2", 0)
      );
 
      info->setSensorParams(
        sensor.getWithUnit("stripEdgeU"),
        sensor.getWithUnit("stripEdgeV"),
        sensor.getWithUnit("DepletionVoltage"),
        sensor.getWithUnit("BiasVoltage"),
        sensor.getDouble("BackplaneCapacitanceU") * unit_pFcm,
        sensor.getDouble("InterstripCapacitanceU") * unit_pFcm,
        sensor.getDouble("CouplingCapacitanceU") * unit_pFcm,
        sensor.getDouble("BackplaneCapacitanceV") * unit_pFcm,
        sensor.getDouble("InterstripCapacitanceV") * unit_pFcm,
        sensor.getDouble("CouplingCapacitanceV") * unit_pFcm,
        sensor.getWithUnit("ADUEquivalentU"),
        sensor.getWithUnit("ADUEquivalentV"),
        sensor.getWithUnit("ElectronicNoiseU"),
        sensor.getWithUnit("ElectronicNoiseV"),
        sensor.getWithUnit("ADUEquivalentSbwU", 0),
        sensor.getWithUnit("ADUEquivalentSbwV", 0),
        sensor.getWithUnit("ElectronicNoiseSbwU", 0),
        sensor.getWithUnit("ElectronicNoiseSbwV", 0)
      );
 
      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 524 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 442 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 209 of file GeoVXDCreator.h.

m_activeStepSize

double m_activeStepSize {5 * Unit::um}

protectedinherited

Stepsize to be used inside active volumes.

Definition at line 207 of file GeoVXDCreator.h.

m_alignment

GearDir m_alignment

protectedinherited

GearDir pointing to the alignment parameters.

Definition at line 183 of file GeoVXDCreator.h.

m_componentCache

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

protectedinherited

Cache of all previously created components.

Definition at line 188 of file GeoVXDCreator.h.

m_components

GearDir m_components

protectedinherited

GearDir pointing to the toplevel of the components.

Definition at line 185 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 220 of file GeoVXDCreator.h.

m_defaultMaterial

std::string m_defaultMaterial

protectedinherited

Name of the Material to be used for Air.

Definition at line 199 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 201 of file GeoVXDCreator.h.

m_electronTolerance

float m_electronTolerance {100}

protectedinherited

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

Definition at line 203 of file GeoVXDCreator.h.

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_ladder

VXDGeoLadder m_ladder

protectedinherited

Parameters of the currently active ladder.

Definition at line 192 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 205 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.

m_onlyPrimaryTrueHits

bool m_onlyPrimaryTrueHits {false}

protectedinherited

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

Definition at line 213 of file GeoVXDCreator.h.

m_prefix

std::string m_prefix

protectedinherited

Prefix to prepend to all volume names.

Definition at line 181 of file GeoVXDCreator.h.

m_radiationsensors

GeoVXDRadiationSensors m_radiationsensors

protectedinherited

Diamond radiation sensor "sub creator".

Definition at line 196 of file GeoVXDCreator.h.

m_seeNeutrons

bool m_seeNeutrons {false}

protectedinherited

Make sensitive detectors also see neutrons.

Definition at line 211 of file GeoVXDCreator.h.

m_sensitive

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

protectedinherited

List to all created sensitive detector instances.

Definition at line 194 of file GeoVXDCreator.h.

m_SensorInfo

std::vector<SensorInfo*> m_SensorInfo

private

Vector of pointers to SensorInfo objects.

Definition at line 139 of file GeoSVDCreator.h.

m_sensorMap

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

protectedinherited

Map containing Information about all defined sensor types.

Definition at line 190 of file GeoVXDCreator.h.

m_UserLimits

std::vector<G4UserLimits*> m_UserLimits

protectedinherited

Vector of G4UserLimit pointers.

Definition at line 218 of file GeoVXDCreator.h.

---

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

• svd/geometry/include/GeoSVDCreator.h
• svd/geometry/src/GeoSVDCreator.cc