| Geant4 Cross Reference |
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 // G4GDMLReadDefine implementation
27 //
28 // Author: Zoltan Torzsok, November 2007
29 // --------------------------------------------------------------------
30
31 #include "G4GDMLReadDefine.hh"
32 #include "G4UnitsTable.hh"
33
34 // G4GDMLMatrix -------------------------------------------------------
35
36 // --------------------------------------------------------------------
37 G4GDMLMatrix::G4GDMLMatrix()
38 {
39 }
40
41 // --------------------------------------------------------------------
42 G4GDMLMatrix::G4GDMLMatrix(std::size_t rows0, std::size_t cols0)
43 {
44 if((rows0 == 0) || (cols0 == 0))
45 {
46 G4Exception("G4GDMLMatrix::G4GDMLMatrix(r,c)", "InvalidSetup",
47 FatalException, "Zero indices as arguments!?");
48 }
49 rows = rows0;
50 cols = cols0;
51 m = new G4double[rows * cols];
52 }
53
54 // --------------------------------------------------------------------
55 G4GDMLMatrix::G4GDMLMatrix(const G4GDMLMatrix& rhs)
56 {
57 if(rhs.m)
58 {
59 rows = rhs.rows;
60 cols = rhs.cols;
61 m = new G4double[rows * cols];
62 for(std::size_t i = 0; i < rows * cols; ++i)
63 {
64 m[i] = rhs.m[i];
65 }
66 }
67 }
68
69 // --------------------------------------------------------------------
70 G4GDMLMatrix& G4GDMLMatrix::operator=(const G4GDMLMatrix& rhs)
71 {
72 // Check assignment to self
73 //
74 if(this == &rhs)
75 {
76 return *this;
77 }
78
79 // Copy data
80 //
81 rows = rhs.rows;
82 cols = rhs.cols;
83 if(rhs.m)
84 {
85 m = new G4double[rows * cols];
86 for(std::size_t i = 0; i < rows * cols; ++i)
87 {
88 m[i] = rhs.m[i];
89 }
90 }
91 else
92 {
93 m = nullptr;
94 }
95
96 return *this;
97 }
98
99 // --------------------------------------------------------------------
100 G4GDMLMatrix::~G4GDMLMatrix()
101 {
102 delete[] m;
103 }
104
105 // --------------------------------------------------------------------
106 void G4GDMLMatrix::Set(std::size_t r, std::size_t c, G4double a)
107 {
108 if(r >= rows || c >= cols)
109 {
110 G4Exception("G4GDMLMatrix::set()", "InvalidSetup", FatalException,
111 "Index out of range!");
112 }
113 m[cols * r + c] = a;
114 }
115
116 // --------------------------------------------------------------------
117 G4double G4GDMLMatrix::Get(std::size_t r, std::size_t c) const
118 {
119 if(r >= rows || c >= cols)
120 {
121 G4Exception("G4GDMLMatrix::get()", "InvalidSetup", FatalException,
122 "Index out of range!");
123 }
124 return m[cols * r + c];
125 }
126
127 // --------------------------------------------------------------------
128 std::size_t G4GDMLMatrix::GetRows() const
129 {
130 return rows;
131 }
132
133 // --------------------------------------------------------------------
134 std::size_t G4GDMLMatrix::GetCols() const
135 {
136 return cols;
137 }
138
139 // G4GDMLReadDefine ---------------------------------------------------
140
141 // --------------------------------------------------------------------
142 G4GDMLReadDefine::G4GDMLReadDefine()
143 : G4GDMLRead()
144 {
145 }
146
147 // --------------------------------------------------------------------
148 G4GDMLReadDefine::~G4GDMLReadDefine()
149 {
150 }
151
152 // --------------------------------------------------------------------
153 G4RotationMatrix G4GDMLReadDefine::GetRotationMatrix(
154 const G4ThreeVector& angles)
155 {
156 G4RotationMatrix rot;
157
158 rot.rotateX(angles.x());
159 rot.rotateY(angles.y());
160 rot.rotateZ(angles.z());
161 rot.rectify(); // Rectify matrix from possible roundoff errors
162
163 return rot;
164 }
165
166 // --------------------------------------------------------------------
167 void G4GDMLReadDefine::ConstantRead(
168 const xercesc::DOMElement* const constantElement)
169 {
170 G4String name = "";
171 G4double value = 0.0;
172
173 const xercesc::DOMNamedNodeMap* const attributes =
174 constantElement->getAttributes();
175 XMLSize_t attributeCount = attributes->getLength();
176
177 for(XMLSize_t attribute_index = 0; attribute_index < attributeCount;
178 ++attribute_index)
179 {
180 xercesc::DOMNode* node = attributes->item(attribute_index);
181
182 if(node->getNodeType() != xercesc::DOMNode::ATTRIBUTE_NODE)
183 {
184 continue;
185 }
186
187 const xercesc::DOMAttr* const attribute =
188 dynamic_cast<xercesc::DOMAttr*>(node);
189 if(attribute == nullptr)
190 {
191 G4Exception("G4GDMLRead::ConstantRead()", "InvalidRead", FatalException,
192 "No attribute found!");
193 return;
194 }
195 const G4String attName = Transcode(attribute->getName());
196 const G4String attValue = Transcode(attribute->getValue());
197
198 if(attName == "name")
199 {
200 name = attValue;
201 }
202 else if(attName == "value")
203 {
204 value = eval.Evaluate(attValue);
205 }
206 }
207
208 eval.DefineConstant(name, value);
209 }
210
211 // --------------------------------------------------------------------
212 void G4GDMLReadDefine::ExpressionRead(
213 const xercesc::DOMElement* const expElement)
214 {
215 G4String name = "";
216 G4double value = 0.0;
217
218 const xercesc::DOMNamedNodeMap* const attributes =
219 expElement->getAttributes();
220 XMLSize_t attributeCount = attributes->getLength();
221
222 for(XMLSize_t attribute_index = 0; attribute_index < attributeCount;
223 ++attribute_index)
224 {
225 xercesc::DOMNode* node = attributes->item(attribute_index);
226
227 if(node->getNodeType() != xercesc::DOMNode::ATTRIBUTE_NODE)
228 {
229 continue;
230 }
231
232 const xercesc::DOMAttr* const attribute =
233 dynamic_cast<xercesc::DOMAttr*>(node);
234 if(attribute == nullptr)
235 {
236 G4Exception("G4GDMLRead::ExpressionRead()", "InvalidRead", FatalException,
237 "No attribute found!");
238 return;
239 }
240 const G4String attName = Transcode(attribute->getName());
241 const G4String attValue = Transcode(attribute->getValue());
242
243 if(attName == "name")
244 {
245 name = attValue;
246 }
247 }
248
249 const G4String expValue = Transcode(expElement->getTextContent());
250 value = eval.Evaluate(expValue);
251 eval.DefineConstant(name, value);
252 }
253
254 // --------------------------------------------------------------------
255 void G4GDMLReadDefine::MatrixRead(
256 const xercesc::DOMElement* const matrixElement)
257 {
258 G4String name = "";
259 G4int coldim = 0;
260 G4String values = "";
261
262 const xercesc::DOMNamedNodeMap* const attributes =
263 matrixElement->getAttributes();
264 XMLSize_t attributeCount = attributes->getLength();
265
266 for(XMLSize_t attribute_index = 0; attribute_index < attributeCount;
267 ++attribute_index)
268 {
269 xercesc::DOMNode* node = attributes->item(attribute_index);
270
271 if(node->getNodeType() != xercesc::DOMNode::ATTRIBUTE_NODE)
272 {
273 continue;
274 }
275
276 const xercesc::DOMAttr* const attribute =
277 dynamic_cast<xercesc::DOMAttr*>(node);
278 if(attribute == nullptr)
279 {
280 G4Exception("G4GDMLRead::MatrixRead()", "InvalidRead", FatalException,
281 "No attribute found!");
282 return;
283 }
284 const G4String attName = Transcode(attribute->getName());
285 const G4String attValue = Transcode(attribute->getValue());
286
287 if(attName == "name")
288 {
289 name = GenerateName(attValue);
290 }
291 else if(attName == "coldim")
292 {
293 coldim = eval.EvaluateInteger(attValue);
294 }
295 else if(attName == "values")
296 {
297 values = attValue;
298 }
299 }
300
301 std::stringstream MatrixValueStream(values);
302 std::vector<G4double> valueList;
303
304 while(!MatrixValueStream.eof())
305 {
306 G4String MatrixValue;
307 MatrixValueStream >> MatrixValue;
308 valueList.push_back(eval.Evaluate(MatrixValue));
309 }
310
311 eval.DefineMatrix(name, coldim, valueList);
312
313 G4GDMLMatrix matrix(valueList.size() / coldim, coldim);
314
315 for(std::size_t i = 0; i < valueList.size(); ++i)
316 {
317 matrix.Set(i / coldim, i % coldim, valueList[i]);
318 }
319
320 matrixMap[name] = matrix;
321 }
322
323 // --------------------------------------------------------------------
324 void G4GDMLReadDefine::PositionRead(
325 const xercesc::DOMElement* const positionElement)
326 {
327 G4String name = "";
328 G4double unit = 1.0;
329 G4ThreeVector position(0., 0., 0.);
330
331 const xercesc::DOMNamedNodeMap* const attributes =
332 positionElement->getAttributes();
333 XMLSize_t attributeCount = attributes->getLength();
334
335 for(XMLSize_t attribute_index = 0; attribute_index < attributeCount;
336 ++attribute_index)
337 {
338 xercesc::DOMNode* node = attributes->item(attribute_index);
339
340 if(node->getNodeType() != xercesc::DOMNode::ATTRIBUTE_NODE)
341 {
342 continue;
343 }
344
345 const xercesc::DOMAttr* const attribute =
346 dynamic_cast<xercesc::DOMAttr*>(node);
347 if(attribute == nullptr)
348 {
349 G4Exception("G4GDMLRead::PositionRead()", "InvalidRead", FatalException,
350 "No attribute found!");
351 return;
352 }
353 const G4String attName = Transcode(attribute->getName());
354 const G4String attValue = Transcode(attribute->getValue());
355
356 if(attName == "name")
357 {
358 name = GenerateName(attValue);
359 }
360 else if(attName == "unit")
361 {
362 unit = G4UnitDefinition::GetValueOf(attValue);
363 if(G4UnitDefinition::GetCategory(attValue) != "Length")
364 {
365 G4Exception("G4GDMLReadDefine::PositionRead()", "InvalidRead",
366 FatalException, "Invalid unit for length!");
367 }
368 }
369 else if(attName == "x")
370 {
371 position.setX(eval.Evaluate(attValue));
372 }
373 else if(attName == "y")
374 {
375 position.setY(eval.Evaluate(attValue));
376 }
377 else if(attName == "z")
378 {
379 position.setZ(eval.Evaluate(attValue));
380 }
381 }
382
383 positionMap[name] = position * unit;
384 }
385
386 // --------------------------------------------------------------------
387 void G4GDMLReadDefine::RotationRead(
388 const xercesc::DOMElement* const rotationElement)
389 {
390 G4String name = "";
391 G4double unit = 1.0;
392 G4ThreeVector rotation(0., 0., 0.);
393
394 const xercesc::DOMNamedNodeMap* const attributes =
395 rotationElement->getAttributes();
396 XMLSize_t attributeCount = attributes->getLength();
397
398 for(XMLSize_t attribute_index = 0; attribute_index < attributeCount;
399 ++attribute_index)
400 {
401 xercesc::DOMNode* node = attributes->item(attribute_index);
402
403 if(node->getNodeType() != xercesc::DOMNode::ATTRIBUTE_NODE)
404 {
405 continue;
406 }
407
408 const xercesc::DOMAttr* const attribute =
409 dynamic_cast<xercesc::DOMAttr*>(node);
410 if(attribute == nullptr)
411 {
412 G4Exception("G4GDMLRead::RotationRead()", "InvalidRead", FatalException,
413 "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")
420 {
421 name = GenerateName(attValue);
422 }
423 else if(attName == "unit")
424 {
425 unit = G4UnitDefinition::GetValueOf(attValue);
426 if(G4UnitDefinition::GetCategory(attValue) != "Angle")
427 {
428 G4Exception("G4GDMLReadDefine::RotationRead()", "InvalidRead",
429 FatalException, "Invalid unit for angle!");
430 }
431 }
432 else if(attName == "x")
433 {
434 rotation.setX(eval.Evaluate(attValue));
435 }
436 else if(attName == "y")
437 {
438 rotation.setY(eval.Evaluate(attValue));
439 }
440 else if(attName == "z")
441 {
442 rotation.setZ(eval.Evaluate(attValue));
443 }
444 }
445
446 rotationMap[name] = rotation * unit;
447 }
448
449 // --------------------------------------------------------------------
450 void G4GDMLReadDefine::ScaleRead(const xercesc::DOMElement* const scaleElement)
451 {
452 G4String name = "";
453 G4ThreeVector scale(1.0, 1.0, 1.0);
454
455 const xercesc::DOMNamedNodeMap* const attributes =
456 scaleElement->getAttributes();
457 XMLSize_t attributeCount = attributes->getLength();
458
459 for(XMLSize_t attribute_index = 0; attribute_index < attributeCount;
460 ++attribute_index)
461 {
462 xercesc::DOMNode* node = attributes->item(attribute_index);
463
464 if(node->getNodeType() != xercesc::DOMNode::ATTRIBUTE_NODE)
465 {
466 continue;
467 }
468
469 const xercesc::DOMAttr* const attribute =
470 dynamic_cast<xercesc::DOMAttr*>(node);
471 if(attribute == nullptr)
472 {
473 G4Exception("G4GDMLRead::ScaleRead()", "InvalidRead", FatalException,
474 "No attribute found!");
475 return;
476 }
477 const G4String attName = Transcode(attribute->getName());
478 const G4String attValue = Transcode(attribute->getValue());
479
480 if(attName == "name")
481 {
482 name = GenerateName(attValue);
483 }
484 else if(attName == "x")
485 {
486 scale.setX(eval.Evaluate(attValue));
487 }
488 else if(attName == "y")
489 {
490 scale.setY(eval.Evaluate(attValue));
491 }
492 else if(attName == "z")
493 {
494 scale.setZ(eval.Evaluate(attValue));
495 }
496 }
497
498 scaleMap[name] = scale;
499 }
500
501 // --------------------------------------------------------------------
502 void G4GDMLReadDefine::VariableRead(
503 const xercesc::DOMElement* const variableElement)
504 {
505 G4String name = "";
506 G4double value = 0.0;
507
508 const xercesc::DOMNamedNodeMap* const attributes =
509 variableElement->getAttributes();
510 XMLSize_t attributeCount = attributes->getLength();
511
512 for(XMLSize_t attribute_index = 0; attribute_index < attributeCount;
513 ++attribute_index)
514 {
515 xercesc::DOMNode* node = attributes->item(attribute_index);
516
517 if(node->getNodeType() != xercesc::DOMNode::ATTRIBUTE_NODE)
518 {
519 continue;
520 }
521
522 const xercesc::DOMAttr* const attribute =
523 dynamic_cast<xercesc::DOMAttr*>(node);
524 if(attribute == nullptr)
525 {
526 G4Exception("G4GDMLRead::VariableRead()", "InvalidRead", FatalException,
527 "No attribute found!");
528 return;
529 }
530 const G4String attName = Transcode(attribute->getName());
531 const G4String attValue = Transcode(attribute->getValue());
532
533 if(attName == "name")
534 {
535 name = attValue;
536 }
537 else if(attName == "value")
538 {
539 value = eval.Evaluate(attValue);
540 }
541 }
542
543 eval.DefineVariable(name, value);
544 }
545
546 // --------------------------------------------------------------------
547 void G4GDMLReadDefine::QuantityRead(const xercesc::DOMElement* const element)
548 {
549 G4String name = "";
550 G4double unit = 1.0;
551 G4double value = 0.0;
552
553 const xercesc::DOMNamedNodeMap* const attributes = element->getAttributes();
554 XMLSize_t attributeCount = attributes->getLength();
555
556 for(XMLSize_t attribute_index = 0; attribute_index < attributeCount;
557 ++attribute_index)
558 {
559 xercesc::DOMNode* node = attributes->item(attribute_index);
560
561 if(node->getNodeType() != xercesc::DOMNode::ATTRIBUTE_NODE)
562 {
563 continue;
564 }
565
566 const xercesc::DOMAttr* const attribute =
567 dynamic_cast<xercesc::DOMAttr*>(node);
568 if(attribute == nullptr)
569 {
570 G4Exception("G4GDMLRead::QuantityRead()", "InvalidRead", FatalException,
571 "No attribute found!");
572 return;
573 }
574 const G4String attName = Transcode(attribute->getName());
575 const G4String attValue = Transcode(attribute->getValue());
576
577 if(attName == "name")
578 {
579 name = attValue;
580 }
581 else if(attName == "value")
582 {
583 value = eval.Evaluate(attValue);
584 }
585 else if(attName == "unit")
586 {
587 unit = G4UnitDefinition::GetValueOf(attValue);
588 }
589 }
590
591 quantityMap[name] = value * unit;
592 eval.DefineConstant(name, value * unit);
593 }
594
595 // --------------------------------------------------------------------
596 void G4GDMLReadDefine::DefineRead(
597 const xercesc::DOMElement* const defineElement)
598 {
599 #ifdef G4VERBOSE
600 G4cout << "G4GDML: Reading definitions..." << G4endl;
601 #endif
602 for(xercesc::DOMNode* iter = defineElement->getFirstChild(); iter != nullptr;
603 iter = iter->getNextSibling())
604 {
605 if(iter->getNodeType() != xercesc::DOMNode::ELEMENT_NODE)
606 {
607 continue;
608 }
609
610 const xercesc::DOMElement* const child =
611 dynamic_cast<xercesc::DOMElement*>(iter);
612 if(child == nullptr)
613 {
614 G4Exception("G4GDMLRead::DefineRead()", "InvalidRead", FatalException,
615 "No child found!");
616 return;
617 }
618 const G4String tag = Transcode(child->getTagName());
619
620 if(tag == "constant")
621 {
622 ConstantRead(child);
623 }
624 else if(tag == "matrix")
625 {
626 MatrixRead(child);
627 }
628 else if(tag == "position")
629 {
630 PositionRead(child);
631 }
632 else if(tag == "rotation")
633 {
634 RotationRead(child);
635 }
636 else if(tag == "scale")
637 {
638 ScaleRead(child);
639 }
640 else if(tag == "variable")
641 {
642 VariableRead(child);
643 }
644 else if(tag == "quantity")
645 {
646 QuantityRead(child);
647 }
648 else if(tag == "expression")
649 {
650 ExpressionRead(child);
651 }
652 else
653 {
654 G4String error_msg = "Unknown tag in define: " + tag;
655 G4Exception("G4GDMLReadDefine::defineRead()", "ReadError", FatalException,
656 error_msg);
657 }
658 }
659 }
660
661 // --------------------------------------------------------------------
662 void G4GDMLReadDefine::VectorRead(
663 const xercesc::DOMElement* const vectorElement, G4ThreeVector& vec)
664 {
665 G4double unit = 1.0;
666
667 const xercesc::DOMNamedNodeMap* const attributes =
668 vectorElement->getAttributes();
669 XMLSize_t attributeCount = attributes->getLength();
670
671 for(XMLSize_t attribute_index = 0; attribute_index < attributeCount;
672 ++attribute_index)
673 {
674 xercesc::DOMNode* attribute_node = attributes->item(attribute_index);
675
676 if(attribute_node->getNodeType() != xercesc::DOMNode::ATTRIBUTE_NODE)
677 {
678 continue;
679 }
680
681 const xercesc::DOMAttr* const attribute =
682 dynamic_cast<xercesc::DOMAttr*>(attribute_node);
683 if(attribute == nullptr)
684 {
685 G4Exception("G4GDMLRead::VectorRead()", "InvalidRead", FatalException,
686 "No attribute found!");
687 return;
688 }
689 const G4String attName = Transcode(attribute->getName());
690 const G4String attValue = Transcode(attribute->getValue());
691
692 if(attName == "unit")
693 {
694 unit = G4UnitDefinition::GetValueOf(attValue);
695 }
696 else if(attName == "x")
697 {
698 vec.setX(eval.Evaluate(attValue));
699 }
700 else if(attName == "y")
701 {
702 vec.setY(eval.Evaluate(attValue));
703 }
704 else if(attName == "z")
705 {
706 vec.setZ(eval.Evaluate(attValue));
707 }
708 }
709
710 vec *= unit;
711 }
712
713 // --------------------------------------------------------------------
714 G4String G4GDMLReadDefine::RefRead(const xercesc::DOMElement* const element)
715 {
716 G4String ref;
717
718 const xercesc::DOMNamedNodeMap* const attributes = element->getAttributes();
719 XMLSize_t attributeCount = attributes->getLength();
720
721 for(XMLSize_t attribute_index = 0; attribute_index < attributeCount;
722 ++attribute_index)
723 {
724 xercesc::DOMNode* attribute_node = attributes->item(attribute_index);
725
726 if(attribute_node->getNodeType() != xercesc::DOMNode::ATTRIBUTE_NODE)
727 {
728 continue;
729 }
730
731 const xercesc::DOMAttr* const attribute =
732 dynamic_cast<xercesc::DOMAttr*>(attribute_node);
733 if(attribute == nullptr)
734 {
735 G4Exception("G4GDMLRead::Read()", "InvalidRead", FatalException,
736 "No attribute found!");
737 return ref;
738 }
739 const G4String attName = Transcode(attribute->getName());
740 const G4String attValue = Transcode(attribute->getValue());
741
742 if(attName == "ref")
743 {
744 ref = attValue;
745 }
746 }
747
748 return ref;
749 }
750
751 // --------------------------------------------------------------------
752 G4bool G4GDMLReadDefine::IsValidID(const G4String& ref) const
753 {
754 return eval.IsVariable(ref);
755 }
756
757 // --------------------------------------------------------------------
758 G4double G4GDMLReadDefine::GetConstant(const G4String& ref)
759 {
760 return eval.GetConstant(ref);
761 }
762
763 // --------------------------------------------------------------------
764 G4double G4GDMLReadDefine::GetVariable(const G4String& ref)
765 {
766 return eval.GetVariable(ref);
767 }
768
769 // --------------------------------------------------------------------
770 G4double G4GDMLReadDefine::GetQuantity(const G4String& ref)
771 {
772 if(quantityMap.find(ref) == quantityMap.cend())
773 {
774 G4String error_msg = "Quantity '" + ref + "' was not found!";
775 G4Exception("G4GDMLReadDefine::getQuantity()", "ReadError", FatalException,
776 error_msg);
777 }
778 return quantityMap[ref];
779 }
780
781 // --------------------------------------------------------------------
782 G4ThreeVector G4GDMLReadDefine::GetPosition(const G4String& ref)
783 {
784 if(positionMap.find(ref) == positionMap.cend())
785 {
786 G4String error_msg = "Position '" + ref + "' was not found!";
787 G4Exception("G4GDMLReadDefine::getPosition()", "ReadError", FatalException,
788 error_msg);
789 }
790 return positionMap[ref];
791 }
792
793 // --------------------------------------------------------------------
794 G4ThreeVector G4GDMLReadDefine::GetRotation(const G4String& ref)
795 {
796 if(rotationMap.find(ref) == rotationMap.cend())
797 {
798 G4String error_msg = "Rotation '" + ref + "' was not found!";
799 G4Exception("G4GDMLReadDefine::getRotation()", "ReadError", FatalException,
800 error_msg);
801 }
802 return rotationMap[ref];
803 }
804
805 // --------------------------------------------------------------------
806 G4ThreeVector G4GDMLReadDefine::GetScale(const G4String& ref)
807 {
808 if(scaleMap.find(ref) == scaleMap.end())
809 {
810 G4String error_msg = "Scale '" + ref + "' was not found!";
811 G4Exception("G4GDMLReadDefine::getScale()", "ReadError", FatalException,
812 error_msg);
813 }
814 return scaleMap[ref];
815 }
816
817 // --------------------------------------------------------------------
818 G4GDMLMatrix G4GDMLReadDefine::GetMatrix(const G4String& ref)
819 {
820 if(matrixMap.find(ref) == matrixMap.end())
821 {
822 G4String error_msg = "Matrix '" + ref + "' was not found!";
823 G4Exception("G4GDMLReadDefine::getMatrix()", "ReadError", FatalException,
824 error_msg);
825 }
826 return matrixMap[ref];
827 }
828