Belle II Software  release-06-01-15
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  G4double fractionmass;
204  a = 1.01 * CLHEP::g / CLHEP::mole;
205  G4Element* elH = new G4Element(name = "Hydrogen", symbol = "H" , zz = 1., a);
206  a = 12.01 * CLHEP::g / CLHEP::mole;
207  G4Element* elC = new G4Element(name = "Carbon" , symbol = "C" , zz = 6., a);
208  a = 16.00 * CLHEP::g / CLHEP::mole;
209  G4Element* elO = new G4Element(name = "Oxygen" , symbol = "O" , zz = 8., a);
210  density = 1.31 * CLHEP::g / CLHEP::cm3;
211  G4Material* peekMat = new G4Material(name = "plumePeek" , density, ncomponents = 3);
212  peekMat->AddElement(elC, fractionmass = 0.76);
213  peekMat->AddElement(elH, fractionmass = 0.08);
214  peekMat->AddElement(elO, fractionmass = 0.16);
215  density = 1.5 * CLHEP::g / CLHEP::cm3;
216  G4Material* carbMat = new G4Material(name = "plumeCarb" , density, ncomponents = 1);
217  carbMat->AddElement(elC, fractionmass = 1.0);
218 
219  G4Box* s_sensor = new G4Box("s_sensor", SensorLengthX / 2., SensorLengthY / 2., dz_sensor);
220  G4LogicalVolume* l_sensor = new G4LogicalVolume(s_sensor, geometry::Materials::get("G4_AIR"), "PLUME.l_sensor");
221 
222  // Substrate Layer //
223  G4Box* s_substrate = new G4Box("s_substrate", SensorLengthX / 2. , SensorLengthY / 2. , SubstrateThickness / 2.);
224  G4LogicalVolume* l_substrate = new G4LogicalVolume(s_substrate, geometry::Materials::get("Silicon"), "PLUME.l_substrate");
225  new G4PVPlacement(0, G4ThreeVector(0, 0, -dz_sensor + SubstrateThickness / 2.), l_substrate, "p_substrate", l_sensor, false, 1);
226 
227  // Epitaxial Layer //
228  G4Box* s_epitaxial = new G4Box("s_epitaxial", SensorLengthX / 2. , SensorLengthY / 2., EpitaxialThickness / 2.);
229  G4LogicalVolume* l_epitaxial = new G4LogicalVolume(s_epitaxial, geometry::Materials::get("Silicon"), "PLUME.l_epitaxial", 0,
230  m_sensitive);
231  new G4PVPlacement(0, G4ThreeVector(0, 0, -dz_sensor + AirGap + SubstrateThickness + EpitaxialThickness / 2.), l_epitaxial,
232  "p_epitaxial", l_sensor, false, 1);
233  // Metalized Layer //
234  G4Box* s_metalized = new G4Box("s_metalized", SensorLengthX / 2. , SensorLengthY / 2. , MetalThickness / 2.);
235  G4LogicalVolume* l_metalized = new G4LogicalVolume(s_metalized, geometry::Materials::get("SiO2Al"), "PLUME.l_metalized");
236  new G4PVPlacement(0, G4ThreeVector(0, 0, -dz_sensor + 2 * AirGap + SubstrateThickness + EpitaxialThickness + MetalThickness / 2.),
237  l_metalized, "p_metalized", l_sensor, false, 1);
238 
239  // temporary
240  /*G4LogicalVolume* l_sensorMir = new G4LogicalVolume(s_sensor, geometry::Materials::get("G4_AIR"), "l_sensorMir");
241  new G4PVPlacement(0, G4ThreeVector(0, 0, -dz_sensor + MetalThickness / 2.), l_metalized, "p_metalized", l_sensorMir, false, 1);
242  new G4PVPlacement(0, G4ThreeVector(0, 0, -dz_sensor + MetalThickness + AirGap + EpitaxialThickness / 2.), l_epitaxial,
243  "p_epitaxial", l_sensorMir, false, 1);
244  new G4PVPlacement(0, G4ThreeVector(0, 0, -dz_sensor + MetalThickness + 2 * AirGap + EpitaxialThickness + SubstrateThickness / 2.),
245  l_substrate, "p_substrate", l_sensorMir, false, 1);
246  */
247 
248 
249  l_epitaxial->SetUserLimits(new G4UserLimits(stepSize));
250  l_substrate->SetVisAttributes(SubstrateVisAtt);
251  l_epitaxial->SetVisAttributes(EpitaxialVisAtt);
252  l_metalized->SetVisAttributes(MetalizedVisAtt);
253 
254  // place 12 sensors on support ladder
255  double zSens = dz_ladder + dz_sensor + AirGap;
256  G4RotationMatrix ra;
257  G4ThreeVector Ta(0, 0, 0);
258  G4Transform3D tra(ra, Ta);
259 
260  // build cooling tubes
261  GearDir pipeParams(content, "CoolingPipes");
262  double pipeLen = pipeParams.getLength("length") * CLHEP::cm;
263  double pipeInR = pipeParams.getLength("rIn") * CLHEP::cm;
264  double pipeOutR = pipeParams.getLength("rOut") * CLHEP::cm;
265  G4Tubs* pipe_s = new G4Tubs("pipe_s", pipeInR, pipeOutR, pipeLen / 2., 0, 2 * M_PI);
266 
267  G4LogicalVolume* pipe_l = new G4LogicalVolume(pipe_s, carbMat, "PLUME.l_pipe");
268  double pipeX = pipeParams.getLength("x") * CLHEP::cm;
269  double pipeY = pipeParams.getLength("y") * CLHEP::cm;
270  double pipeZ = pipeParams.getLength("z") * CLHEP::cm;
271  G4double alphaPipe = pipeParams.getAngle("alpha");
272 
273  //GearDir alignPars;
274  G4Box* s_sensors = new G4Box("s_sensors", flexlen / 2., flexwid / 2., dz_sensor + AirGap);
275 
276  for (auto ladder : content.getNodes("Placements/Ladder")) {
277 
278  std::string id = ladder.getString("@id");
279 
280  G4AssemblyVolume* assemblyLadder = new G4AssemblyVolume();
281  assemblyLadder->AddPlacedAssembly(support, tra);
282 
283  for (auto pars : content.getNodes("SensorAlignment/ladder")) {
284  if (pars.getString("@id") == id) {
285  GearDir alignPars(pars);
286 
287  for (auto sidePars : alignPars.getNodes("side")) {
288  unsigned mirror = 0;
289 
290  G4Transform3D transformSens;
291  if (sidePars.getString("@id") == "mirror") mirror = 1;
292 
293  G4LogicalVolume* l_sensors = new G4LogicalVolume(s_sensors, geometry::Materials::get("G4_AIR"), "PLUME.l_sensors");
294 
295  for (auto sensorPars : sidePars.getNodes("sensor")) {
296  double x = sensorPars.getLength("x") * CLHEP::cm + zshift;
297  double y = sensorPars.getLength("y") * CLHEP::cm;
298  int ids = sensorPars.getInt("id");
299  y = mirror ? -y : y;
300  y -= alwid / 2.;
301  double alpha1 = sensorPars.getAngle("alpha") * CLHEP::rad;
302  if (mirror) transformSens = G4Translate3D(x, y,
303  0) * G4RotateZ3D(alpha1) * G4RotateX3D(M_PI); // think if this is correct, rotation and pos shift for mirror side
304  else transformSens = G4Translate3D(x, y, 0) * G4RotateZ3D(-alpha1);
305 
306  new G4PVPlacement(transformSens, l_sensor, "p_sensor", l_sensors, true,
307  (ids + mirror * 6 + LadderID * 12));
308  }
309  transformSens = G4Translate3D(0, 0, mirror ? -zSens : zSens);
310  assemblyLadder->AddPlacedVolume(l_sensors, transformSens);
311  }
312  }
313  }
314 
315 
316 
317  G4double thetaZ = ladder.getAngle("ThetaZ");
318  G4double r = ladder.getLength("r_plume") * CLHEP::cm - zshift * sin(thetaZ);
319  G4double z = ladder.getLength("z_plume") * CLHEP::cm - zshift * cos(thetaZ);
320  G4double phi = ladder.getAngle("Phi");
321  G4double alpha = ladder.getAngle("Alpha");
322 
323 
324  // place cooling pipes
325  G4Transform3D transformPipe = G4Translate3D(pipeZ + zshift, pipeY, pipeX) * G4RotateZ3D(alphaPipe) * G4RotateY3D(+ M_PI / 2.);
326  assemblyLadder->AddPlacedVolume(pipe_l, transformPipe);
327  transformPipe = G4Translate3D(pipeZ + zshift
328  , pipeY, -pipeX) * G4RotateZ3D(alphaPipe) * G4RotateY3D(+ M_PI / 2.);
329  assemblyLadder->AddPlacedVolume(pipe_l, transformPipe);
330 
331 
332  G4Transform3D transform1;
333  if (LadderID == 1) {
334  G4AssemblyVolume* sup1 = buildSupport1();
335  G4AssemblyVolume* sup2 = buildSupport2();
336  transform1 = G4Translate3D(-fullLength / 2. - 18.7, 0., 1.2) * G4RotateY3D(thetaZ) * G4RotateX3D(M_PI / 2.) * G4RotateY3D(M_PI);
337  assemblyLadder->AddPlacedAssembly(sup1, transform1);
338  transform1 = G4Translate3D(fullLength / 2. + 19.5, 0, -2.6) * G4RotateY3D(thetaZ) * G4RotateX3D(M_PI / 2.);
339  assemblyLadder->AddPlacedAssembly(sup2, transform1);
340  }
341 
342  if (LadderID == 0) {
343  G4AssemblyVolume* sup1 = buildSupport3();
344  G4AssemblyVolume* sup2 = buildSupport4();
345  transform1 = G4Translate3D(fullLength / 2. + 5, 0,
346  7.8) * G4RotateY3D(-thetaZ) * G4RotateZ3D(M_PI / 2.) * G4RotateX3D(M_PI / 2.) * G4RotateY3D(M_PI / 2.);
347  assemblyLadder->AddPlacedAssembly(sup1, transform1);
348  transform1 = G4Translate3D(-fullLength / 2. - 31, 0.,
349  -21.7) * G4RotateY3D(-thetaZ) * G4RotateZ3D(M_PI / 2.) * G4RotateX3D(-M_PI / 2.) * G4RotateY3D(M_PI);
350  assemblyLadder->AddPlacedAssembly(sup2, transform1);
351  }
352 
353  G4Transform3D transform = G4RotateZ3D(phi) * G4Translate3D(r, 0,
354  z) * G4RotateY3D(thetaZ) * G4RotateZ3D(alpha + M_PI) * G4RotateY3D(- M_PI / 2.0);
355 
356  assemblyLadder->MakeImprint(&topVolume, transform);
357 
358  LadderID += 1;
359 
360  }
361 
362  }
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:365
Belle2::plume::PlumeCreator::buildSupport2
G4AssemblyVolume * buildSupport2()
Volume of support2.
Definition: PlumeCreator.cc:412
Belle2::plume::PlumeCreator::buildSupport4
G4AssemblyVolume * buildSupport4()
Volume of support4.
Definition: PlumeCreator.cc:502
Belle2::plume::PlumeCreator::buildSupport3
G4AssemblyVolume * buildSupport3()
Volume of support3.
Definition: PlumeCreator.cc:448
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, GeoCDCCreator, 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, GeoCDCCreator, and GeoARICHCreator.

Definition at line 24 of file CreatorBase.cc.

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