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