| Geant4 Cross Reference |
1 // 1
2 // *******************************************
3 // * License and Disclaimer
4 // *
5 // * The Geant4 software is copyright of th
6 // * the Geant4 Collaboration. It is provided
7 // * conditions of the Geant4 Software License
8 // * LICENSE and available at http://cern.ch/
9 // * include a list of copyright holders.
10 // *
11 // * Neither the authors of this software syst
12 // * institutes,nor the agencies providing fin
13 // * work make any representation or warran
14 // * regarding this software system or assum
15 // * use. Please see the license in the file
16 // * for the full disclaimer and the limitatio
17 // *
18 // * This code implementation is the result
19 // * technical work of the GEANT4 collaboratio
20 // * By using, copying, modifying or distri
21 // * any work based on the software) you ag
22 // * use in resulting scientific publicati
23 // * acceptance of all terms of the Geant4 Sof
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,
43 {
44 if((rows0 == 0) || (cols0 == 0))
45 {
46 G4Exception("G4GDMLMatrix::G4GDMLMatrix(r,
47 FatalException, "Zero indices
48 }
49 rows = rows0;
50 cols = cols0;
51 m = new G4double[rows * cols];
52 }
53
54 // -------------------------------------------
55 G4GDMLMatrix::G4GDMLMatrix(const G4GDMLMatrix&
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; ++
63 {
64 m[i] = rhs.m[i];
65 }
66 }
67 }
68
69 // -------------------------------------------
70 G4GDMLMatrix& G4GDMLMatrix::operator=(const G4
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; ++
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::siz
107 {
108 if(r >= rows || c >= cols)
109 {
110 G4Exception("G4GDMLMatrix::set()", "Invali
111 "Index out of range!");
112 }
113 m[cols * r + c] = a;
114 }
115
116 // -------------------------------------------
117 G4double G4GDMLMatrix::Get(std::size_t r, std:
118 {
119 if(r >= rows || c >= cols)
120 {
121 G4Exception("G4GDMLMatrix::get()", "Invali
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::GetRotation
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 possi
162
163 return rot;
164 }
165
166 // -------------------------------------------
167 void G4GDMLReadDefine::ConstantRead(
168 const xercesc::DOMElement* const constantEle
169 {
170 G4String name = "";
171 G4double value = 0.0;
172
173 const xercesc::DOMNamedNodeMap* const attrib
174 constantElement->getAttributes();
175 XMLSize_t attributeCount = attributes->getLe
176
177 for(XMLSize_t attribute_index = 0; attribute
178 ++attribute_index)
179 {
180 xercesc::DOMNode* node = attributes->item(
181
182 if(node->getNodeType() != xercesc::DOMNode
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()"
192 "No attribute found!");
193 return;
194 }
195 const G4String attName = Transcode(attrib
196 const G4String attValue = Transcode(attrib
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 attrib
219 expElement->getAttributes();
220 XMLSize_t attributeCount = attributes->getLe
221
222 for(XMLSize_t attribute_index = 0; attribute
223 ++attribute_index)
224 {
225 xercesc::DOMNode* node = attributes->item(
226
227 if(node->getNodeType() != xercesc::DOMNode
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(
237 "No attribute found!");
238 return;
239 }
240 const G4String attName = Transcode(attrib
241 const G4String attValue = Transcode(attrib
242
243 if(attName == "name")
244 {
245 name = attValue;
246 }
247 }
248
249 const G4String expValue = Transcode(expEleme
250 value = eval.Evaluate(expV
251 eval.DefineConstant(name, value);
252 }
253
254 // -------------------------------------------
255 void G4GDMLReadDefine::MatrixRead(
256 const xercesc::DOMElement* const matrixEleme
257 {
258 G4String name = "";
259 G4int coldim = 0;
260 G4String values = "";
261
262 const xercesc::DOMNamedNodeMap* const attrib
263 matrixElement->getAttributes();
264 XMLSize_t attributeCount = attributes->getLe
265
266 for(XMLSize_t attribute_index = 0; attribute
267 ++attribute_index)
268 {
269 xercesc::DOMNode* node = attributes->item(
270
271 if(node->getNodeType() != xercesc::DOMNode
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()",
281 "No attribute found!");
282 return;
283 }
284 const G4String attName = Transcode(attrib
285 const G4String attValue = Transcode(attrib
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(MatrixVa
309 }
310
311 eval.DefineMatrix(name, coldim, valueList);
312
313 G4GDMLMatrix matrix(valueList.size() / coldi
314
315 for(std::size_t i = 0; i < valueList.size();
316 {
317 matrix.Set(i / coldim, i % coldim, valueLi
318 }
319
320 matrixMap[name] = matrix;
321 }
322
323 // -------------------------------------------
324 void G4GDMLReadDefine::PositionRead(
325 const xercesc::DOMElement* const positionEle
326 {
327 G4String name = "";
328 G4double unit = 1.0;
329 G4ThreeVector position(0., 0., 0.);
330
331 const xercesc::DOMNamedNodeMap* const attrib
332 positionElement->getAttributes();
333 XMLSize_t attributeCount = attributes->getLe
334
335 for(XMLSize_t attribute_index = 0; attribute
336 ++attribute_index)
337 {
338 xercesc::DOMNode* node = attributes->item(
339
340 if(node->getNodeType() != xercesc::DOMNode
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()"
350 "No attribute found!");
351 return;
352 }
353 const G4String attName = Transcode(attrib
354 const G4String attValue = Transcode(attrib
355
356 if(attName == "name")
357 {
358 name = GenerateName(attValue);
359 }
360 else if(attName == "unit")
361 {
362 unit = G4UnitDefinition::GetValueOf(attV
363 if(G4UnitDefinition::GetCategory(attValu
364 {
365 G4Exception("G4GDMLReadDefine::Positio
366 FatalException, "Invalid u
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 rotationEle
389 {
390 G4String name = "";
391 G4double unit = 1.0;
392 G4ThreeVector rotation(0., 0., 0.);
393
394 const xercesc::DOMNamedNodeMap* const attrib
395 rotationElement->getAttributes();
396 XMLSize_t attributeCount = attributes->getLe
397
398 for(XMLSize_t attribute_index = 0; attribute
399 ++attribute_index)
400 {
401 xercesc::DOMNode* node = attributes->item(
402
403 if(node->getNodeType() != xercesc::DOMNode
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()"
413 "No attribute found!");
414 return;
415 }
416 const G4String attName = Transcode(attrib
417 const G4String attValue = Transcode(attrib
418
419 if(attName == "name")
420 {
421 name = GenerateName(attValue);
422 }
423 else if(attName == "unit")
424 {
425 unit = G4UnitDefinition::GetValueOf(attV
426 if(G4UnitDefinition::GetCategory(attValu
427 {
428 G4Exception("G4GDMLReadDefine::Rotatio
429 FatalException, "Invalid u
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
451 {
452 G4String name = "";
453 G4ThreeVector scale(1.0, 1.0, 1.0);
454
455 const xercesc::DOMNamedNodeMap* const attrib
456 scaleElement->getAttributes();
457 XMLSize_t attributeCount = attributes->getLe
458
459 for(XMLSize_t attribute_index = 0; attribute
460 ++attribute_index)
461 {
462 xercesc::DOMNode* node = attributes->item(
463
464 if(node->getNodeType() != xercesc::DOMNode
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()", "
474 "No attribute found!");
475 return;
476 }
477 const G4String attName = Transcode(attrib
478 const G4String attValue = Transcode(attrib
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 variableEle
504 {
505 G4String name = "";
506 G4double value = 0.0;
507
508 const xercesc::DOMNamedNodeMap* const attrib
509 variableElement->getAttributes();
510 XMLSize_t attributeCount = attributes->getLe
511
512 for(XMLSize_t attribute_index = 0; attribute
513 ++attribute_index)
514 {
515 xercesc::DOMNode* node = attributes->item(
516
517 if(node->getNodeType() != xercesc::DOMNode
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()"
527 "No attribute found!");
528 return;
529 }
530 const G4String attName = Transcode(attrib
531 const G4String attValue = Transcode(attrib
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 xerc
548 {
549 G4String name = "";
550 G4double unit = 1.0;
551 G4double value = 0.0;
552
553 const xercesc::DOMNamedNodeMap* const attrib
554 XMLSize_t attributeCount
555
556 for(XMLSize_t attribute_index = 0; attribute
557 ++attribute_index)
558 {
559 xercesc::DOMNode* node = attributes->item(
560
561 if(node->getNodeType() != xercesc::DOMNode
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()"
571 "No attribute found!");
572 return;
573 }
574 const G4String attName = Transcode(attrib
575 const G4String attValue = Transcode(attrib
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(attV
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 defineEleme
598 {
599 #ifdef G4VERBOSE
600 G4cout << "G4GDML: Reading definitions..." <
601 #endif
602 for(xercesc::DOMNode* iter = defineElement->
603 iter = iter->getNextSi
604 {
605 if(iter->getNodeType() != xercesc::DOMNode
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()",
615 "No child found!");
616 return;
617 }
618 const G4String tag = Transcode(child->getT
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 def
655 G4Exception("G4GDMLReadDefine::defineRea
656 error_msg);
657 }
658 }
659 }
660
661 // -------------------------------------------
662 void G4GDMLReadDefine::VectorRead(
663 const xercesc::DOMElement* const vectorEleme
664 {
665 G4double unit = 1.0;
666
667 const xercesc::DOMNamedNodeMap* const attrib
668 vectorElement->getAttributes();
669 XMLSize_t attributeCount = attributes->getLe
670
671 for(XMLSize_t attribute_index = 0; attribute
672 ++attribute_index)
673 {
674 xercesc::DOMNode* attribute_node = attribu
675
676 if(attribute_node->getNodeType() != xerces
677 {
678 continue;
679 }
680
681 const xercesc::DOMAttr* const attribute =
682 dynamic_cast<xercesc::DOMAttr*>(attribut
683 if(attribute == nullptr)
684 {
685 G4Exception("G4GDMLRead::VectorRead()",
686 "No attribute found!");
687 return;
688 }
689 const G4String attName = Transcode(attrib
690 const G4String attValue = Transcode(attrib
691
692 if(attName == "unit")
693 {
694 unit = G4UnitDefinition::GetValueOf(attV
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 xerce
715 {
716 G4String ref;
717
718 const xercesc::DOMNamedNodeMap* const attrib
719 XMLSize_t attributeCount
720
721 for(XMLSize_t attribute_index = 0; attribute
722 ++attribute_index)
723 {
724 xercesc::DOMNode* attribute_node = attribu
725
726 if(attribute_node->getNodeType() != xerces
727 {
728 continue;
729 }
730
731 const xercesc::DOMAttr* const attribute =
732 dynamic_cast<xercesc::DOMAttr*>(attribut
733 if(attribute == nullptr)
734 {
735 G4Exception("G4GDMLRead::Read()", "Inval
736 "No attribute found!");
737 return ref;
738 }
739 const G4String attName = Transcode(attrib
740 const G4String attValue = Transcode(attrib
741
742 if(attName == "ref")
743 {
744 ref = attValue;
745 }
746 }
747
748 return ref;
749 }
750
751 // -------------------------------------------
752 G4bool G4GDMLReadDefine::IsValidID(const G4Str
753 {
754 return eval.IsVariable(ref);
755 }
756
757 // -------------------------------------------
758 G4double G4GDMLReadDefine::GetConstant(const G
759 {
760 return eval.GetConstant(ref);
761 }
762
763 // -------------------------------------------
764 G4double G4GDMLReadDefine::GetVariable(const G
765 {
766 return eval.GetVariable(ref);
767 }
768
769 // -------------------------------------------
770 G4double G4GDMLReadDefine::GetQuantity(const G
771 {
772 if(quantityMap.find(ref) == quantityMap.cend
773 {
774 G4String error_msg = "Quantity '" + ref +
775 G4Exception("G4GDMLReadDefine::getQuantity
776 error_msg);
777 }
778 return quantityMap[ref];
779 }
780
781 // -------------------------------------------
782 G4ThreeVector G4GDMLReadDefine::GetPosition(co
783 {
784 if(positionMap.find(ref) == positionMap.cend
785 {
786 G4String error_msg = "Position '" + ref +
787 G4Exception("G4GDMLReadDefine::getPosition
788 error_msg);
789 }
790 return positionMap[ref];
791 }
792
793 // -------------------------------------------
794 G4ThreeVector G4GDMLReadDefine::GetRotation(co
795 {
796 if(rotationMap.find(ref) == rotationMap.cend
797 {
798 G4String error_msg = "Rotation '" + ref +
799 G4Exception("G4GDMLReadDefine::getRotation
800 error_msg);
801 }
802 return rotationMap[ref];
803 }
804
805 // -------------------------------------------
806 G4ThreeVector G4GDMLReadDefine::GetScale(const
807 {
808 if(scaleMap.find(ref) == scaleMap.end())
809 {
810 G4String error_msg = "Scale '" + ref + "'
811 G4Exception("G4GDMLReadDefine::getScale()"
812 error_msg);
813 }
814 return scaleMap[ref];
815 }
816
817 // -------------------------------------------
818 G4GDMLMatrix G4GDMLReadDefine::GetMatrix(const
819 {
820 if(matrixMap.find(ref) == matrixMap.end())
821 {
822 G4String error_msg = "Matrix '" + ref + "'
823 G4Exception("G4GDMLReadDefine::getMatrix()
824 error_msg);
825 }
826 return matrixMap[ref];
827 }
828