Geant4 9.6.0
Toolkit for the simulation of the passage of particles through matter
Loading...
Searching...
No Matches
G4GDMLReadMaterials.cc
Go to the documentation of this file.
1//
2// ********************************************************************
3// * License and Disclaimer *
4// * *
5// * The Geant4 software is copyright of the Copyright Holders of *
6// * the Geant4 Collaboration. It is provided under the terms and *
7// * conditions of the Geant4 Software License, included in the file *
8// * LICENSE and available at http://cern.ch/geant4/license . These *
9// * include a list of copyright holders. *
10// * *
11// * Neither the authors of this software system, nor their employing *
12// * institutes,nor the agencies providing financial support for this *
13// * work make any representation or warranty, express or implied, *
14// * regarding this software system or assume any liability for its *
15// * use. Please see the license in the file LICENSE and URL above *
16// * for the full disclaimer and the limitation of liability. *
17// * *
18// * This code implementation is the result of the scientific and *
19// * technical work of the GEANT4 collaboration. *
20// * By using, copying, modifying or distributing the software (or *
21// * any work based on the software) you agree to acknowledge its *
22// * use in resulting scientific publications, and indicate your *
23// * acceptance of all terms of the Geant4 Software license. *
24// ********************************************************************
25//
26//
27// $Id$
28// GEANT4 tag $ Name:$
29//
30// class G4GDMLReadMaterials Implementation
31//
32// Original author: Zoltan Torzsok, November 2007
33//
34// --------------------------------------------------------------------
35
36#include "G4GDMLReadMaterials.hh"
37
38#include "G4PhysicalConstants.hh"
39#include "G4SystemOfUnits.hh"
40#include "G4Element.hh"
41#include "G4Isotope.hh"
42#include "G4Material.hh"
43#include "G4NistManager.hh"
44
45G4GDMLReadMaterials::G4GDMLReadMaterials() : G4GDMLReadDefine()
46{
47}
48
49G4GDMLReadMaterials::~G4GDMLReadMaterials()
50{
51}
52
53G4double
54G4GDMLReadMaterials::AtomRead(const xercesc::DOMElement* const atomElement)
55{
56 G4double value = 0.0;
57 G4double unit = g/mole;
58
59 const xercesc::DOMNamedNodeMap* const attributes
60 = atomElement->getAttributes();
61 XMLSize_t attributeCount = attributes->getLength();
62
63 for (XMLSize_t attribute_index=0;
64 attribute_index<attributeCount; attribute_index++)
65 {
66 xercesc::DOMNode* attribute_node = attributes->item(attribute_index);
67
68 if (attribute_node->getNodeType() != xercesc::DOMNode::ATTRIBUTE_NODE)
69 { continue; }
70
71 const xercesc::DOMAttr* const attribute
72 = dynamic_cast<xercesc::DOMAttr*>(attribute_node);
73 if (!attribute)
74 {
75 G4Exception("G4GDMLReadMaterials::AtomRead()", "InvalidRead",
76 FatalException, "No attribute found!");
77 return value;
78 }
79 const G4String attName = Transcode(attribute->getName());
80 const G4String attValue = Transcode(attribute->getValue());
81
82 if (attName=="value") { value = eval.Evaluate(attValue); } else
83 if (attName=="unit") { unit = eval.Evaluate(attValue); }
84 }
85
86 return value*unit;
87}
88
89G4int G4GDMLReadMaterials::
90CompositeRead(const xercesc::DOMElement* const compositeElement,G4String& ref)
91{
92 G4int n = 0;
93
94 const xercesc::DOMNamedNodeMap* const attributes
95 = compositeElement->getAttributes();
96 XMLSize_t attributeCount = attributes->getLength();
97
98 for (XMLSize_t attribute_index=0;
99 attribute_index<attributeCount; attribute_index++)
100 {
101 xercesc::DOMNode* attribute_node = attributes->item(attribute_index);
102
103 if (attribute_node->getNodeType() != xercesc::DOMNode::ATTRIBUTE_NODE)
104 { continue; }
105
106 const xercesc::DOMAttr* const attribute
107 = dynamic_cast<xercesc::DOMAttr*>(attribute_node);
108 if (!attribute)
109 {
110 G4Exception("G4GDMLReadMaterials::CompositeRead()", "InvalidRead",
111 FatalException, "No attribute found!");
112 return n;
113 }
114 const G4String attName = Transcode(attribute->getName());
115 const G4String attValue = Transcode(attribute->getValue());
116
117 if (attName=="n") { n = eval.EvaluateInteger(attValue); } else
118 if (attName=="ref") { ref = attValue; }
119 }
120
121 return n;
122}
123
124G4double G4GDMLReadMaterials::DRead(const xercesc::DOMElement* const DElement)
125{
126 G4double value = 0.0;
127 G4double unit = g/cm3;
128
129 const xercesc::DOMNamedNodeMap* const attributes
130 = DElement->getAttributes();
131 XMLSize_t attributeCount = attributes->getLength();
132
133 for (XMLSize_t attribute_index=0;
134 attribute_index<attributeCount; attribute_index++)
135 {
136 xercesc::DOMNode* attribute_node = attributes->item(attribute_index);
137
138 if (attribute_node->getNodeType() != xercesc::DOMNode::ATTRIBUTE_NODE)
139 { continue; }
140
141 const xercesc::DOMAttr* const attribute
142 = dynamic_cast<xercesc::DOMAttr*>(attribute_node);
143 if (!attribute)
144 {
145 G4Exception("G4GDMLReadMaterials::DRead()", "InvalidRead",
146 FatalException, "No attribute found!");
147 return value;
148 }
149 const G4String attName = Transcode(attribute->getName());
150 const G4String attValue = Transcode(attribute->getValue());
151
152 if (attName=="value") { value = eval.Evaluate(attValue); } else
153 if (attName=="unit") { unit = eval.Evaluate(attValue); }
154 }
155
156 return value*unit;
157}
158
159G4double G4GDMLReadMaterials::PRead(const xercesc::DOMElement* const PElement)
160{
161 G4double value = STP_Pressure;
162 G4double unit = pascal;
163
164 const xercesc::DOMNamedNodeMap* const attributes = PElement->getAttributes();
165 XMLSize_t attributeCount = attributes->getLength();
166
167 for (XMLSize_t attribute_index=0;
168 attribute_index<attributeCount; attribute_index++)
169 {
170 xercesc::DOMNode* attribute_node = attributes->item(attribute_index);
171
172 if (attribute_node->getNodeType() != xercesc::DOMNode::ATTRIBUTE_NODE)
173 { continue; }
174
175 const xercesc::DOMAttr* const attribute
176 = dynamic_cast<xercesc::DOMAttr*>(attribute_node);
177 if (!attribute)
178 {
179 G4Exception("G4GDMLReadMaterials::PRead()", "InvalidRead",
180 FatalException, "No attribute found!");
181 return value;
182 }
183 const G4String attName = Transcode(attribute->getName());
184 const G4String attValue = Transcode(attribute->getValue());
185
186 if (attName=="value") { value = eval.Evaluate(attValue); } else
187 if (attName=="unit") { unit = eval.Evaluate(attValue); }
188 }
189
190 return value*unit;
191}
192
193G4double G4GDMLReadMaterials::TRead(const xercesc::DOMElement* const TElement)
194{
195 G4double value = STP_Temperature;
196 G4double unit = kelvin;
197
198 const xercesc::DOMNamedNodeMap* const attributes = TElement->getAttributes();
199 XMLSize_t attributeCount = attributes->getLength();
200
201 for (XMLSize_t attribute_index=0;
202 attribute_index<attributeCount; attribute_index++)
203 {
204 xercesc::DOMNode* attribute_node = attributes->item(attribute_index);
205
206 if (attribute_node->getNodeType() != xercesc::DOMNode::ATTRIBUTE_NODE)
207 { continue; }
208
209 const xercesc::DOMAttr* const attribute
210 = dynamic_cast<xercesc::DOMAttr*>(attribute_node);
211 if (!attribute)
212 {
213 G4Exception("G4GDMLReadMaterials::TRead()", "InvalidRead",
214 FatalException, "No attribute found!");
215 return value;
216 }
217 const G4String attName = Transcode(attribute->getName());
218 const G4String attValue = Transcode(attribute->getValue());
219
220 if (attName=="value") { value = eval.Evaluate(attValue); } else
221 if (attName=="unit") { unit = eval.Evaluate(attValue); }
222 }
223
224 return value*unit;
225}
226
227G4double G4GDMLReadMaterials::MEERead(const xercesc::DOMElement* const PElement)
228{
229 G4double value = -1;
230 G4double unit = eV;
231
232 const xercesc::DOMNamedNodeMap* const attributes = PElement->getAttributes();
233 XMLSize_t attributeCount = attributes->getLength();
234
235 for (XMLSize_t attribute_index=0;
236 attribute_index<attributeCount; attribute_index++)
237 {
238 xercesc::DOMNode* attribute_node = attributes->item(attribute_index);
239
240 if (attribute_node->getNodeType() != xercesc::DOMNode::ATTRIBUTE_NODE)
241 { continue; }
242
243 const xercesc::DOMAttr* const attribute
244 = dynamic_cast<xercesc::DOMAttr*>(attribute_node);
245 if (!attribute)
246 {
247 G4Exception("G4GDMLReadMaterials::MEERead()", "InvalidRead",
248 FatalException, "No attribute found!");
249 return value;
250 }
251 const G4String attName = Transcode(attribute->getName());
252 const G4String attValue = Transcode(attribute->getValue());
253
254 if (attName=="value") { value = eval.Evaluate(attValue); } else
255 if (attName=="unit") { unit = eval.Evaluate(attValue); }
256 }
257
258 return value*unit;
259}
260
261void G4GDMLReadMaterials::
262ElementRead(const xercesc::DOMElement* const elementElement)
263{
264 G4String name;
265 G4String formula;
266 G4double a = 0.0;
267 G4double Z = 0.0;
268
269 const xercesc::DOMNamedNodeMap* const attributes
270 = elementElement->getAttributes();
271 XMLSize_t attributeCount = attributes->getLength();
272
273 for (XMLSize_t attribute_index=0;
274 attribute_index<attributeCount; attribute_index++)
275 {
276 xercesc::DOMNode* attribute_node = attributes->item(attribute_index);
277
278 if (attribute_node->getNodeType() != xercesc::DOMNode::ATTRIBUTE_NODE)
279 { continue; }
280
281 const xercesc::DOMAttr* const attribute
282 = dynamic_cast<xercesc::DOMAttr*>(attribute_node);
283 if (!attribute)
284 {
285 G4Exception("G4GDMLReadMaterials::ElementRead()", "InvalidRead",
286 FatalException, "No attribute found!");
287 return;
288 }
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=="formula") { formula = attValue; } else
294 if (attName=="Z") { Z = eval.Evaluate(attValue); }
295 }
296
297 G4int nComponents = 0;
298
299 for (xercesc::DOMNode* iter = elementElement->getFirstChild();
300 iter != 0; iter = iter->getNextSibling())
301 {
302 if (iter->getNodeType() != xercesc::DOMNode::ELEMENT_NODE) { continue; }
303
304 const xercesc::DOMElement* const child
305 = dynamic_cast<xercesc::DOMElement*>(iter);
306 if (!child)
307 {
308 G4Exception("G4GDMLReadMaterials::ElementRead()", "InvalidRead",
309 FatalException, "No child found!");
310 return;
311 }
312 const G4String tag = Transcode(child->getTagName());
313
314 if (tag=="atom") { a = AtomRead(child); } else
315 if (tag=="fraction") { nComponents++; }
316 }
317
318 if (nComponents>0)
319 {
320 MixtureRead(elementElement,
321 new G4Element(Strip(name),formula,nComponents));
322 }
323 else
324 {
325 new G4Element(Strip(name),formula,Z,a);
326 }
327}
328
329G4double G4GDMLReadMaterials::
330FractionRead(const xercesc::DOMElement* const fractionElement, G4String& ref)
331{
332 G4double n = 0.0;
333
334 const xercesc::DOMNamedNodeMap* const attributes
335 = fractionElement->getAttributes();
336 XMLSize_t attributeCount = attributes->getLength();
337
338 for (XMLSize_t attribute_index=0;
339 attribute_index<attributeCount; attribute_index++)
340 {
341 xercesc::DOMNode* attribute_node = attributes->item(attribute_index);
342
343 if (attribute_node->getNodeType() != xercesc::DOMNode::ATTRIBUTE_NODE)
344 { continue; }
345
346 const xercesc::DOMAttr* const attribute
347 = dynamic_cast<xercesc::DOMAttr*>(attribute_node);
348 if (!attribute)
349 {
350 G4Exception("G4GDMLReadMaterials::FractionRead()", "InvalidRead",
351 FatalException, "No attribute found!");
352 return n;
353 }
354 const G4String attName = Transcode(attribute->getName());
355 const G4String attValue = Transcode(attribute->getValue());
356
357 if (attName=="n") { n = eval.Evaluate(attValue); } else
358 if (attName=="ref") { ref = attValue; }
359 }
360
361 return n;
362}
363
364void G4GDMLReadMaterials::
365IsotopeRead(const xercesc::DOMElement* const isotopeElement)
366{
367 G4String name;
368 G4int Z = 0;
369 G4int N = 0;
370 G4double a = 0.0;
371
372 const xercesc::DOMNamedNodeMap* const attributes
373 = isotopeElement->getAttributes();
374 XMLSize_t attributeCount = attributes->getLength();
375
376 for (XMLSize_t attribute_index=0;
377 attribute_index<attributeCount;attribute_index++)
378 {
379 xercesc::DOMNode* attribute_node = attributes->item(attribute_index);
380
381 if (attribute_node->getNodeType() != xercesc::DOMNode::ATTRIBUTE_NODE)
382 { continue; }
383
384 const xercesc::DOMAttr* const attribute
385 = dynamic_cast<xercesc::DOMAttr*>(attribute_node);
386 if (!attribute)
387 {
388 G4Exception("G4GDMLReadMaterials::IsotopeRead()", "InvalidRead",
389 FatalException, "No attribute found!");
390 return;
391 }
392 const G4String attName = Transcode(attribute->getName());
393 const G4String attValue = Transcode(attribute->getValue());
394
395 if (attName=="name") { name = GenerateName(attValue); } else
396 if (attName=="Z") { Z = eval.EvaluateInteger(attValue); } else
397 if (attName=="N") { N = eval.EvaluateInteger(attValue); }
398 }
399
400 for (xercesc::DOMNode* iter = isotopeElement->getFirstChild();
401 iter != 0; iter = iter->getNextSibling())
402 {
403 if (iter->getNodeType() != xercesc::DOMNode::ELEMENT_NODE) { continue; }
404
405 const xercesc::DOMElement* const child
406 = dynamic_cast<xercesc::DOMElement*>(iter);
407 if (!child)
408 {
409 G4Exception("G4GDMLReadMaterials::IsotopeRead()", "InvalidRead",
410 FatalException, "No child found!");
411 return;
412 }
413 const G4String tag = Transcode(child->getTagName());
414
415 if (tag=="atom") { a = AtomRead(child); }
416 }
417
418 new G4Isotope(Strip(name),Z,N,a);
419}
420
421void G4GDMLReadMaterials::
422MaterialRead(const xercesc::DOMElement* const materialElement)
423{
424 G4String name;
425 G4double Z = 0.0;
426 G4double a = 0.0;
427 G4double D = 0.0;
428 G4State state = kStateUndefined;
429 G4double T = STP_Temperature;
430 G4double P = STP_Pressure;
431 G4double MEE = -1.0;
432
433 const xercesc::DOMNamedNodeMap* const attributes
434 = materialElement->getAttributes();
435 XMLSize_t attributeCount = attributes->getLength();
436
437 for (XMLSize_t attribute_index=0;
438 attribute_index<attributeCount; attribute_index++)
439 {
440 xercesc::DOMNode* attribute_node = attributes->item(attribute_index);
441
442 if (attribute_node->getNodeType() != xercesc::DOMNode::ATTRIBUTE_NODE)
443 { continue; }
444
445 const xercesc::DOMAttr* const attribute
446 = dynamic_cast<xercesc::DOMAttr*>(attribute_node);
447 if (!attribute)
448 {
449 G4Exception("G4GDMLReadMaterials::MaterialRead()", "InvalidRead",
450 FatalException, "No attribute found!");
451 return;
452 }
453 const G4String attName = Transcode(attribute->getName());
454 const G4String attValue = Transcode(attribute->getValue());
455
456 if (attName=="name") { name = GenerateName(attValue); } else
457 if (attName=="Z") { Z = eval.Evaluate(attValue); } else
458 if (attName=="state")
459 {
460 if (attValue=="solid") { state = kStateSolid; } else
461 if (attValue=="liquid") { state = kStateLiquid; } else
462 if (attValue=="gas") { state = kStateGas; }
463 }
464 }
465
466 size_t nComponents = 0;
467
468 for (xercesc::DOMNode* iter = materialElement->getFirstChild();
469 iter != 0; iter = iter->getNextSibling())
470 {
471 if (iter->getNodeType() != xercesc::DOMNode::ELEMENT_NODE) { continue; }
472
473 const xercesc::DOMElement* const child
474 = dynamic_cast<xercesc::DOMElement*>(iter);
475 if (!child)
476 {
477 G4Exception("G4GDMLReadMaterials::MaterialRead()", "InvalidRead",
478 FatalException, "No child found!");
479 return;
480 }
481 const G4String tag = Transcode(child->getTagName());
482
483 if (tag=="atom") { a = AtomRead(child); } else
484 if (tag=="Dref") { D = GetQuantity(GenerateName(RefRead(child))); } else
485 if (tag=="Pref") { P = GetQuantity(GenerateName(RefRead(child))); } else
486 if (tag=="Tref") { T = GetQuantity(GenerateName(RefRead(child))); } else
487 if (tag=="MEEref") { MEE = GetQuantity(GenerateName(RefRead(child))); } else
488 if (tag=="D") { D = DRead(child); } else
489 if (tag=="P") { P = PRead(child); } else
490 if (tag=="T") { T = TRead(child); } else
491 if (tag=="MEE") { MEE = MEERead(child); } else
492 if (tag=="fraction" || tag=="composite") { nComponents++; }
493 }
494
495 G4Material* material = 0;
496
497 if (nComponents==0)
498 {
499 material = new G4Material(Strip(name),Z,a,D,state,T,P);
500 }
501 else
502 {
503 material = new G4Material(Strip(name),D,nComponents,state,T,P);
504 MixtureRead(materialElement, material);
505 }
506 if (MEE != -1) // ionisation potential (mean excitation energy)
507 {
508 material->GetIonisation()->SetMeanExcitationEnergy(MEE);
509 }
510
511 for (xercesc::DOMNode* iter = materialElement->getFirstChild();
512 iter != 0; iter = iter->getNextSibling())
513 {
514 if (iter->getNodeType() != xercesc::DOMNode::ELEMENT_NODE) { continue; }
515
516 const xercesc::DOMElement* const child
517 = dynamic_cast<xercesc::DOMElement*>(iter);
518 if (!child)
519 {
520 G4Exception("G4GDMLReadMaterials::MaterialRead()", "InvalidRead",
521 FatalException, "No child found!");
522 return;
523 }
524 const G4String tag = Transcode(child->getTagName());
525
526 if (tag=="property") { PropertyRead(child,material); }
527 }
528}
529
530void G4GDMLReadMaterials::
531MixtureRead(const xercesc::DOMElement *const mixtureElement, G4Element *element)
532{
533 for (xercesc::DOMNode* iter = mixtureElement->getFirstChild();
534 iter != 0; iter = iter->getNextSibling())
535 {
536 if (iter->getNodeType() != xercesc::DOMNode::ELEMENT_NODE) { continue; }
537
538 const xercesc::DOMElement* const child
539 = dynamic_cast<xercesc::DOMElement*>(iter);
540 if (!child)
541 {
542 G4Exception("G4GDMLReadMaterials::MixtureRead()", "InvalidRead",
543 FatalException, "No child found!");
544 return;
545 }
546 const G4String tag = Transcode(child->getTagName());
547
548 if (tag=="fraction")
549 {
550 G4String ref;
551 G4double n = FractionRead(child,ref);
552 element->AddIsotope(GetIsotope(GenerateName(ref,true)),n);
553 }
554 }
555}
556
557void G4GDMLReadMaterials::
558MixtureRead(const xercesc::DOMElement *const mixtureElement,
559 G4Material *material)
560{
561 for (xercesc::DOMNode* iter = mixtureElement->getFirstChild();
562 iter != 0; iter = iter->getNextSibling())
563 {
564 if (iter->getNodeType() != xercesc::DOMNode::ELEMENT_NODE) { continue; }
565
566 const xercesc::DOMElement* const child
567 = dynamic_cast<xercesc::DOMElement*>(iter);
568 if (!child)
569 {
570 G4Exception("G4GDMLReadMaterials::MixtureRead()", "InvalidRead",
571 FatalException, "No child found!");
572 return;
573 }
574 const G4String tag = Transcode(child->getTagName());
575
576 if (tag=="fraction")
577 {
578 G4String ref;
579 G4double n = FractionRead(child,ref);
580
581 G4Material *materialPtr = GetMaterial(GenerateName(ref,true), false);
582 G4Element *elementPtr = GetElement(GenerateName(ref,true), false);
583
584 if (materialPtr != 0) { material->AddMaterial(materialPtr,n); } else
585 if (elementPtr != 0) { material->AddElement(elementPtr,n); }
586
587 if ((materialPtr == 0) && (elementPtr == 0))
588 {
589 G4String error_msg = "Referenced material/element '"
590 + GenerateName(ref,true) + "' was not found!";
591 G4Exception("G4GDMLReadMaterials::MixtureRead()", "InvalidSetup",
592 FatalException, error_msg);
593 }
594 }
595 else if (tag=="composite")
596 {
597 G4String ref;
598 G4int n = CompositeRead(child,ref);
599
600 G4Element *elementPtr = GetElement(GenerateName(ref,true));
601 material->AddElement(elementPtr,n);
602 }
603 }
604}
605
606void G4GDMLReadMaterials::
607PropertyRead(const xercesc::DOMElement* const propertyElement,
608 G4Material* material)
609{
610 G4String name;
611 G4String ref;
612 G4GDMLMatrix matrix;
613
614 const xercesc::DOMNamedNodeMap* const attributes
615 = propertyElement->getAttributes();
616 XMLSize_t attributeCount = attributes->getLength();
617
618 for (XMLSize_t attribute_index=0;
619 attribute_index<attributeCount; attribute_index++)
620 {
621 xercesc::DOMNode* attribute_node = attributes->item(attribute_index);
622
623 if (attribute_node->getNodeType() != xercesc::DOMNode::ATTRIBUTE_NODE)
624 { continue; }
625
626 const xercesc::DOMAttr* const attribute
627 = dynamic_cast<xercesc::DOMAttr*>(attribute_node);
628 if (!attribute)
629 {
630 G4Exception("G4GDMLReadMaterials::PropertyRead()", "InvalidRead",
631 FatalException, "No attribute found!");
632 return;
633 }
634 const G4String attName = Transcode(attribute->getName());
635 const G4String attValue = Transcode(attribute->getValue());
636
637 if (attName=="name") { name = GenerateName(attValue); } else
638 if (attName=="ref") { matrix = GetMatrix(ref=attValue); }
639 }
640
641 /*
642 if (matrix.GetCols() != 2)
643 {
644 G4String error_msg = "Referenced matrix '" + ref
645 + "' should have \n two columns as a property table for material: "
646 + material->GetName();
647 G4Exception("G4GDMLReadMaterials::PropertyRead()", "InvalidRead",
648 FatalException, error_msg);
649 }
650 */
651
652 if (matrix.GetRows() == 0) { return; }
653
654 G4MaterialPropertiesTable* matprop=material->GetMaterialPropertiesTable();
655 if (!matprop)
656 {
657 matprop = new G4MaterialPropertiesTable();
658 material->SetMaterialPropertiesTable(matprop);
659 }
660 if (matrix.GetCols() == 1) // constant property assumed
661 {
662 matprop->AddConstProperty(Strip(name), matrix.Get(0,0));
663 }
664 else // build the material properties vector
665 {
666 G4MaterialPropertyVector* propvect = new G4MaterialPropertyVector();
667 for (size_t i=0; i<matrix.GetRows(); i++)
668 {
669 propvect->InsertValues(matrix.Get(i,0),matrix.Get(i,1));
670 }
671 matprop->AddProperty(Strip(name),propvect);
672 }
673}
674
675void G4GDMLReadMaterials::
676MaterialsRead(const xercesc::DOMElement* const materialsElement)
677{
678 G4cout << "G4GDML: Reading materials..." << G4endl;
679
680 for (xercesc::DOMNode* iter = materialsElement->getFirstChild();
681 iter != 0; iter = iter->getNextSibling())
682 {
683 if (iter->getNodeType() != xercesc::DOMNode::ELEMENT_NODE) { continue; }
684
685 const xercesc::DOMElement* const child
686 = dynamic_cast<xercesc::DOMElement*>(iter);
687 if (!child)
688 {
689 G4Exception("G4GDMLReadMaterials::MaterialsRead()", "InvalidRead",
690 FatalException, "No child found!");
691 return;
692 }
693 const G4String tag = Transcode(child->getTagName());
694
695 if (tag=="define") { DefineRead(child); } else
696 if (tag=="element") { ElementRead(child); } else
697 if (tag=="isotope") { IsotopeRead(child); } else
698 if (tag=="material") { MaterialRead(child); }
699 else
700 {
701 G4String error_msg = "Unknown tag in materials: " + tag;
702 G4Exception("G4GDMLReadMaterials::MaterialsRead()", "InvalidSetup",
703 FatalException, error_msg);
704 }
705 }
706}
707
708G4Element* G4GDMLReadMaterials::
709GetElement(const G4String& ref, G4bool verbose) const
710{
711 G4Element* elementPtr = G4Element::GetElement(ref,false);
712
713 if (!elementPtr)
714 {
715 elementPtr = G4NistManager::Instance()->FindOrBuildElement(ref);
716 }
717
718 if (verbose && !elementPtr)
719 {
720 G4String error_msg = "Referenced element '" + ref + "' was not found!";
721 G4Exception("G4GDMLReadMaterials::GetElement()", "InvalidRead",
722 FatalException, error_msg);
723 }
724
725 return elementPtr;
726}
727
728G4Isotope* G4GDMLReadMaterials::GetIsotope(const G4String& ref,
729 G4bool verbose) const
730{
731 G4Isotope* isotopePtr = G4Isotope::GetIsotope(ref,false);
732
733 if (verbose && !isotopePtr)
734 {
735 G4String error_msg = "Referenced isotope '" + ref + "' was not found!";
736 G4Exception("G4GDMLReadMaterials::GetIsotope()", "InvalidRead",
737 FatalException, error_msg);
738 }
739
740 return isotopePtr;
741}
742
743G4Material* G4GDMLReadMaterials::GetMaterial(const G4String& ref,
744 G4bool verbose) const
745{
746 G4Material *materialPtr = G4Material::GetMaterial(ref,false);
747
748 if (!materialPtr)
749 {
750 materialPtr = G4NistManager::Instance()->FindOrBuildMaterial(ref);
751 }
752
753 if (verbose && !materialPtr)
754 {
755 G4String error_msg = "Referenced material '" + ref + "' was not found!";
756 G4Exception("G4GDMLReadMaterials::GetMaterial()", "InvalidRead",
757 FatalException, error_msg);
758 }
759
760 return materialPtr;
761}
FatalException
@ FatalException
Definition: G4ExceptionSeverity.hh:60
G4MaterialPropertyVector
G4PhysicsOrderedFreeVector G4MaterialPropertyVector
Definition: G4MaterialPropertyVector.hh:62
G4State
G4State
Definition: G4Material.hh:114
kStateSolid
@ kStateSolid
Definition: G4Material.hh:114
kStateLiquid
@ kStateLiquid
Definition: G4Material.hh:114
kStateGas
@ kStateGas
Definition: G4Material.hh:114
kStateUndefined
@ kStateUndefined
Definition: G4Material.hh:114
G4double
double G4double
Definition: G4Types.hh:64
G4int
int G4int
Definition: G4Types.hh:66
G4bool
bool G4bool
Definition: G4Types.hh:67
G4endl
#define G4endl
Definition: G4ios.hh:52
G4cout
G4DLLIMPORT std::ostream G4cout
pascal
#define pascal
Definition: SystemOfUnits.h:188
G4Element::AddIsotope
void AddIsotope(G4Isotope *isotope, G4double RelativeAbundance)
Definition: G4Element.cc:147
G4Element::GetElement
static G4Element * GetElement(G4String name, G4bool warning=true)
Definition: G4Element.cc:413
G4GDMLEvaluator::Evaluate
G4double Evaluate(const G4String &)
Definition: G4GDMLEvaluator.cc:213
G4GDMLEvaluator::EvaluateInteger
G4int EvaluateInteger(const G4String &)
Definition: G4GDMLEvaluator.cc:234
G4GDMLMatrix::GetCols
size_t GetCols() const
Definition: G4GDMLReadDefine.cc:118
G4GDMLMatrix::Get
G4double Get(size_t r, size_t c) const
Definition: G4GDMLReadDefine.cc:103
G4GDMLMatrix::GetRows
size_t GetRows() const
Definition: G4GDMLReadDefine.cc:113
G4GDMLReadDefine::GetQuantity
G4double GetQuantity(const G4String &)
Definition: G4GDMLReadDefine.cc:578
G4GDMLReadDefine::GetMatrix
G4GDMLMatrix GetMatrix(const G4String &)
Definition: G4GDMLReadDefine.cc:622
G4GDMLReadDefine::RefRead
G4String RefRead(const xercesc::DOMElement *const)
Definition: G4GDMLReadDefine.cc:531
G4GDMLReadDefine::DefineRead
virtual void DefineRead(const xercesc::DOMElement *const)
Definition: G4GDMLReadDefine.cc:457
G4GDMLReadMaterials::PropertyRead
void PropertyRead(const xercesc::DOMElement *const, G4Material *)
Definition: G4GDMLReadMaterials.cc:607
G4GDMLReadMaterials::MEERead
G4double MEERead(const xercesc::DOMElement *const)
Definition: G4GDMLReadMaterials.cc:227
G4GDMLReadMaterials::MixtureRead
void MixtureRead(const xercesc::DOMElement *const, G4Element *)
Definition: G4GDMLReadMaterials.cc:531
G4GDMLReadMaterials::DRead
G4double DRead(const xercesc::DOMElement *const)
Definition: G4GDMLReadMaterials.cc:124
G4GDMLReadMaterials::AtomRead
G4double AtomRead(const xercesc::DOMElement *const)
Definition: G4GDMLReadMaterials.cc:54
G4GDMLReadMaterials::GetMaterial
G4Material * GetMaterial(const G4String &, G4bool verbose=true) const
Definition: G4GDMLReadMaterials.cc:743
G4GDMLReadMaterials::GetElement
G4Element * GetElement(const G4String &, G4bool verbose=true) const
Definition: G4GDMLReadMaterials.cc:709
G4GDMLReadMaterials::PRead
G4double PRead(const xercesc::DOMElement *const)
Definition: G4GDMLReadMaterials.cc:159
G4GDMLReadMaterials::GetIsotope
G4Isotope * GetIsotope(const G4String &, G4bool verbose=true) const
Definition: G4GDMLReadMaterials.cc:728
G4GDMLReadMaterials::CompositeRead
G4int CompositeRead(const xercesc::DOMElement *const, G4String &)
Definition: G4GDMLReadMaterials.cc:90
G4GDMLReadMaterials::MaterialsRead
virtual void MaterialsRead(const xercesc::DOMElement *const)
Definition: G4GDMLReadMaterials.cc:676
G4GDMLReadMaterials::TRead
G4double TRead(const xercesc::DOMElement *const)
Definition: G4GDMLReadMaterials.cc:193
G4GDMLReadMaterials::FractionRead
G4double FractionRead(const xercesc::DOMElement *const, G4String &)
Definition: G4GDMLReadMaterials.cc:330
G4GDMLReadMaterials::ElementRead
void ElementRead(const xercesc::DOMElement *const)
Definition: G4GDMLReadMaterials.cc:262
G4GDMLReadMaterials::IsotopeRead
void IsotopeRead(const xercesc::DOMElement *const)
Definition: G4GDMLReadMaterials.cc:365
G4GDMLReadMaterials::MaterialRead
void MaterialRead(const xercesc::DOMElement *const)
Definition: G4GDMLReadMaterials.cc:422
G4GDMLRead::Strip
G4String Strip(const G4String &) const
Definition: G4GDMLRead.cc:100
G4GDMLRead::GenerateName
G4String GenerateName(const G4String &name, G4bool strip=false)
Definition: G4GDMLRead.cc:68
G4GDMLRead::Transcode
G4String Transcode(const XMLCh *const)
Definition: G4GDMLRead.cc:55
G4GDMLRead::eval
G4GDMLEvaluator eval
Definition: G4GDMLRead.hh:144
G4IonisParamMat::SetMeanExcitationEnergy
void SetMeanExcitationEnergy(G4double value)
Definition: G4IonisParamMat.cc:385
G4Isotope::GetIsotope
static G4Isotope * GetIsotope(const G4String &name, G4bool warning=false)
Definition: G4Isotope.cc:196
G4MaterialPropertiesTable::AddConstProperty
void AddConstProperty(const char *key, G4double PropertyValue)
G4MaterialPropertiesTable::AddProperty
G4MaterialPropertyVector * AddProperty(const char *key, G4double *PhotonEnergies, G4double *PropertyValues, G4int NumEntries)
G4Material::GetMaterialPropertiesTable
G4MaterialPropertiesTable * GetMaterialPropertiesTable() const
Definition: G4Material.hh:251
G4Material::GetIonisation
G4IonisParamMat * GetIonisation() const
Definition: G4Material.hh:225
G4Material::AddElement
void AddElement(G4Element *element, G4int nAtoms)
Definition: G4Material.cc:341
G4Material::AddMaterial
void AddMaterial(G4Material *material, G4double fraction)
Definition: G4Material.cc:447
G4Material::SetMaterialPropertiesTable
void SetMaterialPropertiesTable(G4MaterialPropertiesTable *anMPT)
Definition: G4Material.hh:248
G4Material::GetMaterial
static G4Material * GetMaterial(const G4String &name, G4bool warning=true)
Definition: G4Material.cc:576
G4NistManager::FindOrBuildMaterial
G4Material * FindOrBuildMaterial(const G4String &name, G4bool isotopes=true, G4bool warning=false)
Definition: G4NistManager.hh:445
G4NistManager::Instance
static G4NistManager * Instance()
Definition: G4NistManager.cc:68
G4NistManager::FindOrBuildElement
G4Element * FindOrBuildElement(G4int Z, G4bool isotopes=true)
Definition: G4NistManager.hh:313
G4PhysicsOrderedFreeVector::InsertValues
void InsertValues(G4double energy, G4double value)
Definition: G4PhysicsOrderedFreeVector.cc:90
G4Exception
void G4Exception(const char *originOfException, const char *exceptionCode, G4ExceptionSeverity severity, const char *comments)
Definition: G4Exception.cc:41
tag
Definition: xmlparse.cc:179