Belle II Software  release-08-01-10
Public Member Functions | Protected Member Functions | Protected Attributes | List of all members
PlumeCreator Class Reference

The creator for the PLUME geometry. More...

#include <PlumeCreator.h>

Inheritance diagram for PlumeCreator:
Inheritance graph
[legend]
Collaboration diagram for PlumeCreator:
Collaboration graph
[legend]

Public Member Functions

 PlumeCreator ()
 Constructor.
 
virtual ~PlumeCreator ()
 Destructor.
 
virtual void create (const GearDir &content, G4LogicalVolume &topVolume, geometry::GeometryTypes type)
 Creation of the detector geometry from Gearbox (XML). More...
 
 BELLE2_DEFINE_EXCEPTION (DBNotImplemented, "Cannot create geometry from Database.")
 Exception that will be thrown in createFromDB if member is not yet implemented by creator.
 
virtual void createFromDB (const std::string &name, G4LogicalVolume &topVolume, GeometryTypes type)
 Function to create the geometry from the Database. More...
 
virtual void createPayloads (const GearDir &content, const IntervalOfValidity &iov)
 Function to create the geometry database. More...
 

Protected Member Functions

G4AssemblyVolume * buildSupport1 ()
 Volume of support1.
 
G4AssemblyVolume * buildSupport2 ()
 Volume of support2.
 
G4AssemblyVolume * buildSupport3 ()
 Volume of support3.
 
G4AssemblyVolume * buildSupport4 ()
 Volume of support4.
 

Protected Attributes

SensitiveDetector * m_sensitive
 SensitiveDetector PLUME.
 

Detailed Description

The creator for the PLUME geometry.

Definition at line 28 of file PlumeCreator.h.

Member Function Documentation

◆ create()

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

Creation of the detector geometry from Gearbox (XML).

Parameters
[in]contentXML data directory.
[in]topVolumeGeant world volume.
[in]typeGeometry type.

Implements CreatorBase.

Definition at line 62 of file PlumeCreator.cc.

