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