Geant4 Cross Reference |
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 // $Id: G4GDMLReadMaterials.cc,v 1.16 2008/08/22 10:00:20 gcosmo Exp $ >> 28 // GEANT4 tag $ Name:$ >> 29 // >> 30 // class G4GDMLReadMaterials Implementation >> 31 // >> 32 // Original author: Zoltan Torzsok, November 2007 >> 33 // 29 // ------------------------------------------- 34 // -------------------------------------------------------------------- 30 35 31 #include "G4GDMLReadMaterials.hh" 36 #include "G4GDMLReadMaterials.hh" 32 37 33 #include "G4PhysicalConstants.hh" << 38 G4double 34 #include "G4SystemOfUnits.hh" << 39 G4GDMLReadMaterials::AtomRead(const xercesc::DOMElement* const atomElement) 35 #include "G4UnitsTable.hh" << 36 #include "G4Element.hh" << 37 #include "G4Isotope.hh" << 38 #include "G4Material.hh" << 39 #include "G4NistManager.hh" << 40 << 41 // ------------------------------------------- << 42 G4GDMLReadMaterials::G4GDMLReadMaterials() << 43 : G4GDMLReadDefine() << 44 { << 45 } << 46 << 47 // ------------------------------------------- << 48 G4GDMLReadMaterials::~G4GDMLReadMaterials() << 49 { << 50 } << 51 << 52 // ------------------------------------------- << 53 G4double G4GDMLReadMaterials::AtomRead( << 54 const xercesc::DOMElement* const atomElement << 55 { 40 { 56 G4double value = 0.0; << 41 G4double value = 0.0; 57 G4double unit = g / mole; << 42 G4double unit = g/mole; 58 << 59 const xercesc::DOMNamedNodeMap* const attrib << 60 atomElement->getAttributes(); << 61 XMLSize_t attributeCount = attributes->getLe << 62 << 63 for(XMLSize_t attribute_index = 0; attribute << 64 ++attribute_index) << 65 { << 66 xercesc::DOMNode* attribute_node = attribu << 67 << 68 if(attribute_node->getNodeType() != xerces << 69 { << 70 continue; << 71 } << 72 << 73 const xercesc::DOMAttr* const 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 { << 93 G4Exception("G4GDMLReadMaterials::Atom << 94 FatalException, "Invalid u << 95 } << 96 } << 97 } << 98 43 99 return value * unit; << 44 const xercesc::DOMNamedNodeMap* const attributes 100 } << 45 = atomElement->getAttributes(); >> 46 XMLSize_t attributeCount = attributes->getLength(); 101 47 102 // ------------------------------------------- << 48 for (XMLSize_t attribute_index=0; 103 G4int G4GDMLReadMaterials::CompositeRead( << 49 attribute_index<attributeCount; attribute_index++) 104 const xercesc::DOMElement* const compositeEl << 50 { 105 { << 51 xercesc::DOMNode* attribute_node = attributes->item(attribute_index); 106 G4int n = 0; << 107 << 108 const xercesc::DOMNamedNodeMap* const attrib << 109 compositeElement->getAttributes(); << 110 XMLSize_t attributeCount = attributes->getLe << 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 << 143 return n; << 144 } << 145 52 146 // ------------------------------------------- << 53 if (attribute_node->getNodeType() != xercesc::DOMNode::ATTRIBUTE_NODE) 147 G4double G4GDMLReadMaterials::DRead(const xerc << 54 { continue; } 148 { << 149 G4double value = 0.0; << 150 G4double unit = g / cm3; << 151 55 152 const xercesc::DOMNamedNodeMap* const attrib << 56 const xercesc::DOMAttr* const attribute 153 XMLSize_t attributeCount << 57 = dynamic_cast<xercesc::DOMAttr*>(attribute_node); >> 58 const G4String attName = Transcode(attribute->getName()); >> 59 const G4String attValue = Transcode(attribute->getValue()); 154 60 155 for(XMLSize_t attribute_index = 0; attribute << 61 if (attName=="value") { value = eval.Evaluate(attValue); } else 156 ++attribute_index) << 62 if (attName=="unit") { unit = eval.Evaluate(attValue); } 157 { << 63 } 158 xercesc::DOMNode* attribute_node = attribu << 159 << 160 if(attribute_node->getNodeType() != xerces << 161 { << 162 continue; << 163 } << 164 << 165 const xercesc::DOMAttr* const attribute = << 166 dynamic_cast<xercesc::DOMAttr*>(attribut << 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 { << 185 G4Exception("G4GDMLReadMaterials::DRea << 186 FatalException, "Invalid u << 187 } << 188 } << 189 } << 190 64 191 return value * unit; << 65 return value*unit; 192 } 66 } 193 67 194 // ------------------------------------------- << 68 G4int G4GDMLReadMaterials:: 195 G4double G4GDMLReadMaterials::PRead(const xerc << 69 CompositeRead(const xercesc::DOMElement* const compositeElement,G4String& ref) 196 { 70 { 197 G4double value = STP_Pressure; << 71 G4int n = 0; 198 G4double unit = hep_pascal; << 199 72 200 const xercesc::DOMNamedNodeMap* const attrib << 73 const xercesc::DOMNamedNodeMap* const attributes 201 XMLSize_t attributeCount << 74 = compositeElement->getAttributes(); >> 75 XMLSize_t attributeCount = attributes->getLength(); 202 76 203 for(XMLSize_t attribute_index = 0; attribute << 77 for (XMLSize_t attribute_index=0; 204 ++attribute_index) << 78 attribute_index<attributeCount; attribute_index++) 205 { << 79 { 206 xercesc::DOMNode* attribute_node = attribu << 80 xercesc::DOMNode* attribute_node = attributes->item(attribute_index); 207 << 208 if(attribute_node->getNodeType() != xerces << 209 { << 210 continue; << 211 } << 212 << 213 const xercesc::DOMAttr* const 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 { << 233 G4Exception("G4GDMLReadMaterials::PRea << 234 FatalException, "Invalid u << 235 } << 236 } << 237 } << 238 << 239 return value * unit; << 240 } << 241 81 242 // ------------------------------------------- << 82 if (attribute_node->getNodeType() != xercesc::DOMNode::ATTRIBUTE_NODE) 243 G4double G4GDMLReadMaterials::TRead(const xerc << 83 { continue; } 244 { << 245 G4double value = NTP_Temperature; << 246 G4double unit = kelvin; << 247 84 248 const xercesc::DOMNamedNodeMap* const attrib << 85 const xercesc::DOMAttr* const attribute 249 XMLSize_t attributeCount << 86 = dynamic_cast<xercesc::DOMAttr*>(attribute_node); >> 87 const G4String attName = Transcode(attribute->getName()); >> 88 const G4String attValue = Transcode(attribute->getValue()); 250 89 251 for(XMLSize_t attribute_index = 0; attribute << 90 if (attName=="n") { n = eval.EvaluateInteger(attValue); } else 252 ++attribute_index) << 91 if (attName=="ref") { ref = attValue; } 253 { << 92 } 254 xercesc::DOMNode* attribute_node = attribu << 255 << 256 if(attribute_node->getNodeType() != xerces << 257 { << 258 continue; << 259 } << 260 << 261 const xercesc::DOMAttr* const 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 { << 281 G4Exception("G4GDMLReadMaterials::TRea << 282 FatalException, "Invalid u << 283 } << 284 } << 285 } << 286 93 287 return value * unit; << 94 return n; 288 } 95 } 289 96 290 // ------------------------------------------- << 97 G4double G4GDMLReadMaterials::DRead(const xercesc::DOMElement* const DElement) 291 G4double G4GDMLReadMaterials::MEERead(const xe << 292 { << 293 G4double value = -1; << 294 G4double unit = eV; << 295 << 296 const xercesc::DOMNamedNodeMap* const attrib << 297 XMLSize_t attributeCount << 298 << 299 for(XMLSize_t attribute_index = 0; attribute << 300 ++attribute_index) << 301 { << 302 xercesc::DOMNode* attribute_node = attribu << 303 << 304 if(attribute_node->getNodeType() != xerces << 305 { << 306 continue; << 307 } << 308 << 309 const xercesc::DOMAttr* const 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 { << 329 G4Exception("G4GDMLReadMaterials::MEER << 330 FatalException, "Invalid u << 331 } << 332 } << 333 } << 334 << 335 return value * unit; << 336 } << 337 << 338 // ------------------------------------------- << 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 } << 426 << 427 // ------------------------------------------- << 428 G4double G4GDMLReadMaterials::FractionRead( << 429 const xercesc::DOMElement* const fractionEle << 430 { 98 { 431 G4double n = 0.0; << 99 G4double value = 0.0; >> 100 G4double unit = g/cm3; 432 101 433 const xercesc::DOMNamedNodeMap* const attrib << 102 const xercesc::DOMNamedNodeMap* const attributes 434 fractionElement->getAttributes(); << 103 = DElement->getAttributes(); 435 XMLSize_t attributeCount = attributes->getLe << 104 XMLSize_t attributeCount = attributes->getLength(); 436 << 105 437 for(XMLSize_t attribute_index = 0; attribute << 106 for (XMLSize_t attribute_index=0; 438 ++attribute_index) << 107 attribute_index<attributeCount; attribute_index++) 439 { << 108 { 440 xercesc::DOMNode* attribute_node = attribu << 109 xercesc::DOMNode* attribute_node = attributes->item(attribute_index); 441 << 110 442 if(attribute_node->getNodeType() != xerces << 111 if (attribute_node->getNodeType() != xercesc::DOMNode::ATTRIBUTE_NODE) 443 { << 112 { continue; } 444 continue; << 113 445 } << 114 const xercesc::DOMAttr* const attribute 446 << 115 = dynamic_cast<xercesc::DOMAttr*>(attribute_node); 447 const xercesc::DOMAttr* const attribute = << 116 const G4String attName = Transcode(attribute->getName()); 448 dynamic_cast<xercesc::DOMAttr*>(attribut << 117 const G4String attValue = Transcode(attribute->getValue()); 449 if(attribute == nullptr) << 118 450 { << 119 if (attName=="value") { value = eval.Evaluate(attValue); } else 451 G4Exception("G4GDMLReadMaterials::Fracti << 120 if (attName=="unit") { unit = eval.Evaluate(attValue); } 452 FatalException, "No attribut << 121 } 453 return n; << 454 } << 455 const G4String attName = Transcode(attrib << 456 const G4String attValue = Transcode(attrib << 457 << 458 if(attName == "n") << 459 { << 460 n = eval.Evaluate(attValue); << 461 } << 462 else if(attName == "ref") << 463 { << 464 ref = attValue; << 465 } << 466 } << 467 122 468 return n; << 123 return value*unit; 469 } 124 } 470 125 471 // ------------------------------------------- << 126 G4double G4GDMLReadMaterials::PRead(const xercesc::DOMElement* const PElement) 472 void G4GDMLReadMaterials::IsotopeRead( << 473 const xercesc::DOMElement* const isotopeElem << 474 { 127 { 475 G4String name; << 128 G4double value = STP_Pressure; 476 G4int Z = 0; << 129 G4double unit = pascal; 477 G4int N = 0; << 478 G4double a = 0.0; << 479 << 480 const xercesc::DOMNamedNodeMap* const attrib << 481 isotopeElement->getAttributes(); << 482 XMLSize_t attributeCount = attributes->getLe << 483 << 484 for(XMLSize_t attribute_index = 0; attribute << 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 130 543 new G4Isotope(Strip(name), Z, N, a); << 131 const xercesc::DOMNamedNodeMap* const attributes = PElement->getAttributes(); 544 } << 132 XMLSize_t attributeCount = attributes->getLength(); 545 133 546 // ------------------------------------------- << 134 for (XMLSize_t attribute_index=0; 547 void G4GDMLReadMaterials::MaterialRead( << 135 attribute_index<attributeCount; attribute_index++) 548 const xercesc::DOMElement* const materialEle << 136 { 549 { << 137 xercesc::DOMNode* attribute_node = attributes->item(attribute_index); 550 G4String name; << 138 551 G4double Z = 0.0; << 139 if (attribute_node->getNodeType() != xercesc::DOMNode::ATTRIBUTE_NODE) 552 G4double a = 0.0; << 140 { continue; } 553 G4double D = 0.0; << 141 554 G4State state = kStateUndefined; << 142 const xercesc::DOMAttr* const attribute 555 G4double T = NTP_Temperature; << 143 = dynamic_cast<xercesc::DOMAttr*>(attribute_node); 556 G4double P = STP_Pressure; << 144 const G4String attName = Transcode(attribute->getName()); 557 G4double MEE = -1.0; << 145 const G4String attValue = Transcode(attribute->getValue()); 558 << 146 559 const xercesc::DOMNamedNodeMap* const attrib << 147 if (attName=="value") { value = eval.Evaluate(attValue); } else 560 materialElement->getAttributes(); << 148 if (attName=="unit") { unit = eval.Evaluate(attValue); } 561 XMLSize_t attributeCount = attributes->getLe << 149 } 562 << 563 for(XMLSize_t attribute_index = 0; attribute << 564 ++attribute_index) << 565 { << 566 xercesc::DOMNode* attribute_node = attribu << 567 << 568 if(attribute_node->getNodeType() != xerces << 569 { << 570 continue; << 571 } << 572 << 573 const xercesc::DOMAttr* const attribute = << 574 dynamic_cast<xercesc::DOMAttr*>(attribut << 575 if(attribute == nullptr) << 576 { << 577 G4Exception("G4GDMLReadMaterials::Materi << 578 FatalException, "No attribut << 579 return; << 580 } << 581 const G4String attName = Transcode(attrib << 582 const G4String attValue = Transcode(attrib << 583 << 584 if(attName == "name") << 585 { << 586 name = GenerateName(attValue); << 587 } << 588 else if(attName == "Z") << 589 { << 590 Z = eval.Evaluate(attValue); << 591 } << 592 else if(attName == "state") << 593 { << 594 if(attValue == "solid") << 595 { << 596 state = kStateSolid; << 597 } << 598 else if(attValue == "liquid") << 599 { << 600 state = kStateLiquid; << 601 } << 602 else if(attValue == "gas") << 603 { << 604 state = kStateGas; << 605 } << 606 } << 607 } << 608 150 609 std::size_t nComponents = 0; << 151 return value*unit; 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 } 152 } 711 153 712 // ------------------------------------------- << 154 G4double G4GDMLReadMaterials::TRead(const xercesc::DOMElement* const TElement) 713 void G4GDMLReadMaterials::MixtureRead( << 714 const xercesc::DOMElement* const mixtureElem << 715 { << 716 for(xercesc::DOMNode* iter = mixtureElement- << 717 iter = iter->getNextSi << 718 { << 719 if(iter->getNodeType() != xercesc::DOMNode << 720 { << 721 continue; << 722 } << 723 << 724 const xercesc::DOMElement* const child = << 725 dynamic_cast<xercesc::DOMElement*>(iter) << 726 if(child == nullptr) << 727 { << 728 G4Exception("G4GDMLReadMaterials::Mixtur << 729 FatalException, "No child fo << 730 return; << 731 } << 732 const G4String tag = Transcode(child->getT << 733 << 734 if(tag == "fraction") << 735 { << 736 G4String ref; << 737 G4double n = FractionRead(child, ref); << 738 element->AddIsotope(GetIsotope(GenerateN << 739 } << 740 } << 741 } << 742 << 743 // ------------------------------------------- << 744 void G4GDMLReadMaterials::MixtureRead( << 745 const xercesc::DOMElement* const mixtureElem << 746 { 155 { 747 for(xercesc::DOMNode* iter = mixtureElement- << 156 G4double value = STP_Temperature; 748 iter = iter->getNextSi << 157 G4double unit = kelvin; 749 { << 750 if(iter->getNodeType() != xercesc::DOMNode << 751 { << 752 continue; << 753 } << 754 << 755 const xercesc::DOMElement* const child = << 756 dynamic_cast<xercesc::DOMElement*>(iter) << 757 if(child == nullptr) << 758 { << 759 G4Exception("G4GDMLReadMaterials::Mixtur << 760 FatalException, "No child fo << 761 return; << 762 } << 763 const G4String tag = Transcode(child->getT << 764 << 765 if(tag == "fraction") << 766 { << 767 G4String ref; << 768 G4double n = FractionRead(child, ref); << 769 158 770 G4Material* materialPtr = GetMaterial(Ge << 159 const xercesc::DOMNamedNodeMap* const attributes = TElement->getAttributes(); 771 G4Element* elementPtr = GetElement(Gen << 160 XMLSize_t attributeCount = attributes->getLength(); 772 161 773 if(elementPtr != nullptr) << 162 for (XMLSize_t attribute_index=0; >> 163 attribute_index<attributeCount; attribute_index++) >> 164 { >> 165 xercesc::DOMNode* attribute_node = attributes->item(attribute_index); >> 166 >> 167 if (attribute_node->getNodeType() != xercesc::DOMNode::ATTRIBUTE_NODE) >> 168 { continue; } >> 169 >> 170 const xercesc::DOMAttr* const attribute >> 171 = dynamic_cast<xercesc::DOMAttr*>(attribute_node); >> 172 const G4String attName = Transcode(attribute->getName()); >> 173 const G4String attValue = Transcode(attribute->getValue()); >> 174 >> 175 if (attName=="value") { value = eval.Evaluate(attValue); } else >> 176 if (attName=="unit") { unit = eval.Evaluate(attValue); } >> 177 } >> 178 >> 179 return value*unit; >> 180 } >> 181 >> 182 void G4GDMLReadMaterials:: >> 183 ElementRead(const xercesc::DOMElement* const elementElement) >> 184 { >> 185 G4String name; >> 186 G4String formula; >> 187 G4double a = 0.0; >> 188 G4double Z = 0.0; >> 189 >> 190 const xercesc::DOMNamedNodeMap* const attributes >> 191 = elementElement->getAttributes(); >> 192 XMLSize_t attributeCount = attributes->getLength(); >> 193 >> 194 for (XMLSize_t attribute_index=0; >> 195 attribute_index<attributeCount; attribute_index++) >> 196 { >> 197 xercesc::DOMNode* attribute_node = attributes->item(attribute_index); >> 198 >> 199 if (attribute_node->getNodeType() != xercesc::DOMNode::ATTRIBUTE_NODE) >> 200 { continue; } >> 201 >> 202 const xercesc::DOMAttr* const attribute >> 203 = dynamic_cast<xercesc::DOMAttr*>(attribute_node); >> 204 const G4String attName = Transcode(attribute->getName()); >> 205 const G4String attValue = Transcode(attribute->getValue()); >> 206 >> 207 if (attName=="name") { name = GenerateName(attValue); } else >> 208 if (attName=="formula") { formula = attValue; } else >> 209 if (attName=="Z") { Z = eval.Evaluate(attValue); } >> 210 } >> 211 >> 212 G4int nComponents = 0; >> 213 >> 214 for (xercesc::DOMNode* iter = elementElement->getFirstChild(); >> 215 iter != 0; iter = iter->getNextSibling()) >> 216 { >> 217 if (iter->getNodeType() != xercesc::DOMNode::ELEMENT_NODE) { continue; } >> 218 >> 219 const xercesc::DOMElement* const child >> 220 = dynamic_cast<xercesc::DOMElement*>(iter); >> 221 const G4String tag = Transcode(child->getTagName()); >> 222 >> 223 if (tag=="atom") { a = AtomRead(child); } else >> 224 if (tag=="fraction") { nComponents++; } >> 225 } >> 226 >> 227 if (nComponents>0) >> 228 { >> 229 MixtureRead(elementElement, >> 230 new G4Element(Strip(name),formula,nComponents)); >> 231 } >> 232 else >> 233 { >> 234 new G4Element(Strip(name),formula,Z,a); >> 235 } >> 236 } >> 237 >> 238 G4double G4GDMLReadMaterials:: >> 239 FractionRead(const xercesc::DOMElement* const fractionElement, G4String& ref) >> 240 { >> 241 G4double n = 0.0; >> 242 >> 243 const xercesc::DOMNamedNodeMap* const attributes >> 244 = fractionElement->getAttributes(); >> 245 XMLSize_t attributeCount = attributes->getLength(); >> 246 >> 247 for (XMLSize_t attribute_index=0; >> 248 attribute_index<attributeCount; attribute_index++) >> 249 { >> 250 xercesc::DOMNode* attribute_node = attributes->item(attribute_index); >> 251 >> 252 if (attribute_node->getNodeType() != xercesc::DOMNode::ATTRIBUTE_NODE) >> 253 { continue; } >> 254 >> 255 const xercesc::DOMAttr* const attribute >> 256 = dynamic_cast<xercesc::DOMAttr*>(attribute_node); >> 257 const G4String attName = Transcode(attribute->getName()); >> 258 const G4String attValue = Transcode(attribute->getValue()); >> 259 >> 260 if (attName=="n") { n = eval.Evaluate(attValue); } else >> 261 if (attName=="ref") { ref = attValue; } >> 262 } >> 263 >> 264 return n; >> 265 } >> 266 >> 267 void G4GDMLReadMaterials:: >> 268 IsotopeRead(const xercesc::DOMElement* const isotopeElement) >> 269 { >> 270 G4String name; >> 271 G4int Z = 0; >> 272 G4int N = 0; >> 273 G4double a = 0.0; >> 274 >> 275 const xercesc::DOMNamedNodeMap* const attributes >> 276 = isotopeElement->getAttributes(); >> 277 XMLSize_t attributeCount = attributes->getLength(); >> 278 >> 279 for (XMLSize_t attribute_index=0; >> 280 attribute_index<attributeCount;attribute_index++) >> 281 { >> 282 xercesc::DOMNode* attribute_node = attributes->item(attribute_index); >> 283 >> 284 if (attribute_node->getNodeType() != xercesc::DOMNode::ATTRIBUTE_NODE) >> 285 { continue; } >> 286 >> 287 const xercesc::DOMAttr* const attribute >> 288 = dynamic_cast<xercesc::DOMAttr*>(attribute_node); >> 289 const G4String attName = Transcode(attribute->getName()); >> 290 const G4String attValue = Transcode(attribute->getValue()); >> 291 >> 292 if (attName=="name") { name = GenerateName(attValue); } else >> 293 if (attName=="Z") { Z = eval.EvaluateInteger(attValue); } else >> 294 if (attName=="N") { N = eval.EvaluateInteger(attValue); } >> 295 } >> 296 >> 297 for (xercesc::DOMNode* iter = isotopeElement->getFirstChild(); >> 298 iter != 0; iter = iter->getNextSibling()) >> 299 { >> 300 if (iter->getNodeType() != xercesc::DOMNode::ELEMENT_NODE) { continue; } >> 301 >> 302 const xercesc::DOMElement* const child >> 303 = dynamic_cast<xercesc::DOMElement*>(iter); >> 304 const G4String tag = Transcode(child->getTagName()); >> 305 >> 306 if (tag=="atom") { a = AtomRead(child); } >> 307 } >> 308 >> 309 new G4Isotope(Strip(name),Z,N,a); >> 310 } >> 311 >> 312 void G4GDMLReadMaterials:: >> 313 MaterialRead(const xercesc::DOMElement* const materialElement) >> 314 { >> 315 G4String name; >> 316 G4double Z = 0.0; >> 317 G4double a = 0.0; >> 318 G4double D = 0.0; >> 319 G4State state = kStateUndefined; >> 320 G4double T = STP_Temperature; >> 321 G4double P = STP_Pressure; >> 322 >> 323 const xercesc::DOMNamedNodeMap* const attributes >> 324 = materialElement->getAttributes(); >> 325 XMLSize_t attributeCount = attributes->getLength(); >> 326 >> 327 for (XMLSize_t attribute_index=0; >> 328 attribute_index<attributeCount; attribute_index++) >> 329 { >> 330 xercesc::DOMNode* attribute_node = attributes->item(attribute_index); >> 331 >> 332 if (attribute_node->getNodeType() != xercesc::DOMNode::ATTRIBUTE_NODE) >> 333 { continue; } >> 334 >> 335 const xercesc::DOMAttr* const attribute >> 336 = dynamic_cast<xercesc::DOMAttr*>(attribute_node); >> 337 const G4String attName = Transcode(attribute->getName()); >> 338 const G4String attValue = Transcode(attribute->getValue()); >> 339 >> 340 if (attName=="name") { name = GenerateName(attValue); } else >> 341 if (attName=="Z") { Z = eval.Evaluate(attValue); } else >> 342 if (attName=="state") >> 343 { >> 344 if (attValue=="solid") { state = kStateSolid; } else >> 345 if (attValue=="liquid") { state = kStateLiquid; } else >> 346 if (attValue=="gas") { state = kStateGas; } >> 347 } >> 348 } >> 349 >> 350 size_t nComponents = 0; >> 351 >> 352 for (xercesc::DOMNode* iter = materialElement->getFirstChild(); >> 353 iter != 0; iter = iter->getNextSibling()) >> 354 { >> 355 if (iter->getNodeType() != xercesc::DOMNode::ELEMENT_NODE) { continue; } >> 356 >> 357 const xercesc::DOMElement* const child >> 358 = dynamic_cast<xercesc::DOMElement*>(iter); >> 359 const G4String tag = Transcode(child->getTagName()); >> 360 >> 361 if (tag=="atom") { a = AtomRead(child); } else >> 362 if (tag=="Dref") { D = GetQuantity(GenerateName(RefRead(child))); } else >> 363 if (tag=="Pref") { P = GetQuantity(GenerateName(RefRead(child))); } else >> 364 if (tag=="Tref") { T = GetQuantity(GenerateName(RefRead(child))); } else >> 365 if (tag=="D") { D = DRead(child); } else >> 366 if (tag=="P") { P = PRead(child); } else >> 367 if (tag=="T") { T = TRead(child); } else >> 368 if (tag=="fraction" || tag=="composite") { nComponents++; } >> 369 } >> 370 >> 371 G4Material* material = 0; >> 372 >> 373 if (nComponents==0) >> 374 { >> 375 material = new G4Material(Strip(name),Z,a,D,state,T,P); >> 376 } >> 377 else >> 378 { >> 379 material = new G4Material(Strip(name),D,nComponents,state,T,P); >> 380 MixtureRead(materialElement, material); >> 381 } >> 382 >> 383 for (xercesc::DOMNode* iter = materialElement->getFirstChild(); >> 384 iter != 0; iter = iter->getNextSibling()) >> 385 { >> 386 if (iter->getNodeType() != xercesc::DOMNode::ELEMENT_NODE) { continue; } >> 387 >> 388 const xercesc::DOMElement* const child >> 389 = dynamic_cast<xercesc::DOMElement*>(iter); >> 390 const G4String tag = Transcode(child->getTagName()); >> 391 >> 392 if (tag=="property") { PropertyRead(child,material); } >> 393 } >> 394 } >> 395 >> 396 void G4GDMLReadMaterials:: >> 397 MixtureRead(const xercesc::DOMElement *const mixtureElement, G4Element *element) >> 398 { >> 399 for (xercesc::DOMNode* iter = mixtureElement->getFirstChild(); >> 400 iter != 0; iter = iter->getNextSibling()) >> 401 { >> 402 if (iter->getNodeType() != xercesc::DOMNode::ELEMENT_NODE) { continue; } >> 403 >> 404 const xercesc::DOMElement* const child >> 405 = dynamic_cast<xercesc::DOMElement*>(iter); >> 406 const G4String tag = Transcode(child->getTagName()); >> 407 >> 408 if (tag=="fraction") >> 409 { >> 410 G4String ref; >> 411 G4double n = FractionRead(child,ref); >> 412 element->AddIsotope(GetIsotope(GenerateName(ref,true)),n); >> 413 } >> 414 } >> 415 } >> 416 >> 417 void G4GDMLReadMaterials:: >> 418 MixtureRead(const xercesc::DOMElement *const mixtureElement, >> 419 G4Material *material) >> 420 { >> 421 for (xercesc::DOMNode* iter = mixtureElement->getFirstChild(); >> 422 iter != 0; iter = iter->getNextSibling()) >> 423 { >> 424 if (iter->getNodeType() != xercesc::DOMNode::ELEMENT_NODE) { continue; } >> 425 >> 426 const xercesc::DOMElement* const child >> 427 = dynamic_cast<xercesc::DOMElement*>(iter); >> 428 const G4String tag = Transcode(child->getTagName()); >> 429 >> 430 if (tag=="fraction") >> 431 { >> 432 G4String ref; >> 433 G4double n = FractionRead(child,ref); >> 434 >> 435 G4Material *materialPtr = GetMaterial(GenerateName(ref,true), false); >> 436 G4Element *elementPtr = GetElement(GenerateName(ref,true), false); >> 437 >> 438 if (materialPtr != 0) { material->AddMaterial(materialPtr,n); } else >> 439 if (elementPtr != 0) { material->AddElement(elementPtr,n); } >> 440 >> 441 if ((materialPtr == 0) && (elementPtr == 0)) >> 442 { >> 443 G4String error_msg = "Referenced material/element '" >> 444 + GenerateName(ref,true) + "' was not found!"; >> 445 G4Exception("G4GDMLReadMaterials::MixtureRead()", "InvalidSetup", >> 446 FatalException, error_msg); >> 447 } >> 448 } >> 449 else if (tag=="composite") >> 450 { >> 451 G4String ref; >> 452 G4int n = CompositeRead(child,ref); >> 453 >> 454 G4Element *elementPtr = GetElement(GenerateName(ref,true)); >> 455 material->AddElement(elementPtr,n); >> 456 } >> 457 } >> 458 } >> 459 >> 460 void G4GDMLReadMaterials:: >> 461 PropertyRead(const xercesc::DOMElement* const propertyElement, >> 462 G4Material* material) >> 463 { >> 464 G4String name; >> 465 G4String ref; >> 466 G4GDMLMatrix matrix; >> 467 >> 468 const xercesc::DOMNamedNodeMap* const attributes >> 469 = propertyElement->getAttributes(); >> 470 XMLSize_t attributeCount = attributes->getLength(); >> 471 >> 472 for (XMLSize_t attribute_index=0; >> 473 attribute_index<attributeCount; attribute_index++) >> 474 { >> 475 xercesc::DOMNode* attribute_node = attributes->item(attribute_index); >> 476 >> 477 if (attribute_node->getNodeType() != xercesc::DOMNode::ATTRIBUTE_NODE) >> 478 { continue; } >> 479 >> 480 const xercesc::DOMAttr* const attribute >> 481 = dynamic_cast<xercesc::DOMAttr*>(attribute_node); >> 482 const G4String attName = Transcode(attribute->getName()); >> 483 const G4String attValue = Transcode(attribute->getValue()); >> 484 >> 485 if (attName=="name") { name = GenerateName(attValue); } else >> 486 if (attName=="ref") { matrix = GetMatrix(ref=attValue); } >> 487 } >> 488 >> 489 if (matrix.GetCols() != 2) >> 490 { >> 491 G4String error_msg = "Referenced matrix '" + ref >> 492 + "' should have \n two columns as a property table for material: " >> 493 + material->GetName(); >> 494 G4Exception("G4GDMLReadMaterials::PropertyRead()", "InvalidRead", >> 495 FatalException, error_msg); >> 496 } >> 497 if (matrix.GetRows() == 0) { return; } >> 498 >> 499 G4MaterialPropertiesTable* matprop = material->GetMaterialPropertiesTable(); >> 500 if (!matprop) >> 501 { >> 502 material->SetMaterialPropertiesTable( >> 503 matprop = new G4MaterialPropertiesTable()); >> 504 } >> 505 G4MaterialPropertyVector* propvect = new G4MaterialPropertyVector(0,0,0); >> 506 for (size_t i=0; i<matrix.GetRows(); i++) >> 507 { >> 508 propvect->AddElement(matrix.Get(i,0),matrix.Get(i,1)); >> 509 } >> 510 matprop->AddProperty(Strip(name),propvect); >> 511 } >> 512 >> 513 void G4GDMLReadMaterials:: >> 514 MaterialsRead(const xercesc::DOMElement* const materialsElement) >> 515 { >> 516 G4cout << "G4GDML: Reading materials..." << G4endl; >> 517 >> 518 for (xercesc::DOMNode* iter = materialsElement->getFirstChild(); >> 519 iter != 0; iter = iter->getNextSibling()) >> 520 { >> 521 if (iter->getNodeType() != xercesc::DOMNode::ELEMENT_NODE) { continue; } >> 522 >> 523 const xercesc::DOMElement* const child >> 524 = dynamic_cast<xercesc::DOMElement*>(iter); >> 525 const G4String tag = Transcode(child->getTagName()); >> 526 >> 527 if (tag=="element") { ElementRead(child); } else >> 528 if (tag=="isotope") { IsotopeRead(child); } else >> 529 if (tag=="material") { MaterialRead(child); } >> 530 else 774 { 531 { 775 material->AddElement(elementPtr, n); << 532 G4String error_msg = "Unknown tag in materials: " + tag; 776 } << 533 G4Exception("G4GDMLReadMaterials::MaterialsRead()", "InvalidSetup", 777 else if(materialPtr != nullptr) << 778 { << 779 material->AddMaterial(materialPtr, n); << 780 } << 781 << 782 if((materialPtr == nullptr) && (elementP << 783 { << 784 G4String error_msg = "Referenced mater << 785 GenerateName(ref, << 786 G4Exception("G4GDMLReadMaterials::Mixt << 787 FatalException, error_msg) 534 FatalException, error_msg); 788 } 535 } 789 } << 536 } 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 } 537 } 800 538 801 // ------------------------------------------- << 539 G4Element* G4GDMLReadMaterials:: 802 void G4GDMLReadMaterials::PropertyRead( << 540 GetElement(const G4String& ref, G4bool verbose) const 803 const xercesc::DOMElement* const propertyEle << 804 { 541 { 805 G4String name; << 542 G4Element* elementPtr = G4Element::GetElement(ref,false); 806 G4String ref; << 807 G4GDMLMatrix matrix; << 808 << 809 const xercesc::DOMNamedNodeMap* const attrib << 810 propertyElement->getAttributes(); << 811 XMLSize_t attributeCount = attributes->getLe << 812 << 813 for(XMLSize_t attribute_index = 0; attribute << 814 ++attribute_index) << 815 { << 816 xercesc::DOMNode* attribute_node = attribu << 817 << 818 if(attribute_node->getNodeType() != xerces << 819 { << 820 continue; << 821 } << 822 << 823 const xercesc::DOMAttr* const attribute = << 824 dynamic_cast<xercesc::DOMAttr*>(attribut << 825 if(attribute == nullptr) << 826 { << 827 G4Exception("G4GDMLReadMaterials::Proper << 828 FatalException, "No attribut << 829 return; << 830 } << 831 const G4String attName = Transcode(attrib << 832 const G4String attValue = Transcode(attrib << 833 << 834 if(attName == "name") << 835 { << 836 name = GenerateName(attValue); << 837 } << 838 else if(attName == "ref") << 839 { << 840 matrix = GetMatrix(ref = attValue); << 841 } << 842 } << 843 << 844 /* << 845 if (matrix.GetCols() != 2) << 846 { << 847 G4String error_msg = "Referenced matrix '" << 848 + "' should have \n two columns as << 849 + material->GetName(); << 850 G4Exception("G4GDMLReadMaterials::Property << 851 FatalException, error_msg); << 852 } << 853 */ << 854 << 855 if(matrix.GetRows() == 0) << 856 { << 857 return; << 858 } << 859 << 860 G4MaterialPropertiesTable* matprop = materia << 861 if(matprop == nullptr) << 862 { << 863 matprop = new G4MaterialPropertiesTable(); << 864 material->SetMaterialPropertiesTable(matpr << 865 } << 866 if(matrix.GetCols() == 1) // constant prope << 867 { << 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 } << 880 << 881 // ------------------------------------------- << 882 void G4GDMLReadMaterials::MaterialsRead( << 883 const xercesc::DOMElement* const materialsEl << 884 { << 885 #ifdef G4VERBOSE << 886 G4cout << "G4GDML: Reading materials..." << << 887 #endif << 888 for(xercesc::DOMNode* iter = materialsElemen << 889 iter != nullptr; iter << 890 { << 891 if(iter->getNodeType() != xercesc::DOMNode << 892 { << 893 continue; << 894 } << 895 << 896 const xercesc::DOMElement* const child = << 897 dynamic_cast<xercesc::DOMElement*>(iter) << 898 if(child == nullptr) << 899 { << 900 G4Exception("G4GDMLReadMaterials::Materi << 901 FatalException, "No child fo << 902 return; << 903 } << 904 const G4String tag = Transcode(child->getT << 905 << 906 if(tag == "define") << 907 { << 908 DefineRead(child); << 909 } << 910 else if(tag == "element") << 911 { << 912 ElementRead(child); << 913 } << 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 } << 930 543 931 // ------------------------------------------- << 544 if (!elementPtr) 932 G4Element* G4GDMLReadMaterials::GetElement(con << 545 { 933 G4b << 546 elementPtr = G4NistManager::Instance()->FindOrBuildElement(ref); 934 { << 547 } 935 G4Element* elementPtr = G4Element::GetElemen << 936 548 937 if(elementPtr == nullptr) << 549 if (verbose && !elementPtr) 938 { << 550 { 939 elementPtr = G4NistManager::Instance()->Fi << 551 G4String error_msg = "Referenced element '" + ref + "' was not found!"; 940 } << 552 G4Exception("G4GDMLReadMaterials::GetElement()", "InvalidRead", 941 << 553 FatalException, error_msg); 942 if(verbose && elementPtr == nullptr) << 554 } 943 { << 944 G4String error_msg = "Referenced element ' << 945 G4Exception("G4GDMLReadMaterials::GetEleme << 946 FatalException, error_msg); << 947 } << 948 555 949 return elementPtr; << 556 return elementPtr; 950 } 557 } 951 558 952 // ------------------------------------------- << 953 G4Isotope* G4GDMLReadMaterials::GetIsotope(con 559 G4Isotope* G4GDMLReadMaterials::GetIsotope(const G4String& ref, 954 G4b 560 G4bool verbose) const 955 { 561 { 956 G4Isotope* isotopePtr = G4Isotope::GetIsotop << 562 G4Isotope* isotopePtr = G4Isotope::GetIsotope(ref,false); 957 563 958 if(verbose && isotopePtr == nullptr) << 564 if (verbose && !isotopePtr) 959 { << 565 { 960 G4String error_msg = "Referenced isotope ' << 566 G4String error_msg = "Referenced isotope '" + ref + "' was not found!"; 961 G4Exception("G4GDMLReadMaterials::GetIsoto << 567 G4Exception("G4GDMLReadMaterials::GetIsotope()", "InvalidRead", 962 FatalException, error_msg); << 568 FatalException, error_msg); 963 } << 569 } 964 570 965 return isotopePtr; << 571 return isotopePtr; 966 } 572 } 967 573 968 // ------------------------------------------- << 969 G4Material* G4GDMLReadMaterials::GetMaterial(c 574 G4Material* G4GDMLReadMaterials::GetMaterial(const G4String& ref, 970 G 575 G4bool verbose) const 971 { 576 { 972 G4Material* materialPtr = G4Material::GetMat << 577 G4Material *materialPtr = G4Material::GetMaterial(ref,false); 973 578 974 if(materialPtr == nullptr) << 579 if (!materialPtr) 975 { << 580 { 976 materialPtr = G4NistManager::Instance()->F << 581 materialPtr = G4NistManager::Instance()->FindOrBuildMaterial(ref); 977 } << 582 } 978 << 583 979 if(verbose && materialPtr == nullptr) << 584 if (verbose && !materialPtr) 980 { << 585 { 981 G4String error_msg = "Referenced material << 586 G4String error_msg = "Referenced material '" + ref + "' was not found!"; 982 G4Exception("G4GDMLReadMaterials::GetMater << 587 G4Exception("G4GDMLReadMaterials::GetMaterial()", "InvalidRead", 983 FatalException, error_msg); << 588 FatalException, error_msg); 984 } << 589 } 985 590 986 return materialPtr; << 591 return materialPtr; 987 } 592 } 988 593