63  {
64 
65  m_sensitive = new SensitiveDetector();
66 
67  //color attributions
68  G4VisAttributes* FoamVisAtt = new G4VisAttributes(G4Colour::Blue());
69  G4VisAttributes* KaptonVisAtt = new G4VisAttributes(G4Colour::Red());
70  G4VisAttributes* GlueVisAtt = new G4VisAttributes(G4Colour::White());
71  G4VisAttributes* MetalVisAtt = new G4VisAttributes(G4Colour::Gray());
72  G4VisAttributes* SubstrateVisAtt = new G4VisAttributes(G4Colour::Green());
73  G4VisAttributes* MetalizedVisAtt = new G4VisAttributes(G4Colour::Cyan());
74  G4VisAttributes* EpitaxialVisAtt = new G4VisAttributes(G4Colour(1.0, 1.0, 0.0)); //yellow
75 
76  //lets get the stepsize parameter with a default value of 5 µm
77  double stepSize = content.getLength("stepSize", 5 * CLHEP::um);
78 
79  int LadderID = 0;
80 
81  GearDir activeParams(content, "Ladder");
82  G4double SensorLengthX = (activeParams.getInt("nPixelsX") * activeParams.getLength("pitchX")) * CLHEP::cm;
83  G4double SensorLengthY = (activeParams.getInt("nPixelsY") * activeParams.getLength("pitchY")) * CLHEP::cm;
84 
85  G4double AirGap = activeParams.getLength("AirGap") * CLHEP::cm;
86 
87  G4double SubstrateThickness = activeParams.getLength("SubstrateThickness") * CLHEP::cm;
88  G4double EpitaxialThickness = activeParams.getLength("EpitaxialThickness") * CLHEP::cm;
89  G4double MetalThickness = activeParams.getLength("MetalThickness") * CLHEP::cm;
90  G4double GlueThickness = activeParams.getLength("GlueThickness") * CLHEP::cm;
91  G4double KaptonThickness = activeParams.getLength("KaptonThickness") * CLHEP::cm;
92  G4double AluminiumThickness = activeParams.getLength("AluminiumThickness") * CLHEP::cm;
93  G4double foamlen = activeParams.getLength("Foam/length") * CLHEP::cm;
94  G4double foamwid = activeParams.getLength("Foam/width") * CLHEP::cm;
95  G4double foamthick = activeParams.getLength("Foam/thickness") * CLHEP::cm;
96  G4double foamZ = activeParams.getLength("Foam/zPosition") * CLHEP::cm;
97  G4double foamY = activeParams.getLength("Foam/yShift") * CLHEP::cm;
98  G4double flexlen = activeParams.getLength("Flex/length") * CLHEP::cm;
99  G4double flexwid = activeParams.getLength("Flex/width") * CLHEP::cm;
100  G4double flexZ = activeParams.getLength("Flex/zPosition") * CLHEP::cm;
101  G4double allen1 = activeParams.getLength("AlBat/length1") * CLHEP::cm;
102  G4double allen2 = activeParams.getLength("AlBat/length2") * CLHEP::cm;
103  G4double allen3 = activeParams.getLength("AlBat/length3") * CLHEP::cm;
104  G4double alwid = activeParams.getLength("AlBat/width") * CLHEP::cm;
105  G4double althick1 = activeParams.getLength("AlBat/thickness1") * CLHEP::cm;
106  G4double althick2 = activeParams.getLength("AlBat/thickness2") * CLHEP::cm;
107  G4double althick3 = activeParams.getLength("AlBat/thickness3") * CLHEP::cm;
108 
109  // old geometry
110  /*
111  G4double SensorDistance = activeParams.getLength("SensorDistance") * CLHEP::cm;
112  G4double dx_foam = SensorLengthY / 2. + 0.15 * CLHEP::cm ;
113  G4double dy_foam = (SensorLengthX * 6. + 5.*SensorDistance) / 2.;
114  G4double DistanceFromFoamCenter = 0.1 * CLHEP::cm;
115  //Envelop dimension Thickness not divided by 2 to take into account of the 2 sides of foam
116  G4double dz_env = DistanceFromFoamCenter + KaptonThickness + GlueThickness +
117  AluminiumThickness + SubstrateThickness + EpitaxialThickness +
118  MetalThickness + 6. * AirGap;
119  G4Box* s_env = new G4Box("s_env", dx_foam, dy_foam, dz_env);
120  G4LogicalVolume* l_env = new G4LogicalVolume(s_env, geometry::Materials::get("Al"), "l_env");
121  G4Transform3D transformt = G4RotateZ3D(135. / 180 * M_PI - M_PI / 2.0) * G4Translate3D(0, 61,
122  42.2) * G4RotateX3D(- M_PI / 2.0 - 178. / 180 * M_PI);
123  new G4PVPlacement(transformt, l_env, "p_env1", &topVolume, false, 1);
124  transformt = G4RotateZ3D(225. / 180 * M_PI - M_PI / 2.0) * G4Translate3D(0, 84,
125  -21.8) * G4RotateX3D(- M_PI / 2.0 - 20. / 180 * M_PI);
126  new G4PVPlacement(transformt, l_env, "p_env2", &topVolume, false, 1);*/
127  //---------------
128 
129  G4double dz_ladder = foamthick / 2. + KaptonThickness + GlueThickness +
130  AluminiumThickness + 3. * AirGap;
131  G4double dz_sensor = (SubstrateThickness + EpitaxialThickness +
132  MetalThickness + 2. * AirGap) / 2.;
133 
134  G4double fullLength = allen1 + allen2 + allen3 - (foamZ - foamlen / 2.);
135  double zshift = fullLength / 2. - (allen1 + allen2 + allen3);
136 
137  // Create support ladder
138  G4AssemblyVolume* support = new G4AssemblyVolume();
139  G4Transform3D transl;;
140 
141  //create foam layer
142  G4Box* s_foam = new G4Box("s_foam", foamlen / 2., foamwid / 2., foamthick / 2.);
143  G4LogicalVolume* l_foam = new G4LogicalVolume(s_foam, geometry::Materials::get("SiC"), "PLUME.l_foam");
144  transl = G4Translate3D(foamZ + zshift, foamY, 0);
145  support->AddPlacedVolume(l_foam, transl);
146 
147  //create glue layers
148  G4Box* s_glue = new G4Box("s_glue", flexlen / 2., foamwid / 2., GlueThickness / 2.);
149  G4LogicalVolume* l_glue = new G4LogicalVolume(s_glue, geometry::Materials::get("Glue"), "PLUME.l_glue");
150  G4double r_glue = foamthick / 2. + AirGap + GlueThickness / 2.;
151  transl = G4Translate3D(flexZ + zshift, foamY, -r_glue);
152  support->AddPlacedVolume(l_glue, transl);
153  transl = G4Translate3D(flexZ + zshift, foamY, r_glue);
154  support->AddPlacedVolume(l_glue, transl);
155 
156  //create Kapton layers
157  G4Box* s_kapton = new G4Box("s_kapton", flexlen / 2., flexwid / 2., KaptonThickness / 2.);
158  G4LogicalVolume* l_kapton = new G4LogicalVolume(s_kapton, geometry::Materials::get("Kapton"), "PLUME.l_kapton");
159  G4double r_Kapton = r_glue + AirGap + (GlueThickness + KaptonThickness) / 2.;
160  transl = G4Translate3D(flexZ + zshift, 0, -r_Kapton);
161  support->AddPlacedVolume(l_kapton, transl);
162  transl = G4Translate3D(flexZ + zshift, 0, r_Kapton);
163  support->AddPlacedVolume(l_kapton, transl);
164 
165  //create metal layers
166  G4Box* s_metal = new G4Box("s_metal", flexlen / 2., flexwid / 2., AluminiumThickness / 2.);
167  G4LogicalVolume* l_metal = new G4LogicalVolume(s_metal, geometry::Materials::get("Al"), "PLUME.l_metal");
168  G4double r_metal = r_Kapton + AirGap + (KaptonThickness + AluminiumThickness) / 2.;
169  transl = G4Translate3D(flexZ + zshift, 0, -r_metal);
170  support->AddPlacedVolume(l_metal, transl);
171  transl = G4Translate3D(flexZ + zshift, 0, r_metal);
172  support->AddPlacedVolume(l_metal, transl);
173 
174  //create aluminum bat
175  G4Box* s_bat1p = new G4Box("s_bat1p", allen1 / 2., alwid / 2., althick1 / 2.);
176  double incut = foamZ + foamlen / 2.;
177  G4Box* s_bat1t = new G4Box("s_bat1t", incut, foamwid / 2., althick1 + 0.2 / 2.);
178 
179  G4Transform3D tt = G4Translate3D(-allen1 / 2., foamY, 0);
180  G4SubtractionSolid* s_bat1 = new G4SubtractionSolid("s_bat1", s_bat1p, s_bat1t, tt);
181  G4Box* s_bat2 = new G4Box("s_bat2", allen2 / 2., alwid / 2., althick2 / 2.);
182  G4Box* s_bat3 = new G4Box("s_bat3", allen3 / 2., alwid / 2., althick3 / 2.);
183  G4LogicalVolume* l_bat1 = new G4LogicalVolume(s_bat1, geometry::Materials::get("Al"), "PLUME.l_bat1");
184  G4LogicalVolume* l_bat2 = new G4LogicalVolume(s_bat2, geometry::Materials::get("Al"), "PLUME.l_bat2");
185  G4LogicalVolume* l_bat3 = new G4LogicalVolume(s_bat3, geometry::Materials::get("Al"), "PLUME.l_bat3");
186  transl = G4Translate3D(allen1 / 2. + zshift, 0, 0);
187  support->AddPlacedVolume(l_bat1, transl);
188  transl = G4Translate3D(allen1 + allen2 / 2. + zshift, 0, 0);
189  support->AddPlacedVolume(l_bat2, transl);
190  transl = G4Translate3D(allen1 + allen2 + allen3 / 2. + zshift, 0, 0);
191  support->AddPlacedVolume(l_bat3, transl);
192 
193  l_foam->SetVisAttributes(FoamVisAtt);
194  l_kapton->SetVisAttributes(KaptonVisAtt);
195  l_glue->SetVisAttributes(GlueVisAtt);
196  l_metal->SetVisAttributes(MetalVisAtt);
197 
198 
199  G4String symbol, name;
200  G4double a, zz;
201  G4double density;
202  G4int ncomponents;
203  a = 1.01 * CLHEP::g / CLHEP::mole;
204  G4Element* elH = new G4Element(name = "Hydrogen", symbol = "H", zz = 1., a);
205  a = 12.01 * CLHEP::g / CLHEP::mole;
206  G4Element* elC = new G4Element(name = "Carbon", symbol = "C", zz = 6., a);
207  a = 16.00 * CLHEP::g / CLHEP::mole;
208  G4Element* elO = new G4Element(name = "Oxygen", symbol = "O", zz = 8., a);
209  density = 1.31 * CLHEP::g / CLHEP::cm3;
210  G4Material* peekMat = new G4Material(name = "plumePeek", density, ncomponents = 3);
211  peekMat->AddElementByMassFraction(elC, 0.76);
212  peekMat->AddElementByMassFraction(elH, 0.08);
213  peekMat->AddElementByMassFraction(elO, 0.16);
214  density = 1.5 * CLHEP::g / CLHEP::cm3;
215  G4Material* carbMat = new G4Material(name = "plumeCarb", density, ncomponents = 1);
216  carbMat->AddElementByMassFraction(elC, 1.0);
217 
218  G4Box* s_sensor = new G4Box("s_sensor", SensorLengthX / 2., SensorLengthY / 2., dz_sensor);
219  G4LogicalVolume* l_sensor = new G4LogicalVolume(s_sensor, geometry::Materials::get("G4_AIR"), "PLUME.l_sensor");
220 
221  // Substrate Layer //
222  G4Box* s_substrate = new G4Box("s_substrate", SensorLengthX / 2., SensorLengthY / 2., SubstrateThickness / 2.);
223  G4LogicalVolume* l_substrate = new G4LogicalVolume(s_substrate, geometry::Materials::get("Silicon"), "PLUME.l_substrate");
224  new G4PVPlacement(0, G4ThreeVector(0, 0, -dz_sensor + SubstrateThickness / 2.), l_substrate, "p_substrate", l_sensor, false, 1);
225 
226  // Epitaxial Layer //
227  G4Box* s_epitaxial = new G4Box("s_epitaxial", SensorLengthX / 2., SensorLengthY / 2., EpitaxialThickness / 2.);
228  G4LogicalVolume* l_epitaxial = new G4LogicalVolume(s_epitaxial, geometry::Materials::get("Silicon"), "PLUME.l_epitaxial", 0,
229  m_sensitive);
230  new G4PVPlacement(0, G4ThreeVector(0, 0, -dz_sensor + AirGap + SubstrateThickness + EpitaxialThickness / 2.), l_epitaxial,
231  "p_epitaxial", l_sensor, false, 1);
232  // Metalized Layer //
233  G4Box* s_metalized = new G4Box("s_metalized", SensorLengthX / 2., SensorLengthY / 2., MetalThickness / 2.);
234  G4LogicalVolume* l_metalized = new G4LogicalVolume(s_metalized, geometry::Materials::get("SiO2Al"), "PLUME.l_metalized");
235  new G4PVPlacement(0, G4ThreeVector(0, 0, -dz_sensor + 2 * AirGap + SubstrateThickness + EpitaxialThickness + MetalThickness / 2.),
236  l_metalized, "p_metalized", l_sensor, false, 1);
237 
238  // temporary
239  /*G4LogicalVolume* l_sensorMir = new G4LogicalVolume(s_sensor, geometry::Materials::get("G4_AIR"), "l_sensorMir");
240  new G4PVPlacement(0, G4ThreeVector(0, 0, -dz_sensor + MetalThickness / 2.), l_metalized, "p_metalized", l_sensorMir, false, 1);
241  new G4PVPlacement(0, G4ThreeVector(0, 0, -dz_sensor + MetalThickness + AirGap + EpitaxialThickness / 2.), l_epitaxial,
242  "p_epitaxial", l_sensorMir, false, 1);
243  new G4PVPlacement(0, G4ThreeVector(0, 0, -dz_sensor + MetalThickness + 2 * AirGap + EpitaxialThickness + SubstrateThickness / 2.),
244  l_substrate, "p_substrate", l_sensorMir, false, 1);
245  */
246 
247 
248  l_epitaxial->SetUserLimits(new G4UserLimits(stepSize));
249  l_substrate->SetVisAttributes(SubstrateVisAtt);
250  l_epitaxial->SetVisAttributes(EpitaxialVisAtt);
251  l_metalized->SetVisAttributes(MetalizedVisAtt);
252 
253  // place 12 sensors on support ladder
254  double zSens = dz_ladder + dz_sensor + AirGap;
255  G4RotationMatrix ra;
256  G4ThreeVector Ta(0, 0, 0);
257  G4Transform3D tra(ra, Ta);
258 
259  // build cooling tubes
260  GearDir pipeParams(content, "CoolingPipes");
261  double pipeLen = pipeParams.getLength("length") * CLHEP::cm;
262  double pipeInR = pipeParams.getLength("rIn") * CLHEP::cm;
263  double pipeOutR = pipeParams.getLength("rOut") * CLHEP::cm;
264  G4Tubs* pipe_s = new G4Tubs("pipe_s", pipeInR, pipeOutR, pipeLen / 2., 0, 2 * M_PI);
265 
266  G4LogicalVolume* pipe_l = new G4LogicalVolume(pipe_s, carbMat, "PLUME.l_pipe");
267  double pipeX = pipeParams.getLength("x") * CLHEP::cm;
268  double pipeY = pipeParams.getLength("y") * CLHEP::cm;
269  double pipeZ = pipeParams.getLength("z") * CLHEP::cm;
270  G4double alphaPipe = pipeParams.getAngle("alpha");
271 
272  //GearDir alignPars;
273  G4Box* s_sensors = new G4Box("s_sensors", flexlen / 2., flexwid / 2., dz_sensor + AirGap);
274 
275  for (auto ladder : content.getNodes("Placements/Ladder")) {
276 
277  std::string id = ladder.getString("@id");
278 
279  G4AssemblyVolume* assemblyLadder = new G4AssemblyVolume();
280  assemblyLadder->AddPlacedAssembly(support, tra);
281 
282  for (auto pars : content.getNodes("SensorAlignment/ladder")) {
283  if (pars.getString("@id") == id) {
284  GearDir alignPars(pars);
285 
286  for (auto sidePars : alignPars.getNodes("side")) {
287  unsigned mirror = 0;
288 
289  G4Transform3D transformSens;
290  if (sidePars.getString("@id") == "mirror") mirror = 1;
291 
292  G4LogicalVolume* l_sensors = new G4LogicalVolume(s_sensors, geometry::Materials::get("G4_AIR"), "PLUME.l_sensors");
293 
294  for (auto sensorPars : sidePars.getNodes("sensor")) {
295  double x = sensorPars.getLength("x") * CLHEP::cm + zshift;
296  double y = sensorPars.getLength("y") * CLHEP::cm;
297  int ids = sensorPars.getInt("id");
298  y = mirror ? -y : y;
299  y -= alwid / 2.;
300  double alpha1 = sensorPars.getAngle("alpha") * CLHEP::rad;
301  if (mirror) transformSens = G4Translate3D(x, y,
302  0) * G4RotateZ3D(alpha1) * G4RotateX3D(M_PI); // think if this is correct, rotation and pos shift for mirror side
303  else transformSens = G4Translate3D(x, y, 0) * G4RotateZ3D(-alpha1);
304 
305  new G4PVPlacement(transformSens, l_sensor, "p_sensor", l_sensors, true,
306  (ids + mirror * 6 + LadderID * 12));
307  }
308  transformSens = G4Translate3D(0, 0, mirror ? -zSens : zSens);
309  assemblyLadder->AddPlacedVolume(l_sensors, transformSens);
310  }
311  }
312  }
313 
314 
315 
316  G4double thetaZ = ladder.getAngle("ThetaZ");
317  G4double r = ladder.getLength("r_plume") * CLHEP::cm - zshift * sin(thetaZ);
318  G4double z = ladder.getLength("z_plume") * CLHEP::cm - zshift * cos(thetaZ);
319  G4double phi = ladder.getAngle("Phi");
320  G4double alpha = ladder.getAngle("Alpha");
321 
322 
323  // place cooling pipes
324  G4Transform3D transformPipe = G4Translate3D(pipeZ + zshift, pipeY, pipeX) * G4RotateZ3D(alphaPipe) * G4RotateY3D(+ M_PI / 2.);
325  assemblyLadder->AddPlacedVolume(pipe_l, transformPipe);
326  transformPipe = G4Translate3D(pipeZ + zshift
327  , pipeY, -pipeX) * G4RotateZ3D(alphaPipe) * G4RotateY3D(+ M_PI / 2.);
328  assemblyLadder->AddPlacedVolume(pipe_l, transformPipe);
329 
330 
331  G4Transform3D transform1;
332  if (LadderID == 1) {
333  G4AssemblyVolume* sup1 = buildSupport1();
334  G4AssemblyVolume* sup2 = buildSupport2();
335  transform1 = G4Translate3D(-fullLength / 2. - 18.7, 0., 1.2) * G4RotateY3D(thetaZ) * G4RotateX3D(M_PI / 2.) * G4RotateY3D(M_PI);
336  assemblyLadder->AddPlacedAssembly(sup1, transform1);
337  transform1 = G4Translate3D(fullLength / 2. + 19.5, 0, -2.6) * G4RotateY3D(thetaZ) * G4RotateX3D(M_PI / 2.);
338  assemblyLadder->AddPlacedAssembly(sup2, transform1);
339  }
340 
341  if (LadderID == 0) {
342  G4AssemblyVolume* sup1 = buildSupport3();
343  G4AssemblyVolume* sup2 = buildSupport4();
344  transform1 = G4Translate3D(fullLength / 2. + 5, 0,
345  7.8) * G4RotateY3D(-thetaZ) * G4RotateZ3D(M_PI / 2.) * G4RotateX3D(M_PI / 2.) * G4RotateY3D(M_PI / 2.);
346  assemblyLadder->AddPlacedAssembly(sup1, transform1);
347  transform1 = G4Translate3D(-fullLength / 2. - 31, 0.,
348  -21.7) * G4RotateY3D(-thetaZ) * G4RotateZ3D(M_PI / 2.) * G4RotateX3D(-M_PI / 2.) * G4RotateY3D(M_PI);
349  assemblyLadder->AddPlacedAssembly(sup2, transform1);
350  }
351 
352  G4Transform3D transform = G4RotateZ3D(phi) * G4Translate3D(r, 0,
353  z) * G4RotateY3D(thetaZ) * G4RotateZ3D(alpha + M_PI) * G4RotateY3D(- M_PI / 2.0);
354 
355  assemblyLadder->MakeImprint(&topVolume, transform);
356 
357  LadderID += 1;
358 
359  }
360 
361  }
Belle2::geometry::Materials::get
static G4Material * get(const std::string &name)
Find given material.
Definition: Materials.h:63
Belle2::plume::PlumeCreator::buildSupport1
G4AssemblyVolume * buildSupport1()
Volume of support1.
Definition: PlumeCreator.cc:364
Belle2::plume::PlumeCreator::buildSupport2
G4AssemblyVolume * buildSupport2()
Volume of support2.
Definition: PlumeCreator.cc:411
Belle2::plume::PlumeCreator::buildSupport4
G4AssemblyVolume * buildSupport4()
Volume of support4.
Definition: PlumeCreator.cc:501
Belle2::plume::PlumeCreator::buildSupport3
G4AssemblyVolume * buildSupport3()
Volume of support3.
Definition: PlumeCreator.cc:447
Belle2::plume::PlumeCreator::m_sensitive
SensitiveDetector * m_sensitive
SensitiveDetector PLUME.
Definition: PlumeCreator.h:47
Belle2::PXD::SensitiveDetector
VXD::SensitiveDetector< PXDSimHit, PXDTrueHit > SensitiveDetector
The PXD Sensitive Detector class.
Definition: SensitiveDetector.h:23

◆ createFromDB()

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

Function to create the geometry from the Database.

Parameters
namename of the component in the database, could be used to disambiguate multiple components created with the same creator
topVolumeTop volume in which the geometry has to be placed
typeType of geometry to be build

Reimplemented in GeoVXDServiceCreator, GeoHeavyMetalShieldCreator, GeoTOPCreator, GeoSVDCreator, GeoSTRCreator, GeoServiceMaterialCreator, GeoCOILCreator, GeoPXDCreator, GeoKLMCreator, GeoEKLMCreator, GeoBKLMCreator, GeoFarBeamLineCreator, GeoCryostatCreator, GeoBeamPipeCreator, MyDBCreator, GeoECLCreator, GeoCDCCreatorReducedCDC, GeoCDCCreator, BeamabortCreator, GeoARICHCreator, and GeoMagneticField.

Definition at line 17 of file CreatorBase.cc.

◆ createPayloads()

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

Function to create the geometry database.

This function should be implemented to convert Gearbox parameters to one ore more database payloads

Parameters
contentGearDir pointing to the parameters which should be used for construction
iovinterval of validity to use when generating payloads

Reimplemented in GeoVXDServiceCreator, GeoHeavyMetalShieldCreator, GeoTOPCreator, GeoSVDCreator, GeoSTRCreator, GeoServiceMaterialCreator, GeoCOILCreator, GeoPXDCreator, GeoKLMCreator, GeoEKLMCreator, GeoBKLMCreator, GeoFarBeamLineCreator, GeoCryostatCreator, GeoBeamPipeCreator, MyDBCreator, GeoMagneticField, GeoECLCreator, GeoCDCCreatorReducedCDC, GeoCDCCreator, BeamabortCreator, and GeoARICHCreator.

Definition at line 24 of file CreatorBase.cc.

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