Belle II Software development
GeoSVDCreator Class Reference

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

#include <GeoSVDCreator.h>

Inheritance diagram for GeoSVDCreator:
GeoVXDCreator CreatorBase

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::SensorInfoBasecreateSensorInfo (const VXDGeoSensorPar &sensor) override
 Read the sensor definitions from the database.
 
SVDSensorInfoParreadSensorInfo (const GearDir &sensor)
 Read the sensor definitions from gearbox.
 
virtual VXD::SensitiveDetectorBasecreateSensitiveDetector (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< VXDGeoPlacementPargetSubComponents (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, VXDGeoComponentm_componentCache
 Cache of all previously created components.
 
std::map< std::string, VXDGeoSensorm_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::VxdIDm_halfShellVxdIDs
 Used for translation of half-shell name into a VxdID to consistently 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.

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

◆ ~GeoSVDCreator()

~GeoSVDCreator ( )
virtual

The destructor of the GeoSVDCreator class.

Definition at line 52 of file GeoSVDCreator.cc.

53 {
54 for (SensorInfo* sensorInfo : m_SensorInfo) delete sensorInfo;
55 m_SensorInfo.clear();
56 }

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.

45 {
46 SVDGeometryPar config = createConfiguration(content);
47 createGeometry(config, topVolume, type);
48 }

◆ createConfiguration()

SVDGeometryPar createConfiguration ( const GearDir & param)
private

Create a parameter object from the Gearbox XML parameters.

Definition at line 144 of file GeoSVDCreator.cc.

145 {
146 SVDGeometryPar svdGeometryPar;
147
148 //Read prefix ('SVD' or 'PXD')
149 svdGeometryPar.setPrefix(m_prefix);
150
151 //Read some global parameters
152 VXDGlobalPar globals((float)content.getDouble("ElectronTolerance", 100),
153 (float)content.getDouble("MinimumElectrons", 10),
154 content.getLength("ActiveStepSize", 0.005),
155 content.getBool("ActiveChips", false),
156 content.getBool("SeeNeutrons", false),
157 content.getBool("OnlyPrimaryTrueHits", false),
158 content.getBool("OnlyActiveMaterial", false),
159 (float)content.getLength("DistanceTolerance", 0.005),
160 content.getString("DefaultMaterial", "Air")
161 );
162 svdGeometryPar.setGlobalParams(globals);
163
164 //Read envelope parameters
165 GearDir envelopeParams(content, "Envelope/");
166 VXDEnvelopePar envelope(envelopeParams.getString("Name", ""),
167 envelopeParams.getString("Material", "Air"),
168 envelopeParams.getString("Color", ""),
169 envelopeParams.getAngle("minPhi", 0),
170 envelopeParams.getAngle("maxPhi", 2 * M_PI),
171 (envelopeParams.getNodes("InnerPoints/point").size() > 0)
172 );
173
174 for (const GearDir& point : envelopeParams.getNodes("InnerPoints/point")) {
175 pair<double, double> ZXPoint(point.getLength("z"), point.getLength("x"));
176 envelope.getInnerPoints().push_back(ZXPoint);
177 }
178 for (const GearDir& point : envelopeParams.getNodes("OuterPoints/point")) {
179 pair<double, double> ZXPoint(point.getLength("z"), point.getLength("x"));
180 envelope.getOuterPoints().push_back(ZXPoint);
181 }
182 svdGeometryPar.setEnvelope(envelope);
183
184 // Read alignment for detector m_prefix ('PXD' or 'SVD')
185 string pathAlign = (boost::format("Align[@component='%1%']/") % m_prefix).str();
186 GearDir paramsAlign(GearDir(content, "Alignment/"), pathAlign);
187 if (!paramsAlign) {
188 B2WARNING("Could not find alignment parameters for component " << m_prefix);
189 return svdGeometryPar;
190 }
191 svdGeometryPar.getAlignmentMap()[m_prefix] = VXDAlignmentPar(paramsAlign.getLength("du"),
192 paramsAlign.getLength("dv"),
193 paramsAlign.getLength("dw"),
194 paramsAlign.getAngle("alpha"),
195 paramsAlign.getAngle("beta"),
196 paramsAlign.getAngle("gamma")
197 );
198
199 //Read the definition of all sensor types
200 GearDir components(content, "Components/");
201 for (const GearDir& paramsSensor : components.getNodes("Sensor")) {
202 string sensorTypeID = paramsSensor.getString("@type");
203
204 VXDGeoSensorPar sensor(paramsSensor.getString("Material"),
205 paramsSensor.getString("Color", ""),
206 paramsSensor.getLength("width"),
207 paramsSensor.getLength("width2", 0),
208 paramsSensor.getLength("length"),
209 paramsSensor.getLength("height"),
210 paramsSensor.getAngle("angle", 0),
211 paramsSensor.getBool("@slanted", false)
212 );
213 sensor.setActive(VXDGeoComponentPar(
214 paramsSensor.getString("Material"),
215 paramsSensor.getString("Active/Color", "#f00"),
216 paramsSensor.getLength("Active/width"),
217 paramsSensor.getLength("Active/width2", 0),
218 paramsSensor.getLength("Active/length"),
219 paramsSensor.getLength("Active/height")
220 ), VXDGeoPlacementPar(
221 "Active",
222 paramsSensor.getLength("Active/u"),
223 paramsSensor.getLength("Active/v"),
224 paramsSensor.getString("Active/w", "center"),
225 paramsSensor.getLength("Active/woffset", 0)
226 ));
227
228 SVDSensorInfoPar* svdInfo = readSensorInfo(GearDir(paramsSensor, "Active"));
229 sensor.setSensorInfo(svdInfo);
230 sensor.setComponents(getSubComponents(paramsSensor));
231 svdGeometryPar.getSensorMap()[sensorTypeID] = sensor;
232 svdGeometryPar.getSensorInfos().push_back(svdInfo);
233 }
234
235 //Build all ladders including Sensors
236 GearDir support(content, "Support/");
237 readHalfShellSupport(support, svdGeometryPar);
238
239 for (const GearDir& shell : content.getNodes("HalfShell")) {
240
241 string shellName = m_prefix + "." + shell.getString("@name");
242 string pathShell = (boost::format("Align[@component='%1%']/") % shellName).str();
243 GearDir paramsShell(GearDir(content, "Alignment/"), pathShell);
244 if (!paramsShell) {
245 B2WARNING("Could not find alignment parameters for component " << shellName);
246 return svdGeometryPar;
247 }
248 svdGeometryPar.getAlignmentMap()[shellName] = VXDAlignmentPar(paramsShell.getLength("du"),
249 paramsShell.getLength("dv"),
250 paramsShell.getLength("dw"),
251 paramsShell.getAngle("alpha"),
252 paramsShell.getAngle("beta"),
253 paramsShell.getAngle("gamma")
254 );
255
256 VXDHalfShellPar halfShell(shell.getString("@name"), shell.getAngle("shellAngle", 0));
257
258 for (const GearDir& layer : shell.getNodes("Layer")) {
259 int layerID = layer.getInt("@id");
260
261 readLadder(layerID, components, svdGeometryPar);
262 readLayerSupport(layerID, support, svdGeometryPar);
263 readLadderSupport(layerID, support, svdGeometryPar);
264
265 //Loop over defined ladders
266 for (const GearDir& ladder : layer.getNodes("Ladder")) {
267 int ladderID = ladder.getInt("@id");
268 double phi = ladder.getAngle("phi", 0);
269 readLadderComponents(layerID, ladderID, content, svdGeometryPar);
270 halfShell.addLadder(layerID, ladderID, phi);
271 }
272 }
273 svdGeometryPar.getHalfShells().push_back(halfShell);
274 }
275
276 //Create diamond radiation sensors if defined and in background mode
277 GearDir radiationDir(content, "RadiationSensors");
278 if (svdGeometryPar.getGlobalParams().getActiveChips() && radiationDir) {
279 VXDGeoRadiationSensorsPar radiationSensors(
280 m_prefix,
281 radiationDir.getBool("insideEnvelope"),
282 radiationDir.getLength("width"),
283 radiationDir.getLength("length"),
284 radiationDir.getLength("height"),
285 radiationDir.getString("material")
286 );
287
288 //Add radiation sensor positions
289 for (GearDir& position : radiationDir.getNodes("position")) {
290 VXDGeoRadiationSensorsPositionPar diamonds(position.getLength("z"),
291 position.getLength("radius"),
292 position.getAngle("theta")
293 );
294
295 //Loop over all phi positions
296 for (GearDir& sensor : position.getNodes("phi")) {
297 //Add sensor with angle and id
298 diamonds.addSensor(sensor.getInt("@id"), sensor.getAngle());
299 }
300 radiationSensors.addPosition(diamonds);
301 }
302 svdGeometryPar.setRadiationSensors(radiationSensors);
303 }
304 return svdGeometryPar;
305 }

◆ createDiamonds()

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

Create diamond radiation sensors.

Definition at line 210 of file GeoVXDCreator.cc.

212 {
213 //Set the correct top volume to either global top or detector envelope
214 G4LogicalVolume* top = &topVolume;
215 if (params.getInsideEnvelope()) {
216 top = &envelopeVolume;
217 }
218
219 //shape and material are the same for all sensors so create them now
220 const double width = params.getWidth();
221 const double length = params.getLength();
222 const double height = params.getHeight();
223 G4Box* shape = 0;
224 G4Material* material = geometry::Materials::get(params.getMaterial());
225
226 //Now loop over all positions
227 const std::vector<VXDGeoRadiationSensorsPositionPar>& Positions = params.getPositions();
228 for (const VXDGeoRadiationSensorsPositionPar& position : Positions) {
229 //get the radial and z position
230 const double r = position.getRadius();
231 const double z = position.getZ();
232 const double theta = position.getTheta();
233 //and loop over all phi positions
234 const std::map<int, double>& Sensors = position.getSensors();
235 for (const std::pair<const int, double>& sensor : Sensors) {
236 //for (GearDir& sensor : position.getNodes("phi")) {
237 //we need angle and Id
238 const double phi = sensor.second;
239 const int id = sensor.first;
240 //then we create a nice name
241 const std::string name = params.getSubDetector() + ".DiamondSensor." + std::to_string(id);
242 //and create the sensor volume
243 if (not shape) shape = new G4Box("radiationSensorDiamond", width / 2 * CLHEP::cm, length / 2 * CLHEP::cm, height / 2 * CLHEP::cm);
244 G4LogicalVolume* volume = new G4LogicalVolume(shape, material, name);
245 //add a sensitive detector implementation
246 BkgSensitiveDetector* sensitive = new BkgSensitiveDetector(params.getSubDetector().c_str(), id);
247 volume->SetSensitiveDetector(sensitive);
248 //and place it at the correct position
249 G4Transform3D transform = G4RotateZ3D(phi - M_PI / 2) * G4Translate3D(0, r * CLHEP::cm,
250 z * CLHEP::cm) * G4RotateX3D(-M_PI / 2 - theta);
251 new G4PVPlacement(transform, volume, name, top, false, 1);
252 }
253 }
254 }
std::map< VxdID, Sensor > Sensors
Map of all hits in all Sensors.

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

61 {
62 DBObjPtr<SVDGeometryPar> dbObj;
63 if (!dbObj) {
64 // Check that we found the object and if not report the problem
65 B2FATAL("No configuration for " << name << " found.");
66 }
67 createGeometry(*dbObj, topVolume, type);
68 }

◆ createGeometry()

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

Create the geometry from a parameter object.

Definition at line 307 of file GeoSVDCreator.cc.

308 {
309
310 m_activeStepSize = parameters.getGlobalParams().getActiveStepSize() / Unit::mm;
311 m_activeChips = parameters.getGlobalParams().getActiveChips();
312 m_seeNeutrons = parameters.getGlobalParams().getSeeNeutrons();
313 m_onlyPrimaryTrueHits = parameters.getGlobalParams().getOnlyPrimaryTrueHits();
314 m_distanceTolerance = parameters.getGlobalParams().getDistanceTolerance();
315 m_electronTolerance = parameters.getGlobalParams().getElectronTolerance();
316 m_minimumElectrons = parameters.getGlobalParams().getMinimumElectrons();
317 m_onlyActiveMaterial = parameters.getGlobalParams().getOnlyActiveMaterial();
318 m_defaultMaterial = parameters.getGlobalParams().getDefaultMaterial();
319
320 G4Material* material = Materials::get(m_defaultMaterial);
321 if (!material) B2FATAL("Default Material of VXD, '" << m_defaultMaterial << "', could not be found");
322
323
324 //Build envelope
325 G4LogicalVolume* envelope(0);
326 G4VPhysicalVolume* physEnvelope{nullptr};
327 if (!parameters.getEnvelope().getExists()) {
328 B2INFO("Could not find definition for " + m_prefix + " Envelope, placing directly in top volume");
329 envelope = &topVolume;
330 } else {
331 double minZ(0), maxZ(0);
332 G4Polycone* envelopeCone = geometry::createRotationSolid("Envelope",
333 parameters.getEnvelope().getInnerPoints(),
334 parameters.getEnvelope().getOuterPoints(),
335 parameters.getEnvelope().getMinPhi(),
336 parameters.getEnvelope().getMaxPhi(),
337 minZ, maxZ
338 );
339 envelope = new G4LogicalVolume(envelopeCone, material, m_prefix + ".Envelope");
340 setVisibility(*envelope, false);
341 physEnvelope = new G4PVPlacement(getAlignment(parameters.getAlignment(m_prefix)), envelope, m_prefix + ".Envelope",
342 &topVolume, false, 1);
343
344 // Set up region for production cuts
345 G4Region* aRegion = new G4Region("SVDEnvelope");
346 envelope->SetRegion(aRegion);
347 aRegion->AddRootLogicalVolume(envelope);
348 }
349
350 //Read the definition of all sensor types
351 for (const pair<const string, VXDGeoSensorPar>& typeAndSensor : parameters.getSensorMap()) {
352 const string& sensorTypeID = typeAndSensor.first;
353 const VXDGeoSensorPar& paramsSensor = typeAndSensor.second;
354 VXDGeoSensor sensor(
355 paramsSensor.getMaterial(),
356 paramsSensor.getColor(),
357 paramsSensor.getWidth() / Unit::mm,
358 paramsSensor.getWidth2() / Unit::mm,
359 paramsSensor.getLength() / Unit::mm,
360 paramsSensor.getHeight() / Unit::mm,
361 paramsSensor.getSlanted()
362 );
363 sensor.setActive(VXDGeoComponent(
364 paramsSensor.getMaterial(),
365 paramsSensor.getActiveArea().getColor(),
366 paramsSensor.getActiveArea().getWidth() / Unit::mm,
367 paramsSensor.getActiveArea().getWidth2() / Unit::mm,
368 paramsSensor.getActiveArea().getLength() / Unit::mm,
369 paramsSensor.getActiveArea().getHeight() / Unit::mm
370 ), VXDGeoPlacement(
371 "Active",
372 paramsSensor.getActivePlacement().getU() / Unit::mm,
373 paramsSensor.getActivePlacement().getV() / Unit::mm,
374 paramsSensor.getActivePlacement().getW(),
375 paramsSensor.getActivePlacement().getWOffset() / Unit::mm
376 ));
377 sensor.setSensorInfo(createSensorInfo(paramsSensor));
378
379 vector<VXDGeoPlacement> subcomponents;
380 for (const VXDGeoPlacementPar& component : paramsSensor.getComponents()) {
381 subcomponents.push_back(VXDGeoPlacement(
382 component.getName(),
383 component.getU() / Unit::mm,
384 component.getV() / Unit::mm,
385 component.getW(),
386 component.getWOffset() / Unit::mm
387 ));
388 }
389 sensor.setComponents(subcomponents);
390 m_sensorMap[sensorTypeID] = sensor;
391 }
392
393 //Read the component cache from DB
394 for (const string& name : parameters.getComponentInsertOder()) {
395 if (m_componentCache.find(name) != m_componentCache.end()) {
396 // already created due to being a sub component of a previous
397 // component. Seems fishy since the information of this component
398 // is in the db at least twice so we could run into
399 // inconsistencies.
400 B2WARNING("Component " << name << " already created from previous subcomponents, should not be here");
401 continue;
402 }
403 const VXDGeoComponentPar& paramsComponent = parameters.getComponent(name);
404 VXDGeoComponent c(
405 paramsComponent.getMaterial(),
406 paramsComponent.getColor(),
407 paramsComponent.getWidth() / Unit::mm,
408 paramsComponent.getWidth2() / Unit::mm,
409 paramsComponent.getLength() / Unit::mm,
410 paramsComponent.getHeight() / Unit::mm
411 );
412 double angle = paramsComponent.getAngle();
413
414
415 if (c.getWidth() <= 0 || c.getLength() <= 0 || c.getHeight() <= 0) {
416 B2DEBUG(100, "One dimension empty, using auto resize for component");
417 } else {
418 G4VSolid* solid = createTrapezoidal(m_prefix + "." + name, c.getWidth(), c.getWidth2(), c.getLength(), c.getHeight(), angle);
419 c.setVolume(new G4LogicalVolume(solid, Materials::get(c.getMaterial()), m_prefix + "." + name));
420 }
421
422 vector<VXDGeoPlacement> subComponents;
423 for (const VXDGeoPlacementPar& paramsSubComponent : paramsComponent.getSubComponents()) {
424 subComponents.push_back(VXDGeoPlacement(
425 paramsSubComponent.getName(),
426 paramsSubComponent.getU() / Unit::mm,
427 paramsSubComponent.getV() / Unit::mm,
428 paramsSubComponent.getW(),
429 paramsSubComponent.getWOffset() / Unit::mm
430 ));
431
432 }
433
434 createSubComponents(m_prefix + "." + name, c, subComponents);
435 if (m_activeChips && parameters.getSensitiveChipID(name) >= 0) {
436 int chipID = parameters.getSensitiveChipID(name);
437 B2DEBUG(50, "Creating BkgSensitiveDetector for component " << name << " with chipID " << chipID);
438 BkgSensitiveDetector* sensitive = new BkgSensitiveDetector(m_prefix.c_str(), chipID);
439 c.getVolume()->SetSensitiveDetector(sensitive);
440 m_sensitive.push_back(sensitive);
441 }
442
443 m_componentCache[name] = c;
444 }
445
446 //Build all ladders including Sensors
447 VXD::GeoVXDAssembly shellSupport = createHalfShellSupport(parameters);
448
449 //const std::vector<VXDHalfShellPar>& HalfShells = parameters.getHalfShells();
450 for (const VXDHalfShellPar& shell : parameters.getHalfShells()) {
451 string shellName = shell.getName();
452 m_currentHalfShell = m_prefix + "." + shellName;
453 G4Transform3D shellAlignment = getAlignment(parameters.getAlignment(m_currentHalfShell));
454
455 // Remember shell coordinate system (into which ladders are inserted)
456 VXD::GeoCache::getInstance().addHalfShellPlacement(m_halfShellVxdIDs[m_currentHalfShell], shellAlignment);
457
458 //Place shell support
459 double shellAngle = shell.getShellAngle();
460 if (!m_onlyActiveMaterial) shellSupport.place(envelope, shellAlignment * G4RotateZ3D(shellAngle));
461
462 //const std::map< int, std::vector<std::pair<int, double>> >& Layers = shell.getLayers();
463 for (const std::pair<const int, std::vector<std::pair<int, double>> >& layer : shell.getLayers()) {
464 int layerID = layer.first;
465 const std::vector<std::pair<int, double>>& Ladders = layer.second;
466
467
468 setCurrentLayer(layerID, parameters);
469
470 //Place Layer support
471 VXD::GeoVXDAssembly layerSupport = createLayerSupport(layerID, parameters);
472 if (!m_onlyActiveMaterial) layerSupport.place(envelope, shellAlignment * G4RotateZ3D(shellAngle));
473 VXD::GeoVXDAssembly ladderSupport = createLadderSupport(layerID, parameters);
474
475 //Loop over defined ladders
476 for (const std::pair<int, double>& ladder : Ladders) {
477 int ladderID = ladder.first;
478 double phi = ladder.second;
479
480 G4Transform3D ladderPlacement = placeLadder(ladderID, phi, envelope, shellAlignment, parameters);
481 if (!m_onlyActiveMaterial) ladderSupport.place(envelope, ladderPlacement);
482 }
483
484 }
485 }
486
487 //Now build cache with all transformations
488 if (physEnvelope) {
489 VXD::GeoCache::getInstance().findVolumes(physEnvelope);
490 } else {
491 //create a temporary placement of the top volume.
492 G4PVPlacement topPlacement(nullptr, G4ThreeVector(0, 0, 0), &topVolume,
493 "temp_Top", nullptr, false, 1, false);
494 //and search for all VXD sensitive sensors within
495 VXD::GeoCache::getInstance().findVolumes(&topPlacement);
496 }
497
498 //Create diamond radiation sensors if defined and in background mode
499 if (m_activeChips) {
500 if (parameters.getRadiationSensors().getSubDetector() == "") {
501 B2DEBUG(10, "Apparently no radiation sensors defined, skipping");
502 } else {
503 createDiamonds(parameters.getRadiationSensors(), topVolume, *envelope);
504 }
505 }
506 }
void setVisibility(G4LogicalVolume &volume, bool visible)
Helper function to quickly set the visibility of a given volume.
Definition utilities.cc:108

◆ 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 634 of file GeoSVDCreator.cc.

635 {
636 VXD::GeoVXDAssembly supportAssembly;
637
638 //Half shell support is easy as we just add all the defined RotationSolids
639 double minZ(0), maxZ(0);
640
641 const std::vector<VXDRotationSolidPar>& RotationSolids = parameters.getRotationSolids();
642
643 for (const VXDRotationSolidPar& component : RotationSolids) {
644
645 string name = component.getName();
646 string material = component.getMaterial();
647
648 G4Polycone* solid = geometry::createRotationSolid(name,
649 component.getInnerPoints(),
650 component.getOuterPoints(),
651 component.getMinPhi(),
652 component.getMaxPhi(),
653 minZ, maxZ
654 );
655
656 G4LogicalVolume* volume = new G4LogicalVolume(
657 solid, geometry::Materials::get(material), m_prefix + ". " + name);
658 geometry::setColor(*volume, component.getColor());
659 supportAssembly.add(volume);
660 }
661 return supportAssembly;
662 }

◆ createLadderSupport()

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

Create support structure for a SVD Ladder.

Parameters
layerLayer ID to create the support
parameters

Definition at line 800 of file GeoSVDCreator.cc.

801 {
802 VXD::GeoVXDAssembly supportAssembly;
803
804 if (!parameters.getSupportRibsExist(layer)) return supportAssembly;
805 const SVDSupportRibsPar& support = parameters.getSupportRibs(layer);
806
807 // Get the common values for all layers
808 double spacing = support.getSpacing() / Unit::mm / 2.0;
809 double height = support.getHeight() / Unit::mm / 2.0;
810 double innerWidth = support.getInnerWidth() / Unit::mm / 2.0;
811 double outerWidth = support.getOuterWidth() / Unit::mm / 2.0;
812 double tabLength = support.getTabLength() / Unit::mm / 2.0;
813 G4VSolid* inner(0);
814 G4VSolid* outer(0);
815 G4Transform3D placement;
816
817
818 // Now lets create the ribs by adding all boxes to form one union solid
819 const std::vector<SVDSupportBoxPar>& Boxes = support.getBoxes();
820 for (const SVDSupportBoxPar& box : Boxes) {
821 double theta = box.getTheta();
822 double zpos = box.getZ() / Unit::mm;
823 double rpos = box.getR() / Unit::mm;
824 double length = box.getLength() / Unit::mm / 2.0;
825 G4Box* innerBox = new G4Box("innerBox", height, innerWidth, length);
826 G4Box* outerBox = new G4Box("outerBox", height, outerWidth, length);
827 if (!inner) {
828 inner = innerBox;
829 outer = outerBox;
830 placement = G4Translate3D(rpos, 0, zpos) * G4RotateY3D(theta);
831 } else {
832 G4Transform3D relative = placement.inverse() * G4Translate3D(rpos, 0, zpos) * G4RotateY3D(theta);
833 inner = new G4UnionSolid("innerBox", inner, innerBox, relative);
834 outer = new G4UnionSolid("outerBox", outer, outerBox, relative);
835 }
836 }
837
838 // Now lets add the tabs
839 const std::vector<SVDSupportTabPar>& Tabs = support.getTabs();
840 for (const SVDSupportTabPar& tab : Tabs) {
841 double theta = tab.getTheta();
842 double zpos = tab.getZ() / Unit::mm;
843 double rpos = tab.getR() / Unit::mm;
844 G4Box* innerBox = new G4Box("innerBox", height, innerWidth, tabLength);
845 if (!inner) {
846 inner = innerBox;
847 placement = G4Translate3D(rpos, 0, zpos) * G4RotateY3D(theta);
848 } else {
849 G4Transform3D relative = placement.inverse() * G4Translate3D(rpos, 0, zpos) * G4RotateY3D(theta);
850 inner = new G4UnionSolid("innerBox", inner, innerBox, relative);
851 }
852 }
853
854 // Now lets create forward and backward endmounts for the ribs
855 const std::vector<SVDEndmountPar>& Endmounts = support.getEndmounts();
856 for (const SVDEndmountPar& endmount : Endmounts) {
857 double endMountHeight = endmount.getHeight() / Unit::mm / 2.0;
858 double endMountWidth = endmount.getWidth() / Unit::mm / 2.0;
859 double endMountLength = endmount.getLength() / Unit::mm / 2.0;
860 double zpos = endmount.getZ() / Unit::mm;
861 double rpos = endmount.getR() / Unit::mm;
862 G4VSolid* endmountBox = new G4Box("endmountBox", endMountHeight, endMountWidth, endMountLength);
863 if (outer) { // holes for the ribs
864 endmountBox = new G4SubtractionSolid("endmountBox", endmountBox, outer, G4TranslateY3D(-spacing)*placement * G4Translate3D(-rpos, 0,
865 -zpos));
866 endmountBox = new G4SubtractionSolid("endmountBox", endmountBox, outer, G4TranslateY3D(spacing)*placement * G4Translate3D(-rpos, 0,
867 -zpos));
868 }
869 G4LogicalVolume* endmountVolume = new G4LogicalVolume(
870 endmountBox, geometry::Materials::get(support.getEndmountMaterial()),
871 (boost::format("%1%.Layer%2%.%3%Endmount") % m_prefix % layer % endmount.getName()).str());
872 supportAssembly.add(endmountVolume, G4Translate3D(rpos, 0, zpos));
873 }
874
875 // If there has been at least one Box, create the volumes and add them to the assembly
876 if (inner) {
877 outer = new G4SubtractionSolid("outerBox", outer, inner);
878 G4LogicalVolume* outerVolume = new G4LogicalVolume(
879 outer, geometry::Materials::get(support.getOuterMaterial()),
880 (boost::format("%1%.Layer%2%.SupportRib") % m_prefix % layer).str());
881 G4LogicalVolume* innerVolume = new G4LogicalVolume(
882 inner, geometry::Materials::get(support.getInnerMaterial()),
883 (boost::format("%1%.Layer%2%.SupportRib.Airex") % m_prefix % layer).str());
884 geometry::setColor(*outerVolume, support.getOuterColor());
885 geometry::setColor(*innerVolume, support.getInnerColor());
886 supportAssembly.add(innerVolume, G4TranslateY3D(-spacing)*placement);
887 supportAssembly.add(innerVolume, G4TranslateY3D(spacing)*placement);
888 supportAssembly.add(outerVolume, G4TranslateY3D(-spacing)*placement);
889 supportAssembly.add(outerVolume, G4TranslateY3D(spacing)*placement);
890 }
891
892 // Done, return the finished assembly
893 return supportAssembly;
894 }

◆ createLayerSupport()

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

Create support structure for a SVD Layer.

Parameters
layerLayer ID to create the support
parameters

Definition at line 666 of file GeoSVDCreator.cc.

667 {
668 VXD::GeoVXDAssembly supportAssembly;
669
670 //Check if there are any endrings defined for this layer. If not we don't create any
671 if (parameters.getEndringsExist(layer)) {
672 const SVDEndringsPar& support = parameters.getEndrings(layer);
673
674 string material = support.getMaterial();
675 double length = support.getLength() / Unit::mm / 2.0;
676 double gapWidth = support.getGapWidth() / Unit::mm;
677 double baseThickness = support.getBaseThickness() / Unit::mm / 2.0;
678
679 //Create the endrings
680 const std::vector<SVDEndringsTypePar>& Endrings = support.getTypes();
681 for (const SVDEndringsTypePar& endring : Endrings) {
682 double z = endring.getZ() / Unit::mm;
683 double baseRadius = endring.getBaseRadius() / Unit::mm;
684 double innerRadius = endring.getInnerRadius() / Unit::mm;
685 double outerRadius = endring.getOuterRadius() / Unit::mm;
686 double horiBarWidth = endring.getHorizontalBarWidth() / Unit::mm / 2.0;
687 double vertBarWidth = endring.getVerticalBarWidth() / Unit::mm / 2.0;
688
689 double angle = asin(gapWidth / innerRadius);
690 G4VSolid* endringSolid = new G4Tubs("OuterEndring", innerRadius, outerRadius, length, -M_PI / 2 + angle, M_PI - 2 * angle);
691 angle = asin(gapWidth / baseRadius);
692 G4VSolid* endringBase = new G4Tubs("InnerEndring", baseRadius, baseRadius + baseThickness, length, -M_PI / 2 + angle,
693 M_PI - 2 * angle);
694 endringSolid = new G4UnionSolid("Endring", endringSolid, endringBase);
695
696 //Now we need the bars which connect the two rings
697 double height = (innerRadius - baseRadius) / 2.0;
698 double x = vertBarWidth + gapWidth;
699 G4Box* verticalBar = new G4Box("VerticalBar", vertBarWidth, height, length);
700 G4Box* horizontalBar = new G4Box("HorizontalBar", height, horiBarWidth, length);
701 endringSolid = new G4UnionSolid("Endring", endringSolid, verticalBar, G4Translate3D(x, baseRadius + height, 0));
702 endringSolid = new G4UnionSolid("Endring", endringSolid, verticalBar, G4Translate3D(x, -(baseRadius + height), 0));
703 endringSolid = new G4UnionSolid("Endring", endringSolid, horizontalBar, G4Translate3D((baseRadius + height), 0, 0));
704
705 //Finally create the volume and add it to the assembly at the correct z position
706 G4LogicalVolume* endringVolume = new G4LogicalVolume(
707 endringSolid, geometry::Materials::get(material),
708 (boost::format("%1%.Layer%2%.%3%") % m_prefix % layer % endring.getName()).str());
709 supportAssembly.add(endringVolume, G4TranslateZ3D(z));
710 }
711 }
712
713 //Check if there are any coling pipes defined for this layer. If not we don't create any
714 if (parameters.getCoolingPipesExist(layer)) {
715 const SVDCoolingPipesPar& pipes = parameters.getCoolingPipes(layer);
716
717 string material = pipes.getMaterial();
718 double outerRadius = pipes.getOuterDiameter() / Unit::mm / 2.0;
719 double innerRadius = outerRadius - pipes.getWallThickness() / Unit::mm;
720 int nPipes = pipes.getNPipes();
721 double startPhi = pipes.getStartPhi();
722 double deltaPhi = pipes.getDeltaPhi();
723 double radius = pipes.getRadius() / Unit::mm;
724 double zstart = pipes.getZStart() / Unit::mm;
725 double zend = pipes.getZEnd() / Unit::mm;
726 double zlength = (zend - zstart) / 2.0;
727
728
729 // There are two parts: the straight pipes and the bendings. So we only need two different volumes
730 // which we place multiple times
731 G4Tubs* pipeSolid = new G4Tubs("CoolingPipe", innerRadius, outerRadius, zlength, 0, 2 * M_PI);
732 G4LogicalVolume* pipeVolume = new G4LogicalVolume(
733 pipeSolid, geometry::Materials::get(material),
734 (boost::format("%1%.Layer%2%.CoolingPipe") % m_prefix % layer).str());
735 geometry::setColor(*pipeVolume, "#ccc");
736
737#ifndef __clang_analyzer__
738 G4Torus* bendSolid = new G4Torus("CoolingBend", innerRadius, outerRadius, sin(deltaPhi / 2.0)*radius, -M_PI / 2, M_PI);
739 G4LogicalVolume* bendVolume = new G4LogicalVolume(
740 bendSolid, geometry::Materials::get(material),
741 (boost::format("%1%.Layer%2%.CoolingBend") % m_prefix % layer).str());
742#endif
743 // Last pipe may be closer, thus we need additional bending
744 if (pipes.getDeltaL() > 0) {
745 double deltaL = pipes.getDeltaL() / Unit::mm;
746 G4Torus* bendSolidLast = new G4Torus("CoolingBendLast", innerRadius, outerRadius, sin(deltaPhi / 2.0) * radius - deltaL / 2.0,
747 -M_PI / 2, M_PI);
748 G4LogicalVolume* bendVolumeLast = new G4LogicalVolume(bendSolidLast, geometry::Materials::get(material),
749 (boost::format("%1%.Layer%2%.CoolingBendLast") % m_prefix % layer).str());
750 --nPipes;
751
752 // Place the last straight pipe
753 G4Transform3D placement_pipe = G4RotateZ3D(startPhi + (nPipes - 0.5) * deltaPhi) * G4Translate3D(cos(deltaPhi / 2.0) * radius,
754 sin(deltaPhi / 2.0) * radius - deltaL, zstart + zlength);
755 supportAssembly.add(pipeVolume, placement_pipe);
756
757 // Place forward or backward bend
758 double zpos = nPipes % 2 > 0 ? zend : zstart;
759 // Calculate transformation
760 G4Transform3D placement = G4RotateZ3D(startPhi + (nPipes - 0.5) * deltaPhi) * G4Translate3D(cos(deltaPhi / 2.0) * radius,
761 -deltaL / 2.0, zpos) * G4RotateY3D(M_PI / 2);
762 // If we are at the forward side we rotate the bend by 180 degree
763 if (nPipes % 2 > 0) {
764 placement = placement * G4RotateZ3D(M_PI);
765 }
766 // And place the bend
767 supportAssembly.add(bendVolumeLast, placement);
768 }
769
770 for (int i = 0; i < nPipes; ++i) {
771 // Place the straight pipes
772 G4Transform3D placement_pipe = G4RotateZ3D(startPhi + i * deltaPhi) * G4Translate3D(radius, 0, zstart + zlength);
773 supportAssembly.add(pipeVolume, placement_pipe);
774
775 // This was the easy part, now lets add the connection between the pipes. We only need n-1 bendings
776 if (i > 0) {
777 // Place forward or backward bend
778 double zpos = i % 2 > 0 ? zend : zstart;
779 // Calculate transformation
780 G4Transform3D placement = G4RotateZ3D(startPhi + (i - 0.5) * deltaPhi) * G4Translate3D(cos(deltaPhi / 2.0) * radius, 0,
781 zpos) * G4RotateY3D(M_PI / 2);
782 // If we are at the forward side we rotate the bend by 180 degree
783 if (i % 2 > 0) {
784 placement = placement * G4RotateZ3D(M_PI);
785 }
786#ifndef __clang_analyzer__
787 // And place the bend
788 supportAssembly.add(bendVolume, placement);
789#endif
790 }
791 }
792
793 }
794
795 return supportAssembly;
796 }

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

53 {
54 DBImportObjPtr<SVDGeometryPar> importObj;
55 importObj.construct(createConfiguration(content));
56 importObj.import(iov);
57 }

◆ createSensitiveDetector()

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

Return a SensitiveDetector implementation for a given sensor.

Parameters
sensorIDSensorID for the sensor
sensorInformation about the sensor to create the Sensitive Detector for
placementInformation on how to place the sensor

Implements GeoVXDCreator.

Definition at line 135 of file GeoSVDCreator.cc.

137 {
138 SensorInfo* sensorInfo = new SensorInfo(dynamic_cast<const SensorInfo&>(*sensor.getSensorInfo()));
139 sensorInfo->setID(sensorID);
140 SensitiveDetector* sensitive = new SensitiveDetector(sensorInfo);
141 return sensitive;
142 }
VXD::SensitiveDetector< PXDSimHit, PXDTrueHit > SensitiveDetector
The PXD Sensitive Detector class.

◆ createSensorInfo()

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

Read the sensor definitions from the database.

Parameters
sensorReference to the database containing the parameters

Implements GeoVXDCreator.

Definition at line 58 of file GeoSVDCreator.cc.

59 {
60 const SVDSensorInfoPar& infoPar = dynamic_cast<const SVDSensorInfoPar&>(*sensor.getSensorInfo());
61
62 SensorInfo* info = new SensorInfo(
63 VxdID(0, 0, 0),
64 infoPar.getWidth(),
65 infoPar.getLength(),
66 infoPar.getThickness(),
67 infoPar.getUCells(),
68 infoPar.getVCells(),
69 infoPar.getWidth2()
70 );
71 info->setSensorParams(
72 infoPar.getStripEdgeU(),
73 infoPar.getStripEdgeV(),
74 infoPar.getDepletionVoltage(),
75 infoPar.getBiasVoltage(),
76 infoPar.getBackplaneCapacitanceU(),
77 infoPar.getInterstripCapacitanceU(),
78 infoPar.getCouplingCapacitanceU(),
79 infoPar.getBackplaneCapacitanceV(),
80 infoPar.getInterstripCapacitanceV(),
81 infoPar.getCouplingCapacitanceV(),
82 infoPar.getAduEquivalentU(),
83 infoPar.getAduEquivalentV(),
84 infoPar.getElectronicNoiseU(),
85 infoPar.getElectronicNoiseV(),
86 infoPar.getAduEquivalentSbwU(),
87 infoPar.getAduEquivalentSbwV(),
88 infoPar.getElectronicNoiseSbwU(),
89 infoPar.getElectronicNoiseSbwV()
90 );
91 m_SensorInfo.push_back(info);
92 return info;
93 }

◆ 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
nameName for the potential new volume or as prefix for the container to extend the component
componentComponent to fit the subcomponents into
placementsPlacement information for all subcomponents
originCenterbool
allowOutsidebool
Returns
offset in w which was applied to the component when extending it

Definition at line 75 of file GeoVXDCreator.cc.

77 {
78 GeoVXDAssembly assembly;
79 B2DEBUG(100, "Creating component " << name);
80 vector<VXDGeoComponent> subComponents;
81 subComponents.reserve(placements.size());
82 //Go over all subcomponents and check if they will fit inside.
83 //If component.volume is zero we will create one so sum up needed space
84 bool widthResize = component.getWidth() <= 0;
85 bool lengthResize = component.getLength() <= 0;
86 bool heightResize = component.getHeight() <= 0;
87
88 for (VXDGeoPlacement& p : placements) {
89 //Test component already exists
90 if (m_componentCache.find(p.getName()) == m_componentCache.end()) {
91 B2FATAL("A component is requested that was not created before!");
92 }
93 VXDGeoComponent sub = m_componentCache[p.getName()];
94
95 B2DEBUG(100, "SubComponent " << p.getName());
96 B2DEBUG(100, boost::format("Placement: u:%1% cm, v:%2% cm, w:%3% + %4% cm") % p.getU() % p.getV() % p.getW() % p.getWOffset());
97 B2DEBUG(100, boost::format("Dimensions: %1%x%2%x%3% cm") % sub.getWidth() % sub.getLength() % sub.getHeight());
98
99 if (p.getW() == VXDGeoPlacement::c_above || p.getW() == VXDGeoPlacement::c_below) {
100 //Below placement only valid if we are allowed to create a container around component
101 if (!allowOutside) B2FATAL("Cannot place component " << p.getName() << " outside of component " << name);
102 } else if (sub.getHeight() + p.getWOffset() > component.getHeight()) {
103 //Component will not fit heightwise. If we resize the volume anyway than we don't have problems
104 if (!heightResize) {
105 B2FATAL("Subcomponent " << p.getName() << " does not fit into volume: "
106 << "height " << sub.getHeight() << " > " << component.getHeight());
107 }
108 component.getHeight() = sub.getHeight() + p.getWOffset();
109 }
110
111 //Check if component will fit inside width,length. If we can resize do it if needed, otherwise bail
112 double minWidth = max(abs(p.getU() + sub.getWidth() / 2.0), abs(p.getU() - sub.getWidth() / 2.0));
113 double minLength = max(abs(p.getV() + sub.getLength() / 2.0), abs(p.getV() - sub.getLength() / 2.0));
114 if (minWidth > component.getWidth() + component.getWidth() * numeric_limits<double>::epsilon()) {
115 if (!widthResize) {
116 B2FATAL("Subcomponent " << p.getName() << " does not fit into volume: "
117 << "minWidth " << minWidth << " > " << component.getWidth());
118 }
119 component.setWidth(minWidth * 2.0);
120 }
121 if (minLength > component.getLength() + component.getLength() * numeric_limits<double>::epsilon()) {
122 if (!lengthResize) {
123 B2FATAL("Subcomponent " << p.getName() << " does not fit into volume: "
124 << "minLength " << minLength << " > " << component.getLength());
125 }
126 component.setLength(minLength * 2.0);
127 }
128 subComponents.push_back(sub);
129 }
130
131 //zero dimensions are fine mathematically but we don't want them in the simulation
132 if (component.getWidth() <= 0 || component.getLength() <= 0 || component.getHeight() <= 0) {
133 B2FATAL("At least one dimension of component " << name << " is zero which does not make sense");
134 }
135
136 //No volume yet, create a new one automatically assuming air material
137 if (!component.getVolume()) {
138 G4VSolid* componentShape = createTrapezoidal(name, component.getWidth(), component.getWidth2(), component.getLength(),
139 component.getHeight());
140 component.setVolume(new G4LogicalVolume(componentShape, Materials::get(component.getMaterial()), name));
141 }
142
143 B2DEBUG(100, boost::format("Component %1% dimensions: %2%x%3%x%4% cm") % name % component.getWidth() % component.getLength() %
144 component.getHeight());
145
146 //Ok, all volumes set up, now add them together
147 for (size_t i = 0; i < placements.size(); ++i) {
148 VXDGeoPlacement& p = placements[i];
149 VXDGeoComponent& s = subComponents[i];
150
151 G4Transform3D transform = getPosition(component, s, p, originCenter);
152 if (p.getW() == VXDGeoPlacement::c_below || p.getW() == VXDGeoPlacement::c_above) {
153 //Add to selected mother (either component or container around component
154 assembly.add(s.getVolume(), transform);
155 } else {
156 new G4PVPlacement(transform, s.getVolume(), name + "." + p.getName(), component.getVolume(), false, i);
157 }
158 }
159
160 //Set some visibility options for volume. Done here because all components including sensor go through here
161 if (component.getColor().empty()) {
162 B2DEBUG(200, "Component " << name << " is an Air volume, setting invisible");
163 setVisibility(*component.getVolume(), false);
164 } else {
165 B2DEBUG(200, "Component " << name << " color: " << component.getColor());
166 setColor(*component.getVolume(), component.getColor());
167 }
168 B2DEBUG(100, "--> Created component " << name);
169 //Return the difference in W between the origin of the original component and the including container
170 return assembly;
171 }
ExpRunEvt getPosition(const std::vector< Evt > &events, double tEdge)
Get the exp-run-evt number from the event time [hours].
Definition Splitter.h:341
void setColor(G4LogicalVolume &volume, const std::string &color)
Set the color of a logical volume.
Definition utilities.cc:100

◆ createTrapezoidal()

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

Create a trapezoidal solid.

Parameters
namename of the Geant4 solid
widthfull forward width of the shape in mm
width2full backward width of the shape in mm
lengthlength 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
angleangle 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.

258 {
259 double offset(0);
260 if (angle > 0) {
261 const double tana = tan(angle);
262 height = min(tana * length, min(tana * width, height));
263 offset = height / tana;
264 }
265 const double hwidth = width / 2.0;
266 const double hwidth2 = width2 / 2.0;
267 const double hlength = length / 2.0;
268 const double hheight = height / 2.0;
269
270 if (width2 <= 0 || width == width2) {
271 if (angle <= 0) {
272 return new G4Box(name, hwidth, hlength, hheight);
273 } else {
274 return new G4Trd(name, hwidth, hwidth - offset, hlength, hlength - offset, hheight);
275 }
276 }
277 //FIXME: offset not working, g4 complains about nonplanarity of face -X. But we do not need that shape at the moment
278 //so lets ignore it for now
279 return new G4Trap(name, hheight, 0, 0, hlength, hwidth, hwidth2, 0, hlength - offset, hwidth - offset, hwidth2 - offset, 0);
280 }

◆ getAlignment()

G4Transform3D getAlignment ( const VXDAlignmentPar & params)
inherited

Get Alignment from paylead object.

Parameters
paramsPayload object
Returns
Transformation matrix for component

Definition at line 173 of file GeoVXDCreator.cc.

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

◆ 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
motherMother component
daughterDaughter component
placementVXDGeoPlacement
originCenterbool
Returns
Transformation matrix to place the daughter relative to the origin to the mother

Definition at line 180 of file GeoVXDCreator.cc.

182 {
183 double u(placement.getU()), v(placement.getV()), w(0);
184 switch (placement.getW()) {
185 case VXDGeoPlacement::c_below: //Place below component
186 w = - mother.getHeight() / 2.0 - daughter.getHeight() / 2.0;
187 break;
188 case VXDGeoPlacement::c_bottom: //Place inside, at bottom of component
189 w = - mother.getHeight() / 2.0 + daughter.getHeight() / 2.0;
190 break;
191 case VXDGeoPlacement::c_center: //Place inside, centered
192 w = 0;
193 break;
194 case VXDGeoPlacement::c_top: //Place inside, at top of mother
195 w = mother.getHeight() / 2.0 - daughter.getHeight() / 2.0;
196 break;
197 case VXDGeoPlacement::c_above: //Place above mother
198 w = mother.getHeight() / 2.0 + daughter.getHeight() / 2.0;
199 break;
200 }
201 if (!originCenter) { //Sensor has coordinate origin in the corner, all submothers at their center
202 u -= mother.getWidth() / 2.0;
203 v -= mother.getLength() / 2.0;
204 }
205 return G4Translate3D(u, v, w + placement.getWOffset());
206 }

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

608 {
609 vector<VXDGeoPlacementPar> result;
610 for (const GearDir& component : path.getNodes("Component")) {
611 string type;
612 if (!component.exists("@type")) {
613 type = component.getString("@name");
614 } else {
615 type = component.getString("@type");
616 }
617 int nPos = max(component.getNumberNodes("u"), component.getNumberNodes("v"));
618 nPos = max(nPos, component.getNumberNodes("w"));
619 nPos = max(nPos, component.getNumberNodes("woffset"));
620 for (int iPos = 1; iPos <= nPos; ++iPos) {
621 string index = (boost::format("[%1%]") % iPos).str();
622 result.push_back(VXDGeoPlacementPar(
623 type,
624 component.getLength("u" + index, 0),
625 component.getLength("v" + index, 0),
626 component.getString("w" + index, "bottom"),
627 component.getLength("woffset" + index, 0)
628 ));
629 }
630 }
631 return result;
632 }

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

285 {
286 VxdID ladder(m_ladder.getLayerID(), ladderID, 0);
287
288 G4Translate3D ladderPos(m_ladder.getRadius(), m_ladder.getShift(), 0);
289 G4Transform3D ladderPlacement = placement * G4RotateZ3D(phi) * ladderPos * getAlignment(parameters.getAlignment(ladder));
290 // The actual coordinate system of ladder (w still points to Z, there is only phi rotation + move to correct radius + shift)
291 VXD::GeoCache::getInstance().addLadderPlacement(m_halfShellVxdIDs[m_currentHalfShell], ladder, ladderPlacement);
292
293
294 vector<G4Point3D> lastSensorEdge;
295 for (const VXDGeoSensorPlacement& p : m_ladder.getSensors()) {
296 VxdID sensorID(ladder);
297 sensorID.setSensorNumber(p.getSensorID());
298
299
300 std::map<string, VXDGeoSensor>::iterator it = m_sensorMap.find(p.getSensorTypeID());
301 if (it == m_sensorMap.end()) {
302 B2FATAL("Invalid SensorTypeID " << p.getSensorTypeID() << ", please check the definition of " << sensorID);
303 }
304 VXDGeoSensor& s = it->second;
305 string name = m_prefix + "." + (string)sensorID;
306
307 //Calculate the reflection transformation needed. Since we want the
308 //active area to be non reflected we apply this transformation on the
309 //sensor and on the active area
310 G4Transform3D reflection;
311 if (p.getFlipU()) reflection = reflection * G4ReflectX3D();
312 if (p.getFlipV()) reflection = reflection * G4ReflectY3D();
313 if (p.getFlipW()) reflection = reflection * G4ReflectZ3D();
314
315 G4VSolid* sensorShape = createTrapezoidal(name, s.getWidth(), s.getWidth2(), s.getLength(),
316 s.getHeight());
317 G4Material* sensorMaterial = Materials::get(s.getMaterial());
318 if (m_onlyActiveMaterial) {
319 s.setVolume(new G4LogicalVolume(sensorShape, Materials::get(m_defaultMaterial), name));
320 } else {
321 s.setVolume(new G4LogicalVolume(sensorShape, sensorMaterial, name));
322 }
323
324 // Create sensitive Area: this Part is created separately since we want full control over the coordinate system:
325 // local x (called u) should point in RPhi direction
326 // local y (called v) should point in global z
327 // local z (called w) should away from the origin
328 G4VSolid* activeShape = createTrapezoidal(name + ".Active", s.getActiveArea().getWidth(), s.getActiveArea().getWidth2(),
329 s.getActiveArea().getLength(), s.getActiveArea().getHeight());
330
331 //Create appropriate sensitive detector instance
332 SensitiveDetectorBase* sensitive = createSensitiveDetector(sensorID, s, p);
333
334 sensitive->setOptions(m_seeNeutrons, m_onlyPrimaryTrueHits,
335 m_distanceTolerance, m_electronTolerance, m_minimumElectrons);
336 m_sensitive.push_back(sensitive);
337 G4LogicalVolume* active = new G4LogicalVolume(activeShape, sensorMaterial, name + ".Active",
338 0, sensitive);
339 m_UserLimits.push_back(new G4UserLimits(m_activeStepSize));
340 active->SetUserLimits(m_UserLimits.back());
341
342 setColor(*active, s.getActiveArea().getColor());
343
344 //The coordinates of the active region are given as the distance between the corners, not to the center
345 //Place the active area
346 G4Transform3D activePosition = G4Translate3D(s.getActiveArea().getWidth() / 2.0, s.getActiveArea().getLength() / 2.0, 0) *
347 getPosition(s, s.getActiveArea(), s.getActivePlacement(), false);
348
349 G4ReflectionFactory::Instance()->Place(activePosition * reflection, name + ".Active", active, s.getVolume(),
350 false, (int)sensorID, false);
351
352 //Now create all the other components and place the Sensor
353 GeoVXDAssembly assembly;
354 if (!m_onlyActiveMaterial) assembly = createSubComponents(name, s, s.getComponents(), false, true);
355
356 G4RotationMatrix rotation(0, -M_PI / 2.0, -M_PI / 2.0);
357 G4Transform3D sensorAlign = getAlignment(parameters.getAlignment(sensorID));
358 G4Transform3D sensorPlacement = G4Rotate3D(rotation) * sensorAlign * reflection;
359
360 if (s.getSlanted()) {
361 sensorPlacement = G4TranslateX3D(m_ladder.getSlantedRadius() - m_ladder.getRadius()) * G4RotateY3D(
362 -m_ladder.getSlantedAngle()) * sensorPlacement;
363 }
364 sensorPlacement = G4Translate3D(0.0, 0.0, p.getZ()) * sensorPlacement;
365 // Remember the placement of sensor into ladder
366 VXD::GeoCache::getInstance().addSensorPlacement(ladder, sensorID, sensorPlacement * activePosition * reflection);
367 sensorPlacement = ladderPlacement * sensorPlacement;
368
369 assembly.add(s.getVolume());
370 assembly.place(volume, sensorPlacement);
371
372 //See if we want to glue the modules together
373 if (!m_ladder.getGlueMaterial().empty() && !m_onlyActiveMaterial) {
374 double u = s.getWidth() / 2.0 + m_ladder.getGlueSize();
375 double v = s.getLength() / 2.0;
376 double w = s.getHeight() / 2.0 + m_ladder.getGlueSize();
377 std::vector<G4Point3D> curSensorEdge(4);
378 //Lets get the forward corners of the sensor by applying the unreflected placement matrix
379 curSensorEdge[0] = sensorPlacement * reflection * G4Point3D(u, v, + w);
380 curSensorEdge[1] = sensorPlacement * reflection * G4Point3D(u, v, - w);
381 curSensorEdge[2] = sensorPlacement * reflection * G4Point3D(-u, v, - w);
382 curSensorEdge[3] = sensorPlacement * reflection * G4Point3D(-u, v, + w);
383 //If we already have backward edges this is not the first module so we can apply the glue
384 if (lastSensorEdge.size()) {
385 //Check that the modules don't overlap in z
386 bool glueOK = true;
387 for (int i = 0; i < 4; ++i) glueOK &= curSensorEdge[i].z() <= lastSensorEdge[i].z();
388 if (!glueOK) {
389 B2WARNING("Cannot place Glue at sensor " + (string)sensorID +
390 " since it overlaps with the last module in z");
391 } else {
392 //Create Glue which spans from last sensor to this sensor
393 G4TessellatedSolid* solidTarget = new G4TessellatedSolid(m_prefix + ".Glue." + (string)sensorID);
394
395 //Face at end of last Sensor
396 solidTarget->AddFacet(new G4QuadrangularFacet(
397 curSensorEdge[3], curSensorEdge[2], curSensorEdge[1], curSensorEdge[0], ABSOLUTE));
398 //Face at begin of current Sensor
399 solidTarget->AddFacet(new G4QuadrangularFacet(
400 lastSensorEdge[0], lastSensorEdge[1], lastSensorEdge[2], lastSensorEdge[3], ABSOLUTE));
401
402 //Top faces
403 solidTarget->AddFacet(new G4TriangularFacet(
404 curSensorEdge[3], curSensorEdge[0], lastSensorEdge[0], ABSOLUTE));
405 solidTarget->AddFacet(new G4TriangularFacet(
406 lastSensorEdge[0], lastSensorEdge[3], curSensorEdge[3], ABSOLUTE));
407 //Bottom faces
408 solidTarget->AddFacet(new G4TriangularFacet(
409 curSensorEdge[1], curSensorEdge[2], lastSensorEdge[2], ABSOLUTE));
410 solidTarget->AddFacet(new G4TriangularFacet(
411 lastSensorEdge[2], lastSensorEdge[1], curSensorEdge[1], ABSOLUTE));
412 //Right faces
413 solidTarget->AddFacet(new G4TriangularFacet(
414 curSensorEdge[0], curSensorEdge[1], lastSensorEdge[1], ABSOLUTE));
415 solidTarget->AddFacet(new G4TriangularFacet(
416 lastSensorEdge[1], lastSensorEdge[0], curSensorEdge[0], ABSOLUTE));
417 //Left faces
418 solidTarget->AddFacet(new G4TriangularFacet(
419 curSensorEdge[2], curSensorEdge[3], lastSensorEdge[3], ABSOLUTE));
420 solidTarget->AddFacet(new G4TriangularFacet(
421 lastSensorEdge[3], lastSensorEdge[2], curSensorEdge[2], ABSOLUTE));
422
423 solidTarget->SetSolidClosed(true);
424
425 G4LogicalVolume* glue = new G4LogicalVolume(solidTarget, Materials::get(m_ladder.getGlueMaterial()),
426 m_prefix + ".Glue." + (string)sensorID);
427 setColor(*glue, "#097");
428 new G4PVPlacement(G4Transform3D(), glue, m_prefix + ".Glue." + (string)sensorID, volume, false, 1);
429 }
430 }
431 //Remember the backward edge of this sensor to be glued to.
432 lastSensorEdge.resize(4);
433 lastSensorEdge[0] = sensorPlacement * reflection * G4Point3D(u, -v, + w);
434 lastSensorEdge[1] = sensorPlacement * reflection * G4Point3D(u, -v, - w);
435 lastSensorEdge[2] = sensorPlacement * reflection * G4Point3D(-u, -v, - w);
436 lastSensorEdge[3] = sensorPlacement * reflection * G4Point3D(-u, -v, + w);
437 }
438 }
439
440 return ladderPlacement;
441 }

◆ 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
nameName of the component
componentsPath to components
vxdGeometryParVXD geometry parameters

Definition at line 534 of file GeoVXDCreator.cc.

535 {
536
537
538 //Check if component already exists
539 if (vxdGeometryPar.getComponentMap().find(name) != vxdGeometryPar.getComponentMap().end()) {
540 return; // nothing to do
541 }
542
543 //Component does not exist, so lets create a new one
544 string path = (boost::format("descendant::Component[@name='%1%']/") % name).str();
545 GearDir params(componentsDir, path);
546 if (!params) {
547 B2FATAL("Could not find definition for component " << name);
548 return;
549 }
550
551 VXDGeoComponentPar c(
552 params.getString("Material", vxdGeometryPar.getGlobalParams().getDefaultMaterial()),
553 params.getString("Color", ""),
554 params.getLength("width", 0),
555 params.getLength("width2", 0),
556 params.getLength("length", 0),
557 params.getLength("height", 0),
558 params.getAngle("angle", 0)
559 );
560
561 if (c.getWidth() <= 0 || c.getLength() <= 0 || c.getHeight() <= 0) {
562 B2DEBUG(100, "One dimension empty, using auto resize for component");
563 }
564
565 c.setSubComponents(getSubComponents(params));
566 readSubComponents(c.getSubComponents(), componentsDir, vxdGeometryPar);
567
568 if (vxdGeometryPar.getGlobalParams().getActiveChips() && params.exists("activeChipID")) {
569 int chipID = params.getInt("activeChipID");
570 vxdGeometryPar.getSensitiveChipIdMap()[name] = chipID;
571 }
572 vxdGeometryPar.getComponentMap()[name] = c;
573 vxdGeometryPar.getComponentInsertOder().push_back(name);
574 }

◆ 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
supportReference to the database containing the parameters
svdGeometryPar

Definition at line 508 of file GeoSVDCreator.cc.

509 {
510 if (!support) return;
511
512 for (const GearDir& params : support.getNodes("HalfShell/RotationSolid")) {
513
514 VXDRotationSolidPar rotationSolidPar(params.getString("Name", ""),
515 params.getString("Material", "Air"),
516 params.getString("Color", ""),
517 params.getAngle("minPhi", 0),
518 params.getAngle("maxPhi", 2 * M_PI),
519 (params.getNodes("InnerPoints/point").size() > 0)
520 );
521
522 for (const GearDir& point : params.getNodes("InnerPoints/point")) {
523 pair<double, double> ZXPoint(point.getLength("z"), point.getLength("x"));
524 rotationSolidPar.getInnerPoints().push_back(ZXPoint);
525 }
526 for (const GearDir& point : params.getNodes("OuterPoints/point")) {
527 pair<double, double> ZXPoint(point.getLength("z"), point.getLength("x"));
528 rotationSolidPar.getOuterPoints().push_back(ZXPoint);
529 }
530 svdGeometryPar.getRotationSolids().push_back(rotationSolidPar);
531 }
532 return;
533 }

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

577 {
578 string path = (boost::format("Ladder[@layer=%1%]/") % layer).str();
579 GearDir paramsLadder(components, path);
580 if (!paramsLadder) {
581 B2FATAL("Could not find Ladder definition for layer " << layer);
582 }
583
584 geoparameters.getLadderMap()[layer] = VXDGeoLadderPar(
585 layer,
586 paramsLadder.getLength("shift"),
587 paramsLadder.getLength("radius"),
588 paramsLadder.getAngle("slantedAngle", 0),
589 paramsLadder.getLength("slantedRadius", 0),
590 paramsLadder.getLength("Glue/oversize", 0),
591 paramsLadder.getString("Glue/Material", "")
592 );
593
594 for (const GearDir& sensorInfo : paramsLadder.getNodes("Sensor")) {
595
596 geoparameters.getLadderMap()[layer].addSensor(VXDGeoSensorPlacementPar(
597 sensorInfo.getInt("@id"),
598 sensorInfo.getString("@type"),
599 sensorInfo.getLength("."),
600 sensorInfo.getBool("@flipU", false),
601 sensorInfo.getBool("@flipV", false),
602 sensorInfo.getBool("@flipW", false)
603 ));
604 }
605 }

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

473 {
474 VxdID ladder(layerID, ladderID, 0);
475
476 // Read alignment for ladder
477 string path = (boost::format("Align[@component='%1%']/") % ladder).str();
478 GearDir params(GearDir(content, "Alignment/"), path);
479 if (!params) {
480 B2WARNING("Could not find alignment parameters for ladder " << ladder);
481 return;
482 }
483 vxdGeometryPar.getAlignmentMap()[ladder] = VXDAlignmentPar(params.getLength("du"),
484 params.getLength("dv"),
485 params.getLength("dw"),
486 params.getAngle("alpha"),
487 params.getAngle("beta"),
488 params.getAngle("gamma")
489 );
490
491
492
493 for (const VXDGeoSensorPlacementPar& p : vxdGeometryPar.getLadderMap()[layerID].getSensors()) {
494 VxdID sensorID(ladder);
495 sensorID.setSensorNumber(p.getSensorID());
496
497 std::map<string, VXDGeoSensorPar>::iterator it = vxdGeometryPar.getSensorMap().find(p.getSensorTypeID());
498 if (it == vxdGeometryPar.getSensorMap().end()) {
499 B2FATAL("Invalid SensorTypeID " << p.getSensorTypeID() << ", please check the definition of " << sensorID);
500 }
501
502 //Now create all the other components and place the Sensor
503 if (!vxdGeometryPar.getGlobalParams().getOnlyActiveMaterial()) {
504 VXDGeoSensorPar& s = it->second;
505 readSubComponents(s.getComponents(), GearDir(content, "Components/"), vxdGeometryPar);
506 }
507 // Read alignment for sensor
508 string pathSensor = (boost::format("Align[@component='%1%']/") % sensorID).str();
509 GearDir paramsSensor(GearDir(content, "Alignment/"), pathSensor);
510 if (!paramsSensor) {
511 B2WARNING("Could not find alignment parameters for sensorID " << sensorID);
512 return;
513 }
514 vxdGeometryPar.getAlignmentMap()[sensorID] = VXDAlignmentPar(paramsSensor.getLength("du"),
515 paramsSensor.getLength("dv"),
516 paramsSensor.getLength("dw"),
517 paramsSensor.getAngle("alpha"),
518 paramsSensor.getAngle("beta"),
519 paramsSensor.getAngle("gamma")
520 );
521 }
522 return;
523 }

◆ readLadderSupport()

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

Create support structure for a SVD Ladder.

Parameters
layerLayer ID to create the support for
supportReference to the database containing the parameters
svdGeometryPar

Definition at line 580 of file GeoSVDCreator.cc.

581 {
582 if (!support) return;
583
584 // Check if there are any support ribs defined for this layer. If not return empty assembly
585 GearDir params(support, (boost::format("SupportRibs/Layer[@id='%1%']") % layer).str());
586 if (params) {
587 svdGeometryPar.getSupportRibs()[layer] = SVDSupportRibsPar(support.getLength("SupportRibs/spacing"),
588 support.getLength("SupportRibs/height"),
589 support.getLength("SupportRibs/inner/width"),
590 support.getLength("SupportRibs/outer/width"),
591 support.getLength("SupportRibs/inner/tabLength"),
592 support.getString("SupportRibs/outer/Material"),
593 support.getString("SupportRibs/inner/Material"),
594 support.getString("SupportRibs/outer/Color"),
595 support.getString("SupportRibs/inner/Color"),
596 support.getString("SupportRibs/endmount/Material")
597 );
598
599 // Get values for the layer if available
600 if (params.exists("spacing")) svdGeometryPar.getSupportRibs()[layer].setSpacing(params.getLength("spacing"));
601 if (params.exists("height")) svdGeometryPar.getSupportRibs()[layer].setHeight(params.getLength("height"));
602
603 for (const GearDir& box : params.getNodes("box")) {
604 SVDSupportBoxPar boxPar(box.getAngle("theta"),
605 box.getLength("z"),
606 box.getLength("r"),
607 box.getLength("length")
608 );
609 svdGeometryPar.getSupportRibs()[layer].getBoxes().push_back(boxPar);
610 }
611
612 for (const GearDir& tab : params.getNodes("tab")) {
613 SVDSupportTabPar tabPar(tab.getAngle("theta"),
614 tab.getLength("z"),
615 tab.getLength("r")
616 );
617 svdGeometryPar.getSupportRibs()[layer].getTabs().push_back(tabPar);
618 }
619
620 for (const GearDir& endmount : params.getNodes("Endmount")) {
621 SVDEndmountPar mountPar(endmount.getString("@name"),
622 endmount.getLength("height"),
623 endmount.getLength("width"),
624 endmount.getLength("length"),
625 endmount.getLength("z"),
626 endmount.getLength("r")
627 );
628 svdGeometryPar.getSupportRibs()[layer].getEndmounts().push_back(mountPar);
629 }
630 }
631 return;
632 }

◆ readLayerSupport()

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

Create support structure for a SVD Layer.

Parameters
layerLayer ID to create the support for
supportReference to the database containing the parameters
svdGeometryPar

Definition at line 535 of file GeoSVDCreator.cc.

536 {
537 if (!support) return;
538
539 //Check if there are any endrings defined for this layer. If not we don't create any
540 GearDir endrings(support, (boost::format("Endrings/Layer[@id='%1%']") % layer).str());
541 if (endrings) {
542 svdGeometryPar.getEndrings()[layer] = SVDEndringsPar(support.getString("Endrings/Material"),
543 support.getLength("Endrings/length"),
544 support.getLength("Endrings/gapWidth"),
545 support.getLength("Endrings/baseThickness")
546 );
547
548 //Create the endrings
549 for (const GearDir& endring : endrings.getNodes("Endring")) {
550 SVDEndringsTypePar endringPar(endring.getString("@name"),
551 endring.getLength("z"),
552 endring.getLength("baseRadius"),
553 endring.getLength("innerRadius"),
554 endring.getLength("outerRadius"),
555 endring.getLength("horizontalBar"),
556 endring.getLength("verticalBar")
557 );
558 svdGeometryPar.getEndrings()[layer].getTypes().push_back(endringPar);
559 }
560 }
561
562 // Now let's add the cooling pipes to the Support
563 GearDir pipes(support, (boost::format("CoolingPipes/Layer[@id='%1%']") % layer).str());
564 if (pipes) {
565 svdGeometryPar.getCoolingPipes()[layer] = SVDCoolingPipesPar(support.getString("CoolingPipes/Material"),
566 support.getLength("CoolingPipes/outerDiameter"),
567 support.getLength("CoolingPipes/wallThickness"),
568 pipes.getInt("nPipes"),
569 pipes.getAngle("startPhi"),
570 pipes.getAngle("deltaPhi"),
571 pipes.getLength("radius"),
572 pipes.getLength("zstart"),
573 pipes.getLength("zend")
574 );
575 if (pipes.exists("deltaL")) svdGeometryPar.getCoolingPipes()[layer].setDeltaL(pipes.getLength("deltaL"));
576 }
577 return;
578 }

◆ readSensorInfo()

SVDSensorInfoPar * readSensorInfo ( const GearDir & sensor)

Read the sensor definitions from gearbox.

Parameters
sensorReference to the database containing the parameters

Definition at line 95 of file GeoSVDCreator.cc.

96 {
97
98 const double unit_pFcm = 1;
99 // This was 1000 * Unit::fC / Unit::V / Unit::cm; // pF/cm.
100 // We only use ratios of capacities, and this gives nicer numbers.
101 SVDSensorInfoPar* info = new SVDSensorInfoPar(
102 VxdID(0, 0, 0),
103 sensor.getLength("width"),
104 sensor.getLength("length"),
105 sensor.getLength("height"),
106 sensor.getInt("stripsU"),
107 sensor.getInt("stripsV"),
108 sensor.getLength("width2", 0)
109 );
110
111 info->setSensorParams(
112 sensor.getWithUnit("stripEdgeU"),
113 sensor.getWithUnit("stripEdgeV"),
114 sensor.getWithUnit("DepletionVoltage"),
115 sensor.getWithUnit("BiasVoltage"),
116 sensor.getDouble("BackplaneCapacitanceU") * unit_pFcm,
117 sensor.getDouble("InterstripCapacitanceU") * unit_pFcm,
118 sensor.getDouble("CouplingCapacitanceU") * unit_pFcm,
119 sensor.getDouble("BackplaneCapacitanceV") * unit_pFcm,
120 sensor.getDouble("InterstripCapacitanceV") * unit_pFcm,
121 sensor.getDouble("CouplingCapacitanceV") * unit_pFcm,
122 sensor.getWithUnit("ADUEquivalentU"),
123 sensor.getWithUnit("ADUEquivalentV"),
124 sensor.getWithUnit("ElectronicNoiseU"),
125 sensor.getWithUnit("ElectronicNoiseV"),
126 sensor.getWithUnit("ADUEquivalentSbwU", 0),
127 sensor.getWithUnit("ADUEquivalentSbwV", 0),
128 sensor.getWithUnit("ElectronicNoiseSbwU", 0),
129 sensor.getWithUnit("ElectronicNoiseSbwV", 0)
130 );
131
132 return info;
133 }

◆ 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
placementscontainer holding names of all components to be cached
componentsDirPath to Gearbox where parameters are to be found
vxdGeometryPar

Definition at line 525 of file GeoVXDCreator.cc.

527 {
528 for (const VXDGeoPlacementPar& p : placements) {
529 readComponent(p.getName(), componentsDir, vxdGeometryPar);
530 }
531 return;
532 }

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

444 {
445 const VXDGeoLadderPar& paramsLadder = parameters.getLadder(layer);
446
447 m_ladder = VXDGeoLadder(
448 layer,
449 paramsLadder.getShift() / Unit::mm,
450 paramsLadder.getRadius() / Unit::mm,
451 paramsLadder.getSlantedAngle(),
452 paramsLadder.getSlantedRadius() / Unit::mm,
453 paramsLadder.getGlueSize() / Unit::mm,
454 paramsLadder.getGlueMaterial()
455 );
456
457
458 for (const VXDGeoSensorPlacementPar& sensorInfo : paramsLadder.getSensors()) {
459 m_ladder.addSensor(VXDGeoSensorPlacement(
460 sensorInfo.getSensorID(),
461 sensorInfo.getSensorTypeID(),
462 sensorInfo.getZ() / Unit::mm,
463 sensorInfo.getFlipU(),
464 sensorInfo.getFlipV(),
465 sensorInfo.getFlipW()
466 ));
467 }
468 }

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)}}
}
Class to uniquely identify a any structure of the PXD and SVD.
Definition VxdID.h:32

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

Definition at line 224 of file GeoVXDCreator.h.

224 {
225 {{"PXD.Ying"}, {Belle2::VxdID(1, 0, 0, 1)}},
226 {{"PXD.Yang"}, {Belle2::VxdID(1, 0, 0, 2)}},
227 {{"SVD.Pat"}, {Belle2::VxdID(3, 0, 0, 1)}},
228 {{"SVD.Mat"}, {Belle2::VxdID(3, 0, 0, 2)}}
229 };

◆ 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 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 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: