Geant4 Cross Reference

Cross-Referencing   Geant4
Geant4/persistency/gdml/src/G4GDMLReadMaterials.cc

Version: [ ReleaseNotes ] [ 1.0 ] [ 1.1 ] [ 2.0 ] [ 3.0 ] [ 3.1 ] [ 3.2 ] [ 4.0 ] [ 4.0.p1 ] [ 4.0.p2 ] [ 4.1 ] [ 4.1.p1 ] [ 5.0 ] [ 5.0.p1 ] [ 5.1 ] [ 5.1.p1 ] [ 5.2 ] [ 5.2.p1 ] [ 5.2.p2 ] [ 6.0 ] [ 6.0.p1 ] [ 6.1 ] [ 6.2 ] [ 6.2.p1 ] [ 6.2.p2 ] [ 7.0 ] [ 7.0.p1 ] [ 7.1 ] [ 7.1.p1 ] [ 8.0 ] [ 8.0.p1 ] [ 8.1 ] [ 8.1.p1 ] [ 8.1.p2 ] [ 8.2 ] [ 8.2.p1 ] [ 8.3 ] [ 8.3.p1 ] [ 8.3.p2 ] [ 9.0 ] [ 9.0.p1 ] [ 9.0.p2 ] [ 9.1 ] [ 9.1.p1 ] [ 9.1.p2 ] [ 9.1.p3 ] [ 9.2 ] [ 9.2.p1 ] [ 9.2.p2 ] [ 9.2.p3 ] [ 9.2.p4 ] [ 9.3 ] [ 9.3.p1 ] [ 9.3.p2 ] [ 9.4 ] [ 9.4.p1 ] [ 9.4.p2 ] [ 9.4.p3 ] [ 9.4.p4 ] [ 9.5 ] [ 9.5.p1 ] [ 9.5.p2 ] [ 9.6 ] [ 9.6.p1 ] [ 9.6.p2 ] [ 9.6.p3 ] [ 9.6.p4 ] [ 10.0 ] [ 10.0.p1 ] [ 10.0.p2 ] [ 10.0.p3 ] [ 10.0.p4 ] [ 10.1 ] [ 10.1.p1 ] [ 10.1.p2 ] [ 10.1.p3 ] [ 10.2 ] [ 10.2.p1 ] [ 10.2.p2 ] [ 10.2.p3 ] [ 10.3 ] [ 10.3.p1 ] [ 10.3.p2 ] [ 10.3.p3 ] [ 10.4 ] [ 10.4.p1 ] [ 10.4.p2 ] [ 10.4.p3 ] [ 10.5 ] [ 10.5.p1 ] [ 10.6 ] [ 10.6.p1 ] [ 10.6.p2 ] [ 10.6.p3 ] [ 10.7 ] [ 10.7.p1 ] [ 10.7.p2 ] [ 10.7.p3 ] [ 10.7.p4 ] [ 11.0 ] [ 11.0.p1 ] [ 11.0.p2 ] [ 11.0.p3, ] [ 11.0.p4 ] [ 11.1 ] [ 11.1.1 ] [ 11.1.2 ] [ 11.1.3 ] [ 11.2 ] [ 11.2.1 ] [ 11.2.2 ] [ 11.3.0 ]

Diff markup

