source: trunk/source/persistency/gdml/src/G4GDMLReadParamvol.cc @ 1202

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

fichiers manquants
File size: 23.8 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: G4GDMLReadParamvol.cc,v 1.11 2009/01/22 11:02:07 gcosmo Exp $
27// GEANT4 tag $Name: geant4-09-02-ref-02 $
28//
29// class G4GDMLReadParamvol Implementation
30//
31// History:
32// - Created.                                  Zoltan Torzsok, November 2007
33// -------------------------------------------------------------------------
34
35#include "G4GDMLReadParamvol.hh"
36
37void G4GDMLReadParamvol::
38Box_dimensionsRead( const xercesc::DOMElement* const element,
39                    G4GDMLParameterisation::PARAMETER& parameter )
40{
41   G4double lunit = 1.0;
42
43   const xercesc::DOMNamedNodeMap* const attributes = element->getAttributes();
44   XMLSize_t attributeCount = attributes->getLength();
45
46   for (XMLSize_t attribute_index=0;
47        attribute_index<attributeCount; attribute_index++)
48   {
49      xercesc::DOMNode* attribute_node = attributes->item(attribute_index);
50
51      if (attribute_node->getNodeType() != xercesc::DOMNode::ATTRIBUTE_NODE)
52        { continue; }
53
54      const xercesc::DOMAttr* const attribute
55            = dynamic_cast<xercesc::DOMAttr*>(attribute_node);   
56      const G4String attName = Transcode(attribute->getName());
57      const G4String attValue = Transcode(attribute->getValue());
58
59      if (attName=="lunit") { lunit = eval.Evaluate(attValue); } else
60      if (attName=="x") { parameter.dimension[0] = eval.Evaluate(attValue); } else
61      if (attName=="y") { parameter.dimension[1] = eval.Evaluate(attValue); } else
62      if (attName=="z") { parameter.dimension[2] = eval.Evaluate(attValue); }
63   }
64
65   parameter.dimension[0] *= 0.5*lunit;
66   parameter.dimension[1] *= 0.5*lunit;
67   parameter.dimension[2] *= 0.5*lunit;
68}
69
70void G4GDMLReadParamvol::
71Trd_dimensionsRead( const xercesc::DOMElement* const element,
72                    G4GDMLParameterisation::PARAMETER& parameter )
73{
74   G4double lunit = 1.0;
75
76   const xercesc::DOMNamedNodeMap* const attributes = element->getAttributes();
77   XMLSize_t attributeCount = attributes->getLength();
78
79   for (XMLSize_t attribute_index=0;
80        attribute_index<attributeCount; attribute_index++)
81   {
82      xercesc::DOMNode* attribute_node = attributes->item(attribute_index);
83
84      if (attribute_node->getNodeType() != xercesc::DOMNode::ATTRIBUTE_NODE)
85        { continue; }
86
87      const xercesc::DOMAttr* const attribute
88            = dynamic_cast<xercesc::DOMAttr*>(attribute_node);   
89      const G4String attName = Transcode(attribute->getName());
90      const G4String attValue = Transcode(attribute->getValue());
91
92      if (attName=="lunit") { lunit = eval.Evaluate(attValue); } else
93      if (attName=="x1") { parameter.dimension[0]=eval.Evaluate(attValue); } else
94      if (attName=="x2") { parameter.dimension[1]=eval.Evaluate(attValue); } else
95      if (attName=="y1") { parameter.dimension[2]=eval.Evaluate(attValue); } else
96      if (attName=="y2") { parameter.dimension[3]=eval.Evaluate(attValue); } else
97      if (attName=="z")  { parameter.dimension[4]=eval.Evaluate(attValue); }
98   }
99
100   parameter.dimension[0] *= 0.5*lunit;
101   parameter.dimension[1] *= 0.5*lunit;
102   parameter.dimension[2] *= 0.5*lunit;
103   parameter.dimension[3] *= 0.5*lunit;
104   parameter.dimension[4] *= 0.5*lunit;
105}
106
107void G4GDMLReadParamvol::
108Trap_dimensionsRead( const xercesc::DOMElement* const element,
109                     G4GDMLParameterisation::PARAMETER& parameter )
110{
111   G4double lunit = 1.0;
112   G4double aunit = 1.0;
113
114   const xercesc::DOMNamedNodeMap* const attributes = element->getAttributes();
115   XMLSize_t attributeCount = attributes->getLength();
116
117   for (XMLSize_t attribute_index=0;
118        attribute_index<attributeCount; attribute_index++)
119   {
120      xercesc::DOMNode* attribute_node = attributes->item(attribute_index);
121
122      if (attribute_node->getNodeType() != xercesc::DOMNode::ATTRIBUTE_NODE)
123        { continue; }
124
125      const xercesc::DOMAttr* const attribute
126            = dynamic_cast<xercesc::DOMAttr*>(attribute_node);   
127      const G4String attName = Transcode(attribute->getName());
128      const G4String attValue = Transcode(attribute->getValue());
129
130      if (attName=="lunit")
131        { lunit = eval.Evaluate(attValue); } else
132      if (attName=="aunit")
133        { aunit = eval.Evaluate(attValue); } else
134      if (attName=="z")
135        { parameter.dimension[0] = eval.Evaluate(attValue); } else
136      if (attName=="theta")
137        { parameter.dimension[1] = eval.Evaluate(attValue); } else
138      if (attName=="phi")
139        { parameter.dimension[2] = eval.Evaluate(attValue); } else
140      if (attName=="y1")
141        { parameter.dimension[3] = eval.Evaluate(attValue); } else
142      if (attName=="x1")
143        { parameter.dimension[4] = eval.Evaluate(attValue); } else
144      if (attName=="x2")
145        { parameter.dimension[5] = eval.Evaluate(attValue); } else
146      if (attName=="alpha1")
147        { parameter.dimension[6] = eval.Evaluate(attValue); } else
148      if (attName=="y2")
149        { parameter.dimension[7] = eval.Evaluate(attValue); } else
150      if (attName=="x3")
151        { parameter.dimension[8] = eval.Evaluate(attValue); } else
152      if (attName=="x4")
153        { parameter.dimension[9] = eval.Evaluate(attValue); } else
154      if (attName=="alpha2")
155        { parameter.dimension[10] = eval.Evaluate(attValue); }
156   }
157
158   parameter.dimension[0] *= 0.5*lunit;
159   parameter.dimension[1] *= aunit;
160   parameter.dimension[2] *= aunit;
161   parameter.dimension[3] *= 0.5*lunit;
162   parameter.dimension[4] *= 0.5*lunit;
163   parameter.dimension[5] *= 0.5*lunit;
164   parameter.dimension[6] *= aunit;
165   parameter.dimension[7] *= 0.5*lunit;
166   parameter.dimension[8] *= 0.5*lunit;
167   parameter.dimension[9] *= 0.5*lunit;
168   parameter.dimension[10] *= aunit;
169}
170
171void G4GDMLReadParamvol::
172Tube_dimensionsRead( const xercesc::DOMElement* const element,
173                     G4GDMLParameterisation::PARAMETER& parameter )
174{
175   G4double lunit = 1.0;
176   G4double aunit = 1.0;
177
178   const xercesc::DOMNamedNodeMap* const attributes = element->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=="lunit")
195        { lunit = eval.Evaluate(attValue); } else
196      if (attName=="aunit")
197        { aunit = eval.Evaluate(attValue); } else
198      if (attName=="InR")
199        { parameter.dimension[0] = eval.Evaluate(attValue); } else
200      if (attName=="OutR")
201        { parameter.dimension[1] = eval.Evaluate(attValue); } else
202      if (attName=="hz")
203        { parameter.dimension[2] = eval.Evaluate(attValue); } else
204      if (attName=="StartPhi")
205        { parameter.dimension[3] = eval.Evaluate(attValue); } else
206      if (attName=="DeltaPhi")
207        { parameter.dimension[4] = eval.Evaluate(attValue); }
208   }
209
210   parameter.dimension[0] *= lunit;
211   parameter.dimension[1] *= lunit;
212   parameter.dimension[2] *= 0.5*lunit;
213   parameter.dimension[3] *= aunit;
214   parameter.dimension[4] *= aunit;
215}
216
217void G4GDMLReadParamvol::
218Cone_dimensionsRead( const xercesc::DOMElement* const element,
219                     G4GDMLParameterisation::PARAMETER& parameter )
220{
221   G4double lunit = 1.0;
222   G4double aunit = 1.0;
223
224   const xercesc::DOMNamedNodeMap* const attributes = element->getAttributes();
225   XMLSize_t attributeCount = attributes->getLength();
226
227   for (XMLSize_t attribute_index=0;
228        attribute_index<attributeCount; attribute_index++)
229   {
230      xercesc::DOMNode* attribute_node = attributes->item(attribute_index);
231
232      if (attribute_node->getNodeType() != xercesc::DOMNode::ATTRIBUTE_NODE)
233        { continue; }
234
235      const xercesc::DOMAttr* const attribute
236            = dynamic_cast<xercesc::DOMAttr*>(attribute_node);   
237      const G4String attName = Transcode(attribute->getName());
238      const G4String attValue = Transcode(attribute->getValue());
239
240      if (attName=="lunit")
241        { lunit = eval.Evaluate(attValue); } else
242      if (attName=="aunit")
243        { aunit = eval.Evaluate(attValue); } else
244      if (attName=="rmin1")
245        { parameter.dimension[0] = eval.Evaluate(attValue); } else
246      if (attName=="rmax1")
247        { parameter.dimension[1] = eval.Evaluate(attValue); } else
248      if (attName=="rmin2")
249        { parameter.dimension[2] = eval.Evaluate(attValue); } else
250      if (attName=="rmax2")
251        { parameter.dimension[3] = eval.Evaluate(attValue); } else
252      if (attName=="z")
253        { parameter.dimension[4] = eval.Evaluate(attValue); } else
254      if (attName=="startphi")
255        { parameter.dimension[5] = eval.Evaluate(attValue); } else
256      if (attName=="deltaphi")
257        { parameter.dimension[6] = eval.Evaluate(attValue); }
258   }
259
260   parameter.dimension[0] *= lunit;
261   parameter.dimension[1] *= lunit;
262   parameter.dimension[2] *= lunit;
263   parameter.dimension[3] *= lunit;
264   parameter.dimension[4] *= 0.5*lunit;
265   parameter.dimension[5] *= aunit;
266   parameter.dimension[6] *= aunit;
267}
268
269void G4GDMLReadParamvol::
270Sphere_dimensionsRead( const xercesc::DOMElement* const element,
271                       G4GDMLParameterisation::PARAMETER& parameter ) 
272{
273   G4double lunit = 1.0;
274   G4double aunit = 1.0;
275
276   const xercesc::DOMNamedNodeMap* const attributes = element->getAttributes();
277   XMLSize_t attributeCount = attributes->getLength();
278
279   for (XMLSize_t attribute_index=0;
280        attribute_index<attributeCount; attribute_index++)
281   {
282      xercesc::DOMNode* attribute_node = attributes->item(attribute_index);
283
284      if (attribute_node->getNodeType() != xercesc::DOMNode::ATTRIBUTE_NODE)
285        { continue; }
286
287      const xercesc::DOMAttr* const attribute
288            = dynamic_cast<xercesc::DOMAttr*>(attribute_node);   
289      const G4String attName = Transcode(attribute->getName());
290      const G4String attValue = Transcode(attribute->getValue());
291
292      if (attName=="lunit")
293        { lunit = eval.Evaluate(attValue); } else
294      if (attName=="aunit")
295        { aunit = eval.Evaluate(attValue); } else
296      if (attName=="rmin")
297        { parameter.dimension[0] = eval.Evaluate(attValue); } else
298      if (attName=="rmax")
299        { parameter.dimension[1] = eval.Evaluate(attValue); } else
300      if (attName=="startphi")
301        { parameter.dimension[2] = eval.Evaluate(attValue); } else
302      if (attName=="deltaphi")
303        { parameter.dimension[3] = eval.Evaluate(attValue); } else
304      if (attName=="starttheta")
305        { parameter.dimension[4] = eval.Evaluate(attValue); } else
306      if (attName=="deltatheta")
307        { parameter.dimension[5] = eval.Evaluate(attValue); }
308   }
309
310   parameter.dimension[0] *= lunit;
311   parameter.dimension[1] *= lunit;
312   parameter.dimension[2] *= aunit;
313   parameter.dimension[3] *= aunit;
314   parameter.dimension[4] *= aunit;
315   parameter.dimension[5] *= aunit;
316}
317
318void G4GDMLReadParamvol::
319Orb_dimensionsRead( const xercesc::DOMElement* const element,
320                    G4GDMLParameterisation::PARAMETER& parameter )
321{
322   G4double lunit = 1.0;
323
324   const xercesc::DOMNamedNodeMap* const attributes = element->getAttributes();
325   XMLSize_t attributeCount = attributes->getLength();
326
327   for (XMLSize_t attribute_index=0;
328        attribute_index<attributeCount; attribute_index++)
329   {
330      xercesc::DOMNode* attribute_node = attributes->item(attribute_index);
331
332      if (attribute_node->getNodeType() != xercesc::DOMNode::ATTRIBUTE_NODE)
333        { continue; }
334
335      const xercesc::DOMAttr* const attribute
336            = dynamic_cast<xercesc::DOMAttr*>(attribute_node);   
337      const G4String attName = Transcode(attribute->getName());
338      const G4String attValue = Transcode(attribute->getValue());
339
340      if (attName=="lunit") { lunit = eval.Evaluate(attValue); } else
341      if (attName=="r") { parameter.dimension[0] = eval.Evaluate(attValue); }
342   }
343
344   parameter.dimension[0] *= lunit;
345}
346
347void G4GDMLReadParamvol::
348Torus_dimensionsRead( const xercesc::DOMElement* const element,
349                      G4GDMLParameterisation::PARAMETER& parameter )
350{
351   G4double lunit = 1.0;
352   G4double aunit = 1.0;
353
354   const xercesc::DOMNamedNodeMap* const attributes = element->getAttributes();
355   XMLSize_t attributeCount = attributes->getLength();
356
357   for (XMLSize_t attribute_index=0;
358        attribute_index<attributeCount; attribute_index++)
359   {
360      xercesc::DOMNode* attribute_node = attributes->item(attribute_index);
361
362      if (attribute_node->getNodeType() != xercesc::DOMNode::ATTRIBUTE_NODE)
363        { continue; }
364
365      const xercesc::DOMAttr* const attribute
366            = dynamic_cast<xercesc::DOMAttr*>(attribute_node);   
367      const G4String attName = Transcode(attribute->getName());
368      const G4String attValue = Transcode(attribute->getValue());
369
370      if (attName=="lunit")
371        { lunit = eval.Evaluate(attValue); } else
372      if (attName=="aunit")
373        { aunit = eval.Evaluate(attValue); } else
374      if (attName=="rmin")
375        { parameter.dimension[0] = eval.Evaluate(attValue); } else
376      if (attName=="rmax")
377        { parameter.dimension[1] = eval.Evaluate(attValue); } else
378      if (attName=="rtor")
379        { parameter.dimension[2] = eval.Evaluate(attValue); } else
380      if (attName=="startphi")
381        { parameter.dimension[3] = eval.Evaluate(attValue); } else
382      if (attName=="deltaphi")
383        { parameter.dimension[4] = eval.Evaluate(attValue); }
384   }
385
386   parameter.dimension[0] *= lunit;
387   parameter.dimension[1] *= lunit;
388   parameter.dimension[2] *= lunit;
389   parameter.dimension[3] *= aunit;
390   parameter.dimension[4] *= aunit;
391}
392
393void G4GDMLReadParamvol::
394Para_dimensionsRead( const xercesc::DOMElement* const element,
395                     G4GDMLParameterisation::PARAMETER& parameter )
396{
397   G4double lunit = 1.0;
398   G4double aunit = 1.0;
399
400   const xercesc::DOMNamedNodeMap* const attributes = element->getAttributes();
401   XMLSize_t attributeCount = attributes->getLength();
402
403   for (XMLSize_t attribute_index=0;
404        attribute_index<attributeCount; attribute_index++)
405   {
406      xercesc::DOMNode* attribute_node = attributes->item(attribute_index);
407
408      if (attribute_node->getNodeType() != xercesc::DOMNode::ATTRIBUTE_NODE)
409        { continue; }
410
411      const xercesc::DOMAttr* const attribute
412            = dynamic_cast<xercesc::DOMAttr*>(attribute_node);   
413      const G4String attName = Transcode(attribute->getName());
414      const G4String attValue = Transcode(attribute->getValue());
415
416      if (attName=="lunit")
417        { lunit = eval.Evaluate(attValue); } else
418      if (attName=="aunit")
419        { aunit = eval.Evaluate(attValue); } else
420      if (attName=="x")
421        { parameter.dimension[0] = eval.Evaluate(attValue); } else
422      if (attName=="y")
423        { parameter.dimension[1] = eval.Evaluate(attValue); } else
424      if (attName=="z")
425        { parameter.dimension[2] = eval.Evaluate(attValue); } else
426      if (attName=="alpha")
427        { parameter.dimension[3] = eval.Evaluate(attValue); } else
428      if (attName=="theta")
429        { parameter.dimension[4] = eval.Evaluate(attValue); } else
430      if (attName=="phi")
431        { parameter.dimension[5] = eval.Evaluate(attValue); }
432   }
433
434   parameter.dimension[0] = 0.5*lunit;
435   parameter.dimension[1] = 0.5*lunit;
436   parameter.dimension[2] = 0.5*lunit;
437   parameter.dimension[3] = aunit;
438   parameter.dimension[4] = aunit;
439   parameter.dimension[5] = aunit;
440}
441
442void G4GDMLReadParamvol::
443Hype_dimensionsRead( const xercesc::DOMElement* const element,
444                     G4GDMLParameterisation::PARAMETER& parameter )
445{
446   G4double lunit = 1.0;
447   G4double aunit = 1.0;
448
449   const xercesc::DOMNamedNodeMap* const attributes = element->getAttributes();
450   XMLSize_t attributeCount = attributes->getLength();
451
452   for (XMLSize_t attribute_index=0;
453        attribute_index<attributeCount; attribute_index++)
454   {
455      xercesc::DOMNode* attribute_node = attributes->item(attribute_index);
456
457      if (attribute_node->getNodeType() != xercesc::DOMNode::ATTRIBUTE_NODE)
458        { continue; }
459
460      const xercesc::DOMAttr* const attribute
461            = dynamic_cast<xercesc::DOMAttr*>(attribute_node);   
462      const G4String attName = Transcode(attribute->getName());
463      const G4String attValue = Transcode(attribute->getValue());
464
465      if (attName=="lunit")
466        { lunit = eval.Evaluate(attValue); } else
467      if (attName=="aunit")
468        { aunit = eval.Evaluate(attValue); } else
469      if (attName=="rmin")
470        { parameter.dimension[0] = eval.Evaluate(attValue); } else
471      if (attName=="rmax")
472        { parameter.dimension[1] = eval.Evaluate(attValue); } else
473      if (attName=="inst")
474        { parameter.dimension[2] = eval.Evaluate(attValue); } else
475      if (attName=="outst")
476        { parameter.dimension[3] = eval.Evaluate(attValue); } else
477      if (attName=="z")
478        { parameter.dimension[4] = eval.Evaluate(attValue); }
479   }
480
481   parameter.dimension[0] = lunit;
482   parameter.dimension[1] = lunit;
483   parameter.dimension[2] = aunit;
484   parameter.dimension[3] = aunit;
485   parameter.dimension[4] = 0.5*lunit;
486}
487
488void G4GDMLReadParamvol::
489ParametersRead(const xercesc::DOMElement* const element) {
490
491   G4ThreeVector rotation(0.0,0.0,0.0);
492   G4ThreeVector position(0.0,0.0,0.0);
493
494   G4GDMLParameterisation::PARAMETER parameter;
495
496   for (xercesc::DOMNode* iter = element->getFirstChild();
497        iter != 0; iter = iter->getNextSibling())
498   {
499      if (iter->getNodeType() != xercesc::DOMNode::ELEMENT_NODE)  { continue; }
500
501      const xercesc::DOMElement* const child
502            = dynamic_cast<xercesc::DOMElement*>(iter);
503      const G4String tag = Transcode(child->getTagName());
504      if (tag=="rotation") { VectorRead(child,rotation); } else
505      if (tag=="position") { VectorRead(child,position); } else
506      if (tag=="positionref")
507        { position = GetPosition(GenerateName(RefRead(child))); } else
508      if (tag=="rotationref")
509        { rotation = GetRotation(GenerateName(RefRead(child))); } else
510      if (tag=="box_dimensions") { Box_dimensionsRead(child,parameter); } else
511      if (tag=="trd_dimensions") { Trd_dimensionsRead(child,parameter); } else
512      if (tag=="trap_dimensions") { Trap_dimensionsRead(child,parameter); } else
513      if (tag=="tube_dimensions") { Tube_dimensionsRead(child,parameter); } else
514      if (tag=="cone_dimensions") { Cone_dimensionsRead(child,parameter); } else
515      if (tag=="sphere_dimensions") { Cone_dimensionsRead(child,parameter); } else
516      if (tag=="orb_dimensions") { Cone_dimensionsRead(child,parameter); } else
517      if (tag=="torus_dimensions") { Cone_dimensionsRead(child,parameter); } else
518      if (tag=="para_dimensions") { Cone_dimensionsRead(child,parameter); } else
519      if (tag=="hype_dimensions") { Hype_dimensionsRead(child,parameter); }
520      else
521      {
522        G4String error_msg = "Unknown tag in parameters: " + tag;
523        G4Exception("G4GDMLReadParamvol::ParametersRead()", "ReadError",
524                    FatalException, error_msg);
525      }
526   }
527
528   parameter.pRot = new G4RotationMatrix();
529   
530   parameter.pRot->rotateX(rotation.x());
531   parameter.pRot->rotateY(rotation.y());
532   parameter.pRot->rotateZ(rotation.z());
533
534   parameter.position = position;
535
536   parameterisation->AddParameter(parameter);
537}
538
539void G4GDMLReadParamvol::
540ParameterisedRead(const xercesc::DOMElement* const element)
541{
542   for (xercesc::DOMNode* iter = element->getFirstChild();
543        iter != 0; iter = iter->getNextSibling())
544   {
545     if (iter->getNodeType() != xercesc::DOMNode::ELEMENT_NODE)  { continue; }
546
547     const xercesc::DOMElement* const child
548           = dynamic_cast<xercesc::DOMElement*>(iter);
549     const G4String tag = Transcode(child->getTagName());
550 
551     if (tag=="parameters")
552     {
553        G4double number = 1;
554        const xercesc::DOMNamedNodeMap* const attributes
555              = element->getAttributes();
556        XMLSize_t attributeCount = attributes->getLength();
557        for (XMLSize_t attribute_index=0;
558             attribute_index<attributeCount; attribute_index++)
559        {
560          xercesc::DOMNode* attribute_node = attributes->item(attribute_index);
561
562          if (attribute_node->getNodeType() != xercesc::DOMNode::ATTRIBUTE_NODE)
563            { continue; }
564
565          const xercesc::DOMAttr* const attribute
566                = dynamic_cast<xercesc::DOMAttr*>(attribute_node);   
567          const G4String attName = Transcode(attribute->getName());
568          const G4String attValue = Transcode(attribute->getValue());
569
570          if (attName=="number")  { number = eval.Evaluate(attValue); }
571        }
572        ParametersRead(child);
573      }
574      else
575      {
576        if (tag=="loop") { LoopRead(child,&G4GDMLRead::Paramvol_contentRead); }
577      }
578    }
579}
580
581void G4GDMLReadParamvol::
582Paramvol_contentRead(const xercesc::DOMElement* const element)
583{
584   for (xercesc::DOMNode* iter = element->getFirstChild();
585        iter != 0; iter = iter->getNextSibling())
586   {
587      if (iter->getNodeType() != xercesc::DOMNode::ELEMENT_NODE)  { continue; }
588
589      const xercesc::DOMElement* const child
590            = dynamic_cast<xercesc::DOMElement*>(iter);
591      const G4String tag = Transcode(child->getTagName());
592      if (tag=="parameterised_position_size") { ParameterisedRead(child); }else
593      if (tag=="loop") { LoopRead(child,&G4GDMLRead::Paramvol_contentRead); }
594    }
595}
596
597void G4GDMLReadParamvol::
598ParamvolRead(const xercesc::DOMElement* const element, G4LogicalVolume* mother)
599{
600   G4String volumeref;
601
602   parameterisation = new G4GDMLParameterisation();
603
604   for (xercesc::DOMNode* iter = element->getFirstChild();
605        iter != 0; iter = iter->getNextSibling())
606   {
607      if (iter->getNodeType() != xercesc::DOMNode::ELEMENT_NODE)  { continue; }
608
609      const xercesc::DOMElement* const child
610            = dynamic_cast<xercesc::DOMElement*>(iter);
611      const G4String tag = Transcode(child->getTagName());
612
613      if (tag=="volumeref") { volumeref = RefRead(child); }
614     
615   }
616
617   Paramvol_contentRead(element);
618
619   G4LogicalVolume* logvol = GetVolume(GenerateName(volumeref));
620
621   if (parameterisation->GetSize()==0)
622   {
623     G4Exception("G4GDMLReadParamvol::ParamvolRead()",
624                 "ReadError", FatalException,
625                 "No parameters are defined in parameterised volume!");
626   }
627   G4String pv_name = logvol->GetName() + "_param";
628   new G4PVParameterised(pv_name, logvol, mother, kUndefined,
629                         parameterisation->GetSize(), parameterisation, check);
630}
Note: See TracBrowser for help on using the repository browser.