source: trunk/source/persistency/gdml/src/G4GDMLReadSolids.cc @ 1160

Last change on this file since 1160 was 987, checked in by garnier, 15 years ago

fichiers manquants
File size: 56.6 KB
Line 
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: G4GDMLReadSolids.cc,v 1.22 2008/11/21 09:32:46 gcosmo Exp $
27// GEANT4 tag $Name: geant4-09-02-ref-02 $
28//
29// class G4GDMLReadSolids Implementation
30//
31// Original author: Zoltan Torzsok, November 2007
32//
33// --------------------------------------------------------------------
34
35#include "G4GDMLReadSolids.hh"
36
37void G4GDMLReadSolids::
38BooleanRead(const xercesc::DOMElement* const booleanElement, const BooleanOp op)
39{
40   G4String name;
41   G4String first;
42   G4String second;
43   G4ThreeVector position(0.0,0.0,0.0);
44   G4ThreeVector rotation(0.0,0.0,0.0);
45   G4ThreeVector firstposition(0.0,0.0,0.0);
46   G4ThreeVector firstrotation(0.0,0.0,0.0);
47
48   const xercesc::DOMNamedNodeMap* const attributes
49         = booleanElement->getAttributes();
50   XMLSize_t attributeCount = attributes->getLength();
51
52   for (XMLSize_t attribute_index=0;
53        attribute_index<attributeCount; attribute_index++)
54   {
55      xercesc::DOMNode* attribute_node = attributes->item(attribute_index);
56
57      if (attribute_node->getNodeType() != xercesc::DOMNode::ATTRIBUTE_NODE)
58        { continue; }
59
60      const xercesc::DOMAttr* const attribute
61            = dynamic_cast<xercesc::DOMAttr*>(attribute_node);   
62      const G4String attName = Transcode(attribute->getName());
63      const G4String attValue = Transcode(attribute->getValue());
64
65      if (attName=="name")  { name = GenerateName(attValue); }
66   }
67
68   for (xercesc::DOMNode* iter = booleanElement->getFirstChild();
69        iter != 0;iter = iter->getNextSibling())
70   {
71      if (iter->getNodeType() != xercesc::DOMNode::ELEMENT_NODE)  { continue; }
72
73      const xercesc::DOMElement* const child
74            = dynamic_cast<xercesc::DOMElement*>(iter);
75      const G4String tag = Transcode(child->getTagName());
76
77      if (tag=="first") { first = RefRead(child); } else
78      if (tag=="second") { second = RefRead(child); } else
79      if (tag=="position") { VectorRead(child,position); } else
80      if (tag=="rotation") { VectorRead(child,rotation); } else
81      if (tag=="positionref")
82        { position = GetPosition(GenerateName(RefRead(child))); } else
83      if (tag=="rotationref")
84        { rotation = GetRotation(GenerateName(RefRead(child))); } else
85      if (tag=="firstposition") { VectorRead(child,firstposition); } else
86      if (tag=="firstrotation") { VectorRead(child,firstrotation); } else
87      if (tag=="firstpositionref")
88        { firstposition = GetPosition(GenerateName(RefRead(child))); } else
89      if (tag=="firstrotationref")
90        { firstrotation = GetRotation(GenerateName(RefRead(child))); } 
91      else
92      {
93        G4String error_msg = "Unknown tag in boolean solid: " + tag;
94        G4Exception("G4GDMLReadSolids::BooleanRead()", "ReadError",
95                    FatalException, error_msg);
96      }
97   }
98
99   G4VSolid* firstSolid = GetSolid(GenerateName(first));
100   G4VSolid* secondSolid = GetSolid(GenerateName(second));
101
102   G4Transform3D transform(GetRotationMatrix(rotation),position);
103
104   if (( (firstrotation.x()!=0.0) || (firstrotation.y()!=0.0)
105                                  || (firstrotation.z()!=0.0))
106    || ( (firstposition.x()!=0.0) || (firstposition.y()!=0.0)
107                                  || (firstposition.z()!=0.0)))
108   { 
109      G4Transform3D firsttransform(GetRotationMatrix(firstrotation),
110                                   firstposition);
111      firstSolid = new G4DisplacedSolid(GenerateName("displaced_"+first),
112                                        firstSolid, firsttransform);
113   }
114
115   if (op==UNION)
116     { new G4UnionSolid(name,firstSolid,secondSolid,transform); } else
117   if (op==SUBTRACTION)
118     { new G4SubtractionSolid(name,firstSolid,secondSolid,transform); } else
119   if (op==INTERSECTION)
120     { new G4IntersectionSolid(name,firstSolid,secondSolid,transform); }
121}
122
123void G4GDMLReadSolids::BoxRead(const xercesc::DOMElement* const boxElement)
124{
125   G4String name;
126   G4double lunit = 1.0;
127   G4double aunit = 1.0;
128   G4double x = 0.0;
129   G4double y = 0.0;
130   G4double z = 0.0;
131
132   const xercesc::DOMNamedNodeMap* const attributes
133         = boxElement->getAttributes();
134   XMLSize_t attributeCount = attributes->getLength();
135
136   for (XMLSize_t attribute_index=0;
137        attribute_index<attributeCount; attribute_index++)
138   {
139      xercesc::DOMNode* attribute_node = attributes->item(attribute_index);
140
141      if (attribute_node->getNodeType() != xercesc::DOMNode::ATTRIBUTE_NODE)
142        { continue; }
143
144      const xercesc::DOMAttr* const attribute
145            = dynamic_cast<xercesc::DOMAttr*>(attribute_node);   
146      const G4String attName = Transcode(attribute->getName());
147      const G4String attValue = Transcode(attribute->getValue());
148
149      if (attName=="name") { name = GenerateName(attValue); } else
150      if (attName=="lunit") { lunit = eval.Evaluate(attValue); } else
151      if (attName=="aunit") { aunit = eval.Evaluate(attValue); } else
152      if (attName=="x") { x = eval.Evaluate(attValue); } else
153      if (attName=="y") { y = eval.Evaluate(attValue); } else
154      if (attName=="z") { z = eval.Evaluate(attValue); }
155   }
156
157   x *= 0.5*lunit;
158   y *= 0.5*lunit;
159   z *= 0.5*lunit;
160
161   new G4Box(name,x,y,z);
162}
163
164void G4GDMLReadSolids::ConeRead(const xercesc::DOMElement* const coneElement)
165{
166   G4String name;
167   G4double lunit = 1.0;
168   G4double aunit = 1.0;
169   G4double rmin1 = 0.0;
170   G4double rmax1 = 0.0;
171   G4double rmin2 = 0.0;
172   G4double rmax2 = 0.0;
173   G4double z = 0.0;
174   G4double startphi = 0.0;
175   G4double deltaphi = 0.0;
176
177   const xercesc::DOMNamedNodeMap* const attributes
178         = coneElement->getAttributes();
179   XMLSize_t attributeCount = attributes->getLength();
180
181   for (XMLSize_t attribute_index=0;
182        attribute_index<attributeCount; attribute_index++)
183   {
184      xercesc::DOMNode* attribute_node = attributes->item(attribute_index);
185
186      if (attribute_node->getNodeType() != xercesc::DOMNode::ATTRIBUTE_NODE)
187        { continue; }
188
189      const xercesc::DOMAttr* const attribute
190            = dynamic_cast<xercesc::DOMAttr*>(attribute_node);   
191      const G4String attName = Transcode(attribute->getName());
192      const G4String attValue = Transcode(attribute->getValue());
193
194      if (attName=="name") { name = GenerateName(attValue); } else
195      if (attName=="lunit") { lunit = eval.Evaluate(attValue); } else
196      if (attName=="aunit") { aunit = eval.Evaluate(attValue); } else
197      if (attName=="rmin1") { rmin1 = eval.Evaluate(attValue); } else
198      if (attName=="rmax1") { rmax1 = eval.Evaluate(attValue); } else
199      if (attName=="rmin2") { rmin2 = eval.Evaluate(attValue); } else
200      if (attName=="rmax2") { rmax2 = eval.Evaluate(attValue); } else
201      if (attName=="z") { z = eval.Evaluate(attValue); } else
202      if (attName=="startphi") { startphi = eval.Evaluate(attValue); } else
203      if (attName=="deltaphi") { deltaphi = eval.Evaluate(attValue); }
204   }
205
206   rmin1 *= lunit;
207   rmax1 *= lunit;
208   rmin2 *= lunit;
209   rmax2 *= lunit;
210   z *= 0.5*lunit;
211   startphi *= aunit;
212   deltaphi *= aunit;
213
214   new G4Cons(name,rmin1,rmax1,rmin2,rmax2,z,startphi,deltaphi);
215}
216
217void G4GDMLReadSolids::
218ElconeRead(const xercesc::DOMElement* const elconeElement)
219{
220   G4String name;
221   G4double lunit = 1.0;
222   G4double dx = 0.0;
223   G4double dy = 0.0;
224   G4double zmax = 0.0;
225   G4double zcut = 0.0;
226
227   const xercesc::DOMNamedNodeMap* const attributes
228         = elconeElement->getAttributes();
229   XMLSize_t attributeCount = attributes->getLength();
230
231   for (XMLSize_t attribute_index=0;
232        attribute_index<attributeCount; attribute_index++)
233   {
234      xercesc::DOMNode* attribute_node = attributes->item(attribute_index);
235
236      if (attribute_node->getNodeType() != xercesc::DOMNode::ATTRIBUTE_NODE)
237        { continue; }
238
239      const xercesc::DOMAttr* const attribute
240            = dynamic_cast<xercesc::DOMAttr*>(attribute_node);   
241      const G4String attName = Transcode(attribute->getName());
242      const G4String attValue = Transcode(attribute->getValue());
243
244      if (attName=="name") { name = GenerateName(attValue); } else
245      if (attName=="lunit") { lunit = eval.Evaluate(attValue); } else
246      if (attName=="dx") { dx = eval.Evaluate(attValue); } else
247      if (attName=="dy") { dy = eval.Evaluate(attValue); } else
248      if (attName=="zmax") { zmax = eval.Evaluate(attValue); } else
249      if (attName=="zcut") { zcut = eval.Evaluate(attValue); }
250   }
251
252   dx *= lunit;
253   dy *= lunit;
254   zmax *= lunit;
255   zcut *= lunit;
256
257   new G4EllipticalCone(name,dx,dy,zmax,zcut);
258}
259
260void G4GDMLReadSolids::
261EllipsoidRead(const xercesc::DOMElement* const ellipsoidElement)
262{
263   G4String name;
264   G4double lunit = 1.0;
265   G4double ax = 0.0;
266   G4double by = 0.0;
267   G4double cz = 0.0;
268   G4double zcut1 = 0.0;
269   G4double zcut2 = 0.0; 
270
271   const xercesc::DOMNamedNodeMap* const attributes
272         = ellipsoidElement->getAttributes();
273   XMLSize_t attributeCount = attributes->getLength();
274
275   for (XMLSize_t attribute_index=0;
276        attribute_index<attributeCount; attribute_index++)
277   {
278      xercesc::DOMNode* attribute_node = attributes->item(attribute_index);
279
280      if (attribute_node->getNodeType() != xercesc::DOMNode::ATTRIBUTE_NODE)
281        { continue; }
282
283      const xercesc::DOMAttr* const attribute
284            = dynamic_cast<xercesc::DOMAttr*>(attribute_node);   
285      const G4String attName = Transcode(attribute->getName());
286      const G4String attValue = Transcode(attribute->getValue());
287
288      if (attName=="name") { name  = GenerateName(attValue); } else
289      if (attName=="lunit") { lunit = eval.Evaluate(attValue); } else
290      if (attName=="ax") { ax = eval.Evaluate(attValue); } else
291      if (attName=="by") { by = eval.Evaluate(attValue); } else
292      if (attName=="cz") { cz = eval.Evaluate(attValue); } else
293      if (attName=="zcut1") { zcut1 = eval.Evaluate(attValue); } else
294      if (attName=="zcut2") { zcut2 = eval.Evaluate(attValue); }
295   }
296
297   ax *= lunit;
298   by *= lunit;
299   cz *= lunit;
300   zcut1 *= lunit;
301   zcut2 *= lunit; 
302
303   new G4Ellipsoid(name,ax,by,cz,zcut1,zcut2);
304}
305
306void G4GDMLReadSolids::
307EltubeRead(const xercesc::DOMElement* const eltubeElement)
308{
309   G4String name;
310   G4double lunit = 1.0;
311   G4double dx = 0.0;
312   G4double dy = 0.0;
313   G4double dz = 0.0;
314
315   const xercesc::DOMNamedNodeMap* const attributes
316         = eltubeElement->getAttributes();
317   XMLSize_t attributeCount = attributes->getLength();
318
319   for (XMLSize_t attribute_index=0;
320        attribute_index<attributeCount; attribute_index++)
321   {
322      xercesc::DOMNode* attribute_node = attributes->item(attribute_index);
323
324      if (attribute_node->getNodeType() != xercesc::DOMNode::ATTRIBUTE_NODE)
325        { continue; }
326
327      const xercesc::DOMAttr* const attribute
328            = dynamic_cast<xercesc::DOMAttr*>(attribute_node);   
329      const G4String attName = Transcode(attribute->getName());
330      const G4String attValue = Transcode(attribute->getValue());
331
332      if (attName=="name") { name = GenerateName(attValue); } else
333      if (attName=="lunit") { lunit = eval.Evaluate(attValue); } else
334      if (attName=="dx") { dx = eval.Evaluate(attValue); } else
335      if (attName=="dy") { dy = eval.Evaluate(attValue); } else
336      if (attName=="dz") { dz = eval.Evaluate(attValue); }
337   }
338
339   dx *= lunit;
340   dy *= lunit;
341   dz *= lunit;
342
343   new G4EllipticalTube(name,dx,dy,dz);
344}
345
346void G4GDMLReadSolids::XtruRead(const xercesc::DOMElement* const xtruElement)
347{
348   G4String name;
349   G4double lunit = 1.0;
350
351   const xercesc::DOMNamedNodeMap* const attributes
352         = xtruElement->getAttributes();
353   XMLSize_t attributeCount = attributes->getLength();
354
355   for (XMLSize_t attribute_index=0;
356        attribute_index<attributeCount; attribute_index++)
357   {
358      xercesc::DOMNode* attribute_node = attributes->item(attribute_index);
359
360      if (attribute_node->getNodeType() != xercesc::DOMNode::ATTRIBUTE_NODE)
361        { continue; } 
362
363      const xercesc::DOMAttr* const attribute
364            = dynamic_cast<xercesc::DOMAttr*>(attribute_node);   
365      const G4String attName = Transcode(attribute->getName());
366      const G4String attValue = Transcode(attribute->getValue());
367
368      if (attName=="name") { name = GenerateName(attValue); } else
369      if (attName=="lunit") { lunit = eval.Evaluate(attValue); }
370   }
371
372   std::vector<G4TwoVector> twoDimVertexList;
373   std::vector<G4ExtrudedSolid::ZSection> sectionList;
374
375   for (xercesc::DOMNode* iter = xtruElement->getFirstChild();
376        iter != 0; iter = iter->getNextSibling())
377   {
378      if (iter->getNodeType() != xercesc::DOMNode::ELEMENT_NODE) { continue; }
379
380      const xercesc::DOMElement* const child
381            = dynamic_cast<xercesc::DOMElement*>(iter);
382      const G4String tag = Transcode(child->getTagName());
383
384      if (tag=="twoDimVertex")
385        { twoDimVertexList.push_back(TwoDimVertexRead(child,lunit)); } else
386      if (tag=="section")
387        { sectionList.push_back(SectionRead(child,lunit)); }
388   }
389
390   new G4ExtrudedSolid(name,twoDimVertexList,sectionList);
391}
392
393void G4GDMLReadSolids::HypeRead(const xercesc::DOMElement* const hypeElement)
394{
395   G4String name;
396   G4double lunit = 1.0;
397   G4double aunit = 1.0;
398   G4double rmin = 0.0;
399   G4double rmax = 0.0;
400   G4double inst = 0.0;
401   G4double outst = 0.0;
402   G4double z = 0.0;
403
404   const xercesc::DOMNamedNodeMap* const attributes
405         = hypeElement->getAttributes();
406   XMLSize_t attributeCount = attributes->getLength();
407
408   for (XMLSize_t attribute_index=0;
409        attribute_index<attributeCount; attribute_index++)
410   {
411      xercesc::DOMNode* attribute_node = attributes->item(attribute_index);
412
413      if (attribute_node->getNodeType() != xercesc::DOMNode::ATTRIBUTE_NODE)
414        { continue; }
415
416      const xercesc::DOMAttr* const attribute
417            = dynamic_cast<xercesc::DOMAttr*>(attribute_node);   
418      const G4String attName = Transcode(attribute->getName());
419      const G4String attValue = Transcode(attribute->getValue());
420
421      if (attName=="name") { name = GenerateName(attValue); } else
422      if (attName=="lunit") { lunit = eval.Evaluate(attValue); } else
423      if (attName=="aunit") { aunit = eval.Evaluate(attValue); } else
424      if (attName=="rmin") { rmin = eval.Evaluate(attValue); } else
425      if (attName=="rmax") { rmax = eval.Evaluate(attValue); } else
426      if (attName=="inst") { inst = eval.Evaluate(attValue); } else
427      if (attName=="outst") { outst = eval.Evaluate(attValue); } else
428      if (attName=="z") { z = eval.Evaluate(attValue); }
429   }
430
431   rmin *= lunit;
432   rmax *= lunit;
433   inst *= aunit;
434   outst *= aunit;
435   z *= 0.5*lunit;
436
437   new G4Hype(name,rmin,rmax,inst,outst,z);
438}
439
440void G4GDMLReadSolids::OrbRead(const xercesc::DOMElement* const orbElement)
441{
442   G4String name;
443   G4double lunit = 1.0;
444   G4double r = 0.0;
445
446   const xercesc::DOMNamedNodeMap* const attributes
447         = orbElement->getAttributes();
448   XMLSize_t attributeCount = attributes->getLength();
449
450   for (XMLSize_t attribute_index=0;
451        attribute_index<attributeCount; attribute_index++)
452   {
453      xercesc::DOMNode* attribute_node = attributes->item(attribute_index);
454
455      if (attribute_node->getNodeType() != xercesc::DOMNode::ATTRIBUTE_NODE)
456        { continue; }
457
458      const xercesc::DOMAttr* const attribute
459            = dynamic_cast<xercesc::DOMAttr*>(attribute_node);   
460      const G4String attName = Transcode(attribute->getName());
461      const G4String attValue = Transcode(attribute->getValue());
462
463      if (attName=="name") { name = GenerateName(attValue); } else
464      if (attName=="lunit") { lunit = eval.Evaluate(attValue); } else
465      if (attName=="r") { r = eval.Evaluate(attValue); }
466   }
467
468   r *= lunit;
469
470   new G4Orb(name,r);
471}
472
473void G4GDMLReadSolids::ParaRead(const xercesc::DOMElement* const paraElement)
474{
475   G4String name;
476   G4double lunit = 1.0;
477   G4double aunit = 1.0;
478   G4double x = 0.0;
479   G4double y = 0.0;
480   G4double z = 0.0;
481   G4double alpha = 0.0;
482   G4double theta = 0.0;
483   G4double phi = 0.0;
484
485   const xercesc::DOMNamedNodeMap* const attributes
486         = paraElement->getAttributes();
487   XMLSize_t attributeCount = attributes->getLength();
488
489   for (XMLSize_t attribute_index=0;
490        attribute_index<attributeCount; attribute_index++)
491   {
492      xercesc::DOMNode* attribute_node = attributes->item(attribute_index);
493
494      if (attribute_node->getNodeType() != xercesc::DOMNode::ATTRIBUTE_NODE)
495        { continue; }
496
497      const xercesc::DOMAttr* const attribute
498            = dynamic_cast<xercesc::DOMAttr*>(attribute_node);   
499      const G4String attName = Transcode(attribute->getName());
500      const G4String attValue = Transcode(attribute->getValue());
501
502      if (attName=="name") { name = GenerateName(attValue); } else
503      if (attName=="lunit") { lunit = eval.Evaluate(attValue); } else
504      if (attName=="aunit") { aunit = eval.Evaluate(attValue); } else
505      if (attName=="x") { x = eval.Evaluate(attValue); } else
506      if (attName=="y") { y = eval.Evaluate(attValue); } else
507      if (attName=="z") { z = eval.Evaluate(attValue); } else
508      if (attName=="alpha") { alpha = eval.Evaluate(attValue); } else
509      if (attName=="theta") { theta = eval.Evaluate(attValue); } else
510      if (attName=="phi") { phi = eval.Evaluate(attValue); }
511   }
512
513   x *= 0.5*lunit;
514   y *= 0.5*lunit;
515   z *= 0.5*lunit;
516   alpha *= aunit;
517   theta *= aunit;
518   phi *= aunit;
519
520   new G4Para(name,x,y,z,alpha,theta,phi);
521}
522
523void G4GDMLReadSolids::
524ParaboloidRead(const xercesc::DOMElement* const paraElement)
525{
526   G4String name;
527   G4double lunit = 1.0;
528   G4double aunit = 1.0;
529   G4double rlo = 0.0;
530   G4double rhi = 0.0;
531   G4double dz = 0.0;
532 
533   const xercesc::DOMNamedNodeMap* const attributes
534         = paraElement->getAttributes();
535   XMLSize_t attributeCount = attributes->getLength();
536
537   for (XMLSize_t attribute_index=0;
538        attribute_index<attributeCount; attribute_index++)
539   {
540      xercesc::DOMNode* attribute_node = attributes->item(attribute_index);
541
542      if (attribute_node->getNodeType() != xercesc::DOMNode::ATTRIBUTE_NODE)
543        { continue; }
544
545      const xercesc::DOMAttr* const attribute
546            = dynamic_cast<xercesc::DOMAttr*>(attribute_node);   
547      const G4String attName = Transcode(attribute->getName());
548      const G4String attValue = Transcode(attribute->getValue());
549
550      if (attName=="name")  { name = GenerateName(attValue); } else
551      if (attName=="lunit") { lunit = eval.Evaluate(attValue); } else
552      if (attName=="aunit") { aunit = eval.Evaluate(attValue); } else
553      if (attName=="rlo")   { rlo =  eval.Evaluate(attValue); } else
554      if (attName=="rhi")   { rhi = eval.Evaluate(attValue); } else
555      if (attName=="dz")    { dz = eval.Evaluate(attValue); } 
556   }     
557
558   rlo *= 1.*lunit;
559   rhi *= 1.*lunit;
560   dz *= 1.*lunit;
561 
562   new G4Paraboloid(name,dz,rlo,rhi);
563}
564
565void G4GDMLReadSolids::
566PolyconeRead(const xercesc::DOMElement* const polyconeElement) 
567{
568   G4String name;
569   G4double lunit = 1.0;
570   G4double aunit = 1.0;
571   G4double startphi = 0.0;
572   G4double deltaphi = 0.0;
573
574   const xercesc::DOMNamedNodeMap* const attributes
575         = polyconeElement->getAttributes();
576   XMLSize_t attributeCount = attributes->getLength();
577
578   for (XMLSize_t attribute_index=0;
579        attribute_index<attributeCount; attribute_index++)
580   {
581      xercesc::DOMNode* attribute_node = attributes->item(attribute_index);
582
583      if (attribute_node->getNodeType() != xercesc::DOMNode::ATTRIBUTE_NODE)
584        { continue; }
585
586      const xercesc::DOMAttr* const attribute
587            = dynamic_cast<xercesc::DOMAttr*>(attribute_node);   
588      const G4String attName = Transcode(attribute->getName());
589      const G4String attValue = Transcode(attribute->getValue());
590
591      if (attName=="name") { name = GenerateName(attValue); } else
592      if (attName=="lunit") { lunit = eval.Evaluate(attValue); } else
593      if (attName=="aunit") { aunit = eval.Evaluate(attValue); } else
594      if (attName=="startphi") { startphi = eval.Evaluate(attValue); }else
595      if (attName=="deltaphi") { deltaphi = eval.Evaluate(attValue); }
596   }
597
598   startphi *= aunit;
599   deltaphi *= aunit;
600
601   std::vector<zplaneType> zplaneList;
602
603   for (xercesc::DOMNode* iter = polyconeElement->getFirstChild();
604        iter != 0; iter = iter->getNextSibling())
605   {
606      if (iter->getNodeType() != xercesc::DOMNode::ELEMENT_NODE) { continue; }
607
608      const xercesc::DOMElement* const child
609            = dynamic_cast<xercesc::DOMElement*>(iter);
610      const G4String tag = Transcode(child->getTagName());
611
612      if (tag=="zplane") { zplaneList.push_back(ZplaneRead(child)); }
613   }
614
615   G4int numZPlanes = zplaneList.size();
616
617   G4double* rmin_array = new G4double[numZPlanes];
618   G4double* rmax_array = new G4double[numZPlanes];
619   G4double* z_array    = new G4double[numZPlanes];
620
621   for (G4int i=0; i<numZPlanes; i++)
622   { 
623      rmin_array[i] = zplaneList[i].rmin*lunit;
624      rmax_array[i] = zplaneList[i].rmax*lunit;
625      z_array[i]    = zplaneList[i].z*lunit;
626   }
627
628   new G4Polycone(name,startphi,deltaphi,numZPlanes,
629                  z_array,rmin_array,rmax_array);
630}
631
632void G4GDMLReadSolids::
633PolyhedraRead(const xercesc::DOMElement* const polyhedraElement)
634{
635   G4String name;
636   G4double lunit = 1.0;
637   G4double aunit = 1.0;
638   G4double startphi = 0.0;
639   G4double deltaphi = 0.0;
640   G4int numsides = 0;
641
642   const xercesc::DOMNamedNodeMap* const attributes
643         = polyhedraElement->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      const G4String attName = Transcode(attribute->getName());
657      const G4String attValue = Transcode(attribute->getValue());
658
659      if (attName=="name") { name = GenerateName(attValue); } else
660      if (attName=="lunit") { lunit = eval.Evaluate(attValue); } else
661      if (attName=="aunit") { aunit = eval.Evaluate(attValue); } else
662      if (attName=="startphi") { startphi = eval.Evaluate(attValue); } else
663      if (attName=="deltaphi") { deltaphi = eval.Evaluate(attValue); } else
664      if (attName=="numsides") { numsides = eval.EvaluateInteger(attValue); }
665   }
666
667   startphi *= aunit;
668   deltaphi *= aunit;
669
670   std::vector<zplaneType> zplaneList;
671
672   for (xercesc::DOMNode* iter = polyhedraElement->getFirstChild();
673        iter != 0; iter = iter->getNextSibling())
674   {
675      if (iter->getNodeType() != xercesc::DOMNode::ELEMENT_NODE)  { continue; }
676
677      const xercesc::DOMElement* const child
678            = dynamic_cast<xercesc::DOMElement*>(iter);
679      const G4String tag = Transcode(child->getTagName());
680
681      if (tag=="zplane") { zplaneList.push_back(ZplaneRead(child)); }
682   }
683
684   G4int numZPlanes = zplaneList.size();
685
686   G4double* rmin_array = new G4double[numZPlanes];
687   G4double* rmax_array = new G4double[numZPlanes];
688   G4double* z_array = new G4double[numZPlanes];
689
690   for (G4int i=0; i<numZPlanes; i++)
691   { 
692      rmin_array[i] = zplaneList[i].rmin*lunit;
693      rmax_array[i] = zplaneList[i].rmax*lunit;
694      z_array[i] = zplaneList[i].z*lunit;
695   }
696
697   new G4Polyhedra(name,startphi,deltaphi,numsides,numZPlanes,
698                   z_array,rmin_array,rmax_array);
699
700}
701
702G4QuadrangularFacet* G4GDMLReadSolids::
703QuadrangularRead(const xercesc::DOMElement* const quadrangularElement)
704{
705   G4ThreeVector vertex1;
706   G4ThreeVector vertex2;
707   G4ThreeVector vertex3;
708   G4ThreeVector vertex4;
709   G4FacetVertexType type = ABSOLUTE;
710
711   const xercesc::DOMNamedNodeMap* const attributes
712         = quadrangularElement->getAttributes();
713   XMLSize_t attributeCount = attributes->getLength();
714
715   for (XMLSize_t attribute_index=0;
716        attribute_index<attributeCount; attribute_index++)
717   {
718      xercesc::DOMNode* attribute_node = attributes->item(attribute_index);
719
720      if (attribute_node->getNodeType() != xercesc::DOMNode::ATTRIBUTE_NODE)
721        { continue; }
722
723      const xercesc::DOMAttr* const attribute
724            = dynamic_cast<xercesc::DOMAttr*>(attribute_node);   
725      const G4String attName = Transcode(attribute->getName());
726      const G4String attValue = Transcode(attribute->getValue());
727
728      if (attName=="vertex1")
729        { vertex1 = GetPosition(GenerateName(attValue)); } else
730      if (attName=="vertex2")
731        { vertex2 = GetPosition(GenerateName(attValue)); } else
732      if (attName=="vertex3")
733        { vertex3 = GetPosition(GenerateName(attValue)); } else
734      if (attName=="vertex4")
735        { vertex4 = GetPosition(GenerateName(attValue)); } else
736      if (attName=="type")
737        { if (attValue=="RELATIVE") { type = RELATIVE; } }
738   }
739
740   return new G4QuadrangularFacet(vertex1,vertex2,vertex3,vertex4,type);
741}
742
743void G4GDMLReadSolids::
744ReflectedSolidRead(const xercesc::DOMElement* const reflectedSolidElement)
745{
746   G4String name;
747   G4double lunit = 1.0;
748   G4double aunit = 1.0;
749   G4String solid;
750   G4ThreeVector scale(1.0,1.0,1.0);
751   G4ThreeVector rotation;
752   G4ThreeVector position;
753
754   const xercesc::DOMNamedNodeMap* const attributes
755         = reflectedSolidElement->getAttributes();
756   XMLSize_t attributeCount = attributes->getLength();
757
758   for (XMLSize_t attribute_index=0;
759        attribute_index<attributeCount; attribute_index++)
760   {
761      xercesc::DOMNode* attribute_node = attributes->item(attribute_index);
762
763      if (attribute_node->getNodeType() != xercesc::DOMNode::ATTRIBUTE_NODE)
764        { continue; }
765
766      const xercesc::DOMAttr* const attribute
767            = dynamic_cast<xercesc::DOMAttr*>(attribute_node);   
768      const G4String attName = Transcode(attribute->getName());
769      const G4String attValue = Transcode(attribute->getValue());
770
771      if (attName=="name") { name = GenerateName(attValue); } else
772      if (attName=="lunit") { lunit = eval.Evaluate(attValue); } else
773      if (attName=="aunit") { aunit = eval.Evaluate(attValue); } else
774      if (attName=="solid") { solid = GenerateName(attValue); } else
775      if (attName=="sx") { scale.setX(eval.Evaluate(attValue)); } else
776      if (attName=="sy") { scale.setY(eval.Evaluate(attValue)); } else
777      if (attName=="sz") { scale.setZ(eval.Evaluate(attValue)); } else
778      if (attName=="rx") { rotation.setX(eval.Evaluate(attValue)); } else
779      if (attName=="ry") { rotation.setY(eval.Evaluate(attValue)); } else
780      if (attName=="rz") { rotation.setZ(eval.Evaluate(attValue)); } else
781      if (attName=="dx") { position.setX(eval.Evaluate(attValue)); } else
782      if (attName=="dy") { position.setY(eval.Evaluate(attValue)); } else
783      if (attName=="dz") { position.setZ(eval.Evaluate(attValue)); }
784   }
785
786   rotation *= aunit;
787   position *= lunit;
788
789   G4Transform3D transform(GetRotationMatrix(rotation),position);
790   transform = transform*G4Scale3D(scale.x(),scale.y(),scale.z());
791         
792   new G4ReflectedSolid(name,GetSolid(solid),transform);
793}
794
795G4ExtrudedSolid::ZSection G4GDMLReadSolids::
796SectionRead(const xercesc::DOMElement* const sectionElement,G4double lunit) 
797{
798   G4double zPosition = 0.0;
799   G4TwoVector Offset;
800   G4double scalingFactor = 1.0;
801
802   const xercesc::DOMNamedNodeMap* const attributes
803         = sectionElement->getAttributes();
804   XMLSize_t attributeCount = attributes->getLength();
805
806   for (XMLSize_t attribute_index=0;
807        attribute_index<attributeCount; attribute_index++)
808   {
809      xercesc::DOMNode* attribute_node = attributes->item(attribute_index);
810
811      if (attribute_node->getNodeType() != xercesc::DOMNode::ATTRIBUTE_NODE)
812        { continue; }
813
814      const xercesc::DOMAttr* const attribute
815            = dynamic_cast<xercesc::DOMAttr*>(attribute_node);   
816      const G4String attName = Transcode(attribute->getName());
817      const G4String attValue = Transcode(attribute->getValue());
818
819      if (attName=="zPosition")
820        { zPosition = eval.Evaluate(attValue)*lunit; } else
821      if (attName=="xOffset")
822        { Offset.setX(eval.Evaluate(attValue)*lunit); } else
823      if (attName=="yOffset")
824        { Offset.setY(eval.Evaluate(attValue)*lunit); } else
825      if (attName=="scalingFactor")
826        { scalingFactor = eval.Evaluate(attValue); }
827   }
828
829   return G4ExtrudedSolid::ZSection(zPosition,Offset,scalingFactor);
830}
831
832void G4GDMLReadSolids::
833SphereRead(const xercesc::DOMElement* const sphereElement)
834{
835   G4String name;
836   G4double lunit = 1.0;
837   G4double aunit = 1.0;
838   G4double rmin = 0.0;
839   G4double rmax = 0.0;
840   G4double startphi = 0.0;
841   G4double deltaphi = 0.0;
842   G4double starttheta = 0.0;
843   G4double deltatheta = 0.0;
844
845   const xercesc::DOMNamedNodeMap* const attributes
846         = sphereElement->getAttributes();
847   XMLSize_t attributeCount = attributes->getLength();
848
849   for (XMLSize_t attribute_index=0;
850        attribute_index<attributeCount; attribute_index++)
851   {
852      xercesc::DOMNode* attribute_node = attributes->item(attribute_index);
853
854      if (attribute_node->getNodeType() != xercesc::DOMNode::ATTRIBUTE_NODE)
855        { continue; }
856
857      const xercesc::DOMAttr* const attribute
858            = dynamic_cast<xercesc::DOMAttr*>(attribute_node);   
859      const G4String attName = Transcode(attribute->getName());
860      const G4String attValue = Transcode(attribute->getValue());
861
862      if (attName=="name") { name = GenerateName(attValue); } else
863      if (attName=="lunit") { lunit = eval.Evaluate(attValue); } else
864      if (attName=="aunit") { aunit = eval.Evaluate(attValue); } else
865      if (attName=="rmin") { rmin = eval.Evaluate(attValue); } else
866      if (attName=="rmax") { rmax = eval.Evaluate(attValue); } else
867      if (attName=="startphi") { startphi = eval.Evaluate(attValue); } else
868      if (attName=="deltaphi") { deltaphi = eval.Evaluate(attValue); } else
869      if (attName=="starttheta") { starttheta = eval.Evaluate(attValue); } else
870      if (attName=="deltatheta") { deltatheta = eval.Evaluate(attValue); }
871   }
872
873   rmin *= lunit;
874   rmax *= lunit;
875   startphi *= aunit;
876   deltaphi *= aunit;
877   starttheta *= aunit;
878   deltatheta *= aunit;
879
880   new G4Sphere(name,rmin,rmax,startphi,deltaphi,starttheta,deltatheta);
881}
882
883void G4GDMLReadSolids::
884TessellatedRead(const xercesc::DOMElement* const tessellatedElement)
885{
886   G4String name;
887
888   const xercesc::DOMNamedNodeMap* const attributes
889         = tessellatedElement->getAttributes();
890   XMLSize_t attributeCount = attributes->getLength();
891
892   for (XMLSize_t attribute_index=0;
893        attribute_index<attributeCount; attribute_index++)
894   {
895      xercesc::DOMNode* attribute_node = attributes->item(attribute_index);
896
897      if (attribute_node->getNodeType() != xercesc::DOMNode::ATTRIBUTE_NODE)
898        { continue; }
899
900      const xercesc::DOMAttr* const attribute
901            = dynamic_cast<xercesc::DOMAttr*>(attribute_node);   
902      const G4String attName = Transcode(attribute->getName());
903      const G4String attValue = Transcode(attribute->getValue());
904
905      if (attName=="name") { name = GenerateName(attValue); }
906   }
907   
908   G4TessellatedSolid *tessellated = new G4TessellatedSolid(name);
909
910   for (xercesc::DOMNode* iter = tessellatedElement->getFirstChild();
911        iter != 0; iter = iter->getNextSibling())
912   {
913      if (iter->getNodeType() != xercesc::DOMNode::ELEMENT_NODE) { continue; }
914
915      const xercesc::DOMElement* const child
916            = dynamic_cast<xercesc::DOMElement*>(iter);
917      const G4String tag = Transcode(child->getTagName());
918
919      if (tag=="triangular")
920        { tessellated->AddFacet(TriangularRead(child)); } else
921      if (tag=="quadrangular")
922        { tessellated->AddFacet(QuadrangularRead(child)); }
923   }
924
925   tessellated->SetSolidClosed(true);
926}
927
928void G4GDMLReadSolids::TetRead(const xercesc::DOMElement* const tetElement)
929{
930   G4String name;
931   G4ThreeVector vertex1;
932   G4ThreeVector vertex2;
933   G4ThreeVector vertex3;
934   G4ThreeVector vertex4;
935   
936   const xercesc::DOMNamedNodeMap* const attributes
937         = tetElement->getAttributes();
938   XMLSize_t attributeCount = attributes->getLength();
939
940   for (XMLSize_t attribute_index=0;
941        attribute_index<attributeCount;attribute_index++)
942   {
943      xercesc::DOMNode* attribute_node = attributes->item(attribute_index);
944
945      if (attribute_node->getNodeType() != xercesc::DOMNode::ATTRIBUTE_NODE)
946        { continue; }
947
948      const xercesc::DOMAttr* const attribute
949            = dynamic_cast<xercesc::DOMAttr*>(attribute_node);   
950      const G4String attName = Transcode(attribute->getName());
951      const G4String attValue = Transcode(attribute->getValue());
952
953      if (attName=="name")
954        { name = GenerateName(attValue); } else
955      if (attName=="vertex1")
956        { vertex1 = GetPosition(GenerateName(attValue)); } else
957      if (attName=="vertex2")
958        { vertex2 = GetPosition(GenerateName(attValue)); } else
959      if (attName=="vertex3")
960        { vertex3 = GetPosition(GenerateName(attValue)); } else
961      if (attName=="vertex4")
962        { vertex4 = GetPosition(GenerateName(attValue)); }
963   }
964
965   new G4Tet(name,vertex1,vertex2,vertex3,vertex4);
966}
967
968void G4GDMLReadSolids::TorusRead(const xercesc::DOMElement* const torusElement)
969{
970   G4String name;
971   G4double lunit = 1.0;
972   G4double aunit = 1.0;
973   G4double rmin = 0.0;
974   G4double rmax = 0.0;
975   G4double rtor = 0.0;
976   G4double startphi = 0.0;
977   G4double deltaphi = 0.0;
978
979   const xercesc::DOMNamedNodeMap* const attributes
980         = torusElement->getAttributes();
981   XMLSize_t attributeCount = attributes->getLength();
982
983   for (XMLSize_t attribute_index=0;
984        attribute_index<attributeCount; attribute_index++)
985   {
986      xercesc::DOMNode* attribute_node = attributes->item(attribute_index);
987
988      if (attribute_node->getNodeType() != xercesc::DOMNode::ATTRIBUTE_NODE)
989        { continue; }
990
991      const xercesc::DOMAttr* const attribute
992            = dynamic_cast<xercesc::DOMAttr*>(attribute_node);   
993      const G4String attName = Transcode(attribute->getName());
994      const G4String attValue = Transcode(attribute->getValue());
995
996      if (attName=="name") { name = GenerateName(attValue); } else
997      if (attName=="lunit") { lunit = eval.Evaluate(attValue); } else
998      if (attName=="aunit") { aunit = eval.Evaluate(attValue); } else
999      if (attName=="rmin") { rmin = eval.Evaluate(attValue); } else
1000      if (attName=="rmax") { rmax = eval.Evaluate(attValue); } else
1001      if (attName=="rtor") { rtor = eval.Evaluate(attValue); } else
1002      if (attName=="startphi") { startphi = eval.Evaluate(attValue); } else
1003      if (attName=="deltaphi") { deltaphi = eval.Evaluate(attValue); }
1004   }
1005
1006   rmin *= lunit;
1007   rmax *= lunit;
1008   rtor *= lunit;
1009   startphi *= aunit;
1010   deltaphi *= aunit;
1011
1012   new G4Torus(name,rmin,rmax,rtor,startphi,deltaphi);
1013}
1014
1015void G4GDMLReadSolids::TrapRead(const xercesc::DOMElement* const trapElement)
1016{
1017   G4String name;
1018   G4double lunit = 1.0;
1019   G4double aunit = 1.0;
1020   G4double z = 0.0;
1021   G4double theta = 0.0;
1022   G4double phi = 0.0;
1023   G4double y1 = 0.0;
1024   G4double x1 = 0.0;
1025   G4double x2 = 0.0;
1026   G4double alpha1 = 0.0;
1027   G4double y2 = 0.0;
1028   G4double x3 = 0.0;
1029   G4double x4 = 0.0;
1030   G4double alpha2 = 0.0;
1031
1032   const xercesc::DOMNamedNodeMap* const attributes
1033         = trapElement->getAttributes();
1034   XMLSize_t attributeCount = attributes->getLength();
1035
1036   for (XMLSize_t attribute_index=0;
1037        attribute_index<attributeCount; attribute_index++)
1038   {
1039      xercesc::DOMNode* attribute_node = attributes->item(attribute_index);
1040
1041      if (attribute_node->getNodeType() != xercesc::DOMNode::ATTRIBUTE_NODE)
1042        { continue; }
1043
1044      const xercesc::DOMAttr* const attribute
1045            = dynamic_cast<xercesc::DOMAttr*>(attribute_node);   
1046      const G4String attName = Transcode(attribute->getName());
1047      const G4String attValue = Transcode(attribute->getValue());
1048
1049      if (attName=="name") { name = GenerateName(attValue); } else
1050      if (attName=="lunit") { lunit = eval.Evaluate(attValue); } else
1051      if (attName=="aunit") { aunit = eval.Evaluate(attValue); } else
1052      if (attName=="z") { z = eval.Evaluate(attValue); } else
1053      if (attName=="theta") { theta = eval.Evaluate(attValue); } else
1054      if (attName=="phi") { phi = eval.Evaluate(attValue); } else
1055      if (attName=="y1") { y1 = eval.Evaluate(attValue); } else
1056      if (attName=="x1") { x1 = eval.Evaluate(attValue); } else
1057      if (attName=="x2") { x2 = eval.Evaluate(attValue); } else
1058      if (attName=="alpha1") { alpha1 = eval.Evaluate(attValue); } else
1059      if (attName=="y2") { y2 = eval.Evaluate(attValue); } else
1060      if (attName=="x3") { x3 = eval.Evaluate(attValue); } else
1061      if (attName=="x4") { x4 = eval.Evaluate(attValue); } else
1062      if (attName=="alpha2") { alpha2 = eval.Evaluate(attValue); }
1063   }
1064
1065   z *= 0.5*lunit;
1066   theta *= aunit;
1067   phi *= aunit;
1068   y1 *= 0.5*lunit;
1069   x1 *= 0.5*lunit;
1070   x2 *= 0.5*lunit;
1071   alpha1 *= aunit;
1072   y2 *= 0.5*lunit;
1073   x3 *= 0.5*lunit;
1074   x4 *= 0.5*lunit;
1075   alpha2 *= aunit;
1076
1077   new G4Trap(name,z,theta,phi,y1,x1,x2,alpha1,y2,x3,x4,alpha2);
1078}
1079
1080void G4GDMLReadSolids::TrdRead(const xercesc::DOMElement* const trdElement)
1081{
1082   G4String name;
1083   G4double lunit = 1.0;
1084   G4double aunit = 1.0;
1085   G4double x1 = 0.0;
1086   G4double x2 = 0.0;
1087   G4double y1 = 0.0;
1088   G4double y2 = 0.0;
1089   G4double z = 0.0;
1090
1091   const xercesc::DOMNamedNodeMap* const attributes = trdElement->getAttributes();
1092   XMLSize_t attributeCount = attributes->getLength();
1093
1094   for (XMLSize_t attribute_index=0;
1095        attribute_index<attributeCount; attribute_index++)
1096   {
1097      xercesc::DOMNode* attribute_node = attributes->item(attribute_index);
1098
1099      if (attribute_node->getNodeType() != xercesc::DOMNode::ATTRIBUTE_NODE)
1100        { continue; }
1101
1102      const xercesc::DOMAttr* const attribute
1103            = dynamic_cast<xercesc::DOMAttr*>(attribute_node);   
1104      const G4String attName = Transcode(attribute->getName());
1105      const G4String attValue = Transcode(attribute->getValue());
1106
1107      if (attName=="name") { name = GenerateName(attValue); } else
1108      if (attName=="lunit") { lunit = eval.Evaluate(attValue); } else
1109      if (attName=="aunit") { aunit = eval.Evaluate(attValue); } else
1110      if (attName=="x1") { x1 = eval.Evaluate(attValue); } else
1111      if (attName=="x2") { x2 = eval.Evaluate(attValue); } else
1112      if (attName=="y1") { y1 = eval.Evaluate(attValue); } else
1113      if (attName=="y2") { y2 = eval.Evaluate(attValue); } else
1114      if (attName=="z") { z = eval.Evaluate(attValue); }
1115   }
1116
1117   x1 *= 0.5*lunit;
1118   x2 *= 0.5*lunit;
1119   y1 *= 0.5*lunit;
1120   y2 *= 0.5*lunit;
1121   z *= 0.5*lunit;
1122
1123   new G4Trd(name,x1,x2,y1,y2,z);
1124}
1125
1126G4TriangularFacet* G4GDMLReadSolids::
1127TriangularRead(const xercesc::DOMElement* const triangularElement)
1128{
1129   G4ThreeVector vertex1;
1130   G4ThreeVector vertex2;
1131   G4ThreeVector vertex3;
1132   G4FacetVertexType type = ABSOLUTE;
1133
1134   const xercesc::DOMNamedNodeMap* const attributes
1135         = triangularElement->getAttributes();
1136   XMLSize_t attributeCount = attributes->getLength();
1137
1138   for (XMLSize_t attribute_index=0;
1139        attribute_index<attributeCount; attribute_index++)
1140   {
1141      xercesc::DOMNode* attribute_node = attributes->item(attribute_index);
1142
1143      if (attribute_node->getNodeType() != xercesc::DOMNode::ATTRIBUTE_NODE)
1144        { continue; }
1145
1146      const xercesc::DOMAttr* const attribute
1147            = dynamic_cast<xercesc::DOMAttr*>(attribute_node);   
1148      const G4String attName = Transcode(attribute->getName());
1149      const G4String attValue = Transcode(attribute->getValue());
1150
1151      if (attName=="vertex1")
1152        { vertex1 = GetPosition(GenerateName(attValue)); } else
1153      if (attName=="vertex2")
1154        { vertex2 = GetPosition(GenerateName(attValue)); } else
1155      if (attName=="vertex3")
1156        { vertex3 = GetPosition(GenerateName(attValue)); } else
1157      if (attName=="type")
1158        { if (attValue=="RELATIVE") { type = RELATIVE; } }
1159   }
1160
1161   return new G4TriangularFacet(vertex1,vertex2,vertex3,type);
1162}
1163
1164void G4GDMLReadSolids::TubeRead(const xercesc::DOMElement* const tubeElement)
1165{
1166   G4String name;
1167   G4double lunit = 1.0;
1168   G4double aunit = 1.0;
1169   G4double rmin = 0.0;
1170   G4double rmax = 0.0;
1171   G4double z = 0.0;
1172   G4double startphi = 0.0;
1173   G4double deltaphi = 0.0;
1174
1175   const xercesc::DOMNamedNodeMap* const attributes
1176         = tubeElement->getAttributes();
1177   XMLSize_t attributeCount = attributes->getLength();
1178
1179   for (XMLSize_t attribute_index=0;
1180        attribute_index<attributeCount; attribute_index++)
1181   {
1182      xercesc::DOMNode* attribute_node = attributes->item(attribute_index);
1183
1184      if (attribute_node->getNodeType() != xercesc::DOMNode::ATTRIBUTE_NODE)
1185        { continue; }
1186
1187      const xercesc::DOMAttr* const attribute
1188            = dynamic_cast<xercesc::DOMAttr*>(attribute_node);   
1189      const G4String attName = Transcode(attribute->getName());
1190      const G4String attValue = Transcode(attribute->getValue());
1191
1192      if (attName=="name") { name = GenerateName(attValue); } else
1193      if (attName=="lunit") { lunit = eval.Evaluate(attValue); } else
1194      if (attName=="aunit") { aunit = eval.Evaluate(attValue); } else
1195      if (attName=="rmin") { rmin = eval.Evaluate(attValue); } else
1196      if (attName=="rmax") { rmax = eval.Evaluate(attValue); } else
1197      if (attName=="z") { z = eval.Evaluate(attValue); } else
1198      if (attName=="startphi") { startphi = eval.Evaluate(attValue); } else
1199      if (attName=="deltaphi") { deltaphi = eval.Evaluate(attValue); }
1200   }
1201
1202   rmin *= lunit;
1203   rmax *= lunit;
1204   z *= 0.5*lunit;
1205   startphi *= aunit;
1206   deltaphi *= aunit;
1207
1208   new G4Tubs(name,rmin,rmax,z,startphi,deltaphi);
1209}
1210
1211void G4GDMLReadSolids::
1212TwistedboxRead(const xercesc::DOMElement* const twistedboxElement)
1213{
1214   G4String name;
1215   G4double lunit = 1.0;
1216   G4double aunit = 1.0;
1217   G4double PhiTwist = 0.0;
1218   G4double x = 0.0;
1219   G4double y = 0.0;
1220   G4double z = 0.0;
1221
1222   const xercesc::DOMNamedNodeMap* const attributes
1223         = twistedboxElement->getAttributes();
1224   XMLSize_t attributeCount = attributes->getLength();
1225
1226   for (XMLSize_t attribute_index=0;
1227        attribute_index<attributeCount; attribute_index++)
1228   {
1229      xercesc::DOMNode* attribute_node = attributes->item(attribute_index);
1230
1231      if (attribute_node->getNodeType() != xercesc::DOMNode::ATTRIBUTE_NODE)
1232        { continue; }
1233
1234      const xercesc::DOMAttr* const attribute
1235            = dynamic_cast<xercesc::DOMAttr*>(attribute_node);   
1236      const G4String attName = Transcode(attribute->getName());
1237      const G4String attValue = Transcode(attribute->getValue());
1238
1239      if (attName=="name") { name = GenerateName(attValue); } else
1240      if (attName=="lunit") { lunit = eval.Evaluate(attValue); } else
1241      if (attName=="aunit") { aunit = eval.Evaluate(attValue); } else
1242      if (attName=="PhiTwist") { PhiTwist = eval.Evaluate(attValue); } else
1243      if (attName=="x") { x = eval.Evaluate(attValue); } else
1244      if (attName=="y") { y = eval.Evaluate(attValue); } else
1245      if (attName=="z") { z = eval.Evaluate(attValue); }
1246   }
1247
1248   PhiTwist *= aunit;
1249   x *= 0.5*lunit;
1250   y *= 0.5*lunit;
1251   z *= 0.5*lunit;
1252
1253   new G4TwistedBox(name,PhiTwist,x,y,z);
1254}
1255
1256void G4GDMLReadSolids::
1257TwistedtrapRead(const xercesc::DOMElement* const twistedtrapElement)
1258{
1259   G4String name;
1260   G4double lunit = 1.0;
1261   G4double aunit = 1.0;
1262   G4double PhiTwist = 0.0;
1263   G4double z = 0.0;
1264   G4double Theta = 0.0;
1265   G4double Phi = 0.0;
1266   G4double y1 = 0.0;
1267   G4double x1 = 0.0;
1268   G4double x2 = 0.0;
1269   G4double y2 = 0.0;
1270   G4double x3 = 0.0;
1271   G4double x4 = 0.0;
1272   G4double Alph = 0.0;
1273
1274   const xercesc::DOMNamedNodeMap* const attributes
1275         = twistedtrapElement->getAttributes();
1276   XMLSize_t attributeCount = attributes->getLength();
1277
1278   for (XMLSize_t attribute_index=0;
1279        attribute_index<attributeCount; attribute_index++)
1280   {
1281      xercesc::DOMNode* attribute_node = attributes->item(attribute_index);
1282
1283      if (attribute_node->getNodeType() != xercesc::DOMNode::ATTRIBUTE_NODE)
1284        { continue; }
1285
1286      const xercesc::DOMAttr* const attribute
1287            = dynamic_cast<xercesc::DOMAttr*>(attribute_node);   
1288      const G4String attName = Transcode(attribute->getName());
1289      const G4String attValue = Transcode(attribute->getValue());
1290
1291      if (attName=="name") { name = GenerateName(attValue); } else
1292      if (attName=="lunit") { lunit = eval.Evaluate(attValue); } else
1293      if (attName=="aunit") { aunit = eval.Evaluate(attValue); } else
1294      if (attName=="PhiTwist") { PhiTwist = eval.Evaluate(attValue); } else
1295      if (attName=="z") { z = eval.Evaluate(attValue); } else
1296      if (attName=="Theta") { Theta = eval.Evaluate(attValue); } else
1297      if (attName=="Phi") { Phi = eval.Evaluate(attValue); } else
1298      if (attName=="y1") { y1 = eval.Evaluate(attValue); } else
1299      if (attName=="x1") { x1 = eval.Evaluate(attValue); } else
1300      if (attName=="x2") { x2 = eval.Evaluate(attValue); } else
1301      if (attName=="y2") { y2 = eval.Evaluate(attValue); } else
1302      if (attName=="x3") { x3 = eval.Evaluate(attValue); } else
1303      if (attName=="x4") { x4 = eval.Evaluate(attValue); } else
1304      if (attName=="Alph") { Alph = eval.Evaluate(attValue); }
1305   }
1306
1307
1308   PhiTwist *= aunit;
1309   z *= 0.5*lunit;
1310   Theta *= aunit;
1311   Phi *= aunit;
1312   Alph *= aunit;
1313   y1 *= 0.5*lunit;
1314   x1 *= 0.5*lunit;
1315   x2 *= 0.5*lunit;
1316   y2 *= 0.5*lunit;
1317   x3 *= 0.5*lunit;
1318   x4 *= 0.5*lunit;
1319
1320   new G4TwistedTrap(name,PhiTwist,z,Theta,Phi,y1,x1,x2,y2,x3,x4,Alph);
1321}
1322
1323void G4GDMLReadSolids::
1324TwistedtrdRead(const xercesc::DOMElement* const twistedtrdElement)
1325{
1326   G4String name;
1327   G4double lunit = 1.0;
1328   G4double aunit = 1.0;
1329   G4double x1 = 0.0;
1330   G4double x2 = 0.0;
1331   G4double y1 = 0.0;
1332   G4double y2 = 0.0;
1333   G4double z = 0.0;
1334   G4double PhiTwist = 0.0;
1335
1336   const xercesc::DOMNamedNodeMap* const attributes
1337         = twistedtrdElement->getAttributes();
1338   XMLSize_t attributeCount = attributes->getLength();
1339
1340   for (XMLSize_t attribute_index=0;
1341        attribute_index<attributeCount; attribute_index++)
1342   {
1343      xercesc::DOMNode* attribute_node = attributes->item(attribute_index);
1344
1345      if (attribute_node->getNodeType() != xercesc::DOMNode::ATTRIBUTE_NODE)
1346        { continue; }
1347
1348      const xercesc::DOMAttr* const attribute
1349            = dynamic_cast<xercesc::DOMAttr*>(attribute_node);   
1350      const G4String attName = Transcode(attribute->getName());
1351      const G4String attValue = Transcode(attribute->getValue());
1352
1353      if (attName=="name") { name = GenerateName(attValue); } else
1354      if (attName=="lunit") { lunit = eval.Evaluate(attValue); } else
1355      if (attName=="aunit") { aunit = eval.Evaluate(attValue); } else
1356      if (attName=="x1") { x1 = eval.Evaluate(attValue); } else
1357      if (attName=="x2") { x2 = eval.Evaluate(attValue); } else
1358      if (attName=="y1") { y1 = eval.Evaluate(attValue); } else
1359      if (attName=="y2") { y2 = eval.Evaluate(attValue); } else
1360      if (attName=="z") { z = eval.Evaluate(attValue); } else
1361      if (attName=="PhiTwist") { PhiTwist = eval.Evaluate(attValue); }
1362   }
1363
1364   x1 *= 0.5*lunit;
1365   x2 *= 0.5*lunit;
1366   y1 *= 0.5*lunit;
1367   y2 *= 0.5*lunit;
1368   z *= 0.5*lunit;
1369   PhiTwist *= aunit;
1370
1371   new G4TwistedTrd(name,x1,x2,y1,y2,z,PhiTwist);
1372}
1373
1374void G4GDMLReadSolids::
1375TwistedtubsRead(const xercesc::DOMElement* const twistedtubsElement)
1376{
1377   G4String name;
1378   G4double lunit = 1.0;
1379   G4double aunit = 1.0;
1380   G4double twistedangle = 0.0;
1381   G4double endinnerrad = 0.0;
1382   G4double endouterrad = 0.0;
1383   G4double zlen = 0.0;
1384   G4double phi = 0.0;
1385
1386   const xercesc::DOMNamedNodeMap* const attributes
1387         = twistedtubsElement->getAttributes();
1388   XMLSize_t attributeCount = attributes->getLength();
1389
1390   for (XMLSize_t attribute_index=0;
1391        attribute_index<attributeCount; attribute_index++)
1392   {
1393      xercesc::DOMNode* attribute_node = attributes->item(attribute_index);
1394
1395      if (attribute_node->getNodeType() != xercesc::DOMNode::ATTRIBUTE_NODE)
1396        { continue; }
1397
1398      const xercesc::DOMAttr* const attribute
1399            = dynamic_cast<xercesc::DOMAttr*>(attribute_node);   
1400      const G4String attName = Transcode(attribute->getName());
1401      const G4String attValue = Transcode(attribute->getValue());
1402
1403      if (attName=="name") { name = GenerateName(attValue); } else
1404      if (attName=="lunit") { lunit = eval.Evaluate(attValue); } else
1405      if (attName=="aunit") { aunit = eval.Evaluate(attValue); } else
1406      if (attName=="twistedangle") { twistedangle=eval.Evaluate(attValue); } else
1407      if (attName=="endinnerrad")  { endinnerrad=eval.Evaluate(attValue);  } else
1408      if (attName=="endouterrad")  { endouterrad=eval.Evaluate(attValue);  } else
1409      if (attName=="zlen") { zlen = eval.Evaluate(attValue); } else
1410      if (attName=="phi") { phi = eval.Evaluate(attValue); }
1411   }
1412
1413   twistedangle *= aunit;
1414   endinnerrad *= lunit;
1415   endouterrad *= lunit;
1416   zlen *= 0.5*lunit;
1417   phi *= aunit;
1418
1419   new G4TwistedTubs(name,twistedangle,endinnerrad,endouterrad,zlen,phi);
1420}
1421
1422G4TwoVector G4GDMLReadSolids::
1423TwoDimVertexRead(const xercesc::DOMElement* const element, G4double lunit)
1424{
1425   G4TwoVector vec;
1426   
1427   const xercesc::DOMNamedNodeMap* const attributes = element->getAttributes();
1428   XMLSize_t attributeCount = attributes->getLength();
1429
1430   for (XMLSize_t attribute_index=0;
1431        attribute_index<attributeCount; attribute_index++)
1432   {
1433      xercesc::DOMNode* attribute_node = attributes->item(attribute_index);
1434
1435      if (attribute_node->getNodeType() != xercesc::DOMNode::ATTRIBUTE_NODE)
1436        { continue; }
1437
1438      const xercesc::DOMAttr* const attribute
1439            = dynamic_cast<xercesc::DOMAttr*>(attribute_node);   
1440      const G4String attName = Transcode(attribute->getName());
1441      const G4String attValue = Transcode(attribute->getValue());
1442
1443      if (attName=="x") { vec.setX(eval.Evaluate(attValue)*lunit); } else
1444      if (attName=="y") { vec.setY(eval.Evaluate(attValue)*lunit); }
1445   }
1446
1447   return vec;
1448}
1449
1450G4GDMLReadSolids::zplaneType G4GDMLReadSolids::
1451ZplaneRead(const xercesc::DOMElement* const zplaneElement)
1452{
1453   zplaneType zplane;
1454
1455   const xercesc::DOMNamedNodeMap* const attributes
1456         = zplaneElement->getAttributes();
1457   XMLSize_t attributeCount = attributes->getLength();
1458
1459   for (XMLSize_t attribute_index=0;
1460        attribute_index<attributeCount; attribute_index++)
1461   {
1462      xercesc::DOMNode* node = attributes->item(attribute_index);
1463
1464      if (node->getNodeType() != xercesc::DOMNode::ATTRIBUTE_NODE) { continue; }
1465
1466      const xercesc::DOMAttr* const attribute
1467            = dynamic_cast<xercesc::DOMAttr*>(node);   
1468      const G4String attName = Transcode(attribute->getName());
1469      const G4String attValue = Transcode(attribute->getValue());
1470
1471      if (attName=="rmin") { zplane.rmin = eval.Evaluate(attValue); } else
1472      if (attName=="rmax") { zplane.rmax = eval.Evaluate(attValue); } else
1473      if (attName=="z") { zplane.z = eval.Evaluate(attValue); }
1474   }
1475
1476   return zplane;
1477}
1478
1479void G4GDMLReadSolids::
1480OpticalsurfaceRead(const xercesc::DOMElement* const opticalsurfaceElement)
1481{
1482   G4String name;
1483   G4String smodel;
1484   G4String sfinish;
1485   G4String stype;
1486   G4double value = 0.0;
1487
1488   const xercesc::DOMNamedNodeMap* const attributes
1489         = opticalsurfaceElement->getAttributes();
1490   XMLSize_t attributeCount = attributes->getLength();
1491
1492   for (XMLSize_t attribute_index=0;
1493        attribute_index<attributeCount; attribute_index++)
1494   {
1495      xercesc::DOMNode* attribute_node = attributes->item(attribute_index);
1496
1497      if (attribute_node->getNodeType() != xercesc::DOMNode::ATTRIBUTE_NODE)
1498        { continue; }
1499
1500      const xercesc::DOMAttr* const attribute
1501            = dynamic_cast<xercesc::DOMAttr*>(attribute_node);   
1502      const G4String attName = Transcode(attribute->getName());
1503      const G4String attValue = Transcode(attribute->getValue());
1504
1505      if (attName=="name") { name = GenerateName(attValue); } else
1506      if (attName=="model") { smodel = attValue; } else
1507      if (attName=="finish") { sfinish = attValue; } else
1508      if (attName=="type") { stype = attValue; } else
1509      if (attName=="value") { value = eval.Evaluate(attValue); }
1510   }
1511
1512   G4OpticalSurfaceModel model; 
1513   G4OpticalSurfaceFinish finish;
1514   G4SurfaceType type;   
1515   
1516   if (smodel="unified") { model = unified; } else { model = glisur; }
1517
1518   if (sfinish=="polishedfrontpainted") { finish = polishedfrontpainted; } else
1519   if (sfinish=="polishedbackpainted") { finish = polishedbackpainted; } else
1520   if (sfinish=="groundfrontpainted") { finish = groundfrontpainted; } else
1521   if (sfinish=="groundbackpainted") { finish = groundbackpainted; } else
1522   if (sfinish=="ground") { finish = ground; } else { finish = polished; }
1523
1524   if (stype=="dielectric_metal") { type = dielectric_metal; } else
1525   if (stype=="x_ray") { type = x_ray; } else
1526   if (stype=="firsov") { type = firsov; } else { type = dielectric_dielectric; }
1527
1528   new G4OpticalSurface(name,model,finish,type,value);
1529}
1530
1531void G4GDMLReadSolids::SolidsRead(const xercesc::DOMElement* const solidsElement)
1532{
1533   G4cout << "G4GDML: Reading solids..." << G4endl;
1534
1535   for (xercesc::DOMNode* iter = solidsElement->getFirstChild();
1536        iter != 0; iter = iter->getNextSibling())
1537   {
1538      if (iter->getNodeType() != xercesc::DOMNode::ELEMENT_NODE)  { continue; }
1539
1540      const xercesc::DOMElement* const child
1541            = dynamic_cast<xercesc::DOMElement*>(iter);
1542      const G4String tag = Transcode(child->getTagName());
1543
1544      if (tag=="box") { BoxRead(child); } else
1545      if (tag=="cone") { ConeRead(child); } else
1546      if (tag=="elcone") { ElconeRead(child); } else
1547      if (tag=="ellipsoid") { EllipsoidRead(child); }else
1548      if (tag=="eltube") { EltubeRead(child); } else
1549      if (tag=="xtru") { XtruRead(child); } else
1550      if (tag=="hype") { HypeRead(child); } else
1551      if (tag=="intersection") { BooleanRead(child,INTERSECTION); } else
1552      if (tag=="orb") { OrbRead(child); } else
1553      if (tag=="para") { ParaRead(child); } else
1554      if (tag=="paraboloid") { ParaboloidRead(child); } else
1555      if (tag=="polycone") { PolyconeRead(child); } else
1556      if (tag=="polyhedra") { PolyhedraRead(child); } else
1557      if (tag=="reflectedSolid") { ReflectedSolidRead(child); } else
1558      if (tag=="sphere") { SphereRead(child); } else
1559      if (tag=="subtraction") { BooleanRead(child,SUBTRACTION); } else
1560      if (tag=="tessellated") { TessellatedRead(child); } else
1561      if (tag=="tet") { TetRead(child); } else
1562      if (tag=="torus") { TorusRead(child); } else
1563      if (tag=="trap") { TrapRead(child); } else
1564      if (tag=="trd") { TrdRead(child); } else
1565      if (tag=="tube") { TubeRead(child); } else
1566      if (tag=="twistedbox") { TwistedboxRead(child); } else
1567      if (tag=="twistedtrap") { TwistedtrapRead(child); } else
1568      if (tag=="twistedtrd") { TwistedtrdRead(child); } else
1569      if (tag=="twistedtubs") { TwistedtubsRead(child); } else
1570      if (tag=="union") { BooleanRead(child,UNION); } else
1571      if (tag=="opticalsurface") { OpticalsurfaceRead(child); } else
1572      if (tag=="loop") { LoopRead(child,&G4GDMLRead::SolidsRead); }
1573      else
1574      {
1575        G4String error_msg = "Unknown tag in solids: " + tag;
1576        G4Exception("G4GDMLReadSolids::SolidsRead()", "ReadError",
1577                    FatalException, error_msg);
1578      }
1579   }
1580}
1581
1582G4VSolid* G4GDMLReadSolids::GetSolid(const G4String& ref) const
1583{
1584   G4VSolid* solidPtr = G4SolidStore::GetInstance()->GetSolid(ref,false);
1585
1586   if (!solidPtr)
1587   {
1588     G4String error_msg = "Referenced solid '" + ref + "' was not found!";
1589     G4Exception("G4GDMLReadSolids::GetSolid()", "ReadError",
1590                 FatalException, error_msg);
1591   }
1592
1593   return solidPtr;
1594}
1595
1596G4SurfaceProperty* G4GDMLReadSolids::
1597GetSurfaceProperty(const G4String& ref) const
1598{
1599   const G4SurfacePropertyTable* surfaceList
1600         = G4SurfaceProperty::GetSurfacePropertyTable();
1601   const size_t surfaceCount = surfaceList->size();
1602
1603   for (size_t i=0; i<surfaceCount; i++)
1604   {
1605      if ((*surfaceList)[i]->GetName() == ref)  { return (*surfaceList)[i]; }
1606   }
1607
1608   G4String error_msg = "Referenced optical surface '" + ref + "' was not found!";
1609   G4Exception("G4GDMLReadSolids::GetSurfaceProperty()", "ReadError",
1610               FatalException, error_msg);
1611
1612   return 0;
1613}
Note: See TracBrowser for help on using the repository browser.