Geant4 9.6.0
Toolkit for the simulation of the passage of particles through matter
•All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros
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