source: trunk/source/persistency/gdml/src/G4GDMLReadMaterials.cc@ 1353

Last change on this file since 1353 was 1347, checked in by garnier, 15 years ago

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