Differences between /persistency/gdml/src/G4GDMLReadMaterials.cc (Version 11.3.0) and /persistency/gdml/src/G4GDMLReadMaterials.cc (Version 10.6)


  1 //                                                  1 //
  2 // *******************************************      2 // ********************************************************************
  3 // * License and Disclaimer                         3 // * License and Disclaimer                                           *
  4 // *                                                4 // *                                                                  *
  5 // * The  Geant4 software  is  copyright of th      5 // * The  Geant4 software  is  copyright of the Copyright Holders  of *
  6 // * the Geant4 Collaboration.  It is provided      6 // * the Geant4 Collaboration.  It is provided  under  the terms  and *
  7 // * conditions of the Geant4 Software License      7 // * conditions of the Geant4 Software License,  included in the file *
  8 // * LICENSE and available at  http://cern.ch/      8 // * LICENSE and available at  http://cern.ch/geant4/license .  These *
  9 // * include a list of copyright holders.           9 // * include a list of copyright holders.                             *
 10 // *                                               10 // *                                                                  *
 11 // * Neither the authors of this software syst     11 // * Neither the authors of this software system, nor their employing *
 12 // * institutes,nor the agencies providing fin     12 // * institutes,nor the agencies providing financial support for this *
 13 // * work  make  any representation or  warran     13 // * work  make  any representation or  warranty, express or implied, *
 14 // * regarding  this  software system or assum     14 // * regarding  this  software system or assume any liability for its *
 15 // * use.  Please see the license in the file      15 // * use.  Please see the license in the file  LICENSE  and URL above *
 16 // * for the full disclaimer and the limitatio     16 // * for the full disclaimer and the limitation of liability.         *
 17 // *                                               17 // *                                                                  *
 18 // * This  code  implementation is the result      18 // * This  code  implementation is the result of  the  scientific and *
 19 // * technical work of the GEANT4 collaboratio     19 // * technical work of the GEANT4 collaboration.                      *
 20 // * By using,  copying,  modifying or  distri     20 // * By using,  copying,  modifying or  distributing the software (or *
 21 // * any work based  on the software)  you  ag     21 // * any work based  on the software)  you  agree  to acknowledge its *
 22 // * use  in  resulting  scientific  publicati     22 // * use  in  resulting  scientific  publications,  and indicate your *
 23 // * acceptance of all terms of the Geant4 Sof     23 // * acceptance of all terms of the Geant4 Software license.          *
 24 // *******************************************     24 // ********************************************************************
 25 //                                                 25 //
 26 // G4GDMLReadMaterials implementation          << 
 27 //                                                 26 //
 28 // Author: Zoltan Torzsok, November 2007       <<  27 // GEANT4 tag $ Name:$
                                                   >>  28 //
                                                   >>  29 // class G4GDMLReadMaterials Implementation
                                                   >>  30 //
                                                   >>  31 // Original author: Zoltan Torzsok, November 2007
                                                   >>  32 //
 29 // -------------------------------------------     33 // --------------------------------------------------------------------
 30                                                    34 
 31 #include "G4GDMLReadMaterials.hh"                  35 #include "G4GDMLReadMaterials.hh"
 32                                                    36 
 33 #include "G4PhysicalConstants.hh"                  37 #include "G4PhysicalConstants.hh"
 34 #include "G4SystemOfUnits.hh"                      38 #include "G4SystemOfUnits.hh"
 35 #include "G4UnitsTable.hh"                         39 #include "G4UnitsTable.hh"
 36 #include "G4Element.hh"                            40 #include "G4Element.hh"
 37 #include "G4Isotope.hh"                            41 #include "G4Isotope.hh"
 38 #include "G4Material.hh"                           42 #include "G4Material.hh"
 39 #include "G4NistManager.hh"                        43 #include "G4NistManager.hh"
 40                                                    44 
 41 // ------------------------------------------- <<  45 G4GDMLReadMaterials::G4GDMLReadMaterials() : G4GDMLReadDefine()
 42 G4GDMLReadMaterials::G4GDMLReadMaterials()     << 
 43   : G4GDMLReadDefine()                         << 
 44 {                                                  46 {
 45 }                                                  47 }
 46                                                    48 
 47 // ------------------------------------------- << 
 48 G4GDMLReadMaterials::~G4GDMLReadMaterials()        49 G4GDMLReadMaterials::~G4GDMLReadMaterials()
 49 {                                                  50 {
 50 }                                                  51 }
 51                                                    52 
 52 // ------------------------------------------- <<  53 G4double
 53 G4double G4GDMLReadMaterials::AtomRead(        <<  54 G4GDMLReadMaterials::AtomRead(const xercesc::DOMElement* const atomElement)
 54   const xercesc::DOMElement* const atomElement << 
 55 {                                                  55 {
 56   G4double value = 0.0;                        <<  56    G4double value = 0.0;
 57   G4double unit  = g / mole;                   <<  57    G4double unit = g/mole;
 58                                                    58 
 59   const xercesc::DOMNamedNodeMap* const attrib <<  59    const xercesc::DOMNamedNodeMap* const attributes
 60     atomElement->getAttributes();              <<  60          = atomElement->getAttributes();
 61   XMLSize_t attributeCount = attributes->getLe <<  61    XMLSize_t attributeCount = attributes->getLength();
 62                                                <<  62 
 63   for(XMLSize_t attribute_index = 0; attribute <<  63    for (XMLSize_t attribute_index=0;
 64       ++attribute_index)                       <<  64         attribute_index<attributeCount; attribute_index++)
 65   {                                            <<  65    {
 66     xercesc::DOMNode* attribute_node = attribu <<  66       xercesc::DOMNode* attribute_node = attributes->item(attribute_index);
 67                                                <<  67 
 68     if(attribute_node->getNodeType() != xerces <<  68       if (attribute_node->getNodeType() != xercesc::DOMNode::ATTRIBUTE_NODE)
 69     {                                          <<  69       { continue; }
 70       continue;                                <<  70 
 71     }                                          <<  71       const xercesc::DOMAttr* const attribute
 72                                                <<  72             = dynamic_cast<xercesc::DOMAttr*>(attribute_node);   
 73     const xercesc::DOMAttr* const attribute =  <<  73       if (!attribute)
 74       dynamic_cast<xercesc::DOMAttr*>(attribut << 
 75     if(attribute == nullptr)                   << 
 76     {                                          << 
 77       G4Exception("G4GDMLReadMaterials::AtomRe << 
 78                   FatalException, "No attribut << 
 79       return value;                            << 
 80     }                                          << 
 81     const G4String attName  = Transcode(attrib << 
 82     const G4String attValue = Transcode(attrib << 
 83                                                << 
 84     if(attName == "value")                     << 
 85     {                                          << 
 86       value = eval.Evaluate(attValue);         << 
 87     }                                          << 
 88     else if(attName == "unit")                 << 
 89     {                                          << 
 90       unit = G4UnitDefinition::GetValueOf(attV << 
 91       if(G4UnitDefinition::GetCategory(attValu << 
 92       {                                            74       {
 93         G4Exception("G4GDMLReadMaterials::Atom     75         G4Exception("G4GDMLReadMaterials::AtomRead()", "InvalidRead",
 94                     FatalException, "Invalid u <<  76                     FatalException, "No attribute found!");
                                                   >>  77         return value;
 95       }                                            78       }
 96     }                                          <<  79       const G4String attName = Transcode(attribute->getName());
 97   }                                            <<  80       const G4String attValue = Transcode(attribute->getValue());
 98                                                    81 
 99   return value * unit;                         <<  82       if (attName=="value") { value = eval.Evaluate(attValue); } else
                                                   >>  83   if (attName=="unit")  {unit = G4UnitDefinition::GetValueOf(attValue);
                                                   >>  84     if (G4UnitDefinition::GetCategory(attValue)!="Molar mass") {
                                                   >>  85       G4Exception("G4GDMLReadMaterials::AtomRead()", "InvalidRead",
                                                   >>  86       FatalException, "Invalid unit for atomic mass!");  }
                                                   >>  87   }
                                                   >>  88    }
                                                   >>  89 
                                                   >>  90    return value*unit;
100 }                                                  91 }
101                                                    92 
102 // ------------------------------------------- <<  93 G4int G4GDMLReadMaterials::
103 G4int G4GDMLReadMaterials::CompositeRead(      <<  94 CompositeRead(const xercesc::DOMElement* const compositeElement,G4String& ref)
104   const xercesc::DOMElement* const compositeEl << 
105 {                                                  95 {
106   G4int n = 0;                                 <<  96    G4int n = 0;
107                                                    97 
108   const xercesc::DOMNamedNodeMap* const attrib <<  98    const xercesc::DOMNamedNodeMap* const attributes
109     compositeElement->getAttributes();         <<  99          = compositeElement->getAttributes();
110   XMLSize_t attributeCount = attributes->getLe << 100    XMLSize_t attributeCount = attributes->getLength();
111                                                << 
112   for(XMLSize_t attribute_index = 0; attribute << 
113       ++attribute_index)                       << 
114   {                                            << 
115     xercesc::DOMNode* attribute_node = attribu << 
116                                                << 
117     if(attribute_node->getNodeType() != xerces << 
118     {                                          << 
119       continue;                                << 
120     }                                          << 
121                                                << 
122     const xercesc::DOMAttr* const attribute =  << 
123       dynamic_cast<xercesc::DOMAttr*>(attribut << 
124     if(attribute == nullptr)                   << 
125     {                                          << 
126       G4Exception("G4GDMLReadMaterials::Compos << 
127                   FatalException, "No attribut << 
128       return n;                                << 
129     }                                          << 
130     const G4String attName  = Transcode(attrib << 
131     const G4String attValue = Transcode(attrib << 
132                                                << 
133     if(attName == "n")                         << 
134     {                                          << 
135       n = eval.EvaluateInteger(attValue);      << 
136     }                                          << 
137     else if(attName == "ref")                  << 
138     {                                          << 
139       ref = attValue;                          << 
140     }                                          << 
141   }                                            << 
142                                                   101 
143   return n;                                    << 102    for (XMLSize_t attribute_index=0;
                                                   >> 103         attribute_index<attributeCount; attribute_index++)
                                                   >> 104    {
                                                   >> 105       xercesc::DOMNode* attribute_node = attributes->item(attribute_index);
                                                   >> 106 
                                                   >> 107       if (attribute_node->getNodeType() != xercesc::DOMNode::ATTRIBUTE_NODE)
                                                   >> 108       { continue; }
                                                   >> 109 
                                                   >> 110       const xercesc::DOMAttr* const attribute
                                                   >> 111             = dynamic_cast<xercesc::DOMAttr*>(attribute_node);   
                                                   >> 112       if (!attribute)
                                                   >> 113       {
                                                   >> 114         G4Exception("G4GDMLReadMaterials::CompositeRead()", "InvalidRead",
                                                   >> 115                     FatalException, "No attribute found!");
                                                   >> 116         return n;
                                                   >> 117       }
                                                   >> 118       const G4String attName = Transcode(attribute->getName());
                                                   >> 119       const G4String attValue = Transcode(attribute->getValue());
                                                   >> 120 
                                                   >> 121       if (attName=="n")  { n = eval.EvaluateInteger(attValue); } else
                                                   >> 122       if (attName=="ref") { ref = attValue; }
                                                   >> 123    }
                                                   >> 124 
                                                   >> 125    return n;
144 }                                                 126 }
145                                                   127 
146 // ------------------------------------------- << 
147 G4double G4GDMLReadMaterials::DRead(const xerc    128 G4double G4GDMLReadMaterials::DRead(const xercesc::DOMElement* const DElement)
148 {                                                 129 {
149   G4double value = 0.0;                        << 130    G4double value = 0.0;
150   G4double unit  = g / cm3;                    << 131    G4double unit = g/cm3;
151                                                   132 
152   const xercesc::DOMNamedNodeMap* const attrib << 133    const xercesc::DOMNamedNodeMap* const attributes
153   XMLSize_t attributeCount                     << 134          = DElement->getAttributes();
154                                                << 135    XMLSize_t attributeCount = attributes->getLength();
155   for(XMLSize_t attribute_index = 0; attribute << 136 
156       ++attribute_index)                       << 137    for (XMLSize_t attribute_index=0;
157   {                                            << 138         attribute_index<attributeCount; attribute_index++)
158     xercesc::DOMNode* attribute_node = attribu << 139    {
159                                                << 140       xercesc::DOMNode* attribute_node = attributes->item(attribute_index);
160     if(attribute_node->getNodeType() != xerces << 141 
161     {                                          << 142       if (attribute_node->getNodeType() != xercesc::DOMNode::ATTRIBUTE_NODE)
162       continue;                                << 143       { continue; }
163     }                                          << 144 
164                                                << 145       const xercesc::DOMAttr* const attribute
165     const xercesc::DOMAttr* const attribute =  << 146             = dynamic_cast<xercesc::DOMAttr*>(attribute_node);   
166       dynamic_cast<xercesc::DOMAttr*>(attribut << 147       if (!attribute)
167     if(attribute == nullptr)                   << 
168     {                                          << 
169       G4Exception("G4GDMLReadMaterials::DRead( << 
170                   "No attribute found!");      << 
171       return value;                            << 
172     }                                          << 
173     const G4String attName  = Transcode(attrib << 
174     const G4String attValue = Transcode(attrib << 
175                                                << 
176     if(attName == "value")                     << 
177     {                                          << 
178       value = eval.Evaluate(attValue);         << 
179     }                                          << 
180     else if(attName == "unit")                 << 
181     {                                          << 
182       unit = G4UnitDefinition::GetValueOf(attV << 
183       if(G4UnitDefinition::GetCategory(attValu << 
184       {                                           148       {
185         G4Exception("G4GDMLReadMaterials::DRea    149         G4Exception("G4GDMLReadMaterials::DRead()", "InvalidRead",
186                     FatalException, "Invalid u << 150                     FatalException, "No attribute found!");
                                                   >> 151         return value;
187       }                                           152       }
188     }                                          << 153       const G4String attName = Transcode(attribute->getName());
189   }                                            << 154       const G4String attValue = Transcode(attribute->getValue());
                                                   >> 155 
                                                   >> 156       if (attName=="value") { value = eval.Evaluate(attValue); } else
                                                   >> 157   if (attName=="unit")  {
                                                   >> 158     unit = G4UnitDefinition::GetValueOf(attValue);
                                                   >> 159     if (G4UnitDefinition::GetCategory(attValue)!="Volumic Mass") {
                                                   >> 160       G4Exception("G4GDMLReadMaterials::DRead()", "InvalidRead",
                                                   >> 161       FatalException, "Invalid unit for density!");  }
                                                   >> 162   }  
                                                   >> 163    }
190                                                   164 
191   return value * unit;                         << 165    return value*unit;
192 }                                                 166 }
193                                                   167 
194 // ------------------------------------------- << 
195 G4double G4GDMLReadMaterials::PRead(const xerc    168 G4double G4GDMLReadMaterials::PRead(const xercesc::DOMElement* const PElement)
196 {                                                 169 {
197   G4double value = STP_Pressure;               << 170    G4double value = STP_Pressure;
198   G4double unit  = hep_pascal;                 << 171    G4double unit = hep_pascal;
199                                                   172 
200   const xercesc::DOMNamedNodeMap* const attrib << 173    const xercesc::DOMNamedNodeMap* const attributes = PElement->getAttributes();
201   XMLSize_t attributeCount                     << 174    XMLSize_t attributeCount = attributes->getLength();
202                                                   175 
203   for(XMLSize_t attribute_index = 0; attribute << 176    for (XMLSize_t attribute_index=0;
204       ++attribute_index)                       << 177         attribute_index<attributeCount; attribute_index++)
205   {                                            << 178    {
206     xercesc::DOMNode* attribute_node = attribu << 179       xercesc::DOMNode* attribute_node = attributes->item(attribute_index);
207                                                << 180 
208     if(attribute_node->getNodeType() != xerces << 181       if (attribute_node->getNodeType() != xercesc::DOMNode::ATTRIBUTE_NODE)
209     {                                          << 182       { continue; }
210       continue;                                << 183 
211     }                                          << 184       const xercesc::DOMAttr* const attribute
212                                                << 185             = dynamic_cast<xercesc::DOMAttr*>(attribute_node);   
213     const xercesc::DOMAttr* const attribute =  << 186       if (!attribute)
214       dynamic_cast<xercesc::DOMAttr*>(attribut << 
215     if(attribute == nullptr)                   << 
216     {                                          << 
217       G4Exception("G4GDMLReadMaterials::PRead( << 
218                   "No attribute found!");      << 
219       return value;                            << 
220     }                                          << 
221     const G4String attName  = Transcode(attrib << 
222     const G4String attValue = Transcode(attrib << 
223                                                << 
224     if(attName == "value")                     << 
225     {                                          << 
226       value = eval.Evaluate(attValue);         << 
227     }                                          << 
228     else if(attName == "unit")                 << 
229     {                                          << 
230       unit = G4UnitDefinition::GetValueOf(attV << 
231       if(G4UnitDefinition::GetCategory(attValu << 
232       {                                           187       {
233         G4Exception("G4GDMLReadMaterials::PRea    188         G4Exception("G4GDMLReadMaterials::PRead()", "InvalidRead",
234                     FatalException, "Invalid u << 189                     FatalException, "No attribute found!");
                                                   >> 190         return value;
235       }                                           191       }
236     }                                          << 192       const G4String attName = Transcode(attribute->getName());
237   }                                            << 193       const G4String attValue = Transcode(attribute->getValue());
                                                   >> 194 
                                                   >> 195       if (attName=="value") { value = eval.Evaluate(attValue); } else
                                                   >> 196   if (attName=="unit")  { unit = G4UnitDefinition::GetValueOf(attValue);
                                                   >> 197     if (G4UnitDefinition::GetCategory(attValue)!="Pressure") {
                                                   >> 198       G4Exception("G4GDMLReadMaterials::PRead()", "InvalidRead",
                                                   >> 199       FatalException, "Invalid unit for pressure!");  }
                                                   >> 200   }
                                                   >> 201    }
238                                                   202 
239   return value * unit;                         << 203    return value*unit;
240 }                                                 204 }
241                                                   205 
242 // ------------------------------------------- << 
243 G4double G4GDMLReadMaterials::TRead(const xerc    206 G4double G4GDMLReadMaterials::TRead(const xercesc::DOMElement* const TElement)
244 {                                                 207 {
245   G4double value = NTP_Temperature;            << 208    G4double value = STP_Temperature;
246   G4double unit  = kelvin;                     << 209    G4double unit = kelvin;
247                                                   210 
248   const xercesc::DOMNamedNodeMap* const attrib << 211    const xercesc::DOMNamedNodeMap* const attributes = TElement->getAttributes();
249   XMLSize_t attributeCount                     << 212    XMLSize_t attributeCount = attributes->getLength();
250                                                   213 
251   for(XMLSize_t attribute_index = 0; attribute << 214    for (XMLSize_t attribute_index=0;
252       ++attribute_index)                       << 215         attribute_index<attributeCount; attribute_index++)
253   {                                            << 216    {
254     xercesc::DOMNode* attribute_node = attribu << 217       xercesc::DOMNode* attribute_node = attributes->item(attribute_index);
255                                                << 218 
256     if(attribute_node->getNodeType() != xerces << 219       if (attribute_node->getNodeType() != xercesc::DOMNode::ATTRIBUTE_NODE)
257     {                                          << 220       { continue; }
258       continue;                                << 221 
259     }                                          << 222       const xercesc::DOMAttr* const attribute
260                                                << 223             = dynamic_cast<xercesc::DOMAttr*>(attribute_node);   
261     const xercesc::DOMAttr* const attribute =  << 224       if (!attribute)
262       dynamic_cast<xercesc::DOMAttr*>(attribut << 
263     if(attribute == nullptr)                   << 
264     {                                          << 
265       G4Exception("G4GDMLReadMaterials::TRead( << 
266                   "No attribute found!");      << 
267       return value;                            << 
268     }                                          << 
269     const G4String attName  = Transcode(attrib << 
270     const G4String attValue = Transcode(attrib << 
271                                                << 
272     if(attName == "value")                     << 
273     {                                          << 
274       value = eval.Evaluate(attValue);         << 
275     }                                          << 
276     else if(attName == "unit")                 << 
277     {                                          << 
278       unit = G4UnitDefinition::GetValueOf(attV << 
279       if(G4UnitDefinition::GetCategory(attValu << 
280       {                                           225       {
281         G4Exception("G4GDMLReadMaterials::TRea    226         G4Exception("G4GDMLReadMaterials::TRead()", "InvalidRead",
282                     FatalException, "Invalid u << 227                     FatalException, "No attribute found!");
                                                   >> 228         return value;
283       }                                           229       }
284     }                                          << 230       const G4String attName = Transcode(attribute->getName());
285   }                                            << 231       const G4String attValue = Transcode(attribute->getValue());
                                                   >> 232 
                                                   >> 233       if (attName=="value") { value = eval.Evaluate(attValue); } else
                                                   >> 234   if (attName=="unit")  { unit = G4UnitDefinition::GetValueOf(attValue);
                                                   >> 235     if (G4UnitDefinition::GetCategory(attValue)!="Temperature") {
                                                   >> 236       G4Exception("G4GDMLReadMaterials::TRead()", "InvalidRead",
                                                   >> 237       FatalException, "Invalid unit for temperature!");  } 
                                                   >> 238   }
                                                   >> 239    }
286                                                   240 
287   return value * unit;                         << 241    return value*unit;
288 }                                                 242 }
289                                                   243 
290 // ------------------------------------------- << 
291 G4double G4GDMLReadMaterials::MEERead(const xe    244 G4double G4GDMLReadMaterials::MEERead(const xercesc::DOMElement* const PElement)
292 {                                                 245 {
293   G4double value = -1;                         << 246    G4double value = -1;
294   G4double unit  = eV;                         << 247    G4double unit = eV;
295                                                   248 
296   const xercesc::DOMNamedNodeMap* const attrib << 249    const xercesc::DOMNamedNodeMap* const attributes = PElement->getAttributes();
297   XMLSize_t attributeCount                     << 250    XMLSize_t attributeCount = attributes->getLength();
298                                                   251 
299   for(XMLSize_t attribute_index = 0; attribute << 252    for (XMLSize_t attribute_index=0;
300       ++attribute_index)                       << 253         attribute_index<attributeCount; attribute_index++)
301   {                                            << 254    {
302     xercesc::DOMNode* attribute_node = attribu << 255       xercesc::DOMNode* attribute_node = attributes->item(attribute_index);
303                                                << 256 
304     if(attribute_node->getNodeType() != xerces << 257       if (attribute_node->getNodeType() != xercesc::DOMNode::ATTRIBUTE_NODE)
305     {                                          << 258       { continue; }
306       continue;                                << 259 
307     }                                          << 260       const xercesc::DOMAttr* const attribute
308                                                << 261             = dynamic_cast<xercesc::DOMAttr*>(attribute_node);
309     const xercesc::DOMAttr* const attribute =  << 262       if (!attribute)
310       dynamic_cast<xercesc::DOMAttr*>(attribut << 
311     if(attribute == nullptr)                   << 
312     {                                          << 
313       G4Exception("G4GDMLReadMaterials::MEERea << 
314                   FatalException, "No attribut << 
315       return value;                            << 
316     }                                          << 
317     const G4String attName  = Transcode(attrib << 
318     const G4String attValue = Transcode(attrib << 
319                                                << 
320     if(attName == "value")                     << 
321     {                                          << 
322       value = eval.Evaluate(attValue);         << 
323     }                                          << 
324     else if(attName == "unit")                 << 
325     {                                          << 
326       unit = G4UnitDefinition::GetValueOf(attV << 
327       if(G4UnitDefinition::GetCategory(attValu << 
328       {                                           263       {
329         G4Exception("G4GDMLReadMaterials::MEER    264         G4Exception("G4GDMLReadMaterials::MEERead()", "InvalidRead",
330                     FatalException, "Invalid u << 265                     FatalException, "No attribute found!");
                                                   >> 266         return value;
331       }                                           267       }
332     }                                          << 268       const G4String attName = Transcode(attribute->getName());
333   }                                            << 269       const G4String attValue = Transcode(attribute->getValue());
334                                                   270 
335   return value * unit;                         << 271       if (attName=="value") { value = eval.Evaluate(attValue); } else
336 }                                              << 272   if (attName=="unit")  { unit = G4UnitDefinition::GetValueOf(attValue);
                                                   >> 273     if (G4UnitDefinition::GetCategory(attValue)!="Energy") {
                                                   >> 274       G4Exception("G4GDMLReadMaterials::MEERead()", "InvalidRead",
                                                   >> 275       FatalException, "Invalid unit for energy!");  }
                                                   >> 276   }
                                                   >> 277    }
337                                                   278 
338 // ------------------------------------------- << 279    return value*unit;
339 void G4GDMLReadMaterials::ElementRead(         << 
340   const xercesc::DOMElement* const elementElem << 
341 {                                              << 
342   G4String name;                               << 
343   G4String formula;                            << 
344   G4double a = 0.0;                            << 
345   G4double Z = 0.0;                            << 
346                                                << 
347   const xercesc::DOMNamedNodeMap* const attrib << 
348     elementElement->getAttributes();           << 
349   XMLSize_t attributeCount = attributes->getLe << 
350                                                << 
351   for(XMLSize_t attribute_index = 0; attribute << 
352       ++attribute_index)                       << 
353   {                                            << 
354     xercesc::DOMNode* attribute_node = attribu << 
355                                                << 
356     if(attribute_node->getNodeType() != xerces << 
357     {                                          << 
358       continue;                                << 
359     }                                          << 
360                                                << 
361     const xercesc::DOMAttr* const attribute =  << 
362       dynamic_cast<xercesc::DOMAttr*>(attribut << 
363     if(attribute == nullptr)                   << 
364     {                                          << 
365       G4Exception("G4GDMLReadMaterials::Elemen << 
366                   FatalException, "No attribut << 
367       return;                                  << 
368     }                                          << 
369     const G4String attName  = Transcode(attrib << 
370     const G4String attValue = Transcode(attrib << 
371                                                << 
372     if(attName == "name")                      << 
373     {                                          << 
374       name = GenerateName(attValue);           << 
375     }                                          << 
376     else if(attName == "formula")              << 
377     {                                          << 
378       formula = attValue;                      << 
379     }                                          << 
380     else if(attName == "Z")                    << 
381     {                                          << 
382       Z = eval.Evaluate(attValue);             << 
383     }                                          << 
384   }                                            << 
385                                                << 
386   G4int nComponents = 0;                       << 
387                                                << 
388   for(xercesc::DOMNode* iter = elementElement- << 
389       iter                   = iter->getNextSi << 
390   {                                            << 
391     if(iter->getNodeType() != xercesc::DOMNode << 
392     {                                          << 
393       continue;                                << 
394     }                                          << 
395                                                << 
396     const xercesc::DOMElement* const child =   << 
397       dynamic_cast<xercesc::DOMElement*>(iter) << 
398     if(child == nullptr)                       << 
399     {                                          << 
400       G4Exception("G4GDMLReadMaterials::Elemen << 
401                   FatalException, "No child fo << 
402       return;                                  << 
403     }                                          << 
404     const G4String tag = Transcode(child->getT << 
405                                                << 
406     if(tag == "atom")                          << 
407     {                                          << 
408       a = AtomRead(child);                     << 
409     }                                          << 
410     else if(tag == "fraction")                 << 
411     {                                          << 
412       nComponents++;                           << 
413     }                                          << 
414   }                                            << 
415                                                << 
416   if(nComponents > 0)                          << 
417   {                                            << 
418     MixtureRead(elementElement,                << 
419                 new G4Element(Strip(name), for << 
420   }                                            << 
421   else                                         << 
422   {                                            << 
423     new G4Element(Strip(name), formula, Z, a); << 
424   }                                            << 
425 }                                                 280 }
426                                                   281 
427 // ------------------------------------------- << 282 void G4GDMLReadMaterials::
428 G4double G4GDMLReadMaterials::FractionRead(    << 283 ElementRead(const xercesc::DOMElement* const elementElement) 
429   const xercesc::DOMElement* const fractionEle << 
430 {                                                 284 {
431   G4double n = 0.0;                            << 285    G4String name;
                                                   >> 286    G4String formula;
                                                   >> 287    G4double a = 0.0;
                                                   >> 288    G4double Z = 0.0;
                                                   >> 289 
                                                   >> 290    const xercesc::DOMNamedNodeMap* const attributes
                                                   >> 291          = elementElement->getAttributes();
                                                   >> 292    XMLSize_t attributeCount = attributes->getLength();
                                                   >> 293 
                                                   >> 294    for (XMLSize_t attribute_index=0;
                                                   >> 295         attribute_index<attributeCount; attribute_index++)
                                                   >> 296    {
                                                   >> 297       xercesc::DOMNode* attribute_node = attributes->item(attribute_index);
                                                   >> 298 
                                                   >> 299       if (attribute_node->getNodeType() != xercesc::DOMNode::ATTRIBUTE_NODE)
                                                   >> 300       { continue; }
432                                                   301 
433   const xercesc::DOMNamedNodeMap* const attrib << 302       const xercesc::DOMAttr* const attribute
434     fractionElement->getAttributes();          << 303             = dynamic_cast<xercesc::DOMAttr*>(attribute_node);   
435   XMLSize_t attributeCount = attributes->getLe << 304       if (!attribute)
436                                                << 305       {
437   for(XMLSize_t attribute_index = 0; attribute << 306         G4Exception("G4GDMLReadMaterials::ElementRead()", "InvalidRead",
438       ++attribute_index)                       << 307                     FatalException, "No attribute found!");
439   {                                            << 308         return;
440     xercesc::DOMNode* attribute_node = attribu << 309       }
441                                                << 310       const G4String attName = Transcode(attribute->getName());
442     if(attribute_node->getNodeType() != xerces << 311       const G4String attValue = Transcode(attribute->getValue());
443     {                                          << 312 
444       continue;                                << 313       if (attName=="name") { name = GenerateName(attValue); } else
445     }                                          << 314       if (attName=="formula") { formula = attValue; } else
446                                                << 315       if (attName=="Z") { Z = eval.Evaluate(attValue); }
447     const xercesc::DOMAttr* const attribute =  << 316    }
448       dynamic_cast<xercesc::DOMAttr*>(attribut << 317 
449     if(attribute == nullptr)                   << 318    G4int nComponents = 0;
450     {                                          << 319 
451       G4Exception("G4GDMLReadMaterials::Fracti << 320    for (xercesc::DOMNode* iter = elementElement->getFirstChild();
452                   FatalException, "No attribut << 321         iter != 0; iter = iter->getNextSibling())
453       return n;                                << 322    {
454     }                                          << 323       if (iter->getNodeType() != xercesc::DOMNode::ELEMENT_NODE) { continue; }
455     const G4String attName  = Transcode(attrib << 324 
456     const G4String attValue = Transcode(attrib << 325       const xercesc::DOMElement* const child
457                                                << 326             = dynamic_cast<xercesc::DOMElement*>(iter);
458     if(attName == "n")                         << 327       if (!child)
459     {                                          << 328       {
460       n = eval.Evaluate(attValue);             << 329         G4Exception("G4GDMLReadMaterials::ElementRead()", "InvalidRead",
461     }                                          << 330                     FatalException, "No child found!");
462     else if(attName == "ref")                  << 331         return;
463     {                                          << 332       }
464       ref = attValue;                          << 333       const G4String tag = Transcode(child->getTagName());
465     }                                          << 
466   }                                            << 
467                                                   334 
468   return n;                                    << 335       if (tag=="atom") { a = AtomRead(child); }  else
                                                   >> 336       if (tag=="fraction") { nComponents++; }
                                                   >> 337    }
                                                   >> 338 
                                                   >> 339    if (nComponents>0)
                                                   >> 340    {
                                                   >> 341      MixtureRead(elementElement,
                                                   >> 342                  new G4Element(Strip(name),formula,nComponents));
                                                   >> 343    }
                                                   >> 344    else
                                                   >> 345    {
                                                   >> 346      new G4Element(Strip(name),formula,Z,a);
                                                   >> 347    }
469 }                                                 348 }
470                                                   349 
471 // ------------------------------------------- << 350 G4double G4GDMLReadMaterials::
472 void G4GDMLReadMaterials::IsotopeRead(         << 351 FractionRead(const xercesc::DOMElement* const fractionElement, G4String& ref)
473   const xercesc::DOMElement* const isotopeElem << 
474 {                                                 352 {
475   G4String name;                               << 353    G4double n = 0.0;
476   G4int Z    = 0;                              << 354 
477   G4int N    = 0;                              << 355    const xercesc::DOMNamedNodeMap* const attributes
478   G4double a = 0.0;                            << 356          = fractionElement->getAttributes();
479                                                << 357    XMLSize_t attributeCount = attributes->getLength();
480   const xercesc::DOMNamedNodeMap* const attrib << 358 
481     isotopeElement->getAttributes();           << 359    for (XMLSize_t attribute_index=0;
482   XMLSize_t attributeCount = attributes->getLe << 360         attribute_index<attributeCount; attribute_index++)
483                                                << 361    {
484   for(XMLSize_t attribute_index = 0; attribute << 362       xercesc::DOMNode* attribute_node = attributes->item(attribute_index);
485       ++attribute_index)                       << 
486   {                                            << 
487     xercesc::DOMNode* attribute_node = attribu << 
488                                                << 
489     if(attribute_node->getNodeType() != xerces << 
490     {                                          << 
491       continue;                                << 
492     }                                          << 
493                                                << 
494     const xercesc::DOMAttr* const attribute =  << 
495       dynamic_cast<xercesc::DOMAttr*>(attribut << 
496     if(attribute == nullptr)                   << 
497     {                                          << 
498       G4Exception("G4GDMLReadMaterials::Isotop << 
499                   FatalException, "No attribut << 
500       return;                                  << 
501     }                                          << 
502     const G4String attName  = Transcode(attrib << 
503     const G4String attValue = Transcode(attrib << 
504                                                << 
505     if(attName == "name")                      << 
506     {                                          << 
507       name = GenerateName(attValue);           << 
508     }                                          << 
509     else if(attName == "Z")                    << 
510     {                                          << 
511       Z = eval.EvaluateInteger(attValue);      << 
512     }                                          << 
513     else if(attName == "N")                    << 
514     {                                          << 
515       N = eval.EvaluateInteger(attValue);      << 
516     }                                          << 
517   }                                            << 
518                                                << 
519   for(xercesc::DOMNode* iter = isotopeElement- << 
520       iter                   = iter->getNextSi << 
521   {                                            << 
522     if(iter->getNodeType() != xercesc::DOMNode << 
523     {                                          << 
524       continue;                                << 
525     }                                          << 
526                                                << 
527     const xercesc::DOMElement* const child =   << 
528       dynamic_cast<xercesc::DOMElement*>(iter) << 
529     if(child == nullptr)                       << 
530     {                                          << 
531       G4Exception("G4GDMLReadMaterials::Isotop << 
532                   FatalException, "No child fo << 
533       return;                                  << 
534     }                                          << 
535     const G4String tag = Transcode(child->getT << 
536                                                << 
537     if(tag == "atom")                          << 
538     {                                          << 
539       a = AtomRead(child);                     << 
540     }                                          << 
541   }                                            << 
542                                                   363 
543   new G4Isotope(Strip(name), Z, N, a);         << 364       if (attribute_node->getNodeType() != xercesc::DOMNode::ATTRIBUTE_NODE)
                                                   >> 365       { continue; }
                                                   >> 366 
                                                   >> 367       const xercesc::DOMAttr* const attribute
                                                   >> 368             = dynamic_cast<xercesc::DOMAttr*>(attribute_node);   
                                                   >> 369       if (!attribute)
                                                   >> 370       {
                                                   >> 371         G4Exception("G4GDMLReadMaterials::FractionRead()", "InvalidRead",
                                                   >> 372                     FatalException, "No attribute found!");
                                                   >> 373         return n;
                                                   >> 374       }
                                                   >> 375       const G4String attName = Transcode(attribute->getName());
                                                   >> 376       const G4String attValue = Transcode(attribute->getValue());
                                                   >> 377 
                                                   >> 378       if (attName=="n")   { n = eval.Evaluate(attValue); } else
                                                   >> 379       if (attName=="ref") { ref = attValue; }
                                                   >> 380    }
                                                   >> 381 
                                                   >> 382    return n;
544 }                                                 383 }
545                                                   384 
546 // ------------------------------------------- << 385 void G4GDMLReadMaterials::
547 void G4GDMLReadMaterials::MaterialRead(        << 386 IsotopeRead(const xercesc::DOMElement* const isotopeElement)
548   const xercesc::DOMElement* const materialEle << 
549 {                                                 387 {
550   G4String name;                               << 388    G4String name;
551   G4double Z    = 0.0;                         << 389    G4int Z = 0;
552   G4double a    = 0.0;                         << 390    G4int N = 0;
553   G4double D    = 0.0;                         << 391    G4double a = 0.0;
554   G4State state = kStateUndefined;             << 392 
555   G4double T    = NTP_Temperature;             << 393    const xercesc::DOMNamedNodeMap* const attributes
556   G4double P    = STP_Pressure;                << 394          = isotopeElement->getAttributes();
557   G4double MEE  = -1.0;                        << 395    XMLSize_t attributeCount = attributes->getLength();
558                                                << 396 
559   const xercesc::DOMNamedNodeMap* const attrib << 397    for (XMLSize_t attribute_index=0;
560     materialElement->getAttributes();          << 398         attribute_index<attributeCount;attribute_index++)
561   XMLSize_t attributeCount = attributes->getLe << 399    {
562                                                << 400       xercesc::DOMNode* attribute_node = attributes->item(attribute_index);
563   for(XMLSize_t attribute_index = 0; attribute << 401 
564       ++attribute_index)                       << 402       if (attribute_node->getNodeType() != xercesc::DOMNode::ATTRIBUTE_NODE)
565   {                                            << 403       { continue; }
566     xercesc::DOMNode* attribute_node = attribu << 404 
567                                                << 405       const xercesc::DOMAttr* const attribute
568     if(attribute_node->getNodeType() != xerces << 406             = dynamic_cast<xercesc::DOMAttr*>(attribute_node);   
569     {                                          << 407       if (!attribute)
570       continue;                                << 408       {
571     }                                          << 409         G4Exception("G4GDMLReadMaterials::IsotopeRead()", "InvalidRead",
572                                                << 410                     FatalException, "No attribute found!");
573     const xercesc::DOMAttr* const attribute =  << 411         return;
574       dynamic_cast<xercesc::DOMAttr*>(attribut << 412       }
575     if(attribute == nullptr)                   << 413       const G4String attName = Transcode(attribute->getName());
576     {                                          << 414       const G4String attValue = Transcode(attribute->getValue());
577       G4Exception("G4GDMLReadMaterials::Materi << 415 
578                   FatalException, "No attribut << 416       if (attName=="name") { name = GenerateName(attValue); } else
579       return;                                  << 417       if (attName=="Z") { Z = eval.EvaluateInteger(attValue); } else
580     }                                          << 418       if (attName=="N") { N = eval.EvaluateInteger(attValue); }
581     const G4String attName  = Transcode(attrib << 419    }
582     const G4String attValue = Transcode(attrib << 420 
583                                                << 421    for (xercesc::DOMNode* iter = isotopeElement->getFirstChild();
584     if(attName == "name")                      << 422         iter != 0; iter = iter->getNextSibling())
585     {                                          << 423    {
586       name = GenerateName(attValue);           << 424       if (iter->getNodeType() != xercesc::DOMNode::ELEMENT_NODE) { continue; }
587     }                                          << 425 
588     else if(attName == "Z")                    << 426       const xercesc::DOMElement* const child
589     {                                          << 427             = dynamic_cast<xercesc::DOMElement*>(iter);
590       Z = eval.Evaluate(attValue);             << 428       if (!child)
591     }                                          << 429       {
592     else if(attName == "state")                << 430         G4Exception("G4GDMLReadMaterials::IsotopeRead()", "InvalidRead",
593     {                                          << 431                     FatalException, "No child found!");
594       if(attValue == "solid")                  << 432         return;
595       {                                        << 433       }
596         state = kStateSolid;                   << 434       const G4String tag = Transcode(child->getTagName());
597       }                                        << 435 
598       else if(attValue == "liquid")            << 436       if (tag=="atom")  { a = AtomRead(child); }
599       {                                        << 437    }
600         state = kStateLiquid;                  << 438 
601       }                                        << 439    new G4Isotope(Strip(name),Z,N,a);
602       else if(attValue == "gas")               << 
603       {                                        << 
604         state = kStateGas;                     << 
605       }                                        << 
606     }                                          << 
607   }                                            << 
608                                                << 
609   std::size_t nComponents = 0;                 << 
610                                                << 
611   for(xercesc::DOMNode* iter = materialElement << 
612                         iter != nullptr; iter  << 
613   {                                            << 
614     if(iter->getNodeType() != xercesc::DOMNode << 
615     {                                          << 
616       continue;                                << 
617     }                                          << 
618                                                << 
619     const xercesc::DOMElement* const child =   << 
620       dynamic_cast<xercesc::DOMElement*>(iter) << 
621     if(child == nullptr)                       << 
622     {                                          << 
623       G4Exception("G4GDMLReadMaterials::Materi << 
624                   FatalException, "No child fo << 
625       return;                                  << 
626     }                                          << 
627     const G4String tag = Transcode(child->getT << 
628                                                << 
629     if(tag == "atom")                          << 
630     {                                          << 
631       a = AtomRead(child);                     << 
632     }                                          << 
633     else if(tag == "Dref")                     << 
634     {                                          << 
635       D = GetQuantity(GenerateName(RefRead(chi << 
636     }                                          << 
637     else if(tag == "Pref")                     << 
638     {                                          << 
639       P = GetQuantity(GenerateName(RefRead(chi << 
640     }                                          << 
641     else if(tag == "Tref")                     << 
642     {                                          << 
643       T = GetQuantity(GenerateName(RefRead(chi << 
644     }                                          << 
645     else if(tag == "MEEref")                   << 
646     {                                          << 
647       MEE = GetQuantity(GenerateName(RefRead(c << 
648     }                                          << 
649     else if(tag == "D")                        << 
650     {                                          << 
651       D = DRead(child);                        << 
652     }                                          << 
653     else if(tag == "P")                        << 
654     {                                          << 
655       P = PRead(child);                        << 
656     }                                          << 
657     else if(tag == "T")                        << 
658     {                                          << 
659       T = TRead(child);                        << 
660     }                                          << 
661     else if(tag == "MEE")                      << 
662     {                                          << 
663       MEE = MEERead(child);                    << 
664     }                                          << 
665     else if(tag == "fraction" || tag == "compo << 
666     {                                          << 
667       nComponents++;                           << 
668     }                                          << 
669   }                                            << 
670                                                << 
671   G4Material* material = nullptr;              << 
672                                                << 
673   if(nComponents == 0)                         << 
674   {                                            << 
675     material = new G4Material(Strip(name), Z,  << 
676   }                                            << 
677   else                                         << 
678   {                                            << 
679     material = new G4Material(Strip(name), D,  << 
680     MixtureRead(materialElement, material);    << 
681   }                                            << 
682   if(MEE != -1)  // ionisation potential (mean << 
683   {                                            << 
684     material->GetIonisation()->SetMeanExcitati << 
685   }                                            << 
686                                                << 
687   for(xercesc::DOMNode* iter = materialElement << 
688                         iter != nullptr; iter  << 
689   {                                            << 
690     if(iter->getNodeType() != xercesc::DOMNode << 
691     {                                          << 
692       continue;                                << 
693     }                                          << 
694                                                << 
695     const xercesc::DOMElement* const child =   << 
696       dynamic_cast<xercesc::DOMElement*>(iter) << 
697     if(child == nullptr)                       << 
698     {                                          << 
699       G4Exception("G4GDMLReadMaterials::Materi << 
700                   FatalException, "No child fo << 
701       return;                                  << 
702     }                                          << 
703     const G4String tag = Transcode(child->getT << 
704                                                << 
705     if(tag == "property")                      << 
706     {                                          << 
707       PropertyRead(child, material);           << 
708     }                                          << 
709   }                                            << 
710 }                                                 440 }
711                                                   441 
712 // ------------------------------------------- << 442 void G4GDMLReadMaterials::
713 void G4GDMLReadMaterials::MixtureRead(         << 443 MaterialRead(const xercesc::DOMElement* const materialElement)
714   const xercesc::DOMElement* const mixtureElem << 
715 {                                                 444 {
716   for(xercesc::DOMNode* iter = mixtureElement- << 445    G4String name;
717       iter                   = iter->getNextSi << 446    G4double Z = 0.0;
718   {                                            << 447    G4double a = 0.0;
719     if(iter->getNodeType() != xercesc::DOMNode << 448    G4double D = 0.0;
720     {                                          << 449    G4State state = kStateUndefined;
721       continue;                                << 450    G4double T = STP_Temperature;
722     }                                          << 451    G4double P = STP_Pressure;
723                                                << 452    G4double MEE = -1.0;
724     const xercesc::DOMElement* const child =   << 453 
725       dynamic_cast<xercesc::DOMElement*>(iter) << 454    const xercesc::DOMNamedNodeMap* const attributes
726     if(child == nullptr)                       << 455          = materialElement->getAttributes();
727     {                                          << 456    XMLSize_t attributeCount = attributes->getLength();
728       G4Exception("G4GDMLReadMaterials::Mixtur << 457 
729                   FatalException, "No child fo << 458    for (XMLSize_t attribute_index=0;
730       return;                                  << 459         attribute_index<attributeCount; attribute_index++)
731     }                                          << 460    {
732     const G4String tag = Transcode(child->getT << 461       xercesc::DOMNode* attribute_node = attributes->item(attribute_index);
733                                                << 462 
734     if(tag == "fraction")                      << 463       if (attribute_node->getNodeType() != xercesc::DOMNode::ATTRIBUTE_NODE)
735     {                                          << 464       { continue; }
736       G4String ref;                            << 465 
737       G4double n = FractionRead(child, ref);   << 466       const xercesc::DOMAttr* const attribute
738       element->AddIsotope(GetIsotope(GenerateN << 467             = dynamic_cast<xercesc::DOMAttr*>(attribute_node);   
739     }                                          << 468       if (!attribute)
740   }                                            << 469       {
                                                   >> 470         G4Exception("G4GDMLReadMaterials::MaterialRead()", "InvalidRead",
                                                   >> 471                     FatalException, "No attribute found!");
                                                   >> 472         return;
                                                   >> 473       }
                                                   >> 474       const G4String attName = Transcode(attribute->getName());
                                                   >> 475       const G4String attValue = Transcode(attribute->getValue());
                                                   >> 476 
                                                   >> 477       if (attName=="name") { name = GenerateName(attValue); } else
                                                   >> 478       if (attName=="Z") { Z = eval.Evaluate(attValue); } else
                                                   >> 479       if (attName=="state")
                                                   >> 480       {
                                                   >> 481          if (attValue=="solid")  { state = kStateSolid;  } else
                                                   >> 482          if (attValue=="liquid") { state = kStateLiquid; } else
                                                   >> 483          if (attValue=="gas")    { state = kStateGas; }
                                                   >> 484       }
                                                   >> 485    }
                                                   >> 486 
                                                   >> 487    size_t nComponents = 0;
                                                   >> 488 
                                                   >> 489    for (xercesc::DOMNode* iter = materialElement->getFirstChild();
                                                   >> 490         iter != 0; iter = iter->getNextSibling())
                                                   >> 491    {
                                                   >> 492       if (iter->getNodeType() != xercesc::DOMNode::ELEMENT_NODE) { continue; }
                                                   >> 493 
                                                   >> 494       const xercesc::DOMElement* const child
                                                   >> 495             = dynamic_cast<xercesc::DOMElement*>(iter);
                                                   >> 496       if (!child)
                                                   >> 497       {
                                                   >> 498         G4Exception("G4GDMLReadMaterials::MaterialRead()", "InvalidRead",
                                                   >> 499                     FatalException, "No child found!");
                                                   >> 500         return;
                                                   >> 501       }
                                                   >> 502       const G4String tag = Transcode(child->getTagName());
                                                   >> 503 
                                                   >> 504       if (tag=="atom") { a = AtomRead(child); } else
                                                   >> 505       if (tag=="Dref") { D = GetQuantity(GenerateName(RefRead(child))); } else
                                                   >> 506       if (tag=="Pref") { P = GetQuantity(GenerateName(RefRead(child))); } else
                                                   >> 507       if (tag=="Tref") { T = GetQuantity(GenerateName(RefRead(child))); } else
                                                   >> 508       if (tag=="MEEref") { MEE = GetQuantity(GenerateName(RefRead(child))); } else
                                                   >> 509       if (tag=="D") { D = DRead(child); } else
                                                   >> 510       if (tag=="P") { P = PRead(child); } else
                                                   >> 511       if (tag=="T") { T = TRead(child); } else
                                                   >> 512       if (tag=="MEE") { MEE = MEERead(child); } else
                                                   >> 513       if (tag=="fraction" || tag=="composite")  { nComponents++; }
                                                   >> 514    }
                                                   >> 515 
                                                   >> 516    G4Material* material =  0;
                                                   >> 517 
                                                   >> 518    if (nComponents==0)
                                                   >> 519    {
                                                   >> 520      material = new G4Material(Strip(name),Z,a,D,state,T,P);
                                                   >> 521    }
                                                   >> 522    else
                                                   >> 523    {
                                                   >> 524      material = new G4Material(Strip(name),D,nComponents,state,T,P);
                                                   >> 525      MixtureRead(materialElement, material);
                                                   >> 526    }
                                                   >> 527    if (MEE != -1)  // ionisation potential (mean excitation energy)
                                                   >> 528    {
                                                   >> 529      material->GetIonisation()->SetMeanExcitationEnergy(MEE);
                                                   >> 530    }
                                                   >> 531 
                                                   >> 532    for (xercesc::DOMNode* iter = materialElement->getFirstChild();
                                                   >> 533         iter != 0; iter = iter->getNextSibling())
                                                   >> 534    {
                                                   >> 535       if (iter->getNodeType() != xercesc::DOMNode::ELEMENT_NODE) { continue; }
                                                   >> 536 
                                                   >> 537       const xercesc::DOMElement* const child
                                                   >> 538             = dynamic_cast<xercesc::DOMElement*>(iter);
                                                   >> 539       if (!child)
                                                   >> 540       {
                                                   >> 541         G4Exception("G4GDMLReadMaterials::MaterialRead()", "InvalidRead",
                                                   >> 542                     FatalException, "No child found!");
                                                   >> 543         return;
                                                   >> 544       }
                                                   >> 545       const G4String tag = Transcode(child->getTagName());
                                                   >> 546 
                                                   >> 547       if (tag=="property") { PropertyRead(child,material); }
                                                   >> 548    }
741 }                                                 549 }
742                                                   550 
743 // ------------------------------------------- << 551 void G4GDMLReadMaterials::
744 void G4GDMLReadMaterials::MixtureRead(         << 552 MixtureRead(const xercesc::DOMElement *const mixtureElement, G4Element *element)
745   const xercesc::DOMElement* const mixtureElem << 
746 {                                                 553 {
747   for(xercesc::DOMNode* iter = mixtureElement- << 554    for (xercesc::DOMNode* iter = mixtureElement->getFirstChild();
748       iter                   = iter->getNextSi << 555         iter != 0; iter = iter->getNextSibling())
749   {                                            << 556    {
750     if(iter->getNodeType() != xercesc::DOMNode << 557       if (iter->getNodeType() != xercesc::DOMNode::ELEMENT_NODE) { continue; }
751     {                                          << 
752       continue;                                << 
753     }                                          << 
754                                                   558 
755     const xercesc::DOMElement* const child =   << 559       const xercesc::DOMElement* const child
756       dynamic_cast<xercesc::DOMElement*>(iter) << 560             = dynamic_cast<xercesc::DOMElement*>(iter);
757     if(child == nullptr)                       << 561       if (!child)
758     {                                          << 562       {
759       G4Exception("G4GDMLReadMaterials::Mixtur << 563         G4Exception("G4GDMLReadMaterials::MixtureRead()", "InvalidRead",
760                   FatalException, "No child fo << 564                     FatalException, "No child found!");
761       return;                                  << 565         return;
762     }                                          << 566       }
763     const G4String tag = Transcode(child->getT << 567       const G4String tag = Transcode(child->getTagName());
764                                                   568 
765     if(tag == "fraction")                      << 569       if (tag=="fraction")
766     {                                          << 570       {
767       G4String ref;                            << 571          G4String ref;
768       G4double n = FractionRead(child, ref);   << 572          G4double n = FractionRead(child,ref);
                                                   >> 573          element->AddIsotope(GetIsotope(GenerateName(ref,true)),n);
                                                   >> 574       }
                                                   >> 575    }
                                                   >> 576 }
769                                                   577 
770       G4Material* materialPtr = GetMaterial(Ge << 578 void G4GDMLReadMaterials::
771       G4Element* elementPtr   = GetElement(Gen << 579 MixtureRead(const xercesc::DOMElement *const mixtureElement,
                                                   >> 580             G4Material *material)
                                                   >> 581 {
                                                   >> 582    for (xercesc::DOMNode* iter = mixtureElement->getFirstChild();
                                                   >> 583         iter != 0; iter = iter->getNextSibling())
                                                   >> 584    {
                                                   >> 585       if (iter->getNodeType() != xercesc::DOMNode::ELEMENT_NODE) { continue; }
772                                                   586 
773       if(elementPtr != nullptr)                << 587       const xercesc::DOMElement* const child
                                                   >> 588             = dynamic_cast<xercesc::DOMElement*>(iter);
                                                   >> 589       if (!child)
774       {                                           590       {
775         material->AddElement(elementPtr, n);   << 591         G4Exception("G4GDMLReadMaterials::MixtureRead()", "InvalidRead",
                                                   >> 592                     FatalException, "No child found!");
                                                   >> 593         return;
776       }                                           594       }
777       else if(materialPtr != nullptr)          << 595       const G4String tag = Transcode(child->getTagName());
                                                   >> 596 
                                                   >> 597       if (tag=="fraction")
778       {                                           598       {
779         material->AddMaterial(materialPtr, n); << 599          G4String ref;
780       }                                        << 600          G4double n = FractionRead(child,ref);
                                                   >> 601          
                                                   >> 602          G4Material *materialPtr = GetMaterial(GenerateName(ref,true), false);
                                                   >> 603          G4Element *elementPtr = GetElement(GenerateName(ref,true), false);
                                                   >> 604 
                                                   >> 605          if (elementPtr != 0)  { material->AddElement(elementPtr,n); } else
                                                   >> 606          if (materialPtr != 0) { material->AddMaterial(materialPtr,n); }
781                                                   607 
782       if((materialPtr == nullptr) && (elementP << 608          if ((materialPtr == 0) && (elementPtr == 0))
                                                   >> 609          {
                                                   >> 610             G4String error_msg = "Referenced material/element '"
                                                   >> 611                                + GenerateName(ref,true) + "' was not found!";
                                                   >> 612             G4Exception("G4GDMLReadMaterials::MixtureRead()", "InvalidSetup",
                                                   >> 613                         FatalException, error_msg);   
                                                   >> 614          }
                                                   >> 615       } 
                                                   >> 616       else if (tag=="composite")
783       {                                           617       {
784         G4String error_msg = "Referenced mater << 618          G4String ref;
785                              GenerateName(ref, << 619          G4int n = CompositeRead(child,ref);
786         G4Exception("G4GDMLReadMaterials::Mixt << 620 
787                     FatalException, error_msg) << 621          G4Element *elementPtr = GetElement(GenerateName(ref,true));
                                                   >> 622          material->AddElement(elementPtr,n);
788       }                                           623       }
789     }                                          << 624    }
790     else if(tag == "composite")                << 
791     {                                          << 
792       G4String ref;                            << 
793       G4int n = CompositeRead(child, ref);     << 
794                                                << 
795       G4Element* elementPtr = GetElement(Gener << 
796       material->AddElement(elementPtr, n);     << 
797     }                                          << 
798   }                                            << 
799 }                                                 625 }
800                                                   626 
801 // ------------------------------------------- << 627 void G4GDMLReadMaterials::
802 void G4GDMLReadMaterials::PropertyRead(        << 628 PropertyRead(const xercesc::DOMElement* const propertyElement,
803   const xercesc::DOMElement* const propertyEle << 629              G4Material* material)
804 {                                                 630 {
805   G4String name;                               << 631    G4String name;
806   G4String ref;                                << 632    G4String ref;
807   G4GDMLMatrix matrix;                         << 633    G4GDMLMatrix matrix;
808                                                << 634 
809   const xercesc::DOMNamedNodeMap* const attrib << 635    const xercesc::DOMNamedNodeMap* const attributes
810     propertyElement->getAttributes();          << 636          = propertyElement->getAttributes();
811   XMLSize_t attributeCount = attributes->getLe << 637    XMLSize_t attributeCount = attributes->getLength();
812                                                << 638 
813   for(XMLSize_t attribute_index = 0; attribute << 639    for (XMLSize_t attribute_index=0;
814       ++attribute_index)                       << 640         attribute_index<attributeCount; attribute_index++)
815   {                                            << 641    {
816     xercesc::DOMNode* attribute_node = attribu << 642       xercesc::DOMNode* attribute_node = attributes->item(attribute_index);
817                                                << 643 
818     if(attribute_node->getNodeType() != xerces << 644       if (attribute_node->getNodeType() != xercesc::DOMNode::ATTRIBUTE_NODE)
819     {                                          << 645       { continue; }
820       continue;                                << 646 
821     }                                          << 647       const xercesc::DOMAttr* const attribute
822                                                << 648             = dynamic_cast<xercesc::DOMAttr*>(attribute_node);   
823     const xercesc::DOMAttr* const attribute =  << 649       if (!attribute)
824       dynamic_cast<xercesc::DOMAttr*>(attribut << 650       {
825     if(attribute == nullptr)                   << 651         G4Exception("G4GDMLReadMaterials::PropertyRead()", "InvalidRead",
826     {                                          << 652                     FatalException, "No attribute found!");
827       G4Exception("G4GDMLReadMaterials::Proper << 653         return;
828                   FatalException, "No attribut << 654       }
829       return;                                  << 655       const G4String attName = Transcode(attribute->getName());
830     }                                          << 656       const G4String attValue = Transcode(attribute->getValue());
831     const G4String attName  = Transcode(attrib << 657 
832     const G4String attValue = Transcode(attrib << 658       if (attName=="name") { name = GenerateName(attValue); } else
833                                                << 659       if (attName=="ref")  { matrix = GetMatrix(ref=attValue); }
834     if(attName == "name")                      << 660    }
835     {                                          << 661 
836       name = GenerateName(attValue);           << 662    /*
837     }                                          << 663    if (matrix.GetCols() != 2)
838     else if(attName == "ref")                  << 664    {
839     {                                          << 665      G4String error_msg = "Referenced matrix '" + ref
840       matrix = GetMatrix(ref = attValue);      << 666             + "' should have \n two columns as a property table for material: "
841     }                                          << 667             + material->GetName();
842   }                                            << 668      G4Exception("G4GDMLReadMaterials::PropertyRead()", "InvalidRead",
843                                                << 669                  FatalException, error_msg);
844   /*                                           << 670    }
845   if (matrix.GetCols() != 2)                   << 671    */
846   {                                            << 672 
847     G4String error_msg = "Referenced matrix '" << 673    if (matrix.GetRows() == 0) { return; }
848            + "' should have \n two columns as  << 674 
849            + material->GetName();              << 675    G4MaterialPropertiesTable* matprop=material->GetMaterialPropertiesTable();
850     G4Exception("G4GDMLReadMaterials::Property << 676    if (!matprop)
851                 FatalException, error_msg);    << 677    {
852   }                                            << 678      matprop = new G4MaterialPropertiesTable();
853   */                                           << 679      material->SetMaterialPropertiesTable(matprop);
854                                                << 680    }
855   if(matrix.GetRows() == 0)                    << 681    if (matrix.GetCols() == 1)  // constant property assumed
856   {                                            << 682    {
857     return;                                    << 683      matprop->AddConstProperty(Strip(name), matrix.Get(0,0));
858   }                                            << 684    }
859                                                << 685    else  // build the material properties vector
860   G4MaterialPropertiesTable* matprop = materia << 686    {
861   if(matprop == nullptr)                       << 687      G4MaterialPropertyVector* propvect = new G4MaterialPropertyVector();
862   {                                            << 688      for (size_t i=0; i<matrix.GetRows(); i++)
863     matprop = new G4MaterialPropertiesTable(); << 689      {
864     material->SetMaterialPropertiesTable(matpr << 690        propvect->InsertValues(matrix.Get(i,0),matrix.Get(i,1));
865   }                                            << 691      }
866   if(matrix.GetCols() == 1)  // constant prope << 692      matprop->AddProperty(Strip(name),propvect);
867   {                                            << 693    }
868     matprop->AddConstProperty(Strip(name), mat << 
869   }                                            << 
870   else  // build the material properties vecto << 
871   {                                            << 
872     G4MaterialPropertyVector* propvect = new G << 
873     for(std::size_t i = 0; i < matrix.GetRows( << 
874     {                                          << 
875       propvect->InsertValues(matrix.Get(i, 0), << 
876     }                                          << 
877     matprop->AddProperty(Strip(name), propvect << 
878   }                                            << 
879 }                                                 694 }
880                                                   695 
881 // ------------------------------------------- << 696 void G4GDMLReadMaterials::
882 void G4GDMLReadMaterials::MaterialsRead(       << 697 MaterialsRead(const xercesc::DOMElement* const materialsElement)
883   const xercesc::DOMElement* const materialsEl << 
884 {                                                 698 {
885 #ifdef G4VERBOSE                                  699 #ifdef G4VERBOSE
886   G4cout << "G4GDML: Reading materials..." <<  << 700    G4cout << "G4GDML: Reading materials..." << G4endl;
887 #endif                                            701 #endif
888   for(xercesc::DOMNode* iter = materialsElemen << 702    for (xercesc::DOMNode* iter = materialsElement->getFirstChild();
889                         iter != nullptr; iter  << 703         iter != 0; iter = iter->getNextSibling())
890   {                                            << 704    {
891     if(iter->getNodeType() != xercesc::DOMNode << 705       if (iter->getNodeType() != xercesc::DOMNode::ELEMENT_NODE) { continue; }
892     {                                          << 706 
893       continue;                                << 707       const xercesc::DOMElement* const child
894     }                                          << 708             = dynamic_cast<xercesc::DOMElement*>(iter);
895                                                << 709       if (!child)
896     const xercesc::DOMElement* const child =   << 710       {
897       dynamic_cast<xercesc::DOMElement*>(iter) << 711         G4Exception("G4GDMLReadMaterials::MaterialsRead()", "InvalidRead",
898     if(child == nullptr)                       << 712                     FatalException, "No child found!");
899     {                                          << 713         return;
900       G4Exception("G4GDMLReadMaterials::Materi << 714       }
901                   FatalException, "No child fo << 715       const G4String tag = Transcode(child->getTagName());
902       return;                                  << 716       
903     }                                          << 717       if (tag=="define")   { DefineRead(child);  }  else 
904     const G4String tag = Transcode(child->getT << 718       if (tag=="element")  { ElementRead(child); }  else 
905                                                << 719       if (tag=="isotope")  { IsotopeRead(child); }  else 
906     if(tag == "define")                        << 720       if (tag=="material") { MaterialRead(child); }
907     {                                          << 721       else
908       DefineRead(child);                       << 722       {
909     }                                          << 723         G4String error_msg = "Unknown tag in materials: " + tag;
910     else if(tag == "element")                  << 724         G4Exception("G4GDMLReadMaterials::MaterialsRead()", "InvalidSetup",
911     {                                          << 725                     FatalException, error_msg);
912       ElementRead(child);                      << 726       }
913     }                                          << 727    }
914     else if(tag == "isotope")                  << 
915     {                                          << 
916       IsotopeRead(child);                      << 
917     }                                          << 
918     else if(tag == "material")                 << 
919     {                                          << 
920       MaterialRead(child);                     << 
921     }                                          << 
922     else                                       << 
923     {                                          << 
924       G4String error_msg = "Unknown tag in mat << 
925       G4Exception("G4GDMLReadMaterials::Materi << 
926                   FatalException, error_msg);  << 
927     }                                          << 
928   }                                            << 
929 }                                                 728 }
930                                                   729 
931 // ------------------------------------------- << 730 G4Element* G4GDMLReadMaterials::
932 G4Element* G4GDMLReadMaterials::GetElement(con << 731 GetElement(const G4String& ref, G4bool verbose) const
933                                            G4b << 
934 {                                                 732 {
935   G4Element* elementPtr = G4Element::GetElemen << 733    G4Element* elementPtr = G4Element::GetElement(ref,false);
936                                                   734 
937   if(elementPtr == nullptr)                    << 735    if (!elementPtr)
938   {                                            << 736    {
939     elementPtr = G4NistManager::Instance()->Fi << 737      elementPtr = G4NistManager::Instance()->FindOrBuildElement(ref);
940   }                                            << 738    }
941                                                << 
942   if(verbose && elementPtr == nullptr)         << 
943   {                                            << 
944     G4String error_msg = "Referenced element ' << 
945     G4Exception("G4GDMLReadMaterials::GetEleme << 
946                 FatalException, error_msg);    << 
947   }                                            << 
948                                                   739 
949   return elementPtr;                           << 740    if (verbose && !elementPtr)
                                                   >> 741    {
                                                   >> 742      G4String error_msg = "Referenced element '" + ref + "' was not found!";
                                                   >> 743      G4Exception("G4GDMLReadMaterials::GetElement()", "InvalidRead",
                                                   >> 744                  FatalException, error_msg);
                                                   >> 745    }
                                                   >> 746 
                                                   >> 747    return elementPtr;
950 }                                                 748 }
951                                                   749 
952 // ------------------------------------------- << 
953 G4Isotope* G4GDMLReadMaterials::GetIsotope(con    750 G4Isotope* G4GDMLReadMaterials::GetIsotope(const G4String& ref,
954                                            G4b    751                                            G4bool verbose) const
955 {                                                 752 {
956   G4Isotope* isotopePtr = G4Isotope::GetIsotop << 753    G4Isotope* isotopePtr = G4Isotope::GetIsotope(ref,false);
957                                                   754 
958   if(verbose && isotopePtr == nullptr)         << 755    if (verbose && !isotopePtr)
959   {                                            << 756    {
960     G4String error_msg = "Referenced isotope ' << 757      G4String error_msg = "Referenced isotope '" + ref + "' was not found!";
961     G4Exception("G4GDMLReadMaterials::GetIsoto << 758      G4Exception("G4GDMLReadMaterials::GetIsotope()", "InvalidRead",
962                 FatalException, error_msg);    << 759                  FatalException, error_msg);
963   }                                            << 760    }
964                                                   761 
965   return isotopePtr;                           << 762    return isotopePtr;
966 }                                                 763 }
967                                                   764 
968 // ------------------------------------------- << 
969 G4Material* G4GDMLReadMaterials::GetMaterial(c    765 G4Material* G4GDMLReadMaterials::GetMaterial(const G4String& ref,
970                                              G    766                                              G4bool verbose) const
971 {                                                 767 {
972   G4Material* materialPtr = G4Material::GetMat << 768    G4Material *materialPtr = G4Material::GetMaterial(ref,false);
973                                                   769 
974   if(materialPtr == nullptr)                   << 770    if (!materialPtr)
975   {                                            << 771    {
976     materialPtr = G4NistManager::Instance()->F << 772      materialPtr = G4NistManager::Instance()->FindOrBuildMaterial(ref);
977   }                                            << 773    }
978                                                << 774 
979   if(verbose && materialPtr == nullptr)        << 775    if (verbose && !materialPtr)
980   {                                            << 776    {
981     G4String error_msg = "Referenced material  << 777      G4String error_msg = "Referenced material '" + ref + "' was not found!";
982     G4Exception("G4GDMLReadMaterials::GetMater << 778      G4Exception("G4GDMLReadMaterials::GetMaterial()", "InvalidRead",
983                 FatalException, error_msg);    << 779                  FatalException, error_msg);
984   }                                            << 780    }
985                                                   781 
986   return materialPtr;                          << 782    return materialPtr;
987 }                                                 783 }
988                                                   784