Geant4 9.6.0
Toolkit for the simulation of the passage of particles through matter
•All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros
G4GDMLReadParamvol.cc
Go to the documentation of this file.
1//
2// ********************************************************************
3// * License and Disclaimer *
4// * *
5// * The Geant4 software is copyright of the Copyright Holders of *
6// * the Geant4 Collaboration. It is provided under the terms and *
7// * conditions of the Geant4 Software License, included in the file *
8// * LICENSE and available at http://cern.ch/geant4/license . These *
9// * include a list of copyright holders. *
10// * *
11// * Neither the authors of this software system, nor their employing *
12// * institutes,nor the agencies providing financial support for this *
13// * work make any representation or warranty, express or implied, *
14// * regarding this software system or assume any liability for its *
15// * use. Please see the license in the file LICENSE and URL above *
16// * for the full disclaimer and the limitation of liability. *
17// * *
18// * This code implementation is the result of the scientific and *
19// * technical work of the GEANT4 collaboration. *
20// * By using, copying, modifying or distributing the software (or *
21// * any work based on the software) you agree to acknowledge its *
22// * use in resulting scientific publications, and indicate your *
23// * acceptance of all terms of the Geant4 Software license. *
24// ********************************************************************
25//
26// $Id$
27//
28// class G4GDMLReadParamvol Implementation
29//
30// History:
31// - Created. Zoltan Torzsok, November 2007
32// -------------------------------------------------------------------------
33
34#include "G4GDMLReadParamvol.hh"
35
36#include "G4LogicalVolume.hh"
37#include "G4PVParameterised.hh"
38#include "G4PVPlacement.hh"
39#include "G4VPhysicalVolume.hh"
40
41G4GDMLReadParamvol::G4GDMLReadParamvol()
42 : G4GDMLReadSetup(), parameterisation(0)
43{
44}
45
46G4GDMLReadParamvol::~G4GDMLReadParamvol()
47{
48}
49
50void G4GDMLReadParamvol::
51Box_dimensionsRead( const xercesc::DOMElement* const element,
52 G4GDMLParameterisation::PARAMETER& parameter )
53{
54 G4double lunit = 1.0;
55
56 const xercesc::DOMNamedNodeMap* const attributes = element->getAttributes();
57 XMLSize_t attributeCount = attributes->getLength();
58
59 for (XMLSize_t attribute_index=0;
60 attribute_index<attributeCount; attribute_index++)
61 {
62 xercesc::DOMNode* attribute_node = attributes->item(attribute_index);
63
64 if (attribute_node->getNodeType() != xercesc::DOMNode::ATTRIBUTE_NODE)
65 { continue; }
66
67 const xercesc::DOMAttr* const attribute
68 = dynamic_cast<xercesc::DOMAttr*>(attribute_node);
69 if (!attribute)
70 {
71 G4Exception("G4GDMLReadParamvol::Box_dimensionsRead()",
72 "InvalidRead", FatalException, "No attribute found!");
73 return;
74 }
75 const G4String attName = Transcode(attribute->getName());
76 const G4String attValue = Transcode(attribute->getValue());
77
78 if (attName=="lunit") { lunit = eval.Evaluate(attValue); } else
79 if (attName=="x") { parameter.dimension[0] = eval.Evaluate(attValue); } else
80 if (attName=="y") { parameter.dimension[1] = eval.Evaluate(attValue); } else
81 if (attName=="z") { parameter.dimension[2] = eval.Evaluate(attValue); }
82 }
83
84 parameter.dimension[0] *= 0.5*lunit;
85 parameter.dimension[1] *= 0.5*lunit;
86 parameter.dimension[2] *= 0.5*lunit;
87}
88
89void G4GDMLReadParamvol::
90Trd_dimensionsRead( const xercesc::DOMElement* const element,
91 G4GDMLParameterisation::PARAMETER& parameter )
92{
93 G4double lunit = 1.0;
94
95 const xercesc::DOMNamedNodeMap* const attributes = element->getAttributes();
96 XMLSize_t attributeCount = attributes->getLength();
97
98 for (XMLSize_t attribute_index=0;
99 attribute_index<attributeCount; attribute_index++)
100 {
101 xercesc::DOMNode* attribute_node = attributes->item(attribute_index);
102
103 if (attribute_node->getNodeType() != xercesc::DOMNode::ATTRIBUTE_NODE)
104 { continue; }
105
106 const xercesc::DOMAttr* const attribute
107 = dynamic_cast<xercesc::DOMAttr*>(attribute_node);
108 if (!attribute)
109 {
110 G4Exception("G4GDMLReadParamvol::Trd_dimensionsRead()",
111 "InvalidRead", FatalException, "No attribute found!");
112 return;
113 }
114 const G4String attName = Transcode(attribute->getName());
115 const G4String attValue = Transcode(attribute->getValue());
116
117 if (attName=="lunit") { lunit = eval.Evaluate(attValue); } else
118 if (attName=="x1") { parameter.dimension[0]=eval.Evaluate(attValue); } else
119 if (attName=="x2") { parameter.dimension[1]=eval.Evaluate(attValue); } else
120 if (attName=="y1") { parameter.dimension[2]=eval.Evaluate(attValue); } else
121 if (attName=="y2") { parameter.dimension[3]=eval.Evaluate(attValue); } else
122 if (attName=="z") { parameter.dimension[4]=eval.Evaluate(attValue); }
123 }
124
125 parameter.dimension[0] *= 0.5*lunit;
126 parameter.dimension[1] *= 0.5*lunit;
127 parameter.dimension[2] *= 0.5*lunit;
128 parameter.dimension[3] *= 0.5*lunit;
129 parameter.dimension[4] *= 0.5*lunit;
130}
131
132void G4GDMLReadParamvol::
133Trap_dimensionsRead( const xercesc::DOMElement* const element,
134 G4GDMLParameterisation::PARAMETER& parameter )
135{
136 G4double lunit = 1.0;
137 G4double aunit = 1.0;
138
139 const xercesc::DOMNamedNodeMap* const attributes = element->getAttributes();
140 XMLSize_t attributeCount = attributes->getLength();
141
142 for (XMLSize_t attribute_index=0;
143 attribute_index<attributeCount; attribute_index++)
144 {
145 xercesc::DOMNode* attribute_node = attributes->item(attribute_index);
146
147 if (attribute_node->getNodeType() != xercesc::DOMNode::ATTRIBUTE_NODE)
148 { continue; }
149
150 const xercesc::DOMAttr* const attribute
151 = dynamic_cast<xercesc::DOMAttr*>(attribute_node);
152 if (!attribute)
153 {
154 G4Exception("G4GDMLReadParamvol::Trap_dimensionsRead()",
155 "InvalidRead", FatalException, "No attribute found!");
156 return;
157 }
158 const G4String attName = Transcode(attribute->getName());
159 const G4String attValue = Transcode(attribute->getValue());
160
161 if (attName=="lunit")
162 { lunit = eval.Evaluate(attValue); } else
163 if (attName=="aunit")
164 { aunit = eval.Evaluate(attValue); } else
165 if (attName=="z")
166 { parameter.dimension[0] = eval.Evaluate(attValue); } else
167 if (attName=="theta")
168 { parameter.dimension[1] = eval.Evaluate(attValue); } else
169 if (attName=="phi")
170 { parameter.dimension[2] = eval.Evaluate(attValue); } else
171 if (attName=="y1")
172 { parameter.dimension[3] = eval.Evaluate(attValue); } else
173 if (attName=="x1")
174 { parameter.dimension[4] = eval.Evaluate(attValue); } else
175 if (attName=="x2")
176 { parameter.dimension[5] = eval.Evaluate(attValue); } else
177 if (attName=="alpha1")
178 { parameter.dimension[6] = eval.Evaluate(attValue); } else
179 if (attName=="y2")
180 { parameter.dimension[7] = eval.Evaluate(attValue); } else
181 if (attName=="x3")
182 { parameter.dimension[8] = eval.Evaluate(attValue); } else
183 if (attName=="x4")
184 { parameter.dimension[9] = eval.Evaluate(attValue); } else
185 if (attName=="alpha2")
186 { parameter.dimension[10] = eval.Evaluate(attValue); }
187 }
188
189 parameter.dimension[0] *= 0.5*lunit;
190 parameter.dimension[1] *= aunit;
191 parameter.dimension[2] *= aunit;
192 parameter.dimension[3] *= 0.5*lunit;
193 parameter.dimension[4] *= 0.5*lunit;
194 parameter.dimension[5] *= 0.5*lunit;
195 parameter.dimension[6] *= aunit;
196 parameter.dimension[7] *= 0.5*lunit;
197 parameter.dimension[8] *= 0.5*lunit;
198 parameter.dimension[9] *= 0.5*lunit;
199 parameter.dimension[10] *= aunit;
200}
201
202void G4GDMLReadParamvol::
203Tube_dimensionsRead( const xercesc::DOMElement* const element,
204 G4GDMLParameterisation::PARAMETER& parameter )
205{
206 G4double lunit = 1.0;
207 G4double aunit = 1.0;
208
209 const xercesc::DOMNamedNodeMap* const attributes = element->getAttributes();
210 XMLSize_t attributeCount = attributes->getLength();
211
212 for (XMLSize_t attribute_index=0;
213 attribute_index<attributeCount; attribute_index++)
214 {
215 xercesc::DOMNode* attribute_node = attributes->item(attribute_index);
216
217 if (attribute_node->getNodeType() != xercesc::DOMNode::ATTRIBUTE_NODE)
218 { continue; }
219
220 const xercesc::DOMAttr* const attribute
221 = dynamic_cast<xercesc::DOMAttr*>(attribute_node);
222 if (!attribute)
223 {
224 G4Exception("G4GDMLReadParamvol::Tube_dimensionsRead()",
225 "InvalidRead", FatalException, "No attribute found!");
226 return;
227 }
228 const G4String attName = Transcode(attribute->getName());
229 const G4String attValue = Transcode(attribute->getValue());
230
231 if (attName=="lunit")
232 { lunit = eval.Evaluate(attValue); } else
233 if (attName=="aunit")
234 { aunit = eval.Evaluate(attValue); } else
235 if (attName=="InR")
236 { parameter.dimension[0] = eval.Evaluate(attValue); } else
237 if (attName=="OutR")
238 { parameter.dimension[1] = eval.Evaluate(attValue); } else
239 if (attName=="hz")
240 { parameter.dimension[2] = eval.Evaluate(attValue); } else
241 if (attName=="StartPhi")
242 { parameter.dimension[3] = eval.Evaluate(attValue); } else
243 if (attName=="DeltaPhi")
244 { parameter.dimension[4] = eval.Evaluate(attValue); }
245 }
246
247 parameter.dimension[0] *= lunit;
248 parameter.dimension[1] *= lunit;
249 parameter.dimension[2] *= 0.5*lunit;
250 parameter.dimension[3] *= aunit;
251 parameter.dimension[4] *= aunit;
252}
253
254void G4GDMLReadParamvol::
255Cone_dimensionsRead( const xercesc::DOMElement* const element,
256 G4GDMLParameterisation::PARAMETER& parameter )
257{
258 G4double lunit = 1.0;
259 G4double aunit = 1.0;
260
261 const xercesc::DOMNamedNodeMap* const attributes = element->getAttributes();
262 XMLSize_t attributeCount = attributes->getLength();
263
264 for (XMLSize_t attribute_index=0;
265 attribute_index<attributeCount; attribute_index++)
266 {
267 xercesc::DOMNode* attribute_node = attributes->item(attribute_index);
268
269 if (attribute_node->getNodeType() != xercesc::DOMNode::ATTRIBUTE_NODE)
270 { continue; }
271
272 const xercesc::DOMAttr* const attribute
273 = dynamic_cast<xercesc::DOMAttr*>(attribute_node);
274 if (!attribute)
275 {
276 G4Exception("G4GDMLReadParamvol::Cone_dimensionsRead()",
277 "InvalidRead", FatalException, "No attribute found!");
278 return;
279 }
280 const G4String attName = Transcode(attribute->getName());
281 const G4String attValue = Transcode(attribute->getValue());
282
283 if (attName=="lunit")
284 { lunit = eval.Evaluate(attValue); } else
285 if (attName=="aunit")
286 { aunit = eval.Evaluate(attValue); } else
287 if (attName=="rmin1")
288 { parameter.dimension[0] = eval.Evaluate(attValue); } else
289 if (attName=="rmax1")
290 { parameter.dimension[1] = eval.Evaluate(attValue); } else
291 if (attName=="rmin2")
292 { parameter.dimension[2] = eval.Evaluate(attValue); } else
293 if (attName=="rmax2")
294 { parameter.dimension[3] = eval.Evaluate(attValue); } else
295 if (attName=="z")
296 { parameter.dimension[4] = eval.Evaluate(attValue); } else
297 if (attName=="startphi")
298 { parameter.dimension[5] = eval.Evaluate(attValue); } else
299 if (attName=="deltaphi")
300 { parameter.dimension[6] = eval.Evaluate(attValue); }
301 }
302
303 parameter.dimension[0] *= lunit;
304 parameter.dimension[1] *= lunit;
305 parameter.dimension[2] *= lunit;
306 parameter.dimension[3] *= lunit;
307 parameter.dimension[4] *= 0.5*lunit;
308 parameter.dimension[5] *= aunit;
309 parameter.dimension[6] *= aunit;
310}
311
312void G4GDMLReadParamvol::
313Sphere_dimensionsRead( const xercesc::DOMElement* const element,
314 G4GDMLParameterisation::PARAMETER& parameter )
315{
316 G4double lunit = 1.0;
317 G4double aunit = 1.0;
318
319 const xercesc::DOMNamedNodeMap* const attributes = element->getAttributes();
320 XMLSize_t attributeCount = attributes->getLength();
321
322 for (XMLSize_t attribute_index=0;
323 attribute_index<attributeCount; attribute_index++)
324 {
325 xercesc::DOMNode* attribute_node = attributes->item(attribute_index);
326
327 if (attribute_node->getNodeType() != xercesc::DOMNode::ATTRIBUTE_NODE)
328 { continue; }
329
330 const xercesc::DOMAttr* const attribute
331 = dynamic_cast<xercesc::DOMAttr*>(attribute_node);
332 if (!attribute)
333 {
334 G4Exception("G4GDMLReadParamvol::Sphere_dimensionsRead()",
335 "InvalidRead", FatalException, "No attribute found!");
336 return;
337 }
338 const G4String attName = Transcode(attribute->getName());
339 const G4String attValue = Transcode(attribute->getValue());
340
341 if (attName=="lunit")
342 { lunit = eval.Evaluate(attValue); } else
343 if (attName=="aunit")
344 { aunit = eval.Evaluate(attValue); } else
345 if (attName=="rmin")
346 { parameter.dimension[0] = eval.Evaluate(attValue); } else
347 if (attName=="rmax")
348 { parameter.dimension[1] = eval.Evaluate(attValue); } else
349 if (attName=="startphi")
350 { parameter.dimension[2] = eval.Evaluate(attValue); } else
351 if (attName=="deltaphi")
352 { parameter.dimension[3] = eval.Evaluate(attValue); } else
353 if (attName=="starttheta")
354 { parameter.dimension[4] = eval.Evaluate(attValue); } else
355 if (attName=="deltatheta")
356 { parameter.dimension[5] = eval.Evaluate(attValue); }
357 }
358
359 parameter.dimension[0] *= lunit;
360 parameter.dimension[1] *= lunit;
361 parameter.dimension[2] *= aunit;
362 parameter.dimension[3] *= aunit;
363 parameter.dimension[4] *= aunit;
364 parameter.dimension[5] *= aunit;
365}
366
367void G4GDMLReadParamvol::
368Orb_dimensionsRead( const xercesc::DOMElement* const element,
369 G4GDMLParameterisation::PARAMETER& parameter )
370{
371 G4double lunit = 1.0;
372
373 const xercesc::DOMNamedNodeMap* const attributes = element->getAttributes();
374 XMLSize_t attributeCount = attributes->getLength();
375
376 for (XMLSize_t attribute_index=0;
377 attribute_index<attributeCount; attribute_index++)
378 {
379 xercesc::DOMNode* attribute_node = attributes->item(attribute_index);
380
381 if (attribute_node->getNodeType() != xercesc::DOMNode::ATTRIBUTE_NODE)
382 { continue; }
383
384 const xercesc::DOMAttr* const attribute
385 = dynamic_cast<xercesc::DOMAttr*>(attribute_node);
386 if (!attribute)
387 {
388 G4Exception("G4GDMLReadParamvol::Orb_dimensionsRead()",
389 "InvalidRead", FatalException, "No attribute found!");
390 return;
391 }
392 const G4String attName = Transcode(attribute->getName());
393 const G4String attValue = Transcode(attribute->getValue());
394
395 if (attName=="lunit") { lunit = eval.Evaluate(attValue); } else
396 if (attName=="r") { parameter.dimension[0] = eval.Evaluate(attValue); }
397 }
398
399 parameter.dimension[0] *= lunit;
400}
401
402void G4GDMLReadParamvol::
403Torus_dimensionsRead( const xercesc::DOMElement* const element,
404 G4GDMLParameterisation::PARAMETER& parameter )
405{
406 G4double lunit = 1.0;
407 G4double aunit = 1.0;
408
409 const xercesc::DOMNamedNodeMap* const attributes = element->getAttributes();
410 XMLSize_t attributeCount = attributes->getLength();
411
412 for (XMLSize_t attribute_index=0;
413 attribute_index<attributeCount; attribute_index++)
414 {
415 xercesc::DOMNode* attribute_node = attributes->item(attribute_index);
416
417 if (attribute_node->getNodeType() != xercesc::DOMNode::ATTRIBUTE_NODE)
418 { continue; }
419
420 const xercesc::DOMAttr* const attribute
421 = dynamic_cast<xercesc::DOMAttr*>(attribute_node);
422 if (!attribute)
423 {
424 G4Exception("G4GDMLReadParamvol::Torus_dimensionsRead()",
425 "InvalidRead", FatalException, "No attribute found!");
426 return;
427 }
428 const G4String attName = Transcode(attribute->getName());
429 const G4String attValue = Transcode(attribute->getValue());
430
431 if (attName=="lunit")
432 { lunit = eval.Evaluate(attValue); } else
433 if (attName=="aunit")
434 { aunit = eval.Evaluate(attValue); } else
435 if (attName=="rmin")
436 { parameter.dimension[0] = eval.Evaluate(attValue); } else
437 if (attName=="rmax")
438 { parameter.dimension[1] = eval.Evaluate(attValue); } else
439 if (attName=="rtor")
440 { parameter.dimension[2] = eval.Evaluate(attValue); } else
441 if (attName=="startphi")
442 { parameter.dimension[3] = eval.Evaluate(attValue); } else
443 if (attName=="deltaphi")
444 { parameter.dimension[4] = eval.Evaluate(attValue); }
445 }
446
447 parameter.dimension[0] *= lunit;
448 parameter.dimension[1] *= lunit;
449 parameter.dimension[2] *= lunit;
450 parameter.dimension[3] *= aunit;
451 parameter.dimension[4] *= aunit;
452}
453
454void G4GDMLReadParamvol::
455Para_dimensionsRead( const xercesc::DOMElement* const element,
456 G4GDMLParameterisation::PARAMETER& parameter )
457{
458 G4double lunit = 1.0;
459 G4double aunit = 1.0;
460
461 const xercesc::DOMNamedNodeMap* const attributes = element->getAttributes();
462 XMLSize_t attributeCount = attributes->getLength();
463
464 for (XMLSize_t attribute_index=0;
465 attribute_index<attributeCount; attribute_index++)
466 {
467 xercesc::DOMNode* attribute_node = attributes->item(attribute_index);
468
469 if (attribute_node->getNodeType() != xercesc::DOMNode::ATTRIBUTE_NODE)
470 { continue; }
471
472 const xercesc::DOMAttr* const attribute
473 = dynamic_cast<xercesc::DOMAttr*>(attribute_node);
474 if (!attribute)
475 {
476 G4Exception("G4GDMLReadParamvol::Para_dimensionsRead()",
477 "InvalidRead", FatalException, "No attribute found!");
478 return;
479 }
480 const G4String attName = Transcode(attribute->getName());
481 const G4String attValue = Transcode(attribute->getValue());
482
483 if (attName=="lunit")
484 { lunit = eval.Evaluate(attValue); } else
485 if (attName=="aunit")
486 { aunit = eval.Evaluate(attValue); } else
487 if (attName=="x")
488 { parameter.dimension[0] = eval.Evaluate(attValue); } else
489 if (attName=="y")
490 { parameter.dimension[1] = eval.Evaluate(attValue); } else
491 if (attName=="z")
492 { parameter.dimension[2] = eval.Evaluate(attValue); } else
493 if (attName=="alpha")
494 { parameter.dimension[3] = eval.Evaluate(attValue); } else
495 if (attName=="theta")
496 { parameter.dimension[4] = eval.Evaluate(attValue); } else
497 if (attName=="phi")
498 { parameter.dimension[5] = eval.Evaluate(attValue); }
499 }
500
501 parameter.dimension[0] = 0.5*lunit;
502 parameter.dimension[1] = 0.5*lunit;
503 parameter.dimension[2] = 0.5*lunit;
504 parameter.dimension[3] = aunit;
505 parameter.dimension[4] = aunit;
506 parameter.dimension[5] = aunit;
507}
508
509void G4GDMLReadParamvol::
510Hype_dimensionsRead( const xercesc::DOMElement* const element,
511 G4GDMLParameterisation::PARAMETER& parameter )
512{
513 G4double lunit = 1.0;
514 G4double aunit = 1.0;
515
516 const xercesc::DOMNamedNodeMap* const attributes = element->getAttributes();
517 XMLSize_t attributeCount = attributes->getLength();
518
519 for (XMLSize_t attribute_index=0;
520 attribute_index<attributeCount; attribute_index++)
521 {
522 xercesc::DOMNode* attribute_node = attributes->item(attribute_index);
523
524 if (attribute_node->getNodeType() != xercesc::DOMNode::ATTRIBUTE_NODE)
525 { continue; }
526
527 const xercesc::DOMAttr* const attribute
528 = dynamic_cast<xercesc::DOMAttr*>(attribute_node);
529 if (!attribute)
530 {
531 G4Exception("G4GDMLReadParamvol::Hype_dimensionsRead()",
532 "InvalidRead", FatalException, "No attribute found!");
533 return;
534 }
535 const G4String attName = Transcode(attribute->getName());
536 const G4String attValue = Transcode(attribute->getValue());
537
538 if (attName=="lunit")
539 { lunit = eval.Evaluate(attValue); } else
540 if (attName=="aunit")
541 { aunit = eval.Evaluate(attValue); } else
542 if (attName=="rmin")
543 { parameter.dimension[0] = eval.Evaluate(attValue); } else
544 if (attName=="rmax")
545 { parameter.dimension[1] = eval.Evaluate(attValue); } else
546 if (attName=="inst")
547 { parameter.dimension[2] = eval.Evaluate(attValue); } else
548 if (attName=="outst")
549 { parameter.dimension[3] = eval.Evaluate(attValue); } else
550 if (attName=="z")
551 { parameter.dimension[4] = eval.Evaluate(attValue); }
552 }
553
554 parameter.dimension[0] = lunit;
555 parameter.dimension[1] = lunit;
556 parameter.dimension[2] = aunit;
557 parameter.dimension[3] = aunit;
558 parameter.dimension[4] = 0.5*lunit;
559}
560
561void G4GDMLReadParamvol::
562ParametersRead(const xercesc::DOMElement* const element) {
563
564 G4ThreeVector rotation(0.0,0.0,0.0);
565 G4ThreeVector position(0.0,0.0,0.0);
566
567 G4GDMLParameterisation::PARAMETER parameter;
568
569 for (xercesc::DOMNode* iter = element->getFirstChild();
570 iter != 0; iter = iter->getNextSibling())
571 {
572 if (iter->getNodeType() != xercesc::DOMNode::ELEMENT_NODE) { continue; }
573
574 const xercesc::DOMElement* const child
575 = dynamic_cast<xercesc::DOMElement*>(iter);
576 if (!child)
577 {
578 G4Exception("G4GDMLReadParamvol::ParametersRead()",
579 "InvalidRead", FatalException, "No child found!");
580 return;
581 }
582 const G4String tag = Transcode(child->getTagName());
583 if (tag=="rotation") { VectorRead(child,rotation); } else
584 if (tag=="position") { VectorRead(child,position); } else
585 if (tag=="positionref")
586 { position = GetPosition(GenerateName(RefRead(child))); } else
587 if (tag=="rotationref")
588 { rotation = GetRotation(GenerateName(RefRead(child))); } else
589 if (tag=="box_dimensions") { Box_dimensionsRead(child,parameter); } else
590 if (tag=="trd_dimensions") { Trd_dimensionsRead(child,parameter); } else
591 if (tag=="trap_dimensions") { Trap_dimensionsRead(child,parameter); } else
592 if (tag=="tube_dimensions") { Tube_dimensionsRead(child,parameter); } else
593 if (tag=="cone_dimensions") { Cone_dimensionsRead(child,parameter); } else
594 if (tag=="sphere_dimensions") { Cone_dimensionsRead(child,parameter); } else
595 if (tag=="orb_dimensions") { Cone_dimensionsRead(child,parameter); } else
596 if (tag=="torus_dimensions") { Cone_dimensionsRead(child,parameter); } else
597 if (tag=="para_dimensions") { Cone_dimensionsRead(child,parameter); } else
598 if (tag=="hype_dimensions") { Hype_dimensionsRead(child,parameter); }
599 else
600 {
601 G4String error_msg = "Unknown tag in parameters: " + tag;
602 G4Exception("G4GDMLReadParamvol::ParametersRead()", "ReadError",
603 FatalException, error_msg);
604 }
605 }
606
607 parameter.pRot = new G4RotationMatrix();
608
609 parameter.pRot->rotateX(rotation.x());
610 parameter.pRot->rotateY(rotation.y());
611 parameter.pRot->rotateZ(rotation.z());
612
613 parameter.position = position;
614
615 parameterisation->AddParameter(parameter);
616}
617
618void G4GDMLReadParamvol::
619ParameterisedRead(const xercesc::DOMElement* const element)
620{
621 for (xercesc::DOMNode* iter = element->getFirstChild();
622 iter != 0; iter = iter->getNextSibling())
623 {
624 if (iter->getNodeType() != xercesc::DOMNode::ELEMENT_NODE) { continue; }
625
626 const xercesc::DOMElement* const child
627 = dynamic_cast<xercesc::DOMElement*>(iter);
628 if (!child)
629 {
630 G4Exception("G4GDMLReadParamvol::ParameterisedRead()",
631 "InvalidRead", FatalException, "No child found!");
632 return;
633 }
634 const G4String tag = Transcode(child->getTagName());
635
636 if (tag=="parameters")
637 {
638 const xercesc::DOMNamedNodeMap* const attributes
639 = element->getAttributes();
640 XMLSize_t attributeCount = attributes->getLength();
641 for (XMLSize_t attribute_index=0;
642 attribute_index<attributeCount; attribute_index++)
643 {
644 xercesc::DOMNode* attribute_node = attributes->item(attribute_index);
645
646 if (attribute_node->getNodeType() != xercesc::DOMNode::ATTRIBUTE_NODE)
647 { continue; }
648
649 const xercesc::DOMAttr* const attribute
650 = dynamic_cast<xercesc::DOMAttr*>(attribute_node);
651 if (!attribute)
652 {
653 G4Exception("G4GDMLReadParamvol::ParameterisedRead()",
654 "InvalidRead", FatalException, "No attribute found!");
655 return;
656 }
657 const G4String attName = Transcode(attribute->getName());
658 const G4String attValue = Transcode(attribute->getValue());
659
660 if (attName=="number") { eval.Evaluate(attValue); }
661 }
662 ParametersRead(child);
663 }
664 else
665 {
666 if (tag=="loop") { LoopRead(child,&G4GDMLRead::Paramvol_contentRead); }
667 }
668 }
669}
670
671void G4GDMLReadParamvol::
672Paramvol_contentRead(const xercesc::DOMElement* const element)
673{
674 for (xercesc::DOMNode* iter = element->getFirstChild();
675 iter != 0; iter = iter->getNextSibling())
676 {
677 if (iter->getNodeType() != xercesc::DOMNode::ELEMENT_NODE) { continue; }
678
679 const xercesc::DOMElement* const child
680 = dynamic_cast<xercesc::DOMElement*>(iter);
681 if (!child)
682 {
683 G4Exception("G4GDMLReadParamvol::Paramvol_contentRead()", "InvalidRead",
684 FatalException, "No child found!");
685 return;
686 }
687 const G4String tag = Transcode(child->getTagName());
688 if (tag=="parameterised_position_size") { ParameterisedRead(child); }else
689 if (tag=="loop") { LoopRead(child,&G4GDMLRead::Paramvol_contentRead); }
690 }
691}
692
693void G4GDMLReadParamvol::
694ParamvolRead(const xercesc::DOMElement* const element, G4LogicalVolume* mother)
695{
696 G4String volumeref;
697
698 parameterisation = new G4GDMLParameterisation();
699
700 for (xercesc::DOMNode* iter = element->getFirstChild();
701 iter != 0; iter = iter->getNextSibling())
702 {
703 if (iter->getNodeType() != xercesc::DOMNode::ELEMENT_NODE) { continue; }
704
705 const xercesc::DOMElement* const child
706 = dynamic_cast<xercesc::DOMElement*>(iter);
707 if (!child)
708 {
709 G4Exception("G4GDMLReadParamvol::ParamvolRead()", "InvalidRead",
710 FatalException, "No child found!");
711 return;
712 }
713 const G4String tag = Transcode(child->getTagName());
714
715 if (tag=="volumeref") { volumeref = RefRead(child); }
716
717 }
718
719 Paramvol_contentRead(element);
720
721 G4LogicalVolume* logvol = GetVolume(GenerateName(volumeref));
722
723 if (parameterisation->GetSize()==0)
724 {
725 G4Exception("G4GDMLReadParamvol::ParamvolRead()",
726 "ReadError", FatalException,
727 "No parameters are defined in parameterised volume!");
728 }
729 G4String pv_name = logvol->GetName() + "_param";
730 new G4PVParameterised(pv_name, logvol, mother, kUndefined,
731 parameterisation->GetSize(), parameterisation, check);
732}
FatalException
@ FatalException
Definition: G4ExceptionSeverity.hh:60
G4RotationMatrix
CLHEP::HepRotation G4RotationMatrix
Definition: G4RotationMatrix.hh:43
G4double
double G4double
Definition: G4Types.hh:64
CLHEP::Hep3Vector::z
double z() const
CLHEP::Hep3Vector::x
double x() const
CLHEP::Hep3Vector::y
double y() const
CLHEP::HepRotation::rotateX
HepRotation & rotateX(double delta)
Definition: Rotation.cc:66
CLHEP::HepRotation::rotateZ
HepRotation & rotateZ(double delta)
Definition: Rotation.cc:92
CLHEP::HepRotation::rotateY
HepRotation & rotateY(double delta)
Definition: Rotation.cc:79
G4GDMLEvaluator::Evaluate
G4double Evaluate(const G4String &)
Definition: G4GDMLEvaluator.cc:213
G4GDMLParameterisation::AddParameter
void AddParameter(const PARAMETER &)
Definition: G4GDMLParameterisation.cc:41
G4GDMLReadDefine::VectorRead
void VectorRead(const xercesc::DOMElement *const, G4ThreeVector &)
Definition: G4GDMLReadDefine.cc:494
G4GDMLReadDefine::GetPosition
G4ThreeVector GetPosition(const G4String &)
Definition: G4GDMLReadDefine.cc:589
G4GDMLReadDefine::RefRead
G4String RefRead(const xercesc::DOMElement *const)
Definition: G4GDMLReadDefine.cc:531
G4GDMLReadDefine::GetRotation
G4ThreeVector GetRotation(const G4String &)
Definition: G4GDMLReadDefine.cc:600
G4GDMLReadParamvol::ParamvolRead
virtual void ParamvolRead(const xercesc::DOMElement *const, G4LogicalVolume *)
Definition: G4GDMLReadParamvol.cc:694
G4GDMLReadParamvol::ParametersRead
void ParametersRead(const xercesc::DOMElement *const)
Definition: G4GDMLReadParamvol.cc:562
G4GDMLReadParamvol::Cone_dimensionsRead
void Cone_dimensionsRead(const xercesc::DOMElement *const, G4GDMLParameterisation::PARAMETER &)
Definition: G4GDMLReadParamvol.cc:255
G4GDMLReadParamvol::Box_dimensionsRead
void Box_dimensionsRead(const xercesc::DOMElement *const, G4GDMLParameterisation::PARAMETER &)
Definition: G4GDMLReadParamvol.cc:51
G4GDMLReadParamvol::Para_dimensionsRead
void Para_dimensionsRead(const xercesc::DOMElement *const, G4GDMLParameterisation::PARAMETER &)
Definition: G4GDMLReadParamvol.cc:455
G4GDMLReadParamvol::Torus_dimensionsRead
void Torus_dimensionsRead(const xercesc::DOMElement *const, G4GDMLParameterisation::PARAMETER &)
Definition: G4GDMLReadParamvol.cc:403
G4GDMLReadParamvol::parameterisation
G4GDMLParameterisation * parameterisation
Definition: G4GDMLReadParamvol.hh:89
G4GDMLReadParamvol::Sphere_dimensionsRead
void Sphere_dimensionsRead(const xercesc::DOMElement *const, G4GDMLParameterisation::PARAMETER &)
Definition: G4GDMLReadParamvol.cc:313
G4GDMLReadParamvol::Hype_dimensionsRead
void Hype_dimensionsRead(const xercesc::DOMElement *const, G4GDMLParameterisation::PARAMETER &)
Definition: G4GDMLReadParamvol.cc:510
G4GDMLReadParamvol::ParameterisedRead
void ParameterisedRead(const xercesc::DOMElement *const)
Definition: G4GDMLReadParamvol.cc:619
G4GDMLReadParamvol::Trap_dimensionsRead
void Trap_dimensionsRead(const xercesc::DOMElement *const, G4GDMLParameterisation::PARAMETER &)
Definition: G4GDMLReadParamvol.cc:133
G4GDMLReadParamvol::Orb_dimensionsRead
void Orb_dimensionsRead(const xercesc::DOMElement *const, G4GDMLParameterisation::PARAMETER &)
Definition: G4GDMLReadParamvol.cc:368
G4GDMLReadParamvol::Trd_dimensionsRead
void Trd_dimensionsRead(const xercesc::DOMElement *const, G4GDMLParameterisation::PARAMETER &)
Definition: G4GDMLReadParamvol.cc:90
G4GDMLReadParamvol::Paramvol_contentRead
virtual void Paramvol_contentRead(const xercesc::DOMElement *const)
Definition: G4GDMLReadParamvol.cc:672
G4GDMLReadParamvol::Tube_dimensionsRead
void Tube_dimensionsRead(const xercesc::DOMElement *const, G4GDMLParameterisation::PARAMETER &)
Definition: G4GDMLReadParamvol.cc:203
G4GDMLRead::check
G4bool check
Definition: G4GDMLRead.hh:146
G4GDMLRead::Paramvol_contentRead
virtual void Paramvol_contentRead(const xercesc::DOMElement *const)=0
G4GDMLRead::GenerateName
G4String GenerateName(const G4String &name, G4bool strip=false)
Definition: G4GDMLRead.cc:68
G4GDMLRead::GetVolume
virtual G4LogicalVolume * GetVolume(const G4String &) const =0
G4GDMLRead::LoopRead
void LoopRead(const xercesc::DOMElement *const, void(G4GDMLRead::*)(const xercesc::DOMElement *const))
Definition: G4GDMLRead.cc:179
G4GDMLRead::Transcode
G4String Transcode(const XMLCh *const)
Definition: G4GDMLRead.cc:55
G4GDMLRead::eval
G4GDMLEvaluator eval
Definition: G4GDMLRead.hh:144
G4LogicalVolume::GetName
G4String GetName() const
kUndefined
@ kUndefined
Definition: geomdefs.hh:54
G4Exception
void G4Exception(const char *originOfException, const char *exceptionCode, G4ExceptionSeverity severity, const char *comments)
Definition: G4Exception.cc:41
tag
Definition: xmlparse.cc:179
position
#define position
Definition: xmlparse.cc:605