| Geant4 Cross Reference |
1 // 1
2 // *******************************************
3 // * License and Disclaimer
4 // *
5 // * The Geant4 software is copyright of th
6 // * the Geant4 Collaboration. It is provided
7 // * conditions of the Geant4 Software License
8 // * LICENSE and available at http://cern.ch/
9 // * include a list of copyright holders.
10 // *
11 // * Neither the authors of this software syst
12 // * institutes,nor the agencies providing fin
13 // * work make any representation or warran
14 // * regarding this software system or assum
15 // * use. Please see the license in the file
16 // * for the full disclaimer and the limitatio
17 // *
18 // * This code implementation is the result
19 // * technical work of the GEANT4 collaboratio
20 // * By using, copying, modifying or distri
21 // * any work based on the software) you ag
22 // * use in resulting scientific publicati
23 // * acceptance of all terms of the Geant4 Sof
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 // -------------------------------------------
71 G4GDMLReadSolids::G4GDMLReadSolids()
72 : G4GDMLReadMaterials()
73 {
74 }
75
76 // -------------------------------------------
77 G4GDMLReadSolids::~G4GDMLReadSolids()
78 {
79 }
80
81 // -------------------------------------------
82 void G4GDMLReadSolids::BooleanRead(
83 const xercesc::DOMElement* const booleanElem
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 attrib
94 booleanElement->getAttributes();
95 XMLSize_t attributeCount = attributes->getLe
96
97 for(XMLSize_t attribute_index = 0; attribute
98 ++attribute_index)
99 {
100 xercesc::DOMNode* attribute_node = attribu
101
102 if(attribute_node->getNodeType() != xerces
103 {
104 continue;
105 }
106
107 const xercesc::DOMAttr* const attribute =
108 dynamic_cast<xercesc::DOMAttr*>(attribut
109 if(attribute == nullptr)
110 {
111 G4Exception("G4GDMLReadSolids::BooleanRe
112 FatalException, "No attribut
113 return;
114 }
115 const G4String attName = Transcode(attrib
116 const G4String attValue = Transcode(attrib
117
118 if(attName == "name")
119 {
120 name = GenerateName(attValue);
121 }
122 }
123
124 for(xercesc::DOMNode* iter = booleanElement-
125 iter = iter->getNextSi
126 {
127 if(iter->getNodeType() != xercesc::DOMNode
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::BooleanRe
137 FatalException, "No child fo
138 return;
139 }
140 const G4String tag = Transcode(child->getT
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(RefR
161 }
162 else if(tag == "rotationref")
163 {
164 rotation = GetRotation(GenerateName(RefR
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
177 }
178 else if(tag == "firstrotationref")
179 {
180 firstrotation = GetRotation(GenerateName
181 }
182 else
183 {
184 G4String error_msg = "Unknown tag in boo
185 G4Exception("G4GDMLReadSolids::BooleanRe
186 FatalException, error_msg);
187 }
188 }
189
190 G4VSolid* firstSolid = GetSolid(GenerateNam
191 G4VSolid* secondSolid = GetSolid(GenerateNam
192
193 G4Transform3D transform(GetRotationMatrix(ro
194
195 if(((firstrotation.x() != 0.0) || (firstrota
196 (firstrotation.z() != 0.0)) ||
197 ((firstposition.x() != 0.0) || (firstposi
198 (firstposition.z() != 0.0)))
199 {
200 G4Transform3D firsttransform(GetRotationMa
201 firstposition
202 firstSolid = new G4DisplacedSolid(Generate
203 firstSol
204 }
205
206 if(op == UNION)
207 {
208 new G4UnionSolid(name, firstSolid, secondS
209 }
210 else if(op == SUBTRACTION)
211 {
212 new G4SubtractionSolid(name, firstSolid, s
213 }
214 else if(op == INTERSECTION)
215 {
216 new G4IntersectionSolid(name, firstSolid,
217 }
218 }
219
220 // -------------------------------------------
221 void G4GDMLReadSolids::BoxRead(const xercesc::
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 attrib
230 boxElement->getAttributes();
231 XMLSize_t attributeCount = attributes->getLe
232
233 for(XMLSize_t attribute_index = 0; attribute
234 ++attribute_index)
235 {
236 xercesc::DOMNode* attribute_node = attribu
237
238 if(attribute_node->getNodeType() != xerces
239 {
240 continue;
241 }
242
243 const xercesc::DOMAttr* const attribute =
244 dynamic_cast<xercesc::DOMAttr*>(attribut
245 if(attribute == nullptr)
246 {
247 G4Exception("G4GDMLReadSolids::BoxRead()
248 "No attribute found!");
249 return;
250 }
251 const G4String attName = Transcode(attrib
252 const G4String attValue = Transcode(attrib
253
254 if(attName == "name")
255 {
256 name = GenerateName(attValue);
257 }
258 else if(attName == "lunit")
259 {
260 lunit = G4UnitDefinition::GetValueOf(att
261 if(G4UnitDefinition::GetCategory(attValu
262 {
263 G4Exception("G4GDMLReadSolids::BoxRead
264 FatalException, "Invalid u
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 // -------------------------------------------
289 void G4GDMLReadSolids::ConeRead(const xercesc:
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 attrib
303 coneElement->getAttributes();
304 XMLSize_t attributeCount = attributes->getLe
305
306 for(XMLSize_t attribute_index = 0; attribute
307 ++attribute_index)
308 {
309 xercesc::DOMNode* attribute_node = attribu
310
311 if(attribute_node->getNodeType() != xerces
312 {
313 continue;
314 }
315
316 const xercesc::DOMAttr* const attribute =
317 dynamic_cast<xercesc::DOMAttr*>(attribut
318 if(attribute == nullptr)
319 {
320 G4Exception("G4GDMLReadSolids::ConeRead(
321 "No attribute found!");
322 return;
323 }
324 const G4String attName = Transcode(attrib
325 const G4String attValue = Transcode(attrib
326
327 if(attName == "name")
328 {
329 name = GenerateName(attValue);
330 }
331 else if(attName == "lunit")
332 {
333 lunit = G4UnitDefinition::GetValueOf(att
334 if(G4UnitDefinition::GetCategory(attValu
335 {
336 G4Exception("G4GDMLReadSolids::ConeRea
337 FatalException, "Invalid u
338 }
339 }
340 else if(attName == "aunit")
341 {
342 aunit = G4UnitDefinition::GetValueOf(att
343 if(G4UnitDefinition::GetCategory(attValu
344 {
345 G4Exception("G4GDMLReadSolids::ConeRea
346 FatalException, "Invalid u
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,
388 }
389
390 // -------------------------------------------
391 void G4GDMLReadSolids::ElconeRead(
392 const xercesc::DOMElement* const elconeEleme
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 attrib
402 elconeElement->getAttributes();
403 XMLSize_t attributeCount = attributes->getLe
404
405 for(XMLSize_t attribute_index = 0; attribute
406 ++attribute_index)
407 {
408 xercesc::DOMNode* attribute_node = attribu
409
410 if(attribute_node->getNodeType() != xerces
411 {
412 continue;
413 }
414
415 const xercesc::DOMAttr* const attribute =
416 dynamic_cast<xercesc::DOMAttr*>(attribut
417 if(attribute == nullptr)
418 {
419 G4Exception("G4GDMLReadSolids::ElconeRea
420 FatalException, "No attribut
421 return;
422 }
423 const G4String attName = Transcode(attrib
424 const G4String attValue = Transcode(attrib
425
426 if(attName == "name")
427 {
428 name = GenerateName(attValue);
429 }
430 else if(attName == "lunit")
431 {
432 lunit = G4UnitDefinition::GetValueOf(att
433 if(G4UnitDefinition::GetCategory(attValu
434 {
435 G4Exception("G4GDMLReadSolids::ElconeR
436 FatalException, "Invalid u
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, zcu
461 }
462
463 // -------------------------------------------
464 void G4GDMLReadSolids::EllipsoidRead(
465 const xercesc::DOMElement* const ellipsoidEl
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 attrib
476 ellipsoidElement->getAttributes();
477 XMLSize_t attributeCount = attributes->getLe
478
479 for(XMLSize_t attribute_index = 0; attribute
480 ++attribute_index)
481 {
482 xercesc::DOMNode* attribute_node = attribu
483
484 if(attribute_node->getNodeType() != xerces
485 {
486 continue;
487 }
488
489 const xercesc::DOMAttr* const attribute =
490 dynamic_cast<xercesc::DOMAttr*>(attribut
491 if(attribute == nullptr)
492 {
493 G4Exception("G4GDMLReadSolids::Ellipsoid
494 FatalException, "No attribut
495 return;
496 }
497 const G4String attName = Transcode(attrib
498 const G4String attValue = Transcode(attrib
499
500 if(attName == "name")
501 {
502 name = GenerateName(attValue);
503 }
504 else if(attName == "lunit")
505 {
506 lunit = G4UnitDefinition::GetValueOf(att
507 if(G4UnitDefinition::GetCategory(attValu
508 {
509 G4Exception("G4GDMLReadSolids::Ellipso
510 FatalException, "Invalid u
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, zcu
542 }
543
544 // -------------------------------------------
545 void G4GDMLReadSolids::EltubeRead(
546 const xercesc::DOMElement* const eltubeEleme
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 attrib
555 eltubeElement->getAttributes();
556 XMLSize_t attributeCount = attributes->getLe
557
558 for(XMLSize_t attribute_index = 0; attribute
559 ++attribute_index)
560 {
561 xercesc::DOMNode* attribute_node = attribu
562
563 if(attribute_node->getNodeType() != xerces
564 {
565 continue;
566 }
567
568 const xercesc::DOMAttr* const attribute =
569 dynamic_cast<xercesc::DOMAttr*>(attribut
570 if(attribute == nullptr)
571 {
572 G4Exception("G4GDMLReadSolids::EltubeRea
573 FatalException, "No attribut
574 return;
575 }
576 const G4String attName = Transcode(attrib
577 const G4String attValue = Transcode(attrib
578
579 if(attName == "name")
580 {
581 name = GenerateName(attValue);
582 }
583 else if(attName == "lunit")
584 {
585 lunit = G4UnitDefinition::GetValueOf(att
586 if(G4UnitDefinition::GetCategory(attValu
587 {
588 G4Exception("G4GDMLReadSolids::EltubeR
589 FatalException, "Invalid u
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 // -------------------------------------------
614 void G4GDMLReadSolids::XtruRead(const xercesc:
615 {
616 G4String name;
617 G4double lunit = 1.0;
618
619 const xercesc::DOMNamedNodeMap* const attrib
620 xtruElement->getAttributes();
621 XMLSize_t attributeCount = attributes->getLe
622
623 for(XMLSize_t attribute_index = 0; attribute
624 ++attribute_index)
625 {
626 xercesc::DOMNode* attribute_node = attribu
627
628 if(attribute_node->getNodeType() != xerces
629 {
630 continue;
631 }
632
633 const xercesc::DOMAttr* const attribute =
634 dynamic_cast<xercesc::DOMAttr*>(attribut
635 if(attribute == nullptr)
636 {
637 G4Exception("G4GDMLReadSolids::XtruRead(
638 "No attribute found!");
639 return;
640 }
641 const G4String attName = Transcode(attrib
642 const G4String attValue = Transcode(attrib
643
644 if(attName == "name")
645 {
646 name = GenerateName(attValue);
647 }
648 else if(attName == "lunit")
649 {
650 lunit = G4UnitDefinition::GetValueOf(att
651 if(G4UnitDefinition::GetCategory(attValu
652 {
653 G4Exception("G4GDMLReadSolids::XtruRea
654 FatalException, "Invalid u
655 }
656 }
657 }
658
659 std::vector<G4TwoVector> twoDimVertexList;
660 std::vector<G4ExtrudedSolid::ZSection> secti
661
662 for(xercesc::DOMNode* iter = xtruElement->ge
663 iter = iter->getNextSi
664 {
665 if(iter->getNodeType() != xercesc::DOMNode
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(
675 "No child found!");
676 return;
677 }
678 const G4String tag = Transcode(child->getT
679
680 if(tag == "twoDimVertex")
681 {
682 twoDimVertexList.push_back(TwoDimVertexR
683 }
684 else if(tag == "section")
685 {
686 sectionList.push_back(SectionRead(child,
687 }
688 }
689
690 new G4ExtrudedSolid(name, twoDimVertexList,
691 }
692
693 // -------------------------------------------
694 void G4GDMLReadSolids::HypeRead(const xercesc:
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 attrib
706 hypeElement->getAttributes();
707 XMLSize_t attributeCount = attributes->getLe
708
709 for(XMLSize_t attribute_index = 0; attribute
710 ++attribute_index)
711 {
712 xercesc::DOMNode* attribute_node = attribu
713
714 if(attribute_node->getNodeType() != xerces
715 {
716 continue;
717 }
718
719 const xercesc::DOMAttr* const attribute =
720 dynamic_cast<xercesc::DOMAttr*>(attribut
721 if(attribute == nullptr)
722 {
723 G4Exception("G4GDMLReadSolids::HypeRead(
724 "No attribute found!");
725 return;
726 }
727 const G4String attName = Transcode(attrib
728 const G4String attValue = Transcode(attrib
729
730 if(attName == "name")
731 {
732 name = GenerateName(attValue);
733 }
734 else if(attName == "lunit")
735 {
736 lunit = G4UnitDefinition::GetValueOf(att
737 if(G4UnitDefinition::GetCategory(attValu
738 {
739 G4Exception("G4GDMLReadSolids::HypeRea
740 FatalException, "Invalid u
741 }
742 }
743 else if(attName == "aunit")
744 {
745 aunit = G4UnitDefinition::GetValueOf(att
746 if(G4UnitDefinition::GetCategory(attValu
747 {
748 G4Exception("G4GDMLReadSolids::HypeRea
749 FatalException, "Invalid u
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 // -------------------------------------------
784 void G4GDMLReadSolids::MultiUnionNodeRead(
785 const xercesc::DOMElement* const unionNodeEl
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 attrib
794 unionNodeElement->getAttributes();
795 XMLSize_t attributeCount = attributes->getLe
796
797 for(XMLSize_t attribute_index = 0; attribute
798 ++attribute_index)
799 {
800 xercesc::DOMNode* attribute_node = attribu
801
802 if(attribute_node->getNodeType() != xerces
803 {
804 continue;
805 }
806
807 const xercesc::DOMAttr* const attribute =
808 dynamic_cast<xercesc::DOMAttr*>(attribut
809 if(attribute == nullptr)
810 {
811 G4Exception("G4GDMLReadSolids::MultiUnio
812 FatalException, "No attribut
813 return;
814 }
815 const G4String attName = Transcode(attrib
816 const G4String attValue = Transcode(attrib
817
818 if(attName == "name")
819 {
820 name = GenerateName(attValue);
821 }
822 }
823
824 for(xercesc::DOMNode* iter = unionNodeElemen
825 iter != nullptr; iter
826 {
827 if(iter->getNodeType() != xercesc::DOMNode
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::MultiUnio
837 FatalException, "No child fo
838 return;
839 }
840 const G4String tag = Transcode(child->getT
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(RefR
853 }
854 else if(tag == "rotationref")
855 {
856 rotation = GetRotation(GenerateName(RefR
857 }
858 else if(tag == "solid")
859 {
860 solid = RefRead(child);
861 }
862 else
863 {
864 G4String error_msg = "Unknown tag in Mul
865 G4Exception("G4GDMLReadSolids::MultiUnio
866 FatalException, error_msg);
867 }
868 }
869 G4VSolid* solidNode = GetSolid(GenerateName(
870 G4Transform3D transform(GetRotationMatrix(ro
871 multiUnionSolid->AddNode(*solidNode, transfo
872 }
873
874 // -------------------------------------------
875 void G4GDMLReadSolids::MultiUnionRead(
876 const xercesc::DOMElement* const unionElemen
877 {
878 G4String name;
879
880 const xercesc::DOMNamedNodeMap* const attrib
881 unionElement->getAttributes();
882 XMLSize_t attributeCount = attributes->getLe
883
884 for(XMLSize_t attribute_index = 0; attribute
885 ++attribute_index)
886 {
887 xercesc::DOMNode* attribute_node = attribu
888
889 if(attribute_node->getNodeType() != xerces
890 {
891 continue;
892 }
893
894 const xercesc::DOMAttr* const attribute =
895 dynamic_cast<xercesc::DOMAttr*>(attribut
896 if(attribute == nullptr)
897 {
898 G4Exception("G4GDMLReadSolids::MultiUnio
899 FatalException, "No attribut
900 return;
901 }
902 const G4String attName = Transcode(attrib
903 const G4String attValue = Transcode(attrib
904
905 if(attName == "name")
906 {
907 name = GenerateName(attValue);
908 }
909 }
910
911 G4MultiUnion* multiUnion = new G4MultiUnion(
912
913 for(xercesc::DOMNode* iter = unionElement->g
914 iter = iter->getNextSi
915 {
916 if(iter->getNodeType() != xercesc::DOMNode
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::MultiUnio
926 FatalException, "No child fo
927 return;
928 }
929 const G4String tag = Transcode(child->getT
930
931 if(tag == "multiUnionNode")
932 {
933 MultiUnionNodeRead(child, multiUnion);
934 }
935 else
936 {
937 G4String error_msg = "Unknown tag in Mul
938 G4Exception("G4GDMLReadSolids::MultiUnio
939 FatalException, error_msg);
940 }
941 }
942 multiUnion->Voxelize();
943 }
944
945 // -------------------------------------------
946 void G4GDMLReadSolids::OrbRead(const xercesc::
947 {
948 G4String name;
949 G4double lunit = 1.0;
950 G4double r = 0.0;
951
952 const xercesc::DOMNamedNodeMap* const attrib
953 orbElement->getAttributes();
954 XMLSize_t attributeCount = attributes->getLe
955
956 for(XMLSize_t attribute_index = 0; attribute
957 ++attribute_index)
958 {
959 xercesc::DOMNode* attribute_node = attribu
960
961 if(attribute_node->getNodeType() != xerces
962 {
963 continue;
964 }
965
966 const xercesc::DOMAttr* const attribute =
967 dynamic_cast<xercesc::DOMAttr*>(attribut
968 if(attribute == nullptr)
969 {
970 G4Exception("G4GDMLReadSolids::OrbRead()
971 "No attribute found!");
972 return;
973 }
974 const G4String attName = Transcode(attrib
975 const G4String attValue = Transcode(attrib
976
977 if(attName == "name")
978 {
979 name = GenerateName(attValue);
980 }
981 else if(attName == "lunit")
982 {
983 lunit = G4UnitDefinition::GetValueOf(att
984 if(G4UnitDefinition::GetCategory(attValu
985 {
986 G4Exception("G4GDMLReadSolids::OrbRead
987 FatalException, "Invalid u
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 // ------------------------------------------
1002 void G4GDMLReadSolids::ParaRead(const xercesc
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 attri
1015 paraElement->getAttributes();
1016 XMLSize_t attributeCount = attributes->getL
1017
1018 for(XMLSize_t attribute_index = 0; attribut
1019 ++attribute_index)
1020 {
1021 xercesc::DOMNode* attribute_node = attrib
1022
1023 if(attribute_node->getNodeType() != xerce
1024 {
1025 continue;
1026 }
1027
1028 const xercesc::DOMAttr* const attribute =
1029 dynamic_cast<xercesc::DOMAttr*>(attribu
1030 if(attribute == nullptr)
1031 {
1032 G4Exception("G4GDMLReadSolids::ParaRead
1033 "No attribute found!");
1034 return;
1035 }
1036 const G4String attName = Transcode(attri
1037 const G4String attValue = Transcode(attri
1038
1039 if(attName == "name")
1040 {
1041 name = GenerateName(attValue);
1042 }
1043 else if(attName == "lunit")
1044 {
1045 lunit = G4UnitDefinition::GetValueOf(at
1046 if(G4UnitDefinition::GetCategory(attVal
1047 {
1048 G4Exception("G4GDMLReadSolids::ParaRe
1049 FatalException, "Invalid
1050 }
1051 }
1052 else if(attName == "aunit")
1053 {
1054 aunit = G4UnitDefinition::GetValueOf(at
1055 if(G4UnitDefinition::GetCategory(attVal
1056 {
1057 G4Exception("G4GDMLReadSolids::ParaRe
1058 FatalException, "Invalid
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 // ------------------------------------------
1098 void G4GDMLReadSolids::ParaboloidRead(
1099 const xercesc::DOMElement* const paraElemen
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 attri
1108 paraElement->getAttributes();
1109 XMLSize_t attributeCount = attributes->getL
1110
1111 for(XMLSize_t attribute_index = 0; attribut
1112 ++attribute_index)
1113 {
1114 xercesc::DOMNode* attribute_node = attrib
1115
1116 if(attribute_node->getNodeType() != xerce
1117 {
1118 continue;
1119 }
1120
1121 const xercesc::DOMAttr* const attribute =
1122 dynamic_cast<xercesc::DOMAttr*>(attribu
1123 if(attribute == nullptr)
1124 {
1125 G4Exception("G4GDMLReadSolids::Parabolo
1126 FatalException, "No attribu
1127 return;
1128 }
1129 const G4String attName = Transcode(attri
1130 const G4String attValue = Transcode(attri
1131
1132 if(attName == "name")
1133 {
1134 name = GenerateName(attValue);
1135 }
1136 else if(attName == "lunit")
1137 {
1138 lunit = G4UnitDefinition::GetValueOf(at
1139 if(G4UnitDefinition::GetCategory(attVal
1140 {
1141 G4Exception("G4GDMLReadSolids::Parabo
1142 FatalException, "Invalid
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 // ------------------------------------------
1167 void G4GDMLReadSolids::PolyconeRead(
1168 const xercesc::DOMElement* const polyconeEl
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 attri
1177 polyconeElement->getAttributes();
1178 XMLSize_t attributeCount = attributes->getL
1179
1180 for(XMLSize_t attribute_index = 0; attribut
1181 ++attribute_index)
1182 {
1183 xercesc::DOMNode* attribute_node = attrib
1184
1185 if(attribute_node->getNodeType() != xerce
1186 {
1187 continue;
1188 }
1189
1190 const xercesc::DOMAttr* const attribute =
1191 dynamic_cast<xercesc::DOMAttr*>(attribu
1192 if(attribute == nullptr)
1193 {
1194 G4Exception("G4GDMLReadSolids::Polycone
1195 FatalException, "No attribu
1196 return;
1197 }
1198 const G4String attName = Transcode(attri
1199 const G4String attValue = Transcode(attri
1200
1201 if(attName == "name")
1202 {
1203 name = GenerateName(attValue);
1204 }
1205 else if(attName == "lunit")
1206 {
1207 lunit = G4UnitDefinition::GetValueOf(at
1208 if(G4UnitDefinition::GetCategory(attVal
1209 {
1210 G4Exception("G4GDMLReadSolids::Polyco
1211 FatalException, "Invalid
1212 }
1213 }
1214 else if(attName == "aunit")
1215 {
1216 aunit = G4UnitDefinition::GetValueOf(at
1217 if(G4UnitDefinition::GetCategory(attVal
1218 {
1219 G4Exception("G4GDMLReadSolids::Polyco
1220 FatalException, "Invalid
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 = polyconeElemen
1239 iter = iter->getNextS
1240 {
1241 if(iter->getNodeType() != xercesc::DOMNod
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::Polycone
1251 FatalException, "No child f
1252 return;
1253 }
1254 const G4String tag = Transcode(child->get
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[numZPla
1265 G4double* rmax_array = new G4double[numZPla
1266 G4double* z_array = new G4double[numZPla
1267
1268 for(std::size_t i = 0; i < numZPlanes; ++i)
1269 {
1270 rmin_array[i] = zplaneList[i].rmin * luni
1271 rmax_array[i] = zplaneList[i].rmax * luni
1272 z_array[i] = zplaneList[i].z * lunit;
1273 }
1274
1275 new G4Polycone(name, startphi, deltaphi, (G
1276 rmin_array, rmax_array);
1277
1278 delete[] rmin_array;
1279 delete[] rmax_array;
1280 delete[] z_array;
1281 }
1282
1283 // ------------------------------------------
1284 void G4GDMLReadSolids::GenericPolyconeRead(
1285 const xercesc::DOMElement* const polyconeEl
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 attri
1294 polyconeElement->getAttributes();
1295 XMLSize_t attributeCount = attributes->getL
1296
1297 for(XMLSize_t attribute_index = 0; attribut
1298 ++attribute_index)
1299 {
1300 xercesc::DOMNode* attribute_node = attrib
1301
1302 if(attribute_node->getNodeType() != xerce
1303 {
1304 continue;
1305 }
1306
1307 const xercesc::DOMAttr* const attribute =
1308 dynamic_cast<xercesc::DOMAttr*>(attribu
1309 if(attribute == nullptr)
1310 {
1311 G4Exception("G4GDMLReadSolids::GenericP
1312 FatalException, "No attribu
1313 return;
1314 }
1315 const G4String attName = Transcode(attri
1316 const G4String attValue = Transcode(attri
1317
1318 if(attName == "name")
1319 {
1320 name = GenerateName(attValue);
1321 }
1322 else if(attName == "lunit")
1323 {
1324 lunit = G4UnitDefinition::GetValueOf(at
1325 if(G4UnitDefinition::GetCategory(attVal
1326 {
1327 G4Exception("G4GDMLReadSolids::Generi
1328 FatalException, "Invalid
1329 }
1330 }
1331 else if(attName == "aunit")
1332 {
1333 aunit = G4UnitDefinition::GetValueOf(at
1334 if(G4UnitDefinition::GetCategory(attVal
1335 {
1336 G4Exception("G4GDMLReadSolids::Generi
1337 FatalException, "Invalid
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 = polyconeElemen
1356 iter != nullptr; iter
1357 {
1358 if(iter->getNodeType() != xercesc::DOMNod
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::GenericP
1368 FatalException, "No child f
1369 return;
1370 }
1371 const G4String tag = Transcode(child->get
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[numRZPoint
1382 G4double* z_array = new G4double[numRZPoint
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, delta
1390 r_array, z_array);
1391 delete[] r_array;
1392 delete[] z_array;
1393 }
1394
1395 // ------------------------------------------
1396 void G4GDMLReadSolids::PolyhedraRead(
1397 const xercesc::DOMElement* const polyhedraE
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 attri
1407 polyhedraElement->getAttributes();
1408 XMLSize_t attributeCount = attributes->getL
1409
1410 for(XMLSize_t attribute_index = 0; attribut
1411 ++attribute_index)
1412 {
1413 xercesc::DOMNode* attribute_node = attrib
1414
1415 if(attribute_node->getNodeType() != xerce
1416 {
1417 continue;
1418 }
1419
1420 const xercesc::DOMAttr* const attribute =
1421 dynamic_cast<xercesc::DOMAttr*>(attribu
1422 if(attribute == nullptr)
1423 {
1424 G4Exception("G4GDMLReadSolids::Polyhedr
1425 FatalException, "No attribu
1426 return;
1427 }
1428 const G4String attName = Transcode(attri
1429 const G4String attValue = Transcode(attri
1430
1431 if(attName == "name")
1432 {
1433 name = GenerateName(attValue);
1434 }
1435 else if(attName == "lunit")
1436 {
1437 lunit = G4UnitDefinition::GetValueOf(at
1438 if(G4UnitDefinition::GetCategory(attVal
1439 {
1440 G4Exception("G4GDMLReadSolids::Polyhe
1441 FatalException, "Invalid
1442 }
1443 }
1444 else if(attName == "aunit")
1445 {
1446 aunit = G4UnitDefinition::GetValueOf(at
1447 if(G4UnitDefinition::GetCategory(attVal
1448 {
1449 G4Exception("G4GDMLReadSolids::Polyhe
1450 FatalException, "Invalid
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(attValu
1464 }
1465 }
1466
1467 startphi *= aunit;
1468 deltaphi *= aunit;
1469
1470 std::vector<zplaneType> zplaneList;
1471
1472 for(xercesc::DOMNode* iter = polyhedraEleme
1473 iter != nullptr; iter
1474 {
1475 if(iter->getNodeType() != xercesc::DOMNod
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::Polyhedr
1485 FatalException, "No child f
1486 return;
1487 }
1488 const G4String tag = Transcode(child->get
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[numZPla
1499 G4double* rmax_array = new G4double[numZPla
1500 G4double* z_array = new G4double[numZPla
1501
1502 for(std::size_t i = 0; i < numZPlanes; ++i)
1503 {
1504 rmin_array[i] = zplaneList[i].rmin * luni
1505 rmax_array[i] = zplaneList[i].rmax * luni
1506 z_array[i] = zplaneList[i].z * lunit;
1507 }
1508
1509 new G4Polyhedra(name, startphi, deltaphi, n
1510 z_array, rmin_array, rmax_a
1511
1512 delete[] rmin_array;
1513 delete[] rmax_array;
1514 delete[] z_array;
1515 }
1516
1517 // ------------------------------------------
1518 void G4GDMLReadSolids::GenericPolyhedraRead(
1519 const xercesc::DOMElement* const polyhedraE
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 attri
1529 polyhedraElement->getAttributes();
1530 XMLSize_t attributeCount = attributes->getL
1531
1532 for(XMLSize_t attribute_index = 0; attribut
1533 ++attribute_index)
1534 {
1535 xercesc::DOMNode* attribute_node = attrib
1536
1537 if(attribute_node->getNodeType() != xerce
1538 {
1539 continue;
1540 }
1541
1542 const xercesc::DOMAttr* const attribute =
1543 dynamic_cast<xercesc::DOMAttr*>(attribu
1544 if(attribute == nullptr)
1545 {
1546 G4Exception("G4GDMLReadSolids::GenericP
1547 FatalException, "No attribu
1548 return;
1549 }
1550 const G4String attName = Transcode(attri
1551 const G4String attValue = Transcode(attri
1552
1553 if(attName == "name")
1554 {
1555 name = GenerateName(attValue);
1556 }
1557 else if(attName == "lunit")
1558 {
1559 lunit = G4UnitDefinition::GetValueOf(at
1560 if(G4UnitDefinition::GetCategory(attVal
1561 {
1562 G4Exception("G4GDMLReadSolids::Generi
1563 FatalException, "Invalid
1564 }
1565 }
1566 else if(attName == "aunit")
1567 {
1568 aunit = G4UnitDefinition::GetValueOf(at
1569 if(G4UnitDefinition::GetCategory(attVal
1570 {
1571 G4Exception("G4GDMLReadSolids::Generi
1572 FatalException, "Invalid
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(attValu
1586 }
1587 }
1588
1589 startphi *= aunit;
1590 deltaphi *= aunit;
1591
1592 std::vector<rzPointType> rzpointList;
1593
1594 for(xercesc::DOMNode* iter = polyhedraEleme
1595 iter != nullptr; iter
1596 {
1597 if(iter->getNodeType() != xercesc::DOMNod
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::GenericP
1607 FatalException, "No child f
1608 return;
1609 }
1610 const G4String tag = Transcode(child->get
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[numRZPoint
1621 G4double* z_array = new G4double[numRZPoint
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, n
1630 r_array, z_array);
1631
1632 delete[] r_array;
1633 delete[] z_array;
1634 }
1635
1636 // ------------------------------------------
1637 G4QuadrangularFacet* G4GDMLReadSolids::Quadra
1638 const xercesc::DOMElement* const quadrangul
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 attri
1648 quadrangularElement->getAttributes();
1649 XMLSize_t attributeCount = attributes->getL
1650
1651 for(XMLSize_t attribute_index = 0; attribut
1652 ++attribute_index)
1653 {
1654 xercesc::DOMNode* attribute_node = attrib
1655
1656 if(attribute_node->getNodeType() != xerce
1657 {
1658 continue;
1659 }
1660
1661 const xercesc::DOMAttr* const attribute =
1662 dynamic_cast<xercesc::DOMAttr*>(attribu
1663 if(attribute == nullptr)
1664 {
1665 G4Exception("G4GDMLReadSolids::Quadrang
1666 FatalException, "No attribu
1667 return nullptr;
1668 }
1669 const G4String attName = Transcode(attri
1670 const G4String attValue = Transcode(attri
1671
1672 if(attName == "vertex1")
1673 {
1674 vertex1 = GetPosition(GenerateName(attV
1675 }
1676 else if(attName == "vertex2")
1677 {
1678 vertex2 = GetPosition(GenerateName(attV
1679 }
1680 else if(attName == "vertex3")
1681 {
1682 vertex3 = GetPosition(GenerateName(attV
1683 }
1684 else if(attName == "vertex4")
1685 {
1686 vertex4 = GetPosition(GenerateName(attV
1687 }
1688 else if(attName == "lunit")
1689 {
1690 lunit = G4UnitDefinition::GetValueOf(at
1691 if(G4UnitDefinition::GetCategory(attVal
1692 {
1693 G4Exception("G4GDMLReadSolids::Quadra
1694 FatalException, "Invalid
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 * lu
1707 vertex3 * lu
1708 }
1709
1710 // ------------------------------------------
1711 void G4GDMLReadSolids::ReflectedSolidRead(
1712 const xercesc::DOMElement* const reflectedS
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 attri
1723 reflectedSolidElement->getAttributes();
1724 XMLSize_t attributeCount = attributes->getL
1725
1726 for(XMLSize_t attribute_index = 0; attribut
1727 ++attribute_index)
1728 {
1729 xercesc::DOMNode* attribute_node = attrib
1730
1731 if(attribute_node->getNodeType() != xerce
1732 {
1733 continue;
1734 }
1735
1736 const xercesc::DOMAttr* const attribute =
1737 dynamic_cast<xercesc::DOMAttr*>(attribu
1738 if(attribute == nullptr)
1739 {
1740 G4Exception("G4GDMLReadSolids::Reflecte
1741 FatalException, "No attribu
1742 return;
1743 }
1744 const G4String attName = Transcode(attri
1745 const G4String attValue = Transcode(attri
1746
1747 if(attName == "name")
1748 {
1749 name = GenerateName(attValue);
1750 }
1751 else if(attName == "lunit")
1752 {
1753 lunit = G4UnitDefinition::GetValueOf(at
1754 if(G4UnitDefinition::GetCategory(attVal
1755 {
1756 G4Exception("G4GDMLReadSolids::Reflec
1757 FatalException, "Invalid
1758 }
1759 }
1760 else if(attName == "aunit")
1761 {
1762 aunit = G4UnitDefinition::GetValueOf(at
1763 if(G4UnitDefinition::GetCategory(attVal
1764 {
1765 G4Exception("G4GDMLReadSolids::Reflec
1766 FatalException, "Invalid
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(r
1815 transform = transform * G4Scale3D(scale.x()
1816
1817 new G4ReflectedSolid(name, GetSolid(solid),
1818 }
1819
1820 // ------------------------------------------
1821 void G4GDMLReadSolids::ScaledSolidRead(
1822 const xercesc::DOMElement* const scaledSoli
1823 {
1824 G4String name;
1825 G4VSolid* solid = nullptr;
1826 G4ThreeVector scale(1.0, 1.0, 1.0);
1827
1828 const xercesc::DOMNamedNodeMap* const attri
1829 scaledSolidElement->getAttributes();
1830 XMLSize_t attributeCount = attributes->getL
1831
1832 for(XMLSize_t attribute_index = 0; attribut
1833 ++attribute_index)
1834 {
1835 xercesc::DOMNode* attribute_node = attrib
1836
1837 if(attribute_node->getNodeType() != xerce
1838 {
1839 continue;
1840 }
1841
1842 const xercesc::DOMAttr* const attribute =
1843 dynamic_cast<xercesc::DOMAttr*>(attribu
1844 if(attribute == nullptr)
1845 {
1846 G4Exception("G4GDMLReadSolids::ScaledSo
1847 FatalException, "No attribu
1848 return;
1849 }
1850 const G4String attName = Transcode(attri
1851 const G4String attValue = Transcode(attri
1852
1853 if(attName == "name")
1854 {
1855 name = GenerateName(attValue);
1856 }
1857 }
1858
1859 for(xercesc::DOMNode* iter = scaledSolidEle
1860 iter != nullptr; iter
1861 {
1862 if(iter->getNodeType() != xercesc::DOMNod
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::ScaledSo
1872 FatalException, "No child f
1873 return;
1874 }
1875 const G4String tag = Transcode(child->get
1876
1877 if(tag == "solidref")
1878 {
1879 solid = GetSolid(GenerateName(RefRead(c
1880 }
1881 else if(tag == "scale")
1882 {
1883 VectorRead(child, scale);
1884 }
1885 else if(tag == "scaleref")
1886 {
1887 scale = GetScale(GenerateName(RefRead(c
1888 }
1889 else
1890 {
1891 G4String error_msg = "Unknown tag in sc
1892 G4Exception("G4GDMLReadSolids::ScaledSo
1893 FatalException, error_msg);
1894 return;
1895 }
1896 }
1897
1898 G4Scale3D transform = G4Scale3D(scale.x(),
1899
1900 new G4ScaledSolid(name, solid, transform);
1901 }
1902
1903 // ------------------------------------------
1904 G4ExtrudedSolid::ZSection G4GDMLReadSolids::S
1905 const xercesc::DOMElement* const sectionEle
1906 {
1907 G4double zPosition = 0.0;
1908 G4TwoVector Offset;
1909 G4double scalingFactor = 1.0;
1910
1911 const xercesc::DOMNamedNodeMap* const attri
1912 sectionElement->getAttributes();
1913 XMLSize_t attributeCount = attributes->getL
1914
1915 for(XMLSize_t attribute_index = 0; attribut
1916 ++attribute_index)
1917 {
1918 xercesc::DOMNode* attribute_node = attrib
1919
1920 if(attribute_node->getNodeType() != xerce
1921 {
1922 continue;
1923 }
1924
1925 const xercesc::DOMAttr* const attribute =
1926 dynamic_cast<xercesc::DOMAttr*>(attribu
1927 if(attribute == nullptr)
1928 {
1929 G4Exception("G4GDMLReadSolids::SectionR
1930 FatalException, "No attribu
1931 return G4ExtrudedSolid::ZSection(zPosit
1932 }
1933 const G4String attName = Transcode(attri
1934 const G4String attValue = Transcode(attri
1935
1936 if(attName == "zPosition")
1937 {
1938 zPosition = eval.Evaluate(attValue) * l
1939 }
1940 else if(attName == "xOffset")
1941 {
1942 Offset.setX(eval.Evaluate(attValue) * l
1943 }
1944 else if(attName == "yOffset")
1945 {
1946 Offset.setY(eval.Evaluate(attValue) * l
1947 }
1948 else if(attName == "scalingFactor")
1949 {
1950 scalingFactor = eval.Evaluate(attValue)
1951 }
1952 }
1953
1954 return G4ExtrudedSolid::ZSection(zPosition,
1955 }
1956
1957 // ------------------------------------------
1958 void G4GDMLReadSolids::SphereRead(
1959 const xercesc::DOMElement* const sphereElem
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 attri
1972 sphereElement->getAttributes();
1973 XMLSize_t attributeCount = attributes->getL
1974
1975 for(XMLSize_t attribute_index = 0; attribut
1976 ++attribute_index)
1977 {
1978 xercesc::DOMNode* attribute_node = attrib
1979
1980 if(attribute_node->getNodeType() != xerce
1981 {
1982 continue;
1983 }
1984
1985 const xercesc::DOMAttr* const attribute =
1986 dynamic_cast<xercesc::DOMAttr*>(attribu
1987 if(attribute == nullptr)
1988 {
1989 G4Exception("G4GDMLReadSolids::SphereRe
1990 FatalException, "No attribu
1991 return;
1992 }
1993 const G4String attName = Transcode(attri
1994 const G4String attValue = Transcode(attri
1995
1996 if(attName == "name")
1997 {
1998 name = GenerateName(attValue);
1999 }
2000 else if(attName == "lunit")
2001 {
2002 lunit = G4UnitDefinition::GetValueOf(at
2003 if(G4UnitDefinition::GetCategory(attVal
2004 {
2005 G4Exception("G4GDMLReadSolids::Sphere
2006 FatalException, "Invalid
2007 }
2008 }
2009 else if(attName == "aunit")
2010 {
2011 aunit = G4UnitDefinition::GetValueOf(at
2012 if(G4UnitDefinition::GetCategory(attVal
2013 {
2014 G4Exception("G4GDMLReadSolids::Sphere
2015 FatalException, "Invalid
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, de
2052 }
2053
2054 // ------------------------------------------
2055 void G4GDMLReadSolids::TessellatedRead(
2056 const xercesc::DOMElement* const tessellate
2057 {
2058 G4String name;
2059
2060 const xercesc::DOMNamedNodeMap* const attri
2061 tessellatedElement->getAttributes();
2062 XMLSize_t attributeCount = attributes->getL
2063
2064 for(XMLSize_t attribute_index = 0; attribut
2065 ++attribute_index)
2066 {
2067 xercesc::DOMNode* attribute_node = attrib
2068
2069 if(attribute_node->getNodeType() != xerce
2070 {
2071 continue;
2072 }
2073
2074 const xercesc::DOMAttr* const attribute =
2075 dynamic_cast<xercesc::DOMAttr*>(attribu
2076 if(attribute == nullptr)
2077 {
2078 G4Exception("G4GDMLReadSolids::Tessella
2079 FatalException, "No attribu
2080 return;
2081 }
2082 const G4String attName = Transcode(attri
2083 const G4String attValue = Transcode(attri
2084
2085 if(attName == "name")
2086 {
2087 name = GenerateName(attValue);
2088 }
2089 }
2090
2091 G4TessellatedSolid* tessellated = new G4Tes
2092
2093 for(xercesc::DOMNode* iter = tessellatedEle
2094 iter != nullptr; iter
2095 {
2096 if(iter->getNodeType() != xercesc::DOMNod
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::Tessella
2106 FatalException, "No child f
2107 return;
2108 }
2109 const G4String tag = Transcode(child->get
2110
2111 if(tag == "triangular")
2112 {
2113 tessellated->AddFacet(TriangularRead(ch
2114 }
2115 else if(tag == "quadrangular")
2116 {
2117 tessellated->AddFacet(QuadrangularRead(
2118 }
2119 }
2120
2121 tessellated->SetSolidClosed(true);
2122 }
2123
2124 // ------------------------------------------
2125 void G4GDMLReadSolids::TetRead(const xercesc:
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 attri
2135 tetElement->getAttributes();
2136 XMLSize_t attributeCount = attributes->getL
2137
2138 for(XMLSize_t attribute_index = 0; attribut
2139 ++attribute_index)
2140 {
2141 xercesc::DOMNode* attribute_node = attrib
2142
2143 if(attribute_node->getNodeType() != xerce
2144 {
2145 continue;
2146 }
2147
2148 const xercesc::DOMAttr* const attribute =
2149 dynamic_cast<xercesc::DOMAttr*>(attribu
2150 if(attribute == nullptr)
2151 {
2152 G4Exception("G4GDMLReadSolids::TetRead(
2153 "No attribute found!");
2154 return;
2155 }
2156 const G4String attName = Transcode(attri
2157 const G4String attValue = Transcode(attri
2158
2159 if(attName == "name")
2160 {
2161 name = GenerateName(attValue);
2162 }
2163 else if(attName == "lunit")
2164 {
2165 lunit = G4UnitDefinition::GetValueOf(at
2166 if(G4UnitDefinition::GetCategory(attVal
2167 {
2168 G4Exception("G4GDMLReadSolids::TetRea
2169 FatalException, "Invalid
2170 }
2171 }
2172 else if(attName == "vertex1")
2173 {
2174 vertex1 = GetPosition(GenerateName(attV
2175 }
2176 else if(attName == "vertex2")
2177 {
2178 vertex2 = GetPosition(GenerateName(attV
2179 }
2180 else if(attName == "vertex3")
2181 {
2182 vertex3 = GetPosition(GenerateName(attV
2183 }
2184 else if(attName == "vertex4")
2185 {
2186 vertex4 = GetPosition(GenerateName(attV
2187 }
2188 }
2189
2190 new G4Tet(name, vertex1 * lunit, vertex2 *
2191 vertex4 * lunit);
2192 }
2193
2194 // ------------------------------------------
2195 void G4GDMLReadSolids::TorusRead(const xerces
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 attri
2207 torusElement->getAttributes();
2208 XMLSize_t attributeCount = attributes->getL
2209
2210 for(XMLSize_t attribute_index = 0; attribut
2211 ++attribute_index)
2212 {
2213 xercesc::DOMNode* attribute_node = attrib
2214
2215 if(attribute_node->getNodeType() != xerce
2216 {
2217 continue;
2218 }
2219
2220 const xercesc::DOMAttr* const attribute =
2221 dynamic_cast<xercesc::DOMAttr*>(attribu
2222 if(attribute == nullptr)
2223 {
2224 G4Exception("G4GDMLReadSolids::TorusRea
2225 FatalException, "No attribu
2226 return;
2227 }
2228 const G4String attName = Transcode(attri
2229 const G4String attValue = Transcode(attri
2230
2231 if(attName == "name")
2232 {
2233 name = GenerateName(attValue);
2234 }
2235 else if(attName == "lunit")
2236 {
2237 lunit = G4UnitDefinition::GetValueOf(at
2238 if(G4UnitDefinition::GetCategory(attVal
2239 {
2240 G4Exception("G4GDMLReadSolids::TorusR
2241 FatalException, "Invalid
2242 }
2243 }
2244 else if(attName == "aunit")
2245 {
2246 aunit = G4UnitDefinition::GetValueOf(at
2247 if(G4UnitDefinition::GetCategory(attVal
2248 {
2249 G4Exception("G4GDMLReadSolids::TorusR
2250 FatalException, "Invalid
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, startph
2282 }
2283
2284 // ------------------------------------------
2285 void G4GDMLReadSolids::GenTrapRead(
2286 const xercesc::DOMElement* const gtrapEleme
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, v
2292 v4x = 0.0, v4y = 0.0, v5x = 0.0, v
2293 v7x = 0.0, v7y = 0.0, v8x = 0.0, v
2294
2295 const xercesc::DOMNamedNodeMap* const attri
2296 gtrapElement->getAttributes();
2297 XMLSize_t attributeCount = attributes->getL
2298
2299 for(XMLSize_t attribute_index = 0; attribut
2300 ++attribute_index)
2301 {
2302 xercesc::DOMNode* attribute_node = attrib
2303
2304 if(attribute_node->getNodeType() != xerce
2305 {
2306 continue;
2307 }
2308
2309 const xercesc::DOMAttr* const attribute =
2310 dynamic_cast<xercesc::DOMAttr*>(attribu
2311 if(attribute == nullptr)
2312 {
2313 G4Exception("G4GDMLReadSolids::GenTrapR
2314 FatalException, "No attribu
2315 return;
2316 }
2317 const G4String attName = Transcode(attri
2318 const G4String attValue = Transcode(attri
2319
2320 if(attName == "name")
2321 {
2322 name = GenerateName(attValue);
2323 }
2324 else if(attName == "lunit")
2325 {
2326 lunit = G4UnitDefinition::GetValueOf(at
2327 if(G4UnitDefinition::GetCategory(attVal
2328 {
2329 G4Exception("G4GDMLReadSolids::GenTra
2330 FatalException, "Invalid
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,
2406 vertices.push_back(G4TwoVector(v2x * lunit,
2407 vertices.push_back(G4TwoVector(v3x * lunit,
2408 vertices.push_back(G4TwoVector(v4x * lunit,
2409 vertices.push_back(G4TwoVector(v5x * lunit,
2410 vertices.push_back(G4TwoVector(v6x * lunit,
2411 vertices.push_back(G4TwoVector(v7x * lunit,
2412 vertices.push_back(G4TwoVector(v8x * lunit,
2413 new G4GenericTrap(name, dz, vertices);
2414 }
2415
2416 // ------------------------------------------
2417 void G4GDMLReadSolids::TrapRead(const xercesc
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 attri
2435 trapElement->getAttributes();
2436 XMLSize_t attributeCount = attributes->getL
2437
2438 for(XMLSize_t attribute_index = 0; attribut
2439 ++attribute_index)
2440 {
2441 xercesc::DOMNode* attribute_node = attrib
2442
2443 if(attribute_node->getNodeType() != xerce
2444 {
2445 continue;
2446 }
2447
2448 const xercesc::DOMAttr* const attribute =
2449 dynamic_cast<xercesc::DOMAttr*>(attribu
2450 if(attribute == nullptr)
2451 {
2452 G4Exception("G4GDMLReadSolids::TrapRead
2453 "No attribute found!");
2454 return;
2455 }
2456 const G4String attName = Transcode(attri
2457 const G4String attValue = Transcode(attri
2458
2459 if(attName == "name")
2460 {
2461 name = GenerateName(attValue);
2462 }
2463 else if(attName == "lunit")
2464 {
2465 lunit = G4UnitDefinition::GetValueOf(at
2466 if(G4UnitDefinition::GetCategory(attVal
2467 {
2468 G4Exception("G4GDMLReadSolids::TrapRe
2469 FatalException, "Invalid
2470 }
2471 }
2472 else if(attName == "aunit")
2473 {
2474 aunit = G4UnitDefinition::GetValueOf(at
2475 if(G4UnitDefinition::GetCategory(attVal
2476 {
2477 G4Exception("G4GDMLReadSolids::TrapRe
2478 FatalException, "Invalid
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,
2540 }
2541
2542 // ------------------------------------------
2543 void G4GDMLReadSolids::TrdRead(const xercesc:
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 attri
2554 trdElement->getAttributes();
2555 XMLSize_t attributeCount = attributes->getL
2556
2557 for(XMLSize_t attribute_index = 0; attribut
2558 ++attribute_index)
2559 {
2560 xercesc::DOMNode* attribute_node = attrib
2561
2562 if(attribute_node->getNodeType() != xerce
2563 {
2564 continue;
2565 }
2566
2567 const xercesc::DOMAttr* const attribute =
2568 dynamic_cast<xercesc::DOMAttr*>(attribu
2569 if(attribute == nullptr)
2570 {
2571 G4Exception("G4GDMLReadSolids::TrdRead(
2572 "No attribute found!");
2573 return;
2574 }
2575 const G4String attName = Transcode(attri
2576 const G4String attValue = Transcode(attri
2577
2578 if(attName == "name")
2579 {
2580 name = GenerateName(attValue);
2581 }
2582 else if(attName == "lunit")
2583 {
2584 lunit = G4UnitDefinition::GetValueOf(at
2585 if(G4UnitDefinition::GetCategory(attVal
2586 {
2587 G4Exception("G4GDMLReadSolids::TrdRea
2588 FatalException, "Invalid
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 // ------------------------------------------
2623 G4TriangularFacet* G4GDMLReadSolids::Triangul
2624 const xercesc::DOMElement* const triangular
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 attri
2633 triangularElement->getAttributes();
2634 XMLSize_t attributeCount = attributes->getL
2635
2636 for(XMLSize_t attribute_index = 0; attribut
2637 ++attribute_index)
2638 {
2639 xercesc::DOMNode* attribute_node = attrib
2640
2641 if(attribute_node->getNodeType() != xerce
2642 {
2643 continue;
2644 }
2645
2646 const xercesc::DOMAttr* const attribute =
2647 dynamic_cast<xercesc::DOMAttr*>(attribu
2648 if(attribute == nullptr)
2649 {
2650 G4Exception("G4GDMLReadSolids::Triangul
2651 FatalException, "No attribu
2652 return nullptr;
2653 }
2654 const G4String attName = Transcode(attri
2655 const G4String attValue = Transcode(attri
2656
2657 if(attName == "vertex1")
2658 {
2659 vertex1 = GetPosition(GenerateName(attV
2660 }
2661 else if(attName == "vertex2")
2662 {
2663 vertex2 = GetPosition(GenerateName(attV
2664 }
2665 else if(attName == "vertex3")
2666 {
2667 vertex3 = GetPosition(GenerateName(attV
2668 }
2669 else if(attName == "lunit")
2670 {
2671 lunit = G4UnitDefinition::GetValueOf(at
2672 if(G4UnitDefinition::GetCategory(attVal
2673 {
2674 G4Exception("G4GDMLReadSolids::Triang
2675 FatalException, "Invalid
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 * luni
2688 vertex3 * luni
2689 }
2690
2691 // ------------------------------------------
2692 void G4GDMLReadSolids::TubeRead(const xercesc
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 attri
2704 tubeElement->getAttributes();
2705 XMLSize_t attributeCount = attributes->getL
2706
2707 for(XMLSize_t attribute_index = 0; attribut
2708 ++attribute_index)
2709 {
2710 xercesc::DOMNode* attribute_node = attrib
2711
2712 if(attribute_node->getNodeType() != xerce
2713 {
2714 continue;
2715 }
2716
2717 const xercesc::DOMAttr* const attribute =
2718 dynamic_cast<xercesc::DOMAttr*>(attribu
2719 if(attribute == nullptr)
2720 {
2721 G4Exception("G4GDMLReadSolids::TubeRead
2722 "No attribute found!");
2723 return;
2724 }
2725 const G4String attName = Transcode(attri
2726 const G4String attValue = Transcode(attri
2727
2728 if(attName == "name")
2729 {
2730 name = GenerateName(attValue);
2731 }
2732 else if(attName == "lunit")
2733 {
2734 lunit = G4UnitDefinition::GetValueOf(at
2735 if(G4UnitDefinition::GetCategory(attVal
2736 {
2737 G4Exception("G4GDMLReadSolids::TubeRe
2738 FatalException, "Invalid
2739 }
2740 }
2741 else if(attName == "aunit")
2742 {
2743 aunit = G4UnitDefinition::GetValueOf(at
2744 if(G4UnitDefinition::GetCategory(attVal
2745 {
2746 G4Exception("G4GDMLReadSolids::TubeRe
2747 FatalException, "Invalid
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, d
2779 }
2780
2781 // ------------------------------------------
2782 void G4GDMLReadSolids::CutTubeRead(
2783 const xercesc::DOMElement* const cuttubeEle
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 attri
2797 cuttubeElement->getAttributes();
2798 XMLSize_t attributeCount = attributes->getL
2799
2800 for(XMLSize_t attribute_index = 0; attribut
2801 ++attribute_index)
2802 {
2803 xercesc::DOMNode* attribute_node = attrib
2804
2805 if(attribute_node->getNodeType() != xerce
2806 {
2807 continue;
2808 }
2809
2810 const xercesc::DOMAttr* const attribute =
2811 dynamic_cast<xercesc::DOMAttr*>(attribu
2812 if(attribute == nullptr)
2813 {
2814 G4Exception("G4GDMLReadSolids::CutTubeR
2815 FatalException, "No attribu
2816 return;
2817 }
2818 const G4String attName = Transcode(attri
2819 const G4String attValue = Transcode(attri
2820
2821 if(attName == "name")
2822 {
2823 name = GenerateName(attValue);
2824 }
2825 else if(attName == "lunit")
2826 {
2827 lunit = G4UnitDefinition::GetValueOf(at
2828 if(G4UnitDefinition::GetCategory(attVal
2829 {
2830 G4Exception("G4GDMLReadSolids::CutTub
2831 FatalException, "Invalid
2832 }
2833 }
2834 else if(attName == "aunit")
2835 {
2836 aunit = G4UnitDefinition::GetValueOf(at
2837 if(G4UnitDefinition::GetCategory(attVal
2838 {
2839 G4Exception("G4GDMLReadSolids::CutTub
2840 FatalException, "Invalid
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
2896 }
2897
2898 // ------------------------------------------
2899 void G4GDMLReadSolids::TwistedboxRead(
2900 const xercesc::DOMElement* const twistedbox
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 attri
2911 twistedboxElement->getAttributes();
2912 XMLSize_t attributeCount = attributes->getL
2913
2914 for(XMLSize_t attribute_index = 0; attribut
2915 ++attribute_index)
2916 {
2917 xercesc::DOMNode* attribute_node = attrib
2918
2919 if(attribute_node->getNodeType() != xerce
2920 {
2921 continue;
2922 }
2923
2924 const xercesc::DOMAttr* const attribute =
2925 dynamic_cast<xercesc::DOMAttr*>(attribu
2926 if(attribute == nullptr)
2927 {
2928 G4Exception("G4GDMLReadSolids::Twistedb
2929 FatalException, "No attribu
2930 return;
2931 }
2932 const G4String attName = Transcode(attri
2933 const G4String attValue = Transcode(attri
2934
2935 if(attName == "name")
2936 {
2937 name = GenerateName(attValue);
2938 }
2939 else if(attName == "lunit")
2940 {
2941 lunit = G4UnitDefinition::GetValueOf(at
2942 if(G4UnitDefinition::GetCategory(attVal
2943 {
2944 G4Exception("G4GDMLReadSolids::Twiste
2945 FatalException, "Invalid
2946 }
2947 }
2948 else if(attName == "aunit")
2949 {
2950 aunit = G4UnitDefinition::GetValueOf(at
2951 if(G4UnitDefinition::GetCategory(attVal
2952 {
2953 G4Exception("G4GDMLReadSolids::Twiste
2954 FatalException, "Invalid
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 // ------------------------------------------
2984 void G4GDMLReadSolids::TwistedtrapRead(
2985 const xercesc::DOMElement* const twistedtra
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 attri
3003 twistedtrapElement->getAttributes();
3004 XMLSize_t attributeCount = attributes->getL
3005
3006 for(XMLSize_t attribute_index = 0; attribut
3007 ++attribute_index)
3008 {
3009 xercesc::DOMNode* attribute_node = attrib
3010
3011 if(attribute_node->getNodeType() != xerce
3012 {
3013 continue;
3014 }
3015
3016 const xercesc::DOMAttr* const attribute =
3017 dynamic_cast<xercesc::DOMAttr*>(attribu
3018 if(attribute == nullptr)
3019 {
3020 G4Exception("G4GDMLReadSolids::Twistedt
3021 FatalException, "No attribu
3022 return;
3023 }
3024 const G4String attName = Transcode(attri
3025 const G4String attValue = Transcode(attri
3026
3027 if(attName == "name")
3028 {
3029 name = GenerateName(attValue);
3030 }
3031 else if(attName == "lunit")
3032 {
3033 lunit = G4UnitDefinition::GetValueOf(at
3034 if(G4UnitDefinition::GetCategory(attVal
3035 {
3036 G4Exception("G4GDMLReadSolids::Twiste
3037 FatalException, "Invalid
3038 }
3039 }
3040 else if(attName == "aunit")
3041 {
3042 aunit = G4UnitDefinition::GetValueOf(at
3043 if(G4UnitDefinition::GetCategory(attVal
3044 {
3045 G4Exception("G4GDMLReadSolids::Twiste
3046 FatalException, "Invalid
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,
3108 Alph);
3109 }
3110
3111 // ------------------------------------------
3112 void G4GDMLReadSolids::TwistedtrdRead(
3113 const xercesc::DOMElement* const twistedtrd
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 attri
3126 twistedtrdElement->getAttributes();
3127 XMLSize_t attributeCount = attributes->getL
3128
3129 for(XMLSize_t attribute_index = 0; attribut
3130 ++attribute_index)
3131 {
3132 xercesc::DOMNode* attribute_node = attrib
3133
3134 if(attribute_node->getNodeType() != xerce
3135 {
3136 continue;
3137 }
3138
3139 const xercesc::DOMAttr* const attribute =
3140 dynamic_cast<xercesc::DOMAttr*>(attribu
3141 if(attribute == nullptr)
3142 {
3143 G4Exception("G4GDMLReadSolids::Twistedt
3144 FatalException, "No attribu
3145 return;
3146 }
3147 const G4String attName = Transcode(attri
3148 const G4String attValue = Transcode(attri
3149
3150 if(attName == "name")
3151 {
3152 name = GenerateName(attValue);
3153 }
3154 else if(attName == "lunit")
3155 {
3156 lunit = G4UnitDefinition::GetValueOf(at
3157 if(G4UnitDefinition::GetCategory(attVal
3158 {
3159 G4Exception("G4GDMLReadSolids::Twiste
3160 FatalException, "Invalid
3161 }
3162 }
3163 else if(attName == "aunit")
3164 {
3165 aunit = G4UnitDefinition::GetValueOf(at
3166 if(G4UnitDefinition::GetCategory(attVal
3167 {
3168 G4Exception("G4GDMLReadSolids::Twiste
3169 FatalException, "Invalid
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, P
3206 }
3207
3208 // ------------------------------------------
3209 void G4GDMLReadSolids::TwistedtubsRead(
3210 const xercesc::DOMElement* const twistedtub
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 attri
3228 twistedtubsElement->getAttributes();
3229 XMLSize_t attributeCount = attributes->getL
3230
3231 for(XMLSize_t attribute_index = 0; attribut
3232 ++attribute_index)
3233 {
3234 xercesc::DOMNode* attribute_node = attrib
3235
3236 if(attribute_node->getNodeType() != xerce
3237 {
3238 continue;
3239 }
3240
3241 const xercesc::DOMAttr* const attribute =
3242 dynamic_cast<xercesc::DOMAttr*>(attribu
3243 if(attribute == nullptr)
3244 {
3245 G4Exception("G4GDMLReadSolids::Twistedt
3246 FatalException, "No attribu
3247 return;
3248 }
3249 const G4String attName = Transcode(attri
3250 const G4String attValue = Transcode(attri
3251
3252 if(attName == "name")
3253 {
3254 name = GenerateName(attValue);
3255 }
3256 else if(attName == "lunit")
3257 {
3258 lunit = G4UnitDefinition::GetValueOf(at
3259 if(G4UnitDefinition::GetCategory(attVal
3260 {
3261 G4Exception("G4GDMLReadSolids::Twiste
3262 FatalException, "Invalid
3263 }
3264 }
3265 else if(attName == "aunit")
3266 {
3267 aunit = G4UnitDefinition::GetValueOf(at
3268 if(G4UnitDefinition::GetCategory(attVal
3269 {
3270 G4Exception("G4GDMLReadSolids::Twiste
3271 FatalException, "Invalid
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, e
3335 nseg, totphi);
3336 else
3337 new G4TwistedTubs(name, twistedangle, e
3338 phi);
3339 }
3340 else
3341 {
3342 if(nseg != 0)
3343 new G4TwistedTubs(name, twistedangle, m
3344 negativeEndz, positiv
3345 else
3346 new G4TwistedTubs(name, twistedangle, m
3347 negativeEndz, positiv
3348 }
3349 }
3350
3351 // ------------------------------------------
3352 G4TwoVector G4GDMLReadSolids::TwoDimVertexRea
3353 const xercesc::DOMElement* const element, G
3354 {
3355 G4TwoVector vec;
3356
3357 const xercesc::DOMNamedNodeMap* const attri
3358 XMLSize_t attributeCount
3359
3360 for(XMLSize_t attribute_index = 0; attribut
3361 ++attribute_index)
3362 {
3363 xercesc::DOMNode* attribute_node = attrib
3364
3365 if(attribute_node->getNodeType() != xerce
3366 {
3367 continue;
3368 }
3369
3370 const xercesc::DOMAttr* const attribute =
3371 dynamic_cast<xercesc::DOMAttr*>(attribu
3372 if(attribute == nullptr)
3373 {
3374 G4Exception("G4GDMLReadSolids::TwoDimVe
3375 FatalException, "No attribu
3376 return vec;
3377 }
3378 const G4String attName = Transcode(attri
3379 const G4String attValue = Transcode(attri
3380
3381 if(attName == "x")
3382 {
3383 vec.setX(eval.Evaluate(attValue) * luni
3384 }
3385 else if(attName == "y")
3386 {
3387 vec.setY(eval.Evaluate(attValue) * luni
3388 }
3389 }
3390
3391 return vec;
3392 }
3393
3394 // ------------------------------------------
3395 G4GDMLReadSolids::zplaneType G4GDMLReadSolids
3396 const xercesc::DOMElement* const zplaneElem
3397 {
3398 zplaneType zplane = { 0., 0., 0. };
3399
3400 const xercesc::DOMNamedNodeMap* const attri
3401 zplaneElement->getAttributes();
3402 XMLSize_t attributeCount = attributes->getL
3403
3404 for(XMLSize_t attribute_index = 0; attribut
3405 ++attribute_index)
3406 {
3407 xercesc::DOMNode* node = attributes->item
3408
3409 if(node->getNodeType() != xercesc::DOMNod
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::ZplaneRe
3419 FatalException, "No attribu
3420 return zplane;
3421 }
3422 const G4String attName = Transcode(attri
3423 const G4String attValue = Transcode(attri
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 // ------------------------------------------
3443 G4GDMLReadSolids::rzPointType G4GDMLReadSolid
3444 const xercesc::DOMElement* const zplaneElem
3445 {
3446 rzPointType rzpoint = { 0., 0. };
3447
3448 const xercesc::DOMNamedNodeMap* const attri
3449 zplaneElement->getAttributes();
3450 XMLSize_t attributeCount = attributes->getL
3451
3452 for(XMLSize_t attribute_index = 0; attribut
3453 ++attribute_index)
3454 {
3455 xercesc::DOMNode* node = attributes->item
3456
3457 if(node->getNodeType() != xercesc::DOMNod
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::RZPointR
3467 FatalException, "No attribu
3468 return rzpoint;
3469 }
3470 const G4String attName = Transcode(attri
3471 const G4String attValue = Transcode(attri
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 // ------------------------------------------
3487 void G4GDMLReadSolids::PropertyRead(
3488 const xercesc::DOMElement* const propertyEl
3489 G4OpticalSurface* opticalsurface)
3490 {
3491 G4String name;
3492 G4String ref;
3493 G4GDMLMatrix matrix;
3494
3495 const xercesc::DOMNamedNodeMap* const attri
3496 propertyElement->getAttributes();
3497 XMLSize_t attributeCount = attributes->getL
3498
3499 for(XMLSize_t attribute_index = 0; attribut
3500 ++attribute_index)
3501 {
3502 xercesc::DOMNode* attribute_node = attrib
3503
3504 if(attribute_node->getNodeType() != xerce
3505 {
3506 continue;
3507 }
3508
3509 const xercesc::DOMAttr* const attribute =
3510 dynamic_cast<xercesc::DOMAttr*>(attribu
3511 if(attribute == nullptr)
3512 {
3513 G4Exception("G4GDMLReadSolids::Property
3514 FatalException, "No attribu
3515 return;
3516 }
3517 const G4String attName = Transcode(attri
3518 const G4String attValue = Transcode(attri
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 '
3534 + "' should have \n two columns as
3535 opticalsurface: "
3536 + opticalsurface->GetName();
3537 G4Exception("G4GDMLReadSolids::PropertyRe
3538 FatalException, error_msg);
3539 }
3540 */
3541
3542 if(matrix.GetRows() == 0)
3543 {
3544 return;
3545 }
3546
3547 G4MaterialPropertiesTable* matprop =
3548 opticalsurface->GetMaterialPropertiesTabl
3549 if(matprop == nullptr)
3550 {
3551 matprop = new G4MaterialPropertiesTable()
3552 opticalsurface->SetMaterialPropertiesTabl
3553 }
3554 if(matrix.GetCols() == 1) // constant prop
3555 {
3556 matprop->AddConstProperty(Strip(name), ma
3557 }
3558 else // build the material properties vect
3559 {
3560 G4MaterialPropertyVector* propvect;
3561 G4String temp = name + ref;
3562 // first check if it was already built
3563 if(mapOfMatPropVects.find(temp) == mapOfM
3564 {
3565 // if not create a new one
3566 propvect = new G4MaterialPropertyVector
3567 for(size_t i = 0; i < matrix.GetRows();
3568 {
3569 propvect->InsertValues(matrix.Get(i,
3570 }
3571 // and add it to the list for potential
3572 mapOfMatPropVects[temp] = propvect;
3573 }
3574 else
3575 {
3576 propvect = mapOfMatPropVects[temp];
3577 }
3578
3579 matprop->AddProperty(Strip(name), propvec
3580 }
3581 }
3582
3583 // ------------------------------------------
3584 void G4GDMLReadSolids::OpticalSurfaceRead(
3585 const xercesc::DOMElement* const opticalsur
3586 {
3587 G4String name;
3588 G4String smodel;
3589 G4String sfinish;
3590 G4String stype;
3591 G4double value = 0.0;
3592
3593 const xercesc::DOMNamedNodeMap* const attri
3594 opticalsurfaceElement->getAttributes();
3595 XMLSize_t attributeCount = attributes->getL
3596
3597 for(XMLSize_t attribute_index = 0; attribut
3598 ++attribute_index)
3599 {
3600 xercesc::DOMNode* attribute_node = attrib
3601
3602 if(attribute_node->getNodeType() != xerce
3603 {
3604 continue;
3605 }
3606
3607 const xercesc::DOMAttr* const attribute =
3608 dynamic_cast<xercesc::DOMAttr*>(attribu
3609 if(attribute == nullptr)
3610 {
3611 G4Exception("G4GDMLReadSolids::OpticalS
3612 FatalException, "No attribu
3613 return;
3614 }
3615 const G4String attName = Transcode(attri
3616 const G4String attValue = Transcode(attri
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 ==
3649 {
3650 model = unified;
3651 }
3652 else if((smodel == "LUT") || (smodel == "2"
3653 {
3654 model = LUT;
3655 }
3656 else if((smodel == "DAVIS") || (smodel == "
3657 {
3658 model = DAVIS;
3659 }
3660 else
3661 {
3662 model = dichroic;
3663 }
3664
3665 if((sfinish == "polished") || (sfinish == "
3666 {
3667 finish = polished;
3668 }
3669 else if((sfinish == "polishedfrontpainted")
3670 {
3671 finish = polishedfrontpainted;
3672 }
3673 else if((sfinish == "polishedbackpainted")
3674 {
3675 finish = polishedbackpainted;
3676 }
3677 else if((sfinish == "ground") || (sfinish =
3678 {
3679 finish = ground;
3680 }
3681 else if((sfinish == "groundfrontpainted") |
3682 {
3683 finish = groundfrontpainted;
3684 }
3685 else if((sfinish == "groundbackpainted") ||
3686 {
3687 finish = groundbackpainted;
3688 }
3689 else if((sfinish == "polishedlumirrorair")
3690 {
3691 finish = polishedlumirrorair;
3692 }
3693 else if((sfinish == "polishedlumirrorglue")
3694 {
3695 finish = polishedlumirrorglue;
3696 }
3697 else if((sfinish == "polishedair") || (sfin
3698 {
3699 finish = polishedair;
3700 }
3701 else if((sfinish == "polishedteflonair") ||
3702 {
3703 finish = polishedteflonair;
3704 }
3705 else if((sfinish == "polishedtioair") || (s
3706 {
3707 finish = polishedtioair;
3708 }
3709 else if((sfinish == "polishedtyvekair") ||
3710 {
3711 finish = polishedtyvekair;
3712 }
3713 else if((sfinish == "polishedvm2000air") ||
3714 {
3715 finish = polishedvm2000air;
3716 }
3717 else if((sfinish == "polishedvm2000glue") |
3718 {
3719 finish = polishedvm2000glue;
3720 }
3721 else if((sfinish == "etchedlumirrorair") ||
3722 {
3723 finish = etchedlumirrorair;
3724 }
3725 else if((sfinish == "etchedlumirrorglue") |
3726 {
3727 finish = etchedlumirrorglue;
3728 }
3729 else if((sfinish == "etchedair") || (sfinis
3730 {
3731 finish = etchedair;
3732 }
3733 else if((sfinish == "etchedteflonair") || (
3734 {
3735 finish = etchedteflonair;
3736 }
3737 else if((sfinish == "etchedtioair") || (sfi
3738 {
3739 finish = etchedtioair;
3740 }
3741 else if((sfinish == "etchedtyvekair") || (s
3742 {
3743 finish = etchedtyvekair;
3744 }
3745 else if((sfinish == "etchedvm2000air") || (
3746 {
3747 finish = etchedvm2000air;
3748 }
3749 else if((sfinish == "etchedvm2000glue") ||
3750 {
3751 finish = etchedvm2000glue;
3752 }
3753 else if((sfinish == "groundlumirrorair") ||
3754 {
3755 finish = groundlumirrorair;
3756 }
3757 else if((sfinish == "groundlumirrorglue") |
3758 {
3759 finish = groundlumirrorglue;
3760 }
3761 else if((sfinish == "groundair") || (sfinis
3762 {
3763 finish = groundair;
3764 }
3765 else if((sfinish == "groundteflonair") || (
3766 {
3767 finish = groundteflonair;
3768 }
3769 else if((sfinish == "groundtioair") || (sfi
3770 {
3771 finish = groundtioair;
3772 }
3773 else if((sfinish == "groundtyvekair") || (s
3774 {
3775 finish = groundtyvekair;
3776 }
3777 else if((sfinish == "groundvm2000air") || (
3778 {
3779 finish = groundvm2000air;
3780 }
3781 else if((sfinish == "groundvm2000glue") ||
3782 {
3783 finish = groundvm2000glue;
3784 }
3785 else if((sfinish == "Rough_LUT") || (sfinis
3786 {
3787 finish = Rough_LUT;
3788 }
3789 else if((sfinish == "RoughTeflon_LUT") || (
3790 {
3791 finish = RoughTeflon_LUT;
3792 }
3793 else if((sfinish == "RoughESR_LUT") || (sfi
3794 {
3795 finish = RoughESR_LUT;
3796 }
3797 else if((sfinish == "RoughESRGrease_LUT") |
3798 {
3799 finish = RoughESRGrease_LUT;
3800 }
3801 else if((sfinish == "Polished_LUT") || (sfi
3802 {
3803 finish = Polished_LUT;
3804 }
3805 else if((sfinish == "PolishedTeflon_LUT") |
3806 {
3807 finish = PolishedTeflon_LUT;
3808 }
3809 else if((sfinish == "PolishedESR_LUT") || (
3810 {
3811 finish = PolishedESR_LUT;
3812 }
3813 else if((sfinish == "PolishedESRGrease_LUT"
3814 {
3815 finish = PolishedESRGrease_LUT;
3816 }
3817 else
3818 {
3819 finish = Detector_LUT;
3820 }
3821
3822 if((stype == "dielectric_metal") || (stype
3823 {
3824 type = dielectric_metal;
3825 }
3826 else if((stype == "dielectric_dielectric")
3827 {
3828 type = dielectric_dielectric;
3829 }
3830 else if((stype == "dielectric_LUT") || (sty
3831 {
3832 type = dielectric_LUT;
3833 }
3834 else if((stype == "dielectric_LUTDAVIS") ||
3835 {
3836 type = dielectric_LUTDAVIS;
3837 }
3838 else if((stype == "dielectric_dichroic") ||
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,
3853
3854 for(xercesc::DOMNode* iter = opticalsurface
3855 iter != nullptr; iter = iter->getNextSi
3856 {
3857 if(iter->getNodeType() != xercesc::DOMNod
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::OpticalS
3867 FatalException, "No child f
3868 return;
3869 }
3870 const G4String tag = Transcode(child->get
3871
3872 if(tag == "property")
3873 {
3874 PropertyRead(child, opticalsurface);
3875 }
3876 }
3877 }
3878
3879 // ------------------------------------------
3880 void G4GDMLReadSolids::SolidsRead(
3881 const xercesc::DOMElement* const solidsElem
3882 {
3883 #ifdef G4VERBOSE
3884 G4cout << "G4GDML: Reading solids..." << G4
3885 #endif
3886 for(xercesc::DOMNode* iter = solidsElement-
3887 iter = iter->getNextS
3888 {
3889 if(iter->getNodeType() != xercesc::DOMNod
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::SolidsRe
3899 FatalException, "No child f
3900 return;
3901 }
3902 const G4String tag = Transcode(child->get
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 so
4050 G4Exception("G4GDMLReadSolids::SolidsRe
4051 error_msg);
4052 }
4053 }
4054 }
4055
4056 // ------------------------------------------
4057 G4VSolid* G4GDMLReadSolids::GetSolid(const G4
4058 {
4059 G4VSolid* solidPtr = G4SolidStore::GetInsta
4060 ->GetSoli
4061
4062 if(solidPtr == nullptr)
4063 {
4064 G4String error_msg = "Referenced solid '"
4065 G4Exception("G4GDMLReadSolids::GetSolid()
4066 error_msg);
4067 }
4068
4069 return solidPtr;
4070 }
4071
4072 // ------------------------------------------
4073 G4SurfaceProperty* G4GDMLReadSolids::GetSurfa
4074 const G4String& ref) const
4075 {
4076 const G4SurfacePropertyTable* surfaceList =
4077 G4SurfaceProperty::GetSurfacePropertyTabl
4078 const std::size_t surfaceCount = surfaceLis
4079
4080 for(std::size_t i = 0; i < surfaceCount; ++
4081 {
4082 if((*surfaceList)[i]->GetName() == ref)
4083 {
4084 return (*surfaceList)[i];
4085 }
4086 }
4087
4088 G4String error_msg =
4089 "Referenced optical surface '" + ref + "'
4090 G4Exception("G4GDMLReadSolids::GetSurfacePr
4091 FatalException, error_msg);
4092
4093 return nullptr;
4094 }
4095