Geant4 11.1.1
Toolkit for the simulation of the passage of particles through matter
•All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Pages
G4GDMLReadSolids.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// G4GDMLReadSolids implementation
27//
28// Author: Zoltan Torzsok, November 2007
29// --------------------------------------------------------------------
30
31#include "G4GDMLReadSolids.hh"
32#include "G4Box.hh"
33#include "G4Cons.hh"
34#include "G4Ellipsoid.hh"
35#include "G4EllipticalCone.hh"
36#include "G4EllipticalTube.hh"
37#include "G4Hype.hh"
38#include "G4IntersectionSolid.hh"
39#include "G4Orb.hh"
40#include "G4Para.hh"
41#include "G4Paraboloid.hh"
42#include "G4Polycone.hh"
43#include "G4GenericPolycone.hh"
44#include "G4Polyhedra.hh"
45#include "G4QuadrangularFacet.hh"
46#include "G4ReflectedSolid.hh"
47#include "G4ScaledSolid.hh"
48#include "G4Sphere.hh"
49#include "G4SolidStore.hh"
50#include "G4SubtractionSolid.hh"
51#include "G4GenericTrap.hh"
52#include "G4TessellatedSolid.hh"
53#include "G4Tet.hh"
54#include "G4Torus.hh"
55#include "G4Transform3D.hh"
56#include "G4Trap.hh"
57#include "G4Trd.hh"
58#include "G4TriangularFacet.hh"
59#include "G4Tubs.hh"
60#include "G4CutTubs.hh"
61#include "G4TwistedBox.hh"
62#include "G4TwistedTrap.hh"
63#include "G4TwistedTrd.hh"
64#include "G4TwistedTubs.hh"
65#include "G4UnionSolid.hh"
66#include "G4OpticalSurface.hh"
67#include "G4UnitsTable.hh"
68#include "G4SurfaceProperty.hh"
69
70// --------------------------------------------------------------------
71G4GDMLReadSolids::G4GDMLReadSolids()
72 : G4GDMLReadMaterials()
73{
74}
75
76// --------------------------------------------------------------------
77G4GDMLReadSolids::~G4GDMLReadSolids()
78{
79}
80
81// --------------------------------------------------------------------
82void G4GDMLReadSolids::BooleanRead(
83 const xercesc::DOMElement* const booleanElement, const BooleanOp op)
84{
85 G4String name;
86 G4String first;
87 G4String scnd;
88 G4ThreeVector position(0.0, 0.0, 0.0);
89 G4ThreeVector rotation(0.0, 0.0, 0.0);
90 G4ThreeVector firstposition(0.0, 0.0, 0.0);
91 G4ThreeVector firstrotation(0.0, 0.0, 0.0);
92
93 const xercesc::DOMNamedNodeMap* const attributes =
94 booleanElement->getAttributes();
95 XMLSize_t attributeCount = attributes->getLength();
96
97 for(XMLSize_t attribute_index = 0; attribute_index < attributeCount;
98 ++attribute_index)
99 {
100 xercesc::DOMNode* attribute_node = attributes->item(attribute_index);
101
102 if(attribute_node->getNodeType() != xercesc::DOMNode::ATTRIBUTE_NODE)
103 {
104 continue;
105 }
106
107 const xercesc::DOMAttr* const attribute =
108 dynamic_cast<xercesc::DOMAttr*>(attribute_node);
109 if(attribute == nullptr)
110 {
111 G4Exception("G4GDMLReadSolids::BooleanRead()", "InvalidRead",
112 FatalException, "No attribute found!");
113 return;
114 }
115 const G4String attName = Transcode(attribute->getName());
116 const G4String attValue = Transcode(attribute->getValue());
117
118 if(attName == "name")
119 {
120 name = GenerateName(attValue);
121 }
122 }
123
124 for(xercesc::DOMNode* iter = booleanElement->getFirstChild(); iter != nullptr;
125 iter = iter->getNextSibling())
126 {
127 if(iter->getNodeType() != xercesc::DOMNode::ELEMENT_NODE)
128 {
129 continue;
130 }
131
132 const xercesc::DOMElement* const child =
133 dynamic_cast<xercesc::DOMElement*>(iter);
134 if(child == nullptr)
135 {
136 G4Exception("G4GDMLReadSolids::BooleanRead()", "InvalidRead",
137 FatalException, "No child found!");
138 return;
139 }
140 const G4String tag = Transcode(child->getTagName());
141
142 if(tag == "first")
143 {
144 first = RefRead(child);
145 }
146 else if(tag == "second")
147 {
148 scnd = RefRead(child);
149 }
150 else if(tag == "position")
151 {
152 VectorRead(child, position);
153 }
154 else if(tag == "rotation")
155 {
156 VectorRead(child, rotation);
157 }
158 else if(tag == "positionref")
159 {
160 position = GetPosition(GenerateName(RefRead(child)));
161 }
162 else if(tag == "rotationref")
163 {
164 rotation = GetRotation(GenerateName(RefRead(child)));
165 }
166 else if(tag == "firstposition")
167 {
168 VectorRead(child, firstposition);
169 }
170 else if(tag == "firstrotation")
171 {
172 VectorRead(child, firstrotation);
173 }
174 else if(tag == "firstpositionref")
175 {
176 firstposition = GetPosition(GenerateName(RefRead(child)));
177 }
178 else if(tag == "firstrotationref")
179 {
180 firstrotation = GetRotation(GenerateName(RefRead(child)));
181 }
182 else
183 {
184 G4String error_msg = "Unknown tag in boolean solid: " + tag;
185 G4Exception("G4GDMLReadSolids::BooleanRead()", "ReadError",
186 FatalException, error_msg);
187 }
188 }
189
190 G4VSolid* firstSolid = GetSolid(GenerateName(first));
191 G4VSolid* secondSolid = GetSolid(GenerateName(scnd));
192
193 G4Transform3D transform(GetRotationMatrix(rotation), position);
194
195 if(((firstrotation.x() != 0.0) || (firstrotation.y() != 0.0) ||
196 (firstrotation.z() != 0.0)) ||
197 ((firstposition.x() != 0.0) || (firstposition.y() != 0.0) ||
198 (firstposition.z() != 0.0)))
199 {
200 G4Transform3D firsttransform(GetRotationMatrix(firstrotation),
201 firstposition);
202 firstSolid = new G4DisplacedSolid(GenerateName("displaced_" + first),
203 firstSolid, firsttransform);
204 }
205
206 if(op == UNION)
207 {
208 new G4UnionSolid(name, firstSolid, secondSolid, transform);
209 }
210 else if(op == SUBTRACTION)
211 {
212 new G4SubtractionSolid(name, firstSolid, secondSolid, transform);
213 }
214 else if(op == INTERSECTION)
215 {
216 new G4IntersectionSolid(name, firstSolid, secondSolid, transform);
217 }
218}
219
220// --------------------------------------------------------------------
221void G4GDMLReadSolids::BoxRead(const xercesc::DOMElement* const boxElement)
222{
223 G4String name;
224 G4double lunit = 1.0;
225 G4double x = 0.0;
226 G4double y = 0.0;
227 G4double z = 0.0;
228
229 const xercesc::DOMNamedNodeMap* const attributes =
230 boxElement->getAttributes();
231 XMLSize_t attributeCount = attributes->getLength();
232
233 for(XMLSize_t attribute_index = 0; attribute_index < attributeCount;
234 ++attribute_index)
235 {
236 xercesc::DOMNode* attribute_node = attributes->item(attribute_index);
237
238 if(attribute_node->getNodeType() != xercesc::DOMNode::ATTRIBUTE_NODE)
239 {
240 continue;
241 }
242
243 const xercesc::DOMAttr* const attribute =
244 dynamic_cast<xercesc::DOMAttr*>(attribute_node);
245 if(attribute == nullptr)
246 {
247 G4Exception("G4GDMLReadSolids::BoxRead()", "InvalidRead", FatalException,
248 "No attribute found!");
249 return;
250 }
251 const G4String attName = Transcode(attribute->getName());
252 const G4String attValue = Transcode(attribute->getValue());
253
254 if(attName == "name")
255 {
256 name = GenerateName(attValue);
257 }
258 else if(attName == "lunit")
259 {
260 lunit = G4UnitDefinition::GetValueOf(attValue);
261 if(G4UnitDefinition::GetCategory(attValue) != "Length")
262 {
263 G4Exception("G4GDMLReadSolids::BoxRead()", "InvalidRead",
264 FatalException, "Invalid unit for length!");
265 }
266 }
267 else if(attName == "x")
268 {
269 x = eval.Evaluate(attValue);
270 }
271 else if(attName == "y")
272 {
273 y = eval.Evaluate(attValue);
274 }
275 else if(attName == "z")
276 {
277 z = eval.Evaluate(attValue);
278 }
279 }
280
281 x *= 0.5 * lunit;
282 y *= 0.5 * lunit;
283 z *= 0.5 * lunit;
284
285 new G4Box(name, x, y, z);
286}
287
288// --------------------------------------------------------------------
289void G4GDMLReadSolids::ConeRead(const xercesc::DOMElement* const coneElement)
290{
291 G4String name;
292 G4double lunit = 1.0;
293 G4double aunit = 1.0;
294 G4double rmin1 = 0.0;
295 G4double rmax1 = 0.0;
296 G4double rmin2 = 0.0;
297 G4double rmax2 = 0.0;
298 G4double z = 0.0;
299 G4double startphi = 0.0;
300 G4double deltaphi = 0.0;
301
302 const xercesc::DOMNamedNodeMap* const attributes =
303 coneElement->getAttributes();
304 XMLSize_t attributeCount = attributes->getLength();
305
306 for(XMLSize_t attribute_index = 0; attribute_index < attributeCount;
307 ++attribute_index)
308 {
309 xercesc::DOMNode* attribute_node = attributes->item(attribute_index);
310
311 if(attribute_node->getNodeType() != xercesc::DOMNode::ATTRIBUTE_NODE)
312 {
313 continue;
314 }
315
316 const xercesc::DOMAttr* const attribute =
317 dynamic_cast<xercesc::DOMAttr*>(attribute_node);
318 if(attribute == nullptr)
319 {
320 G4Exception("G4GDMLReadSolids::ConeRead()", "InvalidRead", FatalException,
321 "No attribute found!");
322 return;
323 }
324 const G4String attName = Transcode(attribute->getName());
325 const G4String attValue = Transcode(attribute->getValue());
326
327 if(attName == "name")
328 {
329 name = GenerateName(attValue);
330 }
331 else if(attName == "lunit")
332 {
333 lunit = G4UnitDefinition::GetValueOf(attValue);
334 if(G4UnitDefinition::GetCategory(attValue) != "Length")
335 {
336 G4Exception("G4GDMLReadSolids::ConeRead()", "InvalidRead",
337 FatalException, "Invalid unit for length!");
338 }
339 }
340 else if(attName == "aunit")
341 {
342 aunit = G4UnitDefinition::GetValueOf(attValue);
343 if(G4UnitDefinition::GetCategory(attValue) != "Angle")
344 {
345 G4Exception("G4GDMLReadSolids::ConeRead()", "InvalidRead",
346 FatalException, "Invalid unit for angle!");
347 }
348 }
349 else if(attName == "rmin1")
350 {
351 rmin1 = eval.Evaluate(attValue);
352 }
353 else if(attName == "rmax1")
354 {
355 rmax1 = eval.Evaluate(attValue);
356 }
357 else if(attName == "rmin2")
358 {
359 rmin2 = eval.Evaluate(attValue);
360 }
361 else if(attName == "rmax2")
362 {
363 rmax2 = eval.Evaluate(attValue);
364 }
365 else if(attName == "z")
366 {
367 z = eval.Evaluate(attValue);
368 }
369 else if(attName == "startphi")
370 {
371 startphi = eval.Evaluate(attValue);
372 }
373 else if(attName == "deltaphi")
374 {
375 deltaphi = eval.Evaluate(attValue);
376 }
377 }
378
379 rmin1 *= lunit;
380 rmax1 *= lunit;
381 rmin2 *= lunit;
382 rmax2 *= lunit;
383 z *= 0.5 * lunit;
384 startphi *= aunit;
385 deltaphi *= aunit;
386
387 new G4Cons(name, rmin1, rmax1, rmin2, rmax2, z, startphi, deltaphi);
388}
389
390// --------------------------------------------------------------------
391void G4GDMLReadSolids::ElconeRead(
392 const xercesc::DOMElement* const elconeElement)
393{
394 G4String name;
395 G4double lunit = 1.0;
396 G4double dx = 0.0;
397 G4double dy = 0.0;
398 G4double zmax = 0.0;
399 G4double zcut = 0.0;
400
401 const xercesc::DOMNamedNodeMap* const attributes =
402 elconeElement->getAttributes();
403 XMLSize_t attributeCount = attributes->getLength();
404
405 for(XMLSize_t attribute_index = 0; attribute_index < attributeCount;
406 ++attribute_index)
407 {
408 xercesc::DOMNode* attribute_node = attributes->item(attribute_index);
409
410 if(attribute_node->getNodeType() != xercesc::DOMNode::ATTRIBUTE_NODE)
411 {
412 continue;
413 }
414
415 const xercesc::DOMAttr* const attribute =
416 dynamic_cast<xercesc::DOMAttr*>(attribute_node);
417 if(attribute == nullptr)
418 {
419 G4Exception("G4GDMLReadSolids::ElconeRead()", "InvalidRead",
420 FatalException, "No attribute found!");
421 return;
422 }
423 const G4String attName = Transcode(attribute->getName());
424 const G4String attValue = Transcode(attribute->getValue());
425
426 if(attName == "name")
427 {
428 name = GenerateName(attValue);
429 }
430 else if(attName == "lunit")
431 {
432 lunit = G4UnitDefinition::GetValueOf(attValue);
433 if(G4UnitDefinition::GetCategory(attValue) != "Length")
434 {
435 G4Exception("G4GDMLReadSolids::ElconeRead()", "InvalidRead",
436 FatalException, "Invalid unit for length!");
437 }
438 }
439 else if(attName == "dx")
440 {
441 dx = eval.Evaluate(attValue);
442 }
443 else if(attName == "dy")
444 {
445 dy = eval.Evaluate(attValue);
446 }
447 else if(attName == "zmax")
448 {
449 zmax = eval.Evaluate(attValue);
450 }
451 else if(attName == "zcut")
452 {
453 zcut = eval.Evaluate(attValue);
454 }
455 }
456
457 zmax *= lunit;
458 zcut *= lunit;
459
460 new G4EllipticalCone(name, dx, dy, zmax, zcut);
461}
462
463// --------------------------------------------------------------------
464void G4GDMLReadSolids::EllipsoidRead(
465 const xercesc::DOMElement* const ellipsoidElement)
466{
467 G4String name;
468 G4double lunit = 1.0;
469 G4double ax = 0.0;
470 G4double by = 0.0;
471 G4double cz = 0.0;
472 G4double zcut1 = 0.0;
473 G4double zcut2 = 0.0;
474
475 const xercesc::DOMNamedNodeMap* const attributes =
476 ellipsoidElement->getAttributes();
477 XMLSize_t attributeCount = attributes->getLength();
478
479 for(XMLSize_t attribute_index = 0; attribute_index < attributeCount;
480 ++attribute_index)
481 {
482 xercesc::DOMNode* attribute_node = attributes->item(attribute_index);
483
484 if(attribute_node->getNodeType() != xercesc::DOMNode::ATTRIBUTE_NODE)
485 {
486 continue;
487 }
488
489 const xercesc::DOMAttr* const attribute =
490 dynamic_cast<xercesc::DOMAttr*>(attribute_node);
491 if(attribute == nullptr)
492 {
493 G4Exception("G4GDMLReadSolids::EllipsoidRead()", "InvalidRead",
494 FatalException, "No attribute found!");
495 return;
496 }
497 const G4String attName = Transcode(attribute->getName());
498 const G4String attValue = Transcode(attribute->getValue());
499
500 if(attName == "name")
501 {
502 name = GenerateName(attValue);
503 }
504 else if(attName == "lunit")
505 {
506 lunit = G4UnitDefinition::GetValueOf(attValue);
507 if(G4UnitDefinition::GetCategory(attValue) != "Length")
508 {
509 G4Exception("G4GDMLReadSolids::EllipsoidRead()", "InvalidRead",
510 FatalException, "Invalid unit for length!");
511 }
512 }
513 else if(attName == "ax")
514 {
515 ax = eval.Evaluate(attValue);
516 }
517 else if(attName == "by")
518 {
519 by = eval.Evaluate(attValue);
520 }
521 else if(attName == "cz")
522 {
523 cz = eval.Evaluate(attValue);
524 }
525 else if(attName == "zcut1")
526 {
527 zcut1 = eval.Evaluate(attValue);
528 }
529 else if(attName == "zcut2")
530 {
531 zcut2 = eval.Evaluate(attValue);
532 }
533 }
534
535 ax *= lunit;
536 by *= lunit;
537 cz *= lunit;
538 zcut1 *= lunit;
539 zcut2 *= lunit;
540
541 new G4Ellipsoid(name, ax, by, cz, zcut1, zcut2);
542}
543
544// --------------------------------------------------------------------
545void G4GDMLReadSolids::EltubeRead(
546 const xercesc::DOMElement* const eltubeElement)
547{
548 G4String name;
549 G4double lunit = 1.0;
550 G4double dx = 0.0;
551 G4double dy = 0.0;
552 G4double dz = 0.0;
553
554 const xercesc::DOMNamedNodeMap* const attributes =
555 eltubeElement->getAttributes();
556 XMLSize_t attributeCount = attributes->getLength();
557
558 for(XMLSize_t attribute_index = 0; attribute_index < attributeCount;
559 ++attribute_index)
560 {
561 xercesc::DOMNode* attribute_node = attributes->item(attribute_index);
562
563 if(attribute_node->getNodeType() != xercesc::DOMNode::ATTRIBUTE_NODE)
564 {
565 continue;
566 }
567
568 const xercesc::DOMAttr* const attribute =
569 dynamic_cast<xercesc::DOMAttr*>(attribute_node);
570 if(attribute == nullptr)
571 {
572 G4Exception("G4GDMLReadSolids::EltubeRead()", "InvalidRead",
573 FatalException, "No attribute found!");
574 return;
575 }
576 const G4String attName = Transcode(attribute->getName());
577 const G4String attValue = Transcode(attribute->getValue());
578
579 if(attName == "name")
580 {
581 name = GenerateName(attValue);
582 }
583 else if(attName == "lunit")
584 {
585 lunit = G4UnitDefinition::GetValueOf(attValue);
586 if(G4UnitDefinition::GetCategory(attValue) != "Length")
587 {
588 G4Exception("G4GDMLReadSolids::EltubeRead()", "InvalidRead",
589 FatalException, "Invalid unit for length!");
590 }
591 }
592 else if(attName == "dx")
593 {
594 dx = eval.Evaluate(attValue);
595 }
596 else if(attName == "dy")
597 {
598 dy = eval.Evaluate(attValue);
599 }
600 else if(attName == "dz")
601 {
602 dz = eval.Evaluate(attValue);
603 }
604 }
605
606 dx *= lunit;
607 dy *= lunit;
608 dz *= lunit;
609
610 new G4EllipticalTube(name, dx, dy, dz);
611}
612
613// --------------------------------------------------------------------
614void G4GDMLReadSolids::XtruRead(const xercesc::DOMElement* const xtruElement)
615{
616 G4String name;
617 G4double lunit = 1.0;
618
619 const xercesc::DOMNamedNodeMap* const attributes =
620 xtruElement->getAttributes();
621 XMLSize_t attributeCount = attributes->getLength();
622
623 for(XMLSize_t attribute_index = 0; attribute_index < attributeCount;
624 ++attribute_index)
625 {
626 xercesc::DOMNode* attribute_node = attributes->item(attribute_index);
627
628 if(attribute_node->getNodeType() != xercesc::DOMNode::ATTRIBUTE_NODE)
629 {
630 continue;
631 }
632
633 const xercesc::DOMAttr* const attribute =
634 dynamic_cast<xercesc::DOMAttr*>(attribute_node);
635 if(attribute == nullptr)
636 {
637 G4Exception("G4GDMLReadSolids::XtruRead()", "InvalidRead", FatalException,
638 "No attribute found!");
639 return;
640 }
641 const G4String attName = Transcode(attribute->getName());
642 const G4String attValue = Transcode(attribute->getValue());
643
644 if(attName == "name")
645 {
646 name = GenerateName(attValue);
647 }
648 else if(attName == "lunit")
649 {
650 lunit = G4UnitDefinition::GetValueOf(attValue);
651 if(G4UnitDefinition::GetCategory(attValue) != "Length")
652 {
653 G4Exception("G4GDMLReadSolids::XtruRead()", "InvalidRead",
654 FatalException, "Invalid unit for length!");
655 }
656 }
657 }
658
659 std::vector<G4TwoVector> twoDimVertexList;
660 std::vector<G4ExtrudedSolid::ZSection> sectionList;
661
662 for(xercesc::DOMNode* iter = xtruElement->getFirstChild(); iter != nullptr;
663 iter = iter->getNextSibling())
664 {
665 if(iter->getNodeType() != xercesc::DOMNode::ELEMENT_NODE)
666 {
667 continue;
668 }
669
670 const xercesc::DOMElement* const child =
671 dynamic_cast<xercesc::DOMElement*>(iter);
672 if(child == nullptr)
673 {
674 G4Exception("G4GDMLReadSolids::XtruRead()", "InvalidRead", FatalException,
675 "No child found!");
676 return;
677 }
678 const G4String tag = Transcode(child->getTagName());
679
680 if(tag == "twoDimVertex")
681 {
682 twoDimVertexList.push_back(TwoDimVertexRead(child, lunit));
683 }
684 else if(tag == "section")
685 {
686 sectionList.push_back(SectionRead(child, lunit));
687 }
688 }
689
690 new G4ExtrudedSolid(name, twoDimVertexList, sectionList);
691}
692
693// --------------------------------------------------------------------
694void G4GDMLReadSolids::HypeRead(const xercesc::DOMElement* const hypeElement)
695{
696 G4String name;
697 G4double lunit = 1.0;
698 G4double aunit = 1.0;
699 G4double rmin = 0.0;
700 G4double rmax = 0.0;
701 G4double inst = 0.0;
702 G4double outst = 0.0;
703 G4double z = 0.0;
704
705 const xercesc::DOMNamedNodeMap* const attributes =
706 hypeElement->getAttributes();
707 XMLSize_t attributeCount = attributes->getLength();
708
709 for(XMLSize_t attribute_index = 0; attribute_index < attributeCount;
710 ++attribute_index)
711 {
712 xercesc::DOMNode* attribute_node = attributes->item(attribute_index);
713
714 if(attribute_node->getNodeType() != xercesc::DOMNode::ATTRIBUTE_NODE)
715 {
716 continue;
717 }
718
719 const xercesc::DOMAttr* const attribute =
720 dynamic_cast<xercesc::DOMAttr*>(attribute_node);
721 if(attribute == nullptr)
722 {
723 G4Exception("G4GDMLReadSolids::HypeRead()", "InvalidRead", FatalException,
724 "No attribute found!");
725 return;
726 }
727 const G4String attName = Transcode(attribute->getName());
728 const G4String attValue = Transcode(attribute->getValue());
729
730 if(attName == "name")
731 {
732 name = GenerateName(attValue);
733 }
734 else if(attName == "lunit")
735 {
736 lunit = G4UnitDefinition::GetValueOf(attValue);
737 if(G4UnitDefinition::GetCategory(attValue) != "Length")
738 {
739 G4Exception("G4GDMLReadSolids::HypeRead()", "InvalidRead",
740 FatalException, "Invalid unit for length!");
741 }
742 }
743 else if(attName == "aunit")
744 {
745 aunit = G4UnitDefinition::GetValueOf(attValue);
746 if(G4UnitDefinition::GetCategory(attValue) != "Angle")
747 {
748 G4Exception("G4GDMLReadSolids::HypeRead()", "InvalidRead",
749 FatalException, "Invalid unit for angle!");
750 }
751 }
752 else if(attName == "rmin")
753 {
754 rmin = eval.Evaluate(attValue);
755 }
756 else if(attName == "rmax")
757 {
758 rmax = eval.Evaluate(attValue);
759 }
760 else if(attName == "inst")
761 {
762 inst = eval.Evaluate(attValue);
763 }
764 else if(attName == "outst")
765 {
766 outst = eval.Evaluate(attValue);
767 }
768 else if(attName == "z")
769 {
770 z = eval.Evaluate(attValue);
771 }
772 }
773
774 rmin *= lunit;
775 rmax *= lunit;
776 inst *= aunit;
777 outst *= aunit;
778 z *= 0.5 * lunit;
779
780 new G4Hype(name, rmin, rmax, inst, outst, z);
781}
782
783// --------------------------------------------------------------------
784void G4GDMLReadSolids::MultiUnionNodeRead(
785 const xercesc::DOMElement* const unionNodeElement,
786 G4MultiUnion* const multiUnionSolid)
787{
788 G4String name;
789 G4String solid;
790 G4ThreeVector position(0.0, 0.0, 0.0);
791 G4ThreeVector rotation(0.0, 0.0, 0.0);
792
793 const xercesc::DOMNamedNodeMap* const attributes =
794 unionNodeElement->getAttributes();
795 XMLSize_t attributeCount = attributes->getLength();
796
797 for(XMLSize_t attribute_index = 0; attribute_index < attributeCount;
798 ++attribute_index)
799 {
800 xercesc::DOMNode* attribute_node = attributes->item(attribute_index);
801
802 if(attribute_node->getNodeType() != xercesc::DOMNode::ATTRIBUTE_NODE)
803 {
804 continue;
805 }
806
807 const xercesc::DOMAttr* const attribute =
808 dynamic_cast<xercesc::DOMAttr*>(attribute_node);
809 if(attribute == nullptr)
810 {
811 G4Exception("G4GDMLReadSolids::MultiUnionNodeRead()", "InvalidRead",
812 FatalException, "No attribute found!");
813 return;
814 }
815 const G4String attName = Transcode(attribute->getName());
816 const G4String attValue = Transcode(attribute->getValue());
817
818 if(attName == "name")
819 {
820 name = GenerateName(attValue);
821 }
822 }
823
824 for(xercesc::DOMNode* iter = unionNodeElement->getFirstChild();
825 iter != nullptr; iter = iter->getNextSibling())
826 {
827 if(iter->getNodeType() != xercesc::DOMNode::ELEMENT_NODE)
828 {
829 continue;
830 }
831
832 const xercesc::DOMElement* const child =
833 dynamic_cast<xercesc::DOMElement*>(iter);
834 if(child == nullptr)
835 {
836 G4Exception("G4GDMLReadSolids::MultiUnionNodeRead()", "InvalidRead",
837 FatalException, "No child found!");
838 return;
839 }
840 const G4String tag = Transcode(child->getTagName());
841
842 if(tag == "position")
843 {
844 VectorRead(child, position);
845 }
846 else if(tag == "rotation")
847 {
848 VectorRead(child, rotation);
849 }
850 else if(tag == "positionref")
851 {
852 position = GetPosition(GenerateName(RefRead(child)));
853 }
854 else if(tag == "rotationref")
855 {
856 rotation = GetRotation(GenerateName(RefRead(child)));
857 }
858 else if(tag == "solid")
859 {
860 solid = RefRead(child);
861 }
862 else
863 {
864 G4String error_msg = "Unknown tag in MultiUnion structure: " + tag;
865 G4Exception("G4GDMLReadSolids::MultiUnionNodeRead()", "ReadError",
866 FatalException, error_msg);
867 }
868 }
869 G4VSolid* solidNode = GetSolid(GenerateName(solid));
870 G4Transform3D transform(GetRotationMatrix(rotation), position);
871 multiUnionSolid->AddNode(*solidNode, transform);
872}
873
874// --------------------------------------------------------------------
875void G4GDMLReadSolids::MultiUnionRead(
876 const xercesc::DOMElement* const unionElement)
877{
878 G4String name;
879
880 const xercesc::DOMNamedNodeMap* const attributes =
881 unionElement->getAttributes();
882 XMLSize_t attributeCount = attributes->getLength();
883
884 for(XMLSize_t attribute_index = 0; attribute_index < attributeCount;
885 ++attribute_index)
886 {
887 xercesc::DOMNode* attribute_node = attributes->item(attribute_index);
888
889 if(attribute_node->getNodeType() != xercesc::DOMNode::ATTRIBUTE_NODE)
890 {
891 continue;
892 }
893
894 const xercesc::DOMAttr* const attribute =
895 dynamic_cast<xercesc::DOMAttr*>(attribute_node);
896 if(attribute == nullptr)
897 {
898 G4Exception("G4GDMLReadSolids::MultiUnionRead()", "InvalidRead",
899 FatalException, "No attribute found!");
900 return;
901 }
902 const G4String attName = Transcode(attribute->getName());
903 const G4String attValue = Transcode(attribute->getValue());
904
905 if(attName == "name")
906 {
907 name = GenerateName(attValue);
908 }
909 }
910
911 G4MultiUnion* multiUnion = new G4MultiUnion(name);
912
913 for(xercesc::DOMNode* iter = unionElement->getFirstChild(); iter != nullptr;
914 iter = iter->getNextSibling())
915 {
916 if(iter->getNodeType() != xercesc::DOMNode::ELEMENT_NODE)
917 {
918 continue;
919 }
920
921 const xercesc::DOMElement* const child =
922 dynamic_cast<xercesc::DOMElement*>(iter);
923 if(child == nullptr)
924 {
925 G4Exception("G4GDMLReadSolids::MultiUnionRead()", "InvalidRead",
926 FatalException, "No child found!");
927 return;
928 }
929 const G4String tag = Transcode(child->getTagName());
930
931 if(tag == "multiUnionNode")
932 {
933 MultiUnionNodeRead(child, multiUnion);
934 }
935 else
936 {
937 G4String error_msg = "Unknown tag in MultiUnion structure: " + tag;
938 G4Exception("G4GDMLReadSolids::MultiUnionRead()", "ReadError",
939 FatalException, error_msg);
940 }
941 }
942 multiUnion->Voxelize();
943}
944
945// --------------------------------------------------------------------
946void G4GDMLReadSolids::OrbRead(const xercesc::DOMElement* const orbElement)
947{
948 G4String name;
949 G4double lunit = 1.0;
950 G4double r = 0.0;
951
952 const xercesc::DOMNamedNodeMap* const attributes =
953 orbElement->getAttributes();
954 XMLSize_t attributeCount = attributes->getLength();
955
956 for(XMLSize_t attribute_index = 0; attribute_index < attributeCount;
957 ++attribute_index)
958 {
959 xercesc::DOMNode* attribute_node = attributes->item(attribute_index);
960
961 if(attribute_node->getNodeType() != xercesc::DOMNode::ATTRIBUTE_NODE)
962 {
963 continue;
964 }
965
966 const xercesc::DOMAttr* const attribute =
967 dynamic_cast<xercesc::DOMAttr*>(attribute_node);
968 if(attribute == nullptr)
969 {
970 G4Exception("G4GDMLReadSolids::OrbRead()", "InvalidRead", FatalException,
971 "No attribute found!");
972 return;
973 }
974 const G4String attName = Transcode(attribute->getName());
975 const G4String attValue = Transcode(attribute->getValue());
976
977 if(attName == "name")
978 {
979 name = GenerateName(attValue);
980 }
981 else if(attName == "lunit")
982 {
983 lunit = G4UnitDefinition::GetValueOf(attValue);
984 if(G4UnitDefinition::GetCategory(attValue) != "Length")
985 {
986 G4Exception("G4GDMLReadSolids::OrbRead()", "InvalidRead",
987 FatalException, "Invalid unit for length!");
988 }
989 }
990 else if(attName == "r")
991 {
992 r = eval.Evaluate(attValue);
993 }
994 }
995
996 r *= lunit;
997
998 new G4Orb(name, r);
999}
1000
1001// --------------------------------------------------------------------
1002void G4GDMLReadSolids::ParaRead(const xercesc::DOMElement* const paraElement)
1003{
1004 G4String name;
1005 G4double lunit = 1.0;
1006 G4double aunit = 1.0;
1007 G4double x = 0.0;
1008 G4double y = 0.0;
1009 G4double z = 0.0;
1010 G4double alpha = 0.0;
1011 G4double theta = 0.0;
1012 G4double phi = 0.0;
1013
1014 const xercesc::DOMNamedNodeMap* const attributes =
1015 paraElement->getAttributes();
1016 XMLSize_t attributeCount = attributes->getLength();
1017
1018 for(XMLSize_t attribute_index = 0; attribute_index < attributeCount;
1019 ++attribute_index)
1020 {
1021 xercesc::DOMNode* attribute_node = attributes->item(attribute_index);
1022
1023 if(attribute_node->getNodeType() != xercesc::DOMNode::ATTRIBUTE_NODE)
1024 {
1025 continue;
1026 }
1027
1028 const xercesc::DOMAttr* const attribute =
1029 dynamic_cast<xercesc::DOMAttr*>(attribute_node);
1030 if(attribute == nullptr)
1031 {
1032 G4Exception("G4GDMLReadSolids::ParaRead()", "InvalidRead", FatalException,
1033 "No attribute found!");
1034 return;
1035 }
1036 const G4String attName = Transcode(attribute->getName());
1037 const G4String attValue = Transcode(attribute->getValue());
1038
1039 if(attName == "name")
1040 {
1041 name = GenerateName(attValue);
1042 }
1043 else if(attName == "lunit")
1044 {
1045 lunit = G4UnitDefinition::GetValueOf(attValue);
1046 if(G4UnitDefinition::GetCategory(attValue) != "Length")
1047 {
1048 G4Exception("G4GDMLReadSolids::ParaRead()", "InvalidRead",
1049 FatalException, "Invalid unit for length!");
1050 }
1051 }
1052 else if(attName == "aunit")
1053 {
1054 aunit = G4UnitDefinition::GetValueOf(attValue);
1055 if(G4UnitDefinition::GetCategory(attValue) != "Angle")
1056 {
1057 G4Exception("G4GDMLReadSolids::ParaRead()", "InvalidRead",
1058 FatalException, "Invalid unit for angle!");
1059 }
1060 }
1061 else if(attName == "x")
1062 {
1063 x = eval.Evaluate(attValue);
1064 }
1065 else if(attName == "y")
1066 {
1067 y = eval.Evaluate(attValue);
1068 }
1069 else if(attName == "z")
1070 {
1071 z = eval.Evaluate(attValue);
1072 }
1073 else if(attName == "alpha")
1074 {
1075 alpha = eval.Evaluate(attValue);
1076 }
1077 else if(attName == "theta")
1078 {
1079 theta = eval.Evaluate(attValue);
1080 }
1081 else if(attName == "phi")
1082 {
1083 phi = eval.Evaluate(attValue);
1084 }
1085 }
1086
1087 x *= 0.5 * lunit;
1088 y *= 0.5 * lunit;
1089 z *= 0.5 * lunit;
1090 alpha *= aunit;
1091 theta *= aunit;
1092 phi *= aunit;
1093
1094 new G4Para(name, x, y, z, alpha, theta, phi);
1095}
1096
1097// --------------------------------------------------------------------
1098void G4GDMLReadSolids::ParaboloidRead(
1099 const xercesc::DOMElement* const paraElement)
1100{
1101 G4String name;
1102 G4double lunit = 1.0;
1103 G4double rlo = 0.0;
1104 G4double rhi = 0.0;
1105 G4double dz = 0.0;
1106
1107 const xercesc::DOMNamedNodeMap* const attributes =
1108 paraElement->getAttributes();
1109 XMLSize_t attributeCount = attributes->getLength();
1110
1111 for(XMLSize_t attribute_index = 0; attribute_index < attributeCount;
1112 ++attribute_index)
1113 {
1114 xercesc::DOMNode* attribute_node = attributes->item(attribute_index);
1115
1116 if(attribute_node->getNodeType() != xercesc::DOMNode::ATTRIBUTE_NODE)
1117 {
1118 continue;
1119 }
1120
1121 const xercesc::DOMAttr* const attribute =
1122 dynamic_cast<xercesc::DOMAttr*>(attribute_node);
1123 if(attribute == nullptr)
1124 {
1125 G4Exception("G4GDMLReadSolids::ParaboloidRead()", "InvalidRead",
1126 FatalException, "No attribute found!");
1127 return;
1128 }
1129 const G4String attName = Transcode(attribute->getName());
1130 const G4String attValue = Transcode(attribute->getValue());
1131
1132 if(attName == "name")
1133 {
1134 name = GenerateName(attValue);
1135 }
1136 else if(attName == "lunit")
1137 {
1138 lunit = G4UnitDefinition::GetValueOf(attValue);
1139 if(G4UnitDefinition::GetCategory(attValue) != "Length")
1140 {
1141 G4Exception("G4GDMLReadSolids::ParaboloidRead()", "InvalidRead",
1142 FatalException, "Invalid unit for length!");
1143 }
1144 }
1145 else if(attName == "rlo")
1146 {
1147 rlo = eval.Evaluate(attValue);
1148 }
1149 else if(attName == "rhi")
1150 {
1151 rhi = eval.Evaluate(attValue);
1152 }
1153 else if(attName == "dz")
1154 {
1155 dz = eval.Evaluate(attValue);
1156 }
1157 }
1158
1159 rlo *= 1. * lunit;
1160 rhi *= 1. * lunit;
1161 dz *= 1. * lunit;
1162
1163 new G4Paraboloid(name, dz, rlo, rhi);
1164}
1165
1166// --------------------------------------------------------------------
1167void G4GDMLReadSolids::PolyconeRead(
1168 const xercesc::DOMElement* const polyconeElement)
1169{
1170 G4String name;
1171 G4double lunit = 1.0;
1172 G4double aunit = 1.0;
1173 G4double startphi = 0.0;
1174 G4double deltaphi = 0.0;
1175
1176 const xercesc::DOMNamedNodeMap* const attributes =
1177 polyconeElement->getAttributes();
1178 XMLSize_t attributeCount = attributes->getLength();
1179
1180 for(XMLSize_t attribute_index = 0; attribute_index < attributeCount;
1181 ++attribute_index)
1182 {
1183 xercesc::DOMNode* attribute_node = attributes->item(attribute_index);
1184
1185 if(attribute_node->getNodeType() != xercesc::DOMNode::ATTRIBUTE_NODE)
1186 {
1187 continue;
1188 }
1189
1190 const xercesc::DOMAttr* const attribute =
1191 dynamic_cast<xercesc::DOMAttr*>(attribute_node);
1192 if(attribute == nullptr)
1193 {
1194 G4Exception("G4GDMLReadSolids::PolyconeRead()", "InvalidRead",
1195 FatalException, "No attribute found!");
1196 return;
1197 }
1198 const G4String attName = Transcode(attribute->getName());
1199 const G4String attValue = Transcode(attribute->getValue());
1200
1201 if(attName == "name")
1202 {
1203 name = GenerateName(attValue);
1204 }
1205 else if(attName == "lunit")
1206 {
1207 lunit = G4UnitDefinition::GetValueOf(attValue);
1208 if(G4UnitDefinition::GetCategory(attValue) != "Length")
1209 {
1210 G4Exception("G4GDMLReadSolids::PolyconeRead()", "InvalidRead",
1211 FatalException, "Invalid unit for length!");
1212 }
1213 }
1214 else if(attName == "aunit")
1215 {
1216 aunit = G4UnitDefinition::GetValueOf(attValue);
1217 if(G4UnitDefinition::GetCategory(attValue) != "Angle")
1218 {
1219 G4Exception("G4GDMLReadSolids::PolyconeRead()", "InvalidRead",
1220 FatalException, "Invalid unit for angle!");
1221 }
1222 }
1223 else if(attName == "startphi")
1224 {
1225 startphi = eval.Evaluate(attValue);
1226 }
1227 else if(attName == "deltaphi")
1228 {
1229 deltaphi = eval.Evaluate(attValue);
1230 }
1231 }
1232
1233 startphi *= aunit;
1234 deltaphi *= aunit;
1235
1236 std::vector<zplaneType> zplaneList;
1237
1238 for(xercesc::DOMNode* iter = polyconeElement->getFirstChild(); iter!= nullptr;
1239 iter = iter->getNextSibling())
1240 {
1241 if(iter->getNodeType() != xercesc::DOMNode::ELEMENT_NODE)
1242 {
1243 continue;
1244 }
1245
1246 const xercesc::DOMElement* const child =
1247 dynamic_cast<xercesc::DOMElement*>(iter);
1248 if(child == nullptr)
1249 {
1250 G4Exception("G4GDMLReadSolids::PolyconeRead()", "InvalidRead",
1251 FatalException, "No child found!");
1252 return;
1253 }
1254 const G4String tag = Transcode(child->getTagName());
1255
1256 if(tag == "zplane")
1257 {
1258 zplaneList.push_back(ZplaneRead(child));
1259 }
1260 }
1261
1262 std::size_t numZPlanes = zplaneList.size();
1263
1264 G4double* rmin_array = new G4double[numZPlanes];
1265 G4double* rmax_array = new G4double[numZPlanes];
1266 G4double* z_array = new G4double[numZPlanes];
1267
1268 for(std::size_t i = 0; i < numZPlanes; ++i)
1269 {
1270 rmin_array[i] = zplaneList[i].rmin * lunit;
1271 rmax_array[i] = zplaneList[i].rmax * lunit;
1272 z_array[i] = zplaneList[i].z * lunit;
1273 }
1274
1275 new G4Polycone(name, startphi, deltaphi, (G4int)numZPlanes, z_array,
1276 rmin_array, rmax_array);
1277
1278 delete[] rmin_array;
1279 delete[] rmax_array;
1280 delete[] z_array;
1281}
1282
1283// --------------------------------------------------------------------
1284void G4GDMLReadSolids::GenericPolyconeRead(
1285 const xercesc::DOMElement* const polyconeElement)
1286{
1287 G4String name;
1288 G4double lunit = 1.0;
1289 G4double aunit = 1.0;
1290 G4double startphi = 0.0;
1291 G4double deltaphi = 0.0;
1292
1293 const xercesc::DOMNamedNodeMap* const attributes =
1294 polyconeElement->getAttributes();
1295 XMLSize_t attributeCount = attributes->getLength();
1296
1297 for(XMLSize_t attribute_index = 0; attribute_index < attributeCount;
1298 ++attribute_index)
1299 {
1300 xercesc::DOMNode* attribute_node = attributes->item(attribute_index);
1301
1302 if(attribute_node->getNodeType() != xercesc::DOMNode::ATTRIBUTE_NODE)
1303 {
1304 continue;
1305 }
1306
1307 const xercesc::DOMAttr* const attribute =
1308 dynamic_cast<xercesc::DOMAttr*>(attribute_node);
1309 if(attribute == nullptr)
1310 {
1311 G4Exception("G4GDMLReadSolids::GenericPolyconeRead()", "InvalidRead",
1312 FatalException, "No attribute found!");
1313 return;
1314 }
1315 const G4String attName = Transcode(attribute->getName());
1316 const G4String attValue = Transcode(attribute->getValue());
1317
1318 if(attName == "name")
1319 {
1320 name = GenerateName(attValue);
1321 }
1322 else if(attName == "lunit")
1323 {
1324 lunit = G4UnitDefinition::GetValueOf(attValue);
1325 if(G4UnitDefinition::GetCategory(attValue) != "Length")
1326 {
1327 G4Exception("G4GDMLReadSolids::GenericPolyconeRead()", "InvalidRead",
1328 FatalException, "Invalid unit for length!");
1329 }
1330 }
1331 else if(attName == "aunit")
1332 {
1333 aunit = G4UnitDefinition::GetValueOf(attValue);
1334 if(G4UnitDefinition::GetCategory(attValue) != "Angle")
1335 {
1336 G4Exception("G4GDMLReadSolids::GenericPolyconeRead()", "InvalidRead",
1337 FatalException, "Invalid unit for angle!");
1338 }
1339 }
1340 else if(attName == "startphi")
1341 {
1342 startphi = eval.Evaluate(attValue);
1343 }
1344 else if(attName == "deltaphi")
1345 {
1346 deltaphi = eval.Evaluate(attValue);
1347 }
1348 }
1349
1350 startphi *= aunit;
1351 deltaphi *= aunit;
1352
1353 std::vector<rzPointType> rzPointList;
1354
1355 for(xercesc::DOMNode* iter = polyconeElement->getFirstChild();
1356 iter != nullptr; iter = iter->getNextSibling())
1357 {
1358 if(iter->getNodeType() != xercesc::DOMNode::ELEMENT_NODE)
1359 {
1360 continue;
1361 }
1362
1363 const xercesc::DOMElement* const child =
1364 dynamic_cast<xercesc::DOMElement*>(iter);
1365 if(child == nullptr)
1366 {
1367 G4Exception("G4GDMLReadSolids::GenericPolyconeRead()", "InvalidRead",
1368 FatalException, "No child found!");
1369 return;
1370 }
1371 const G4String tag = Transcode(child->getTagName());
1372
1373 if(tag == "rzpoint")
1374 {
1375 rzPointList.push_back(RZPointRead(child));
1376 }
1377 }
1378
1379 std::size_t numRZPoints = rzPointList.size();
1380
1381 G4double* r_array = new G4double[numRZPoints];
1382 G4double* z_array = new G4double[numRZPoints];
1383
1384 for(std::size_t i = 0; i < numRZPoints; ++i)
1385 {
1386 r_array[i] = rzPointList[i].r * lunit;
1387 z_array[i] = rzPointList[i].z * lunit;
1388 }
1389 new G4GenericPolycone(name, startphi, deltaphi, (G4int)numRZPoints,
1390 r_array, z_array);
1391 delete[] r_array;
1392 delete[] z_array;
1393}
1394
1395// --------------------------------------------------------------------
1396void G4GDMLReadSolids::PolyhedraRead(
1397 const xercesc::DOMElement* const polyhedraElement)
1398{
1399 G4String name;
1400 G4double lunit = 1.0;
1401 G4double aunit = 1.0;
1402 G4double startphi = 0.0;
1403 G4double deltaphi = 0.0;
1404 G4int numsides = 0;
1405
1406 const xercesc::DOMNamedNodeMap* const attributes =
1407 polyhedraElement->getAttributes();
1408 XMLSize_t attributeCount = attributes->getLength();
1409
1410 for(XMLSize_t attribute_index = 0; attribute_index < attributeCount;
1411 ++attribute_index)
1412 {
1413 xercesc::DOMNode* attribute_node = attributes->item(attribute_index);
1414
1415 if(attribute_node->getNodeType() != xercesc::DOMNode::ATTRIBUTE_NODE)
1416 {
1417 continue;
1418 }
1419
1420 const xercesc::DOMAttr* const attribute =
1421 dynamic_cast<xercesc::DOMAttr*>(attribute_node);
1422 if(attribute == nullptr)
1423 {
1424 G4Exception("G4GDMLReadSolids::PolyhedraRead()", "InvalidRead",
1425 FatalException, "No attribute found!");
1426 return;
1427 }
1428 const G4String attName = Transcode(attribute->getName());
1429 const G4String attValue = Transcode(attribute->getValue());
1430
1431 if(attName == "name")
1432 {
1433 name = GenerateName(attValue);
1434 }
1435 else if(attName == "lunit")
1436 {
1437 lunit = G4UnitDefinition::GetValueOf(attValue);
1438 if(G4UnitDefinition::GetCategory(attValue) != "Length")
1439 {
1440 G4Exception("G4GDMLReadSolids::PolyhedraRead()", "InvalidRead",
1441 FatalException, "Invalid unit for length!");
1442 }
1443 }
1444 else if(attName == "aunit")
1445 {
1446 aunit = G4UnitDefinition::GetValueOf(attValue);
1447 if(G4UnitDefinition::GetCategory(attValue) != "Angle")
1448 {
1449 G4Exception("G4GDMLReadSolids::PolyhedraRead()", "InvalidRead",
1450 FatalException, "Invalid unit for angle!");
1451 }
1452 }
1453 else if(attName == "startphi")
1454 {
1455 startphi = eval.Evaluate(attValue);
1456 }
1457 else if(attName == "deltaphi")
1458 {
1459 deltaphi = eval.Evaluate(attValue);
1460 }
1461 else if(attName == "numsides")
1462 {
1463 numsides = eval.EvaluateInteger(attValue);
1464 }
1465 }
1466
1467 startphi *= aunit;
1468 deltaphi *= aunit;
1469
1470 std::vector<zplaneType> zplaneList;
1471
1472 for(xercesc::DOMNode* iter = polyhedraElement->getFirstChild();
1473 iter != nullptr; iter = iter->getNextSibling())
1474 {
1475 if(iter->getNodeType() != xercesc::DOMNode::ELEMENT_NODE)
1476 {
1477 continue;
1478 }
1479
1480 const xercesc::DOMElement* const child =
1481 dynamic_cast<xercesc::DOMElement*>(iter);
1482 if(child == nullptr)
1483 {
1484 G4Exception("G4GDMLReadSolids::PolyhedraRead()", "InvalidRead",
1485 FatalException, "No child found!");
1486 return;
1487 }
1488 const G4String tag = Transcode(child->getTagName());
1489
1490 if(tag == "zplane")
1491 {
1492 zplaneList.push_back(ZplaneRead(child));
1493 }
1494 }
1495
1496 std::size_t numZPlanes = zplaneList.size();
1497
1498 G4double* rmin_array = new G4double[numZPlanes];
1499 G4double* rmax_array = new G4double[numZPlanes];
1500 G4double* z_array = new G4double[numZPlanes];
1501
1502 for(std::size_t i = 0; i < numZPlanes; ++i)
1503 {
1504 rmin_array[i] = zplaneList[i].rmin * lunit;
1505 rmax_array[i] = zplaneList[i].rmax * lunit;
1506 z_array[i] = zplaneList[i].z * lunit;
1507 }
1508
1509 new G4Polyhedra(name, startphi, deltaphi, numsides, (G4int)numZPlanes,
1510 z_array, rmin_array, rmax_array);
1511
1512 delete[] rmin_array;
1513 delete[] rmax_array;
1514 delete[] z_array;
1515}
1516
1517// --------------------------------------------------------------------
1518void G4GDMLReadSolids::GenericPolyhedraRead(
1519 const xercesc::DOMElement* const polyhedraElement)
1520{
1521 G4String name;
1522 G4double lunit = 1.0;
1523 G4double aunit = 1.0;
1524 G4double startphi = 0.0;
1525 G4double deltaphi = 0.0;
1526 G4int numsides = 0;
1527
1528 const xercesc::DOMNamedNodeMap* const attributes =
1529 polyhedraElement->getAttributes();
1530 XMLSize_t attributeCount = attributes->getLength();
1531
1532 for(XMLSize_t attribute_index = 0; attribute_index < attributeCount;
1533 ++attribute_index)
1534 {
1535 xercesc::DOMNode* attribute_node = attributes->item(attribute_index);
1536
1537 if(attribute_node->getNodeType() != xercesc::DOMNode::ATTRIBUTE_NODE)
1538 {
1539 continue;
1540 }
1541
1542 const xercesc::DOMAttr* const attribute =
1543 dynamic_cast<xercesc::DOMAttr*>(attribute_node);
1544 if(attribute == nullptr)
1545 {
1546 G4Exception("G4GDMLReadSolids::GenericPolyhedraRead()", "InvalidRead",
1547 FatalException, "No attribute found!");
1548 return;
1549 }
1550 const G4String attName = Transcode(attribute->getName());
1551 const G4String attValue = Transcode(attribute->getValue());
1552
1553 if(attName == "name")
1554 {
1555 name = GenerateName(attValue);
1556 }
1557 else if(attName == "lunit")
1558 {
1559 lunit = G4UnitDefinition::GetValueOf(attValue);
1560 if(G4UnitDefinition::GetCategory(attValue) != "Length")
1561 {
1562 G4Exception("G4GDMLReadSolids::GenericPolyhedraRead()", "InvalidRead",
1563 FatalException, "Invalid unit for length!");
1564 }
1565 }
1566 else if(attName == "aunit")
1567 {
1568 aunit = G4UnitDefinition::GetValueOf(attValue);
1569 if(G4UnitDefinition::GetCategory(attValue) != "Angle")
1570 {
1571 G4Exception("G4GDMLReadSolids::GenericPolyhedraRead()", "InvalidRead",
1572 FatalException, "Invalid unit for angle!");
1573 }
1574 }
1575 else if(attName == "startphi")
1576 {
1577 startphi = eval.Evaluate(attValue);
1578 }
1579 else if(attName == "deltaphi")
1580 {
1581 deltaphi = eval.Evaluate(attValue);
1582 }
1583 else if(attName == "numsides")
1584 {
1585 numsides = eval.EvaluateInteger(attValue);
1586 }
1587 }
1588
1589 startphi *= aunit;
1590 deltaphi *= aunit;
1591
1592 std::vector<rzPointType> rzpointList;
1593
1594 for(xercesc::DOMNode* iter = polyhedraElement->getFirstChild();
1595 iter != nullptr; iter = iter->getNextSibling())
1596 {
1597 if(iter->getNodeType() != xercesc::DOMNode::ELEMENT_NODE)
1598 {
1599 continue;
1600 }
1601
1602 const xercesc::DOMElement* const child =
1603 dynamic_cast<xercesc::DOMElement*>(iter);
1604 if(child == nullptr)
1605 {
1606 G4Exception("G4GDMLReadSolids::GenericPolyhedraRead()", "InvalidRead",
1607 FatalException, "No child found!");
1608 return;
1609 }
1610 const G4String tag = Transcode(child->getTagName());
1611
1612 if(tag == "rzpoint")
1613 {
1614 rzpointList.push_back(RZPointRead(child));
1615 }
1616 }
1617
1618 std::size_t numRZPoints = rzpointList.size();
1619
1620 G4double* r_array = new G4double[numRZPoints];
1621 G4double* z_array = new G4double[numRZPoints];
1622
1623 for(std::size_t i = 0; i < numRZPoints; ++i)
1624 {
1625 r_array[i] = rzpointList[i].r * lunit;
1626 z_array[i] = rzpointList[i].z * lunit;
1627 }
1628
1629 new G4Polyhedra(name, startphi, deltaphi, numsides, (G4int)numRZPoints,
1630 r_array, z_array);
1631
1632 delete[] r_array;
1633 delete[] z_array;
1634}
1635
1636// --------------------------------------------------------------------
1637G4QuadrangularFacet* G4GDMLReadSolids::QuadrangularRead(
1638 const xercesc::DOMElement* const quadrangularElement)
1639{
1640 G4ThreeVector vertex1;
1641 G4ThreeVector vertex2;
1642 G4ThreeVector vertex3;
1643 G4ThreeVector vertex4;
1644 G4FacetVertexType type = ABSOLUTE;
1645 G4double lunit = 1.0;
1646
1647 const xercesc::DOMNamedNodeMap* const attributes =
1648 quadrangularElement->getAttributes();
1649 XMLSize_t attributeCount = attributes->getLength();
1650
1651 for(XMLSize_t attribute_index = 0; attribute_index < attributeCount;
1652 ++attribute_index)
1653 {
1654 xercesc::DOMNode* attribute_node = attributes->item(attribute_index);
1655
1656 if(attribute_node->getNodeType() != xercesc::DOMNode::ATTRIBUTE_NODE)
1657 {
1658 continue;
1659 }
1660
1661 const xercesc::DOMAttr* const attribute =
1662 dynamic_cast<xercesc::DOMAttr*>(attribute_node);
1663 if(attribute == nullptr)
1664 {
1665 G4Exception("G4GDMLReadSolids::QuadrangularRead()", "InvalidRead",
1666 FatalException, "No attribute found!");
1667 return nullptr;
1668 }
1669 const G4String attName = Transcode(attribute->getName());
1670 const G4String attValue = Transcode(attribute->getValue());
1671
1672 if(attName == "vertex1")
1673 {
1674 vertex1 = GetPosition(GenerateName(attValue));
1675 }
1676 else if(attName == "vertex2")
1677 {
1678 vertex2 = GetPosition(GenerateName(attValue));
1679 }
1680 else if(attName == "vertex3")
1681 {
1682 vertex3 = GetPosition(GenerateName(attValue));
1683 }
1684 else if(attName == "vertex4")
1685 {
1686 vertex4 = GetPosition(GenerateName(attValue));
1687 }
1688 else if(attName == "lunit")
1689 {
1690 lunit = G4UnitDefinition::GetValueOf(attValue);
1691 if(G4UnitDefinition::GetCategory(attValue) != "Length")
1692 {
1693 G4Exception("G4GDMLReadSolids::QuadrangularRead()", "InvalidRead",
1694 FatalException, "Invalid unit for length!");
1695 }
1696 }
1697 else if(attName == "type")
1698 {
1699 if(attValue == "RELATIVE")
1700 {
1701 type = RELATIVE;
1702 }
1703 }
1704 }
1705
1706 return new G4QuadrangularFacet(vertex1 * lunit, vertex2 * lunit,
1707 vertex3 * lunit, vertex4 * lunit, type);
1708}
1709
1710// --------------------------------------------------------------------
1711void G4GDMLReadSolids::ReflectedSolidRead(
1712 const xercesc::DOMElement* const reflectedSolidElement)
1713{
1714 G4String name;
1715 G4double lunit = 1.0;
1716 G4double aunit = 1.0;
1717 G4String solid;
1718 G4ThreeVector scale(1.0, 1.0, 1.0);
1719 G4ThreeVector rotation;
1720 G4ThreeVector position;
1721
1722 const xercesc::DOMNamedNodeMap* const attributes =
1723 reflectedSolidElement->getAttributes();
1724 XMLSize_t attributeCount = attributes->getLength();
1725
1726 for(XMLSize_t attribute_index = 0; attribute_index < attributeCount;
1727 ++attribute_index)
1728 {
1729 xercesc::DOMNode* attribute_node = attributes->item(attribute_index);
1730
1731 if(attribute_node->getNodeType() != xercesc::DOMNode::ATTRIBUTE_NODE)
1732 {
1733 continue;
1734 }
1735
1736 const xercesc::DOMAttr* const attribute =
1737 dynamic_cast<xercesc::DOMAttr*>(attribute_node);
1738 if(attribute == nullptr)
1739 {
1740 G4Exception("G4GDMLReadSolids::ReflectedSolidRead()", "InvalidRead",
1741 FatalException, "No attribute found!");
1742 return;
1743 }
1744 const G4String attName = Transcode(attribute->getName());
1745 const G4String attValue = Transcode(attribute->getValue());
1746
1747 if(attName == "name")
1748 {
1749 name = GenerateName(attValue);
1750 }
1751 else if(attName == "lunit")
1752 {
1753 lunit = G4UnitDefinition::GetValueOf(attValue);
1754 if(G4UnitDefinition::GetCategory(attValue) != "Length")
1755 {
1756 G4Exception("G4GDMLReadSolids::ReflectedSolidRead()", "InvalidRead",
1757 FatalException, "Invalid unit for length!");
1758 }
1759 }
1760 else if(attName == "aunit")
1761 {
1762 aunit = G4UnitDefinition::GetValueOf(attValue);
1763 if(G4UnitDefinition::GetCategory(attValue) != "Angle")
1764 {
1765 G4Exception("G4GDMLReadSolids::ReflectedSolidRead()", "InvalidRead",
1766 FatalException, "Invalid unit for angle!");
1767 }
1768 }
1769 else if(attName == "solid")
1770 {
1771 solid = GenerateName(attValue);
1772 }
1773 else if(attName == "sx")
1774 {
1775 scale.setX(eval.Evaluate(attValue));
1776 }
1777 else if(attName == "sy")
1778 {
1779 scale.setY(eval.Evaluate(attValue));
1780 }
1781 else if(attName == "sz")
1782 {
1783 scale.setZ(eval.Evaluate(attValue));
1784 }
1785 else if(attName == "rx")
1786 {
1787 rotation.setX(eval.Evaluate(attValue));
1788 }
1789 else if(attName == "ry")
1790 {
1791 rotation.setY(eval.Evaluate(attValue));
1792 }
1793 else if(attName == "rz")
1794 {
1795 rotation.setZ(eval.Evaluate(attValue));
1796 }
1797 else if(attName == "dx")
1798 {
1799 position.setX(eval.Evaluate(attValue));
1800 }
1801 else if(attName == "dy")
1802 {
1803 position.setY(eval.Evaluate(attValue));
1804 }
1805 else if(attName == "dz")
1806 {
1807 position.setZ(eval.Evaluate(attValue));
1808 }
1809 }
1810
1811 rotation *= aunit;
1812 position *= lunit;
1813
1814 G4Transform3D transform(GetRotationMatrix(rotation), position);
1815 transform = transform * G4Scale3D(scale.x(), scale.y(), scale.z());
1816
1817 new G4ReflectedSolid(name, GetSolid(solid), transform);
1818}
1819
1820// --------------------------------------------------------------------
1821void G4GDMLReadSolids::ScaledSolidRead(
1822 const xercesc::DOMElement* const scaledSolidElement)
1823{
1824 G4String name;
1825 G4VSolid* solid = nullptr;
1826 G4ThreeVector scale(1.0, 1.0, 1.0);
1827
1828 const xercesc::DOMNamedNodeMap* const attributes =
1829 scaledSolidElement->getAttributes();
1830 XMLSize_t attributeCount = attributes->getLength();
1831
1832 for(XMLSize_t attribute_index = 0; attribute_index < attributeCount;
1833 ++attribute_index)
1834 {
1835 xercesc::DOMNode* attribute_node = attributes->item(attribute_index);
1836
1837 if(attribute_node->getNodeType() != xercesc::DOMNode::ATTRIBUTE_NODE)
1838 {
1839 continue;
1840 }
1841
1842 const xercesc::DOMAttr* const attribute =
1843 dynamic_cast<xercesc::DOMAttr*>(attribute_node);
1844 if(attribute == nullptr)
1845 {
1846 G4Exception("G4GDMLReadSolids::ScaledSolidRead()", "InvalidRead",
1847 FatalException, "No attribute found!");
1848 return;
1849 }
1850 const G4String attName = Transcode(attribute->getName());
1851 const G4String attValue = Transcode(attribute->getValue());
1852
1853 if(attName == "name")
1854 {
1855 name = GenerateName(attValue);
1856 }
1857 }
1858
1859 for(xercesc::DOMNode* iter = scaledSolidElement->getFirstChild();
1860 iter != nullptr; iter = iter->getNextSibling())
1861 {
1862 if(iter->getNodeType() != xercesc::DOMNode::ELEMENT_NODE)
1863 {
1864 continue;
1865 }
1866
1867 const xercesc::DOMElement* const child =
1868 dynamic_cast<xercesc::DOMElement*>(iter);
1869 if(child == nullptr)
1870 {
1871 G4Exception("G4GDMLReadSolids::ScaledSolidRead()", "InvalidRead",
1872 FatalException, "No child found!");
1873 return;
1874 }
1875 const G4String tag = Transcode(child->getTagName());
1876
1877 if(tag == "solidref")
1878 {
1879 solid = GetSolid(GenerateName(RefRead(child)));
1880 }
1881 else if(tag == "scale")
1882 {
1883 VectorRead(child, scale);
1884 }
1885 else if(tag == "scaleref")
1886 {
1887 scale = GetScale(GenerateName(RefRead(child)));
1888 }
1889 else
1890 {
1891 G4String error_msg = "Unknown tag in scaled solid: " + tag;
1892 G4Exception("G4GDMLReadSolids::ScaledSolidRead()", "ReadError",
1893 FatalException, error_msg);
1894 return;
1895 }
1896 }
1897
1898 G4Scale3D transform = G4Scale3D(scale.x(), scale.y(), scale.z());
1899
1900 new G4ScaledSolid(name, solid, transform);
1901}
1902
1903// --------------------------------------------------------------------
1904G4ExtrudedSolid::ZSection G4GDMLReadSolids::SectionRead(
1905 const xercesc::DOMElement* const sectionElement, G4double lunit)
1906{
1907 G4double zPosition = 0.0;
1908 G4TwoVector Offset;
1909 G4double scalingFactor = 1.0;
1910
1911 const xercesc::DOMNamedNodeMap* const attributes =
1912 sectionElement->getAttributes();
1913 XMLSize_t attributeCount = attributes->getLength();
1914
1915 for(XMLSize_t attribute_index = 0; attribute_index < attributeCount;
1916 ++attribute_index)
1917 {
1918 xercesc::DOMNode* attribute_node = attributes->item(attribute_index);
1919
1920 if(attribute_node->getNodeType() != xercesc::DOMNode::ATTRIBUTE_NODE)
1921 {
1922 continue;
1923 }
1924
1925 const xercesc::DOMAttr* const attribute =
1926 dynamic_cast<xercesc::DOMAttr*>(attribute_node);
1927 if(attribute == nullptr)
1928 {
1929 G4Exception("G4GDMLReadSolids::SectionRead()", "InvalidRead",
1930 FatalException, "No attribute found!");
1931 return G4ExtrudedSolid::ZSection(zPosition, Offset, scalingFactor);
1932 }
1933 const G4String attName = Transcode(attribute->getName());
1934 const G4String attValue = Transcode(attribute->getValue());
1935
1936 if(attName == "zPosition")
1937 {
1938 zPosition = eval.Evaluate(attValue) * lunit;
1939 }
1940 else if(attName == "xOffset")
1941 {
1942 Offset.setX(eval.Evaluate(attValue) * lunit);
1943 }
1944 else if(attName == "yOffset")
1945 {
1946 Offset.setY(eval.Evaluate(attValue) * lunit);
1947 }
1948 else if(attName == "scalingFactor")
1949 {
1950 scalingFactor = eval.Evaluate(attValue);
1951 }
1952 }
1953
1954 return G4ExtrudedSolid::ZSection(zPosition, Offset, scalingFactor);
1955}
1956
1957// --------------------------------------------------------------------
1958void G4GDMLReadSolids::SphereRead(
1959 const xercesc::DOMElement* const sphereElement)
1960{
1961 G4String name;
1962 G4double lunit = 1.0;
1963 G4double aunit = 1.0;
1964 G4double rmin = 0.0;
1965 G4double rmax = 0.0;
1966 G4double startphi = 0.0;
1967 G4double deltaphi = 0.0;
1968 G4double starttheta = 0.0;
1969 G4double deltatheta = 0.0;
1970
1971 const xercesc::DOMNamedNodeMap* const attributes =
1972 sphereElement->getAttributes();
1973 XMLSize_t attributeCount = attributes->getLength();
1974
1975 for(XMLSize_t attribute_index = 0; attribute_index < attributeCount;
1976 ++attribute_index)
1977 {
1978 xercesc::DOMNode* attribute_node = attributes->item(attribute_index);
1979
1980 if(attribute_node->getNodeType() != xercesc::DOMNode::ATTRIBUTE_NODE)
1981 {
1982 continue;
1983 }
1984
1985 const xercesc::DOMAttr* const attribute =
1986 dynamic_cast<xercesc::DOMAttr*>(attribute_node);
1987 if(attribute == nullptr)
1988 {
1989 G4Exception("G4GDMLReadSolids::SphereRead()", "InvalidRead",
1990 FatalException, "No attribute found!");
1991 return;
1992 }
1993 const G4String attName = Transcode(attribute->getName());
1994 const G4String attValue = Transcode(attribute->getValue());
1995
1996 if(attName == "name")
1997 {
1998 name = GenerateName(attValue);
1999 }
2000 else if(attName == "lunit")
2001 {
2002 lunit = G4UnitDefinition::GetValueOf(attValue);
2003 if(G4UnitDefinition::GetCategory(attValue) != "Length")
2004 {
2005 G4Exception("G4GDMLReadSolids::SphereRead()", "InvalidRead",
2006 FatalException, "Invalid unit for length!");
2007 }
2008 }
2009 else if(attName == "aunit")
2010 {
2011 aunit = G4UnitDefinition::GetValueOf(attValue);
2012 if(G4UnitDefinition::GetCategory(attValue) != "Angle")
2013 {
2014 G4Exception("G4GDMLReadSolids::SphereRead()", "InvalidRead",
2015 FatalException, "Invalid unit for angle!");
2016 }
2017 }
2018 else if(attName == "rmin")
2019 {
2020 rmin = eval.Evaluate(attValue);
2021 }
2022 else if(attName == "rmax")
2023 {
2024 rmax = eval.Evaluate(attValue);
2025 }
2026 else if(attName == "startphi")
2027 {
2028 startphi = eval.Evaluate(attValue);
2029 }
2030 else if(attName == "deltaphi")
2031 {
2032 deltaphi = eval.Evaluate(attValue);
2033 }
2034 else if(attName == "starttheta")
2035 {
2036 starttheta = eval.Evaluate(attValue);
2037 }
2038 else if(attName == "deltatheta")
2039 {
2040 deltatheta = eval.Evaluate(attValue);
2041 }
2042 }
2043
2044 rmin *= lunit;
2045 rmax *= lunit;
2046 startphi *= aunit;
2047 deltaphi *= aunit;
2048 starttheta *= aunit;
2049 deltatheta *= aunit;
2050
2051 new G4Sphere(name, rmin, rmax, startphi, deltaphi, starttheta, deltatheta);
2052}
2053
2054// --------------------------------------------------------------------
2055void G4GDMLReadSolids::TessellatedRead(
2056 const xercesc::DOMElement* const tessellatedElement)
2057{
2058 G4String name;
2059
2060 const xercesc::DOMNamedNodeMap* const attributes =
2061 tessellatedElement->getAttributes();
2062 XMLSize_t attributeCount = attributes->getLength();
2063
2064 for(XMLSize_t attribute_index = 0; attribute_index < attributeCount;
2065 ++attribute_index)
2066 {
2067 xercesc::DOMNode* attribute_node = attributes->item(attribute_index);
2068
2069 if(attribute_node->getNodeType() != xercesc::DOMNode::ATTRIBUTE_NODE)
2070 {
2071 continue;
2072 }
2073
2074 const xercesc::DOMAttr* const attribute =
2075 dynamic_cast<xercesc::DOMAttr*>(attribute_node);
2076 if(attribute == nullptr)
2077 {
2078 G4Exception("G4GDMLReadSolids::TessellatedRead()", "InvalidRead",
2079 FatalException, "No attribute found!");
2080 return;
2081 }
2082 const G4String attName = Transcode(attribute->getName());
2083 const G4String attValue = Transcode(attribute->getValue());
2084
2085 if(attName == "name")
2086 {
2087 name = GenerateName(attValue);
2088 }
2089 }
2090
2091 G4TessellatedSolid* tessellated = new G4TessellatedSolid(name);
2092
2093 for(xercesc::DOMNode* iter = tessellatedElement->getFirstChild();
2094 iter != nullptr; iter = iter->getNextSibling())
2095 {
2096 if(iter->getNodeType() != xercesc::DOMNode::ELEMENT_NODE)
2097 {
2098 continue;
2099 }
2100
2101 const xercesc::DOMElement* const child =
2102 dynamic_cast<xercesc::DOMElement*>(iter);
2103 if(child == nullptr)
2104 {
2105 G4Exception("G4GDMLReadSolids::TessellatedRead()", "InvalidRead",
2106 FatalException, "No child found!");
2107 return;
2108 }
2109 const G4String tag = Transcode(child->getTagName());
2110
2111 if(tag == "triangular")
2112 {
2113 tessellated->AddFacet(TriangularRead(child));
2114 }
2115 else if(tag == "quadrangular")
2116 {
2117 tessellated->AddFacet(QuadrangularRead(child));
2118 }
2119 }
2120
2121 tessellated->SetSolidClosed(true);
2122}
2123
2124// --------------------------------------------------------------------
2125void G4GDMLReadSolids::TetRead(const xercesc::DOMElement* const tetElement)
2126{
2127 G4String name;
2128 G4ThreeVector vertex1;
2129 G4ThreeVector vertex2;
2130 G4ThreeVector vertex3;
2131 G4ThreeVector vertex4;
2132 G4double lunit = 1.0;
2133
2134 const xercesc::DOMNamedNodeMap* const attributes =
2135 tetElement->getAttributes();
2136 XMLSize_t attributeCount = attributes->getLength();
2137
2138 for(XMLSize_t attribute_index = 0; attribute_index < attributeCount;
2139 ++attribute_index)
2140 {
2141 xercesc::DOMNode* attribute_node = attributes->item(attribute_index);
2142
2143 if(attribute_node->getNodeType() != xercesc::DOMNode::ATTRIBUTE_NODE)
2144 {
2145 continue;
2146 }
2147
2148 const xercesc::DOMAttr* const attribute =
2149 dynamic_cast<xercesc::DOMAttr*>(attribute_node);
2150 if(attribute == nullptr)
2151 {
2152 G4Exception("G4GDMLReadSolids::TetRead()", "InvalidRead", FatalException,
2153 "No attribute found!");
2154 return;
2155 }
2156 const G4String attName = Transcode(attribute->getName());
2157 const G4String attValue = Transcode(attribute->getValue());
2158
2159 if(attName == "name")
2160 {
2161 name = GenerateName(attValue);
2162 }
2163 else if(attName == "lunit")
2164 {
2165 lunit = G4UnitDefinition::GetValueOf(attValue);
2166 if(G4UnitDefinition::GetCategory(attValue) != "Length")
2167 {
2168 G4Exception("G4GDMLReadSolids::TetRead()", "InvalidRead",
2169 FatalException, "Invalid unit for length!");
2170 }
2171 }
2172 else if(attName == "vertex1")
2173 {
2174 vertex1 = GetPosition(GenerateName(attValue));
2175 }
2176 else if(attName == "vertex2")
2177 {
2178 vertex2 = GetPosition(GenerateName(attValue));
2179 }
2180 else if(attName == "vertex3")
2181 {
2182 vertex3 = GetPosition(GenerateName(attValue));
2183 }
2184 else if(attName == "vertex4")
2185 {
2186 vertex4 = GetPosition(GenerateName(attValue));
2187 }
2188 }
2189
2190 new G4Tet(name, vertex1 * lunit, vertex2 * lunit, vertex3 * lunit,
2191 vertex4 * lunit);
2192}
2193
2194// --------------------------------------------------------------------
2195void G4GDMLReadSolids::TorusRead(const xercesc::DOMElement* const torusElement)
2196{
2197 G4String name;
2198 G4double lunit = 1.0;
2199 G4double aunit = 1.0;
2200 G4double rmin = 0.0;
2201 G4double rmax = 0.0;
2202 G4double rtor = 0.0;
2203 G4double startphi = 0.0;
2204 G4double deltaphi = 0.0;
2205
2206 const xercesc::DOMNamedNodeMap* const attributes =
2207 torusElement->getAttributes();
2208 XMLSize_t attributeCount = attributes->getLength();
2209
2210 for(XMLSize_t attribute_index = 0; attribute_index < attributeCount;
2211 ++attribute_index)
2212 {
2213 xercesc::DOMNode* attribute_node = attributes->item(attribute_index);
2214
2215 if(attribute_node->getNodeType() != xercesc::DOMNode::ATTRIBUTE_NODE)
2216 {
2217 continue;
2218 }
2219
2220 const xercesc::DOMAttr* const attribute =
2221 dynamic_cast<xercesc::DOMAttr*>(attribute_node);
2222 if(attribute == nullptr)
2223 {
2224 G4Exception("G4GDMLReadSolids::TorusRead()", "InvalidRead",
2225 FatalException, "No attribute found!");
2226 return;
2227 }
2228 const G4String attName = Transcode(attribute->getName());
2229 const G4String attValue = Transcode(attribute->getValue());
2230
2231 if(attName == "name")
2232 {
2233 name = GenerateName(attValue);
2234 }
2235 else if(attName == "lunit")
2236 {
2237 lunit = G4UnitDefinition::GetValueOf(attValue);
2238 if(G4UnitDefinition::GetCategory(attValue) != "Length")
2239 {
2240 G4Exception("G4GDMLReadSolids::TorusRead()", "InvalidRead",
2241 FatalException, "Invalid unit for length!");
2242 }
2243 }
2244 else if(attName == "aunit")
2245 {
2246 aunit = G4UnitDefinition::GetValueOf(attValue);
2247 if(G4UnitDefinition::GetCategory(attValue) != "Angle")
2248 {
2249 G4Exception("G4GDMLReadSolids::TorusRead()", "InvalidRead",
2250 FatalException, "Invalid unit for angle!");
2251 }
2252 }
2253 else if(attName == "rmin")
2254 {
2255 rmin = eval.Evaluate(attValue);
2256 }
2257 else if(attName == "rmax")
2258 {
2259 rmax = eval.Evaluate(attValue);
2260 }
2261 else if(attName == "rtor")
2262 {
2263 rtor = eval.Evaluate(attValue);
2264 }
2265 else if(attName == "startphi")
2266 {
2267 startphi = eval.Evaluate(attValue);
2268 }
2269 else if(attName == "deltaphi")
2270 {
2271 deltaphi = eval.Evaluate(attValue);
2272 }
2273 }
2274
2275 rmin *= lunit;
2276 rmax *= lunit;
2277 rtor *= lunit;
2278 startphi *= aunit;
2279 deltaphi *= aunit;
2280
2281 new G4Torus(name, rmin, rmax, rtor, startphi, deltaphi);
2282}
2283
2284// --------------------------------------------------------------------
2285void G4GDMLReadSolids::GenTrapRead(
2286 const xercesc::DOMElement* const gtrapElement)
2287{
2288 G4String name;
2289 G4double lunit = 1.0;
2290 G4double dz = 0.0;
2291 G4double v1x = 0.0, v1y = 0.0, v2x = 0.0, v2y = 0.0, v3x = 0.0, v3y = 0.0,
2292 v4x = 0.0, v4y = 0.0, v5x = 0.0, v5y = 0.0, v6x = 0.0, v6y = 0.0,
2293 v7x = 0.0, v7y = 0.0, v8x = 0.0, v8y = 0.0;
2294
2295 const xercesc::DOMNamedNodeMap* const attributes =
2296 gtrapElement->getAttributes();
2297 XMLSize_t attributeCount = attributes->getLength();
2298
2299 for(XMLSize_t attribute_index = 0; attribute_index < attributeCount;
2300 ++attribute_index)
2301 {
2302 xercesc::DOMNode* attribute_node = attributes->item(attribute_index);
2303
2304 if(attribute_node->getNodeType() != xercesc::DOMNode::ATTRIBUTE_NODE)
2305 {
2306 continue;
2307 }
2308
2309 const xercesc::DOMAttr* const attribute =
2310 dynamic_cast<xercesc::DOMAttr*>(attribute_node);
2311 if(attribute == nullptr)
2312 {
2313 G4Exception("G4GDMLReadSolids::GenTrapRead()", "InvalidRead",
2314 FatalException, "No attribute found!");
2315 return;
2316 }
2317 const G4String attName = Transcode(attribute->getName());
2318 const G4String attValue = Transcode(attribute->getValue());
2319
2320 if(attName == "name")
2321 {
2322 name = GenerateName(attValue);
2323 }
2324 else if(attName == "lunit")
2325 {
2326 lunit = G4UnitDefinition::GetValueOf(attValue);
2327 if(G4UnitDefinition::GetCategory(attValue) != "Length")
2328 {
2329 G4Exception("G4GDMLReadSolids::GenTrapRead()", "InvalidRead",
2330 FatalException, "Invalid unit for length!");
2331 }
2332 }
2333 else if(attName == "dz")
2334 {
2335 dz = eval.Evaluate(attValue);
2336 }
2337 else if(attName == "v1x")
2338 {
2339 v1x = eval.Evaluate(attValue);
2340 }
2341 else if(attName == "v1y")
2342 {
2343 v1y = eval.Evaluate(attValue);
2344 }
2345 else if(attName == "v2x")
2346 {
2347 v2x = eval.Evaluate(attValue);
2348 }
2349 else if(attName == "v2y")
2350 {
2351 v2y = eval.Evaluate(attValue);
2352 }
2353 else if(attName == "v3x")
2354 {
2355 v3x = eval.Evaluate(attValue);
2356 }
2357 else if(attName == "v3y")
2358 {
2359 v3y = eval.Evaluate(attValue);
2360 }
2361 else if(attName == "v4x")
2362 {
2363 v4x = eval.Evaluate(attValue);
2364 }
2365 else if(attName == "v4y")
2366 {
2367 v4y = eval.Evaluate(attValue);
2368 }
2369 else if(attName == "v5x")
2370 {
2371 v5x = eval.Evaluate(attValue);
2372 }
2373 else if(attName == "v5y")
2374 {
2375 v5y = eval.Evaluate(attValue);
2376 }
2377 else if(attName == "v6x")
2378 {
2379 v6x = eval.Evaluate(attValue);
2380 }
2381 else if(attName == "v6y")
2382 {
2383 v6y = eval.Evaluate(attValue);
2384 }
2385 else if(attName == "v7x")
2386 {
2387 v7x = eval.Evaluate(attValue);
2388 }
2389 else if(attName == "v7y")
2390 {
2391 v7y = eval.Evaluate(attValue);
2392 }
2393 else if(attName == "v8x")
2394 {
2395 v8x = eval.Evaluate(attValue);
2396 }
2397 else if(attName == "v8y")
2398 {
2399 v8y = eval.Evaluate(attValue);
2400 }
2401 }
2402
2403 dz *= lunit;
2404 std::vector<G4TwoVector> vertices;
2405 vertices.push_back(G4TwoVector(v1x * lunit, v1y * lunit));
2406 vertices.push_back(G4TwoVector(v2x * lunit, v2y * lunit));
2407 vertices.push_back(G4TwoVector(v3x * lunit, v3y * lunit));
2408 vertices.push_back(G4TwoVector(v4x * lunit, v4y * lunit));
2409 vertices.push_back(G4TwoVector(v5x * lunit, v5y * lunit));
2410 vertices.push_back(G4TwoVector(v6x * lunit, v6y * lunit));
2411 vertices.push_back(G4TwoVector(v7x * lunit, v7y * lunit));
2412 vertices.push_back(G4TwoVector(v8x * lunit, v8y * lunit));
2413 new G4GenericTrap(name, dz, vertices);
2414}
2415
2416// --------------------------------------------------------------------
2417void G4GDMLReadSolids::TrapRead(const xercesc::DOMElement* const trapElement)
2418{
2419 G4String name;
2420 G4double lunit = 1.0;
2421 G4double aunit = 1.0;
2422 G4double z = 0.0;
2423 G4double theta = 0.0;
2424 G4double phi = 0.0;
2425 G4double y1 = 0.0;
2426 G4double x1 = 0.0;
2427 G4double x2 = 0.0;
2428 G4double alpha1 = 0.0;
2429 G4double y2 = 0.0;
2430 G4double x3 = 0.0;
2431 G4double x4 = 0.0;
2432 G4double alpha2 = 0.0;
2433
2434 const xercesc::DOMNamedNodeMap* const attributes =
2435 trapElement->getAttributes();
2436 XMLSize_t attributeCount = attributes->getLength();
2437
2438 for(XMLSize_t attribute_index = 0; attribute_index < attributeCount;
2439 ++attribute_index)
2440 {
2441 xercesc::DOMNode* attribute_node = attributes->item(attribute_index);
2442
2443 if(attribute_node->getNodeType() != xercesc::DOMNode::ATTRIBUTE_NODE)
2444 {
2445 continue;
2446 }
2447
2448 const xercesc::DOMAttr* const attribute =
2449 dynamic_cast<xercesc::DOMAttr*>(attribute_node);
2450 if(attribute == nullptr)
2451 {
2452 G4Exception("G4GDMLReadSolids::TrapRead()", "InvalidRead", FatalException,
2453 "No attribute found!");
2454 return;
2455 }
2456 const G4String attName = Transcode(attribute->getName());
2457 const G4String attValue = Transcode(attribute->getValue());
2458
2459 if(attName == "name")
2460 {
2461 name = GenerateName(attValue);
2462 }
2463 else if(attName == "lunit")
2464 {
2465 lunit = G4UnitDefinition::GetValueOf(attValue);
2466 if(G4UnitDefinition::GetCategory(attValue) != "Length")
2467 {
2468 G4Exception("G4GDMLReadSolids::TrapRead()", "InvalidRead",
2469 FatalException, "Invalid unit for length!");
2470 }
2471 }
2472 else if(attName == "aunit")
2473 {
2474 aunit = G4UnitDefinition::GetValueOf(attValue);
2475 if(G4UnitDefinition::GetCategory(attValue) != "Angle")
2476 {
2477 G4Exception("G4GDMLReadSolids::TrapRead()", "InvalidRead",
2478 FatalException, "Invalid unit for angle!");
2479 }
2480 }
2481 else if(attName == "z")
2482 {
2483 z = eval.Evaluate(attValue);
2484 }
2485 else if(attName == "theta")
2486 {
2487 theta = eval.Evaluate(attValue);
2488 }
2489 else if(attName == "phi")
2490 {
2491 phi = eval.Evaluate(attValue);
2492 }
2493 else if(attName == "y1")
2494 {
2495 y1 = eval.Evaluate(attValue);
2496 }
2497 else if(attName == "x1")
2498 {
2499 x1 = eval.Evaluate(attValue);
2500 }
2501 else if(attName == "x2")
2502 {
2503 x2 = eval.Evaluate(attValue);
2504 }
2505 else if(attName == "alpha1")
2506 {
2507 alpha1 = eval.Evaluate(attValue);
2508 }
2509 else if(attName == "y2")
2510 {
2511 y2 = eval.Evaluate(attValue);
2512 }
2513 else if(attName == "x3")
2514 {
2515 x3 = eval.Evaluate(attValue);
2516 }
2517 else if(attName == "x4")
2518 {
2519 x4 = eval.Evaluate(attValue);
2520 }
2521 else if(attName == "alpha2")
2522 {
2523 alpha2 = eval.Evaluate(attValue);
2524 }
2525 }
2526
2527 z *= 0.5 * lunit;
2528 theta *= aunit;
2529 phi *= aunit;
2530 y1 *= 0.5 * lunit;
2531 x1 *= 0.5 * lunit;
2532 x2 *= 0.5 * lunit;
2533 alpha1 *= aunit;
2534 y2 *= 0.5 * lunit;
2535 x3 *= 0.5 * lunit;
2536 x4 *= 0.5 * lunit;
2537 alpha2 *= aunit;
2538
2539 new G4Trap(name, z, theta, phi, y1, x1, x2, alpha1, y2, x3, x4, alpha2);
2540}
2541
2542// --------------------------------------------------------------------
2543void G4GDMLReadSolids::TrdRead(const xercesc::DOMElement* const trdElement)
2544{
2545 G4String name;
2546 G4double lunit = 1.0;
2547 G4double x1 = 0.0;
2548 G4double x2 = 0.0;
2549 G4double y1 = 0.0;
2550 G4double y2 = 0.0;
2551 G4double z = 0.0;
2552
2553 const xercesc::DOMNamedNodeMap* const attributes =
2554 trdElement->getAttributes();
2555 XMLSize_t attributeCount = attributes->getLength();
2556
2557 for(XMLSize_t attribute_index = 0; attribute_index < attributeCount;
2558 ++attribute_index)
2559 {
2560 xercesc::DOMNode* attribute_node = attributes->item(attribute_index);
2561
2562 if(attribute_node->getNodeType() != xercesc::DOMNode::ATTRIBUTE_NODE)
2563 {
2564 continue;
2565 }
2566
2567 const xercesc::DOMAttr* const attribute =
2568 dynamic_cast<xercesc::DOMAttr*>(attribute_node);
2569 if(attribute == nullptr)
2570 {
2571 G4Exception("G4GDMLReadSolids::TrdRead()", "InvalidRead", FatalException,
2572 "No attribute found!");
2573 return;
2574 }
2575 const G4String attName = Transcode(attribute->getName());
2576 const G4String attValue = Transcode(attribute->getValue());
2577
2578 if(attName == "name")
2579 {
2580 name = GenerateName(attValue);
2581 }
2582 else if(attName == "lunit")
2583 {
2584 lunit = G4UnitDefinition::GetValueOf(attValue);
2585 if(G4UnitDefinition::GetCategory(attValue) != "Length")
2586 {
2587 G4Exception("G4GDMLReadSolids::TrdRead()", "InvalidRead",
2588 FatalException, "Invalid unit for length!");
2589 }
2590 }
2591 else if(attName == "x1")
2592 {
2593 x1 = eval.Evaluate(attValue);
2594 }
2595 else if(attName == "x2")
2596 {
2597 x2 = eval.Evaluate(attValue);
2598 }
2599 else if(attName == "y1")
2600 {
2601 y1 = eval.Evaluate(attValue);
2602 }
2603 else if(attName == "y2")
2604 {
2605 y2 = eval.Evaluate(attValue);
2606 }
2607 else if(attName == "z")
2608 {
2609 z = eval.Evaluate(attValue);
2610 }
2611 }
2612
2613 x1 *= 0.5 * lunit;
2614 x2 *= 0.5 * lunit;
2615 y1 *= 0.5 * lunit;
2616 y2 *= 0.5 * lunit;
2617 z *= 0.5 * lunit;
2618
2619 new G4Trd(name, x1, x2, y1, y2, z);
2620}
2621
2622// --------------------------------------------------------------------
2623G4TriangularFacet* G4GDMLReadSolids::TriangularRead(
2624 const xercesc::DOMElement* const triangularElement)
2625{
2626 G4ThreeVector vertex1;
2627 G4ThreeVector vertex2;
2628 G4ThreeVector vertex3;
2629 G4FacetVertexType type = ABSOLUTE;
2630 G4double lunit = 1.0;
2631
2632 const xercesc::DOMNamedNodeMap* const attributes =
2633 triangularElement->getAttributes();
2634 XMLSize_t attributeCount = attributes->getLength();
2635
2636 for(XMLSize_t attribute_index = 0; attribute_index < attributeCount;
2637 ++attribute_index)
2638 {
2639 xercesc::DOMNode* attribute_node = attributes->item(attribute_index);
2640
2641 if(attribute_node->getNodeType() != xercesc::DOMNode::ATTRIBUTE_NODE)
2642 {
2643 continue;
2644 }
2645
2646 const xercesc::DOMAttr* const attribute =
2647 dynamic_cast<xercesc::DOMAttr*>(attribute_node);
2648 if(attribute == nullptr)
2649 {
2650 G4Exception("G4GDMLReadSolids::TriangularRead()", "InvalidRead",
2651 FatalException, "No attribute found!");
2652 return nullptr;
2653 }
2654 const G4String attName = Transcode(attribute->getName());
2655 const G4String attValue = Transcode(attribute->getValue());
2656
2657 if(attName == "vertex1")
2658 {
2659 vertex1 = GetPosition(GenerateName(attValue));
2660 }
2661 else if(attName == "vertex2")
2662 {
2663 vertex2 = GetPosition(GenerateName(attValue));
2664 }
2665 else if(attName == "vertex3")
2666 {
2667 vertex3 = GetPosition(GenerateName(attValue));
2668 }
2669 else if(attName == "lunit")
2670 {
2671 lunit = G4UnitDefinition::GetValueOf(attValue);
2672 if(G4UnitDefinition::GetCategory(attValue) != "Length")
2673 {
2674 G4Exception("G4GDMLReadSolids::TriangularRead()", "InvalidRead",
2675 FatalException, "Invalid unit for length!");
2676 }
2677 }
2678 else if(attName == "type")
2679 {
2680 if(attValue == "RELATIVE")
2681 {
2682 type = RELATIVE;
2683 }
2684 }
2685 }
2686
2687 return new G4TriangularFacet(vertex1 * lunit, vertex2 * lunit,
2688 vertex3 * lunit, type);
2689}
2690
2691// --------------------------------------------------------------------
2692void G4GDMLReadSolids::TubeRead(const xercesc::DOMElement* const tubeElement)
2693{
2694 G4String name;
2695 G4double lunit = 1.0;
2696 G4double aunit = 1.0;
2697 G4double rmin = 0.0;
2698 G4double rmax = 0.0;
2699 G4double z = 0.0;
2700 G4double startphi = 0.0;
2701 G4double deltaphi = 0.0;
2702
2703 const xercesc::DOMNamedNodeMap* const attributes =
2704 tubeElement->getAttributes();
2705 XMLSize_t attributeCount = attributes->getLength();
2706
2707 for(XMLSize_t attribute_index = 0; attribute_index < attributeCount;
2708 ++attribute_index)
2709 {
2710 xercesc::DOMNode* attribute_node = attributes->item(attribute_index);
2711
2712 if(attribute_node->getNodeType() != xercesc::DOMNode::ATTRIBUTE_NODE)
2713 {
2714 continue;
2715 }
2716
2717 const xercesc::DOMAttr* const attribute =
2718 dynamic_cast<xercesc::DOMAttr*>(attribute_node);
2719 if(attribute == nullptr)
2720 {
2721 G4Exception("G4GDMLReadSolids::TubeRead()", "InvalidRead", FatalException,
2722 "No attribute found!");
2723 return;
2724 }
2725 const G4String attName = Transcode(attribute->getName());
2726 const G4String attValue = Transcode(attribute->getValue());
2727
2728 if(attName == "name")
2729 {
2730 name = GenerateName(attValue);
2731 }
2732 else if(attName == "lunit")
2733 {
2734 lunit = G4UnitDefinition::GetValueOf(attValue);
2735 if(G4UnitDefinition::GetCategory(attValue) != "Length")
2736 {
2737 G4Exception("G4GDMLReadSolids::TubeRead()", "InvalidRead",
2738 FatalException, "Invalid unit for length!");
2739 }
2740 }
2741 else if(attName == "aunit")
2742 {
2743 aunit = G4UnitDefinition::GetValueOf(attValue);
2744 if(G4UnitDefinition::GetCategory(attValue) != "Angle")
2745 {
2746 G4Exception("G4GDMLReadSolids::TubeRead()", "InvalidRead",
2747 FatalException, "Invalid unit for angle!");
2748 }
2749 }
2750 else if(attName == "rmin")
2751 {
2752 rmin = eval.Evaluate(attValue);
2753 }
2754 else if(attName == "rmax")
2755 {
2756 rmax = eval.Evaluate(attValue);
2757 }
2758 else if(attName == "z")
2759 {
2760 z = eval.Evaluate(attValue);
2761 }
2762 else if(attName == "startphi")
2763 {
2764 startphi = eval.Evaluate(attValue);
2765 }
2766 else if(attName == "deltaphi")
2767 {
2768 deltaphi = eval.Evaluate(attValue);
2769 }
2770 }
2771
2772 rmin *= lunit;
2773 rmax *= lunit;
2774 z *= 0.5 * lunit;
2775 startphi *= aunit;
2776 deltaphi *= aunit;
2777
2778 new G4Tubs(name, rmin, rmax, z, startphi, deltaphi);
2779}
2780
2781// --------------------------------------------------------------------
2782void G4GDMLReadSolids::CutTubeRead(
2783 const xercesc::DOMElement* const cuttubeElement)
2784{
2785 G4String name;
2786 G4double lunit = 1.0;
2787 G4double aunit = 1.0;
2788 G4double rmin = 0.0;
2789 G4double rmax = 0.0;
2790 G4double z = 0.0;
2791 G4double startphi = 0.0;
2792 G4double deltaphi = 0.0;
2793 G4ThreeVector lowNorm(0);
2794 G4ThreeVector highNorm(0);
2795
2796 const xercesc::DOMNamedNodeMap* const attributes =
2797 cuttubeElement->getAttributes();
2798 XMLSize_t attributeCount = attributes->getLength();
2799
2800 for(XMLSize_t attribute_index = 0; attribute_index < attributeCount;
2801 ++attribute_index)
2802 {
2803 xercesc::DOMNode* attribute_node = attributes->item(attribute_index);
2804
2805 if(attribute_node->getNodeType() != xercesc::DOMNode::ATTRIBUTE_NODE)
2806 {
2807 continue;
2808 }
2809
2810 const xercesc::DOMAttr* const attribute =
2811 dynamic_cast<xercesc::DOMAttr*>(attribute_node);
2812 if(attribute == nullptr)
2813 {
2814 G4Exception("G4GDMLReadSolids::CutTubeRead()", "InvalidRead",
2815 FatalException, "No attribute found!");
2816 return;
2817 }
2818 const G4String attName = Transcode(attribute->getName());
2819 const G4String attValue = Transcode(attribute->getValue());
2820
2821 if(attName == "name")
2822 {
2823 name = GenerateName(attValue);
2824 }
2825 else if(attName == "lunit")
2826 {
2827 lunit = G4UnitDefinition::GetValueOf(attValue);
2828 if(G4UnitDefinition::GetCategory(attValue) != "Length")
2829 {
2830 G4Exception("G4GDMLReadSolids::CutTubeRead()", "InvalidRead",
2831 FatalException, "Invalid unit for length!");
2832 }
2833 }
2834 else if(attName == "aunit")
2835 {
2836 aunit = G4UnitDefinition::GetValueOf(attValue);
2837 if(G4UnitDefinition::GetCategory(attValue) != "Angle")
2838 {
2839 G4Exception("G4GDMLReadSolids::CutTubeRead()", "InvalidRead",
2840 FatalException, "Invalid unit for angle!");
2841 }
2842 }
2843 else if(attName == "rmin")
2844 {
2845 rmin = eval.Evaluate(attValue);
2846 }
2847 else if(attName == "rmax")
2848 {
2849 rmax = eval.Evaluate(attValue);
2850 }
2851 else if(attName == "z")
2852 {
2853 z = eval.Evaluate(attValue);
2854 }
2855 else if(attName == "startphi")
2856 {
2857 startphi = eval.Evaluate(attValue);
2858 }
2859 else if(attName == "deltaphi")
2860 {
2861 deltaphi = eval.Evaluate(attValue);
2862 }
2863 else if(attName == "lowX")
2864 {
2865 lowNorm.setX(eval.Evaluate(attValue));
2866 }
2867 else if(attName == "lowY")
2868 {
2869 lowNorm.setY(eval.Evaluate(attValue));
2870 }
2871 else if(attName == "lowZ")
2872 {
2873 lowNorm.setZ(eval.Evaluate(attValue));
2874 }
2875 else if(attName == "highX")
2876 {
2877 highNorm.setX(eval.Evaluate(attValue));
2878 }
2879 else if(attName == "highY")
2880 {
2881 highNorm.setY(eval.Evaluate(attValue));
2882 }
2883 else if(attName == "highZ")
2884 {
2885 highNorm.setZ(eval.Evaluate(attValue));
2886 }
2887 }
2888
2889 rmin *= lunit;
2890 rmax *= lunit;
2891 z *= 0.5 * lunit;
2892 startphi *= aunit;
2893 deltaphi *= aunit;
2894
2895 new G4CutTubs(name, rmin, rmax, z, startphi, deltaphi, lowNorm, highNorm);
2896}
2897
2898// --------------------------------------------------------------------
2899void G4GDMLReadSolids::TwistedboxRead(
2900 const xercesc::DOMElement* const twistedboxElement)
2901{
2902 G4String name;
2903 G4double lunit = 1.0;
2904 G4double aunit = 1.0;
2905 G4double PhiTwist = 0.0;
2906 G4double x = 0.0;
2907 G4double y = 0.0;
2908 G4double z = 0.0;
2909
2910 const xercesc::DOMNamedNodeMap* const attributes =
2911 twistedboxElement->getAttributes();
2912 XMLSize_t attributeCount = attributes->getLength();
2913
2914 for(XMLSize_t attribute_index = 0; attribute_index < attributeCount;
2915 ++attribute_index)
2916 {
2917 xercesc::DOMNode* attribute_node = attributes->item(attribute_index);
2918
2919 if(attribute_node->getNodeType() != xercesc::DOMNode::ATTRIBUTE_NODE)
2920 {
2921 continue;
2922 }
2923
2924 const xercesc::DOMAttr* const attribute =
2925 dynamic_cast<xercesc::DOMAttr*>(attribute_node);
2926 if(attribute == nullptr)
2927 {
2928 G4Exception("G4GDMLReadSolids::TwistedboxRead()", "InvalidRead",
2929 FatalException, "No attribute found!");
2930 return;
2931 }
2932 const G4String attName = Transcode(attribute->getName());
2933 const G4String attValue = Transcode(attribute->getValue());
2934
2935 if(attName == "name")
2936 {
2937 name = GenerateName(attValue);
2938 }
2939 else if(attName == "lunit")
2940 {
2941 lunit = G4UnitDefinition::GetValueOf(attValue);
2942 if(G4UnitDefinition::GetCategory(attValue) != "Length")
2943 {
2944 G4Exception("G4GDMLReadSolids::TwistedBoxRead()", "InvalidRead",
2945 FatalException, "Invalid unit for length!");
2946 }
2947 }
2948 else if(attName == "aunit")
2949 {
2950 aunit = G4UnitDefinition::GetValueOf(attValue);
2951 if(G4UnitDefinition::GetCategory(attValue) != "Angle")
2952 {
2953 G4Exception("G4GDMLReadSolids::TwistedboxRead()", "InvalidRead",
2954 FatalException, "Invalid unit for angle!");
2955 }
2956 }
2957 else if(attName == "PhiTwist")
2958 {
2959 PhiTwist = eval.Evaluate(attValue);
2960 }
2961 else if(attName == "x")
2962 {
2963 x = eval.Evaluate(attValue);
2964 }
2965 else if(attName == "y")
2966 {
2967 y = eval.Evaluate(attValue);
2968 }
2969 else if(attName == "z")
2970 {
2971 z = eval.Evaluate(attValue);
2972 }
2973 }
2974
2975 PhiTwist *= aunit;
2976 x *= 0.5 * lunit;
2977 y *= 0.5 * lunit;
2978 z *= 0.5 * lunit;
2979
2980 new G4TwistedBox(name, PhiTwist, x, y, z);
2981}
2982
2983// --------------------------------------------------------------------
2984void G4GDMLReadSolids::TwistedtrapRead(
2985 const xercesc::DOMElement* const twistedtrapElement)
2986{
2987 G4String name;
2988 G4double lunit = 1.0;
2989 G4double aunit = 1.0;
2990 G4double PhiTwist = 0.0;
2991 G4double z = 0.0;
2992 G4double Theta = 0.0;
2993 G4double Phi = 0.0;
2994 G4double y1 = 0.0;
2995 G4double x1 = 0.0;
2996 G4double x2 = 0.0;
2997 G4double y2 = 0.0;
2998 G4double x3 = 0.0;
2999 G4double x4 = 0.0;
3000 G4double Alph = 0.0;
3001
3002 const xercesc::DOMNamedNodeMap* const attributes =
3003 twistedtrapElement->getAttributes();
3004 XMLSize_t attributeCount = attributes->getLength();
3005
3006 for(XMLSize_t attribute_index = 0; attribute_index < attributeCount;
3007 ++attribute_index)
3008 {
3009 xercesc::DOMNode* attribute_node = attributes->item(attribute_index);
3010
3011 if(attribute_node->getNodeType() != xercesc::DOMNode::ATTRIBUTE_NODE)
3012 {
3013 continue;
3014 }
3015
3016 const xercesc::DOMAttr* const attribute =
3017 dynamic_cast<xercesc::DOMAttr*>(attribute_node);
3018 if(attribute == nullptr)
3019 {
3020 G4Exception("G4GDMLReadSolids::TwistedtrapRead()", "InvalidRead",
3021 FatalException, "No attribute found!");
3022 return;
3023 }
3024 const G4String attName = Transcode(attribute->getName());
3025 const G4String attValue = Transcode(attribute->getValue());
3026
3027 if(attName == "name")
3028 {
3029 name = GenerateName(attValue);
3030 }
3031 else if(attName == "lunit")
3032 {
3033 lunit = G4UnitDefinition::GetValueOf(attValue);
3034 if(G4UnitDefinition::GetCategory(attValue) != "Length")
3035 {
3036 G4Exception("G4GDMLReadSolids::TwistedtrapRead()", "InvalidRead",
3037 FatalException, "Invalid unit for length!");
3038 }
3039 }
3040 else if(attName == "aunit")
3041 {
3042 aunit = G4UnitDefinition::GetValueOf(attValue);
3043 if(G4UnitDefinition::GetCategory(attValue) != "Angle")
3044 {
3045 G4Exception("G4GDMLReadSolids::TwistedtrapRead()", "InvalidRead",
3046 FatalException, "Invalid unit for angle!");
3047 }
3048 }
3049 else if(attName == "PhiTwist")
3050 {
3051 PhiTwist = eval.Evaluate(attValue);
3052 }
3053 else if(attName == "z")
3054 {
3055 z = eval.Evaluate(attValue);
3056 }
3057 else if(attName == "Theta")
3058 {
3059 Theta = eval.Evaluate(attValue);
3060 }
3061 else if(attName == "Phi")
3062 {
3063 Phi = eval.Evaluate(attValue);
3064 }
3065 else if(attName == "y1")
3066 {
3067 y1 = eval.Evaluate(attValue);
3068 }
3069 else if(attName == "x1")
3070 {
3071 x1 = eval.Evaluate(attValue);
3072 }
3073 else if(attName == "x2")
3074 {
3075 x2 = eval.Evaluate(attValue);
3076 }
3077 else if(attName == "y2")
3078 {
3079 y2 = eval.Evaluate(attValue);
3080 }
3081 else if(attName == "x3")
3082 {
3083 x3 = eval.Evaluate(attValue);
3084 }
3085 else if(attName == "x4")
3086 {
3087 x4 = eval.Evaluate(attValue);
3088 }
3089 else if(attName == "Alph")
3090 {
3091 Alph = eval.Evaluate(attValue);
3092 }
3093 }
3094
3095 PhiTwist *= aunit;
3096 z *= 0.5 * lunit;
3097 Theta *= aunit;
3098 Phi *= aunit;
3099 Alph *= aunit;
3100 y1 *= 0.5 * lunit;
3101 x1 *= 0.5 * lunit;
3102 x2 *= 0.5 * lunit;
3103 y2 *= 0.5 * lunit;
3104 x3 *= 0.5 * lunit;
3105 x4 *= 0.5 * lunit;
3106
3107 new G4TwistedTrap(name, PhiTwist, z, Theta, Phi, y1, x1, x2, y2, x3, x4,
3108 Alph);
3109}
3110
3111// --------------------------------------------------------------------
3112void G4GDMLReadSolids::TwistedtrdRead(
3113 const xercesc::DOMElement* const twistedtrdElement)
3114{
3115 G4String name;
3116 G4double lunit = 1.0;
3117 G4double aunit = 1.0;
3118 G4double x1 = 0.0;
3119 G4double x2 = 0.0;
3120 G4double y1 = 0.0;
3121 G4double y2 = 0.0;
3122 G4double z = 0.0;
3123 G4double PhiTwist = 0.0;
3124
3125 const xercesc::DOMNamedNodeMap* const attributes =
3126 twistedtrdElement->getAttributes();
3127 XMLSize_t attributeCount = attributes->getLength();
3128
3129 for(XMLSize_t attribute_index = 0; attribute_index < attributeCount;
3130 ++attribute_index)
3131 {
3132 xercesc::DOMNode* attribute_node = attributes->item(attribute_index);
3133
3134 if(attribute_node->getNodeType() != xercesc::DOMNode::ATTRIBUTE_NODE)
3135 {
3136 continue;
3137 }
3138
3139 const xercesc::DOMAttr* const attribute =
3140 dynamic_cast<xercesc::DOMAttr*>(attribute_node);
3141 if(attribute == nullptr)
3142 {
3143 G4Exception("G4GDMLReadSolids::TwistedtrdRead()", "InvalidRead",
3144 FatalException, "No attribute found!");
3145 return;
3146 }
3147 const G4String attName = Transcode(attribute->getName());
3148 const G4String attValue = Transcode(attribute->getValue());
3149
3150 if(attName == "name")
3151 {
3152 name = GenerateName(attValue);
3153 }
3154 else if(attName == "lunit")
3155 {
3156 lunit = G4UnitDefinition::GetValueOf(attValue);
3157 if(G4UnitDefinition::GetCategory(attValue) != "Length")
3158 {
3159 G4Exception("G4GDMLReadSolids::TwistedtrdRead()", "InvalidRead",
3160 FatalException, "Invalid unit for length!");
3161 }
3162 }
3163 else if(attName == "aunit")
3164 {
3165 aunit = G4UnitDefinition::GetValueOf(attValue);
3166 if(G4UnitDefinition::GetCategory(attValue) != "Angle")
3167 {
3168 G4Exception("G4GDMLReadSolids::TwistedtrdRead()", "InvalidRead",
3169 FatalException, "Invalid unit for angle!");
3170 }
3171 }
3172 else if(attName == "x1")
3173 {
3174 x1 = eval.Evaluate(attValue);
3175 }
3176 else if(attName == "x2")
3177 {
3178 x2 = eval.Evaluate(attValue);
3179 }
3180 else if(attName == "y1")
3181 {
3182 y1 = eval.Evaluate(attValue);
3183 }
3184 else if(attName == "y2")
3185 {
3186 y2 = eval.Evaluate(attValue);
3187 }
3188 else if(attName == "z")
3189 {
3190 z = eval.Evaluate(attValue);
3191 }
3192 else if(attName == "PhiTwist")
3193 {
3194 PhiTwist = eval.Evaluate(attValue);
3195 }
3196 }
3197
3198 x1 *= 0.5 * lunit;
3199 x2 *= 0.5 * lunit;
3200 y1 *= 0.5 * lunit;
3201 y2 *= 0.5 * lunit;
3202 z *= 0.5 * lunit;
3203 PhiTwist *= aunit;
3204
3205 new G4TwistedTrd(name, x1, x2, y1, y2, z, PhiTwist);
3206}
3207
3208// --------------------------------------------------------------------
3209void G4GDMLReadSolids::TwistedtubsRead(
3210 const xercesc::DOMElement* const twistedtubsElement)
3211{
3212 G4String name;
3213 G4double lunit = 1.0;
3214 G4double aunit = 1.0;
3215 G4double twistedangle = 0.0;
3216 G4double endinnerrad = 0.0;
3217 G4double endouterrad = 0.0;
3218 G4double zlen = 0.0;
3219 G4double phi = 0.0;
3220 G4double totphi = 0.0;
3221 G4double midinnerrad = 0.0;
3222 G4double midouterrad = 0.0;
3223 G4double positiveEndz = 0.0;
3224 G4double negativeEndz = 0.0;
3225 G4int nseg = 0;
3226
3227 const xercesc::DOMNamedNodeMap* const attributes =
3228 twistedtubsElement->getAttributes();
3229 XMLSize_t attributeCount = attributes->getLength();
3230
3231 for(XMLSize_t attribute_index = 0; attribute_index < attributeCount;
3232 ++attribute_index)
3233 {
3234 xercesc::DOMNode* attribute_node = attributes->item(attribute_index);
3235
3236 if(attribute_node->getNodeType() != xercesc::DOMNode::ATTRIBUTE_NODE)
3237 {
3238 continue;
3239 }
3240
3241 const xercesc::DOMAttr* const attribute =
3242 dynamic_cast<xercesc::DOMAttr*>(attribute_node);
3243 if(attribute == nullptr)
3244 {
3245 G4Exception("G4GDMLReadSolids::TwistedtubsRead()", "InvalidRead",
3246 FatalException, "No attribute found!");
3247 return;
3248 }
3249 const G4String attName = Transcode(attribute->getName());
3250 const G4String attValue = Transcode(attribute->getValue());
3251
3252 if(attName == "name")
3253 {
3254 name = GenerateName(attValue);
3255 }
3256 else if(attName == "lunit")
3257 {
3258 lunit = G4UnitDefinition::GetValueOf(attValue);
3259 if(G4UnitDefinition::GetCategory(attValue) != "Length")
3260 {
3261 G4Exception("G4GDMLReadSolids::TwistedtubsRead()", "InvalidRead",
3262 FatalException, "Invalid unit for length!");
3263 }
3264 }
3265 else if(attName == "aunit")
3266 {
3267 aunit = G4UnitDefinition::GetValueOf(attValue);
3268 if(G4UnitDefinition::GetCategory(attValue) != "Angle")
3269 {
3270 G4Exception("G4GDMLReadSolids::TwistedtubsRead()", "InvalidRead",
3271 FatalException, "Invalid unit for angle!");
3272 }
3273 }
3274 else if(attName == "twistedangle")
3275 {
3276 twistedangle = eval.Evaluate(attValue);
3277 }
3278 else if(attName == "endinnerrad")
3279 {
3280 endinnerrad = eval.Evaluate(attValue);
3281 }
3282 else if(attName == "endouterrad")
3283 {
3284 endouterrad = eval.Evaluate(attValue);
3285 }
3286 else if(attName == "zlen")
3287 {
3288 zlen = eval.Evaluate(attValue);
3289 }
3290 else if(attName == "midinnerrad")
3291 {
3292 midinnerrad = eval.Evaluate(attValue);
3293 }
3294 else if(attName == "midouterrad")
3295 {
3296 midouterrad = eval.Evaluate(attValue);
3297 }
3298 else if(attName == "negativeEndz")
3299 {
3300 negativeEndz = eval.Evaluate(attValue);
3301 }
3302 else if(attName == "positiveEndz")
3303 {
3304 positiveEndz = eval.Evaluate(attValue);
3305 }
3306 else if(attName == "nseg")
3307 {
3308 nseg = eval.Evaluate(attValue);
3309 }
3310 else if(attName == "totphi")
3311 {
3312 totphi = eval.Evaluate(attValue);
3313 }
3314 else if(attName == "phi")
3315 {
3316 phi = eval.Evaluate(attValue);
3317 }
3318 }
3319
3320 twistedangle *= aunit;
3321 endinnerrad *= lunit;
3322 endouterrad *= lunit;
3323 zlen *= 0.5 * lunit;
3324 midinnerrad *= lunit;
3325 midouterrad *= lunit;
3326 positiveEndz *= lunit;
3327 negativeEndz *= lunit;
3328 phi *= aunit;
3329 totphi *= aunit;
3330
3331 if(zlen != 0.0)
3332 {
3333 if(nseg != 0)
3334 new G4TwistedTubs(name, twistedangle, endinnerrad, endouterrad, zlen,
3335 nseg, totphi);
3336 else
3337 new G4TwistedTubs(name, twistedangle, endinnerrad, endouterrad, zlen,
3338 phi);
3339 }
3340 else
3341 {
3342 if(nseg != 0)
3343 new G4TwistedTubs(name, twistedangle, midinnerrad, midouterrad,
3344 negativeEndz, positiveEndz, nseg, totphi);
3345 else
3346 new G4TwistedTubs(name, twistedangle, midinnerrad, midouterrad,
3347 negativeEndz, positiveEndz, phi);
3348 }
3349}
3350
3351// --------------------------------------------------------------------
3352G4TwoVector G4GDMLReadSolids::TwoDimVertexRead(
3353 const xercesc::DOMElement* const element, G4double lunit)
3354{
3355 G4TwoVector vec;
3356
3357 const xercesc::DOMNamedNodeMap* const attributes = element->getAttributes();
3358 XMLSize_t attributeCount = attributes->getLength();
3359
3360 for(XMLSize_t attribute_index = 0; attribute_index < attributeCount;
3361 ++attribute_index)
3362 {
3363 xercesc::DOMNode* attribute_node = attributes->item(attribute_index);
3364
3365 if(attribute_node->getNodeType() != xercesc::DOMNode::ATTRIBUTE_NODE)
3366 {
3367 continue;
3368 }
3369
3370 const xercesc::DOMAttr* const attribute =
3371 dynamic_cast<xercesc::DOMAttr*>(attribute_node);
3372 if(attribute == nullptr)
3373 {
3374 G4Exception("G4GDMLReadSolids::TwoDimVertexRead()", "InvalidRead",
3375 FatalException, "No attribute found!");
3376 return vec;
3377 }
3378 const G4String attName = Transcode(attribute->getName());
3379 const G4String attValue = Transcode(attribute->getValue());
3380
3381 if(attName == "x")
3382 {
3383 vec.setX(eval.Evaluate(attValue) * lunit);
3384 }
3385 else if(attName == "y")
3386 {
3387 vec.setY(eval.Evaluate(attValue) * lunit);
3388 }
3389 }
3390
3391 return vec;
3392}
3393
3394// --------------------------------------------------------------------
3395G4GDMLReadSolids::zplaneType G4GDMLReadSolids::ZplaneRead(
3396 const xercesc::DOMElement* const zplaneElement)
3397{
3398 zplaneType zplane = { 0., 0., 0. };
3399
3400 const xercesc::DOMNamedNodeMap* const attributes =
3401 zplaneElement->getAttributes();
3402 XMLSize_t attributeCount = attributes->getLength();
3403
3404 for(XMLSize_t attribute_index = 0; attribute_index < attributeCount;
3405 ++attribute_index)
3406 {
3407 xercesc::DOMNode* node = attributes->item(attribute_index);
3408
3409 if(node->getNodeType() != xercesc::DOMNode::ATTRIBUTE_NODE)
3410 {
3411 continue;
3412 }
3413
3414 const xercesc::DOMAttr* const attribute =
3415 dynamic_cast<xercesc::DOMAttr*>(node);
3416 if(attribute == nullptr)
3417 {
3418 G4Exception("G4GDMLReadSolids::ZplaneRead()", "InvalidRead",
3419 FatalException, "No attribute found!");
3420 return zplane;
3421 }
3422 const G4String attName = Transcode(attribute->getName());
3423 const G4String attValue = Transcode(attribute->getValue());
3424
3425 if(attName == "rmin")
3426 {
3427 zplane.rmin = eval.Evaluate(attValue);
3428 }
3429 else if(attName == "rmax")
3430 {
3431 zplane.rmax = eval.Evaluate(attValue);
3432 }
3433 else if(attName == "z")
3434 {
3435 zplane.z = eval.Evaluate(attValue);
3436 }
3437 }
3438
3439 return zplane;
3440}
3441
3442// --------------------------------------------------------------------
3443G4GDMLReadSolids::rzPointType G4GDMLReadSolids::RZPointRead(
3444 const xercesc::DOMElement* const zplaneElement)
3445{
3446 rzPointType rzpoint = { 0., 0. };
3447
3448 const xercesc::DOMNamedNodeMap* const attributes =
3449 zplaneElement->getAttributes();
3450 XMLSize_t attributeCount = attributes->getLength();
3451
3452 for(XMLSize_t attribute_index = 0; attribute_index < attributeCount;
3453 ++attribute_index)
3454 {
3455 xercesc::DOMNode* node = attributes->item(attribute_index);
3456
3457 if(node->getNodeType() != xercesc::DOMNode::ATTRIBUTE_NODE)
3458 {
3459 continue;
3460 }
3461
3462 const xercesc::DOMAttr* const attribute =
3463 dynamic_cast<xercesc::DOMAttr*>(node);
3464 if(attribute == nullptr)
3465 {
3466 G4Exception("G4GDMLReadSolids::RZPointRead()", "InvalidRead",
3467 FatalException, "No attribute found!");
3468 return rzpoint;
3469 }
3470 const G4String attName = Transcode(attribute->getName());
3471 const G4String attValue = Transcode(attribute->getValue());
3472
3473 if(attName == "r")
3474 {
3475 rzpoint.r = eval.Evaluate(attValue);
3476 }
3477 else if(attName == "z")
3478 {
3479 rzpoint.z = eval.Evaluate(attValue);
3480 }
3481 }
3482
3483 return rzpoint;
3484}
3485
3486// --------------------------------------------------------------------
3487void G4GDMLReadSolids::PropertyRead(
3488 const xercesc::DOMElement* const propertyElement,
3489 G4OpticalSurface* opticalsurface)
3490{
3491 G4String name;
3492 G4String ref;
3493 G4GDMLMatrix matrix;
3494
3495 const xercesc::DOMNamedNodeMap* const attributes =
3496 propertyElement->getAttributes();
3497 XMLSize_t attributeCount = attributes->getLength();
3498
3499 for(XMLSize_t attribute_index = 0; attribute_index < attributeCount;
3500 ++attribute_index)
3501 {
3502 xercesc::DOMNode* attribute_node = attributes->item(attribute_index);
3503
3504 if(attribute_node->getNodeType() != xercesc::DOMNode::ATTRIBUTE_NODE)
3505 {
3506 continue;
3507 }
3508
3509 const xercesc::DOMAttr* const attribute =
3510 dynamic_cast<xercesc::DOMAttr*>(attribute_node);
3511 if(attribute == nullptr)
3512 {
3513 G4Exception("G4GDMLReadSolids::PropertyRead()", "InvalidRead",
3514 FatalException, "No attribute found!");
3515 return;
3516 }
3517 const G4String attName = Transcode(attribute->getName());
3518 const G4String attValue = Transcode(attribute->getValue());
3519
3520 if(attName == "name")
3521 {
3522 name = GenerateName(attValue);
3523 }
3524 else if(attName == "ref")
3525 {
3526 matrix = GetMatrix(ref = attValue);
3527 }
3528 }
3529
3530 /*
3531 if (matrix.GetCols() != 2)
3532 {
3533 G4String error_msg = "Referenced matrix '" + ref
3534 + "' should have \n two columns as a property table for
3535 opticalsurface: "
3536 + opticalsurface->GetName();
3537 G4Exception("G4GDMLReadSolids::PropertyRead()", "InvalidRead",
3538 FatalException, error_msg);
3539 }
3540 */
3541
3542 if(matrix.GetRows() == 0)
3543 {
3544 return;
3545 }
3546
3547 G4MaterialPropertiesTable* matprop =
3548 opticalsurface->GetMaterialPropertiesTable();
3549 if(matprop == nullptr)
3550 {
3551 matprop = new G4MaterialPropertiesTable();
3552 opticalsurface->SetMaterialPropertiesTable(matprop);
3553 }
3554 if(matrix.GetCols() == 1) // constant property assumed
3555 {
3556 matprop->AddConstProperty(Strip(name), matrix.Get(0, 0), true);
3557 }
3558 else // build the material properties vector
3559 {
3560 G4MaterialPropertyVector* propvect;
3561 G4String temp = name + ref;
3562 // first check if it was already built
3563 if(mapOfMatPropVects.find(temp) == mapOfMatPropVects.end())
3564 {
3565 // if not create a new one
3566 propvect = new G4MaterialPropertyVector();
3567 for(size_t i = 0; i < matrix.GetRows(); i++)
3568 {
3569 propvect->InsertValues(matrix.Get(i, 0), matrix.Get(i, 1));
3570 }
3571 // and add it to the list for potential future reuse
3572 mapOfMatPropVects[temp] = propvect;
3573 }
3574 else
3575 {
3576 propvect = mapOfMatPropVects[temp];
3577 }
3578
3579 matprop->AddProperty(Strip(name), propvect, true);
3580 }
3581}
3582
3583// --------------------------------------------------------------------
3584void G4GDMLReadSolids::OpticalSurfaceRead(
3585 const xercesc::DOMElement* const opticalsurfaceElement)
3586{
3587 G4String name;
3588 G4String smodel;
3589 G4String sfinish;
3590 G4String stype;
3591 G4double value = 0.0;
3592
3593 const xercesc::DOMNamedNodeMap* const attributes =
3594 opticalsurfaceElement->getAttributes();
3595 XMLSize_t attributeCount = attributes->getLength();
3596
3597 for(XMLSize_t attribute_index = 0; attribute_index < attributeCount;
3598 ++attribute_index)
3599 {
3600 xercesc::DOMNode* attribute_node = attributes->item(attribute_index);
3601
3602 if(attribute_node->getNodeType() != xercesc::DOMNode::ATTRIBUTE_NODE)
3603 {
3604 continue;
3605 }
3606
3607 const xercesc::DOMAttr* const attribute =
3608 dynamic_cast<xercesc::DOMAttr*>(attribute_node);
3609 if(attribute == nullptr)
3610 {
3611 G4Exception("G4GDMLReadSolids::OpticalSurfaceRead()", "InvalidRead",
3612 FatalException, "No attribute found!");
3613 return;
3614 }
3615 const G4String attName = Transcode(attribute->getName());
3616 const G4String attValue = Transcode(attribute->getValue());
3617
3618 if(attName == "name")
3619 {
3620 name = GenerateName(attValue);
3621 }
3622 else if(attName == "model")
3623 {
3624 smodel = attValue;
3625 }
3626 else if(attName == "finish")
3627 {
3628 sfinish = attValue;
3629 }
3630 else if(attName == "type")
3631 {
3632 stype = attValue;
3633 }
3634 else if(attName == "value")
3635 {
3636 value = eval.Evaluate(attValue);
3637 }
3638 }
3639
3640 G4OpticalSurfaceModel model;
3641 G4OpticalSurfaceFinish finish;
3642 G4SurfaceType type;
3643
3644 if((smodel == "glisur") || (smodel == "0"))
3645 {
3646 model = glisur;
3647 }
3648 else if((smodel == "unified") || (smodel == "1"))
3649 {
3650 model = unified;
3651 }
3652 else if((smodel == "LUT") || (smodel == "2"))
3653 {
3654 model = LUT;
3655 }
3656 else if((smodel == "DAVIS") || (smodel == "3"))
3657 {
3658 model = DAVIS;
3659 }
3660 else
3661 {
3662 model = dichroic;
3663 }
3664
3665 if((sfinish == "polished") || (sfinish == "0"))
3666 {
3667 finish = polished;
3668 }
3669 else if((sfinish == "polishedfrontpainted") || (sfinish == "1"))
3670 {
3671 finish = polishedfrontpainted;
3672 }
3673 else if((sfinish == "polishedbackpainted") || (sfinish == "2"))
3674 {
3675 finish = polishedbackpainted;
3676 }
3677 else if((sfinish == "ground") || (sfinish == "3"))
3678 {
3679 finish = ground;
3680 }
3681 else if((sfinish == "groundfrontpainted") || (sfinish == "4"))
3682 {
3683 finish = groundfrontpainted;
3684 }
3685 else if((sfinish == "groundbackpainted") || (sfinish == "5"))
3686 {
3687 finish = groundbackpainted;
3688 }
3689 else if((sfinish == "polishedlumirrorair") || (sfinish == "6"))
3690 {
3691 finish = polishedlumirrorair;
3692 }
3693 else if((sfinish == "polishedlumirrorglue") || (sfinish == "7"))
3694 {
3695 finish = polishedlumirrorglue;
3696 }
3697 else if((sfinish == "polishedair") || (sfinish == "8"))
3698 {
3699 finish = polishedair;
3700 }
3701 else if((sfinish == "polishedteflonair") || (sfinish == "9"))
3702 {
3703 finish = polishedteflonair;
3704 }
3705 else if((sfinish == "polishedtioair") || (sfinish == "10"))
3706 {
3707 finish = polishedtioair;
3708 }
3709 else if((sfinish == "polishedtyvekair") || (sfinish == "11"))
3710 {
3711 finish = polishedtyvekair;
3712 }
3713 else if((sfinish == "polishedvm2000air") || (sfinish == "12"))
3714 {
3715 finish = polishedvm2000air;
3716 }
3717 else if((sfinish == "polishedvm2000glue") || (sfinish == "13"))
3718 {
3719 finish = polishedvm2000glue;
3720 }
3721 else if((sfinish == "etchedlumirrorair") || (sfinish == "14"))
3722 {
3723 finish = etchedlumirrorair;
3724 }
3725 else if((sfinish == "etchedlumirrorglue") || (sfinish == "15"))
3726 {
3727 finish = etchedlumirrorglue;
3728 }
3729 else if((sfinish == "etchedair") || (sfinish == "16"))
3730 {
3731 finish = etchedair;
3732 }
3733 else if((sfinish == "etchedteflonair") || (sfinish == "17"))
3734 {
3735 finish = etchedteflonair;
3736 }
3737 else if((sfinish == "etchedtioair") || (sfinish == "18"))
3738 {
3739 finish = etchedtioair;
3740 }
3741 else if((sfinish == "etchedtyvekair") || (sfinish == "19"))
3742 {
3743 finish = etchedtyvekair;
3744 }
3745 else if((sfinish == "etchedvm2000air") || (sfinish == "20"))
3746 {
3747 finish = etchedvm2000air;
3748 }
3749 else if((sfinish == "etchedvm2000glue") || (sfinish == "21"))
3750 {
3751 finish = etchedvm2000glue;
3752 }
3753 else if((sfinish == "groundlumirrorair") || (sfinish == "22"))
3754 {
3755 finish = groundlumirrorair;
3756 }
3757 else if((sfinish == "groundlumirrorglue") || (sfinish == "23"))
3758 {
3759 finish = groundlumirrorglue;
3760 }
3761 else if((sfinish == "groundair") || (sfinish == "24"))
3762 {
3763 finish = groundair;
3764 }
3765 else if((sfinish == "groundteflonair") || (sfinish == "25"))
3766 {
3767 finish = groundteflonair;
3768 }
3769 else if((sfinish == "groundtioair") || (sfinish == "26"))
3770 {
3771 finish = groundtioair;
3772 }
3773 else if((sfinish == "groundtyvekair") || (sfinish == "27"))
3774 {
3775 finish = groundtyvekair;
3776 }
3777 else if((sfinish == "groundvm2000air") || (sfinish == "28"))
3778 {
3779 finish = groundvm2000air;
3780 }
3781 else if((sfinish == "groundvm2000glue") || (sfinish == "29"))
3782 {
3783 finish = groundvm2000glue;
3784 }
3785 else if((sfinish == "Rough_LUT") || (sfinish == "30"))
3786 {
3787 finish = Rough_LUT;
3788 }
3789 else if((sfinish == "RoughTeflon_LUT") || (sfinish == "31"))
3790 {
3791 finish = RoughTeflon_LUT;
3792 }
3793 else if((sfinish == "RoughESR_LUT") || (sfinish == "32"))
3794 {
3795 finish = RoughESR_LUT;
3796 }
3797 else if((sfinish == "RoughESRGrease_LUT") || (sfinish == "33"))
3798 {
3799 finish = RoughESRGrease_LUT;
3800 }
3801 else if((sfinish == "Polished_LUT") || (sfinish == "34"))
3802 {
3803 finish = Polished_LUT;
3804 }
3805 else if((sfinish == "PolishedTeflon_LUT") || (sfinish == "35"))
3806 {
3807 finish = PolishedTeflon_LUT;
3808 }
3809 else if((sfinish == "PolishedESR_LUT") || (sfinish == "36"))
3810 {
3811 finish = PolishedESR_LUT;
3812 }
3813 else if((sfinish == "PolishedESRGrease_LUT") || (sfinish == "37"))
3814 {
3815 finish = PolishedESRGrease_LUT;
3816 }
3817 else
3818 {
3819 finish = Detector_LUT;
3820 }
3821
3822 if((stype == "dielectric_metal") || (stype == "0"))
3823 {
3824 type = dielectric_metal;
3825 }
3826 else if((stype == "dielectric_dielectric") || (stype == "1"))
3827 {
3828 type = dielectric_dielectric;
3829 }
3830 else if((stype == "dielectric_LUT") || (stype == "2"))
3831 {
3832 type = dielectric_LUT;
3833 }
3834 else if((stype == "dielectric_LUTDAVIS") || (stype == "3"))
3835 {
3836 type = dielectric_LUTDAVIS;
3837 }
3838 else if((stype == "dielectric_dichroic") || (stype == "4"))
3839 {
3840 type = dielectric_dichroic;
3841 }
3842 else if((stype == "firsov") || (stype == "5"))
3843 {
3844 type = firsov;
3845 }
3846 else
3847 {
3848 type = x_ray;
3849 }
3850
3851 G4OpticalSurface* opticalsurface =
3852 new G4OpticalSurface(name, model, finish, type, value);
3853
3854 for(xercesc::DOMNode* iter = opticalsurfaceElement->getFirstChild();
3855 iter != nullptr; iter = iter->getNextSibling())
3856 {
3857 if(iter->getNodeType() != xercesc::DOMNode::ELEMENT_NODE)
3858 {
3859 continue;
3860 }
3861
3862 const xercesc::DOMElement* const child =
3863 dynamic_cast<xercesc::DOMElement*>(iter);
3864 if(child == nullptr)
3865 {
3866 G4Exception("G4GDMLReadSolids::OpticalSurfaceRead()", "InvalidRead",
3867 FatalException, "No child found!");
3868 return;
3869 }
3870 const G4String tag = Transcode(child->getTagName());
3871
3872 if(tag == "property")
3873 {
3874 PropertyRead(child, opticalsurface);
3875 }
3876 }
3877}
3878
3879// --------------------------------------------------------------------
3880void G4GDMLReadSolids::SolidsRead(
3881 const xercesc::DOMElement* const solidsElement)
3882{
3883#ifdef G4VERBOSE
3884 G4cout << "G4GDML: Reading solids..." << G4endl;
3885#endif
3886 for(xercesc::DOMNode* iter = solidsElement->getFirstChild(); iter != nullptr;
3887 iter = iter->getNextSibling())
3888 {
3889 if(iter->getNodeType() != xercesc::DOMNode::ELEMENT_NODE)
3890 {
3891 continue;
3892 }
3893
3894 const xercesc::DOMElement* const child =
3895 dynamic_cast<xercesc::DOMElement*>(iter);
3896 if(child == nullptr)
3897 {
3898 G4Exception("G4GDMLReadSolids::SolidsRead()", "InvalidRead",
3899 FatalException, "No child found!");
3900 return;
3901 }
3902 const G4String tag = Transcode(child->getTagName());
3903 if(tag == "define")
3904 {
3905 DefineRead(child);
3906 }
3907 else if(tag == "box")
3908 {
3909 BoxRead(child);
3910 }
3911 else if(tag == "cone")
3912 {
3913 ConeRead(child);
3914 }
3915 else if(tag == "elcone")
3916 {
3917 ElconeRead(child);
3918 }
3919 else if(tag == "ellipsoid")
3920 {
3921 EllipsoidRead(child);
3922 }
3923 else if(tag == "eltube")
3924 {
3925 EltubeRead(child);
3926 }
3927 else if(tag == "xtru")
3928 {
3929 XtruRead(child);
3930 }
3931 else if(tag == "hype")
3932 {
3933 HypeRead(child);
3934 }
3935 else if(tag == "intersection")
3936 {
3937 BooleanRead(child, INTERSECTION);
3938 }
3939 else if(tag == "multiUnion")
3940 {
3941 MultiUnionRead(child);
3942 }
3943 else if(tag == "orb")
3944 {
3945 OrbRead(child);
3946 }
3947 else if(tag == "para")
3948 {
3949 ParaRead(child);
3950 }
3951 else if(tag == "paraboloid")
3952 {
3953 ParaboloidRead(child);
3954 }
3955 else if(tag == "polycone")
3956 {
3957 PolyconeRead(child);
3958 }
3959 else if(tag == "genericPolycone")
3960 {
3961 GenericPolyconeRead(child);
3962 }
3963 else if(tag == "polyhedra")
3964 {
3965 PolyhedraRead(child);
3966 }
3967 else if(tag == "genericPolyhedra")
3968 {
3969 GenericPolyhedraRead(child);
3970 }
3971 else if(tag == "reflectedSolid")
3972 {
3973 ReflectedSolidRead(child);
3974 }
3975 else if(tag == "scaledSolid")
3976 {
3977 ScaledSolidRead(child);
3978 }
3979 else if(tag == "sphere")
3980 {
3981 SphereRead(child);
3982 }
3983 else if(tag == "subtraction")
3984 {
3985 BooleanRead(child, SUBTRACTION);
3986 }
3987 else if(tag == "tessellated")
3988 {
3989 TessellatedRead(child);
3990 }
3991 else if(tag == "tet")
3992 {
3993 TetRead(child);
3994 }
3995 else if(tag == "torus")
3996 {
3997 TorusRead(child);
3998 }
3999 else if(tag == "arb8")
4000 {
4001 GenTrapRead(child);
4002 }
4003 else if(tag == "trap")
4004 {
4005 TrapRead(child);
4006 }
4007 else if(tag == "trd")
4008 {
4009 TrdRead(child);
4010 }
4011 else if(tag == "tube")
4012 {
4013 TubeRead(child);
4014 }
4015 else if(tag == "cutTube")
4016 {
4017 CutTubeRead(child);
4018 }
4019 else if(tag == "twistedbox")
4020 {
4021 TwistedboxRead(child);
4022 }
4023 else if(tag == "twistedtrap")
4024 {
4025 TwistedtrapRead(child);
4026 }
4027 else if(tag == "twistedtrd")
4028 {
4029 TwistedtrdRead(child);
4030 }
4031 else if(tag == "twistedtubs")
4032 {
4033 TwistedtubsRead(child);
4034 }
4035 else if(tag == "union")
4036 {
4037 BooleanRead(child, UNION);
4038 }
4039 else if(tag == "opticalsurface")
4040 {
4041 OpticalSurfaceRead(child);
4042 }
4043 else if(tag == "loop")
4044 {
4045 LoopRead(child, &G4GDMLRead::SolidsRead);
4046 }
4047 else
4048 {
4049 G4String error_msg = "Unknown tag in solids: " + tag;
4050 G4Exception("G4GDMLReadSolids::SolidsRead()", "ReadError", FatalException,
4051 error_msg);
4052 }
4053 }
4054}
4055
4056// --------------------------------------------------------------------
4057G4VSolid* G4GDMLReadSolids::GetSolid(const G4String& ref) const
4058{
4059 G4VSolid* solidPtr = G4SolidStore::GetInstance()
4060 ->GetSolid(ref,false,reverseSearch);
4061
4062 if(solidPtr == nullptr)
4063 {
4064 G4String error_msg = "Referenced solid '" + ref + "' was not found!";
4065 G4Exception("G4GDMLReadSolids::GetSolid()", "ReadError", FatalException,
4066 error_msg);
4067 }
4068
4069 return solidPtr;
4070}
4071
4072// --------------------------------------------------------------------
4073G4SurfaceProperty* G4GDMLReadSolids::GetSurfaceProperty(
4074 const G4String& ref) const
4075{
4076 const G4SurfacePropertyTable* surfaceList =
4077 G4SurfaceProperty::GetSurfacePropertyTable();
4078 const std::size_t surfaceCount = surfaceList->size();
4079
4080 for(std::size_t i = 0; i < surfaceCount; ++i)
4081 {
4082 if((*surfaceList)[i]->GetName() == ref)
4083 {
4084 return (*surfaceList)[i];
4085 }
4086 }
4087
4088 G4String error_msg =
4089 "Referenced optical surface '" + ref + "' was not found!";
4090 G4Exception("G4GDMLReadSolids::GetSurfaceProperty()", "ReadError",
4091 FatalException, error_msg);
4092
4093 return nullptr;
4094}
FatalException
@ FatalException
Definition: G4ExceptionSeverity.hh:61
G4Exception
void G4Exception(const char *originOfException, const char *exceptionCode, G4ExceptionSeverity severity, const char *description)
Definition: G4Exception.cc:59
G4MaterialPropertyVector
G4PhysicsFreeVector G4MaterialPropertyVector
Definition: G4MaterialPropertyVector.hh:60
G4OpticalSurfaceModel
G4OpticalSurfaceModel
Definition: G4OpticalSurface.hh:111
unified
@ unified
Definition: G4OpticalSurface.hh:113
DAVIS
@ DAVIS
Definition: G4OpticalSurface.hh:115
dichroic
@ dichroic
Definition: G4OpticalSurface.hh:116
glisur
@ glisur
Definition: G4OpticalSurface.hh:112
G4OpticalSurfaceFinish
G4OpticalSurfaceFinish
Definition: G4OpticalSurface.hh:57
groundfrontpainted
@ groundfrontpainted
Definition: G4OpticalSurface.hh:63
polishedlumirrorair
@ polishedlumirrorair
Definition: G4OpticalSurface.hh:67
groundtyvekair
@ groundtyvekair
Definition: G4OpticalSurface.hh:92
groundtioair
@ groundtioair
Definition: G4OpticalSurface.hh:91
PolishedESR_LUT
@ PolishedESR_LUT
Definition: G4OpticalSurface.hh:104
groundvm2000glue
@ groundvm2000glue
Definition: G4OpticalSurface.hh:94
polishedair
@ polishedair
Definition: G4OpticalSurface.hh:70
groundair
@ groundair
Definition: G4OpticalSurface.hh:89
etchedteflonair
@ etchedteflonair
Definition: G4OpticalSurface.hh:81
etchedtyvekair
@ etchedtyvekair
Definition: G4OpticalSurface.hh:83
etchedvm2000glue
@ etchedvm2000glue
Definition: G4OpticalSurface.hh:85
RoughESR_LUT
@ RoughESR_LUT
Definition: G4OpticalSurface.hh:99
polishedbackpainted
@ polishedbackpainted
Definition: G4OpticalSurface.hh:60
etchedtioair
@ etchedtioair
Definition: G4OpticalSurface.hh:82
Polished_LUT
@ Polished_LUT
Definition: G4OpticalSurface.hh:102
groundvm2000air
@ groundvm2000air
Definition: G4OpticalSurface.hh:93
polished
@ polished
Definition: G4OpticalSurface.hh:58
Detector_LUT
@ Detector_LUT
Definition: G4OpticalSurface.hh:107
polishedlumirrorglue
@ polishedlumirrorglue
Definition: G4OpticalSurface.hh:68
polishedtyvekair
@ polishedtyvekair
Definition: G4OpticalSurface.hh:73
PolishedESRGrease_LUT
@ PolishedESRGrease_LUT
Definition: G4OpticalSurface.hh:105
RoughESRGrease_LUT
@ RoughESRGrease_LUT
Definition: G4OpticalSurface.hh:100
ground
@ ground
Definition: G4OpticalSurface.hh:62
Rough_LUT
@ Rough_LUT
Definition: G4OpticalSurface.hh:97
polishedteflonair
@ polishedteflonair
Definition: G4OpticalSurface.hh:71
etchedair
@ etchedair
Definition: G4OpticalSurface.hh:80
polishedvm2000air
@ polishedvm2000air
Definition: G4OpticalSurface.hh:74
etchedlumirrorglue
@ etchedlumirrorglue
Definition: G4OpticalSurface.hh:79
polishedvm2000glue
@ polishedvm2000glue
Definition: G4OpticalSurface.hh:75
polishedfrontpainted
@ polishedfrontpainted
Definition: G4OpticalSurface.hh:59
RoughTeflon_LUT
@ RoughTeflon_LUT
Definition: G4OpticalSurface.hh:98
polishedtioair
@ polishedtioair
Definition: G4OpticalSurface.hh:72
groundlumirrorglue
@ groundlumirrorglue
Definition: G4OpticalSurface.hh:88
PolishedTeflon_LUT
@ PolishedTeflon_LUT
Definition: G4OpticalSurface.hh:103
etchedvm2000air
@ etchedvm2000air
Definition: G4OpticalSurface.hh:84
groundbackpainted
@ groundbackpainted
Definition: G4OpticalSurface.hh:64
etchedlumirrorair
@ etchedlumirrorair
Definition: G4OpticalSurface.hh:78
groundlumirrorair
@ groundlumirrorair
Definition: G4OpticalSurface.hh:87
groundteflonair
@ groundteflonair
Definition: G4OpticalSurface.hh:90
G4SurfacePropertyTable
std::vector< G4SurfaceProperty * > G4SurfacePropertyTable
Definition: G4SurfaceProperty.hh:58
G4SurfaceType
G4SurfaceType
Definition: G4SurfaceProperty.hh:61
dielectric_metal
@ dielectric_metal
Definition: G4SurfaceProperty.hh:62
dielectric_LUT
@ dielectric_LUT
Definition: G4SurfaceProperty.hh:64
dielectric_dielectric
@ dielectric_dielectric
Definition: G4SurfaceProperty.hh:63
dielectric_LUTDAVIS
@ dielectric_LUTDAVIS
Definition: G4SurfaceProperty.hh:65
dielectric_dichroic
@ dielectric_dichroic
Definition: G4SurfaceProperty.hh:66
x_ray
@ x_ray
Definition: G4SurfaceProperty.hh:68
firsov
@ firsov
Definition: G4SurfaceProperty.hh:67
G4Scale3D
HepGeom::Scale3D G4Scale3D
Definition: G4Transform3D.hh:50
G4TwoVector
CLHEP::Hep2Vector G4TwoVector
Definition: G4TwoVector.hh:36
G4double
double G4double
Definition: G4Types.hh:83
G4int
int G4int
Definition: G4Types.hh:85
G4FacetVertexType
G4FacetVertexType
Definition: G4VFacet.hh:48
ABSOLUTE
@ ABSOLUTE
Definition: G4VFacet.hh:48
RELATIVE
@ RELATIVE
Definition: G4VFacet.hh:48
alpha2
const G4double alpha2
Definition: G4WentzelOKandVIxSection.cc:70
G4endl
#define G4endl
Definition: G4ios.hh:57
G4cout
G4GLOB_DLL std::ostream G4cout
CLHEP::Hep2Vector::setY
void setY(double y)
CLHEP::Hep2Vector::setX
void setX(double x)
CLHEP::Hep3Vector::z
double z() const
CLHEP::Hep3Vector::x
double x() const
CLHEP::Hep3Vector::setY
void setY(double)
CLHEP::Hep3Vector::y
double y() const
CLHEP::Hep3Vector::setZ
void setZ(double)
CLHEP::Hep3Vector::setX
void setX(double)
G4Box
Definition: G4Box.hh:56
G4Cons
Definition: G4Cons.hh:78
G4GDMLEvaluator::Evaluate
G4double Evaluate(const G4String &)
Definition: G4GDMLEvaluator.cc:238
G4GDMLEvaluator::EvaluateInteger
G4int EvaluateInteger(const G4String &)
Definition: G4GDMLEvaluator.cc:260
G4GDMLMatrix::GetCols
std::size_t GetCols() const
Definition: G4GDMLReadDefine.cc:134
G4GDMLMatrix::GetRows
std::size_t GetRows() const
Definition: G4GDMLReadDefine.cc:128
G4GDMLMatrix::Get
G4double Get(std::size_t r, std::size_t c) const
Definition: G4GDMLReadDefine.cc:117
G4GDMLReadDefine::GetScale
G4ThreeVector GetScale(const G4String &)
Definition: G4GDMLReadDefine.cc:806
G4GDMLReadDefine::VectorRead
void VectorRead(const xercesc::DOMElement *const, G4ThreeVector &)
Definition: G4GDMLReadDefine.cc:662
G4GDMLReadDefine::GetRotationMatrix
G4RotationMatrix GetRotationMatrix(const G4ThreeVector &)
Definition: G4GDMLReadDefine.cc:153
G4GDMLReadDefine::GetPosition
G4ThreeVector GetPosition(const G4String &)
Definition: G4GDMLReadDefine.cc:782
G4GDMLReadDefine::GetMatrix
G4GDMLMatrix GetMatrix(const G4String &)
Definition: G4GDMLReadDefine.cc:818
G4GDMLReadDefine::RefRead
G4String RefRead(const xercesc::DOMElement *const)
Definition: G4GDMLReadDefine.cc:714
G4GDMLReadDefine::GetRotation
G4ThreeVector GetRotation(const G4String &)
Definition: G4GDMLReadDefine.cc:794
G4GDMLReadDefine::DefineRead
virtual void DefineRead(const xercesc::DOMElement *const)
Definition: G4GDMLReadDefine.cc:596
G4GDMLReadSolids::GetSurfaceProperty
G4SurfaceProperty * GetSurfaceProperty(const G4String &) const
Definition: G4GDMLReadSolids.cc:4073
G4GDMLReadSolids::ReflectedSolidRead
void ReflectedSolidRead(const xercesc::DOMElement *const)
Definition: G4GDMLReadSolids.cc:1711
G4GDMLReadSolids::SectionRead
G4ExtrudedSolid::ZSection SectionRead(const xercesc::DOMElement *const, G4double)
Definition: G4GDMLReadSolids.cc:1904
G4GDMLReadSolids::ParaboloidRead
void ParaboloidRead(const xercesc::DOMElement *const)
Definition: G4GDMLReadSolids.cc:1098
G4GDMLReadSolids::PropertyRead
void PropertyRead(const xercesc::DOMElement *const, G4OpticalSurface *)
Definition: G4GDMLReadSolids.cc:3487
G4GDMLReadSolids::XtruRead
void XtruRead(const xercesc::DOMElement *const)
Definition: G4GDMLReadSolids.cc:614
G4GDMLReadSolids::SphereRead
void SphereRead(const xercesc::DOMElement *const)
Definition: G4GDMLReadSolids.cc:1958
G4GDMLReadSolids::TwistedtrapRead
void TwistedtrapRead(const xercesc::DOMElement *const)
Definition: G4GDMLReadSolids.cc:2984
G4GDMLReadSolids::TubeRead
void TubeRead(const xercesc::DOMElement *const)
Definition: G4GDMLReadSolids.cc:2692
G4GDMLReadSolids::GenTrapRead
void GenTrapRead(const xercesc::DOMElement *const)
Definition: G4GDMLReadSolids.cc:2285
G4GDMLReadSolids::GetSolid
G4VSolid * GetSolid(const G4String &) const
Definition: G4GDMLReadSolids.cc:4057
G4GDMLReadSolids::HypeRead
void HypeRead(const xercesc::DOMElement *const)
Definition: G4GDMLReadSolids.cc:694
G4GDMLReadSolids::RZPointRead
rzPointType RZPointRead(const xercesc::DOMElement *const)
Definition: G4GDMLReadSolids.cc:3443
G4GDMLReadSolids::TrdRead
void TrdRead(const xercesc::DOMElement *const)
Definition: G4GDMLReadSolids.cc:2543
G4GDMLReadSolids::ParaRead
void ParaRead(const xercesc::DOMElement *const)
Definition: G4GDMLReadSolids.cc:1002
G4GDMLReadSolids::TwistedtrdRead
void TwistedtrdRead(const xercesc::DOMElement *const)
Definition: G4GDMLReadSolids.cc:3112
G4GDMLReadSolids::PolyhedraRead
void PolyhedraRead(const xercesc::DOMElement *const)
Definition: G4GDMLReadSolids.cc:1396
G4GDMLReadSolids::ConeRead
void ConeRead(const xercesc::DOMElement *const)
Definition: G4GDMLReadSolids.cc:289
G4GDMLReadSolids::OpticalSurfaceRead
void OpticalSurfaceRead(const xercesc::DOMElement *const)
Definition: G4GDMLReadSolids.cc:3584
G4GDMLReadSolids::QuadrangularRead
G4QuadrangularFacet * QuadrangularRead(const xercesc::DOMElement *const)
Definition: G4GDMLReadSolids.cc:1637
G4GDMLReadSolids::CutTubeRead
void CutTubeRead(const xercesc::DOMElement *const)
Definition: G4GDMLReadSolids.cc:2782
G4GDMLReadSolids::TetRead
void TetRead(const xercesc::DOMElement *const)
Definition: G4GDMLReadSolids.cc:2125
G4GDMLReadSolids::GenericPolyhedraRead
void GenericPolyhedraRead(const xercesc::DOMElement *const)
Definition: G4GDMLReadSolids.cc:1518
G4GDMLReadSolids::MultiUnionRead
void MultiUnionRead(const xercesc::DOMElement *const)
Definition: G4GDMLReadSolids.cc:875
G4GDMLReadSolids::MultiUnionNodeRead
void MultiUnionNodeRead(const xercesc::DOMElement *const, G4MultiUnion *const)
Definition: G4GDMLReadSolids.cc:784
G4GDMLReadSolids::SolidsRead
virtual void SolidsRead(const xercesc::DOMElement *const)
Definition: G4GDMLReadSolids.cc:3880
G4GDMLReadSolids::EllipsoidRead
void EllipsoidRead(const xercesc::DOMElement *const)
Definition: G4GDMLReadSolids.cc:464
G4GDMLReadSolids::ElconeRead
void ElconeRead(const xercesc::DOMElement *const)
Definition: G4GDMLReadSolids.cc:391
G4GDMLReadSolids::TessellatedRead
void TessellatedRead(const xercesc::DOMElement *const)
Definition: G4GDMLReadSolids.cc:2055
G4GDMLReadSolids::TwistedboxRead
void TwistedboxRead(const xercesc::DOMElement *const)
Definition: G4GDMLReadSolids.cc:2899
G4GDMLReadSolids::GenericPolyconeRead
void GenericPolyconeRead(const xercesc::DOMElement *const)
Definition: G4GDMLReadSolids.cc:1284
G4GDMLReadSolids::BoxRead
void BoxRead(const xercesc::DOMElement *const)
Definition: G4GDMLReadSolids.cc:221
G4GDMLReadSolids::ZplaneRead
zplaneType ZplaneRead(const xercesc::DOMElement *const)
Definition: G4GDMLReadSolids.cc:3395
G4GDMLReadSolids::~G4GDMLReadSolids
virtual ~G4GDMLReadSolids()
Definition: G4GDMLReadSolids.cc:77
G4GDMLReadSolids::OrbRead
void OrbRead(const xercesc::DOMElement *const)
Definition: G4GDMLReadSolids.cc:946
G4GDMLReadSolids::PolyconeRead
void PolyconeRead(const xercesc::DOMElement *const)
Definition: G4GDMLReadSolids.cc:1167
G4GDMLReadSolids::TwoDimVertexRead
G4TwoVector TwoDimVertexRead(const xercesc::DOMElement *const, G4double)
Definition: G4GDMLReadSolids.cc:3352
G4GDMLReadSolids::EltubeRead
void EltubeRead(const xercesc::DOMElement *const)
Definition: G4GDMLReadSolids.cc:545
G4GDMLReadSolids::TwistedtubsRead
void TwistedtubsRead(const xercesc::DOMElement *const)
Definition: G4GDMLReadSolids.cc:3209
G4GDMLReadSolids::TorusRead
void TorusRead(const xercesc::DOMElement *const)
Definition: G4GDMLReadSolids.cc:2195
G4GDMLReadSolids::ScaledSolidRead
void ScaledSolidRead(const xercesc::DOMElement *const)
Definition: G4GDMLReadSolids.cc:1821
G4GDMLReadSolids::BooleanRead
void BooleanRead(const xercesc::DOMElement *const, const BooleanOp)
Definition: G4GDMLReadSolids.cc:82
G4GDMLReadSolids::TrapRead
void TrapRead(const xercesc::DOMElement *const)
Definition: G4GDMLReadSolids.cc:2417
G4GDMLReadSolids::TriangularRead
G4TriangularFacet * TriangularRead(const xercesc::DOMElement *const)
Definition: G4GDMLReadSolids.cc:2623
G4GDMLRead::Strip
G4String Strip(const G4String &) const
Definition: G4GDMLRead.cc:104
G4GDMLRead::SolidsRead
virtual void SolidsRead(const xercesc::DOMElement *const)=0
G4GDMLRead::GenerateName
G4String GenerateName(const G4String &name, G4bool strip=false)
Definition: G4GDMLRead.cc:70
G4GDMLRead::LoopRead
void LoopRead(const xercesc::DOMElement *const, void(G4GDMLRead::*)(const xercesc::DOMElement *const))
Definition: G4GDMLRead.cc:194
G4GDMLRead::Transcode
G4String Transcode(const XMLCh *const)
Definition: G4GDMLRead.cc:55
G4GDMLRead::eval
G4GDMLEvaluator eval
Definition: G4GDMLRead.hh:156
G4Hype
Definition: G4Hype.hh:69
G4MaterialPropertiesTable::AddConstProperty
void AddConstProperty(const G4String &key, G4double propertyValue, G4bool createNewKey=false)
Definition: G4MaterialPropertiesTable.cc:458
G4MaterialPropertiesTable::AddProperty
G4MaterialPropertyVector * AddProperty(const G4String &key, const std::vector< G4double > &photonEnergies, const std::vector< G4double > &propertyValues, G4bool createNewKey=false, G4bool spline=false)
Definition: G4MaterialPropertiesTable.cc:309
G4MultiUnion::AddNode
void AddNode(G4VSolid &solid, const G4Transform3D &trans)
Definition: G4MultiUnion.cc:69
G4OpticalSurface::SetMaterialPropertiesTable
void SetMaterialPropertiesTable(G4MaterialPropertiesTable *anMPT)
Definition: G4OpticalSurface.hh:167
G4OpticalSurface::GetMaterialPropertiesTable
G4MaterialPropertiesTable * GetMaterialPropertiesTable() const
Definition: G4OpticalSurface.hh:160
G4Orb
Definition: G4Orb.hh:56
G4Para
Definition: G4Para.hh:79
G4PhysicsFreeVector::InsertValues
void InsertValues(const G4double energy, const G4double value)
Definition: G4PhysicsFreeVector.cc:133
G4SolidStore::GetSolid
G4VSolid * GetSolid(const G4String &name, G4bool verbose=true, G4bool reverseSearch=false) const
Definition: G4SolidStore.cc:209
G4SolidStore::GetInstance
static G4SolidStore * GetInstance()
Definition: G4SolidStore.cc:250
G4SurfaceProperty::GetSurfacePropertyTable
static const G4SurfacePropertyTable * GetSurfacePropertyTable()
Definition: G4SurfaceProperty.cc:65
G4TessellatedSolid::AddFacet
G4bool AddFacet(G4VFacet *aFacet)
Definition: G4TessellatedSolid.cc:207
G4TessellatedSolid::SetSolidClosed
void SetSolidClosed(const G4bool t)
Definition: G4TessellatedSolid.cc:592
G4Tet
Definition: G4Tet.hh:56
G4Trd
Definition: G4Trd.hh:63
G4Tubs
Definition: G4Tubs.hh:75
G4UnitDefinition::GetValueOf
static G4double GetValueOf(const G4String &)
Definition: G4UnitsTable.cc:185
G4UnitDefinition::GetCategory
static G4String GetCategory(const G4String &)
Definition: G4UnitsTable.cc:210
tag
Definition: xmlparse.c:284