| 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 // G4GDMLReadParamvol implementation
27 //
28 // Author: Zoltan Torzsok, November 2007
29 // -------------------------------------------
30
31 #include "G4GDMLReadParamvol.hh"
32 #include "G4GDMLReadSolids.hh"
33 #include "G4LogicalVolume.hh"
34 #include "G4PVParameterised.hh"
35 #include "G4PVPlacement.hh"
36 #include "G4VPhysicalVolume.hh"
37 #include "G4UnitsTable.hh"
38
39 // -------------------------------------------
40 G4GDMLReadParamvol::G4GDMLReadParamvol()
41 : G4GDMLReadSetup()
42 {
43 }
44
45 G4GDMLReadParamvol::~G4GDMLReadParamvol()
46 {
47 }
48
49 // -------------------------------------------
50 void G4GDMLReadParamvol::Box_dimensionsRead(
51 const xercesc::DOMElement* const element,
52 G4GDMLParameterisation::PARAMETER& parameter
53 {
54 G4double lunit = 1.0;
55
56 const xercesc::DOMNamedNodeMap* const attrib
57 XMLSize_t attributeCount
58
59 for(XMLSize_t attribute_index = 0; attribute
60 ++attribute_index)
61 {
62 xercesc::DOMNode* attribute_node = attribu
63
64 if(attribute_node->getNodeType() != xerces
65 {
66 continue;
67 }
68
69 const xercesc::DOMAttr* const attribute =
70 dynamic_cast<xercesc::DOMAttr*>(attribut
71 if(attribute == nullptr)
72 {
73 G4Exception("G4GDMLReadParamvol::Box_dim
74 FatalException, "No attribut
75 return;
76 }
77 const G4String attName = Transcode(attrib
78 const G4String attValue = Transcode(attrib
79
80 if(attName == "lunit")
81 {
82 lunit = G4UnitDefinition::GetValueOf(att
83 if(G4UnitDefinition::GetCategory(attValu
84 {
85 G4Exception("G4GDMLReadParamvol::Box_d
86 FatalException, "Invalid u
87 }
88 }
89 else if(attName == "x")
90 {
91 parameter.dimension[0] = eval.Evaluate(a
92 }
93 else if(attName == "y")
94 {
95 parameter.dimension[1] = eval.Evaluate(a
96 }
97 else if(attName == "z")
98 {
99 parameter.dimension[2] = eval.Evaluate(a
100 }
101 }
102
103 parameter.dimension[0] *= 0.5 * lunit;
104 parameter.dimension[1] *= 0.5 * lunit;
105 parameter.dimension[2] *= 0.5 * lunit;
106 }
107
108 // -------------------------------------------
109 void G4GDMLReadParamvol::Trd_dimensionsRead(
110 const xercesc::DOMElement* const element,
111 G4GDMLParameterisation::PARAMETER& parameter
112 {
113 G4double lunit = 1.0;
114
115 const xercesc::DOMNamedNodeMap* const attrib
116 XMLSize_t attributeCount
117
118 for(XMLSize_t attribute_index = 0; attribute
119 ++attribute_index)
120 {
121 xercesc::DOMNode* attribute_node = attribu
122
123 if(attribute_node->getNodeType() != xerces
124 {
125 continue;
126 }
127
128 const xercesc::DOMAttr* const attribute =
129 dynamic_cast<xercesc::DOMAttr*>(attribut
130 if(attribute == nullptr)
131 {
132 G4Exception("G4GDMLReadParamvol::Trd_dim
133 FatalException, "No attribut
134 return;
135 }
136 const G4String attName = Transcode(attrib
137 const G4String attValue = Transcode(attrib
138
139 if(attName == "lunit")
140 {
141 lunit = G4UnitDefinition::GetValueOf(att
142 if(G4UnitDefinition::GetCategory(attValu
143 {
144 G4Exception("G4GDMLReadParamvol::Trd_d
145 FatalException, "Invalid u
146 }
147 }
148 else if(attName == "x1")
149 {
150 parameter.dimension[0] = eval.Evaluate(a
151 }
152 else if(attName == "x2")
153 {
154 parameter.dimension[1] = eval.Evaluate(a
155 }
156 else if(attName == "y1")
157 {
158 parameter.dimension[2] = eval.Evaluate(a
159 }
160 else if(attName == "y2")
161 {
162 parameter.dimension[3] = eval.Evaluate(a
163 }
164 else if(attName == "z")
165 {
166 parameter.dimension[4] = eval.Evaluate(a
167 }
168 }
169
170 parameter.dimension[0] *= 0.5 * lunit;
171 parameter.dimension[1] *= 0.5 * lunit;
172 parameter.dimension[2] *= 0.5 * lunit;
173 parameter.dimension[3] *= 0.5 * lunit;
174 parameter.dimension[4] *= 0.5 * lunit;
175 }
176
177 // -------------------------------------------
178 void G4GDMLReadParamvol::Trap_dimensionsRead(
179 const xercesc::DOMElement* const element,
180 G4GDMLParameterisation::PARAMETER& parameter
181 {
182 G4double lunit = 1.0;
183 G4double aunit = 1.0;
184
185 const xercesc::DOMNamedNodeMap* const attrib
186 XMLSize_t attributeCount
187
188 for(XMLSize_t attribute_index = 0; attribute
189 ++attribute_index)
190 {
191 xercesc::DOMNode* attribute_node = attribu
192
193 if(attribute_node->getNodeType() != xerces
194 {
195 continue;
196 }
197
198 const xercesc::DOMAttr* const attribute =
199 dynamic_cast<xercesc::DOMAttr*>(attribut
200 if(attribute == nullptr)
201 {
202 G4Exception("G4GDMLReadParamvol::Trap_di
203 FatalException, "No attribut
204 return;
205 }
206 const G4String attName = Transcode(attrib
207 const G4String attValue = Transcode(attrib
208
209 if(attName == "lunit")
210 {
211 lunit = G4UnitDefinition::GetValueOf(att
212 if(G4UnitDefinition::GetCategory(attValu
213 {
214 G4Exception("G4GDMLReadParamvol::Trap_
215 FatalException, "Invalid u
216 }
217 }
218 else if(attName == "aunit")
219 {
220 aunit = G4UnitDefinition::GetValueOf(att
221 if(G4UnitDefinition::GetCategory(attValu
222 {
223 G4Exception("G4GDMLReadParamvol::Trap_
224 FatalException, "Invalid u
225 }
226 }
227 else if(attName == "z")
228 {
229 parameter.dimension[0] = eval.Evaluate(a
230 }
231 else if(attName == "theta")
232 {
233 parameter.dimension[1] = eval.Evaluate(a
234 }
235 else if(attName == "phi")
236 {
237 parameter.dimension[2] = eval.Evaluate(a
238 }
239 else if(attName == "y1")
240 {
241 parameter.dimension[3] = eval.Evaluate(a
242 }
243 else if(attName == "x1")
244 {
245 parameter.dimension[4] = eval.Evaluate(a
246 }
247 else if(attName == "x2")
248 {
249 parameter.dimension[5] = eval.Evaluate(a
250 }
251 else if(attName == "alpha1")
252 {
253 parameter.dimension[6] = eval.Evaluate(a
254 }
255 else if(attName == "y2")
256 {
257 parameter.dimension[7] = eval.Evaluate(a
258 }
259 else if(attName == "x3")
260 {
261 parameter.dimension[8] = eval.Evaluate(a
262 }
263 else if(attName == "x4")
264 {
265 parameter.dimension[9] = eval.Evaluate(a
266 }
267 else if(attName == "alpha2")
268 {
269 parameter.dimension[10] = eval.Evaluate(
270 }
271 }
272
273 parameter.dimension[0] *= 0.5 * lunit;
274 parameter.dimension[1] *= aunit;
275 parameter.dimension[2] *= aunit;
276 parameter.dimension[3] *= 0.5 * lunit;
277 parameter.dimension[4] *= 0.5 * lunit;
278 parameter.dimension[5] *= 0.5 * lunit;
279 parameter.dimension[6] *= aunit;
280 parameter.dimension[7] *= 0.5 * lunit;
281 parameter.dimension[8] *= 0.5 * lunit;
282 parameter.dimension[9] *= 0.5 * lunit;
283 parameter.dimension[10] *= aunit;
284 }
285
286 // -------------------------------------------
287 void G4GDMLReadParamvol::Tube_dimensionsRead(
288 const xercesc::DOMElement* const element,
289 G4GDMLParameterisation::PARAMETER& parameter
290 {
291 G4double lunit = 1.0;
292 G4double aunit = 1.0;
293
294 const xercesc::DOMNamedNodeMap* const attrib
295 XMLSize_t attributeCount
296
297 for(XMLSize_t attribute_index = 0; attribute
298 ++attribute_index)
299 {
300 xercesc::DOMNode* attribute_node = attribu
301
302 if(attribute_node->getNodeType() != xerces
303 {
304 continue;
305 }
306
307 const xercesc::DOMAttr* const attribute =
308 dynamic_cast<xercesc::DOMAttr*>(attribut
309 if(attribute == nullptr)
310 {
311 G4Exception("G4GDMLReadParamvol::Tube_di
312 FatalException, "No attribut
313 return;
314 }
315 const G4String attName = Transcode(attrib
316 const G4String attValue = Transcode(attrib
317
318 if(attName == "lunit")
319 {
320 lunit = G4UnitDefinition::GetValueOf(att
321 if(G4UnitDefinition::GetCategory(attValu
322 {
323 G4Exception("G4GDMLReadParamvol::Tube_
324 FatalException, "Invalid u
325 }
326 }
327 else if(attName == "aunit")
328 {
329 aunit = G4UnitDefinition::GetValueOf(att
330 if(G4UnitDefinition::GetCategory(attValu
331 {
332 G4Exception("G4GDMLReadParamvol::Tube_
333 FatalException, "Invalid u
334 }
335 }
336 else if(attName == "InR")
337 {
338 parameter.dimension[0] = eval.Evaluate(a
339 }
340 else if(attName == "OutR")
341 {
342 parameter.dimension[1] = eval.Evaluate(a
343 }
344 else if(attName == "hz")
345 {
346 parameter.dimension[2] = eval.Evaluate(a
347 }
348 else if(attName == "StartPhi")
349 {
350 parameter.dimension[3] = eval.Evaluate(a
351 }
352 else if(attName == "DeltaPhi")
353 {
354 parameter.dimension[4] = eval.Evaluate(a
355 }
356 }
357
358 parameter.dimension[0] *= lunit;
359 parameter.dimension[1] *= lunit;
360 parameter.dimension[2] *= 0.5 * lunit;
361 parameter.dimension[3] *= aunit;
362 parameter.dimension[4] *= aunit;
363 }
364
365 // -------------------------------------------
366 void G4GDMLReadParamvol::Cone_dimensionsRead(
367 const xercesc::DOMElement* const element,
368 G4GDMLParameterisation::PARAMETER& parameter
369 {
370 G4double lunit = 1.0;
371 G4double aunit = 1.0;
372
373 const xercesc::DOMNamedNodeMap* const attrib
374 XMLSize_t attributeCount
375
376 for(XMLSize_t attribute_index = 0; attribute
377 ++attribute_index)
378 {
379 xercesc::DOMNode* attribute_node = attribu
380
381 if(attribute_node->getNodeType() != xerces
382 {
383 continue;
384 }
385
386 const xercesc::DOMAttr* const attribute =
387 dynamic_cast<xercesc::DOMAttr*>(attribut
388 if(attribute == nullptr)
389 {
390 G4Exception("G4GDMLReadParamvol::Cone_di
391 FatalException, "No attribut
392 return;
393 }
394 const G4String attName = Transcode(attrib
395 const G4String attValue = Transcode(attrib
396
397 if(attName == "lunit")
398 {
399 lunit = G4UnitDefinition::GetValueOf(att
400 if(G4UnitDefinition::GetCategory(attValu
401 {
402 G4Exception("G4GDMLReadParamvol::Cone_
403 FatalException, "Invalid u
404 }
405 }
406 else if(attName == "aunit")
407 {
408 aunit = G4UnitDefinition::GetValueOf(att
409 if(G4UnitDefinition::GetCategory(attValu
410 {
411 G4Exception("G4GDMLReadParamvol::Cone_
412 FatalException, "Invalid u
413 }
414 }
415 else if(attName == "rmin1")
416 {
417 parameter.dimension[0] = eval.Evaluate(a
418 }
419 else if(attName == "rmax1")
420 {
421 parameter.dimension[1] = eval.Evaluate(a
422 }
423 else if(attName == "rmin2")
424 {
425 parameter.dimension[2] = eval.Evaluate(a
426 }
427 else if(attName == "rmax2")
428 {
429 parameter.dimension[3] = eval.Evaluate(a
430 }
431 else if(attName == "z")
432 {
433 parameter.dimension[4] = eval.Evaluate(a
434 }
435 else if(attName == "startphi")
436 {
437 parameter.dimension[5] = eval.Evaluate(a
438 }
439 else if(attName == "deltaphi")
440 {
441 parameter.dimension[6] = eval.Evaluate(a
442 }
443 }
444
445 parameter.dimension[0] *= lunit;
446 parameter.dimension[1] *= lunit;
447 parameter.dimension[2] *= lunit;
448 parameter.dimension[3] *= lunit;
449 parameter.dimension[4] *= 0.5 * lunit;
450 parameter.dimension[5] *= aunit;
451 parameter.dimension[6] *= aunit;
452 }
453
454 // -------------------------------------------
455 void G4GDMLReadParamvol::Sphere_dimensionsRead
456 const xercesc::DOMElement* const element,
457 G4GDMLParameterisation::PARAMETER& parameter
458 {
459 G4double lunit = 1.0;
460 G4double aunit = 1.0;
461
462 const xercesc::DOMNamedNodeMap* const attrib
463 XMLSize_t attributeCount
464
465 for(XMLSize_t attribute_index = 0; attribute
466 ++attribute_index)
467 {
468 xercesc::DOMNode* attribute_node = attribu
469
470 if(attribute_node->getNodeType() != xerces
471 {
472 continue;
473 }
474
475 const xercesc::DOMAttr* const attribute =
476 dynamic_cast<xercesc::DOMAttr*>(attribut
477 if(attribute == nullptr)
478 {
479 G4Exception("G4GDMLReadParamvol::Sphere_
480 FatalException, "No attribut
481 return;
482 }
483 const G4String attName = Transcode(attrib
484 const G4String attValue = Transcode(attrib
485
486 if(attName == "lunit")
487 {
488 lunit = G4UnitDefinition::GetValueOf(att
489 if(G4UnitDefinition::GetCategory(attValu
490 {
491 G4Exception("G4GDMLReadParamvol::Spher
492 "InvalidRead", FatalExcept
493 }
494 }
495 else if(attName == "aunit")
496 {
497 aunit = G4UnitDefinition::GetValueOf(att
498 if(G4UnitDefinition::GetCategory(attValu
499 {
500 G4Exception("G4GDMLReadParamvol::Spher
501 "InvalidRead", FatalExcept
502 }
503 }
504 else if(attName == "rmin")
505 {
506 parameter.dimension[0] = eval.Evaluate(a
507 }
508 else if(attName == "rmax")
509 {
510 parameter.dimension[1] = eval.Evaluate(a
511 }
512 else if(attName == "startphi")
513 {
514 parameter.dimension[2] = eval.Evaluate(a
515 }
516 else if(attName == "deltaphi")
517 {
518 parameter.dimension[3] = eval.Evaluate(a
519 }
520 else if(attName == "starttheta")
521 {
522 parameter.dimension[4] = eval.Evaluate(a
523 }
524 else if(attName == "deltatheta")
525 {
526 parameter.dimension[5] = eval.Evaluate(a
527 }
528 }
529
530 parameter.dimension[0] *= lunit;
531 parameter.dimension[1] *= lunit;
532 parameter.dimension[2] *= aunit;
533 parameter.dimension[3] *= aunit;
534 parameter.dimension[4] *= aunit;
535 parameter.dimension[5] *= aunit;
536 }
537
538 // -------------------------------------------
539 void G4GDMLReadParamvol::Orb_dimensionsRead(
540 const xercesc::DOMElement* const element,
541 G4GDMLParameterisation::PARAMETER& parameter
542 {
543 G4double lunit = 1.0;
544
545 const xercesc::DOMNamedNodeMap* const attrib
546 XMLSize_t attributeCount
547
548 for(XMLSize_t attribute_index = 0; attribute
549 ++attribute_index)
550 {
551 xercesc::DOMNode* attribute_node = attribu
552
553 if(attribute_node->getNodeType() != xerces
554 {
555 continue;
556 }
557
558 const xercesc::DOMAttr* const attribute =
559 dynamic_cast<xercesc::DOMAttr*>(attribut
560 if(attribute == nullptr)
561 {
562 G4Exception("G4GDMLReadParamvol::Orb_dim
563 FatalException, "No attribut
564 return;
565 }
566 const G4String attName = Transcode(attrib
567 const G4String attValue = Transcode(attrib
568
569 if(attName == "lunit")
570 {
571 lunit = G4UnitDefinition::GetValueOf(att
572 }
573 if(G4UnitDefinition::GetCategory(attValue)
574 {
575 G4Exception("G4GDMLReadParamvol::Orb_dim
576 FatalException, "Invalid uni
577 }
578 else if(attName == "r")
579 {
580 parameter.dimension[0] = eval.Evaluate(a
581 }
582 }
583
584 parameter.dimension[0] *= lunit;
585 }
586
587 // -------------------------------------------
588 void G4GDMLReadParamvol::Torus_dimensionsRead(
589 const xercesc::DOMElement* const element,
590 G4GDMLParameterisation::PARAMETER& parameter
591 {
592 G4double lunit = 1.0;
593 G4double aunit = 1.0;
594
595 const xercesc::DOMNamedNodeMap* const attrib
596 XMLSize_t attributeCount
597
598 for(XMLSize_t attribute_index = 0; attribute
599 ++attribute_index)
600 {
601 xercesc::DOMNode* attribute_node = attribu
602
603 if(attribute_node->getNodeType() != xerces
604 {
605 continue;
606 }
607
608 const xercesc::DOMAttr* const attribute =
609 dynamic_cast<xercesc::DOMAttr*>(attribut
610 if(attribute == nullptr)
611 {
612 G4Exception("G4GDMLReadParamvol::Torus_d
613 FatalException, "No attribut
614 return;
615 }
616 const G4String attName = Transcode(attrib
617 const G4String attValue = Transcode(attrib
618
619 if(attName == "lunit")
620 {
621 lunit = G4UnitDefinition::GetValueOf(att
622 if(G4UnitDefinition::GetCategory(attValu
623 {
624 G4Exception("G4GDMLReadParamvol::Torus
625 FatalException, "Invalid u
626 }
627 }
628 else if(attName == "aunit")
629 {
630 aunit = G4UnitDefinition::GetValueOf(att
631 if(G4UnitDefinition::GetCategory(attValu
632 {
633 G4Exception("G4GDMLReadParamvol::Torus
634 FatalException, "Invalid u
635 }
636 }
637 else if(attName == "rmin")
638 {
639 parameter.dimension[0] = eval.Evaluate(a
640 }
641 else if(attName == "rmax")
642 {
643 parameter.dimension[1] = eval.Evaluate(a
644 }
645 else if(attName == "rtor")
646 {
647 parameter.dimension[2] = eval.Evaluate(a
648 }
649 else if(attName == "startphi")
650 {
651 parameter.dimension[3] = eval.Evaluate(a
652 }
653 else if(attName == "deltaphi")
654 {
655 parameter.dimension[4] = eval.Evaluate(a
656 }
657 }
658
659 parameter.dimension[0] *= lunit;
660 parameter.dimension[1] *= lunit;
661 parameter.dimension[2] *= lunit;
662 parameter.dimension[3] *= aunit;
663 parameter.dimension[4] *= aunit;
664 }
665
666 // -------------------------------------------
667 void G4GDMLReadParamvol::Ellipsoid_dimensionsR
668 const xercesc::DOMElement* const element,
669 G4GDMLParameterisation::PARAMETER& parameter
670 {
671 G4double lunit
672 const xercesc::DOMNamedNodeMap* const attrib
673 XMLSize_t attributeCount
674
675 for(XMLSize_t attribute_index = 0; attribute
676 ++attribute_index)
677 {
678 xercesc::DOMNode* attribute_node = attribu
679
680 if(attribute_node->getNodeType() != xerces
681 {
682 continue;
683 }
684
685 const xercesc::DOMAttr* const attribute =
686 dynamic_cast<xercesc::DOMAttr*>(attribut
687 if(attribute == nullptr)
688 {
689 G4Exception("G4GDMLReadParamvol::Ellipso
690 "InvalidRead", FatalExceptio
691 return;
692 }
693 const G4String attName = Transcode(attrib
694 const G4String attValue = Transcode(attrib
695
696 if(attName == "lunit")
697 {
698 lunit = G4UnitDefinition::GetValueOf(att
699 if(G4UnitDefinition::GetCategory(attValu
700 {
701 G4Exception("G4GDMLReadParamvol::Ellip
702 "InvalidRead", FatalExcept
703 }
704 }
705 else if(attName == "ax")
706 {
707 parameter.dimension[0] = eval.Evaluate(a
708 }
709 else if(attName == "by")
710 {
711 parameter.dimension[1] = eval.Evaluate(a
712 }
713 else if(attName == "cz")
714 {
715 parameter.dimension[2] = eval.Evaluate(a
716 }
717 else if(attName == "zcut1")
718 {
719 parameter.dimension[3] = eval.Evaluate(a
720 }
721 else if(attName == "zcut2")
722 {
723 parameter.dimension[4] = eval.Evaluate(a
724 }
725 }
726
727 parameter.dimension[0] *= lunit;
728 parameter.dimension[1] *= lunit;
729 parameter.dimension[2] *= lunit;
730 parameter.dimension[3] *= lunit;
731 parameter.dimension[4] *= lunit;
732 }
733
734 // -------------------------------------------
735 void G4GDMLReadParamvol::Para_dimensionsRead(
736 const xercesc::DOMElement* const element,
737 G4GDMLParameterisation::PARAMETER& parameter
738 {
739 G4double lunit = 1.0;
740 G4double aunit = 1.0;
741
742 const xercesc::DOMNamedNodeMap* const attrib
743 XMLSize_t attributeCount
744
745 for(XMLSize_t attribute_index = 0; attribute
746 ++attribute_index)
747 {
748 xercesc::DOMNode* attribute_node = attribu
749
750 if(attribute_node->getNodeType() != xerces
751 {
752 continue;
753 }
754
755 const xercesc::DOMAttr* const attribute =
756 dynamic_cast<xercesc::DOMAttr*>(attribut
757 if(attribute == nullptr)
758 {
759 G4Exception("G4GDMLReadParamvol::Para_di
760 FatalException, "No attribut
761 return;
762 }
763 const G4String attName = Transcode(attrib
764 const G4String attValue = Transcode(attrib
765
766 if(attName == "lunit")
767 {
768 lunit = G4UnitDefinition::GetValueOf(att
769 if(G4UnitDefinition::GetCategory(attValu
770 {
771 G4Exception("G4GDMLReadParamvol::Para_
772 FatalException, "Invalid u
773 }
774 }
775 else if(attName == "aunit")
776 {
777 aunit = G4UnitDefinition::GetValueOf(att
778 if(G4UnitDefinition::GetCategory(attValu
779 {
780 G4Exception("G4GDMLReadParamvol::Para_
781 FatalException, "Invalid u
782 }
783 }
784 else if(attName == "x")
785 {
786 parameter.dimension[0] = eval.Evaluate(a
787 }
788 else if(attName == "y")
789 {
790 parameter.dimension[1] = eval.Evaluate(a
791 }
792 else if(attName == "z")
793 {
794 parameter.dimension[2] = eval.Evaluate(a
795 }
796 else if(attName == "alpha")
797 {
798 parameter.dimension[3] = eval.Evaluate(a
799 }
800 else if(attName == "theta")
801 {
802 parameter.dimension[4] = eval.Evaluate(a
803 }
804 else if(attName == "phi")
805 {
806 parameter.dimension[5] = eval.Evaluate(a
807 }
808 }
809
810 parameter.dimension[0] = 0.5 * lunit;
811 parameter.dimension[1] = 0.5 * lunit;
812 parameter.dimension[2] = 0.5 * lunit;
813 parameter.dimension[3] = aunit;
814 parameter.dimension[4] = aunit;
815 parameter.dimension[5] = aunit;
816 }
817
818 // -------------------------------------------
819 void G4GDMLReadParamvol::Hype_dimensionsRead(
820 const xercesc::DOMElement* const element,
821 G4GDMLParameterisation::PARAMETER& parameter
822 {
823 G4double lunit = 1.0;
824 G4double aunit = 1.0;
825
826 const xercesc::DOMNamedNodeMap* const attrib
827 XMLSize_t attributeCount
828
829 for(XMLSize_t attribute_index = 0; attribute
830 ++attribute_index)
831 {
832 xercesc::DOMNode* attribute_node = attribu
833
834 if(attribute_node->getNodeType() != xerces
835 {
836 continue;
837 }
838
839 const xercesc::DOMAttr* const attribute =
840 dynamic_cast<xercesc::DOMAttr*>(attribut
841 if(attribute == nullptr)
842 {
843 G4Exception("G4GDMLReadParamvol::Hype_di
844 FatalException, "No attribut
845 return;
846 }
847 const G4String attName = Transcode(attrib
848 const G4String attValue = Transcode(attrib
849
850 if(attName == "lunit")
851 {
852 lunit = G4UnitDefinition::GetValueOf(att
853 if(G4UnitDefinition::GetCategory(attValu
854 {
855 G4Exception("G4GDMLReadParamvol::Hype_
856 FatalException, "Invalid u
857 }
858 }
859 else if(attName == "aunit")
860 {
861 aunit = G4UnitDefinition::GetValueOf(att
862 if(G4UnitDefinition::GetCategory(attValu
863 {
864 G4Exception("G4GDMLReadParamvol::Hype_
865 FatalException, "Invalid u
866 }
867 }
868 else if(attName == "rmin")
869 {
870 parameter.dimension[0] = eval.Evaluate(a
871 }
872 else if(attName == "rmax")
873 {
874 parameter.dimension[1] = eval.Evaluate(a
875 }
876 else if(attName == "inst")
877 {
878 parameter.dimension[2] = eval.Evaluate(a
879 }
880 else if(attName == "outst")
881 {
882 parameter.dimension[3] = eval.Evaluate(a
883 }
884 else if(attName == "z")
885 {
886 parameter.dimension[4] = eval.Evaluate(a
887 }
888 }
889
890 parameter.dimension[0] = lunit;
891 parameter.dimension[1] = lunit;
892 parameter.dimension[2] = aunit;
893 parameter.dimension[3] = aunit;
894 parameter.dimension[4] = 0.5 * lunit;
895 }
896
897 // -------------------------------------------
898 void G4GDMLReadParamvol::Polycone_dimensionsRe
899 const xercesc::DOMElement* const element,
900 G4GDMLParameterisation::PARAMETER& parameter
901 {
902 G4double lunit = 1.0;
903 G4double aunit = 1.0;
904
905 std::vector<zplaneType> zplaneList;
906
907 const xercesc::DOMNamedNodeMap* const attrib
908 XMLSize_t attributeCount
909
910 for(XMLSize_t attribute_index = 0; attribute
911 ++attribute_index)
912 {
913 xercesc::DOMNode* attribute_node = attribu
914
915 if(attribute_node->getNodeType() != xerces
916 {
917 continue;
918 }
919
920 const xercesc::DOMAttr* const attribute =
921 dynamic_cast<xercesc::DOMAttr*>(attribut
922 if(attribute == nullptr)
923 {
924 G4Exception("G4GDMLReadParamvol::Polycon
925 "InvalidRead", FatalExceptio
926 return;
927 }
928 const G4String attName = Transcode(attrib
929 const G4String attValue = Transcode(attrib
930
931 if(attName == "lunit")
932 {
933 lunit = G4UnitDefinition::GetValueOf(att
934 if(G4UnitDefinition::GetCategory(attValu
935 {
936 G4Exception("G4GDMLReadParamvol::Polyc
937 "InvalidRead", FatalExcept
938 }
939 }
940 else if(attName == "aunit")
941 {
942 aunit = G4UnitDefinition::GetValueOf(att
943 if(G4UnitDefinition::GetCategory(attValu
944 {
945 G4Exception("G4GDMLReadParamvol::Polyc
946 "InvalidRead", FatalExcept
947 }
948 }
949 else if(attName == "startPhi")
950 {
951 parameter.dimension[0] = eval.Evaluate(a
952 }
953 else if(attName == "openPhi")
954 {
955 parameter.dimension[1] = eval.Evaluate(a
956 }
957 else if(attName == "numRZ")
958 {
959 parameter.dimension[2] = eval.Evaluate(a
960 }
961 }
962
963 parameter.dimension[0] *= aunit;
964 parameter.dimension[1] *= aunit;
965
966 for(xercesc::DOMNode* iter = element->getFir
967 iter = iter->getNextSi
968 {
969 if(iter->getNodeType() != xercesc::DOMNode
970 {
971 continue;
972 }
973
974 const xercesc::DOMElement* const child =
975 dynamic_cast<xercesc::DOMElement*>(iter)
976 if(child == nullptr)
977 {
978 G4Exception("G4GDMLReadParamVol::Polycon
979 "InvalidRead", FatalExceptio
980 return;
981 }
982 const G4String tag = Transcode(child->getT
983
984 if(tag == "zplane")
985 {
986 zplaneList.push_back(ZplaneRead(child));
987 }
988 }
989
990 std::size_t numZPlanes = zplaneList.size();
991 for(std::size_t i = 0; i < numZPlanes; ++i)
992 {
993 parameter.dimension[3 + i * 3] = zplaneLis
994 parameter.dimension[4 + i * 3] = zplaneLis
995 parameter.dimension[5 + i * 3] = zplaneLis
996 }
997 }
998
999 // -------------------------------------------
1000 void G4GDMLReadParamvol::Polyhedra_dimensions
1001 const xercesc::DOMElement* const element,
1002 G4GDMLParameterisation::PARAMETER& paramete
1003 {
1004 G4double lunit = 1.0;
1005 G4double aunit = 1.0;
1006
1007 std::vector<zplaneType> zplaneList;
1008
1009 const xercesc::DOMNamedNodeMap* const attri
1010 XMLSize_t attributeCount
1011
1012 for(XMLSize_t attribute_index = 0; attribut
1013 ++attribute_index)
1014 {
1015 xercesc::DOMNode* attribute_node = attrib
1016
1017 if(attribute_node->getNodeType() != xerce
1018 {
1019 continue;
1020 }
1021
1022 const xercesc::DOMAttr* const attribute =
1023 dynamic_cast<xercesc::DOMAttr*>(attribu
1024 if(attribute == nullptr)
1025 {
1026 G4Exception("G4GDMLReadParamvol::Polyco
1027 "InvalidRead", FatalExcepti
1028 return;
1029 }
1030 const G4String attName = Transcode(attri
1031 const G4String attValue = Transcode(attri
1032
1033 if(attName == "lunit")
1034 {
1035 lunit = G4UnitDefinition::GetValueOf(at
1036 if(G4UnitDefinition::GetCategory(attVal
1037 {
1038 G4Exception("G4GDMLReadParamvol::Poly
1039 "InvalidRead", FatalExcep
1040 }
1041 }
1042 else if(attName == "aunit")
1043 {
1044 aunit = G4UnitDefinition::GetValueOf(at
1045 if(G4UnitDefinition::GetCategory(attVal
1046 {
1047 G4Exception("G4GDMLReadParamvol::Poly
1048 "InvalidRead", FatalExcep
1049 }
1050 }
1051 else if(attName == "startPhi")
1052 {
1053 parameter.dimension[0] = eval.Evaluate(
1054 }
1055 else if(attName == "openPhi")
1056 {
1057 parameter.dimension[1] = eval.Evaluate(
1058 }
1059 else if(attName == "numRZ")
1060 {
1061 parameter.dimension[2] = eval.Evaluate(
1062 }
1063 else if(attName == "numSide")
1064 {
1065 parameter.dimension[3] = eval.Evaluate(
1066 }
1067 }
1068
1069 parameter.dimension[0] *= aunit;
1070 parameter.dimension[1] *= aunit;
1071
1072 for(auto iter = element->getFirstChild(); i
1073 iter = iter->getNextSibling())
1074 {
1075 if(iter->getNodeType() != xercesc::DOMNod
1076 {
1077 continue;
1078 }
1079
1080 const xercesc::DOMElement* const child =
1081 dynamic_cast<xercesc::DOMElement*>(iter
1082 if(child == nullptr)
1083 {
1084 G4Exception("G4GDMLReadParamvo::Polyhed
1085 FatalException, "No child f
1086 return;
1087 }
1088 const G4String tag = Transcode(child->get
1089
1090 if(tag == "zplane")
1091 {
1092 zplaneList.push_back(ZplaneRead(child))
1093 }
1094 }
1095
1096 std::size_t numZPlanes = zplaneList.size();
1097 for(std::size_t i = 0; i < numZPlanes; ++i)
1098 {
1099 parameter.dimension[4 + i * 3] = zplaneLi
1100 parameter.dimension[5 + i * 3] = zplaneLi
1101 parameter.dimension[6 + i * 3] = zplaneLi
1102 }
1103 }
1104
1105 // ------------------------------------------
1106 void G4GDMLReadParamvol::ParametersRead(
1107 const xercesc::DOMElement* const element)
1108 {
1109 G4ThreeVector rotation(0.0, 0.0, 0.0);
1110 G4ThreeVector position(0.0, 0.0, 0.0);
1111
1112 G4GDMLParameterisation::PARAMETER parameter
1113
1114 for(xercesc::DOMNode* iter = element->getFi
1115 iter = iter->getNextS
1116 {
1117 if(iter->getNodeType() != xercesc::DOMNod
1118 {
1119 continue;
1120 }
1121
1122 const xercesc::DOMElement* const child =
1123 dynamic_cast<xercesc::DOMElement*>(iter
1124 if(child == nullptr)
1125 {
1126 G4Exception("G4GDMLReadParamvol::Parame
1127 FatalException, "No child f
1128 return;
1129 }
1130 const G4String tag = Transcode(child->get
1131 if(tag == "rotation")
1132 {
1133 VectorRead(child, rotation);
1134 }
1135 else if(tag == "position")
1136 {
1137 VectorRead(child, position);
1138 }
1139 else if(tag == "positionref")
1140 {
1141 position = GetPosition(GenerateName(Ref
1142 }
1143 else if(tag == "rotationref")
1144 {
1145 rotation = GetRotation(GenerateName(Ref
1146 }
1147 else if(tag == "box_dimensions")
1148 {
1149 Box_dimensionsRead(child, parameter);
1150 }
1151 else if(tag == "trd_dimensions")
1152 {
1153 Trd_dimensionsRead(child, parameter);
1154 }
1155 else if(tag == "trap_dimensions")
1156 {
1157 Trap_dimensionsRead(child, parameter);
1158 }
1159 else if(tag == "tube_dimensions")
1160 {
1161 Tube_dimensionsRead(child, parameter);
1162 }
1163 else if(tag == "cone_dimensions")
1164 {
1165 Cone_dimensionsRead(child, parameter);
1166 }
1167 else if(tag == "sphere_dimensions")
1168 {
1169 Sphere_dimensionsRead(child, parameter)
1170 }
1171 else if(tag == "orb_dimensions")
1172 {
1173 Orb_dimensionsRead(child, parameter);
1174 }
1175 else if(tag == "torus_dimensions")
1176 {
1177 Torus_dimensionsRead(child, parameter);
1178 }
1179 else if(tag == "ellipsoid_dimensions")
1180 {
1181 Ellipsoid_dimensionsRead(child, paramet
1182 }
1183 else if(tag == "para_dimensions")
1184 {
1185 Para_dimensionsRead(child, parameter);
1186 }
1187 else if(tag == "polycone_dimensions")
1188 {
1189 Polycone_dimensionsRead(child, paramete
1190 }
1191 else if(tag == "polyhedra_dimensions")
1192 {
1193 Polyhedra_dimensionsRead(child, paramet
1194 }
1195 else if(tag == "hype_dimensions")
1196 {
1197 Hype_dimensionsRead(child, parameter);
1198 }
1199 else
1200 {
1201 G4String error_msg = "Unknown tag in pa
1202 G4Exception("G4GDMLReadParamvol::Parame
1203 FatalException, error_msg);
1204 }
1205 }
1206
1207 parameter.pRot = new G4RotationMatrix();
1208
1209 parameter.pRot->rotateX(rotation.x());
1210 parameter.pRot->rotateY(rotation.y());
1211 parameter.pRot->rotateZ(rotation.z());
1212
1213 parameter.position = position;
1214
1215 parameterisation->AddParameter(parameter);
1216 }
1217
1218 // ------------------------------------------
1219 void G4GDMLReadParamvol::ParameterisedRead(
1220 const xercesc::DOMElement* const element)
1221 {
1222 for(xercesc::DOMNode* iter = element->getFi
1223 iter = iter->getNextS
1224 {
1225 if(iter->getNodeType() != xercesc::DOMNod
1226 {
1227 continue;
1228 }
1229
1230 const xercesc::DOMElement* const child =
1231 dynamic_cast<xercesc::DOMElement*>(iter
1232 if(child == nullptr)
1233 {
1234 G4Exception("G4GDMLReadParamvol::Parame
1235 FatalException, "No child f
1236 return;
1237 }
1238 const G4String tag = Transcode(child->get
1239
1240 if(tag == "parameters")
1241 {
1242 const xercesc::DOMNamedNodeMap* const a
1243 element->getAttributes();
1244 XMLSize_t attributeCount = attributes->
1245 for(XMLSize_t attribute_index = 0; attr
1246 ++attribute_index)
1247 {
1248 xercesc::DOMNode* attribute_node = at
1249
1250 if(attribute_node->getNodeType() != x
1251 {
1252 continue;
1253 }
1254
1255 const xercesc::DOMAttr* const attribu
1256 dynamic_cast<xercesc::DOMAttr*>(att
1257 if(attribute == nullptr)
1258 {
1259 G4Exception("G4GDMLReadParamvol::Pa
1260 FatalException, "No att
1261 return;
1262 }
1263 const G4String attName = Transcode(a
1264 const G4String attValue = Transcode(a
1265
1266 if(attName == "number")
1267 {
1268 eval.Evaluate(attValue);
1269 }
1270 }
1271 ParametersRead(child);
1272 }
1273 else
1274 {
1275 if(tag == "loop")
1276 {
1277 LoopRead(child, &G4GDMLRead::Paramvol
1278 }
1279 }
1280 }
1281 }
1282
1283 // ------------------------------------------
1284 void G4GDMLReadParamvol::Paramvol_contentRead
1285 const xercesc::DOMElement* const element)
1286 {
1287 for(xercesc::DOMNode* iter = element->getFi
1288 iter = iter->getNextS
1289 {
1290 if(iter->getNodeType() != xercesc::DOMNod
1291 {
1292 continue;
1293 }
1294
1295 const xercesc::DOMElement* const child =
1296 dynamic_cast<xercesc::DOMElement*>(iter
1297 if(child == nullptr)
1298 {
1299 G4Exception("G4GDMLReadParamvol::Paramv
1300 FatalException, "No child f
1301 return;
1302 }
1303 const G4String tag = Transcode(child->get
1304 if(tag == "parameterised_position_size")
1305 {
1306 ParameterisedRead(child);
1307 }
1308 else if(tag == "loop")
1309 {
1310 LoopRead(child, &G4GDMLRead::Paramvol_c
1311 }
1312 }
1313 }
1314
1315 // ------------------------------------------
1316 void G4GDMLReadParamvol::ParamvolRead(const x
1317 G4Logic
1318 {
1319 G4String volumeref;
1320
1321 parameterisation = new G4GDMLParameterisati
1322 for(xercesc::DOMNode* iter = element->getFi
1323 iter = iter->getNextS
1324 {
1325 if(iter->getNodeType() != xercesc::DOMNod
1326 {
1327 continue;
1328 }
1329
1330 const xercesc::DOMElement* const child =
1331 dynamic_cast<xercesc::DOMElement*>(iter
1332 if(child == nullptr)
1333 {
1334 G4Exception("G4GDMLReadParamvol::Paramv
1335 FatalException, "No child f
1336 return;
1337 }
1338 const G4String tag = Transcode(child->get
1339
1340 if(tag == "volumeref")
1341 {
1342 volumeref = RefRead(child);
1343 }
1344 }
1345
1346 Paramvol_contentRead(element);
1347
1348 G4LogicalVolume* logvol = GetVolume(Generat
1349
1350 if(parameterisation->GetSize() == 0)
1351 {
1352 G4Exception("G4GDMLReadParamvol::Paramvol
1353 FatalException,
1354 "No parameters are defined in
1355 }
1356 G4String pv_name = logvol->GetName() + "_pa
1357 new G4PVParameterised(pv_name, logvol, moth
1358 parameterisation->Get
1359 }
1360