Geant4 9.6.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// $Id$
27//
28// class G4GDMLReadSolids Implementation
29//
30// Original author: Zoltan Torzsok, November 2007
31//
32// --------------------------------------------------------------------
33
34#include "G4GDMLReadSolids.hh"
35
36#include "G4Box.hh"
37#include "G4Cons.hh"
38#include "G4Ellipsoid.hh"
39#include "G4EllipticalCone.hh"
40#include "G4EllipticalTube.hh"
41#include "G4Hype.hh"
42#include "G4IntersectionSolid.hh"
43#include "G4Orb.hh"
44#include "G4Para.hh"
45#include "G4Paraboloid.hh"
46#include "G4Polycone.hh"
47#include "G4Polyhedra.hh"
48#include "G4QuadrangularFacet.hh"
49#include "G4ReflectedSolid.hh"
50#include "G4Sphere.hh"
51#include "G4SolidStore.hh"
52#include "G4SubtractionSolid.hh"
53#include "G4GenericTrap.hh"
54#include "G4TessellatedSolid.hh"
55#include "G4Tet.hh"
56#include "G4Torus.hh"
57#include "G4Transform3D.hh"
58#include "G4Trap.hh"
59#include "G4Trd.hh"
60#include "G4TriangularFacet.hh"
61#include "G4Tubs.hh"
62#include "G4CutTubs.hh"
63#include "G4TwistedBox.hh"
64#include "G4TwistedTrap.hh"
65#include "G4TwistedTrd.hh"
66#include "G4TwistedTubs.hh"
67#include "G4UnionSolid.hh"
68#include "G4OpticalSurface.hh"
69#include "G4SurfaceProperty.hh"
70
71G4GDMLReadSolids::G4GDMLReadSolids() : G4GDMLReadMaterials()
72{
73}
74
75G4GDMLReadSolids::~G4GDMLReadSolids()
76{
77}
78
79void G4GDMLReadSolids::
80BooleanRead(const xercesc::DOMElement* const booleanElement, const BooleanOp op)
81{
82 G4String name;
83 G4String first;
84 G4String scnd;
85 G4ThreeVector position(0.0,0.0,0.0);
86 G4ThreeVector rotation(0.0,0.0,0.0);
87 G4ThreeVector firstposition(0.0,0.0,0.0);
88 G4ThreeVector firstrotation(0.0,0.0,0.0);
89
90 const xercesc::DOMNamedNodeMap* const attributes
91 = booleanElement->getAttributes();
92 XMLSize_t attributeCount = attributes->getLength();
93
94 for (XMLSize_t attribute_index=0;
95 attribute_index<attributeCount; attribute_index++)
96 {
97 xercesc::DOMNode* attribute_node = attributes->item(attribute_index);
98
99 if (attribute_node->getNodeType() != xercesc::DOMNode::ATTRIBUTE_NODE)
100 { continue; }
101
102 const xercesc::DOMAttr* const attribute
103 = dynamic_cast<xercesc::DOMAttr*>(attribute_node);
104 if (!attribute)
105 {
106 G4Exception("G4GDMLReadSolids::BooleanRead()",
107 "InvalidRead", FatalException, "No attribute found!");
108 return;
109 }
110 const G4String attName = Transcode(attribute->getName());
111 const G4String attValue = Transcode(attribute->getValue());
112
113 if (attName=="name") { name = GenerateName(attValue); }
114 }
115
116 for (xercesc::DOMNode* iter = booleanElement->getFirstChild();
117 iter != 0;iter = iter->getNextSibling())
118 {
119 if (iter->getNodeType() != xercesc::DOMNode::ELEMENT_NODE) { continue; }
120
121 const xercesc::DOMElement* const child
122 = dynamic_cast<xercesc::DOMElement*>(iter);
123 if (!child)
124 {
125 G4Exception("G4GDMLReadSolids::BooleanRead()",
126 "InvalidRead", FatalException, "No child found!");
127 return;
128 }
129 const G4String tag = Transcode(child->getTagName());
130
131 if (tag=="first") { first = RefRead(child); } else
132 if (tag=="second") { scnd = RefRead(child); } else
133 if (tag=="position") { VectorRead(child,position); } else
134 if (tag=="rotation") { VectorRead(child,rotation); } else
135 if (tag=="positionref")
136 { position = GetPosition(GenerateName(RefRead(child))); } else
137 if (tag=="rotationref")
138 { rotation = GetRotation(GenerateName(RefRead(child))); } else
139 if (tag=="firstposition") { VectorRead(child,firstposition); } else
140 if (tag=="firstrotation") { VectorRead(child,firstrotation); } else
141 if (tag=="firstpositionref")
142 { firstposition = GetPosition(GenerateName(RefRead(child))); } else
143 if (tag=="firstrotationref")
144 { firstrotation = GetRotation(GenerateName(RefRead(child))); }
145 else
146 {
147 G4String error_msg = "Unknown tag in boolean solid: " + tag;
148 G4Exception("G4GDMLReadSolids::BooleanRead()", "ReadError",
149 FatalException, error_msg);
150 }
151 }
152
153 G4VSolid* firstSolid = GetSolid(GenerateName(first));
154 G4VSolid* secondSolid = GetSolid(GenerateName(scnd));
155
156 G4Transform3D transform(GetRotationMatrix(rotation),position);
157
158 if (( (firstrotation.x()!=0.0) || (firstrotation.y()!=0.0)
159 || (firstrotation.z()!=0.0))
160 || ( (firstposition.x()!=0.0) || (firstposition.y()!=0.0)
161 || (firstposition.z()!=0.0)))
162 {
163 G4Transform3D firsttransform(GetRotationMatrix(firstrotation),
164 firstposition);
165 firstSolid = new G4DisplacedSolid(GenerateName("displaced_"+first),
166 firstSolid, firsttransform);
167 }
168
169 if (op==UNION)
170 { new G4UnionSolid(name,firstSolid,secondSolid,transform); } else
171 if (op==SUBTRACTION)
172 { new G4SubtractionSolid(name,firstSolid,secondSolid,transform); } else
173 if (op==INTERSECTION)
174 { new G4IntersectionSolid(name,firstSolid,secondSolid,transform); }
175}
176
177void G4GDMLReadSolids::BoxRead(const xercesc::DOMElement* const boxElement)
178{
179 G4String name;
180 G4double lunit = 1.0;
181 G4double x = 0.0;
182 G4double y = 0.0;
183 G4double z = 0.0;
184
185 const xercesc::DOMNamedNodeMap* const attributes
186 = boxElement->getAttributes();
187 XMLSize_t attributeCount = attributes->getLength();
188
189 for (XMLSize_t attribute_index=0;
190 attribute_index<attributeCount; attribute_index++)
191 {
192 xercesc::DOMNode* attribute_node = attributes->item(attribute_index);
193
194 if (attribute_node->getNodeType() != xercesc::DOMNode::ATTRIBUTE_NODE)
195 { continue; }
196
197 const xercesc::DOMAttr* const attribute
198 = dynamic_cast<xercesc::DOMAttr*>(attribute_node);
199 if (!attribute)
200 {
201 G4Exception("G4GDMLReadSolids::BoxRead()",
202 "InvalidRead", FatalException, "No attribute found!");
203 return;
204 }
205 const G4String attName = Transcode(attribute->getName());
206 const G4String attValue = Transcode(attribute->getValue());
207
208 if (attName=="name") { name = GenerateName(attValue); } else
209 if (attName=="lunit") { lunit = eval.Evaluate(attValue); } else
210 if (attName=="x") { x = eval.Evaluate(attValue); } else
211 if (attName=="y") { y = eval.Evaluate(attValue); } else
212 if (attName=="z") { z = eval.Evaluate(attValue); }
213 }
214
215 x *= 0.5*lunit;
216 y *= 0.5*lunit;
217 z *= 0.5*lunit;
218
219 new G4Box(name,x,y,z);
220}
221
222void G4GDMLReadSolids::ConeRead(const xercesc::DOMElement* const coneElement)
223{
224 G4String name;
225 G4double lunit = 1.0;
226 G4double aunit = 1.0;
227 G4double rmin1 = 0.0;
228 G4double rmax1 = 0.0;
229 G4double rmin2 = 0.0;
230 G4double rmax2 = 0.0;
231 G4double z = 0.0;
232 G4double startphi = 0.0;
233 G4double deltaphi = 0.0;
234
235 const xercesc::DOMNamedNodeMap* const attributes
236 = coneElement->getAttributes();
237 XMLSize_t attributeCount = attributes->getLength();
238
239 for (XMLSize_t attribute_index=0;
240 attribute_index<attributeCount; attribute_index++)
241 {
242 xercesc::DOMNode* attribute_node = attributes->item(attribute_index);
243
244 if (attribute_node->getNodeType() != xercesc::DOMNode::ATTRIBUTE_NODE)
245 { continue; }
246
247 const xercesc::DOMAttr* const attribute
248 = dynamic_cast<xercesc::DOMAttr*>(attribute_node);
249 if (!attribute)
250 {
251 G4Exception("G4GDMLReadSolids::ConeRead()",
252 "InvalidRead", FatalException, "No attribute found!");
253 return;
254 }
255 const G4String attName = Transcode(attribute->getName());
256 const G4String attValue = Transcode(attribute->getValue());
257
258 if (attName=="name") { name = GenerateName(attValue); } else
259 if (attName=="lunit") { lunit = eval.Evaluate(attValue); } else
260 if (attName=="aunit") { aunit = eval.Evaluate(attValue); } else
261 if (attName=="rmin1") { rmin1 = eval.Evaluate(attValue); } else
262 if (attName=="rmax1") { rmax1 = eval.Evaluate(attValue); } else
263 if (attName=="rmin2") { rmin2 = eval.Evaluate(attValue); } else
264 if (attName=="rmax2") { rmax2 = eval.Evaluate(attValue); } else
265 if (attName=="z") { z = eval.Evaluate(attValue); } else
266 if (attName=="startphi") { startphi = eval.Evaluate(attValue); } else
267 if (attName=="deltaphi") { deltaphi = eval.Evaluate(attValue); }
268 }
269
270 rmin1 *= lunit;
271 rmax1 *= lunit;
272 rmin2 *= lunit;
273 rmax2 *= lunit;
274 z *= 0.5*lunit;
275 startphi *= aunit;
276 deltaphi *= aunit;
277
278 new G4Cons(name,rmin1,rmax1,rmin2,rmax2,z,startphi,deltaphi);
279}
280
281void G4GDMLReadSolids::
282ElconeRead(const xercesc::DOMElement* const elconeElement)
283{
284 G4String name;
285 G4double lunit = 1.0;
286 G4double dx = 0.0;
287 G4double dy = 0.0;
288 G4double zmax = 0.0;
289 G4double zcut = 0.0;
290
291 const xercesc::DOMNamedNodeMap* const attributes
292 = elconeElement->getAttributes();
293 XMLSize_t attributeCount = attributes->getLength();
294
295 for (XMLSize_t attribute_index=0;
296 attribute_index<attributeCount; attribute_index++)
297 {
298 xercesc::DOMNode* attribute_node = attributes->item(attribute_index);
299
300 if (attribute_node->getNodeType() != xercesc::DOMNode::ATTRIBUTE_NODE)
301 { continue; }
302
303 const xercesc::DOMAttr* const attribute
304 = dynamic_cast<xercesc::DOMAttr*>(attribute_node);
305 if (!attribute)
306 {
307 G4Exception("G4GDMLReadSolids::ElconeRead()",
308 "InvalidRead", FatalException, "No attribute found!");
309 return;
310 }
311 const G4String attName = Transcode(attribute->getName());
312 const G4String attValue = Transcode(attribute->getValue());
313
314 if (attName=="name") { name = GenerateName(attValue); } else
315 if (attName=="lunit") { lunit = eval.Evaluate(attValue); } else
316 if (attName=="dx") { dx = eval.Evaluate(attValue); } else
317 if (attName=="dy") { dy = eval.Evaluate(attValue); } else
318 if (attName=="zmax") { zmax = eval.Evaluate(attValue); } else
319 if (attName=="zcut") { zcut = eval.Evaluate(attValue); }
320 }
321
322 zmax *= lunit;
323 zcut *= lunit;
324
325 new G4EllipticalCone(name,dx,dy,zmax,zcut);
326}
327
328void G4GDMLReadSolids::
329EllipsoidRead(const xercesc::DOMElement* const ellipsoidElement)
330{
331 G4String name;
332 G4double lunit = 1.0;
333 G4double ax = 0.0;
334 G4double by = 0.0;
335 G4double cz = 0.0;
336 G4double zcut1 = 0.0;
337 G4double zcut2 = 0.0;
338
339 const xercesc::DOMNamedNodeMap* const attributes
340 = ellipsoidElement->getAttributes();
341 XMLSize_t attributeCount = attributes->getLength();
342
343 for (XMLSize_t attribute_index=0;
344 attribute_index<attributeCount; attribute_index++)
345 {
346 xercesc::DOMNode* attribute_node = attributes->item(attribute_index);
347
348 if (attribute_node->getNodeType() != xercesc::DOMNode::ATTRIBUTE_NODE)
349 { continue; }
350
351 const xercesc::DOMAttr* const attribute
352 = dynamic_cast<xercesc::DOMAttr*>(attribute_node);
353 if (!attribute)
354 {
355 G4Exception("G4GDMLReadSolids::EllipsoidRead()",
356 "InvalidRead", FatalException, "No attribute found!");
357 return;
358 }
359 const G4String attName = Transcode(attribute->getName());
360 const G4String attValue = Transcode(attribute->getValue());
361
362 if (attName=="name") { name = GenerateName(attValue); } else
363 if (attName=="lunit") { lunit = eval.Evaluate(attValue); } else
364 if (attName=="ax") { ax = eval.Evaluate(attValue); } else
365 if (attName=="by") { by = eval.Evaluate(attValue); } else
366 if (attName=="cz") { cz = eval.Evaluate(attValue); } else
367 if (attName=="zcut1") { zcut1 = eval.Evaluate(attValue); } else
368 if (attName=="zcut2") { zcut2 = eval.Evaluate(attValue); }
369 }
370
371 ax *= lunit;
372 by *= lunit;
373 cz *= lunit;
374 zcut1 *= lunit;
375 zcut2 *= lunit;
376
377 new G4Ellipsoid(name,ax,by,cz,zcut1,zcut2);
378}
379
380void G4GDMLReadSolids::
381EltubeRead(const xercesc::DOMElement* const eltubeElement)
382{
383 G4String name;
384 G4double lunit = 1.0;
385 G4double dx = 0.0;
386 G4double dy = 0.0;
387 G4double dz = 0.0;
388
389 const xercesc::DOMNamedNodeMap* const attributes
390 = eltubeElement->getAttributes();
391 XMLSize_t attributeCount = attributes->getLength();
392
393 for (XMLSize_t attribute_index=0;
394 attribute_index<attributeCount; attribute_index++)
395 {
396 xercesc::DOMNode* attribute_node = attributes->item(attribute_index);
397
398 if (attribute_node->getNodeType() != xercesc::DOMNode::ATTRIBUTE_NODE)
399 { continue; }
400
401 const xercesc::DOMAttr* const attribute
402 = dynamic_cast<xercesc::DOMAttr*>(attribute_node);
403 if (!attribute)
404 {
405 G4Exception("G4GDMLReadSolids::EltubeRead()",
406 "InvalidRead", FatalException, "No attribute found!");
407 return;
408 }
409 const G4String attName = Transcode(attribute->getName());
410 const G4String attValue = Transcode(attribute->getValue());
411
412 if (attName=="name") { name = GenerateName(attValue); } else
413 if (attName=="lunit") { lunit = eval.Evaluate(attValue); } else
414 if (attName=="dx") { dx = eval.Evaluate(attValue); } else
415 if (attName=="dy") { dy = eval.Evaluate(attValue); } else
416 if (attName=="dz") { dz = eval.Evaluate(attValue); }
417 }
418
419 dx *= lunit;
420 dy *= lunit;
421 dz *= lunit;
422
423 new G4EllipticalTube(name,dx,dy,dz);
424}
425
426void G4GDMLReadSolids::XtruRead(const xercesc::DOMElement* const xtruElement)
427{
428 G4String name;
429 G4double lunit = 1.0;
430
431 const xercesc::DOMNamedNodeMap* const attributes
432 = xtruElement->getAttributes();
433 XMLSize_t attributeCount = attributes->getLength();
434
435 for (XMLSize_t attribute_index=0;
436 attribute_index<attributeCount; attribute_index++)
437 {
438 xercesc::DOMNode* attribute_node = attributes->item(attribute_index);
439
440 if (attribute_node->getNodeType() != xercesc::DOMNode::ATTRIBUTE_NODE)
441 { continue; }
442
443 const xercesc::DOMAttr* const attribute
444 = dynamic_cast<xercesc::DOMAttr*>(attribute_node);
445 if (!attribute)
446 {
447 G4Exception("G4GDMLReadSolids::XtruRead()",
448 "InvalidRead", FatalException, "No attribute found!");
449 return;
450 }
451 const G4String attName = Transcode(attribute->getName());
452 const G4String attValue = Transcode(attribute->getValue());
453
454 if (attName=="name") { name = GenerateName(attValue); } else
455 if (attName=="lunit") { lunit = eval.Evaluate(attValue); }
456 }
457
458 std::vector<G4TwoVector> twoDimVertexList;
459 std::vector<G4ExtrudedSolid::ZSection> sectionList;
460
461 for (xercesc::DOMNode* iter = xtruElement->getFirstChild();
462 iter != 0; iter = iter->getNextSibling())
463 {
464 if (iter->getNodeType() != xercesc::DOMNode::ELEMENT_NODE) { continue; }
465
466 const xercesc::DOMElement* const child
467 = dynamic_cast<xercesc::DOMElement*>(iter);
468 if (!child)
469 {
470 G4Exception("G4GDMLReadSolids::XtruRead()",
471 "InvalidRead", FatalException, "No child found!");
472 return;
473 }
474 const G4String tag = Transcode(child->getTagName());
475
476 if (tag=="twoDimVertex")
477 { twoDimVertexList.push_back(TwoDimVertexRead(child,lunit)); } else
478 if (tag=="section")
479 { sectionList.push_back(SectionRead(child,lunit)); }
480 }
481
482 new G4ExtrudedSolid(name,twoDimVertexList,sectionList);
483}
484
485void G4GDMLReadSolids::HypeRead(const xercesc::DOMElement* const hypeElement)
486{
487 G4String name;
488 G4double lunit = 1.0;
489 G4double aunit = 1.0;
490 G4double rmin = 0.0;
491 G4double rmax = 0.0;
492 G4double inst = 0.0;
493 G4double outst = 0.0;
494 G4double z = 0.0;
495
496 const xercesc::DOMNamedNodeMap* const attributes
497 = hypeElement->getAttributes();
498 XMLSize_t attributeCount = attributes->getLength();
499
500 for (XMLSize_t attribute_index=0;
501 attribute_index<attributeCount; attribute_index++)
502 {
503 xercesc::DOMNode* attribute_node = attributes->item(attribute_index);
504
505 if (attribute_node->getNodeType() != xercesc::DOMNode::ATTRIBUTE_NODE)
506 { continue; }
507
508 const xercesc::DOMAttr* const attribute
509 = dynamic_cast<xercesc::DOMAttr*>(attribute_node);
510 if (!attribute)
511 {
512 G4Exception("G4GDMLReadSolids::HypeRead()",
513 "InvalidRead", FatalException, "No attribute found!");
514 return;
515 }
516 const G4String attName = Transcode(attribute->getName());
517 const G4String attValue = Transcode(attribute->getValue());
518
519 if (attName=="name") { name = GenerateName(attValue); } else
520 if (attName=="lunit") { lunit = eval.Evaluate(attValue); } else
521 if (attName=="aunit") { aunit = eval.Evaluate(attValue); } else
522 if (attName=="rmin") { rmin = eval.Evaluate(attValue); } else
523 if (attName=="rmax") { rmax = eval.Evaluate(attValue); } else
524 if (attName=="inst") { inst = eval.Evaluate(attValue); } else
525 if (attName=="outst") { outst = eval.Evaluate(attValue); } else
526 if (attName=="z") { z = eval.Evaluate(attValue); }
527 }
528
529 rmin *= lunit;
530 rmax *= lunit;
531 inst *= aunit;
532 outst *= aunit;
533 z *= 0.5*lunit;
534
535 new G4Hype(name,rmin,rmax,inst,outst,z);
536}
537
538void G4GDMLReadSolids::OrbRead(const xercesc::DOMElement* const orbElement)
539{
540 G4String name;
541 G4double lunit = 1.0;
542 G4double r = 0.0;
543
544 const xercesc::DOMNamedNodeMap* const attributes
545 = orbElement->getAttributes();
546 XMLSize_t attributeCount = attributes->getLength();
547
548 for (XMLSize_t attribute_index=0;
549 attribute_index<attributeCount; attribute_index++)
550 {
551 xercesc::DOMNode* attribute_node = attributes->item(attribute_index);
552
553 if (attribute_node->getNodeType() != xercesc::DOMNode::ATTRIBUTE_NODE)
554 { continue; }
555
556 const xercesc::DOMAttr* const attribute
557 = dynamic_cast<xercesc::DOMAttr*>(attribute_node);
558 if (!attribute)
559 {
560 G4Exception("G4GDMLReadSolids::OrbRead()",
561 "InvalidRead", FatalException, "No attribute found!");
562 return;
563 }
564 const G4String attName = Transcode(attribute->getName());
565 const G4String attValue = Transcode(attribute->getValue());
566
567 if (attName=="name") { name = GenerateName(attValue); } else
568 if (attName=="lunit") { lunit = eval.Evaluate(attValue); } else
569 if (attName=="r") { r = eval.Evaluate(attValue); }
570 }
571
572 r *= lunit;
573
574 new G4Orb(name,r);
575}
576
577void G4GDMLReadSolids::ParaRead(const xercesc::DOMElement* const paraElement)
578{
579 G4String name;
580 G4double lunit = 1.0;
581 G4double aunit = 1.0;
582 G4double x = 0.0;
583 G4double y = 0.0;
584 G4double z = 0.0;
585 G4double alpha = 0.0;
586 G4double theta = 0.0;
587 G4double phi = 0.0;
588
589 const xercesc::DOMNamedNodeMap* const attributes
590 = paraElement->getAttributes();
591 XMLSize_t attributeCount = attributes->getLength();
592
593 for (XMLSize_t attribute_index=0;
594 attribute_index<attributeCount; attribute_index++)
595 {
596 xercesc::DOMNode* attribute_node = attributes->item(attribute_index);
597
598 if (attribute_node->getNodeType() != xercesc::DOMNode::ATTRIBUTE_NODE)
599 { continue; }
600
601 const xercesc::DOMAttr* const attribute
602 = dynamic_cast<xercesc::DOMAttr*>(attribute_node);
603 if (!attribute)
604 {
605 G4Exception("G4GDMLReadSolids::ParaRead()",
606 "InvalidRead", FatalException, "No attribute found!");
607 return;
608 }
609 const G4String attName = Transcode(attribute->getName());
610 const G4String attValue = Transcode(attribute->getValue());
611
612 if (attName=="name") { name = GenerateName(attValue); } else
613 if (attName=="lunit") { lunit = eval.Evaluate(attValue); } else
614 if (attName=="aunit") { aunit = eval.Evaluate(attValue); } else
615 if (attName=="x") { x = eval.Evaluate(attValue); } else
616 if (attName=="y") { y = eval.Evaluate(attValue); } else
617 if (attName=="z") { z = eval.Evaluate(attValue); } else
618 if (attName=="alpha") { alpha = eval.Evaluate(attValue); } else
619 if (attName=="theta") { theta = eval.Evaluate(attValue); } else
620 if (attName=="phi") { phi = eval.Evaluate(attValue); }
621 }
622
623 x *= 0.5*lunit;
624 y *= 0.5*lunit;
625 z *= 0.5*lunit;
626 alpha *= aunit;
627 theta *= aunit;
628 phi *= aunit;
629
630 new G4Para(name,x,y,z,alpha,theta,phi);
631}
632
633void G4GDMLReadSolids::
634ParaboloidRead(const xercesc::DOMElement* const paraElement)
635{
636 G4String name;
637 G4double lunit = 1.0;
638 G4double rlo = 0.0;
639 G4double rhi = 0.0;
640 G4double dz = 0.0;
641
642 const xercesc::DOMNamedNodeMap* const attributes
643 = paraElement->getAttributes();
644 XMLSize_t attributeCount = attributes->getLength();
645
646 for (XMLSize_t attribute_index=0;
647 attribute_index<attributeCount; attribute_index++)
648 {
649 xercesc::DOMNode* attribute_node = attributes->item(attribute_index);
650
651 if (attribute_node->getNodeType() != xercesc::DOMNode::ATTRIBUTE_NODE)
652 { continue; }
653
654 const xercesc::DOMAttr* const attribute
655 = dynamic_cast<xercesc::DOMAttr*>(attribute_node);
656 if (!attribute)
657 {
658 G4Exception("G4GDMLReadSolids::ParaboloidRead()",
659 "InvalidRead", FatalException, "No attribute found!");
660 return;
661 }
662 const G4String attName = Transcode(attribute->getName());
663 const G4String attValue = Transcode(attribute->getValue());
664
665 if (attName=="name") { name = GenerateName(attValue); } else
666 if (attName=="lunit") { lunit = eval.Evaluate(attValue); } else
667 if (attName=="rlo") { rlo = eval.Evaluate(attValue); } else
668 if (attName=="rhi") { rhi = eval.Evaluate(attValue); } else
669 if (attName=="dz") { dz = eval.Evaluate(attValue); }
670 }
671
672 rlo *= 1.*lunit;
673 rhi *= 1.*lunit;
674 dz *= 1.*lunit;
675
676 new G4Paraboloid(name,dz,rlo,rhi);
677}
678
679void G4GDMLReadSolids::
680PolyconeRead(const xercesc::DOMElement* const polyconeElement)
681{
682 G4String name;
683 G4double lunit = 1.0;
684 G4double aunit = 1.0;
685 G4double startphi = 0.0;
686 G4double deltaphi = 0.0;
687
688 const xercesc::DOMNamedNodeMap* const attributes
689 = polyconeElement->getAttributes();
690 XMLSize_t attributeCount = attributes->getLength();
691
692 for (XMLSize_t attribute_index=0;
693 attribute_index<attributeCount; attribute_index++)
694 {
695 xercesc::DOMNode* attribute_node = attributes->item(attribute_index);
696
697 if (attribute_node->getNodeType() != xercesc::DOMNode::ATTRIBUTE_NODE)
698 { continue; }
699
700 const xercesc::DOMAttr* const attribute
701 = dynamic_cast<xercesc::DOMAttr*>(attribute_node);
702 if (!attribute)
703 {
704 G4Exception("G4GDMLReadSolids::PolyconeRead()",
705 "InvalidRead", FatalException, "No attribute found!");
706 return;
707 }
708 const G4String attName = Transcode(attribute->getName());
709 const G4String attValue = Transcode(attribute->getValue());
710
711 if (attName=="name") { name = GenerateName(attValue); } else
712 if (attName=="lunit") { lunit = eval.Evaluate(attValue); } else
713 if (attName=="aunit") { aunit = eval.Evaluate(attValue); } else
714 if (attName=="startphi") { startphi = eval.Evaluate(attValue); }else
715 if (attName=="deltaphi") { deltaphi = eval.Evaluate(attValue); }
716 }
717
718 startphi *= aunit;
719 deltaphi *= aunit;
720
721 std::vector<zplaneType> zplaneList;
722
723 for (xercesc::DOMNode* iter = polyconeElement->getFirstChild();
724 iter != 0; iter = iter->getNextSibling())
725 {
726 if (iter->getNodeType() != xercesc::DOMNode::ELEMENT_NODE) { continue; }
727
728 const xercesc::DOMElement* const child
729 = dynamic_cast<xercesc::DOMElement*>(iter);
730 if (!child)
731 {
732 G4Exception("G4GDMLReadSolids::PolyconeRead()",
733 "InvalidRead", FatalException, "No child found!");
734 return;
735 }
736 const G4String tag = Transcode(child->getTagName());
737
738 if (tag=="zplane") { zplaneList.push_back(ZplaneRead(child)); }
739 }
740
741 G4int numZPlanes = zplaneList.size();
742
743 G4double* rmin_array = new G4double[numZPlanes];
744 G4double* rmax_array = new G4double[numZPlanes];
745 G4double* z_array = new G4double[numZPlanes];
746
747 for (G4int i=0; i<numZPlanes; i++)
748 {
749 rmin_array[i] = zplaneList[i].rmin*lunit;
750 rmax_array[i] = zplaneList[i].rmax*lunit;
751 z_array[i] = zplaneList[i].z*lunit;
752 }
753
754 new G4Polycone(name,startphi,deltaphi,numZPlanes,
755 z_array,rmin_array,rmax_array);
756}
757
758void G4GDMLReadSolids::
759PolyhedraRead(const xercesc::DOMElement* const polyhedraElement)
760{
761 G4String name;
762 G4double lunit = 1.0;
763 G4double aunit = 1.0;
764 G4double startphi = 0.0;
765 G4double deltaphi = 0.0;
766 G4int numsides = 0;
767
768 const xercesc::DOMNamedNodeMap* const attributes
769 = polyhedraElement->getAttributes();
770 XMLSize_t attributeCount = attributes->getLength();
771
772 for (XMLSize_t attribute_index=0;
773 attribute_index<attributeCount; attribute_index++)
774 {
775 xercesc::DOMNode* attribute_node = attributes->item(attribute_index);
776
777 if (attribute_node->getNodeType() != xercesc::DOMNode::ATTRIBUTE_NODE)
778 { continue; }
779
780 const xercesc::DOMAttr* const attribute
781 = dynamic_cast<xercesc::DOMAttr*>(attribute_node);
782 if (!attribute)
783 {
784 G4Exception("G4GDMLReadSolids::PolyhedraRead()",
785 "InvalidRead", FatalException, "No attribute found!");
786 return;
787 }
788 const G4String attName = Transcode(attribute->getName());
789 const G4String attValue = Transcode(attribute->getValue());
790
791 if (attName=="name") { name = GenerateName(attValue); } else
792 if (attName=="lunit") { lunit = eval.Evaluate(attValue); } else
793 if (attName=="aunit") { aunit = eval.Evaluate(attValue); } else
794 if (attName=="startphi") { startphi = eval.Evaluate(attValue); } else
795 if (attName=="deltaphi") { deltaphi = eval.Evaluate(attValue); } else
796 if (attName=="numsides") { numsides = eval.EvaluateInteger(attValue); }
797 }
798
799 startphi *= aunit;
800 deltaphi *= aunit;
801
802 std::vector<zplaneType> zplaneList;
803
804 for (xercesc::DOMNode* iter = polyhedraElement->getFirstChild();
805 iter != 0; iter = iter->getNextSibling())
806 {
807 if (iter->getNodeType() != xercesc::DOMNode::ELEMENT_NODE) { continue; }
808
809 const xercesc::DOMElement* const child
810 = dynamic_cast<xercesc::DOMElement*>(iter);
811 if (!child)
812 {
813 G4Exception("G4GDMLReadSolids::PolyhedraRead()",
814 "InvalidRead", FatalException, "No child found!");
815 return;
816 }
817 const G4String tag = Transcode(child->getTagName());
818
819 if (tag=="zplane") { zplaneList.push_back(ZplaneRead(child)); }
820 }
821
822 G4int numZPlanes = zplaneList.size();
823
824 G4double* rmin_array = new G4double[numZPlanes];
825 G4double* rmax_array = new G4double[numZPlanes];
826 G4double* z_array = new G4double[numZPlanes];
827
828 for (G4int i=0; i<numZPlanes; i++)
829 {
830 rmin_array[i] = zplaneList[i].rmin*lunit;
831 rmax_array[i] = zplaneList[i].rmax*lunit;
832 z_array[i] = zplaneList[i].z*lunit;
833 }
834
835 new G4Polyhedra(name,startphi,deltaphi,numsides,numZPlanes,
836 z_array,rmin_array,rmax_array);
837
838}
839
840G4QuadrangularFacet* G4GDMLReadSolids::
841QuadrangularRead(const xercesc::DOMElement* const quadrangularElement)
842{
843 G4ThreeVector vertex1;
844 G4ThreeVector vertex2;
845 G4ThreeVector vertex3;
846 G4ThreeVector vertex4;
847 G4FacetVertexType type = ABSOLUTE;
848 G4double lunit = 1.0;
849
850 const xercesc::DOMNamedNodeMap* const attributes
851 = quadrangularElement->getAttributes();
852 XMLSize_t attributeCount = attributes->getLength();
853
854 for (XMLSize_t attribute_index=0;
855 attribute_index<attributeCount; attribute_index++)
856 {
857 xercesc::DOMNode* attribute_node = attributes->item(attribute_index);
858
859 if (attribute_node->getNodeType() != xercesc::DOMNode::ATTRIBUTE_NODE)
860 { continue; }
861
862 const xercesc::DOMAttr* const attribute
863 = dynamic_cast<xercesc::DOMAttr*>(attribute_node);
864 if (!attribute)
865 {
866 G4Exception("G4GDMLReadSolids::QuadrangularRead()",
867 "InvalidRead", FatalException, "No attribute found!");
868 return 0;
869 }
870 const G4String attName = Transcode(attribute->getName());
871 const G4String attValue = Transcode(attribute->getValue());
872
873 if (attName=="vertex1")
874 { vertex1 = GetPosition(GenerateName(attValue)); } else
875 if (attName=="vertex2")
876 { vertex2 = GetPosition(GenerateName(attValue)); } else
877 if (attName=="vertex3")
878 { vertex3 = GetPosition(GenerateName(attValue)); } else
879 if (attName=="vertex4")
880 { vertex4 = GetPosition(GenerateName(attValue)); } else
881 if (attName=="lunit")
882 { lunit = eval.Evaluate(attValue); } else
883 if (attName=="type")
884 { if (attValue=="RELATIVE") { type = RELATIVE; } }
885 }
886
887 return new G4QuadrangularFacet(vertex1*lunit,vertex2*lunit,
888 vertex3*lunit,vertex4*lunit,type);
889}
890
891void G4GDMLReadSolids::
892ReflectedSolidRead(const xercesc::DOMElement* const reflectedSolidElement)
893{
894 G4String name;
895 G4double lunit = 1.0;
896 G4double aunit = 1.0;
897 G4String solid;
898 G4ThreeVector scale(1.0,1.0,1.0);
899 G4ThreeVector rotation;
900 G4ThreeVector position;
901
902 const xercesc::DOMNamedNodeMap* const attributes
903 = reflectedSolidElement->getAttributes();
904 XMLSize_t attributeCount = attributes->getLength();
905
906 for (XMLSize_t attribute_index=0;
907 attribute_index<attributeCount; attribute_index++)
908 {
909 xercesc::DOMNode* attribute_node = attributes->item(attribute_index);
910
911 if (attribute_node->getNodeType() != xercesc::DOMNode::ATTRIBUTE_NODE)
912 { continue; }
913
914 const xercesc::DOMAttr* const attribute
915 = dynamic_cast<xercesc::DOMAttr*>(attribute_node);
916 if (!attribute)
917 {
918 G4Exception("G4GDMLReadSolids::ReflectedSolidRead()",
919 "InvalidRead", FatalException, "No attribute found!");
920 return;
921 }
922 const G4String attName = Transcode(attribute->getName());
923 const G4String attValue = Transcode(attribute->getValue());
924
925 if (attName=="name") { name = GenerateName(attValue); } else
926 if (attName=="lunit") { lunit = eval.Evaluate(attValue); } else
927 if (attName=="aunit") { aunit = eval.Evaluate(attValue); } else
928 if (attName=="solid") { solid = GenerateName(attValue); } else
929 if (attName=="sx") { scale.setX(eval.Evaluate(attValue)); } else
930 if (attName=="sy") { scale.setY(eval.Evaluate(attValue)); } else
931 if (attName=="sz") { scale.setZ(eval.Evaluate(attValue)); } else
932 if (attName=="rx") { rotation.setX(eval.Evaluate(attValue)); } else
933 if (attName=="ry") { rotation.setY(eval.Evaluate(attValue)); } else
934 if (attName=="rz") { rotation.setZ(eval.Evaluate(attValue)); } else
935 if (attName=="dx") { position.setX(eval.Evaluate(attValue)); } else
936 if (attName=="dy") { position.setY(eval.Evaluate(attValue)); } else
937 if (attName=="dz") { position.setZ(eval.Evaluate(attValue)); }
938 }
939
940 rotation *= aunit;
941 position *= lunit;
942
943 G4Transform3D transform(GetRotationMatrix(rotation),position);
944 transform = transform*G4Scale3D(scale.x(),scale.y(),scale.z());
945
946 new G4ReflectedSolid(name,GetSolid(solid),transform);
947}
948
949G4ExtrudedSolid::ZSection G4GDMLReadSolids::
950SectionRead(const xercesc::DOMElement* const sectionElement,G4double lunit)
951{
952 G4double zPosition = 0.0;
953 G4TwoVector Offset;
954 G4double scalingFactor = 1.0;
955
956 const xercesc::DOMNamedNodeMap* const attributes
957 = sectionElement->getAttributes();
958 XMLSize_t attributeCount = attributes->getLength();
959
960 for (XMLSize_t attribute_index=0;
961 attribute_index<attributeCount; attribute_index++)
962 {
963 xercesc::DOMNode* attribute_node = attributes->item(attribute_index);
964
965 if (attribute_node->getNodeType() != xercesc::DOMNode::ATTRIBUTE_NODE)
966 { continue; }
967
968 const xercesc::DOMAttr* const attribute
969 = dynamic_cast<xercesc::DOMAttr*>(attribute_node);
970 if (!attribute)
971 {
972 G4Exception("G4GDMLReadSolids::SectionRead()",
973 "InvalidRead", FatalException, "No attribute found!");
974 return G4ExtrudedSolid::ZSection(zPosition,Offset,scalingFactor);
975 }
976 const G4String attName = Transcode(attribute->getName());
977 const G4String attValue = Transcode(attribute->getValue());
978
979 if (attName=="zPosition")
980 { zPosition = eval.Evaluate(attValue)*lunit; } else
981 if (attName=="xOffset")
982 { Offset.setX(eval.Evaluate(attValue)*lunit); } else
983 if (attName=="yOffset")
984 { Offset.setY(eval.Evaluate(attValue)*lunit); } else
985 if (attName=="scalingFactor")
986 { scalingFactor = eval.Evaluate(attValue); }
987 }
988
989 return G4ExtrudedSolid::ZSection(zPosition,Offset,scalingFactor);
990}
991
992void G4GDMLReadSolids::
993SphereRead(const xercesc::DOMElement* const sphereElement)
994{
995 G4String name;
996 G4double lunit = 1.0;
997 G4double aunit = 1.0;
998 G4double rmin = 0.0;
999 G4double rmax = 0.0;
1000 G4double startphi = 0.0;
1001 G4double deltaphi = 0.0;
1002 G4double starttheta = 0.0;
1003 G4double deltatheta = 0.0;
1004
1005 const xercesc::DOMNamedNodeMap* const attributes
1006 = sphereElement->getAttributes();
1007 XMLSize_t attributeCount = attributes->getLength();
1008
1009 for (XMLSize_t attribute_index=0;
1010 attribute_index<attributeCount; attribute_index++)
1011 {
1012 xercesc::DOMNode* attribute_node = attributes->item(attribute_index);
1013
1014 if (attribute_node->getNodeType() != xercesc::DOMNode::ATTRIBUTE_NODE)
1015 { continue; }
1016
1017 const xercesc::DOMAttr* const attribute
1018 = dynamic_cast<xercesc::DOMAttr*>(attribute_node);
1019 if (!attribute)
1020 {
1021 G4Exception("G4GDMLReadSolids::SphereRead()",
1022 "InvalidRead", FatalException, "No attribute found!");
1023 return;
1024 }
1025 const G4String attName = Transcode(attribute->getName());
1026 const G4String attValue = Transcode(attribute->getValue());
1027
1028 if (attName=="name") { name = GenerateName(attValue); } else
1029 if (attName=="lunit") { lunit = eval.Evaluate(attValue); } else
1030 if (attName=="aunit") { aunit = eval.Evaluate(attValue); } else
1031 if (attName=="rmin") { rmin = eval.Evaluate(attValue); } else
1032 if (attName=="rmax") { rmax = eval.Evaluate(attValue); } else
1033 if (attName=="startphi") { startphi = eval.Evaluate(attValue); } else
1034 if (attName=="deltaphi") { deltaphi = eval.Evaluate(attValue); } else
1035 if (attName=="starttheta") { starttheta = eval.Evaluate(attValue); } else
1036 if (attName=="deltatheta") { deltatheta = eval.Evaluate(attValue); }
1037 }
1038
1039 rmin *= lunit;
1040 rmax *= lunit;
1041 startphi *= aunit;
1042 deltaphi *= aunit;
1043 starttheta *= aunit;
1044 deltatheta *= aunit;
1045
1046 new G4Sphere(name,rmin,rmax,startphi,deltaphi,starttheta,deltatheta);
1047}
1048
1049void G4GDMLReadSolids::
1050TessellatedRead(const xercesc::DOMElement* const tessellatedElement)
1051{
1052 G4String name;
1053
1054 const xercesc::DOMNamedNodeMap* const attributes
1055 = tessellatedElement->getAttributes();
1056 XMLSize_t attributeCount = attributes->getLength();
1057
1058 for (XMLSize_t attribute_index=0;
1059 attribute_index<attributeCount; attribute_index++)
1060 {
1061 xercesc::DOMNode* attribute_node = attributes->item(attribute_index);
1062
1063 if (attribute_node->getNodeType() != xercesc::DOMNode::ATTRIBUTE_NODE)
1064 { continue; }
1065
1066 const xercesc::DOMAttr* const attribute
1067 = dynamic_cast<xercesc::DOMAttr*>(attribute_node);
1068 if (!attribute)
1069 {
1070 G4Exception("G4GDMLReadSolids::TessellatedRead()",
1071 "InvalidRead", FatalException, "No attribute found!");
1072 return;
1073 }
1074 const G4String attName = Transcode(attribute->getName());
1075 const G4String attValue = Transcode(attribute->getValue());
1076
1077 if (attName=="name") { name = GenerateName(attValue); }
1078 }
1079
1080 G4TessellatedSolid *tessellated = new G4TessellatedSolid(name);
1081
1082 for (xercesc::DOMNode* iter = tessellatedElement->getFirstChild();
1083 iter != 0; iter = iter->getNextSibling())
1084 {
1085 if (iter->getNodeType() != xercesc::DOMNode::ELEMENT_NODE) { continue; }
1086
1087 const xercesc::DOMElement* const child
1088 = dynamic_cast<xercesc::DOMElement*>(iter);
1089 if (!child)
1090 {
1091 G4Exception("G4GDMLReadSolids::TessellatedRead()",
1092 "InvalidRead", FatalException, "No child found!");
1093 return;
1094 }
1095 const G4String tag = Transcode(child->getTagName());
1096
1097 if (tag=="triangular")
1098 { tessellated->AddFacet(TriangularRead(child)); } else
1099 if (tag=="quadrangular")
1100 { tessellated->AddFacet(QuadrangularRead(child)); }
1101 }
1102
1103 tessellated->SetSolidClosed(true);
1104}
1105
1106void G4GDMLReadSolids::TetRead(const xercesc::DOMElement* const tetElement)
1107{
1108 G4String name;
1109 G4ThreeVector vertex1;
1110 G4ThreeVector vertex2;
1111 G4ThreeVector vertex3;
1112 G4ThreeVector vertex4;
1113 G4double lunit = 1.0;
1114
1115 const xercesc::DOMNamedNodeMap* const attributes
1116 = tetElement->getAttributes();
1117 XMLSize_t attributeCount = attributes->getLength();
1118
1119 for (XMLSize_t attribute_index=0;
1120 attribute_index<attributeCount;attribute_index++)
1121 {
1122 xercesc::DOMNode* attribute_node = attributes->item(attribute_index);
1123
1124 if (attribute_node->getNodeType() != xercesc::DOMNode::ATTRIBUTE_NODE)
1125 { continue; }
1126
1127 const xercesc::DOMAttr* const attribute
1128 = dynamic_cast<xercesc::DOMAttr*>(attribute_node);
1129 if (!attribute)
1130 {
1131 G4Exception("G4GDMLReadSolids::TetRead()",
1132 "InvalidRead", FatalException, "No attribute found!");
1133 return;
1134 }
1135 const G4String attName = Transcode(attribute->getName());
1136 const G4String attValue = Transcode(attribute->getValue());
1137
1138 if (attName=="name")
1139 { name = GenerateName(attValue); } else
1140 if (attName=="lunit")
1141 { lunit = eval.Evaluate(attValue); } else
1142 if (attName=="vertex1")
1143 { vertex1 = GetPosition(GenerateName(attValue)); } else
1144 if (attName=="vertex2")
1145 { vertex2 = GetPosition(GenerateName(attValue)); } else
1146 if (attName=="vertex3")
1147 { vertex3 = GetPosition(GenerateName(attValue)); } else
1148 if (attName=="vertex4")
1149 { vertex4 = GetPosition(GenerateName(attValue)); }
1150 }
1151
1152 new G4Tet(name,vertex1*lunit,vertex2*lunit,vertex3*lunit,vertex4*lunit);
1153}
1154
1155void G4GDMLReadSolids::TorusRead(const xercesc::DOMElement* const torusElement)
1156{
1157 G4String name;
1158 G4double lunit = 1.0;
1159 G4double aunit = 1.0;
1160 G4double rmin = 0.0;
1161 G4double rmax = 0.0;
1162 G4double rtor = 0.0;
1163 G4double startphi = 0.0;
1164 G4double deltaphi = 0.0;
1165
1166 const xercesc::DOMNamedNodeMap* const attributes
1167 = torusElement->getAttributes();
1168 XMLSize_t attributeCount = attributes->getLength();
1169
1170 for (XMLSize_t attribute_index=0;
1171 attribute_index<attributeCount; attribute_index++)
1172 {
1173 xercesc::DOMNode* attribute_node = attributes->item(attribute_index);
1174
1175 if (attribute_node->getNodeType() != xercesc::DOMNode::ATTRIBUTE_NODE)
1176 { continue; }
1177
1178 const xercesc::DOMAttr* const attribute
1179 = dynamic_cast<xercesc::DOMAttr*>(attribute_node);
1180 if (!attribute)
1181 {
1182 G4Exception("G4GDMLReadSolids::TorusRead()",
1183 "InvalidRead", FatalException, "No attribute found!");
1184 return;
1185 }
1186 const G4String attName = Transcode(attribute->getName());
1187 const G4String attValue = Transcode(attribute->getValue());
1188
1189 if (attName=="name") { name = GenerateName(attValue); } else
1190 if (attName=="lunit") { lunit = eval.Evaluate(attValue); } else
1191 if (attName=="aunit") { aunit = eval.Evaluate(attValue); } else
1192 if (attName=="rmin") { rmin = eval.Evaluate(attValue); } else
1193 if (attName=="rmax") { rmax = eval.Evaluate(attValue); } else
1194 if (attName=="rtor") { rtor = eval.Evaluate(attValue); } else
1195 if (attName=="startphi") { startphi = eval.Evaluate(attValue); } else
1196 if (attName=="deltaphi") { deltaphi = eval.Evaluate(attValue); }
1197 }
1198
1199 rmin *= lunit;
1200 rmax *= lunit;
1201 rtor *= lunit;
1202 startphi *= aunit;
1203 deltaphi *= aunit;
1204
1205 new G4Torus(name,rmin,rmax,rtor,startphi,deltaphi);
1206}
1207
1208void G4GDMLReadSolids::
1209GenTrapRead(const xercesc::DOMElement* const gtrapElement)
1210{
1211 G4String name;
1212 G4double lunit = 1.0;
1213 G4double dz =0.0;
1214 G4double v1x=0.0, v1y=0.0, v2x=0.0, v2y=0.0, v3x=0.0, v3y=0.0,
1215 v4x=0.0, v4y=0.0, v5x=0.0, v5y=0.0, v6x=0.0, v6y=0.0,
1216 v7x=0.0, v7y=0.0, v8x=0.0, v8y=0.0;
1217
1218 const xercesc::DOMNamedNodeMap* const attributes
1219 = gtrapElement->getAttributes();
1220 XMLSize_t attributeCount = attributes->getLength();
1221
1222 for (XMLSize_t attribute_index=0;
1223 attribute_index<attributeCount; attribute_index++)
1224 {
1225 xercesc::DOMNode* attribute_node = attributes->item(attribute_index);
1226
1227 if (attribute_node->getNodeType() != xercesc::DOMNode::ATTRIBUTE_NODE)
1228 { continue; }
1229
1230 const xercesc::DOMAttr* const attribute
1231 = dynamic_cast<xercesc::DOMAttr*>(attribute_node);
1232 if (!attribute)
1233 {
1234 G4Exception("G4GDMLReadSolids::GenTrapRead()",
1235 "InvalidRead", FatalException, "No attribute found!");
1236 return;
1237 }
1238 const G4String attName = Transcode(attribute->getName());
1239 const G4String attValue = Transcode(attribute->getValue());
1240
1241 if (attName=="name") { name = GenerateName(attValue); } else
1242 if (attName=="lunit") { lunit = eval.Evaluate(attValue); } else
1243 if (attName=="dz") { dz = eval.Evaluate(attValue); } else
1244 if (attName=="v1x") { v1x = eval.Evaluate(attValue); } else
1245 if (attName=="v1y") { v1y = eval.Evaluate(attValue); } else
1246 if (attName=="v2x") { v2x = eval.Evaluate(attValue); } else
1247 if (attName=="v2y") { v2y = eval.Evaluate(attValue); } else
1248 if (attName=="v3x") { v3x = eval.Evaluate(attValue); } else
1249 if (attName=="v3y") { v3y = eval.Evaluate(attValue); } else
1250 if (attName=="v4x") { v4x = eval.Evaluate(attValue); } else
1251 if (attName=="v4y") { v4y = eval.Evaluate(attValue); } else
1252 if (attName=="v5x") { v5x = eval.Evaluate(attValue); } else
1253 if (attName=="v5y") { v5y = eval.Evaluate(attValue); } else
1254 if (attName=="v6x") { v6x = eval.Evaluate(attValue); } else
1255 if (attName=="v6y") { v6y = eval.Evaluate(attValue); } else
1256 if (attName=="v7x") { v7x = eval.Evaluate(attValue); } else
1257 if (attName=="v7y") { v7y = eval.Evaluate(attValue); } else
1258 if (attName=="v8x") { v8x = eval.Evaluate(attValue); } else
1259 if (attName=="v8y") { v8y = eval.Evaluate(attValue); }
1260 }
1261
1262 dz *= lunit;
1263 std::vector<G4TwoVector> vertices;
1264 vertices.push_back(G4TwoVector(v1x*lunit,v1y*lunit));
1265 vertices.push_back(G4TwoVector(v2x*lunit,v2y*lunit));
1266 vertices.push_back(G4TwoVector(v3x*lunit,v3y*lunit));
1267 vertices.push_back(G4TwoVector(v4x*lunit,v4y*lunit));
1268 vertices.push_back(G4TwoVector(v5x*lunit,v5y*lunit));
1269 vertices.push_back(G4TwoVector(v6x*lunit,v6y*lunit));
1270 vertices.push_back(G4TwoVector(v7x*lunit,v7y*lunit));
1271 vertices.push_back(G4TwoVector(v8x*lunit,v8y*lunit));
1272 new G4GenericTrap(name,dz,vertices);
1273}
1274
1275void G4GDMLReadSolids::TrapRead(const xercesc::DOMElement* const trapElement)
1276{
1277 G4String name;
1278 G4double lunit = 1.0;
1279 G4double aunit = 1.0;
1280 G4double z = 0.0;
1281 G4double theta = 0.0;
1282 G4double phi = 0.0;
1283 G4double y1 = 0.0;
1284 G4double x1 = 0.0;
1285 G4double x2 = 0.0;
1286 G4double alpha1 = 0.0;
1287 G4double y2 = 0.0;
1288 G4double x3 = 0.0;
1289 G4double x4 = 0.0;
1290 G4double alpha2 = 0.0;
1291
1292 const xercesc::DOMNamedNodeMap* const attributes
1293 = trapElement->getAttributes();
1294 XMLSize_t attributeCount = attributes->getLength();
1295
1296 for (XMLSize_t attribute_index=0;
1297 attribute_index<attributeCount; attribute_index++)
1298 {
1299 xercesc::DOMNode* attribute_node = attributes->item(attribute_index);
1300
1301 if (attribute_node->getNodeType() != xercesc::DOMNode::ATTRIBUTE_NODE)
1302 { continue; }
1303
1304 const xercesc::DOMAttr* const attribute
1305 = dynamic_cast<xercesc::DOMAttr*>(attribute_node);
1306 if (!attribute)
1307 {
1308 G4Exception("G4GDMLReadSolids::TrapRead()",
1309 "InvalidRead", FatalException, "No attribute found!");
1310 return;
1311 }
1312 const G4String attName = Transcode(attribute->getName());
1313 const G4String attValue = Transcode(attribute->getValue());
1314
1315 if (attName=="name") { name = GenerateName(attValue); } else
1316 if (attName=="lunit") { lunit = eval.Evaluate(attValue); } else
1317 if (attName=="aunit") { aunit = eval.Evaluate(attValue); } else
1318 if (attName=="z") { z = eval.Evaluate(attValue); } else
1319 if (attName=="theta") { theta = eval.Evaluate(attValue); } else
1320 if (attName=="phi") { phi = eval.Evaluate(attValue); } else
1321 if (attName=="y1") { y1 = eval.Evaluate(attValue); } else
1322 if (attName=="x1") { x1 = eval.Evaluate(attValue); } else
1323 if (attName=="x2") { x2 = eval.Evaluate(attValue); } else
1324 if (attName=="alpha1") { alpha1 = eval.Evaluate(attValue); } else
1325 if (attName=="y2") { y2 = eval.Evaluate(attValue); } else
1326 if (attName=="x3") { x3 = eval.Evaluate(attValue); } else
1327 if (attName=="x4") { x4 = eval.Evaluate(attValue); } else
1328 if (attName=="alpha2") { alpha2 = eval.Evaluate(attValue); }
1329 }
1330
1331 z *= 0.5*lunit;
1332 theta *= aunit;
1333 phi *= aunit;
1334 y1 *= 0.5*lunit;
1335 x1 *= 0.5*lunit;
1336 x2 *= 0.5*lunit;
1337 alpha1 *= aunit;
1338 y2 *= 0.5*lunit;
1339 x3 *= 0.5*lunit;
1340 x4 *= 0.5*lunit;
1341 alpha2 *= aunit;
1342
1343 new G4Trap(name,z,theta,phi,y1,x1,x2,alpha1,y2,x3,x4,alpha2);
1344}
1345
1346void G4GDMLReadSolids::TrdRead(const xercesc::DOMElement* const trdElement)
1347{
1348 G4String name;
1349 G4double lunit = 1.0;
1350 G4double x1 = 0.0;
1351 G4double x2 = 0.0;
1352 G4double y1 = 0.0;
1353 G4double y2 = 0.0;
1354 G4double z = 0.0;
1355
1356 const xercesc::DOMNamedNodeMap* const attributes = trdElement->getAttributes();
1357 XMLSize_t attributeCount = attributes->getLength();
1358
1359 for (XMLSize_t attribute_index=0;
1360 attribute_index<attributeCount; attribute_index++)
1361 {
1362 xercesc::DOMNode* attribute_node = attributes->item(attribute_index);
1363
1364 if (attribute_node->getNodeType() != xercesc::DOMNode::ATTRIBUTE_NODE)
1365 { continue; }
1366
1367 const xercesc::DOMAttr* const attribute
1368 = dynamic_cast<xercesc::DOMAttr*>(attribute_node);
1369 if (!attribute)
1370 {
1371 G4Exception("G4GDMLReadSolids::TrdRead()",
1372 "InvalidRead", FatalException, "No attribute found!");
1373 return;
1374 }
1375 const G4String attName = Transcode(attribute->getName());
1376 const G4String attValue = Transcode(attribute->getValue());
1377
1378 if (attName=="name") { name = GenerateName(attValue); } else
1379 if (attName=="lunit") { lunit = eval.Evaluate(attValue); } else
1380 if (attName=="x1") { x1 = eval.Evaluate(attValue); } else
1381 if (attName=="x2") { x2 = eval.Evaluate(attValue); } else
1382 if (attName=="y1") { y1 = eval.Evaluate(attValue); } else
1383 if (attName=="y2") { y2 = eval.Evaluate(attValue); } else
1384 if (attName=="z") { z = eval.Evaluate(attValue); }
1385 }
1386
1387 x1 *= 0.5*lunit;
1388 x2 *= 0.5*lunit;
1389 y1 *= 0.5*lunit;
1390 y2 *= 0.5*lunit;
1391 z *= 0.5*lunit;
1392
1393 new G4Trd(name,x1,x2,y1,y2,z);
1394}
1395
1396G4TriangularFacet* G4GDMLReadSolids::
1397TriangularRead(const xercesc::DOMElement* const triangularElement)
1398{
1399 G4ThreeVector vertex1;
1400 G4ThreeVector vertex2;
1401 G4ThreeVector vertex3;
1402 G4FacetVertexType type = ABSOLUTE;
1403 G4double lunit = 1.0;
1404
1405 const xercesc::DOMNamedNodeMap* const attributes
1406 = triangularElement->getAttributes();
1407 XMLSize_t attributeCount = attributes->getLength();
1408
1409 for (XMLSize_t attribute_index=0;
1410 attribute_index<attributeCount; attribute_index++)
1411 {
1412 xercesc::DOMNode* attribute_node = attributes->item(attribute_index);
1413
1414 if (attribute_node->getNodeType() != xercesc::DOMNode::ATTRIBUTE_NODE)
1415 { continue; }
1416
1417 const xercesc::DOMAttr* const attribute
1418 = dynamic_cast<xercesc::DOMAttr*>(attribute_node);
1419 if (!attribute)
1420 {
1421 G4Exception("G4GDMLReadSolids::TriangularRead()",
1422 "InvalidRead", FatalException, "No attribute found!");
1423 return 0;
1424 }
1425 const G4String attName = Transcode(attribute->getName());
1426 const G4String attValue = Transcode(attribute->getValue());
1427
1428 if (attName=="vertex1")
1429 { vertex1 = GetPosition(GenerateName(attValue)); } else
1430 if (attName=="vertex2")
1431 { vertex2 = GetPosition(GenerateName(attValue)); } else
1432 if (attName=="vertex3")
1433 { vertex3 = GetPosition(GenerateName(attValue)); } else
1434 if (attName=="lunit")
1435 { lunit = eval.Evaluate(attValue); } else
1436 if (attName=="type")
1437 { if (attValue=="RELATIVE") { type = RELATIVE; } }
1438 }
1439
1440 return new G4TriangularFacet(vertex1*lunit,vertex2*lunit,vertex3*lunit,type);
1441}
1442
1443void G4GDMLReadSolids::TubeRead(const xercesc::DOMElement* const tubeElement)
1444{
1445 G4String name;
1446 G4double lunit = 1.0;
1447 G4double aunit = 1.0;
1448 G4double rmin = 0.0;
1449 G4double rmax = 0.0;
1450 G4double z = 0.0;
1451 G4double startphi = 0.0;
1452 G4double deltaphi = 0.0;
1453
1454 const xercesc::DOMNamedNodeMap* const attributes
1455 = tubeElement->getAttributes();
1456 XMLSize_t attributeCount = attributes->getLength();
1457
1458 for (XMLSize_t attribute_index=0;
1459 attribute_index<attributeCount; attribute_index++)
1460 {
1461 xercesc::DOMNode* attribute_node = attributes->item(attribute_index);
1462
1463 if (attribute_node->getNodeType() != xercesc::DOMNode::ATTRIBUTE_NODE)
1464 { continue; }
1465
1466 const xercesc::DOMAttr* const attribute
1467 = dynamic_cast<xercesc::DOMAttr*>(attribute_node);
1468 if (!attribute)
1469 {
1470 G4Exception("G4GDMLReadSolids::TubeRead()",
1471 "InvalidRead", FatalException, "No attribute found!");
1472 return;
1473 }
1474 const G4String attName = Transcode(attribute->getName());
1475 const G4String attValue = Transcode(attribute->getValue());
1476
1477 if (attName=="name") { name = GenerateName(attValue); } else
1478 if (attName=="lunit") { lunit = eval.Evaluate(attValue); } else
1479 if (attName=="aunit") { aunit = eval.Evaluate(attValue); } else
1480 if (attName=="rmin") { rmin = eval.Evaluate(attValue); } else
1481 if (attName=="rmax") { rmax = eval.Evaluate(attValue); } else
1482 if (attName=="z") { z = eval.Evaluate(attValue); } else
1483 if (attName=="startphi") { startphi = eval.Evaluate(attValue); } else
1484 if (attName=="deltaphi") { deltaphi = eval.Evaluate(attValue); }
1485 }
1486
1487 rmin *= lunit;
1488 rmax *= lunit;
1489 z *= 0.5*lunit;
1490 startphi *= aunit;
1491 deltaphi *= aunit;
1492
1493 new G4Tubs(name,rmin,rmax,z,startphi,deltaphi);
1494}
1495
1496void G4GDMLReadSolids::CutTubeRead(const xercesc::DOMElement* const cuttubeElement)
1497{
1498 G4String name;
1499 G4double lunit = 1.0;
1500 G4double aunit = 1.0;
1501 G4double rmin = 0.0;
1502 G4double rmax = 0.0;
1503 G4double z = 0.0;
1504 G4double startphi = 0.0;
1505 G4double deltaphi = 0.0;
1506 G4ThreeVector lowNorm(0);
1507 G4ThreeVector highNorm(0);
1508
1509 const xercesc::DOMNamedNodeMap* const attributes
1510 = cuttubeElement->getAttributes();
1511 XMLSize_t attributeCount = attributes->getLength();
1512
1513 for (XMLSize_t attribute_index=0;
1514 attribute_index<attributeCount; attribute_index++)
1515 {
1516 xercesc::DOMNode* attribute_node = attributes->item(attribute_index);
1517
1518 if (attribute_node->getNodeType() != xercesc::DOMNode::ATTRIBUTE_NODE)
1519 { continue; }
1520
1521 const xercesc::DOMAttr* const attribute
1522 = dynamic_cast<xercesc::DOMAttr*>(attribute_node);
1523 if (!attribute)
1524 {
1525 G4Exception("G4GDMLReadSolids::CutTubeRead()",
1526 "InvalidRead", FatalException, "No attribute found!");
1527 return;
1528 }
1529 const G4String attName = Transcode(attribute->getName());
1530 const G4String attValue = Transcode(attribute->getValue());
1531
1532 if (attName=="name") { name = GenerateName(attValue); } else
1533 if (attName=="lunit") { lunit = eval.Evaluate(attValue); } else
1534 if (attName=="aunit") { aunit = eval.Evaluate(attValue); } else
1535 if (attName=="rmin") { rmin = eval.Evaluate(attValue); } else
1536 if (attName=="rmax") { rmax = eval.Evaluate(attValue); } else
1537 if (attName=="z") { z = eval.Evaluate(attValue); } else
1538 if (attName=="startphi") { startphi = eval.Evaluate(attValue); } else
1539 if (attName=="deltaphi") { deltaphi = eval.Evaluate(attValue); } else
1540 if (attName=="lowX") { lowNorm.setX (eval.Evaluate(attValue)); } else
1541 if (attName=="lowY") { lowNorm.setY (eval.Evaluate(attValue)); } else
1542 if (attName=="lowZ") { lowNorm.setZ (eval.Evaluate(attValue)); } else
1543 if (attName=="highX") { highNorm.setX (eval.Evaluate(attValue)); } else
1544 if (attName=="highY") { highNorm.setY (eval.Evaluate(attValue)); } else
1545 if (attName=="highZ") { highNorm.setZ (eval.Evaluate(attValue)); }
1546
1547 }
1548
1549 rmin *= lunit;
1550 rmax *= lunit;
1551 z *= 0.5*lunit;
1552 startphi *= aunit;
1553 deltaphi *= aunit;
1554
1555 new G4CutTubs(name,rmin,rmax,z,startphi,deltaphi,lowNorm,highNorm);
1556}
1557
1558void G4GDMLReadSolids::
1559TwistedboxRead(const xercesc::DOMElement* const twistedboxElement)
1560{
1561 G4String name;
1562 G4double lunit = 1.0;
1563 G4double aunit = 1.0;
1564 G4double PhiTwist = 0.0;
1565 G4double x = 0.0;
1566 G4double y = 0.0;
1567 G4double z = 0.0;
1568
1569 const xercesc::DOMNamedNodeMap* const attributes
1570 = twistedboxElement->getAttributes();
1571 XMLSize_t attributeCount = attributes->getLength();
1572
1573 for (XMLSize_t attribute_index=0;
1574 attribute_index<attributeCount; attribute_index++)
1575 {
1576 xercesc::DOMNode* attribute_node = attributes->item(attribute_index);
1577
1578 if (attribute_node->getNodeType() != xercesc::DOMNode::ATTRIBUTE_NODE)
1579 { continue; }
1580
1581 const xercesc::DOMAttr* const attribute
1582 = dynamic_cast<xercesc::DOMAttr*>(attribute_node);
1583 if (!attribute)
1584 {
1585 G4Exception("G4GDMLReadSolids::TwistedboxRead()",
1586 "InvalidRead", FatalException, "No attribute found!");
1587 return;
1588 }
1589 const G4String attName = Transcode(attribute->getName());
1590 const G4String attValue = Transcode(attribute->getValue());
1591
1592 if (attName=="name") { name = GenerateName(attValue); } else
1593 if (attName=="lunit") { lunit = eval.Evaluate(attValue); } else
1594 if (attName=="aunit") { aunit = eval.Evaluate(attValue); } else
1595 if (attName=="PhiTwist") { PhiTwist = eval.Evaluate(attValue); } else
1596 if (attName=="x") { x = eval.Evaluate(attValue); } else
1597 if (attName=="y") { y = eval.Evaluate(attValue); } else
1598 if (attName=="z") { z = eval.Evaluate(attValue); }
1599 }
1600
1601 PhiTwist *= aunit;
1602 x *= 0.5*lunit;
1603 y *= 0.5*lunit;
1604 z *= 0.5*lunit;
1605
1606 new G4TwistedBox(name,PhiTwist,x,y,z);
1607}
1608
1609void G4GDMLReadSolids::
1610TwistedtrapRead(const xercesc::DOMElement* const twistedtrapElement)
1611{
1612 G4String name;
1613 G4double lunit = 1.0;
1614 G4double aunit = 1.0;
1615 G4double PhiTwist = 0.0;
1616 G4double z = 0.0;
1617 G4double Theta = 0.0;
1618 G4double Phi = 0.0;
1619 G4double y1 = 0.0;
1620 G4double x1 = 0.0;
1621 G4double x2 = 0.0;
1622 G4double y2 = 0.0;
1623 G4double x3 = 0.0;
1624 G4double x4 = 0.0;
1625 G4double Alph = 0.0;
1626
1627 const xercesc::DOMNamedNodeMap* const attributes
1628 = twistedtrapElement->getAttributes();
1629 XMLSize_t attributeCount = attributes->getLength();
1630
1631 for (XMLSize_t attribute_index=0;
1632 attribute_index<attributeCount; attribute_index++)
1633 {
1634 xercesc::DOMNode* attribute_node = attributes->item(attribute_index);
1635
1636 if (attribute_node->getNodeType() != xercesc::DOMNode::ATTRIBUTE_NODE)
1637 { continue; }
1638
1639 const xercesc::DOMAttr* const attribute
1640 = dynamic_cast<xercesc::DOMAttr*>(attribute_node);
1641 if (!attribute)
1642 {
1643 G4Exception("G4GDMLReadSolids::TwistedtrapRead()",
1644 "InvalidRead", FatalException, "No attribute found!");
1645 return;
1646 }
1647 const G4String attName = Transcode(attribute->getName());
1648 const G4String attValue = Transcode(attribute->getValue());
1649
1650 if (attName=="name") { name = GenerateName(attValue); } else
1651 if (attName=="lunit") { lunit = eval.Evaluate(attValue); } else
1652 if (attName=="aunit") { aunit = eval.Evaluate(attValue); } else
1653 if (attName=="PhiTwist") { PhiTwist = eval.Evaluate(attValue); } else
1654 if (attName=="z") { z = eval.Evaluate(attValue); } else
1655 if (attName=="Theta") { Theta = eval.Evaluate(attValue); } else
1656 if (attName=="Phi") { Phi = eval.Evaluate(attValue); } else
1657 if (attName=="y1") { y1 = eval.Evaluate(attValue); } else
1658 if (attName=="x1") { x1 = eval.Evaluate(attValue); } else
1659 if (attName=="x2") { x2 = eval.Evaluate(attValue); } else
1660 if (attName=="y2") { y2 = eval.Evaluate(attValue); } else
1661 if (attName=="x3") { x3 = eval.Evaluate(attValue); } else
1662 if (attName=="x4") { x4 = eval.Evaluate(attValue); } else
1663 if (attName=="Alph") { Alph = eval.Evaluate(attValue); }
1664 }
1665
1666
1667 PhiTwist *= aunit;
1668 z *= 0.5*lunit;
1669 Theta *= aunit;
1670 Phi *= aunit;
1671 Alph *= aunit;
1672 y1 *= 0.5*lunit;
1673 x1 *= 0.5*lunit;
1674 x2 *= 0.5*lunit;
1675 y2 *= 0.5*lunit;
1676 x3 *= 0.5*lunit;
1677 x4 *= 0.5*lunit;
1678
1679 new G4TwistedTrap(name,PhiTwist,z,Theta,Phi,y1,x1,x2,y2,x3,x4,Alph);
1680}
1681
1682void G4GDMLReadSolids::
1683TwistedtrdRead(const xercesc::DOMElement* const twistedtrdElement)
1684{
1685 G4String name;
1686 G4double lunit = 1.0;
1687 G4double aunit = 1.0;
1688 G4double x1 = 0.0;
1689 G4double x2 = 0.0;
1690 G4double y1 = 0.0;
1691 G4double y2 = 0.0;
1692 G4double z = 0.0;
1693 G4double PhiTwist = 0.0;
1694
1695 const xercesc::DOMNamedNodeMap* const attributes
1696 = twistedtrdElement->getAttributes();
1697 XMLSize_t attributeCount = attributes->getLength();
1698
1699 for (XMLSize_t attribute_index=0;
1700 attribute_index<attributeCount; attribute_index++)
1701 {
1702 xercesc::DOMNode* attribute_node = attributes->item(attribute_index);
1703
1704 if (attribute_node->getNodeType() != xercesc::DOMNode::ATTRIBUTE_NODE)
1705 { continue; }
1706
1707 const xercesc::DOMAttr* const attribute
1708 = dynamic_cast<xercesc::DOMAttr*>(attribute_node);
1709 if (!attribute)
1710 {
1711 G4Exception("G4GDMLReadSolids::TwistedtrdRead()",
1712 "InvalidRead", FatalException, "No attribute found!");
1713 return;
1714 }
1715 const G4String attName = Transcode(attribute->getName());
1716 const G4String attValue = Transcode(attribute->getValue());
1717
1718 if (attName=="name") { name = GenerateName(attValue); } else
1719 if (attName=="lunit") { lunit = eval.Evaluate(attValue); } else
1720 if (attName=="aunit") { aunit = eval.Evaluate(attValue); } else
1721 if (attName=="x1") { x1 = eval.Evaluate(attValue); } else
1722 if (attName=="x2") { x2 = eval.Evaluate(attValue); } else
1723 if (attName=="y1") { y1 = eval.Evaluate(attValue); } else
1724 if (attName=="y2") { y2 = eval.Evaluate(attValue); } else
1725 if (attName=="z") { z = eval.Evaluate(attValue); } else
1726 if (attName=="PhiTwist") { PhiTwist = eval.Evaluate(attValue); }
1727 }
1728
1729 x1 *= 0.5*lunit;
1730 x2 *= 0.5*lunit;
1731 y1 *= 0.5*lunit;
1732 y2 *= 0.5*lunit;
1733 z *= 0.5*lunit;
1734 PhiTwist *= aunit;
1735
1736 new G4TwistedTrd(name,x1,x2,y1,y2,z,PhiTwist);
1737}
1738
1739void G4GDMLReadSolids::
1740TwistedtubsRead(const xercesc::DOMElement* const twistedtubsElement)
1741{
1742 G4String name;
1743 G4double lunit = 1.0;
1744 G4double aunit = 1.0;
1745 G4double twistedangle = 0.0;
1746 G4double endinnerrad = 0.0;
1747 G4double endouterrad = 0.0;
1748 G4double zlen = 0.0;
1749 G4double phi = 0.0;
1750
1751 const xercesc::DOMNamedNodeMap* const attributes
1752 = twistedtubsElement->getAttributes();
1753 XMLSize_t attributeCount = attributes->getLength();
1754
1755 for (XMLSize_t attribute_index=0;
1756 attribute_index<attributeCount; attribute_index++)
1757 {
1758 xercesc::DOMNode* attribute_node = attributes->item(attribute_index);
1759
1760 if (attribute_node->getNodeType() != xercesc::DOMNode::ATTRIBUTE_NODE)
1761 { continue; }
1762
1763 const xercesc::DOMAttr* const attribute
1764 = dynamic_cast<xercesc::DOMAttr*>(attribute_node);
1765 if (!attribute)
1766 {
1767 G4Exception("G4GDMLReadSolids::TwistedtubsRead()",
1768 "InvalidRead", FatalException, "No attribute found!");
1769 return;
1770 }
1771 const G4String attName = Transcode(attribute->getName());
1772 const G4String attValue = Transcode(attribute->getValue());
1773
1774 if (attName=="name") { name = GenerateName(attValue); } else
1775 if (attName=="lunit") { lunit = eval.Evaluate(attValue); } else
1776 if (attName=="aunit") { aunit = eval.Evaluate(attValue); } else
1777 if (attName=="twistedangle") { twistedangle=eval.Evaluate(attValue); } else
1778 if (attName=="endinnerrad") { endinnerrad=eval.Evaluate(attValue); } else
1779 if (attName=="endouterrad") { endouterrad=eval.Evaluate(attValue); } else
1780 if (attName=="zlen") { zlen = eval.Evaluate(attValue); } else
1781 if (attName=="phi") { phi = eval.Evaluate(attValue); }
1782 }
1783
1784 twistedangle *= aunit;
1785 endinnerrad *= lunit;
1786 endouterrad *= lunit;
1787 zlen *= 0.5*lunit;
1788 phi *= aunit;
1789
1790 new G4TwistedTubs(name,twistedangle,endinnerrad,endouterrad,zlen,phi);
1791}
1792
1793G4TwoVector G4GDMLReadSolids::
1794TwoDimVertexRead(const xercesc::DOMElement* const element, G4double lunit)
1795{
1796 G4TwoVector vec;
1797
1798 const xercesc::DOMNamedNodeMap* const attributes = element->getAttributes();
1799 XMLSize_t attributeCount = attributes->getLength();
1800
1801 for (XMLSize_t attribute_index=0;
1802 attribute_index<attributeCount; attribute_index++)
1803 {
1804 xercesc::DOMNode* attribute_node = attributes->item(attribute_index);
1805
1806 if (attribute_node->getNodeType() != xercesc::DOMNode::ATTRIBUTE_NODE)
1807 { continue; }
1808
1809 const xercesc::DOMAttr* const attribute
1810 = dynamic_cast<xercesc::DOMAttr*>(attribute_node);
1811 if (!attribute)
1812 {
1813 G4Exception("G4GDMLReadSolids::TwoDimVertexRead()",
1814 "InvalidRead", FatalException, "No attribute found!");
1815 return vec;
1816 }
1817 const G4String attName = Transcode(attribute->getName());
1818 const G4String attValue = Transcode(attribute->getValue());
1819
1820 if (attName=="x") { vec.setX(eval.Evaluate(attValue)*lunit); } else
1821 if (attName=="y") { vec.setY(eval.Evaluate(attValue)*lunit); }
1822 }
1823
1824 return vec;
1825}
1826
1827G4GDMLReadSolids::zplaneType G4GDMLReadSolids::
1828ZplaneRead(const xercesc::DOMElement* const zplaneElement)
1829{
1830 zplaneType zplane = {0.,0.,0.};
1831
1832 const xercesc::DOMNamedNodeMap* const attributes
1833 = zplaneElement->getAttributes();
1834 XMLSize_t attributeCount = attributes->getLength();
1835
1836 for (XMLSize_t attribute_index=0;
1837 attribute_index<attributeCount; attribute_index++)
1838 {
1839 xercesc::DOMNode* node = attributes->item(attribute_index);
1840
1841 if (node->getNodeType() != xercesc::DOMNode::ATTRIBUTE_NODE) { continue; }
1842
1843 const xercesc::DOMAttr* const attribute
1844 = dynamic_cast<xercesc::DOMAttr*>(node);
1845 if (!attribute)
1846 {
1847 G4Exception("G4GDMLReadSolids::ZplaneRead()",
1848 "InvalidRead", FatalException, "No attribute found!");
1849 return zplane;
1850 }
1851 const G4String attName = Transcode(attribute->getName());
1852 const G4String attValue = Transcode(attribute->getValue());
1853
1854 if (attName=="rmin") { zplane.rmin = eval.Evaluate(attValue); } else
1855 if (attName=="rmax") { zplane.rmax = eval.Evaluate(attValue); } else
1856 if (attName=="z") { zplane.z = eval.Evaluate(attValue); }
1857 }
1858
1859 return zplane;
1860}
1861
1862void G4GDMLReadSolids::
1863OpticalSurfaceRead(const xercesc::DOMElement* const opticalsurfaceElement)
1864{
1865 G4String name;
1866 G4String smodel;
1867 G4String sfinish;
1868 G4String stype;
1869 G4double value = 0.0;
1870
1871 const xercesc::DOMNamedNodeMap* const attributes
1872 = opticalsurfaceElement->getAttributes();
1873 XMLSize_t attributeCount = attributes->getLength();
1874
1875 for (XMLSize_t attribute_index=0;
1876 attribute_index<attributeCount; attribute_index++)
1877 {
1878 xercesc::DOMNode* attribute_node = attributes->item(attribute_index);
1879
1880 if (attribute_node->getNodeType() != xercesc::DOMNode::ATTRIBUTE_NODE)
1881 { continue; }
1882
1883 const xercesc::DOMAttr* const attribute
1884 = dynamic_cast<xercesc::DOMAttr*>(attribute_node);
1885 if (!attribute)
1886 {
1887 G4Exception("G4GDMLReadSolids::OpticalSurfaceRead()",
1888 "InvalidRead", FatalException, "No attribute found!");
1889 return;
1890 }
1891 const G4String attName = Transcode(attribute->getName());
1892 const G4String attValue = Transcode(attribute->getValue());
1893
1894 if (attName=="name") { name = GenerateName(attValue); } else
1895 if (attName=="model") { smodel = attValue; } else
1896 if (attName=="finish") { sfinish = attValue; } else
1897 if (attName=="type") { stype = attValue; } else
1898 if (attName=="value") { value = eval.Evaluate(attValue); }
1899 }
1900
1901 G4OpticalSurfaceModel model;
1902 G4OpticalSurfaceFinish finish;
1903 G4SurfaceType type;
1904
1905 if ((smodel=="glisur") || (smodel=="0")) { model = glisur; } else
1906 if ((smodel=="unified") || (smodel=="1")) { model = unified; }
1907 else { model = LUT; }
1908
1909 if ((sfinish=="polished") || (sfinish=="0"))
1910 { finish = polished; } else
1911 if ((sfinish=="polishedfrontpainted") || (sfinish=="1"))
1912 { finish = polishedfrontpainted; } else
1913 if ((sfinish=="polishedbackpainted") || (sfinish=="2"))
1914 { finish = polishedbackpainted; } else
1915 if ((sfinish=="ground") || (sfinish=="3"))
1916 { finish = ground; } else
1917 if ((sfinish=="groundfrontpainted") || (sfinish=="4"))
1918 { finish = groundfrontpainted; } else
1919 if ((sfinish=="groundbackpainted") || (sfinish=="5"))
1920 { finish = groundbackpainted; } else
1921 if ((sfinish=="polishedlumirrorair") || (sfinish=="6"))
1922 { finish = polishedlumirrorair; } else
1923 if ((sfinish=="polishedlumirrorglue") || (sfinish=="7"))
1924 { finish = polishedlumirrorglue; } else
1925 if ((sfinish=="polishedair") || (sfinish=="8"))
1926 { finish = polishedair; } else
1927 if ((sfinish=="polishedteflonair") || (sfinish=="9"))
1928 { finish = polishedteflonair; } else
1929 if ((sfinish=="polishedtioair") || (sfinish=="10"))
1930 { finish = polishedtioair; } else
1931 if ((sfinish=="polishedtyvekair") || (sfinish=="11"))
1932 { finish = polishedtyvekair; } else
1933 if ((sfinish=="polishedvm2000air") || (sfinish=="12"))
1934 { finish = polishedvm2000air; } else
1935 if ((sfinish=="polishedvm2000glue") || (sfinish=="13"))
1936 { finish = polishedvm2000glue; } else
1937 if ((sfinish=="etchedlumirrorair") || (sfinish=="14"))
1938 { finish = etchedlumirrorair; } else
1939 if ((sfinish=="etchedlumirrorglue") || (sfinish=="15"))
1940 { finish = etchedlumirrorglue; } else
1941 if ((sfinish=="etchedair") || (sfinish=="16"))
1942 { finish = etchedair; } else
1943 if ((sfinish=="etchedteflonair") || (sfinish=="17"))
1944 { finish = etchedteflonair; } else
1945 if ((sfinish=="etchedtioair") || (sfinish=="18"))
1946 { finish = etchedtioair; } else
1947 if ((sfinish=="etchedtyvekair") || (sfinish=="19"))
1948 { finish = etchedtyvekair; } else
1949 if ((sfinish=="etchedvm2000air") || (sfinish=="20"))
1950 { finish = etchedvm2000air; } else
1951 if ((sfinish=="etchedvm2000glue") || (sfinish=="21"))
1952 { finish = etchedvm2000glue; } else
1953 if ((sfinish=="groundlumirrorair") || (sfinish=="22"))
1954 { finish = groundlumirrorair; } else
1955 if ((sfinish=="groundlumirrorglue") || (sfinish=="23"))
1956 { finish = groundlumirrorglue; } else
1957 if ((sfinish=="groundair") || (sfinish=="24"))
1958 { finish = groundair; } else
1959 if ((sfinish=="groundteflonair") || (sfinish=="25"))
1960 { finish = groundteflonair; } else
1961 if ((sfinish=="groundtioair") || (sfinish=="26"))
1962 { finish = groundtioair; } else
1963 if ((sfinish=="groundtyvekair") || (sfinish=="27"))
1964 { finish = groundtyvekair; } else
1965 if ((sfinish=="groundvm2000air") || (sfinish=="28"))
1966 { finish = groundvm2000air; }
1967 else { finish = groundvm2000glue; }
1968
1969 if ((stype=="dielectric_metal") || (stype=="0"))
1970 { type = dielectric_metal; } else
1971 if ((stype=="dielectric_dielectric") || (stype=="1"))
1972 { type = dielectric_dielectric; } else
1973 if ((stype=="dielectric_LUT") || (stype=="2"))
1974 { type = dielectric_LUT; } else
1975 if ((stype=="firsov") || (stype=="3"))
1976 { type = firsov; }
1977 else { type = x_ray; }
1978
1979 new G4OpticalSurface(name,model,finish,type,value);
1980}
1981
1982void G4GDMLReadSolids::SolidsRead(const xercesc::DOMElement* const solidsElement)
1983{
1984 G4cout << "G4GDML: Reading solids..." << G4endl;
1985
1986 for (xercesc::DOMNode* iter = solidsElement->getFirstChild();
1987 iter != 0; iter = iter->getNextSibling())
1988 {
1989 if (iter->getNodeType() != xercesc::DOMNode::ELEMENT_NODE) { continue; }
1990
1991 const xercesc::DOMElement* const child
1992 = dynamic_cast<xercesc::DOMElement*>(iter);
1993 if (!child)
1994 {
1995 G4Exception("G4GDMLReadSolids::SolidsRead()",
1996 "InvalidRead", FatalException, "No child found!");
1997 return;
1998 }
1999 const G4String tag = Transcode(child->getTagName());
2000 if (tag=="define") { DefineRead(child); } else
2001 if (tag=="box") { BoxRead(child); } else
2002 if (tag=="cone") { ConeRead(child); } else
2003 if (tag=="elcone") { ElconeRead(child); } else
2004 if (tag=="ellipsoid") { EllipsoidRead(child); }else
2005 if (tag=="eltube") { EltubeRead(child); } else
2006 if (tag=="xtru") { XtruRead(child); } else
2007 if (tag=="hype") { HypeRead(child); } else
2008 if (tag=="intersection") { BooleanRead(child,INTERSECTION); } else
2009 if (tag=="orb") { OrbRead(child); } else
2010 if (tag=="para") { ParaRead(child); } else
2011 if (tag=="paraboloid") { ParaboloidRead(child); } else
2012 if (tag=="polycone") { PolyconeRead(child); } else
2013 if (tag=="polyhedra") { PolyhedraRead(child); } else
2014 if (tag=="reflectedSolid") { ReflectedSolidRead(child); } else
2015 if (tag=="sphere") { SphereRead(child); } else
2016 if (tag=="subtraction") { BooleanRead(child,SUBTRACTION); } else
2017 if (tag=="tessellated") { TessellatedRead(child); } else
2018 if (tag=="tet") { TetRead(child); } else
2019 if (tag=="torus") { TorusRead(child); } else
2020 if (tag=="arb8") { GenTrapRead(child); } else
2021 if (tag=="trap") { TrapRead(child); } else
2022 if (tag=="trd") { TrdRead(child); } else
2023 if (tag=="tube") { TubeRead(child); } else
2024 if (tag=="cutTube") { CutTubeRead(child); } else
2025 if (tag=="twistedbox") { TwistedboxRead(child); } else
2026 if (tag=="twistedtrap") { TwistedtrapRead(child); } else
2027 if (tag=="twistedtrd") { TwistedtrdRead(child); } else
2028 if (tag=="twistedtubs") { TwistedtubsRead(child); } else
2029 if (tag=="union") { BooleanRead(child,UNION); } else
2030 if (tag=="opticalsurface") { OpticalSurfaceRead(child); } else
2031 if (tag=="loop") { LoopRead(child,&G4GDMLRead::SolidsRead); }
2032 else
2033 {
2034 G4String error_msg = "Unknown tag in solids: " + tag;
2035 G4Exception("G4GDMLReadSolids::SolidsRead()", "ReadError",
2036 FatalException, error_msg);
2037 }
2038 }
2039}
2040
2041G4VSolid* G4GDMLReadSolids::GetSolid(const G4String& ref) const
2042{
2043 G4VSolid* solidPtr = G4SolidStore::GetInstance()->GetSolid(ref,false);
2044
2045 if (!solidPtr)
2046 {
2047 G4String error_msg = "Referenced solid '" + ref + "' was not found!";
2048 G4Exception("G4GDMLReadSolids::GetSolid()", "ReadError",
2049 FatalException, error_msg);
2050 }
2051
2052 return solidPtr;
2053}
2054
2055G4SurfaceProperty* G4GDMLReadSolids::
2056GetSurfaceProperty(const G4String& ref) const
2057{
2058 const G4SurfacePropertyTable* surfaceList
2059 = G4SurfaceProperty::GetSurfacePropertyTable();
2060 const size_t surfaceCount = surfaceList->size();
2061
2062 for (size_t i=0; i<surfaceCount; i++)
2063 {
2064 if ((*surfaceList)[i]->GetName() == ref) { return (*surfaceList)[i]; }
2065 }
2066
2067 G4String error_msg = "Referenced optical surface '" + ref + "' was not found!";
2068 G4Exception("G4GDMLReadSolids::GetSurfaceProperty()", "ReadError",
2069 FatalException, error_msg);
2070
2071 return 0;
2072}
FatalException
@ FatalException
Definition: G4ExceptionSeverity.hh:60
G4OpticalSurfaceModel
G4OpticalSurfaceModel
Definition: G4OpticalSurface.hh:99
unified
@ unified
Definition: G4OpticalSurface.hh:101
glisur
@ glisur
Definition: G4OpticalSurface.hh:100
G4OpticalSurfaceFinish
G4OpticalSurfaceFinish
Definition: G4OpticalSurface.hh:61
groundfrontpainted
@ groundfrontpainted
Definition: G4OpticalSurface.hh:67
polishedlumirrorair
@ polishedlumirrorair
Definition: G4OpticalSurface.hh:70
groundtyvekair
@ groundtyvekair
Definition: G4OpticalSurface.hh:93
groundtioair
@ groundtioair
Definition: G4OpticalSurface.hh:92
groundvm2000glue
@ groundvm2000glue
Definition: G4OpticalSurface.hh:95
polishedair
@ polishedair
Definition: G4OpticalSurface.hh:72
groundair
@ groundair
Definition: G4OpticalSurface.hh:90
etchedteflonair
@ etchedteflonair
Definition: G4OpticalSurface.hh:82
etchedtyvekair
@ etchedtyvekair
Definition: G4OpticalSurface.hh:84
etchedvm2000glue
@ etchedvm2000glue
Definition: G4OpticalSurface.hh:86
polishedbackpainted
@ polishedbackpainted
Definition: G4OpticalSurface.hh:64
etchedtioair
@ etchedtioair
Definition: G4OpticalSurface.hh:83
groundvm2000air
@ groundvm2000air
Definition: G4OpticalSurface.hh:94
polished
@ polished
Definition: G4OpticalSurface.hh:62
polishedlumirrorglue
@ polishedlumirrorglue
Definition: G4OpticalSurface.hh:71
polishedtyvekair
@ polishedtyvekair
Definition: G4OpticalSurface.hh:75
ground
@ ground
Definition: G4OpticalSurface.hh:66
polishedteflonair
@ polishedteflonair
Definition: G4OpticalSurface.hh:73
etchedair
@ etchedair
Definition: G4OpticalSurface.hh:81
polishedvm2000air
@ polishedvm2000air
Definition: G4OpticalSurface.hh:76
etchedlumirrorglue
@ etchedlumirrorglue
Definition: G4OpticalSurface.hh:80
polishedvm2000glue
@ polishedvm2000glue
Definition: G4OpticalSurface.hh:77
polishedfrontpainted
@ polishedfrontpainted
Definition: G4OpticalSurface.hh:63
polishedtioair
@ polishedtioair
Definition: G4OpticalSurface.hh:74
groundlumirrorglue
@ groundlumirrorglue
Definition: G4OpticalSurface.hh:89
etchedvm2000air
@ etchedvm2000air
Definition: G4OpticalSurface.hh:85
groundbackpainted
@ groundbackpainted
Definition: G4OpticalSurface.hh:68
etchedlumirrorair
@ etchedlumirrorair
Definition: G4OpticalSurface.hh:79
groundlumirrorair
@ groundlumirrorair
Definition: G4OpticalSurface.hh:88
groundteflonair
@ groundteflonair
Definition: G4OpticalSurface.hh:91
G4SurfacePropertyTable
std::vector< G4SurfaceProperty * > G4SurfacePropertyTable
Definition: G4SurfaceProperty.hh:63
G4SurfaceType
G4SurfaceType
Definition: G4SurfaceProperty.hh:66
dielectric_metal
@ dielectric_metal
Definition: G4SurfaceProperty.hh:67
dielectric_LUT
@ dielectric_LUT
Definition: G4SurfaceProperty.hh:69
dielectric_dielectric
@ dielectric_dielectric
Definition: G4SurfaceProperty.hh:68
x_ray
@ x_ray
Definition: G4SurfaceProperty.hh:71
firsov
@ firsov
Definition: G4SurfaceProperty.hh:70
G4Scale3D
HepGeom::Scale3D G4Scale3D
Definition: G4Transform3D.hh:52
G4TwoVector
CLHEP::Hep2Vector G4TwoVector
Definition: G4TwoVector.hh:42
G4double
double G4double
Definition: G4Types.hh:64
G4int
int G4int
Definition: G4Types.hh:66
G4FacetVertexType
G4FacetVertexType
Definition: G4VFacet.hh:56
ABSOLUTE
@ ABSOLUTE
Definition: G4VFacet.hh:56
RELATIVE
@ RELATIVE
Definition: G4VFacet.hh:56
G4endl
#define G4endl
Definition: G4ios.hh:52
G4cout
G4DLLIMPORT 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:55
G4Cons
Definition: G4Cons.hh:75
G4GDMLEvaluator::Evaluate
G4double Evaluate(const G4String &)
Definition: G4GDMLEvaluator.cc:213
G4GDMLEvaluator::EvaluateInteger
G4int EvaluateInteger(const G4String &)
Definition: G4GDMLEvaluator.cc:234
G4GDMLReadDefine::VectorRead
void VectorRead(const xercesc::DOMElement *const, G4ThreeVector &)
Definition: G4GDMLReadDefine.cc:494
G4GDMLReadDefine::GetRotationMatrix
G4RotationMatrix GetRotationMatrix(const G4ThreeVector &)
Definition: G4GDMLReadDefine.cc:132
G4GDMLReadDefine::GetPosition
G4ThreeVector GetPosition(const G4String &)
Definition: G4GDMLReadDefine.cc:589
G4GDMLReadDefine::RefRead
G4String RefRead(const xercesc::DOMElement *const)
Definition: G4GDMLReadDefine.cc:531
G4GDMLReadDefine::GetRotation
G4ThreeVector GetRotation(const G4String &)
Definition: G4GDMLReadDefine.cc:600
G4GDMLReadDefine::DefineRead
virtual void DefineRead(const xercesc::DOMElement *const)
Definition: G4GDMLReadDefine.cc:457
G4GDMLReadSolids::GetSurfaceProperty
G4SurfaceProperty * GetSurfaceProperty(const G4String &) const
Definition: G4GDMLReadSolids.cc:2056
G4GDMLReadSolids::ReflectedSolidRead
void ReflectedSolidRead(const xercesc::DOMElement *const)
Definition: G4GDMLReadSolids.cc:892
G4GDMLReadSolids::SectionRead
G4ExtrudedSolid::ZSection SectionRead(const xercesc::DOMElement *const, G4double)
Definition: G4GDMLReadSolids.cc:950
G4GDMLReadSolids::ParaboloidRead
void ParaboloidRead(const xercesc::DOMElement *const)
Definition: G4GDMLReadSolids.cc:634
G4GDMLReadSolids::XtruRead
void XtruRead(const xercesc::DOMElement *const)
Definition: G4GDMLReadSolids.cc:426
G4GDMLReadSolids::SphereRead
void SphereRead(const xercesc::DOMElement *const)
Definition: G4GDMLReadSolids.cc:993
G4GDMLReadSolids::TwistedtrapRead
void TwistedtrapRead(const xercesc::DOMElement *const)
Definition: G4GDMLReadSolids.cc:1610
G4GDMLReadSolids::TubeRead
void TubeRead(const xercesc::DOMElement *const)
Definition: G4GDMLReadSolids.cc:1443
G4GDMLReadSolids::GenTrapRead
void GenTrapRead(const xercesc::DOMElement *const)
Definition: G4GDMLReadSolids.cc:1209
G4GDMLReadSolids::GetSolid
G4VSolid * GetSolid(const G4String &) const
Definition: G4GDMLReadSolids.cc:2041
G4GDMLReadSolids::HypeRead
void HypeRead(const xercesc::DOMElement *const)
Definition: G4GDMLReadSolids.cc:485
G4GDMLReadSolids::TrdRead
void TrdRead(const xercesc::DOMElement *const)
Definition: G4GDMLReadSolids.cc:1346
G4GDMLReadSolids::ParaRead
void ParaRead(const xercesc::DOMElement *const)
Definition: G4GDMLReadSolids.cc:577
G4GDMLReadSolids::TwistedtrdRead
void TwistedtrdRead(const xercesc::DOMElement *const)
Definition: G4GDMLReadSolids.cc:1683
G4GDMLReadSolids::PolyhedraRead
void PolyhedraRead(const xercesc::DOMElement *const)
Definition: G4GDMLReadSolids.cc:759
G4GDMLReadSolids::ConeRead
void ConeRead(const xercesc::DOMElement *const)
Definition: G4GDMLReadSolids.cc:222
G4GDMLReadSolids::OpticalSurfaceRead
void OpticalSurfaceRead(const xercesc::DOMElement *const)
Definition: G4GDMLReadSolids.cc:1863
G4GDMLReadSolids::QuadrangularRead
G4QuadrangularFacet * QuadrangularRead(const xercesc::DOMElement *const)
Definition: G4GDMLReadSolids.cc:841
G4GDMLReadSolids::CutTubeRead
void CutTubeRead(const xercesc::DOMElement *const)
Definition: G4GDMLReadSolids.cc:1496
G4GDMLReadSolids::TetRead
void TetRead(const xercesc::DOMElement *const)
Definition: G4GDMLReadSolids.cc:1106
G4GDMLReadSolids::SolidsRead
virtual void SolidsRead(const xercesc::DOMElement *const)
Definition: G4GDMLReadSolids.cc:1982
G4GDMLReadSolids::EllipsoidRead
void EllipsoidRead(const xercesc::DOMElement *const)
Definition: G4GDMLReadSolids.cc:329
G4GDMLReadSolids::ElconeRead
void ElconeRead(const xercesc::DOMElement *const)
Definition: G4GDMLReadSolids.cc:282
G4GDMLReadSolids::TessellatedRead
void TessellatedRead(const xercesc::DOMElement *const)
Definition: G4GDMLReadSolids.cc:1050
G4GDMLReadSolids::TwistedboxRead
void TwistedboxRead(const xercesc::DOMElement *const)
Definition: G4GDMLReadSolids.cc:1559
G4GDMLReadSolids::BoxRead
void BoxRead(const xercesc::DOMElement *const)
Definition: G4GDMLReadSolids.cc:177
G4GDMLReadSolids::ZplaneRead
zplaneType ZplaneRead(const xercesc::DOMElement *const)
Definition: G4GDMLReadSolids.cc:1828
G4GDMLReadSolids::~G4GDMLReadSolids
virtual ~G4GDMLReadSolids()
Definition: G4GDMLReadSolids.cc:75
G4GDMLReadSolids::OrbRead
void OrbRead(const xercesc::DOMElement *const)
Definition: G4GDMLReadSolids.cc:538
G4GDMLReadSolids::PolyconeRead
void PolyconeRead(const xercesc::DOMElement *const)
Definition: G4GDMLReadSolids.cc:680
G4GDMLReadSolids::TwoDimVertexRead
G4TwoVector TwoDimVertexRead(const xercesc::DOMElement *const, G4double)
Definition: G4GDMLReadSolids.cc:1794
G4GDMLReadSolids::EltubeRead
void EltubeRead(const xercesc::DOMElement *const)
Definition: G4GDMLReadSolids.cc:381
G4GDMLReadSolids::TwistedtubsRead
void TwistedtubsRead(const xercesc::DOMElement *const)
Definition: G4GDMLReadSolids.cc:1740
G4GDMLReadSolids::TorusRead
void TorusRead(const xercesc::DOMElement *const)
Definition: G4GDMLReadSolids.cc:1155
G4GDMLReadSolids::BooleanRead
void BooleanRead(const xercesc::DOMElement *const, const BooleanOp)
Definition: G4GDMLReadSolids.cc:80
G4GDMLReadSolids::TrapRead
void TrapRead(const xercesc::DOMElement *const)
Definition: G4GDMLReadSolids.cc:1275
G4GDMLReadSolids::TriangularRead
G4TriangularFacet * TriangularRead(const xercesc::DOMElement *const)
Definition: G4GDMLReadSolids.cc:1397
G4GDMLRead::SolidsRead
virtual void SolidsRead(const xercesc::DOMElement *const)=0
G4GDMLRead::GenerateName
G4String GenerateName(const G4String &name, G4bool strip=false)
Definition: G4GDMLRead.cc:68
G4GDMLRead::LoopRead
void LoopRead(const xercesc::DOMElement *const, void(G4GDMLRead::*)(const xercesc::DOMElement *const))
Definition: G4GDMLRead.cc:179
G4GDMLRead::Transcode
G4String Transcode(const XMLCh *const)
Definition: G4GDMLRead.cc:55
G4GDMLRead::eval
G4GDMLEvaluator eval
Definition: G4GDMLRead.hh:144
G4Hype
Definition: G4Hype.hh:67
G4Orb
Definition: G4Orb.hh:52
G4Para
Definition: G4Para.hh:77
G4SolidStore::GetSolid
G4VSolid * GetSolid(const G4String &name, G4bool verbose=true) const
Definition: G4SolidStore.cc:158
G4SolidStore::GetInstance
static G4SolidStore * GetInstance()
Definition: G4SolidStore.cc:179
G4SurfaceProperty::GetSurfacePropertyTable
static const G4SurfacePropertyTable * GetSurfacePropertyTable()
Definition: G4SurfaceProperty.cc:79
G4TessellatedSolid::AddFacet
G4bool AddFacet(G4VFacet *aFacet)
Definition: G4TessellatedSolid.cc:220
G4TessellatedSolid::SetSolidClosed
void SetSolidClosed(const G4bool t)
Definition: G4TessellatedSolid.cc:560
G4Tet
Definition: G4Tet.hh:57
G4Trd
Definition: G4Trd.hh:63
G4Tubs
Definition: G4Tubs.hh:77
G4Exception
void G4Exception(const char *originOfException, const char *exceptionCode, G4ExceptionSeverity severity, const char *comments)
Definition: G4Exception.cc:41
tag
Definition: xmlparse.cc:179
position
#define position
Definition: xmlparse.cc:605