source: trunk/source/persistency/gdml/src/G4GDMLReadStructure.cc @ 1355

Last change on this file since 1355 was 1347, checked in by garnier, 14 years ago

geant4 tag 9.4
File size: 30.1 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: G4GDMLReadStructure.cc,v 1.67 2010/11/02 10:39:27 gcosmo Exp $
27// GEANT4 tag $Name: gdml-V09-03-09 $
28//
29// class G4GDMLReadStructure Implementation
30//
31// Original author: Zoltan Torzsok, November 2007
32//
33// --------------------------------------------------------------------
34
35#include "G4GDMLReadStructure.hh"
36
37#include "G4LogicalVolume.hh"
38#include "G4VPhysicalVolume.hh"
39#include "G4PVPlacement.hh"
40#include "G4LogicalVolumeStore.hh"
41#include "G4PhysicalVolumeStore.hh"
42#include "G4AssemblyVolume.hh"
43#include "G4ReflectionFactory.hh"
44#include "G4PVDivisionFactory.hh"
45#include "G4LogicalBorderSurface.hh"
46#include "G4LogicalSkinSurface.hh"
47#include "G4VisAttributes.hh"
48
49G4GDMLReadStructure::G4GDMLReadStructure()
50  : G4GDMLReadParamvol(), pMotherLogical(0)
51{
52}
53
54G4GDMLReadStructure::~G4GDMLReadStructure()
55{
56}
57
58G4GDMLAuxPairType G4GDMLReadStructure::
59AuxiliaryRead(const xercesc::DOMElement* const auxiliaryElement)
60{
61   G4GDMLAuxPairType auxpair = {"",""};
62
63   const xercesc::DOMNamedNodeMap* const attributes
64         = auxiliaryElement->getAttributes();
65   XMLSize_t attributeCount = attributes->getLength();
66
67   for (XMLSize_t attribute_index=0;
68        attribute_index<attributeCount; attribute_index++)
69   {
70      xercesc::DOMNode* attribute_node = attributes->item(attribute_index);
71
72      if (attribute_node->getNodeType() != xercesc::DOMNode::ATTRIBUTE_NODE)
73        { continue; }
74
75      const xercesc::DOMAttr* const attribute
76            = dynamic_cast<xercesc::DOMAttr*>(attribute_node);   
77      if (!attribute)
78      {
79        G4Exception("G4GDMLReadStructure::AuxiliaryRead()",
80                    "InvalidRead", FatalException, "No attribute found!");
81        return auxpair;
82      }
83      const G4String attName = Transcode(attribute->getName());
84      const G4String attValue = Transcode(attribute->getValue());
85
86      if (attName=="auxtype") { auxpair.type = attValue; } else
87        //      if (attName=="auxvalue") { auxpair.value = eval.Evaluate(attValue); }
88      if (attName=="auxvalue") { auxpair.value = attValue; }
89   }
90
91   return auxpair;
92}
93
94void G4GDMLReadStructure::
95BorderSurfaceRead(const xercesc::DOMElement* const bordersurfaceElement)
96{
97   G4String name;
98   G4VPhysicalVolume* pv1 = 0;
99   G4VPhysicalVolume* pv2 = 0;
100   G4SurfaceProperty* prop = 0;
101   G4int index = 0;
102
103   const xercesc::DOMNamedNodeMap* const attributes
104         = bordersurfaceElement->getAttributes();
105   XMLSize_t attributeCount = attributes->getLength();
106
107   for (XMLSize_t attribute_index=0;
108        attribute_index<attributeCount; attribute_index++)
109   {
110      xercesc::DOMNode* attribute_node = attributes->item(attribute_index);
111
112      if (attribute_node->getNodeType() != xercesc::DOMNode::ATTRIBUTE_NODE)
113        { continue; }
114
115      const xercesc::DOMAttr* const attribute
116            = dynamic_cast<xercesc::DOMAttr*>(attribute_node);   
117      if (!attribute)
118      {
119        G4Exception("G4GDMLReadStructure::BorderSurfaceRead()",
120                    "InvalidRead", FatalException, "No attribute found!");
121        return;
122      }
123      const G4String attName = Transcode(attribute->getName());
124      const G4String attValue = Transcode(attribute->getValue());
125
126      if (attName=="name")
127        { name = GenerateName(attValue); } else
128      if (attName=="surfaceproperty")
129        { prop = GetSurfaceProperty(GenerateName(attValue)); }
130   }
131
132   for (xercesc::DOMNode* iter = bordersurfaceElement->getFirstChild();
133        iter != 0; iter = iter->getNextSibling())
134   {
135      if (iter->getNodeType() != xercesc::DOMNode::ELEMENT_NODE)  { continue; }
136
137      const xercesc::DOMElement* const child
138            = dynamic_cast<xercesc::DOMElement*>(iter);
139      if (!child)
140      {
141        G4Exception("G4GDMLReadStructure::BorderSurfaceRead()",
142                    "InvalidRead", FatalException, "No child found!");
143        return;
144      }
145      const G4String tag = Transcode(child->getTagName());
146
147      if (tag != "physvolref")  { continue; }
148 
149      if (index==0)
150        { pv1 = GetPhysvol(GenerateName(RefRead(child))); index++; } else
151      if (index==1)
152        { pv2 = GetPhysvol(GenerateName(RefRead(child))); index++; } else
153      break;
154   }
155
156   new G4LogicalBorderSurface(Strip(name),pv1,pv2,prop);
157}
158
159void G4GDMLReadStructure::
160DivisionvolRead(const xercesc::DOMElement* const divisionvolElement)
161{
162   G4String name;
163   G4double unit = 1.0;
164   G4double width = 0.0;
165   G4double offset = 0.0;
166   G4int number = 0;
167   EAxis axis = kUndefined;
168   G4LogicalVolume* logvol = 0;
169   
170   const xercesc::DOMNamedNodeMap* const attributes
171         = divisionvolElement->getAttributes();
172   XMLSize_t attributeCount = attributes->getLength();
173
174   for (XMLSize_t attribute_index=0;
175        attribute_index<attributeCount; attribute_index++)
176   {
177      xercesc::DOMNode* attribute_node = attributes->item(attribute_index);
178
179      if (attribute_node->getNodeType() != xercesc::DOMNode::ATTRIBUTE_NODE)
180        { continue; }
181
182      const xercesc::DOMAttr* const attribute
183            = dynamic_cast<xercesc::DOMAttr*>(attribute_node);   
184      if (!attribute)
185      {
186        G4Exception("G4GDMLReadStructure::DivisionvolRead()",
187                    "InvalidRead", FatalException, "No attribute found!");
188        return;
189      }
190      const G4String attName = Transcode(attribute->getName());
191      const G4String attValue = Transcode(attribute->getValue());
192
193      if (attName=="name") { name = attValue; } else
194      if (attName=="unit") { unit = eval.Evaluate(attValue); } else
195      if (attName=="width") { width = eval.Evaluate(attValue); } else
196      if (attName=="offset") { offset = eval.Evaluate(attValue); } else
197      if (attName=="number") { number = eval.EvaluateInteger(attValue); } else
198      if (attName=="axis")
199      {
200         if (attValue=="kXAxis") { axis = kXAxis; } else
201         if (attValue=="kYAxis") { axis = kYAxis; } else
202         if (attValue=="kZAxis") { axis = kZAxis; } else
203         if (attValue=="kRho") { axis = kRho; } else
204         if (attValue=="kPhi") { axis = kPhi; }
205      }
206   }
207
208   width *= unit;
209   offset *= unit;
210
211   for (xercesc::DOMNode* iter = divisionvolElement->getFirstChild();
212        iter != 0;iter = iter->getNextSibling())
213   {
214      if (iter->getNodeType() != xercesc::DOMNode::ELEMENT_NODE) { continue; }
215
216      const xercesc::DOMElement* const child
217            = dynamic_cast<xercesc::DOMElement*>(iter);
218      if (!child)
219      {
220        G4Exception("G4GDMLReadStructure::DivisionvolRead()",
221                    "InvalidRead", FatalException, "No child found!");
222        return;
223      }
224      const G4String tag = Transcode(child->getTagName());
225
226      if (tag=="volumeref") { logvol = GetVolume(GenerateName(RefRead(child))); }
227   }
228
229   if (!logvol)  { return; }
230
231   G4PVDivisionFactory::GetInstance();
232   G4PhysicalVolumesPair pair;
233
234   G4String pv_name = logvol->GetName() + "_div";
235   if ((number != 0) && (width == 0.0))
236   {
237     pair = G4ReflectionFactory::Instance()
238            ->Divide(pv_name,logvol,pMotherLogical,axis,number,offset);
239   }
240   else if ((number == 0) && (width != 0.0))
241   {
242     pair = G4ReflectionFactory::Instance()
243            ->Divide(pv_name,logvol,pMotherLogical,axis,width,offset);
244   }
245   else
246   {
247     pair = G4ReflectionFactory::Instance()
248            ->Divide(pv_name,logvol,pMotherLogical,axis,number,width,offset);
249   }
250
251   if (pair.first != 0) { GeneratePhysvolName(name,pair.first); }
252   if (pair.second != 0) { GeneratePhysvolName(name,pair.second); }
253}
254
255G4LogicalVolume* G4GDMLReadStructure::
256FileRead(const xercesc::DOMElement* const fileElement)
257{
258   G4String name;
259   G4String volname;
260
261   const xercesc::DOMNamedNodeMap* const attributes
262         = fileElement->getAttributes();
263   XMLSize_t attributeCount = attributes->getLength();
264
265   for (XMLSize_t attribute_index=0;
266        attribute_index<attributeCount; attribute_index++)
267   {
268      xercesc::DOMNode* attribute_node = attributes->item(attribute_index);
269
270      if (attribute_node->getNodeType() != xercesc::DOMNode::ATTRIBUTE_NODE)
271        { continue; }
272
273      const xercesc::DOMAttr* const attribute
274            = dynamic_cast<xercesc::DOMAttr*>(attribute_node);   
275      if (!attribute)
276      {
277        G4Exception("G4GDMLReadStructure::FileRead()",
278                    "InvalidRead", FatalException, "No attribute found!");
279        return 0;
280      }
281      const G4String attName = Transcode(attribute->getName());
282      const G4String attValue = Transcode(attribute->getValue());
283
284      if (attName=="name") { name = attValue; } else
285      if (attName=="volname") { volname = attValue; }
286   }
287
288   const G4bool isModule = true;
289   G4GDMLReadStructure structure;
290   structure.Read(name,validate,isModule);
291
292   // Register existing auxiliar information defined in child module
293   //
294   const G4GDMLAuxMapType* aux = structure.GetAuxMap();
295   if (!aux->empty())
296   {
297     G4GDMLAuxMapType::const_iterator pos;
298     for (pos = aux->begin(); pos != aux->end(); ++pos)
299     {
300       auxMap.insert(std::make_pair(pos->first,pos->second));
301     }
302   }
303
304   // Return volume structure from child module
305   //
306   if (volname.empty())
307   {
308     return structure.GetVolume(structure.GetSetup("Default"));
309   }
310   else
311   {
312     return structure.GetVolume(structure.GenerateName(volname));
313   }
314}
315
316void G4GDMLReadStructure::
317PhysvolRead(const xercesc::DOMElement* const physvolElement,
318            G4AssemblyVolume* pAssembly)
319{
320   G4String name;
321   G4LogicalVolume* logvol = 0;
322   G4AssemblyVolume* assembly = 0;
323   G4ThreeVector position(0.0,0.0,0.0);
324   G4ThreeVector rotation(0.0,0.0,0.0);
325   G4ThreeVector scale(1.0,1.0,1.0);
326
327   const xercesc::DOMNamedNodeMap* const attributes
328         = physvolElement->getAttributes();
329   XMLSize_t attributeCount = attributes->getLength();
330
331   for (XMLSize_t attribute_index=0;
332        attribute_index<attributeCount; attribute_index++)
333   {
334     xercesc::DOMNode* attribute_node = attributes->item(attribute_index);
335
336     if (attribute_node->getNodeType() != xercesc::DOMNode::ATTRIBUTE_NODE)
337       { continue; }
338
339     const xercesc::DOMAttr* const attribute
340           = dynamic_cast<xercesc::DOMAttr*>(attribute_node);   
341     if (!attribute)
342     {
343       G4Exception("G4GDMLReadStructure::PhysvolRead()",
344                   "InvalidRead", FatalException, "No attribute found!");
345       return;
346     }
347     const G4String attName = Transcode(attribute->getName());
348     const G4String attValue = Transcode(attribute->getValue());
349
350     if (attName=="name") { name = attValue; }
351   }
352
353   for (xercesc::DOMNode* iter = physvolElement->getFirstChild();
354        iter != 0; iter = iter->getNextSibling())
355   {
356     if (iter->getNodeType() != xercesc::DOMNode::ELEMENT_NODE)  { continue; }
357
358     const xercesc::DOMElement* const child
359           = dynamic_cast<xercesc::DOMElement*>(iter);
360     if (!child)
361     {
362       G4Exception("G4GDMLReadStructure::PhysvolRead()",
363                   "InvalidRead", FatalException, "No child found!");
364       return;
365     }
366     const G4String tag = Transcode(child->getTagName());
367
368     if (tag=="volumeref")
369       {
370         const G4String& child_name = GenerateName(RefRead(child));
371         assembly = GetAssembly(child_name);
372         if (!assembly) { logvol = GetVolume(child_name); }
373       }
374     else if (tag=="file")
375       { logvol = FileRead(child); }
376     else if (tag=="position")
377       { VectorRead(child,position); }
378     else if (tag=="rotation")
379       { VectorRead(child,rotation); }
380     else if (tag=="scale")
381       { VectorRead(child,scale); }
382     else if (tag=="positionref")
383       { position = GetPosition(GenerateName(RefRead(child))); }
384     else if (tag=="rotationref")
385        { rotation = GetRotation(GenerateName(RefRead(child))); }
386     else if (tag=="scaleref")
387        { scale = GetScale(GenerateName(RefRead(child))); }
388     else
389        {
390          G4String error_msg = "Unknown tag in physvol: " + tag;
391          G4Exception("G4GDMLReadStructure::PhysvolRead()", "ReadError",
392                      FatalException, error_msg);
393          return;
394        }
395   }
396
397   G4Transform3D transform(GetRotationMatrix(rotation).inverse(),position);
398   transform = transform*G4Scale3D(scale.x(),scale.y(),scale.z());
399
400   if (pAssembly)   // Fill assembly structure
401   {
402     if (!logvol) { return; }
403     pAssembly->AddPlacedVolume(logvol, transform);
404   }
405   else             // Generate physical volume tree or do assembly imprint
406   {
407     if (assembly)
408     {
409       assembly->MakeImprint(pMotherLogical, transform, 0, check);
410     }
411     else
412     {
413       if (!logvol) { return; }
414       G4String pv_name = logvol->GetName() + "_PV";
415       G4PhysicalVolumesPair pair = G4ReflectionFactory::Instance()
416         ->Place(transform,pv_name,logvol,pMotherLogical,false,0,check);
417
418       if (pair.first != 0) { GeneratePhysvolName(name,pair.first); }
419       if (pair.second != 0) { GeneratePhysvolName(name,pair.second); }
420     }
421   }
422}
423
424void G4GDMLReadStructure::
425ReplicavolRead(const xercesc::DOMElement* const replicavolElement, G4int number)
426{
427  G4LogicalVolume* logvol = 0;
428  for (xercesc::DOMNode* iter = replicavolElement->getFirstChild();
429                         iter != 0; iter = iter->getNextSibling())
430  {
431    if (iter->getNodeType() != xercesc::DOMNode::ELEMENT_NODE)  { continue; }
432
433    const xercesc::DOMElement* const child
434          = dynamic_cast<xercesc::DOMElement*>(iter);
435    if (!child)
436    {
437      G4Exception("G4GDMLReadStructure::ReplicavolRead()",
438                  "InvalidRead", FatalException, "No child found!");
439      return;
440    }
441    const G4String tag = Transcode(child->getTagName());
442
443    if (tag=="volumeref")
444    {
445      logvol = GetVolume(GenerateName(RefRead(child)));
446    }
447    else if (tag=="replicate_along_axis")
448    {
449      if (logvol)  { ReplicaRead(child,logvol,number); }
450    }
451    else
452    {
453      G4String error_msg = "Unknown tag in ReplicavolRead: " + tag;
454      G4Exception("G4GDMLReadStructure::ReplicavolRead()",
455                  "ReadError", FatalException, error_msg);
456    }
457  }
458}
459
460void G4GDMLReadStructure::
461ReplicaRead(const xercesc::DOMElement* const replicaElement,
462            G4LogicalVolume* logvol, G4int number)
463{
464   G4double width = 0.0;
465   G4double offset = 0.0;
466   G4ThreeVector position(0.0,0.0,0.0);
467   G4ThreeVector rotation(0.0,0.0,0.0);
468   EAxis axis = kUndefined;
469   G4String name;
470 
471   for (xercesc::DOMNode* iter = replicaElement->getFirstChild();
472                          iter != 0; iter = iter->getNextSibling())
473   {
474      if (iter->getNodeType() != xercesc::DOMNode::ELEMENT_NODE)  { continue; }
475
476      const xercesc::DOMElement* const child
477            = dynamic_cast<xercesc::DOMElement*>(iter);
478      if (!child)
479      {
480        G4Exception("G4GDMLReadStructure::ReplicaRead()",
481                    "InvalidRead", FatalException, "No child found!");
482        return;
483      }
484      const G4String tag = Transcode(child->getTagName()); 
485
486      if (tag=="position")
487        { VectorRead(child,position); } else
488      if (tag=="rotation")
489        { VectorRead(child,rotation); } else
490      if (tag=="positionref")
491        { position = GetPosition(GenerateName(RefRead(child))); } else
492      if (tag=="rotationref")
493        { rotation = GetRotation(GenerateName(RefRead(child))); } else
494      if (tag=="direction")
495        { axis=AxisRead(child); } else
496      if (tag=="width")
497        { width=QuantityRead(child); } else
498      if (tag=="offset")
499        { offset=QuantityRead(child); }
500      else
501      {
502        G4String error_msg = "Unknown tag in ReplicaRead: " + tag;
503        G4Exception("G4GDMLReadStructure::ReplicaRead()", "ReadError",
504                    FatalException, error_msg);
505      }
506   }
507
508   G4String pv_name = logvol->GetName() + "_PV";
509   G4PhysicalVolumesPair pair = G4ReflectionFactory::Instance()
510     ->Replicate(pv_name,logvol,pMotherLogical,axis,number,width,offset);
511
512   if (pair.first != 0) { GeneratePhysvolName(name,pair.first); }
513   if (pair.second != 0) { GeneratePhysvolName(name,pair.second); }
514
515}
516
517EAxis G4GDMLReadStructure::
518AxisRead(const xercesc::DOMElement* const axisElement)
519{
520   EAxis axis = kUndefined;
521
522   const xercesc::DOMNamedNodeMap* const attributes
523         = axisElement->getAttributes();
524   XMLSize_t attributeCount = attributes->getLength();
525
526   for (XMLSize_t attribute_index=0;
527        attribute_index<attributeCount; attribute_index++)
528   {
529      xercesc::DOMNode* attribute_node = attributes->item(attribute_index);
530
531      if (attribute_node->getNodeType() != xercesc::DOMNode::ATTRIBUTE_NODE)
532        { continue; }
533
534      const xercesc::DOMAttr* const attribute
535            = dynamic_cast<xercesc::DOMAttr*>(attribute_node);   
536      if (!attribute)
537      {
538        G4Exception("G4GDMLReadStructure::AxisRead()",
539                    "InvalidRead", FatalException, "No attribute found!");
540        return axis;
541      }
542      const G4String attName = Transcode(attribute->getName());
543      const G4String attValue = Transcode(attribute->getValue());
544      if (attName=="x")
545        { if( eval.Evaluate(attValue)==1.) {axis=kXAxis;} }
546      else if (attName=="y")
547        { if( eval.Evaluate(attValue)==1.) {axis=kYAxis;} }
548      else if (attName=="z")
549        { if( eval.Evaluate(attValue)==1.) {axis=kZAxis;} }
550      else if (attName=="rho")
551        { if( eval.Evaluate(attValue)==1.) {axis=kRho;}   }
552      else if (attName=="phi")
553        { if( eval.Evaluate(attValue)==1.) {axis=kPhi;}   }
554   }
555
556   return axis;
557}
558
559G4double G4GDMLReadStructure::
560QuantityRead(const xercesc::DOMElement* const readElement)
561{
562   G4double value = 0.0;
563   G4double unit = 0.0;
564   const xercesc::DOMNamedNodeMap* const attributes
565         = readElement->getAttributes();
566   XMLSize_t attributeCount = attributes->getLength();
567
568   for (XMLSize_t attribute_index=0;
569        attribute_index<attributeCount; attribute_index++)
570   {
571      xercesc::DOMNode* attribute_node = attributes->item(attribute_index);
572
573      if (attribute_node->getNodeType() != xercesc::DOMNode::ATTRIBUTE_NODE)
574        { continue; }
575      const xercesc::DOMAttr* const attribute
576            = dynamic_cast<xercesc::DOMAttr*>(attribute_node);   
577      if (!attribute)
578      {
579        G4Exception("G4GDMLReadStructure::QuantityRead()",
580                    "InvalidRead", FatalException, "No attribute found!");
581        return value;
582      }
583      const G4String attName = Transcode(attribute->getName());
584      const G4String attValue = Transcode(attribute->getValue());
585
586      if (attName=="unit") { unit = eval.Evaluate(attValue); } else
587      if (attName=="value"){ value= eval.Evaluate(attValue); } 
588   }
589
590   return value*unit;
591}
592
593void G4GDMLReadStructure::
594VolumeRead(const xercesc::DOMElement* const volumeElement)
595{
596   G4VSolid* solidPtr = 0;
597   G4Material* materialPtr = 0;
598   G4GDMLAuxListType auxList;
599   
600   XMLCh *name_attr = xercesc::XMLString::transcode("name");
601   const G4String name = Transcode(volumeElement->getAttribute(name_attr));
602   xercesc::XMLString::release(&name_attr);
603
604   for (xercesc::DOMNode* iter = volumeElement->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      if (!child)
612      {
613        G4Exception("G4GDMLReadStructure::VolumeRead()",
614                    "InvalidRead", FatalException, "No child found!");
615        return;
616      }
617      const G4String tag = Transcode(child->getTagName());
618
619      if (tag=="auxiliary")
620        { auxList.push_back(AuxiliaryRead(child)); } else
621      if (tag=="materialref")
622        { materialPtr = GetMaterial(GenerateName(RefRead(child),true)); } else
623      if (tag=="solidref")
624        { solidPtr = GetSolid(GenerateName(RefRead(child))); }
625   }
626
627   pMotherLogical = new G4LogicalVolume(solidPtr,materialPtr,
628                                        GenerateName(name),0,0,0);
629
630   if (!auxList.empty()) { auxMap[pMotherLogical] = auxList; }
631
632   Volume_contentRead(volumeElement);
633}
634
635void G4GDMLReadStructure::
636AssemblyRead(const xercesc::DOMElement* const assemblyElement)
637{
638   XMLCh *name_attr = xercesc::XMLString::transcode("name");
639   const G4String name = Transcode(assemblyElement->getAttribute(name_attr));
640   xercesc::XMLString::release(&name_attr);
641
642   G4AssemblyVolume* pAssembly = new G4AssemblyVolume();
643   assemblyMap.insert(std::make_pair(GenerateName(name), pAssembly));
644
645   for (xercesc::DOMNode* iter = assemblyElement->getFirstChild();
646        iter != 0; iter = iter->getNextSibling())
647   {
648      if (iter->getNodeType() != xercesc::DOMNode::ELEMENT_NODE) { continue; }
649      const xercesc::DOMElement* const child
650            = dynamic_cast<xercesc::DOMElement*>(iter);
651      if (!child)
652      {
653        G4Exception("G4GDMLReadStructure::AssemblyRead()",
654                    "InvalidRead", FatalException, "No child found!");
655        return;
656      }
657      const G4String tag = Transcode(child->getTagName());
658
659      if (tag=="physvol")
660      {
661        PhysvolRead(child, pAssembly);
662      }
663      else
664      {
665        G4cout << "Unsupported GDML tag '" << tag
666               << "' for Geant4 assembly structure !" << G4endl;
667      }
668   }
669}
670
671void G4GDMLReadStructure::
672SkinSurfaceRead(const xercesc::DOMElement* const skinsurfaceElement)
673{
674   G4String name;
675   G4LogicalVolume* logvol = 0;
676   G4SurfaceProperty* prop = 0;
677
678   const xercesc::DOMNamedNodeMap* const attributes
679         = skinsurfaceElement->getAttributes();
680   XMLSize_t attributeCount = attributes->getLength();
681
682   for (XMLSize_t attribute_index=0;
683        attribute_index<attributeCount; attribute_index++)
684   {
685      xercesc::DOMNode* attribute_node = attributes->item(attribute_index);
686
687      if (attribute_node->getNodeType() != xercesc::DOMNode::ATTRIBUTE_NODE)
688        { continue; }
689
690      const xercesc::DOMAttr* const attribute
691            = dynamic_cast<xercesc::DOMAttr*>(attribute_node);   
692      if (!attribute)
693      {
694        G4Exception("G4GDMLReadStructure::SkinsurfaceRead()",
695                    "InvalidRead", FatalException, "No attribute found!");
696        return;
697      }
698      const G4String attName = Transcode(attribute->getName());
699      const G4String attValue = Transcode(attribute->getValue());
700
701      if (attName=="name")
702        { name = GenerateName(attValue); } else
703      if (attName=="surfaceproperty")
704        { prop = GetSurfaceProperty(GenerateName(attValue)); }
705   }
706
707   for (xercesc::DOMNode* iter = skinsurfaceElement->getFirstChild();
708        iter != 0; iter = iter->getNextSibling())
709   {
710      if (iter->getNodeType() != xercesc::DOMNode::ELEMENT_NODE)  { continue; }
711
712      const xercesc::DOMElement* const child
713            = dynamic_cast<xercesc::DOMElement*>(iter);
714      if (!child)
715      {
716        G4Exception("G4GDMLReadStructure::SkinsurfaceRead()",
717                    "InvalidRead", FatalException, "No child found!");
718        return;
719      }
720      const G4String tag = Transcode(child->getTagName());
721
722      if (tag=="volumeref")
723      {
724        logvol = GetVolume(GenerateName(RefRead(child)));
725      }
726      else
727      {
728        G4String error_msg = "Unknown tag in skinsurface: " + tag;
729        G4Exception("G4GDMLReadStructure::SkinsurfaceRead()", "ReadError",
730                    FatalException, error_msg);
731      }
732   }
733
734   new G4LogicalSkinSurface(Strip(name),logvol,prop);
735}
736
737void G4GDMLReadStructure::
738Volume_contentRead(const xercesc::DOMElement* const volumeElement)
739{
740   for (xercesc::DOMNode* iter = volumeElement->getFirstChild();
741        iter != 0; iter = iter->getNextSibling())
742   {
743      if (iter->getNodeType() != xercesc::DOMNode::ELEMENT_NODE) { continue; }
744
745      const xercesc::DOMElement* const child
746            = dynamic_cast<xercesc::DOMElement*>(iter);
747      if (!child)
748      {
749        G4Exception("G4GDMLReadStructure::Volume_contentRead()",
750                    "InvalidRead", FatalException, "No child found!");
751        return;
752      }
753      const G4String tag = Transcode(child->getTagName());
754
755      if ((tag=="auxiliary") || (tag=="materialref") || (tag=="solidref"))
756      {
757        // These are already processed in VolumeRead()
758      }
759      else if (tag=="paramvol")
760      {
761        ParamvolRead(child,pMotherLogical);
762      }
763      else if (tag=="physvol")
764      {
765        PhysvolRead(child);
766      }
767      else if (tag=="replicavol")
768      {
769        G4int number = 1;
770        const xercesc::DOMNamedNodeMap* const attributes
771              = child->getAttributes();
772        XMLSize_t attributeCount = attributes->getLength();
773        for (XMLSize_t attribute_index=0;
774                       attribute_index<attributeCount; attribute_index++)
775        {
776          xercesc::DOMNode* attribute_node
777                 = attributes->item(attribute_index);
778          if (attribute_node->getNodeType()!=xercesc::DOMNode::ATTRIBUTE_NODE)
779          {
780            continue;
781          }
782          const xercesc::DOMAttr* const attribute
783                = dynamic_cast<xercesc::DOMAttr*>(attribute_node);   
784          if (!attribute)
785          {
786            G4Exception("G4GDMLReadStructure::Volume_contentRead()",
787                        "InvalidRead", FatalException, "No attribute found!");
788            return;
789          }
790          const G4String attName = Transcode(attribute->getName());
791          const G4String attValue = Transcode(attribute->getValue());
792          if (attName=="number")
793          {
794            number = eval.EvaluateInteger(attValue);
795          }
796        }
797        ReplicavolRead(child,number); 
798      }
799      else if (tag=="divisionvol")
800      {
801        DivisionvolRead(child);
802      }
803      else if (tag=="loop")
804      {
805        LoopRead(child,&G4GDMLRead::Volume_contentRead);
806      }
807      else
808      {
809        G4cout << "Treating unknown GDML tag in volume '" << tag
810               << "' as GDML extension..." << G4endl;
811      }
812   }
813}
814
815void G4GDMLReadStructure::
816StructureRead(const xercesc::DOMElement* const structureElement)
817{
818   G4cout << "G4GDML: Reading structure..." << G4endl;
819
820   for (xercesc::DOMNode* iter = structureElement->getFirstChild();
821        iter != 0; iter = iter->getNextSibling())
822   {
823      if (iter->getNodeType() != xercesc::DOMNode::ELEMENT_NODE)  { continue; }
824
825      const xercesc::DOMElement* const child
826            = dynamic_cast<xercesc::DOMElement*>(iter);
827      if (!child)
828      {
829        G4Exception("G4GDMLReadStructure::StructureRead()",
830                    "InvalidRead", FatalException, "No child found!");
831        return;
832      }
833      const G4String tag = Transcode(child->getTagName());
834
835      if (tag=="bordersurface") { BorderSurfaceRead(child); } else
836      if (tag=="skinsurface") { SkinSurfaceRead(child); } else
837      if (tag=="volume") { VolumeRead(child); } else
838      if (tag=="assembly") { AssemblyRead(child); } else
839      if (tag=="loop") { LoopRead(child,&G4GDMLRead::StructureRead); }
840      else
841      {
842        G4String error_msg = "Unknown tag in structure: " + tag;
843        G4Exception("G4GDMLReadStructure::StructureRead()",
844                    "ReadError", FatalException, error_msg);
845      }
846   }
847}
848
849G4VPhysicalVolume* G4GDMLReadStructure::
850GetPhysvol(const G4String& ref) const
851{
852   G4VPhysicalVolume* physvolPtr =
853     G4PhysicalVolumeStore::GetInstance()->GetVolume(ref,false);
854
855   if (!physvolPtr)
856   {
857     G4String error_msg = "Referenced physvol '" + ref + "' was not found!";
858     G4Exception("G4GDMLReadStructure::GetPhysvol()", "ReadError",
859                 FatalException, error_msg);
860   }
861
862   return physvolPtr;
863}
864
865G4LogicalVolume* G4GDMLReadStructure::
866GetVolume(const G4String& ref) const
867{
868   G4LogicalVolume *volumePtr
869   = G4LogicalVolumeStore::GetInstance()->GetVolume(ref,false);
870
871   if (!volumePtr)
872   {
873     G4String error_msg = "Referenced volume '" + ref + "' was not found!";
874     G4Exception("G4GDMLReadStructure::GetVolume()", "ReadError",
875                 FatalException, error_msg);
876   }
877
878   return volumePtr;
879}
880
881G4AssemblyVolume* G4GDMLReadStructure::
882GetAssembly(const G4String& ref) const
883{
884   G4GDMLAssemblyMapType::const_iterator pos = assemblyMap.find(ref);
885   if (pos != assemblyMap.end()) { return pos->second; }
886   return 0;
887}
888
889G4GDMLAuxListType G4GDMLReadStructure::
890GetVolumeAuxiliaryInformation(G4LogicalVolume* logvol) const
891{
892   G4GDMLAuxMapType::const_iterator pos = auxMap.find(logvol);
893   if (pos != auxMap.end()) { return pos->second; }
894   else { return G4GDMLAuxListType(); }
895}
896
897const G4GDMLAuxMapType* G4GDMLReadStructure::
898GetAuxMap() const
899{
900   return &auxMap;
901}
902
903G4VPhysicalVolume* G4GDMLReadStructure::
904GetWorldVolume(const G4String& setupName)
905{   
906   G4LogicalVolume* volume = GetVolume(Strip(GetSetup(setupName)));
907   volume->SetVisAttributes(G4VisAttributes::Invisible);
908
909   G4VPhysicalVolume* pvWorld = 0;
910
911   if(setuptoPV[setupName])
912   {
913     pvWorld = setuptoPV[setupName];
914   }
915   else
916   {
917     pvWorld = new G4PVPlacement(0,G4ThreeVector(0,0,0),volume,
918                                 volume->GetName()+"_PV",0,0,0);
919     setuptoPV[setupName] = pvWorld;
920   }
921   return pvWorld;
922}
923
924void G4GDMLReadStructure::Clear()
925{
926  eval.Clear();
927  setuptoPV.clear();
928}
Note: See TracBrowser for help on using the repository browser.